Added return value to get_data

src/engines/kv.rs

@@ -1,26 +1,26 @@
 // TODO: Remove
 #![allow(dead_code)]
 
-// pub mod logic;
+pub mod logic;
 pub mod structs;
 
 // #[cfg(test)]
 // mod tests;
 
+use std::{collections::HashMap, convert::Infallible};
+
 use crate::{
-    engines::kv::{
+    engines::kv::{logic::body_to_json, structs::*},
-        logic::body_to_json,
-        structs::{KvSecret, SecretMeta},
-    },
     storage::DatabaseDriver,
 };
 use axum::{
     extract::{Path, State},
+    response::IntoResponse,
     routing::*,
-    Router,
+    Json, Router,
 };
-use log::{info, trace};
+use log::{info, error};
-use sqlx::{error::UnexpectedNullError, Row};
+use sqlx::Row;
 
 pub fn kv_router(pool: DatabaseDriver) -> Router {
     Router::new()
@@ -49,40 +49,41 @@ async fn post_config() -> &'static str {
     todo!("not implemented")
 }
 
-async fn get_data(State(pool): State<DatabaseDriver>, Path(path): Path<String>) -> &'static str {
+async fn get_data(
-    // SQL Anfrage gegen Path
+    State(pool): State<DatabaseDriver>,
+    Path(path): Path<String>,
+) -> Result<impl IntoResponse, Infallible> {
     match sqlx::query("SELECT * FROM secret_versions WHERE secret_path = $1")
         .bind(path)
         .fetch_one(&pool)
         .await
     {
         Ok(v) => {
-            let secret_data: String = v.get("secret_data");
+            let version: i64 = v.get("version_number");
-            let created_time: String = v.get("created_time");
+            let secret_content: HashMap<String, String> = HashMap::from([
-            let deletion_time: String = v.get("deletion_time");
+                ("secret_data".to_string(), v.get("secret_data")),
-            let version_number: i64 = v.get("version_number");
+                ("created_time".to_string(), v.get("created_time")),
-            let secret_path: String = v.get("secret_path");
+                ("deletion_time".to_string(), v.get("deletion_time")),
-            info!(
+                ("version_number".to_string(), version.to_string()),
-                "{:?}",
+                ("secret_path".to_string(), v.get("secret_path")),
-                (
+            ]);
-                    secret_data,
+            let return_secret = KvSecretReq {
-                    created_time,
+                data: secret_content,
-                    deletion_time,
+                options: None,
-                    version_number,
+            };
-                    secret_path
+            info!("{:?}", return_secret);
-                )
+
-            );
+            Ok(Json(return_secret))
-            // Handle returned data
-            return "Success";
         }
-        Err(e) => {
+        Err(e) => match e {
-            match e {
+            sqlx::Error::RowNotFound => {
-                sqlx::Error::RowNotFound => trace!("{:?}", e),
+                error!("{:?}", e);
+                let error_data: HashMap<String, String> = HashMap::from([("error".to_string(), "Secret not found".to_string())]);
+                let error_secret = KvSecretReq{data: error_data, options: None};
+                Ok(Json(error_secret))
+            },
             _ => panic!("{:?}", e),
-            }
+        },
-            info!("{:?}", e);
-            return "Error";
-        }
     }
 }
 
@@ -93,45 +94,45 @@ async fn post_data(
 ) -> &'static str {
     // Insert Metadata first -> Else: Error because of foreign key constraint
 
-    let mut body_json = body_to_json(body);
+    // let mut body_json = body_to_json(body);
 
-    let secret: KvSecret = KvSecret {
+    // let secret: KvSecret = KvSecret {
-        data: body_json["data"]["password1"].take().to_string(),
+    //     data: body_json["data"]["password1"].take().to_string(),
-        version: body_json["data"]["version"].take().as_i64(),
+    //     version: body_json["data"]["version"].take().as_i64(),
-    };
+    // };
-    log::debug!(
+    // log::debug!(
-        "Secret: {}, Content: {}, Version: {}, path: {}",
+    //     "Secret: {}, Content: {}, Version: {}, path: {}",
-        path,
+    //     path,
-        secret.data,
+    //     secret.data,
-        secret.version.unwrap_or(0),
+    //     secret.version.unwrap_or(0),
-        path
+    //     path
-    );
+    // );
 
-    let created_time = "05-03-2024 12:00:00";
+    // let created_time = "05-03-2024 12:00:00";
-    let deletion_time = "05-03-2024 12:00:00";
+    // let deletion_time = "05-03-2024 12:00:00";
-    let version = "0";
+    // let version = "0";
-    match sqlx::query!(
+    // match sqlx::query!(
-        "INSERT INTO secret_versions VALUES ($1, $2, $3, $4, $5)",
+    //     "INSERT INTO secret_versions VALUES ($1, $2, $3, $4, $5)",
-        secret.data,
+    //     secret.data,
-        created_time,
+    //     created_time,
-        deletion_time,
+    //     deletion_time,
-        version,
+    //     version,
-        version
+    //     version
-    )
+    // )
-    .execute(&pool)
+    // .execute(&pool)
-    .await
+    // .await
-    {
+    // {
-        Ok(v) => {
+    //     Ok(v) => {
-            trace!("{:?}", v);
+    //         trace!("{:?}", v);
-            "Success"
+    //         "Success"
-        }
+    //     }
-        Err(e) => {
+    //     Err(e) => {
-            trace!("{:?}", e);
+    //         trace!("{:?}", e);
-            "Error"
+    //         "Error"
-        }
+    //     }
-    }
+    // }
 
-    // todo!("not implemented")
+    todo!("not implemented")
 }
 
 /* mock for return

src/engines/kv/structs.rs

@@ -5,7 +5,7 @@ use std::{collections::HashMap, vec};
 
 pub type KvSecretData = HashMap<String, String>;
 
-#[derive(Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug)]
 pub struct KvSecretReq {
     /// Map (required)
     pub data: KvSecretData,