A bunch more small things

src-tauri/src/main.rs

@@ -21,9 +21,10 @@ use tauri::{AppHandle, State, Wry};
 use tauri::{CustomMenuItem, Manager, SystemTray, SystemTrayEvent, SystemTrayMenu, WindowEvent};
 use tokio::sync::Mutex;
 
-use crate::models::{create_workspace, find_workspaces, Request, Workspace};
 use window_ext::WindowExt;
 
+use crate::models::HttpRequestHeader;
+
 mod models;
 mod runtime;
 mod window_ext;
@@ -54,15 +55,17 @@ async fn load_db(db_instance: State<'_, Mutex<Pool<Sqlite>>>) -> Result<(), Stri
 async fn send_request(
     app_handle: AppHandle<Wry>,
     db_instance: State<'_, Mutex<Pool<Sqlite>>>,
-    url: &str,
-    method: &str,
-    body: Option<&str>,
-) -> Result<CustomResponse, String> {
+    request_id: &str,
+) -> Result<models::HttpResponse, String> {
+    let pool = &*db_instance.lock().await;
+    let req = models::get_request(request_id, pool)
+        .await
+        .expect("Failed to get request");
     let start = std::time::Instant::now();
 
-    let mut abs_url = url.to_string();
+    let mut abs_url = req.url.to_string();
     if !abs_url.starts_with("http://") && !abs_url.starts_with("https://") {
-        abs_url = format!("http://{}", url);
+        abs_url = format!("http://{}", req.url);
     }
 
     let client = reqwest::Client::builder()
@@ -78,24 +81,16 @@ async fn send_request(
         HeaderValue::from_static("123-123-123"),
     );
 
-    let m = Method::from_bytes(method.to_uppercase().as_bytes()).unwrap();
+    let m = Method::from_bytes(req.method.to_uppercase().as_bytes()).unwrap();
     let builder = client.request(m, abs_url.to_string()).headers(headers);
 
-    let req = match body {
-        Some(b) => builder.body(b.to_string()).build(),
+    let sendable_req = match req.body {
+        Some(b) => builder.body(b).build(),
         None => builder.build(),
-    };
+    }
+    .expect("Failed to build request");
 
-    let req = match req {
-        Ok(v) => v,
-        Err(e) => {
-            println!("Error: {}", e);
-            return Err(e.to_string());
-        }
-    };
-
-    let resp = client.execute(req).await;
-    let elapsed = start.elapsed().as_millis();
+    let resp = client.execute(sendable_req).await;
 
     let p = app_handle
         .path_resolver()
@@ -106,27 +101,33 @@ async fn send_request(
 
     match resp {
         Ok(v) => {
-            let url = v.url().to_string();
-            let status = v.status().as_u16();
+            let status = v.status().as_u16() as i64;
             let status_reason = v.status().canonical_reason();
-            let method = method.to_string();
             let headers = v
                 .headers()
                 .iter()
-                .map(|(k, v)| (k.as_str().to_string(), v.to_str().unwrap().to_string()))
-                .collect::<HashMap<String, String>>();
-            let body = v.text().await.unwrap();
-            let elapsed2 = start.elapsed().as_millis();
-            Ok(CustomResponse {
+                .map(|(k, v)| models::HttpResponseHeader {
+                    name: k.as_str().to_string(),
+                    value: v.to_str().unwrap().to_string(),
+                })
+                .collect();
+            let url = v.url().clone();
+            let body = v.text().await.expect("Failed to get body");
+            let elapsed = start.elapsed().as_millis() as i64;
+            let response = models::create_response(
+                &req.id,
+                elapsed,
+                url.as_str(),
                 status,
                 status_reason,
-                body,
-                elapsed,
-                elapsed2,
-                method,
-                url,
+                body.as_str(),
                 headers,
-            })
+                pool,
+            )
+            .await
+            .expect("Failed to create response");
+
+            Ok(response)
         }
         Err(e) => {
             println!("Error: {}", e);
@@ -140,27 +141,23 @@ async fn upsert_request(
     id: Option<&str>,
     workspace_id: &str,
     name: &str,
+    url: &str,
+    body: Option<&str>,
+    headers: Vec<HttpRequestHeader>,
+    method: &str,
     db_instance: State<'_, Mutex<Pool<Sqlite>>>,
-) -> Result<Request, String> {
+) -> Result<models::HttpRequest, String> {
     let pool = &*db_instance.lock().await;
-    models::upsert_request(
-        id,
-        workspace_id,
-        name,
-        "GET",
-        None,
-        "https://google.com",
-        pool,
-    )
-    .await
-    .map_err(|e| e.to_string())
+    models::upsert_request(id, workspace_id, name, method, body, url, headers, pool)
+        .await
+        .map_err(|e| e.to_string())
 }
 
 #[tauri::command]
 async fn requests(
     workspace_id: &str,
     db_instance: State<'_, Mutex<Pool<Sqlite>>>,
-) -> Result<Vec<Request>, String> {
+) -> Result<Vec<models::HttpRequest>, String> {
     let pool = &*db_instance.lock().await;
     models::find_requests(workspace_id, pool)
         .await
@@ -168,13 +165,48 @@ async fn requests(
 }
 
 #[tauri::command]
-async fn workspaces(db_instance: State<'_, Mutex<Pool<Sqlite>>>) -> Result<Vec<Workspace>, String> {
+async fn responses(
+    request_id: &str,
+    db_instance: State<'_, Mutex<Pool<Sqlite>>>,
+) -> Result<Vec<models::HttpResponse>, String> {
     let pool = &*db_instance.lock().await;
-    let workspaces = find_workspaces(pool)
+    models::find_responses(request_id, pool)
+        .await
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+async fn delete_response(
+    id: &str,
+    db_instance: State<'_, Mutex<Pool<Sqlite>>>,
+) -> Result<(), String> {
+    let pool = &*db_instance.lock().await;
+    models::delete_response(id, pool)
+        .await
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+async fn delete_all_responses(
+    request_id: &str,
+    db_instance: State<'_, Mutex<Pool<Sqlite>>>,
+) -> Result<(), String> {
+    let pool = &*db_instance.lock().await;
+    models::delete_all_responses(request_id, pool)
+        .await
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+async fn workspaces(
+    db_instance: State<'_, Mutex<Pool<Sqlite>>>,
+) -> Result<Vec<models::Workspace>, String> {
+    let pool = &*db_instance.lock().await;
+    let workspaces = models::find_workspaces(pool)
         .await
         .expect("Failed to find workspaces");
     if workspaces.is_empty() {
-        let workspace = create_workspace("Default", "This is the default workspace", pool)
+        let workspace = models::create_workspace("Default", "This is the default workspace", pool)
             .await
             .expect("Failed to create workspace");
         Ok(vec![workspace])
@@ -205,7 +237,7 @@ fn main() {
             let dir = app.path_resolver().app_data_dir().unwrap();
             create_dir_all(dir.clone()).expect("Problem creating App directory!");
             let p = dir.join("db.sqlite");
-            let p_string = p.to_string_lossy().replace(" ", "%20");
+            let p_string = p.to_string_lossy().replace(' ', "%20");
             let url = format!("sqlite://{}?mode=rwc", p_string);
             println!("DB PATH: {}", p_string);
             tauri::async_runtime::block_on(async move {
@@ -244,12 +276,15 @@ fn main() {
             }
         })
         .invoke_handler(tauri::generate_handler![
-            send_request,
             greet,
             load_db,
             workspaces,
             requests,
+            send_request,
             upsert_request,
+            responses,
+            delete_response,
+            delete_all_responses,
         ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");