feat: phase 2

Newfound motivation

rust/src/cmd.rs

@@ -1,81 +1,108 @@
 use log;
+use std::collections::HashMap;
 use std::path::PathBuf;
 use tokio::sync::Mutex;
 
-use crate::pkg_remote;
-use crate::pkg_local;
+use crate::pkg::{Package, PkgKey};
+use crate::pkg_store::InstallResult;
 use crate::profile::Profile;
-use crate::AppData;
-use crate::model::Package;
+use crate::appdata::AppData;
+use crate::{liner, start};
 
 use tauri::State;
 
 #[tauri::command]
-pub async fn startline(
-    state: State<'_, Mutex<AppData>>,
-) -> Result<Option<Profile>, ()> {
+pub async fn startline(state: State<'_, Mutex<AppData>>) -> Result<(), String> {
     log::debug!("invoke: startline");
 
     let appd = state.lock().await;
 
-    Ok(appd.profile.clone())
-}
-
-#[tauri::command]
-pub async fn download_package(pkg: Package) -> Result<(), String> {
-    log::debug!("invoke: download_package");
-
-    pkg_remote::download_package(pkg).await.map_err(|e| e.to_string())
-}
-
-#[tauri::command]
-pub async fn delete_package(namespace: String, name: String) -> Result<(), String> {
-    log::debug!("invoke: download_package");
-
-    pkg_local::delete_package(namespace, name).await.map_err(|e| e.to_string())
-}
-
-#[tauri::command]
-pub async fn reload_packages(state: State<'_, tokio::sync::Mutex<AppData>>) -> Result<(), String> {
-    log::debug!("invoke: reload_packages");
-
-    let mut appd = state.lock().await;
-    // todo: this should only fetch new things
-    match pkg_local::walk_packages(false).await {
-        Ok(m) => {
-            appd.mods_local = m;
-            Ok(())
-        }
-        Err(e) => {
-            Err(e.to_string())
-        }
+    if let Some(p) = &appd.profile {
+        // TODO if p.needsUpdate
+        liner::line_up(p).await.expect("Line-up failed");
+        start::start(p).map_err(|e| e.to_string()).map(|_| ())
+        //Ok(())
+    } else {
+        Err("No profile".to_owned())
     }
 }
 
 #[tauri::command]
-pub async fn get_packages(state: State<'_, Mutex<AppData>>) -> Result<Vec<Package>, ()> {
-    log::debug!("invoke: get_packages");
+pub async fn install_package(state: State<'_, tokio::sync::Mutex<AppData>>, key: PkgKey) -> Result<InstallResult, String> {
+    log::debug!("invoke: install_package");
+
+    let mut appd = state.lock().await;
+    let rv = appd.pkgs.install_package(&key, true)
+        .await
+        .map_err(|e| e.to_string());
+
+
+    // if rv.is_ok() {
+    //     _ = appd.toggle_package(key, true);
+    // }
+
+    rv
+}
+
+#[tauri::command]
+pub async fn delete_package(state: State<'_, tokio::sync::Mutex<AppData>>, key: PkgKey) -> Result<(), String> {
+    log::debug!("invoke: delete_package");
+
+    let mut appd = state.lock().await;
+    appd.pkgs.delete_package(&key, true)
+        .await
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+pub async fn get_package(state: State<'_, tokio::sync::Mutex<AppData>>, key: PkgKey) -> Result<Package, String> {
+    log::debug!("invoke: get_package");
+
+    let appd = state.lock().await;
+    appd.pkgs.get(key)
+        .map_err(|e| e.to_string())
+        .cloned()
+}
+
+#[tauri::command]
+pub async fn toggle_package(state: State<'_, tokio::sync::Mutex<AppData>>, key: PkgKey, enable: bool) -> Result<(), String> {
+    log::debug!("invoke: toggle_package");
+
+    let mut appd = state.lock().await;
+    appd.toggle_package(key, enable)
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+pub async fn reload_all_packages(state: State<'_, tokio::sync::Mutex<AppData>>) -> Result<(), String> {
+    log::debug!("invoke: reload_all_packages");
+
+    let mut appd = state.lock().await;
+    appd.pkgs.reload_all()
+        .await
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+pub async fn get_all_packages(state: State<'_, Mutex<AppData>>) -> Result<HashMap<PkgKey, Package>, ()> {
+    log::debug!("invoke: get_all_packages");
 
     let appd = state.lock().await;
 
-    Ok(appd.mods_local.clone())
+    Ok(appd.pkgs.get_all())
 }
 
 #[tauri::command]
-pub async fn get_listings(state: State<'_, Mutex<AppData>>) -> Result<Vec<Package>, String> {
-    log::debug!("invoke: get_listings");
+pub async fn fetch_listings(state: State<'_, Mutex<AppData>>) -> Result<(), String> {
+    log::debug!("invoke: fetch_listings");
 
     let mut appd = state.lock().await;
-    match pkg_remote::get_listings(&mut appd).await {
-        Ok(l) => Ok(l.clone()),
-        Err(e) => Err(e.to_string())
-    }
+    appd.pkgs.fetch_listings().await
+        .map_err(|e| e.to_string())
 }
 
 #[tauri::command]
-pub async fn get_current_profile(
-    state: State<'_, Mutex<AppData>>,
-) -> Result<Option<Profile>, ()> {
+pub async fn get_current_profile(state: State<'_, Mutex<AppData>>) -> Result<Option<Profile>, ()> {
     log::debug!("invoke: get_current_profile");
 
     let appd = state.lock().await;
@@ -83,9 +110,7 @@ pub async fn get_current_profile(
 }
 
 #[tauri::command]
-pub async fn save_profile(
-    state: State<'_, Mutex<AppData>>
-) -> Result<(), ()> {
+pub async fn save_profile(state: State<'_, Mutex<AppData>>) -> Result<(), ()> {
     log::debug!("invoke: save_profile");
 
     let appd = state.lock().await;
@@ -101,7 +126,7 @@ pub async fn save_profile(
 #[tauri::command]
 pub async fn init_profile(
     state: State<'_, Mutex<AppData>>,
-    path: PathBuf
+    path: PathBuf,
 ) -> Result<Profile, String> {
     log::debug!("invoke: init_profile");
 
@@ -112,4 +137,4 @@ pub async fn init_profile(
     appd.profile = Some(new_profile.clone());
 
     Ok(new_profile)
-}
+}