Added web ui

src/web.rs

@@ -1,9 +1,7 @@
 use actix_web::{web, HttpResponse, Result};
 use log::info;
 use rust_embed::RustEmbed;
-use serde::{Deserialize, Serialize};
 use serde_json::json;
-use std::collections::HashSet;
 use tokio_postgres::Client;
 
 use crate::server::{get_keys_from_db, Flows};
@@ -12,19 +10,13 @@ use crate::server::{get_keys_from_db, Flows};
 #[folder = "static/"]
 struct StaticAssets;
 
-#[derive(Deserialize)]
-struct DeleteKeyPath {
-    flow_id: String,
-    server: String,
-}
-
 // API endpoint to get list of available flows
 pub async fn get_flows_api(allowed_flows: web::Data<Vec<String>>) -> Result<HttpResponse> {
     info!("API request for available flows");
     Ok(HttpResponse::Ok().json(&**allowed_flows))
 }
 
-// API endpoint to delete a specific key by server name
+// API endpoint to deprecate a specific key by server name
 pub async fn delete_key_by_server(
     flows: web::Data<Flows>,
     path: web::Path<(String, String)>,
@@ -33,7 +25,7 @@ pub async fn delete_key_by_server(
 ) -> Result<HttpResponse> {
     let (flow_id_str, server_name) = path.into_inner();
 
-    info!("API request to delete key for server '{}' in flow '{}'", server_name, flow_id_str);
+    info!("API request to deprecate key for server '{}' in flow '{}'", server_name, flow_id_str);
 
     if !allowed_flows.contains(&flow_id_str) {
         return Ok(HttpResponse::Forbidden().json(json!({
@@ -41,11 +33,119 @@ pub async fn delete_key_by_server(
         })));
     }
 
-    // Delete from database
-    match delete_key_from_db(&db_client, &server_name, &flow_id_str).await {
+    // Deprecate in database
+    match crate::db::deprecate_key_by_server(&db_client, &server_name, &flow_id_str).await {
+        Ok(deprecated_count) => {
+            if deprecated_count > 0 {
+                info!("Deprecated {} key(s) for server '{}' in flow '{}'", deprecated_count, server_name, flow_id_str);
+                
+                // Refresh the in-memory flows
+                let updated_flows = match get_keys_from_db(&db_client).await {
+                    Ok(flows) => flows,
+                    Err(e) => {
+                        return Ok(HttpResponse::InternalServerError().json(json!({
+                            "error": format!("Failed to refresh flows: {}", e)
+                        })));
+                    }
+                };
+
+                let mut flows_guard = flows.lock().unwrap();
+                *flows_guard = updated_flows;
+
+                Ok(HttpResponse::Ok().json(json!({
+                    "message": format!("Successfully deprecated {} key(s) for server '{}'", deprecated_count, server_name),
+                    "deprecated_count": deprecated_count
+                })))
+            } else {
+                Ok(HttpResponse::NotFound().json(json!({
+                    "error": format!("No keys found for server '{}'", server_name)
+                })))
+            }
+        }
+        Err(e) => {
+            Ok(HttpResponse::InternalServerError().json(json!({
+                "error": format!("Failed to deprecate key: {}", e)
+            })))
+        }
+    }
+}
+
+// API endpoint to restore a deprecated key
+pub async fn restore_key_by_server(
+    flows: web::Data<Flows>,
+    path: web::Path<(String, String)>,
+    db_client: web::Data<std::sync::Arc<Client>>,
+    allowed_flows: web::Data<Vec<String>>,
+) -> Result<HttpResponse> {
+    let (flow_id_str, server_name) = path.into_inner();
+
+    info!("API request to restore key for server '{}' in flow '{}'", server_name, flow_id_str);
+
+    if !allowed_flows.contains(&flow_id_str) {
+        return Ok(HttpResponse::Forbidden().json(json!({
+            "error": "Flow ID not allowed"
+        })));
+    }
+
+    // Restore in database
+    match crate::db::restore_key_by_server(&db_client, &server_name, &flow_id_str).await {
+        Ok(restored_count) => {
+            if restored_count > 0 {
+                info!("Restored {} key(s) for server '{}' in flow '{}'", restored_count, server_name, flow_id_str);
+                
+                // Refresh the in-memory flows
+                let updated_flows = match get_keys_from_db(&db_client).await {
+                    Ok(flows) => flows,
+                    Err(e) => {
+                        return Ok(HttpResponse::InternalServerError().json(json!({
+                            "error": format!("Failed to refresh flows: {}", e)
+                        })));
+                    }
+                };
+
+                let mut flows_guard = flows.lock().unwrap();
+                *flows_guard = updated_flows;
+
+                Ok(HttpResponse::Ok().json(json!({
+                    "message": format!("Successfully restored {} key(s) for server '{}'", restored_count, server_name),
+                    "restored_count": restored_count
+                })))
+            } else {
+                Ok(HttpResponse::NotFound().json(json!({
+                    "error": format!("No deprecated keys found for server '{}'", server_name)
+                })))
+            }
+        }
+        Err(e) => {
+            Ok(HttpResponse::InternalServerError().json(json!({
+                "error": format!("Failed to restore key: {}", e)
+            })))
+        }
+    }
+}
+
+// API endpoint to permanently delete a key
+pub async fn permanently_delete_key_by_server(
+    flows: web::Data<Flows>,
+    path: web::Path<(String, String)>,
+    db_client: web::Data<std::sync::Arc<Client>>,
+    allowed_flows: web::Data<Vec<String>>,
+) -> Result<HttpResponse> {
+    let (flow_id_str, server_name) = path.into_inner();
+
+    info!("API request to permanently delete key for server '{}' in flow '{}'", server_name, flow_id_str);
+
+    if !allowed_flows.contains(&flow_id_str) {
+        return Ok(HttpResponse::Forbidden().json(json!({
+            "error": "Flow ID not allowed"
+        })));
+    }
+
+    // Permanently delete from database
+    match crate::db::permanently_delete_key_by_server(&db_client, &server_name, &flow_id_str).await {
         Ok(deleted_count) => {
             if deleted_count > 0 {
-                info!("Deleted {} key(s) for server '{}' in flow '{}'", deleted_count, server_name, flow_id_str);
+                info!("Permanently deleted {} key(s) for server '{}' in flow '{}'", deleted_count, server_name, flow_id_str);
                 
                 // Refresh the in-memory flows
                 let updated_flows = match get_keys_from_db(&db_client).await {
@@ -78,68 +178,6 @@ pub async fn delete_key_by_server(
     }
 }
 
-// Helper function to delete a key from database
-async fn delete_key_from_db(
-    client: &Client,
-    server_name: &str,
-    flow_name: &str,
-) -> Result<u64, tokio_postgres::Error> {
-    // First, find the key_ids for the given server
-    let key_rows = client
-        .query("SELECT key_id FROM public.keys WHERE host = $1", &[&server_name])
-        .await?;
-
-    if key_rows.is_empty() {
-        return Ok(0);
-    }
-
-    let key_ids: Vec<i32> = key_rows.iter().map(|row| row.get::<_, i32>(0)).collect();
-
-    // Delete flow associations first
-    let mut flow_delete_count = 0;
-    for key_id in &key_ids {
-        let deleted = client
-            .execute(
-                "DELETE FROM public.flows WHERE name = $1 AND key_id = $2",
-                &[&flow_name, key_id],
-            )
-            .await?;
-        flow_delete_count += deleted;
-    }
-
-    // Check if any of these keys are used in other flows
-    let mut keys_to_delete = Vec::new();
-    for key_id in &key_ids {
-        let count: i64 = client
-            .query_one(
-                "SELECT COUNT(*) FROM public.flows WHERE key_id = $1",
-                &[key_id],
-            )
-            .await?
-            .get(0);
-
-        if count == 0 {
-            keys_to_delete.push(*key_id);
-        }
-    }
-
-    // Delete keys that are no longer referenced by any flow
-    let mut total_deleted = 0;
-    for key_id in keys_to_delete {
-        let deleted = client
-            .execute("DELETE FROM public.keys WHERE key_id = $1", &[&key_id])
-            .await?;
-        total_deleted += deleted;
-    }
-
-    info!(
-        "Deleted {} flow associations and {} orphaned keys for server '{}'",
-        flow_delete_count, total_deleted, server_name
-    );
-
-    Ok(std::cmp::max(flow_delete_count, total_deleted))
-}
-
 // Serve static files from embedded assets
 pub async fn serve_static_file(path: web::Path<String>) -> Result<HttpResponse> {
     let file_path = path.into_inner();