Database startup update

.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,16 @@ 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) => {
+                println!("selected: {}", id);
+                if let Ok(db) = self.database.lock() {
+                    if let Ok(audio_files) = db.get_all_audio_files() {
+                        println!("ALL {}", audio_files.len());
+                        self.table_rows = audio_files;
+                    }
+                }
+                println!("num rows: {}", self.table_rows.len());
+            }
         });
     }
 }

src/database/audio_file.rs

@@ -1,12 +1,14 @@
-use super::{CollectionID, Database, DatabaseConnectionHandle, DatabaseError};
+use super::prelude::*;
 use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+use vizia::prelude::*;
 
 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,
+    pub id: AudioFileID,
+    pub name: String,
+    pub collection: CollectionID,
     duration: f32,
     sample_rate: f32,
     bit_depth: f32,
@@ -16,6 +18,20 @@ pub struct AudioFile {
 }
 
 impl AudioFile {
+    pub fn from_path(path: &PathBuf, id: AudioFileID) -> Option<Self> {
+        let extension = path.extension().map(|v| v.to_str().unwrap()).unwrap_or("");
+
+        if !AUDIO_FILE_EXTENSIONS.contains(&extension) {
+            return None;
+        }
+
+        let name = path.file_name().unwrap().to_str().unwrap();
+
+        let audio_file = AudioFile::new(id, name.to_string(), id, 0.0, 0.0, 0.0, None, None, 0.0);
+
+        Some(audio_file)
+    }
+
     pub fn new(
         id: AudioFileID,
         name: String,
@@ -33,8 +49,10 @@ impl AudioFile {
 
 pub trait DatabaseAudioFileHandler {
     fn get_all_audio_files(&self) -> Result<Vec<AudioFile>, DatabaseError>;
+    fn get_audio_file_by_path(&self, path: &PathBuf) -> Result<AudioFile, DatabaseError>;
     fn get_child_audio_files(&self, parent: CollectionID) -> Result<Vec<AudioFile>, DatabaseError>;
     fn insert_audio_file(&mut self, audio_file: AudioFile) -> Result<(), DatabaseError>;
+    fn remove_audio_file(&mut self, audio_file: AudioFileID) -> Result<(), DatabaseError>;
 }
 
 impl DatabaseAudioFileHandler for Database {
@@ -63,13 +81,40 @@ impl DatabaseAudioFileHandler for Database {
         Err(DatabaseError::ConnectionClosed)
     }
 
+    fn get_audio_file_by_path(&self, path: &PathBuf) -> Result<AudioFile, DatabaseError> {
+        if let Some(connection) = self.get_connection() {
+            let mut query = connection.prepare(
+                "SELECT id, name, collection, duration, sample_rate, bit_depth, bpm, key, size FROM audio_files WHERE path = (?1)",
+            )?;
+
+            let col: AudioFile = query.query_row([path.to_str().unwrap()], |row| {
+                let path: String = row.get(3)?;
+                Ok(AudioFile {
+                    id: row.get(0)?,
+                    name: row.get(1)?,
+                    collection: row.get(2)?,
+                    duration: row.get(3)?,
+                    sample_rate: row.get(4)?,
+                    bit_depth: row.get(5)?,
+                    bpm: row.get(6)?,
+                    key: row.get(7)?,
+                    size: row.get(8)?,
+                })
+            })?;
+
+            return Ok(col);
+        }
+
+        Err(DatabaseError::ConnectionClosed)
+    }
+
     fn get_child_audio_files(&self, parent: CollectionID) -> Result<Vec<AudioFile>, DatabaseError> {
         if let Some(connection) = self.get_connection() {
             let mut query = connection.prepare(
                 "SELECT id, name, collection, duration, sample_rate, bit_depth, bpm, key, size FROM audio_files WHERE collection = (?1)",
             )?;
 
-            let collections = query.query_map([parent], |row| {
+            let audio_files = query.query_map([parent], |row| {
                 Ok(AudioFile {
                     id: row.get(0)?,
                     name: row.get(1)?,
@@ -83,7 +128,7 @@ impl DatabaseAudioFileHandler for Database {
                 })
             })?;
 
-            return Ok(collections.map(|v| v.unwrap()).collect());
+            return Ok(audio_files.map(|v| v.unwrap()).collect());
         }
         Err(DatabaseError::ConnectionClosed)
     }
@@ -101,14 +146,21 @@ impl DatabaseAudioFileHandler for Database {
                     audio_file.bit_depth,
                     audio_file.bpm,
                     audio_file.key,
-                    audio_file.key,
                     audio_file.size,
                 ),
             )?;
         }
 
         Ok(())
     }
+
+    fn remove_audio_file(&mut self, audio_file: AudioFileID) -> Result<(), DatabaseError> {
+        if let Some(connection) = self.get_connection() {
+            connection.execute("DELETE FROM audio_files WHERE id = (?1)", [audio_file])?;
+        }
+
+        Ok(())
+    }
 }
 
 impl From<AudioFile> for usize {