feat: add working forms

Author: DefinitelyNotSimon13

.gitignore

@@ -6,6 +6,7 @@ node_modules
 /.svelte-kit
 /build
 coverage
+utils/fake-data*
 
 # OS
 .DS_Store

episko_gui_backend/src/commands.rs

@@ -1,25 +1,67 @@
+use serde::Serialize;
 use std::path::Path;
 use tokio::sync::Mutex;
 use uuid::Uuid;
 
 use episko_lib::{
+    database::retrieve_metadata::Pagination,
     files::File,
-    metadata::{Metadata, metadata_handler::MetadataHandler},
+    metadata::{Metadata, MetadataPreview, metadata_handler::MetadataHandler},
 };
 
 use crate::{AppState, Error, model::MetadataDco, model::MetadataDto};
 
+static PAGE_SIZE: u32 = 10;
+
+#[derive(Serialize, Debug)]
+pub struct PagedData<T> {
+    total_size: u32,
+    page_size: u32,
+    page_number: u32,
+    data: Vec<T>,
+}
+
 #[tauri::command]
-pub async fn get_all(state: tauri::State<'_, Mutex<AppState>>) -> Result<Vec<MetadataDto>, Error> {
+pub async fn init_cache(state: tauri::State<'_, Mutex<AppState>>) -> Result<(), Error> {
     let state = state.lock().await;
 
-    let projects = Metadata::all_from_db(&state.db)
-        .await?
-        .into_iter()
-        .map(Into::into)
-        .collect();
+    let files = state.config_handler.files();
+    for file in files {
+        Metadata::from_file(file)?.write_to_db(&state.db).await?;
+    }
 
-    Ok(projects)
+    let dirs = state.config_handler.dirs();
+    for dir in dirs {
+        let files = MetadataHandler::search_directory(dir)?;
+        for file in &files {
+            Metadata::from_file(file)?.write_to_db(&state.db).await?;
+        }
+    }
+
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn get_all(
+    page_number: u32,
+    query: Option<String>,
+    state: tauri::State<'_, Mutex<AppState>>,
+) -> Result<PagedData<MetadataPreview>, Error> {
+    let state = state.lock().await;
+
+    let projects = Metadata::all_preview_from_db(
+        Some(Pagination::new(page_number, PAGE_SIZE)),
+        query.clone(),
+        &state.db,
+    )
+    .await?;
+
+    Ok(PagedData {
+        total_size: Metadata::amount_cached(query, &state.db).await?,
+        page_size: PAGE_SIZE,
+        page_number,
+        data: projects,
+    })
 }
 
 #[tauri::command]
@@ -44,18 +86,18 @@ pub async fn update_metadata(
 
     let metadata = updated.update(metadata)?;
 
-    metadata.write_to_db(&state.db).await?;
+    metadata.update_in_db(&state.db).await?;
     metadata.write_file(&metadata.directory)?;
 
     Ok(metadata.into())
 }
 
 #[tauri::command]
 pub async fn create_metadata(
-    new: MetadataDco,
+    created: MetadataDco,
     state: tauri::State<'_, Mutex<AppState>>,
-) -> Result<MetadataDto, Error> {
-    let metadata = new.create()?;
+) -> Result<Uuid, Error> {
+    let metadata = created.create()?;
 
     let mut state = state.lock().await;
 
@@ -66,7 +108,7 @@ pub async fn create_metadata(
     state.config_handler.add_saved_file(&metadata.directory);
     state.config_handler.save_config()?;
 
-    Ok(metadata.into())
+    Ok(metadata.id)
 }
 
 #[tauri::command]

episko_gui_backend/src/lib.rs

@@ -3,19 +3,15 @@
 use episko_lib::{
     config::ConfigHandler,
     database::DatabaseHandler,
-    files::File as _,
-    metadata::{
-        Metadata,
-        metadata_handler::MetadataHandler,
-    },
 };
 use state::AppState;
 use tauri::Manager;
 use tokio::sync::Mutex;
 
 mod commands;
 use commands::{
-    create_metadata, get_all, get_with_id, load_from_directory, load_from_file, update_metadata,
+    create_metadata, get_all, get_with_id, init_cache, load_from_directory, load_from_file,
+    update_metadata,
 };
 
 pub mod model;
@@ -35,19 +31,6 @@ pub async fn run() -> Result<(), Box<dyn std::error::Error>> {
 
     let db = DatabaseHandler::with_config(config_handler.config()).await?;
 
-    let files = config_handler.files();
-    for file in files {
-        Metadata::from_file(file)?.write_to_db(&db).await?;
-    }
-
-    let dirs = config_handler.dirs();
-    for dir in dirs {
-        let files = MetadataHandler::search_directory(dir)?;
-        for file in &files {
-            Metadata::from_file(file)?.write_to_db(&db).await?;
-        }
-    }
-
     tauri::async_runtime::set(tokio::runtime::Handle::current());
 
     tauri::Builder::default()
@@ -58,6 +41,7 @@ pub async fn run() -> Result<(), Box<dyn std::error::Error>> {
         })
         .plugin(tauri_plugin_shell::init())
         .invoke_handler(tauri::generate_handler![
+            init_cache,
             get_all,
             get_with_id,
             update_metadata,

episko_gui_backend/src/model/dco.rs

@@ -1,6 +1,8 @@
 use episko_lib::{
+    metadata::{
+        property::Property, BuildSystem, Category, Ide, Language, Metadata, MetadataBuilder,
+    },
     ApplyIf as _,
-    metadata::{BuildSystem, Category, Ide, Language, Metadata, MetadataBuilder},
 };
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
@@ -26,7 +28,12 @@ impl MetadataDco {
     ///
     /// # Errors
     /// !TODO!
-    pub fn create(self) -> Result<Metadata, Error> {
+    pub fn create(mut self) -> Result<Metadata, Error> {
+        self.categories.iter_mut().for_each(Property::update_id);
+        self.build_systems.iter_mut().for_each(Property::update_id);
+        self.languages.iter_mut().for_each(Property::update_id);
+        self.preffered_ide.iter_mut().for_each(Property::update_id);
+
         Ok(Metadata::builder()
             .directory_path(&self.directory)
             .title(&self.title)
@@ -46,7 +53,12 @@ impl MetadataDco {
     ///
     /// # Errors
     /// !TODO!
-    pub fn update(self, metadata: Metadata) -> Result<Metadata, Error> {
+    pub fn update(mut self, metadata: Metadata) -> Result<Metadata, Error> {
+        self.categories.iter_mut().for_each(Property::update_id);
+        self.build_systems.iter_mut().for_each(Property::update_id);
+        self.languages.iter_mut().for_each(Property::update_id);
+        self.preffered_ide.iter_mut().for_each(Property::update_id);
+
         Ok(metadata
             .update()
             .directory_path(&self.directory)
@@ -68,7 +80,7 @@ impl MetadataDco {
 mod tests {
     use super::*;
     use episko_lib::metadata::{
-        BuildSystem, Category, Ide, Language, Metadata, property::Property as _,
+        property::Property as _, BuildSystem, Category, Ide, Language, Metadata,
     };
     use std::path::PathBuf;
 

episko_gui_backend/src/model/dto.rs

@@ -47,7 +47,7 @@ mod tests {
     use super::*;
     use chrono::Utc;
     use episko_lib::metadata::{
-        BuildSystem, Category, Ide, Language, Metadata, property::Property as _,
+        property::Property as _, BuildSystem, Category, Ide, Language, Metadata,
     };
     use uuid::Uuid;
 

episko_lib/src/database.rs

@@ -78,22 +78,89 @@ pub enum Error {
 }
 
 #[cfg(test)]
-pub async fn setup_db() -> DatabaseHandler {
-    use sqlx::migrate::Migrator;
-    static MIGRATOR: Migrator = sqlx::migrate!();
+pub mod db_test {
+    use std::collections::HashSet;
 
-    let db = DatabaseHandler::new("sqlite://").await.unwrap();
-    MIGRATOR.run(db.conn()).await.unwrap();
+    use super::*;
+    use crate::{
+        ApplyIf as _,
+        metadata::{Metadata, property::Property as _, *},
+    };
+    use chrono::{TimeDelta, Utc};
+
+    pub async fn fill_db(amount: usize, db: &DatabaseHandler) {
+        let test_data = generate_test_metadata(amount);
+
+        for el in test_data {
+            el.write_to_db(db).await.expect("writing test data");
+        }
+    }
+
+    pub fn generate_test_metadata(count: usize) -> Vec<Metadata> {
+        let base_time = Utc::now();
+        let ides = ["VSCode", "IntelliJ", "Sublime", "Vim"];
+        let categories = ["Web", "CLI", "GUI", "Embedded", "AI"];
+        let languages = ["Rust", "Python", "JavaScript", "Go", "C++"];
+        let build_systems = ["Cargo", "Make", "CMake", "NPM", "Bazel"];
+
+        (0..count)
+            .map(|i| {
+                let offset = TimeDelta::try_days(i as i64).unwrap();
+
+                Metadata::builder()
+                    .title(&format!("Test Project {}", i + 1))
+                    .directory(".")
+                    .apply_if(
+                        Some(categories[i % categories.len()]),
+                        MetadataBuilder::add_category,
+                    )
+                    .add_language(Language::with_version(
+                        languages[i % languages.len()],
+                        &format!("1.{}", i),
+                    ))
+                    .apply_if(
+                        (i % 2 == 0).then_some(Ide::new(ides[i % ides.len()])),
+                        MetadataBuilder::preffered_ide,
+                    )
+                    .add_build_system(BuildSystem::with_version(
+                        build_systems[i % build_systems.len()],
+                        &format!("2.{}", i),
+                    ))
+                    .apply_if(
+                        (i % 3 == 0).then_some("Sample description"),
+                        MetadataBuilder::description,
+                    )
+                    .apply_if(
+                        (i % 4 == 0).then_some("https://github.com/example/project"),
+                        MetadataBuilder::repository_url,
+                    )
+                    .created(base_time - offset)
+                    .updated(base_time)
+                    .build()
+                    .expect("Should generate valid metadata")
+            })
+            .collect()
+    }
 
-    db
+    #[test]
+    fn test_generated_metadata() {
+        let test_data = generate_test_metadata(5);
+        assert_eq!(test_data.len(), 5);
+
+        let ids: HashSet<Uuid> = test_data.iter().map(|m| m.id).collect();
+        assert_eq!(ids.len(), 5);
+    }
 }
 
 #[cfg(test)]
 mod test {
-    use super::*;
+    use sqlx::SqlitePool;
+
+    use crate::database::{DatabaseHandler, db_test::fill_db};
 
-    #[tokio::test]
-    async fn setup_test_db() {
-        setup_db().await;
+    #[sqlx::test]
+    async fn setup_test_db(conn: SqlitePool) {
+        let db = DatabaseHandler::with_conn(conn);
+        fill_db(25, &db).await;
     }
 }