Hooking DB

.vscode/settings.json

@@ -10,4 +10,5 @@
 	},
 	"prettier.tabWidth": 4,
 	"css.lint.unknownProperties": "ignore",
+	"rust-analyzer.showUnlinkedFileNotification": false,
 }

README.md

@@ -1,3 +1,7 @@
 # Vizia Sample Browser
 
 An audio sample browser application.
+
+| Header 1 | Header 2 |
+| --- | --- |
+| Table 1 | Table 2 |

src/app_data.rs

@@ -1,20 +1,27 @@
+use std::sync::{Arc, Mutex};
+
 use vizia::prelude::*;
 
-use crate::state::browser::BrowserState;
+use crate::{
+    database::prelude::{AudioFile, CollectionID, Database, DatabaseAudioFileHandler},
+    state::browser::{BrowserState, Directory},
+};
 
 #[derive(Lens)]
 pub struct AppData {
+    pub database: Arc<Mutex<Database>>,
     pub browser: BrowserState,
     pub browser_width: f32,
     pub table_height: f32,
     pub table_headers: Vec<String>,
-    pub table_rows: Vec<Vec<String>>,
+    pub table_rows: Vec<AudioFile>,
     pub search_text: String,
 }
 
 pub enum AppEvent {
     SetBrowserWidth(f32),
     SetTableHeight(f32),
+    ViewCollection(CollectionID),
 }
 
 impl Model for AppData {
@@ -24,6 +31,13 @@ impl Model for AppData {
         event.map(|app_event, _| match app_event {
             AppEvent::SetBrowserWidth(width) => self.browser_width = *width,
             AppEvent::SetTableHeight(height) => self.table_height = *height,
+            AppEvent::ViewCollection(id) => {
+                if let Ok(db) = self.database.lock() {
+                    if let Ok(audio_files) = db.get_child_audio_files(*id) {
+                        self.table_rows = audio_files;
+                    }
+                }
+            }
         });
     }
 }

src/database/audio_file.rs

@@ -1,18 +1,20 @@
+use vizia::prelude::*;
+
 use super::{CollectionID, Database, DatabaseConnectionHandle, DatabaseError};
 use serde::{Deserialize, Serialize};
 
 pub type AudioFileID = usize;
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Data, Lens)]
 pub struct AudioFile {
-    id: AudioFileID,
-    name: String,
-    collection: CollectionID,
-    duration: f32,
-    sample_rate: f32,
-    bit_depth: f32,
-    bpm: Option<f32>,
-    key: Option<f32>,
-    size: f32,
+    pub id: AudioFileID,
+    pub name: String,
+    pub collection: CollectionID,
+    pub duration: f32,
+    pub sample_rate: f32,
+    pub bit_depth: f32,
+    pub bpm: Option<f32>,
+    pub key: Option<f32>,
+    pub size: f32,
 }
 
 impl AudioFile {
@@ -101,7 +103,6 @@ impl DatabaseAudioFileHandler for Database {
                     audio_file.bit_depth,
                     audio_file.bpm,
                     audio_file.key,
-                    audio_file.key,
                     audio_file.size,
                 ),
             )?;

src/database/collection.rs

@@ -1,3 +1,5 @@
+use std::path::{Path, PathBuf};
+
 use super::{Database, DatabaseConnectionHandle, DatabaseError};
 use serde::{Deserialize, Serialize};
 
