add current

Author: ericwang401

src-tauri/src/analyzer.rs

@@ -1,25 +1,36 @@
-use std::path::{Path, PathBuf};
+use crate::commands::{ProgressCallback, ProgressUpdate};
+use crate::serializer::Dataset;
 use anyhow::anyhow;
+use std::path::{Path, PathBuf};
 use tokio::fs::remove_file;
 use tokio::process::Command;
-use crate::serializer::Dataset;
 
-
-pub async fn analyze_all(deps_dir: &Path, data_dir: &Path, datasets: &Vec<Dataset>) -> anyhow::Result<Vec<(PathBuf, u64)>> {
+pub async fn analyze_all(
+    deps_dir: &Path,
+    data_dir: &Path,
+    datasets: &Vec<Dataset>,
+    progress_callback: &ProgressCallback,
+) -> anyhow::Result<Vec<(PathBuf, u64)>> {
     let mut results = vec![];
 
     for dataset in datasets {
         let result = analyze(deps_dir, data_dir, dataset).await?;
         results.push(result);
+        progress_callback(ProgressUpdate::Increment { iterations: 1 });
     }
 
     Ok(results)
 }
 
-async fn analyze(deps_dir: &Path, data_dir: &Path, dataset: &Dataset) -> anyhow::Result<(PathBuf, u64)> {
+async fn analyze(
+    deps_dir: &Path,
+    data_dir: &Path,
+    dataset: &Dataset,
+) -> anyhow::Result<(PathBuf, u64)> {
     let mut command = Command::new(deps_dir.join("SRM_Rate.exe")); // TODO: figure out lifetimes here
 
-    command.arg(dataset.heavy_water.to_str().unwrap())
+    command
+        .arg(dataset.heavy_water.to_str().unwrap())
         .arg(dataset.spreadsheet.to_str().unwrap());
 
     let input_file_name = dataset.spreadsheet.file_stem().unwrap().to_str().unwrap();
@@ -29,12 +40,22 @@ async fn analyze(deps_dir: &Path, data_dir: &Path, dataset: &Dataset) -> anyhow:
         .await
         .map_err(|err| anyhow!(format!("Command couldn't run: {err}")))?;
 
-    remove_file(&dataset.heavy_water).await.map_err(|err| anyhow!(format!("Couldn't delete heavy water file: {err}")))?;
-    remove_file(&dataset.spreadsheet).await.map_err(|err| anyhow!(format!("Couldn't delete spreadsheet file: {err}")))?;
+    remove_file(&dataset.heavy_water)
+        .await
+        .map_err(|err| anyhow!(format!("Couldn't delete heavy water file: {err}")))?;
+    remove_file(&dataset.spreadsheet)
+        .await
+        .map_err(|err| anyhow!(format!("Couldn't delete spreadsheet file: {err}")))?;
 
     if output.status.success() {
-        Ok((data_dir.join(format!("{input_file_name}.RateConst.csv")), dataset.samples_removed))
+        Ok((
+            data_dir.join(format!("{input_file_name}.RateConst.csv")),
+            dataset.samples_removed,
+        ))
     } else {
-        Err(anyhow!(format!("The command didn't complete successfully: {}", String::from_utf8_lossy(&output.stdout))))
+        Err(anyhow!(format!(
+            "The command didn't complete successfully: {}",
+            String::from_utf8_lossy(&output.stderr)
+        )))
     }
-}
+}

src-tauri/src/commands.rs

@@ -3,6 +3,7 @@ use std::path::Path;
 use futures::future::join_all;
 use reqwest::Client;
 use tauri::api::dialog::blocking::FileDialogBuilder;
+use tauri::Manager;
 use tokio::fs;
 use tokio::fs::create_dir;
 use crate::aggregator::aggregate;
@@ -14,35 +15,35 @@ use crate::processor::process_file;
 use crate::serializer::{serialize, serialize_calculations};
 use tokio::task::{JoinHandle, JoinSet};
 
+pub enum ProgressUpdate {
+    Set {
+        iterations: usize,
+        total_iterations: Option<usize>,
+    },
+    Increment {
+        iterations: usize,
+    },
+}
 
-#[tauri::command]
-pub async fn install_dependencies(app_handle: tauri::AppHandle) -> Result<(), String> {
-    let dependencies_dir = app_handle
-        .path_resolver()
-        .app_local_data_dir()
-        .unwrap()
-        .join("dependencies");
-
-    if fs::try_exists(&dependencies_dir).await.unwrap() == true {
-        fs::remove_dir_all(&dependencies_dir)
-            .await
-            .map_err(|err| format!("Failed to remove existing dependencies: {err}"))?;
-    }
+pub type ProgressCallback = Box<dyn Fn(ProgressUpdate) + Send + Sync>;
 
-    let client = Client::new();
-    let response = client
-        .get("https://github.com/rgsadygov/SRM_executables/archive/refs/heads/main.zip")
-        .send()
-        .await
-        .map_err(|err| format!("Failed to download dependencies: {err}"))?
-        .bytes()
-        .await
-        .unwrap();
+#[derive(Clone, serde::Serialize)]
+struct ProgressSetPayload {
+    uuid: String,
+    iterations: usize,
+    total_iterations: Option<usize>,
+}
 
-    zip_extract::extract(Cursor::new(response), &dependencies_dir, true)
-        .map_err(|err| format!("Failed to extract dependencies: {err}"))?;
+#[derive(Clone, serde::Serialize)]
+struct ProgressIncrementPayload {
+    uuid: String,
+    iterations: usize,
+}
 
-    Ok(())
+#[derive(Clone, serde::Serialize)]
+struct ErrorPayload {
+    uuid: String,
+    message: String,
 }
 
 #[tauri::command]
@@ -54,7 +55,8 @@ pub async fn process_data(
     input_files: Vec<InputFile>,
 ) -> Result<(), String> {
     // TODO: https://tauri.app/v1/guides/features/events/
-    dbg!("is this running?");
+    dbg!("Run");
+    dbg!(&input_files);
 
     let deps_path = match engine_type {
         EngineType::Single =>
@@ -64,26 +66,63 @@ pub async fn process_data(
             .resolve_resource("assets").unwrap().join("multi-timepoint-engine"),
     };
 
+    let window = app.get_window("main").unwrap();
     let mut tasks: Vec<JoinHandle<anyhow::Result<()>>> = vec![];
-    dbg!("wtf");
-
 
     for input_file in input_files {
+        dbg!("hellno");
         let deps_path = deps_path.clone();
+        let window = window.clone();
+        let input_uuid = input_file.uuid.clone();
 
         let task = tokio::spawn(async move {
-            process_file(
+            let window2 = window.clone();
+            let progress_callback: ProgressCallback = Box::new(move |update| {
+                match update {
+                    ProgressUpdate::Set { iterations, total_iterations } => {
+                        let payload = ProgressSetPayload {
+                            uuid: input_uuid.clone(),
+                            iterations,
+                            total_iterations,
+                        };
+
+                        window2.emit("progress-set", payload).unwrap();
+                    }
+                    ProgressUpdate::Increment { iterations } => {
+                        let payload = ProgressIncrementPayload {
+                            uuid: input_uuid.clone(),
+                            iterations,
+                        };
+
+                        window2.emit("progress-update", payload).unwrap();
+                    }
+                }
+            });
+
+            let input_uuid = input_file.uuid.clone();
+
+            match process_file(
                 &deps_path,
                 should_remove_na_calculations,
                 tolerance_multiplier,
                 input_file,
-            ).await?;
-
-            dbg!("hello?");
-
-            Ok(())
+                progress_callback,
+            ).await {
+                Ok(()) => Ok(()),
+                Err(err) => {
+                    dbg!(&err);
+                    let payload = ErrorPayload {
+                        uuid: input_uuid,
+                        message: err.to_string(),
+                    };
+                    window.emit("process-error", payload).unwrap();
+                    Err(err)
+                }
+            }
         });
 
+        dbg!("hello yes");
+
         tasks.push(task);
     }
 

src-tauri/src/main.rs

@@ -13,7 +13,7 @@ mod lib;
 #[tokio::main]
 async fn main() {
   tauri::Builder::default()
-    .invoke_handler(tauri::generate_handler![commands::install_dependencies, commands::process_data])
+    .invoke_handler(tauri::generate_handler![commands::process_data])
     .run(tauri::generate_context!())
     .expect("error while running tauri application");
 }

src-tauri/src/processor.rs

@@ -3,6 +3,7 @@ use anyhow::anyhow;
 use tokio::fs::create_dir;
 use crate::aggregator::aggregate;
 use crate::analyzer::analyze_all;
+use crate::commands::{ProgressCallback, ProgressUpdate};
 use crate::grouper::{group_by_na_columns, group_by_peptides};
 use crate::parser::{InputFile, parse};
 use crate::serializer::{serialize, serialize_calculations};
@@ -12,7 +13,14 @@ pub async fn process_file(
     should_remove_na_calculations: bool,
     tolerance_multiplier: f64,
     input_file_path: InputFile,
+    progress_callback: ProgressCallback,
 ) -> anyhow::Result<()> {
+    dbg!("Run 2");
+    progress_callback(ProgressUpdate::Set {
+        iterations: 0,
+        total_iterations: Some(100),
+    });
+
     let temp_dir = tempfile::tempdir().map_err(|e| anyhow!(e.to_string()))?;
     let data_dir = temp_dir.path().join("data");
 
@@ -28,6 +36,10 @@ pub async fn process_file(
     ) = parse(input_file_path).await?;
 
     let groups = group_by_na_columns(group_by_peptides(tolerance_multiplier, peptides));
+    progress_callback(ProgressUpdate::Set {
+        iterations: 0,
+        total_iterations: Some(groups.len() * 2 + groups.len() / 10),
+    });
 
     let datasets = serialize(
         should_remove_na_calculations,
@@ -36,9 +48,10 @@ pub async fn process_file(
         mice,
         labels,
         groups,
+        &progress_callback,
     ).await.unwrap();
 
-    let calculations = analyze_all(&deps_dir, &data_dir, &datasets).await?;
+    let calculations = analyze_all(&deps_dir, &data_dir, &datasets, &progress_callback).await?;
     let calculations = aggregate(&calculations).await.map_err(|e| anyhow!(e.to_string()))?;
 
     let input_file_name = input_file_path
@@ -51,6 +64,11 @@ pub async fn process_file(
 
     serialize_calculations(&file_path, &calculations)?;
 
+    progress_callback(ProgressUpdate::Set {
+        iterations: 100,
+        total_iterations: Some(100),
+    });
+
     temp_dir.close().map_err(|e| anyhow!(e.to_string()))?;
 
     Ok(())

src-tauri/src/serializer.rs

@@ -5,7 +5,7 @@ use csv::Writer;
 use tokio::fs::File;
 use tokio::io::AsyncWriteExt;
 use crate::aggregator::Calculation;
-
+use crate::commands::{ProgressCallback, ProgressUpdate};
 use crate::grouper::NAGroup;
 use crate::parser::{Day, Label, Mouse, Peptide};
 
@@ -24,6 +24,7 @@ pub async fn serialize(
     mice: Vec<Mouse>,
     labels: Vec<Label>,
     groups: Vec<NAGroup>,
+    progress_callback: &ProgressCallback,
 ) -> anyhow::Result<Vec<Dataset>> {
     let mut datasets = vec![];
 
@@ -55,6 +56,10 @@ pub async fn serialize(
             heavy_water,
             samples_removed: columns_removed,
         });
+
+        progress_callback(ProgressUpdate::Increment {
+            iterations: 1,
+        });
     }
 
     Ok(datasets)

src/lib/components/interfaces/dashboard/InputData.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-    import { DocumentChartBar, Icon, XMark } from 'svelte-hero-icons'
+    import { DocumentChartBar, ExclamationCircle, Icon, XMark } from 'svelte-hero-icons'
     import type { InputFile } from '$lib/types/form'
     import { createEventDispatcher } from 'svelte'
 
@@ -12,8 +12,17 @@
 </script>
 
 <div class="flex items-center flex-nowrap pl-5 py-3 pr-4 w-full bg-muted first:rounded-t-md last:rounded-b-md">
-    <Icon src={DocumentChartBar} solid class="w-6 h-6 mr-2" />
-    <span class="truncate">{inputFile.path.name}</span>
+    {#if inputFile.errors}
+        <Icon src={ExclamationCircle} solid class="w-6 h-6 mr-2 text-destructive" />
+    {:else}
+        <Icon src={DocumentChartBar} solid class="w-6 h-6 mr-2" />
+    {/if}
+    <div>
+        <p class="truncate">{inputFile.path.name}</p>
+        {#if inputFile.errors}
+            <p class="truncate text-xs text-muted-foreground">{inputFile.errors}</p>
+        {/if}
+    </div>
     <div class="grow"></div>
     <button on:click={() => dispatch('delete')} class="h-full p-1 rounded-md hover:bg-card">
         <Icon src={XMark} class="w-5 h-5" />