src/app.rs

@@ -1,11 +1,9 @@
 use std::sync::Arc;
 use crate::data::Id;
-use crate::data::entities::DeckSettings;
+use crate::data_provider::decks::{DeckRepository};
-use crate::data::entities::{WordData, WordGroup};
-use crate::data_provider::decks::load_sets;
 use crate::data_provider::settings::get_setting;
 use crate::data_provider::sqlite::{SqliteConnection};
-use crate::data_provider::words::{load_word_groups, load_words};
+use crate::data_provider::words::{WordRepository};
 use crate::navigation::RootMessage::Keyboard;
 use crate::navigation::{AppSettings, RootMessage, ScreenState};
 use chrono::NaiveDate;
@@ -18,6 +16,9 @@ use iced_core::{Font, Size, Theme};
 use log::info;
 use parking_lot::RwLock;
 use rusqlite::Connection;
+use crate::data::repositories::Repository;
+use crate::data_provider::word_groups::WordGroupRepository;
+
 pub const USER_FONT: Font = Font::with_name("Noto Sans JP");
 
 pub fn start() -> iced::Result {
@@ -61,9 +62,9 @@ fn subscription(_state: &ScreenState) -> Subscription<RootMessage> {
 
 #[derive(Clone)]
 pub struct AppState {
-    pub dictionary: Vec<WordData>,
+    pub dictionary: WordRepository,
-    pub decks: Vec<DeckSettings>,
+    pub decks: DeckRepository,
-    pub word_groups: Vec<WordGroup>,
+    pub word_groups: WordGroupRepository,
     pub connection: Arc<RwLock<SqliteConnection>>,
     pub sync_data: Arc<RwLock<AppSettings>>,
     pub activity: HashMap<Id, Vec<(NaiveDate, u32)>>,
@@ -77,30 +78,31 @@ impl Default for AppState {
 
 impl AppState {
     pub fn new() -> Self {
+        let connection = Arc::new(RwLock::new(SqliteConnection::default()));
         Self {
-            dictionary: vec![],
+            dictionary: WordRepository::new(connection.clone()),
-            decks: vec![],
+            decks: DeckRepository::new(connection.clone()),
-            word_groups: vec![],
+            word_groups: WordGroupRepository::new(connection.clone()),
-            connection: Arc::new(RwLock::new(Default::default())),
             sync_data: Arc::new(RwLock::new(AppSettings {
                 key: None,
                 auto_web_fetch: false,
             })),
             activity: Default::default(),
+            connection,
         }
     }
 }
 
 pub fn fill_state(state: &mut AppState) {
     let connection = state.connection.read();
-    let list = load_words(&connection);
+
-    let sets = load_sets(&connection);
-    let groups = load_word_groups(&connection);
     let setting = load_settings(&connection);
 
-    state.dictionary = list.unwrap_or_default();
+    state.word_groups.write().start().unwrap();
-    state.decks = sets.unwrap_or_default();
+        state.dictionary.write().start().unwrap();
-    state.word_groups = groups.unwrap_or_default();
+    state.decks.write().start().unwrap();
+
+
     state.sync_data = Arc::new(RwLock::new(setting))
 }
 

src/data/entities.rs

@@ -79,6 +79,17 @@ pub struct DeckSettings {
     pub count: Option<usize>,
     pub open_mode: OrderMode,
 }
+
+impl EntityData for DeckSettings {
+    fn id(&self) -> Id {
+        self.id
+    }
+
+    fn set_id(&mut self, id: Id) {
+        self.id = id;
+    }
+}
+
 impl DeckSettings {
     pub(crate) fn with_name(name: String) -> DeckSettings {
         DeckSettings {

src/data/repositories.rs

@@ -10,6 +10,7 @@ use rusqlite::Connection;
 use std::marker::PhantomData;
 use std::ops::Deref;
 use std::sync::Arc;
+use crate::data_provider::sqlite::SqliteConnection;
 
 pub trait Repository<T, D>
 where
@@ -192,13 +193,31 @@ pub struct DataRepositoryInner<T: std::clone::Clone + EntityData, D: DbLayer<T>>
     cache: Vec<T>,
     temporal: Vec<T>,
     next_temporal: u32,
-    connection: Arc<RwLock<Connection>>,
+    connection: Arc<RwLock<SqliteConnection>>,
     data_layer: D,
     query_manger: QueryManger<T, Self, D>,
     version: u16,
     shifts: u16,
 }
 
+impl<T: std::clone::Clone + EntityData, D: DbLayer<T> + std::default::Default>  DataRepository<T, D> {
+    pub fn new(connection: Arc<RwLock<SqliteConnection>>) -> DataRepository<T, D> {
+        Self{
+            inner: Arc::new(RwLock::new(DataRepositoryInner{
+                cache: vec![],
+                temporal: vec![],
+                next_temporal: 0,
+                connection,
+                data_layer: Default::default(),
+                query_manger: QueryManger { queries: vec![] },
+                version: 0,
+                shifts: 0,
+            })),
+        }
+    }
+}
+
+
 impl<T: std::clone::Clone + EntityData, D: DbLayer<T>> Deref for DataRepository<T, D> {
     type Target = Arc<RwLock<DataRepositoryInner<T, D>>>;
 

src/data_provider/card_states.rs

@@ -9,7 +9,7 @@ use rusqlite::{Connection, Error, Params, Row, params};
 use std::time::Instant;
 use crate::data::repositories::DataRepository;
 
-type CardStateRepository = DataRepository<CardState, SqliteDbLayer<CardState, CardStatesQuerySet>>;
+pub type CardStateRepository = DataRepository<CardState, SqliteDbLayer<CardState, CardStatesQuerySet>>;
 pub struct CardStatesQuerySet;
 impl TableAccessQuerySet<CardState> for CardStatesQuerySet {
     fn load() -> &'static str {

src/data_provider/custom_fields.rs

@@ -3,7 +3,7 @@ use crate::data::repositories::DataRepository;
 use crate::data_provider::{SqliteDbLayer, TableAccessQuerySet};
 use rusqlite::{Error, Params, Row};
 
-type CustomFieldRepository = DataRepository<CustomField, SqliteDbLayer<CustomField, CustomFieldsQuerySet>>;
+pub type CustomFieldRepository = DataRepository<CustomField, SqliteDbLayer<CustomField, CustomFieldsQuerySet>>;
 
 pub struct CustomFieldsQuerySet;
 impl TableAccessQuerySet<WordGroup> for CustomFieldsQuerySet {

src/data_provider/decks.rs

@@ -8,8 +8,9 @@ use rusqlite::{Connection, Error, Params, Row};
 use crate::data::repositories::DataRepository;
 use crate::data_provider::card_states::CardStatesQuerySet;
 
-type DeckRepository = DataRepository<DeckSettings, SqliteDbLayer<DeckSettings, DeckQuerySet>>;
+pub type DeckRepository = DataRepository<DeckSettings, SqliteDbLayer<DeckSettings, DeckQuerySet>>;
 
+#[derive(Clone)]
 pub struct DeckQuerySet;
 impl TableAccessQuerySet<DeckSettings> for DeckQuerySet {
     fn load() -> &'static str {

src/data_provider/mod.rs

@@ -30,6 +30,7 @@ pub trait TableAccessQuerySet<T> {
     fn update_params(entity: &T) -> impl Params;
 }
 
+#[derive(Clone)]
 pub struct SqliteDbLayer<T, Q>
 where
     Q: TableAccessQuerySet<T>,
@@ -37,6 +38,14 @@ where
     _phantom: PhantomData<(T, Q)>,
 }
 
+impl<T, Q: TableAccessQuerySet<T>> Default for SqliteDbLayer<T, Q>{
+    fn default() -> Self {
+        Self{
+            _phantom: PhantomData,
+        }
+    }
+}
+
 impl<T: EntityData, Q: TableAccessQuerySet<T>> DbLayer<T> for SqliteDbLayer<T, Q> {
     fn write_entity(&self, entity: &T, connection: &Connection) -> MaybeError {
         let time = Instant::now();

src/data_provider/word_groups.rs

@@ -4,8 +4,9 @@ use rusqlite::{Error, Params, Row};
 use crate::data::repositories::DataRepository;
 use crate::data_provider::decks::DeckQuerySet;
 
-type WordGroupRepository = DataRepository<WordGroup, SqliteDbLayer<WordGroup, WordGroupQuerySet>>;
+pub type WordGroupRepository = DataRepository<WordGroup, SqliteDbLayer<WordGroup, WordGroupQuerySet>>;
 
+#[derive(Clone)]
 pub struct WordGroupQuerySet;
 impl TableAccessQuerySet<WordGroup> for WordGroupQuerySet {
     fn load() -> &'static str {

src/data_provider/words.rs

@@ -7,8 +7,9 @@ use rusqlite::{Connection, Error, Params, Row, params};
 use std::collections::HashMap;
 use crate::data::repositories::DataRepository;
 
-type DeckRepository = DataRepository<WordData, SqliteDbLayer<WordData, WordQuerySet>>;
+pub type WordRepository = DataRepository<WordData, SqliteDbLayer<WordData, WordQuerySet>>;
 
+#[derive(Clone)]
 pub struct WordQuerySet;
 impl TableAccessQuerySet<WordData> for WordQuerySet {
     fn load() -> &'static str {