Initial commit: Momentry Studio v0.1.0

src-tauri/src/main.rs

@@ -0,0 +1,200 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+use serde::Serialize;
+
+#[derive(Serialize)]
+struct SearchResult {
+    file_uuid: String,
+    start_time: f64,
+    end_time: f64,
+    summary: String,
+    similarity: f64,
+    file_name: Option<String>,
+}
+
+#[derive(Serialize)]
+struct FileInfo {
+    file_uuid: String,
+    file_name: String,
+    file_size: i64,
+    modified_time: String,
+    is_registered: bool,
+}
+
+#[derive(Serialize)]
+struct PersonInfo {
+    identity_uuid: String,
+    name: String,
+}
+
+#[derive(Serialize)]
+struct FaceInfo {
+    id: i64,
+    file_uuid: String,
+    frame_number: i64,
+    confidence: f64,
+}
+
+#[derive(Serialize)]
+struct TraceInfo {
+    trace_id: i32,
+    file_uuid: String,
+    first_sec: f64,
+    last_sec: f64,
+    avg_confidence: f64,
+    frame_count: i64,
+}
+
+const CORE_API: &str = "http://localhost:3002";
+const API_KEY: &str = "muser_68600856036340bcafc01930eb4bd839_1774418104_97221b69";
+
+#[tauri::command]
+async fn search_llm_smart(query: String, limit: usize) -> Result<Vec<SearchResult>, String> {
+    let client = reqwest::Client::new();
+    let url = format!("{}/api/v1/search/llm-smart?api_key={}", CORE_API, API_KEY);
+    
+    let response = client
+        .post(&url)
+        .json(&serde_json::json!({"query": query, "limit": limit}))
+        .send()
+        .await
+        .map_err(|e| format!("Request failed: {}", e))?;
+    
+    let json: serde_json::Value = response
+        .json()
+        .await
+        .map_err(|e| format!("Parse failed: {}", e))?;
+    
+    let results: Vec<SearchResult> = json["results"]
+        .as_array()
+        .unwrap_or(&vec![])
+        .iter()
+        .filter_map(|r| {
+            Some(SearchResult {
+                file_uuid: r["file_uuid"].as_str()?.to_string(),
+                start_time: r["start_time"].as_f64()?,
+                end_time: r["end_time"].as_f64()?,
+                summary: r["summary"].as_str()?.to_string(),
+                similarity: r["similarity"].as_f64().unwrap_or(0.0),
+                file_name: r["file_name"].as_str().map(|s| s.to_string()),
+            })
+        })
+        .collect();
+    
+    Ok(results)
+}
+
+#[tauri::command]
+async fn get_files(page_size: usize) -> Result<Vec<FileInfo>, String> {
+    let client = reqwest::Client::new();
+    let url = format!("{}/api/v1/files/scan?api_key={}&page_size={}", CORE_API, API_KEY, page_size);
+    
+    let response = client.get(&url).send().await.map_err(|e| format!("Request failed: {}", e))?;
+    let json: serde_json::Value = response.json().await.map_err(|e| format!("Parse failed: {}", e))?;
+    
+    let files: Vec<FileInfo> = json["files"]
+        .as_array()
+        .unwrap_or(&vec![])
+        .iter()
+        .filter_map(|f| {
+            Some(FileInfo {
+                file_uuid: f["file_uuid"].as_str()?.to_string(),
+                file_name: f["file_name"].as_str()?.to_string(),
+                file_size: f["file_size"].as_i64().unwrap_or(0),
+                modified_time: f["modified_time"].as_str().unwrap_or("").to_string(),
+                is_registered: f["is_registered"].as_bool().unwrap_or(false),
+            })
+        })
+        .collect();
+    
+    Ok(files)
+}
+
+#[tauri::command]
+async fn get_people(page: usize, per_page: usize) -> Result<Vec<PersonInfo>, String> {
+    let client = reqwest::Client::new();
+    let url = format!("{}/api/v1/identities?api_key={}&page={}&per_page={}", CORE_API, API_KEY, page, per_page);
+    
+    let response = client.get(&url).send().await.map_err(|e| format!("Request failed: {}", e))?;
+    let json: serde_json::Value = response.json().await.map_err(|e| format!("Parse failed: {}", e))?;
+    
+    let people: Vec<PersonInfo> = json["identities"]
+        .as_array()
+        .unwrap_or(&vec![])
+        .iter()
+        .filter_map(|i| {
+            Some(PersonInfo {
+                identity_uuid: i["identity_uuid"].as_str()?.to_string(),
+                name: i["name"].as_str()?.to_string(),
+            })
+        })
+        .collect();
+    
+    Ok(people)
+}
+
+#[tauri::command]
+async fn get_faces(uuid: String, per_page: usize) -> Result<Vec<FaceInfo>, String> {
+    let client = reqwest::Client::new();
+    let url = format!("{}/api/v1/identity/{}/faces?api_key={}&page_size={}", CORE_API, uuid, API_KEY, per_page);
+    
+    let response = client.get(&url).send().await.map_err(|e| format!("Request failed: {}", e))?;
+    let json: serde_json::Value = response.json().await.map_err(|e| format!("Parse failed: {}", e))?;
+    
+    let faces: Vec<FaceInfo> = json["faces"]
+        .as_array()
+        .unwrap_or(&vec![])
+        .iter()
+        .filter_map(|f| {
+            Some(FaceInfo {
+                id: f["id"].as_i64().unwrap_or(0),
+                file_uuid: f["file_uuid"].as_str()?.to_string(),
+                frame_number: f["frame_number"].as_i64().unwrap_or(0),
+                confidence: f["confidence"].as_f64().unwrap_or(0.0),
+            })
+        })
+        .collect();
+    
+    Ok(faces)
+}
+
+#[tauri::command]
+async fn get_traces(uuid: String, per_page: usize) -> Result<Vec<TraceInfo>, String> {
+    let client = reqwest::Client::new();
+    let url = format!("{}/api/v1/identity/{}/traces?api_key={}&page_size={}", CORE_API, uuid, API_KEY, per_page);
+    
+    let response = client.get(&url).send().await.map_err(|e| format!("Request failed: {}", e))?;
+    let json: serde_json::Value = response.json().await.map_err(|e| format!("Parse failed: {}", e))?;
+    
+    let traces: Vec<TraceInfo> = json["traces"]
+        .as_array()
+        .unwrap_or(&vec![])
+        .iter()
+        .filter_map(|t| {
+            Some(TraceInfo {
+                trace_id: t["trace_id"].as_i64().unwrap_or(0) as i32,
+                file_uuid: t["file_uuid"].as_str()?.to_string(),
+                first_sec: t["first_sec"].as_f64().unwrap_or(0.0),
+                last_sec: t["last_sec"].as_f64().unwrap_or(0.0),
+                avg_confidence: t["avg_confidence"].as_f64().unwrap_or(0.0),
+                frame_count: t["frame_count"].as_i64().unwrap_or(0),
+            })
+        })
+        .collect();
+    
+    Ok(traces)
+}
+
+fn main() {
+    tauri::Builder::default()
+        .plugin(tauri_plugin_shell::init())
+        .invoke_handler(tauri::generate_handler![
+            search_llm_smart,
+            get_files,
+            get_people,
+            get_faces,
+            get_traces
+        ])
+        .run(tauri::generate_context!())
+        .expect("error while running tauri application");
+}