src/core/deck.rs

@@ -8,7 +8,7 @@ use crate::core::srs::{
     WordOpenMode, WorstWordsSRSModule,
 };
 use crate::data::entities::*;
-use crate::data_provider::card_states::{update_stat_score, CardStateRepository, CardStateRepositoryInner};
+use crate::data_provider::card_states::{CardStateRepositoryInner};
 use crate::notification::{MaybeError, NotificationData};
 use log::info;
 use rhai::{Engine, Scope};

src/data.rs

@@ -3,7 +3,7 @@ pub mod repositories;
 
 use rusqlite::ToSql;
 use rusqlite::types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef};
-use std::fmt::{Display, Formatter, write};
+use std::fmt::{Display, Formatter};
 use std::num::ParseIntError;
 use std::str::FromStr;
 

src/data/entities.rs

@@ -1,6 +1,4 @@
-use crate::app::AppState;
+use crate::core::srs::{FADE_PER_DAY, MAX_SCORE, WordOpenMode};
-use crate::core::srs::{FADE_PER_DAY, MAX_SCORE, OrderMode, WordOpenMode};
-use crate::data::repositories::Repository;
 use crate::data::{INVALID_ID, Id};
 use chrono::{DateTime, NaiveDate, Utc};
 use fsrs::MemoryState;

src/data/repositories.rs

@@ -1,5 +1,6 @@
 use crate::data::Id;
-use crate::data::entities::{EntityData, EntityHandle, WordData};
+use crate::data::entities::{EntityData, EntityHandle};
+use crate::data_provider::sqlite::SqliteConnection;
 use crate::helpers::into_result;
 use crate::notification::{MaybeError, NotificationData};
 use parking_lot::{Mutex, RwLock};
@@ -9,10 +10,7 @@ use rayon::iter::ParallelIterator;
 use rusqlite::Connection;
 use std::marker::PhantomData;
 use std::ops::{Deref, Index, IndexMut};
-use std::rc::Rc;
-use std::slice::Iter;
 use std::sync::Arc;
-use crate::data_provider::sqlite::SqliteConnection;
 
 pub trait Repository<T, D>
 where

src/data_provider/mod.rs

@@ -1,5 +1,5 @@
 use crate::data::Id;
-use crate::data::entities::{CardState, EntityData};
+use crate::data::entities::{EntityData};
 use crate::data::repositories::{BatchedDbLayer, DbLayer};
 use crate::notification::MaybeError;
 use crate::notification::NotificationData::{DbLoadError, DbSaveError};

src/data_provider/word_groups.rs

@@ -1,8 +1,7 @@
-use crate::data::entities::{DeckSettings, WordGroup};
+use crate::data::entities::WordGroup;
+use crate::data::repositories::{DataRepository, DataRepositoryInner};
 use crate::data_provider::{SqliteDbLayer, TableAccessQuerySet};
 use rusqlite::{Error, Params, Row};
-use crate::data::repositories::{DataRepository, DataRepositoryInner};
-use crate::data_provider::decks::DeckQuerySet;
 
 pub type WordGroupRepository = DataRepository<WordGroup, WordGroupDataLayer>;
 pub type WordGroupRepositoryInner = DataRepositoryInner<WordGroup, WordGroupDataLayer>;

src/data_provider/words.rs

@@ -1,14 +1,12 @@
 use crate::data::entities::{WordData, WordGroup};
+use crate::data::repositories::{DataRepository, DataRepositoryInner};
 use crate::data_provider::{SqliteDbLayer, TableAccessQuerySet};
 use crate::notification::NotificationData::{DbLoadError, DbSaveError};
 use crate::notification::{MaybeError, NotificationData};
-use litemap::LiteMap;
 use rusqlite::{Connection, Error, Params, Row, params};
-use std::collections::HashMap;
-use crate::data::repositories::{BatchedDbLayer, DataRepository, DataRepositoryInner};
 
-pub type WordRepository = DataRepository<WordData, SqliteDbLayer<WordData, WordQuerySet>>;
+pub type WordRepository = DataRepository<WordData, WordDataLayer>;
-pub type WordRepositoryInner = DataRepositoryInner<WordData, SqliteDbLayer<WordData, WordQuerySet>>;
+pub type WordRepositoryInner = DataRepositoryInner<WordData, WordDataLayer>;
 pub type WordDataLayer = SqliteDbLayer<WordData, WordQuerySet>;
 #[derive(Clone)]
 pub struct WordQuerySet;

src/pages/dictionary.rs

@@ -2,7 +2,8 @@ use crate::app::AppState;
 use crate::data::Id;
 use crate::data::entities::{EntityHandle, WordData, WordGroup};
 use crate::data::repositories::{Query, Repository};
-use crate::data_provider::words::{WordRepository, WordDataLayer, WordQuerySet, WordRepositoryInner};
+use crate::data_provider::words::WordDataLayer;
+use crate::data_provider::words::WordRepositoryInner;
 use crate::navigation::Page::{Import, Word};
 use crate::navigation::{NavigatedPage, Page, RootMessage};
 use crate::pages::dictionary::DictionaryMessage::*;

src/pages/import.rs

@@ -1,7 +1,8 @@
 use crate::app::AppState;
-use crate::data::entities::{EntityData, WordData, WordGroup};
+use crate::data::entities::EntityData;
+use crate::data::entities::WordData;
+use crate::data::entities::WordGroup;
 use crate::data_provider::import::{ImportData, ImportGroup, get_words_of_group, load_groups};
-use crate::data_provider::words::{add_group, add_words};
 use crate::fs::*;
 use crate::navigation::{NavigatedPage, Page, RootMessage};
 use crate::notification::NotificationData::OpenFileError;

src/pages/repetition.rs

@@ -9,17 +9,16 @@ use crate::navigation::{KeyPressedPage, NavigatedPage, Page, RootMessage};
 use crate::notification::{MaybeError, NotificationData};
 use crate::styling::*;
 use crate::{push_error, push_error_task};
-use chrono::Local;
 use iced::alignment::Horizontal::Center;
 use iced::keyboard::key::Physical::Code;
 use iced::widget::text::Style;
 use iced::widget::{Column, button, column, container, row, rule, space, text, tooltip};
 use iced::{Element, Fill, Task, Theme, alignment, keyboard};
-use parking_lot::Mutex;
 use rodio::MixerDeviceSink;
 use std::collections::HashSet;
 use std::sync::Arc;
 use tokio::task::spawn_blocking;
+use crate::data::repositories::Repository;
 
 pub struct RepetitionState {
     state: AppState,
@@ -108,7 +107,8 @@ impl RepetitionState {
     ) -> Result<RepetitionState, NotificationData> {
         let mut card_set = DeckData::new(&set, state.clone())?;
         let (word, stat) = card_set.next();
-
+        let word = state.dictionary.read().get_static(word).unwrap();
+        let stat = state.card_states.read().get_static(stat).unwrap();
         let sink_handle = if set.forward.contains("speech") || set.backward.contains("speech") {
             rodio::DeviceSinkBuilder::open_default_sink().ok()
         } else {
@@ -150,9 +150,11 @@ impl RepetitionState {
 
         self.open = false;
         self.opened.insert(self.current_word.id);
-        let next = self.set.next();
+        let (word, state) = self.set.next();
-        self.current_word = next.0;
+        let word = self.state.dictionary.read().get_static(word).unwrap();
-        self.current_statistic = next.1;
+        let stat = self.state.card_states.read().get_static(state).unwrap();
+        self.current_word = word;
+        self.current_statistic = stat;
 
         if self.settings.require_speech() && self.sink.is_some() {
             let sink = self.sink.clone();