From 08ab55f283bb76390989c731f5423d8ab399dea0 Mon Sep 17 00:00:00 2001 From: Mikhail Mitrofanov Date: Fri, 4 Sep 2026 13:00:41 +0300 Subject: [PATCH] Fix deck data --- src/app.rs | 8 +-- src/core/deck.rs | 117 +++++++++++++++++++++++++------ src/core/srs.rs | 24 +++---- src/data_provider/card_states.rs | 3 +- src/navigation.rs | 5 +- src/pages/repetition.rs | 20 ------ src/pages/repetition_settings.rs | 64 ++++++++--------- 7 files changed, 145 insertions(+), 96 deletions(-) diff --git a/src/app.rs b/src/app.rs index 8d61352..0ebd160 100644 --- a/src/app.rs +++ b/src/app.rs @@ -11,7 +11,7 @@ use iced_core::window::Position; use iced_core::window::settings::PlatformSpecific; use iced_core::{Font, Size, Theme}; use log::info; -use parking_lot::RwLock; +use parking_lot::{Mutex, RwLock}; use rusqlite::Connection; use crate::data::repositories::Repository; use crate::data_provider::card_states::CardStateRepository; @@ -65,7 +65,7 @@ pub struct AppState { pub decks: DeckRepository, pub word_groups: WordGroupRepository, pub card_states: CardStateRepository, - pub connection: Arc>, + pub connection: Arc>, pub sync_data: Arc>, pub history: HistoryRepository, } @@ -78,7 +78,7 @@ impl Default for AppState { impl AppState { pub fn new() -> Self { - let connection = Arc::new(RwLock::new(SqliteConnection::default())); + let connection = Arc::new(Mutex::new(SqliteConnection::default())); Self { dictionary: WordRepository::new(connection.clone()), decks: DeckRepository::new(connection.clone()), @@ -95,7 +95,7 @@ impl AppState { } pub fn fill_state(state: &mut AppState) { - let connection = state.connection.read(); + let connection = state.connection.lock(); let setting = load_settings(&connection); diff --git a/src/core/deck.rs b/src/core/deck.rs index e87a3c1..8de5c3a 100644 --- a/src/core/deck.rs +++ b/src/core/deck.rs @@ -1,3 +1,6 @@ +use std::sync::Arc; +use std::time::Instant; +use chrono::Utc; use crate::app::AppState; use crate::core::srs::OrderModule::{Fsrs, RandomSRS, SemiRandomSRS, WorstWordsSRS}; use crate::core::srs::{ @@ -5,14 +8,16 @@ use crate::core::srs::{ WordOpenMode, WorstWordsSRSModule, }; use crate::data::entities::*; -use crate::data_provider::card_states::update_stat_score; +use crate::data_provider::card_states::{update_stat_score, CardStateRepository, CardStateRepositoryInner}; use crate::notification::{MaybeError, NotificationData}; -use chrono::Utc; +use log::info; +use rhai::{Engine, Scope}; +use crate::data::repositories::Repository; #[derive(Clone)] pub struct DeckData { - pub(crate) words: Vec, - pub(crate) set: Vec, + pub(crate) words: Vec>, + pub(crate) set: Vec>, current_word_index: Option, state: AppState, order_module: OrderModule, @@ -51,57 +56,68 @@ impl DeckData { // }) } - pub fn next(&mut self) -> (WordData, CardState) { + pub fn next(&mut self) -> (EntityHandle, EntityHandle) { + let repo = self.state.card_states.read(); + let links = Self::set_links(self.set.as_slice(), &repo); let index = match self.order_module { SemiRandomSRS(ref mut module) => { if !module.initialized { - module.init(self.set.as_slice()) + module.init(links.as_slice()); } - module.next(self.set.as_slice()) + module.next(links.as_slice()) } RandomSRS(ref mut module) => { if !module.initialized { - module.init(self.set.as_slice()) + module.init(links.as_slice()) } - module.next(self.set.as_slice()) + module.next(links.as_slice()) } WorstWordsSRS(ref mut module) => { if !module.initialized { - module.init(self.set.as_slice()) + module.init(links.as_slice()) } - module.next(self.set.as_slice()) + module.next(links.as_slice()) } Fsrs(ref mut module) => { if !module.initialized { - module.init(self.set.as_slice()) + module.init(links.as_slice()) } - module.next(self.set.as_slice()) + module.next(links.as_slice()) } }; self.current_word_index = Some(index); (self.words[index].clone(), self.set[index].clone()) } + + fn set_links<'a>(set: &[EntityHandle], repo: &'a CardStateRepositoryInner) -> Vec<&'a CardState> { + set.iter().map(|h| repo.get_ref_static(*h).unwrap()).collect::>() + } + pub fn open(&mut self, status: WordOpenMode) -> MaybeError { if let Some(index) = self.current_word_index { - let word: &mut CardState = &mut self.set[index]; - let old_score = word.score; - word.update(status); - let new_score = word.score; + let mut repo = self.state.card_states.write(); + let card_state_handle = &mut self.set[index]; + let card_state = repo.get_mut(card_state_handle).unwrap(); + let old_score = card_state.score; + card_state.update(status); + let new_score = card_state.score; + let mut fsrs = false; match self.order_module { SemiRandomSRS(ref mut module) => { - module.open(status, index, word); + module.open(status, index, card_state); } RandomSRS(ref mut module) => { - module.open(status, index, word); + module.open(status, index, card_state); } WorstWordsSRS(ref mut module) => { - module.open(status, index, word); + module.open(status, index, card_state); } Fsrs(ref mut module) => { - module.open(status, index, word); + module.open(status, index, card_state); + fsrs = true; } } @@ -114,7 +130,21 @@ impl DeckData { OrderMode::FullRandom => RandomSRS(RandomSRSModule::new()), } } - update_stat_score(word, &self.state.connection.read())?; + + let word_id = card_state.word_id; + repo.save(card_state_handle)?; + + let mut history = self.state.history.write(); + history.create_now(HistoryNote { + id: Default::default(), + timestamp: Utc::now(), + set_id: self.settings.id, + word_id, + answer: status.clone(), + before: old_score, + after: new_score, + fsrs, + })?; todo!("Implement history pushing") // let _ = push_note( // self.settings.id, @@ -133,4 +163,47 @@ impl DeckData { pub fn len(&self) -> usize { self.set.len() } + + pub fn list(deck: &DeckSettings, state: &AppState) -> Result>, NotificationData> { + let time = Instant::now(); + let mut list = vec![]; + let engine = Engine::new(); + + let ast = engine.compile(&deck.filter); + if let Ok(ast) = ast { + let groups = state.word_groups.read().iter().cloned().collect::>(); + let dictionary = &state.dictionary.read(); + let query = dictionary.query_par(Arc::new(move |word| { + let mut more = rhai::Map::new(); + for iced in &word.additional { + more.insert(iced.0.clone().into(), iced.1.clone().into()); + } + let mut scope = Scope::new(); + let group_name = groups[groups.binary_search_by_key(&word.group_id, |g| g.id).unwrap()].name.clone(); + scope + .push_constant("id", word.id.0 as i64) + .push_constant("key", word.key.clone()) + .push_constant("value", word.value.clone()) + .push_constant("tags", word.tags.clone()) + .push_constant("more", more) + .push_constant( + "group", + group_name, + ); + + let result = engine.eval_ast_with_scope::(&mut scope, &ast); + if let Ok(result) = result { + return result; + } + false + })); + + info!("Collecting available words is {:?}", time.elapsed()); + let handles =query.handles().collect(); + drop(query); + Ok(handles) + } else { + Ok(list) + } + } } diff --git a/src/core/srs.rs b/src/core/srs.rs index bd85444..3e59c1f 100644 --- a/src/core/srs.rs +++ b/src/core/srs.rs @@ -31,9 +31,9 @@ pub enum OrderModule { Fsrs(FsrsModule), } pub trait SRSModule { - fn next(&mut self, set: &[CardState]) -> usize; + fn next(&mut self, set: &[&CardState]) -> usize; fn open(&mut self, status: WordOpenMode, index: usize, updated_word: &mut CardState); - fn init(&mut self, set: &[CardState]); + fn init(&mut self, set: &[&CardState]); } #[derive(Clone)] pub struct RandomSRSModule { @@ -49,7 +49,7 @@ impl RandomSRSModule { } } impl SRSModule for RandomSRSModule { - fn next(&mut self, set: &[CardState]) -> usize { + fn next(&mut self, set: &[&CardState]) -> usize { match self.basket.pop() { Some(index) => index, None => { @@ -62,7 +62,7 @@ impl SRSModule for RandomSRSModule { fn open(&mut self, _: WordOpenMode, _: usize, _: &mut CardState) {} - fn init(&mut self, set: &[CardState]) { + fn init(&mut self, set: &[&CardState]) { self.initialized = true; self.basket = (0..set.len()).collect::>(); self.basket.shuffle(&mut rand::rng()) @@ -86,7 +86,7 @@ impl SemiRandomSRSModule { } } impl SRSModule for SemiRandomSRSModule { - fn next(&mut self, set: &[CardState]) -> usize { + fn next(&mut self, set: &[&CardState]) -> usize { let index = self.last_weights.sample(&mut self.generator); if self.history.contains(&index) && self.history.len() != 1 { @@ -106,7 +106,7 @@ impl SRSModule for SemiRandomSRSModule { .update_weights(&[(index, &new_weight)]) .expect("update weights error"); } - fn init(&mut self, set: &[CardState]) { + fn init(&mut self, set: &[&CardState]) { self.initialized = true; let weights = set .iter() @@ -116,7 +116,7 @@ impl SRSModule for SemiRandomSRSModule { } } impl SemiRandomSRSModule { - fn history_len(&self, set: &[CardState]) -> usize { + fn history_len(&self, set: &[&CardState]) -> usize { ((set.len() as f32 * MAX_HISTORY_LEN_PART) as usize).clamp(1, MAX_HISTORY_LEN) } } @@ -130,7 +130,7 @@ pub struct WorstWordsSRSModule { rounds_count: u8, } impl SRSModule for WorstWordsSRSModule { - fn next(&mut self, set: &[CardState]) -> usize { + fn next(&mut self, set: &[&CardState]) -> usize { if self.rounds_remaining == 0 { self.fill_pool(set); self.rounds_remaining = self.rounds_count; @@ -148,7 +148,7 @@ impl SRSModule for WorstWordsSRSModule { fn open(&mut self, _: WordOpenMode, _: usize, _: &mut CardState) {} - fn init(&mut self, _: &[CardState]) { + fn init(&mut self, _: &[&CardState]) { self.initialized = true; } } @@ -163,7 +163,7 @@ impl WorstWordsSRSModule { queue: vec![], } } - fn fill_pool(&mut self, set: &[CardState]) { + fn fill_pool(&mut self, set: &[&CardState]) { let mut sorted = set.iter().enumerate().collect::>(); sorted.sort_by_key(|c| c.1.score); let mut worst = sorted[0..self.pool_size] @@ -187,7 +187,7 @@ pub struct FsrsModule { } impl SRSModule for FsrsModule { - fn next(&mut self, _: &[CardState]) -> usize { + fn next(&mut self, _: &[&CardState]) -> usize { if self.current_group.is_empty() { self.fill_partial_pool(); } @@ -233,7 +233,7 @@ impl SRSModule for FsrsModule { } } - fn init(&mut self, set: &[CardState]) { + fn init(&mut self, set: &[&CardState]) { self.rng = rng(); let today = Local::now().date_naive(); self.today_set = set diff --git a/src/data_provider/card_states.rs b/src/data_provider/card_states.rs index 1091d4c..e8f98a5 100644 --- a/src/data_provider/card_states.rs +++ b/src/data_provider/card_states.rs @@ -7,9 +7,10 @@ use fsrs::MemoryState; use log::info; use rusqlite::{Connection, Error, Params, Row, params}; use std::time::Instant; -use crate::data::repositories::DataRepository; +use crate::data::repositories::{DataRepository, DataRepositoryInner}; pub type CardStateRepository = DataRepository>; +pub type CardStateRepositoryInner = DataRepositoryInner>; #[derive(Clone)] pub struct CardStatesQuerySet; impl TableAccessQuerySet for CardStatesQuerySet { diff --git a/src/navigation.rs b/src/navigation.rs index 7b41f7e..e205793 100644 --- a/src/navigation.rs +++ b/src/navigation.rs @@ -1,6 +1,5 @@ use crate::app::{fill_state, AppState}; -use crate::data::Id; -use crate::data_provider::sqlite::{create_db, SqliteConnection}; +use crate::data_provider::sqlite::{create_db}; use crate::data_provider::web_api::{ get_local_version, get_web_version, load_data, set_local_version, }; @@ -149,7 +148,7 @@ impl ScreenState { info!("Loading data"); let state = &mut self.app_state; if cfg!(windows) { - state.connection.write().finish(); + state.connection.lock().finish(); } let db_file = db_path(); let temp_db_file = temp_db_path(); diff --git a/src/pages/repetition.rs b/src/pages/repetition.rs index 560699b..4143742 100644 --- a/src/pages/repetition.rs +++ b/src/pages/repetition.rs @@ -162,29 +162,9 @@ impl RepetitionState { Err(err) => push_error!(err), }); } - self.increment_counter(); Task::none() } - fn increment_counter(&mut self) { - let mut state = self.state; - let id = self.settings.id; - let activity = state.activity.get_mut(&id); - - let now = Local::now().date_naive(); - - if let Some(activity) = activity { - let (last_day, counter) = activity.last_mut().unwrap(); - if *last_day == now { - *counter += 1; - } else { - activity.push((now, 1)); - } - } else { - state.activity.insert(id, vec![(now, 1)]); - } - } - fn draw_forward(&self) -> Element<'_, RepetitionMessage> { self.draw_card_view(self.settings.forward.as_str()) } diff --git a/src/pages/repetition_settings.rs b/src/pages/repetition_settings.rs index 5e02039..1a08472 100644 --- a/src/pages/repetition_settings.rs +++ b/src/pages/repetition_settings.rs @@ -1,5 +1,5 @@ use crate::app::AppState; -use crate::data::entities::DeckSettings; +use crate::data::entities::{DeckSettings, EntityHandle}; use crate::data_provider::card_states::{delete_stats, load_stats_of_deck}; use crate::navigation::Page::PreviousPage; use crate::navigation::{NavigatedPage, Page, RootMessage}; @@ -16,31 +16,25 @@ use iced_core::{Padding, Theme, color}; use parking_lot::Mutex; use std::sync::Arc; use std::time::Duration; +use crate::core::deck::DeckData; +use crate::data::repositories::BatchedRepository; pub struct RepetitionSettingsState { - set: DeckSettings, - index: usize, + settings: EntityHandle, state: AppState, real_delete: bool, correct_filter: bool, filter_changed: bool, + filtered_words: Option } impl RepetitionSettingsState { - pub(crate) fn new(index: usize, state: AppState) -> RepetitionSettingsState { - let set; - { - let local_state = state.lock(); - set = local_state.decks[index].clone(); - } - let filter_state = set.check_filter(); - + pub(crate) fn new(settings: EntityHandle, state: AppState) -> RepetitionSettingsState { RepetitionSettingsState { - index, - set, + settings, state, real_delete: false, - correct_filter: filter_state, + correct_filter: false, filter_changed: false, } } @@ -61,34 +55,34 @@ impl NavigatedPage for RepetitionSettingsState { Back => {} Save => { let mut state = self.state.lock(); - if let Err(e) = update_deck(&mut self.set, &state.connection) { + if let Err(e) = update_deck(&mut self.settings, &state.connection) { return push_error_task!(e); } if self.filter_changed - && let Err(e) = update_deck_stats(&self.set, &state) + && let Err(e) = update_deck_stats(&self.settings, &state) { return push_error_task!(e); } - state.decks[self.index] = self.set.clone(); + state.decks[self.index] = self.settings.clone(); } SetName(new) => { - self.set.name = new; + self.settings.name = new; } SetForward(new) => { - self.set.forward = new; + self.settings.forward = new; } SetBackward(backward) => { - self.set.backward = backward; + self.settings.backward = backward; } SetFilter(new) => { - self.set.filter = new; - self.correct_filter = self.set.check_filter(); + self.settings.filter = new; + self.correct_filter = self.settings.check_filter(); self.filter_changed = true; } TryFilter => { let state = self.state.lock(); - let count = self.set.get_word_list(&state).len(); - self.set.count = Some(count); + let count = self.settings.get_word_list(&state).len(); + self.settings.count = Some(count); } DeleteSet => { if !self.real_delete { @@ -99,7 +93,7 @@ impl NavigatedPage for RepetitionSettingsState { }); } let mut state = self.state.lock(); - if let Err(e) = delete_set(&self.set, &state.connection) { + if let Err(e) = delete_set(&self.settings, &state.connection) { return push_error_task!(e); } @@ -118,22 +112,22 @@ impl NavigatedPage for RepetitionSettingsState { column![ column![ text!("Название набора"), - text_input("", &self.set.name).on_input(SetName), + text_input("", &self.settings.name).on_input(SetName), ] .spacing(QUARTER_SPACING), column![ text!("Передняя сторона"), - text_input("", &self.set.forward).on_input(SetForward), + text_input("", &self.settings.forward).on_input(SetForward), ] .spacing(QUARTER_SPACING), column![ text!("Задняя сторона"), - text_input("", &self.set.backward).on_input(SetBackward), + text_input("", &self.settings.backward).on_input(SetBackward), ] .spacing(QUARTER_SPACING), column![ text!("Фильтр"), - text_input("", &self.set.filter) + text_input("", &self.settings.filter) .style(|x, status| { let mut primary = Theme::default()(x, status); if !self.correct_filter { @@ -145,7 +139,7 @@ impl NavigatedPage for RepetitionSettingsState { button("Проверить фильтр") .style(jl_button) .on_press(TryFilter), - self.count_view(&self.set), + self.count_view(&self.settings), ] .spacing(QUARTER_SPACING), ] @@ -179,8 +173,8 @@ impl NavigatedPage for RepetitionSettingsState { } fn update_deck_stats(deck: &DeckSettings, state: &AppState) -> MaybeError { - let mut db_stats = load_stats_of_deck(deck, &state.connection).expect("Wrong db operation"); - let filtered_words = deck.get_word_list(state); + let mut db_stats = state.card_states.read().query_par(Arc::new(|s| s.set_id == deck.id)); + let filtered_words = DeckData::list(deck, state)?; filtered_words.iter().for_each(|word| { let word_id = state.dictionary[*word].id; if let Some(index) = db_stats.iter().position(|stat| stat.word_id == word_id) { @@ -188,13 +182,15 @@ fn update_deck_stats(deck: &DeckSettings, state: &AppState) -> MaybeError { } }); - delete_stats(db_stats.as_slice(), &state.connection)?; + let repo = state.card_states.write(); + // repo.delete_many(); + // delete_stats(db_stats.as_slice(), &state.connection)?; Ok(()) } impl RepetitionSettingsState { fn count_view(&self, set: &DeckSettings) -> Element<'_, RepetitionSettingsMessage> { - if let Some(count) = set.count { + if let Some(count) = self.filtered_words { return text!("Количество слов: {}", count).into(); } space().into()