@@ -7,11 +9,17 @@ pub struct Collection {
     id: CollectionID,
     parent_collection: Option<CollectionID>,
     name: String,
+    path: PathBuf,
 }
 
 impl Collection {
-    pub fn new(id: CollectionID, parent_collection: Option<CollectionID>, name: String) -> Self {
-        Self { id, parent_collection, name }
+    pub fn new(
+        id: CollectionID,
+        parent_collection: Option<CollectionID>,
+        name: String,
+        path: PathBuf,
+    ) -> Self {
+        Self { id, parent_collection, name, path }
     }
 
     pub fn id(&self) -> usize {
@@ -25,6 +33,10 @@ impl Collection {
     pub fn name(&self) -> &str {
         self.name.as_ref()
     }
+
+    pub fn path(&self) -> &PathBuf {
+        &self.path
+    }
 }
 
 pub trait DatabaseCollectionHandler {
@@ -39,11 +51,17 @@ impl DatabaseCollectionHandler for Database {
     fn get_root_collection(&self) -> Result<Collection, DatabaseError> {
         if let Some(connection) = self.get_connection() {
             let mut query = connection.prepare(
-                "SELECT id, parent_collection, name FROM collections WHERE parent_collection IS NULL",
+                "SELECT id, parent_collection, name, path FROM collections WHERE parent_collection IS NULL",
             )?;
 
             let col: Collection = query.query_row([], |row| {
-                Ok(Collection { id: row.get(0)?, parent_collection: None, name: row.get(2)? })
+                let path: String = row.get(3)?;
+                Ok(Collection::new(
+                    row.get(0)?,
+                    row.get(1)?,
+                    row.get(2)?,
+                    Path::new(&path).to_path_buf(),
+                ))
             })?;
 
             return Ok(col);
@@ -55,14 +73,19 @@ impl DatabaseCollectionHandler for Database {
     fn get_all_collections(&self) -> Result<Vec<Collection>, DatabaseError> {
         if let Some(connection) = self.get_connection() {
             let mut query =
-                connection.prepare("SELECT id, parent_collection, name FROM collections")?;
+                connection.prepare("SELECT id, parent_collection, name, path FROM collections")?;
 
             let collections = query.query_map([], |row| {
-                Ok(Collection {
-                    id: row.get(0)?,
-                    parent_collection: row.get(1)?,
-                    name: row.get(2)?,
-                })
+                Ok(Collection::new(
+                    row.get(0)?,
+                    row.get(1)?,
+                    row.get(2)?,
+                    Path::new(&{
+                        let s: String = row.get(3)?;
+                        s
+                    })
+                    .to_path_buf(),
+                ))
             })?;
 
             return Ok(collections.map(|v| v.unwrap()).collect());
@@ -77,15 +100,17 @@ impl DatabaseCollectionHandler for Database {
     ) -> Result<Vec<Collection>, DatabaseError> {
         if let Some(connection) = self.get_connection() {
             let mut query = connection.prepare(
-                "SELECT id, parent_collection, name FROM collections WHERE parent_collection = (?1)",
+                "SELECT id, parent_collection, name, path FROM collections WHERE parent_collection = (?1)",
             )?;
 
             let collections = query.query_map([parent], |row| {
-                Ok(Collection {
-                    id: row.get(0)?,
-                    name: row.get(2)?,
-                    parent_collection: row.get(1)?,
-                })
+                let path: String = row.get(3)?;
+                Ok(Collection::new(
+                    row.get(0)?,
+                    row.get(1)?,
+                    row.get(2)?,
+                    Path::new(&path).to_path_buf(),
+                ))
             })?;
 
             return Ok(collections.map(|v| v.unwrap()).collect());
@@ -97,8 +122,8 @@ impl DatabaseCollectionHandler for Database {
     fn insert_collection(&mut self, collection: Collection) -> Result<(), DatabaseError> {
         if let Some(connection) = self.get_connection() {
             connection.execute(
-                "INSERT INTO collections (id, parent_collection, name) VALUES (?1, ?2, ?3)",
-                (collection.id, collection.parent_collection, collection.name),
+                "INSERT INTO collections (id, parent_collection, name, path) VALUES (?1, ?2, ?3, ?4)",
+                (collection.id, collection.parent_collection, collection.name, collection.path.to_str().unwrap()),
             )?;
         }
 

src/database/error.rs

@@ -1,7 +1,7 @@
 #[derive(Debug)]
 pub enum DatabaseError {
     ConnectionClosed,
-    PathNotDirecotry,
+    PathNotDirectory,
     RusqliteError(rusqlite::Error),
     IOError(std::io::Error),
 }

src/database/handler.rs

@@ -1,7 +1,6 @@
 use crate::state::browser::Directory;
 
 use super::*;
-use itertools::Itertools;
 use rusqlite::Connection;
 use std::{
     any::Any,
@@ -13,11 +12,12 @@ use std::{
     rc::Rc,
     sync::atomic::AtomicUsize,
 };
+use vizia::prelude::*;
 
 pub const DATABASE_FILE_NAME: &str = ".database.vsb";
 pub const AUDIO_FILE_EXTENSIONS: [&'static str; 1] = ["wav"];
 
-#[derive(Debug)]
+#[derive(Debug, Lens)]
 pub struct Database {
     pub(super) path: PathBuf,
     pub(super) conn: Option<Connection>,
@@ -28,7 +28,7 @@ impl Database {
     pub fn from_directory(path: PathBuf) -> Result<Self, DatabaseError> {
         // Check file is directory
         if !directory_exists(&path) {
-            return Err(DatabaseError::PathNotDirecotry);
+            return Err(DatabaseError::PathNotDirectory);
         }
 
         // Open connection
@@ -39,8 +39,8 @@ impl Database {
 
         s.open_connection()?;
 
+        s.initialize_empty_database();
         // if !database_exists {
-        //     s.initialize_empty_database();
         // } else {
         //     s.update_database();
         // }
@@ -68,6 +68,10 @@ impl Database {
             let mut colls = collections.borrow_mut();
 
             let name = path.file_name().unwrap().to_str().unwrap().to_string();
+            if name == ".vsb-meta" {
+                return;
+            }
+
             let id = collection_count.load(std::sync::atomic::Ordering::Relaxed);
             collection_count.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
             let parent_id = match parent_path.is_none() {
@@ -76,7 +80,7 @@ impl Database {
             };
 
             // Insert collection
-            let collection = Collection::new(id, parent_id, name);
+            let collection = Collection::new(id, parent_id, name, path.clone());
 
             db.insert_collection(collection);
 
@@ -154,67 +158,10 @@ where
     Ok(())
 }
 
-#[derive(Clone, Debug)]
-struct RecursiveDir {
-    id: CollectionID,
-    parent_id: Option<CollectionID>,
-    name: String,
-    children: Vec<RecursiveDir>,
-}
-
-fn query_to_recursive(db: &Database) -> RecursiveDir {
-    let collections = db.get_all_collections().unwrap();
-
-    let mut hm: HashMap<CollectionID, RecursiveDir> = HashMap::new();
-
-    for coll in collections {
-        hm.insert(
-            coll.id(),
-            RecursiveDir {
-                id: coll.id(),
-                parent_id: coll.parent_collection(),
-                name: coll.name().to_string(),
-                children: Vec::new(),
-            },
-        );
-    }
-
-    fn children_of_collection(
-        map: &HashMap<CollectionID, RecursiveDir>,
-        coll: CollectionID,
-    ) -> VecDeque<CollectionID> {
-        map.values().filter(|v| v.parent_id == Some(coll)).map(|v| v.id).collect()
-    }
-
-    let mut root_dir = hm.values().find(|v| v.parent_id.is_none()).unwrap().clone();
-
-    let mut collection_stack: VecDeque<CollectionID> = children_of_collection(&hm, root_dir.id);
-
-    while let Some(coll) = collection_stack.pop_front() {
-        let mut children = children_of_collection(&hm, coll);
-        collection_stack.append(&mut children);
-
-        let coll_data = hm.get(&coll).unwrap().clone();
-        root_dir.children.push(coll_data);
-    }
-
-    root_dir
-}
-
-#[test]
-fn query_to_recursive_test() {
-    let mut handle = Database::from_connection("", Some(Connection::open_in_memory().unwrap()));
-    handle.get_connection().unwrap().execute_batch(include_str!("sqls/schema.sql")).unwrap();
-    handle.get_connection().unwrap().execute_batch(include_str!("sqls/test.sql")).unwrap();
-
-    let root = query_to_recursive(&handle);
-
-    print_directory(&root);
-}
-
-fn print_directory(dir: &RecursiveDir) {
-    println!("{:?}", dir.name);
-    for child in dir.children.iter() {
-        print_directory(child)
+impl PartialEq for Database {
+    fn eq(&self, other: &Self) -> bool {
+        self.path == other.path
+            && self.conn.is_some() == other.conn.is_some()
+            && self.meta == other.meta
     }
 }

src/database/sqls/schema.sql

@@ -2,6 +2,7 @@ CREATE TABLE collections (
     id                  integer UNIQUE PRIMARY KEY,
     parent_collection   integer NULL,
     name                nvarchar(255),
+    path                nvarchar(255),
 
     FOREIGN KEY(parent_collection) REFERENCES collections(id)
 );

src/database/sqls/test.sql

@@ -1,8 +1,8 @@
-INSERT INTO collections(id, parent_collection, name) VALUES (0, NULL, "Sample Library");
-INSERT INTO collections(id, parent_collection, name) VALUES (1, 0, "Library 1");
-INSERT INTO collections(id, parent_collection, name) VALUES (2, 0, "Library 2");
-INSERT INTO collections(id, parent_collection, name) VALUES (3, 1, "Sub Library 1.1");
-INSERT INTO collections(id, parent_collection, name) VALUES (4, 1, "Sub Library 1.2");
+INSERT INTO collections(id, parent_collection, name, path) VALUES (0, NULL, "Sample Library", "");
+INSERT INTO collections(id, parent_collection, name, path) VALUES (1, 0, "Library 1", "");
+INSERT INTO collections(id, parent_collection, name, path) VALUES (2, 0, "Library 2", "");
+INSERT INTO collections(id, parent_collection, name, path) VALUES (3, 1, "Sub Library 1.1", "");
+INSERT INTO collections(id, parent_collection, name, path) VALUES (4, 1, "Sub Library 1.2", "");
 
 INSERT INTO audio_files(id, name, collection, duration, sample_rate, bit_depth, bpm, key, size) VALUES (0, "Audio File 0", 0, 0, 0, 0, 0, 0, 0);
 INSERT INTO audio_files(id, name, collection, duration, sample_rate, bit_depth, bpm, key, size) VALUES (1, "Audio File 1", 1, 0, 0, 0, 0, 0, 0);