multipart wip

src/server.rs

@@ -1,35 +1,76 @@
 use axum::{
-    http::StatusCode, response::{IntoResponse, Response}, routing::{get, post}, Extension, Json, Router
+        extract::Multipart, http::StatusCode, response::{IntoResponse, Response}, routing::{get, post}, Extension, Json, Router
 };
-use serde::Deserialize;
 use tracing_subscriber::{fmt, prelude::*, EnvFilter};
-use zettle_db::rabbitmq::{consumer::RabbitMQConsumer, producer::RabbitMQProducer, RabbitMQConfig};
+use uuid::Uuid;
+use zettle_db::{models::ingress::{FileInfo, IngressContent, IngressMultipart  }, rabbitmq::{consumer::RabbitMQConsumer, RabbitMQConfig}};
+use zettle_db::rabbitmq::publisher::RabbitMQProducer;
 use std::sync::Arc;
-
-#[derive(Deserialize)]
-struct IngressPayload {
-    payload: String,
-}
+use axum_typed_multipart::TypedMultipart;
+use axum::debug_handler;
 
 use tracing::{info, error};
 
-async fn ingress_handler(
+pub async fn ingress_handler(
     Extension(producer): Extension<Arc<RabbitMQProducer>>,
-    Json(payload): Json<IngressPayload>
-) -> Response {
-    info!("Received payload: {:?}", payload.payload);
-    match producer.publish(&payload.payload.into_bytes().to_vec()).await {
+    TypedMultipart(multipart_data): TypedMultipart<IngressMultipart>, // Parse form data
+) -> impl IntoResponse {
+    info!("Received multipart data: {:?}", &multipart_data);
+
+    let file_info = if let Some(file) = multipart_data.file {
+        // File name or default to "data.bin" if none is provided
+        let file_name = file.metadata.file_name.unwrap_or(String::from("data.bin"));
+        let mime_type = mime_guess::from_path(&file_name)
+            .first_or_octet_stream()
+            .to_string();
+        let uuid = Uuid::new_v4();
+        let path = std::path::Path::new("/tmp").join(uuid.to_string()).join(&file_name);
+
+        // Persist the file
+        match file.contents.persist(&path) {
+            Ok(_) => {
+                info!("File saved at: {:?}", path);
+                // Generate FileInfo
+                let file_info = FileInfo {
+                    uuid,
+                    sha256: "sha-12412".to_string(),
+                    path: path.to_string_lossy().to_string(),
+                    mime_type,
+                };
+                Some(file_info)
+            }
+            Err(e) => {
+                error!("Failed to save file: {:?}", e);
+                return (StatusCode::INTERNAL_SERVER_ERROR, "Failed to store file").into_response();
+            }
+        }
+    } else {
+        None // No file was uploaded
+    };
+
+    // Convert `IngressMultipart` to `IngressContent`
+    let content = match IngressContent::new(multipart_data.content, multipart_data.instructions,multipart_data.category, file_info).await {
+        Ok(content) => content,
+        Err(e) => {
+            error!("Error creating IngressContent: {:?}", e);
+            return (StatusCode::INTERNAL_SERVER_ERROR, "Failed to create content").into_response();
+        }
+    };
+
+    // Publish content to RabbitMQ (or other system)
+    match producer.publish(&content).await {
         Ok(_) => {
             info!("Message published successfully");
-            "thank you".to_string().into_response()
-        },
+            "Successfully processed".to_string().into_response()
+        }
         Err(e) => {
             error!("Failed to publish message: {:?}", e);
-            (axum::http::StatusCode::INTERNAL_SERVER_ERROR, "Failed to publish message").into_response()
+            (StatusCode::INTERNAL_SERVER_ERROR, "Failed to publish message").into_response()
         }
     }
 }
 
+
 async fn queue_length_handler() -> Response {
     info!("Getting queue length");
     
@@ -61,6 +102,7 @@ async fn queue_length_handler() -> Response {
     }
 }
 
+
 #[tokio::main(flavor = "multi_thread", worker_threads = 2)]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Set up tracing