Partial dictionary rewrite

src/data_provider/decks.rs

@@ -1,12 +1,7 @@
-use crate::core::srs::OrderMode;
-use crate::data::entities::{CardState, DeckSettings};
-use crate::data_provider::{SqliteDbLayer, TableAccessQuerySet};
-use crate::notification::NotificationData::{DbLoadError, DbSaveError};
-use crate::notification::{MaybeError, NotificationData};
-use chrono::NaiveDate;
-use rusqlite::{Connection, Error, Params, Row};
+use crate::data::entities::DeckSettings;
 use crate::data::repositories::DataRepository;
-use crate::data_provider::card_states::CardStatesQuerySet;
+use crate::data_provider::{SqliteDbLayer, TableAccessQuerySet};
+use rusqlite::{Error, Params, Row};
 
 pub type DeckRepository = DataRepository<DeckSettings, SqliteDbLayer<DeckSettings, DeckQuerySet>>;
 
@@ -36,8 +31,6 @@ impl TableAccessQuerySet<DeckSettings> for DeckQuerySet {
             forward: row.get(2)?,
             backward: row.get(3)?,
             filter: row.get(4)?,
-            count: None,
-            open_mode: OrderMode::Default,
         })
     }
 
@@ -59,75 +52,4 @@ impl TableAccessQuerySet<DeckSettings> for DeckQuerySet {
             entity.id,
         )
     }
-}
-
-pub fn load_sets(connection: &Connection) -> Result<Vec<DeckSettings>, NotificationData> {
-    let mut stmt = connection
-        .prepare("SELECT id, name, forward, backward, filter FROM decks")
-        .expect("Failed to prepare state query");
-    let iter = stmt
-        .query_map([], |row| {
-            Ok(DeckSettings {
-                id: row.get(0)?,
-                name: row.get(1)?,
-                forward: row.get(2)?,
-                backward: row.get(3)?,
-                filter: row.get(4)?,
-                count: None,
-                open_mode: OrderMode::Default,
-            })
-        })
-        .map_err(|_| DbLoadError)?;
-
-    let mut buffer = Vec::with_capacity(16);
-    iter.filter_map(|res| res.ok()).for_each(|i| buffer.push(i));
-    Ok(buffer)
-}
-
-pub fn add_set(set: &mut DeckSettings, connection: &Connection) -> MaybeError {
-    let index : u32 = connection
-        .query_row(
-            "INSERT INTO decks (name, forward, backward, filter) VALUES (?1, ?2, ?3, ?4) RETURNING id",
-            (
-                &set.name,
-                &set.forward,
-                &set.backward,
-                &set.filter,
-            ),
-            |row| row.get(0)
-        )
-        .map_err(|_| DbSaveError)?;
-
-    set.id = index.into();
-    Ok(())
-}
-
-pub fn update_deck(set: &mut DeckSettings, connection: &Connection) -> MaybeError {
-    if !set.id.is_valid() {
-        add_set(set, connection)?;
-    } else {
-        connection
-            .execute(
-                "UPDATE decks SET name = ?1, forward = ?2, backward = ?3, filter = ?4 WHERE id = ?5",
-                (
-                    &set.name,
-                    &set.forward,
-                    &set.backward,
-                    &set.filter,
-                    &set.id
-                ),
-            )
-            .map_err(|_| DbSaveError)?;
-    }
-    Ok(())
-}
-
-pub fn delete_set(set: &DeckSettings, connection: &Connection) -> MaybeError {
-    if !set.id.is_valid() {
-        return Err(DbSaveError);
-    }
-    connection
-        .execute("DELETE FROM decks WHERE id = ?1", (&set.id,))
-        .map_err(|_| DbSaveError)?;
-    Ok(())
-}
+}

src/data_provider/word_groups.rs

@@ -1,10 +1,12 @@
 use crate::data::entities::{DeckSettings, WordGroup};
 use crate::data_provider::{SqliteDbLayer, TableAccessQuerySet};
 use rusqlite::{Error, Params, Row};
-use crate::data::repositories::DataRepository;
+use crate::data::repositories::{DataRepository, DataRepositoryInner};
 use crate::data_provider::decks::DeckQuerySet;
 
-pub type WordGroupRepository = DataRepository<WordGroup, SqliteDbLayer<WordGroup, WordGroupQuerySet>>;
+pub type WordGroupRepository = DataRepository<WordGroup, WordGroupDataLayer>;
+pub type WordGroupRepositoryInner = DataRepositoryInner<WordGroup, WordGroupDataLayer>;
+pub type WordGroupDataLayer = SqliteDbLayer<WordGroup, WordGroupQuerySet>;
 
 #[derive(Clone)]
 pub struct WordGroupQuerySet;

src/data_provider/words.rs

@@ -5,10 +5,11 @@ use crate::notification::{MaybeError, NotificationData};
 use litemap::LiteMap;
 use rusqlite::{Connection, Error, Params, Row, params};
 use std::collections::HashMap;
-use crate::data::repositories::DataRepository;
+use crate::data::repositories::{BatchedDbLayer, DataRepository, DataRepositoryInner};
 
 pub type WordRepository = DataRepository<WordData, SqliteDbLayer<WordData, WordQuerySet>>;
-
+pub type WordRepositoryInner = DataRepositoryInner<WordData, SqliteDbLayer<WordData, WordQuerySet>>;
+pub type WordDataLayer = SqliteDbLayer<WordData, WordQuerySet>;
 #[derive(Clone)]
 pub struct WordQuerySet;
 impl TableAccessQuerySet<WordData> for WordQuerySet {