Added callers moulde (#120)

* Added callers moulde

* Code formatting

* Added uuid dependency

* Added queue_song endpoint

* Added endpoint to router

* Added dependencies for postgres

* Added migrations directory

* Added more code

* Added migrations

* Removed migration

* Docker fixes

* Updated gitignore

* Updated env sample file

* Endpoint url fix

* Updated env sample

* Updated docker file to copy migrations

* Might undo later

* Updated env sample and docker compose

* Updated cargo dependencies

* Saving changes

* Workflow fix

* Will need to take another look at the dependencies again

* Added code

* Test is not finished yet

* Warning fix for now

* Updated workflow to setup database

* Workflow fix

* Workflow fix attempt

* Warning fix

* Warning fix

* Updated workflow

* Added test files

Might change later

* Added more crates

* Added more test code

Not finished

* Formatting

* Close, but far

* I believe it is now working

* Formatting

* Added more crates

* Code cleanup

* Code reformatting

* Code cleanup

* Crate cleanup

* Cleanup

src/callers/mod.rs

@@ -0,0 +1,5 @@
+pub mod song;
+
+pub mod endpoints {
+    pub const QUEUESONG: &str = "/api/v2/song/queue";
+}

src/callers/song.rs

@@ -0,0 +1,106 @@
+pub mod request {
+    use serde::{Deserialize, Serialize};
+
+    #[derive(Default, Deserialize, Serialize)]
+    pub struct Request {
+        pub message: String,
+    }
+}
+
+pub mod response {
+    use serde::{Deserialize, Serialize};
+
+    #[derive(Default, Deserialize, Serialize)]
+    pub struct Response {
+        pub message: String,
+        pub data: Vec<uuid::Uuid>,
+    }
+}
+
+mod song_queue {
+    use sqlx::Row;
+
+    #[derive(Debug, serde::Serialize, sqlx::FromRow)]
+    pub struct InsertedData {
+        pub id: uuid::Uuid,
+    }
+
+    pub async fn insert(
+        pool: &sqlx::PgPool,
+        data: &Vec<u8>,
+        filename: &String,
+    ) -> Result<uuid::Uuid, sqlx::Error> {
+        let result = sqlx::query(
+            r#"
+            INSERT INTO "songQueue" (data, filename) VALUES($1, $2) RETURNING id;
+            "#,
+        )
+        .bind(data)
+        .bind(filename)
+        .fetch_one(pool)
+        .await
+        .map_err(|e| {
+            eprintln!("Error inserting: {}", e);
+        });
+
+        match result {
+            Ok(row) => {
+                let id: uuid::Uuid = row
+                    .try_get("id")
+                    .map_err(|_e| sqlx::Error::RowNotFound)
+                    .unwrap();
+                Ok(id)
+            }
+            Err(_err) => Err(sqlx::Error::RowNotFound),
+        }
+    }
+}
+
+pub mod endpoint {
+    use axum::{Json, http::StatusCode};
+    use std::io::Write;
+
+    use crate::callers::song::song_queue;
+
+    pub async fn queue_song(
+        axum::Extension(pool): axum::Extension<sqlx::PgPool>,
+        mut multipart: axum::extract::Multipart,
+    ) -> (StatusCode, Json<super::response::Response>) {
+        let mut results: Vec<uuid::Uuid> = Vec::new();
+        let mut response = super::response::Response::default();
+
+        while let Some(field) = multipart.next_field().await.unwrap() {
+            let name = field.name().unwrap().to_string();
+            let file_name = field.file_name().unwrap().to_string();
+            let content_type = field.content_type().unwrap().to_string();
+            let data = field.bytes().await.unwrap();
+
+            println!(
+                "Received file '{}' (name = '{}', content-type = '{}', size = {})",
+                file_name,
+                name,
+                content_type,
+                data.len()
+            );
+
+            // Save the file to disk
+            let mut file = std::fs::File::create(&file_name).unwrap();
+            file.write_all(&data).unwrap();
+
+            let raw_data: Vec<u8> = data.to_vec();
+            let queue_repo = song_queue::insert(&pool, &raw_data, &file_name)
+                .await
+                .unwrap();
+            results.push(queue_repo);
+        }
+
+        response.data = results;
+        response.message = if response.data.is_empty() {
+            String::from("Error")
+        } else {
+            String::from("Success")
+        };
+
+        (StatusCode::OK, Json(response))
+    }
+}

src/main.rs

@@ -1,29 +1,90 @@
-use axum::{
-    // Json,
-    Router,
-    // http::StatusCode,
-    // routing::{get, post},
-    routing::get,
-};
-// use serde::{Deserialize, Serialize};
+pub mod callers;
+
+pub mod db {
+
+    use sqlx::postgres::PgPoolOptions;
+    use std::env;
+
+    pub mod connection_settings {
+        pub const MAXCONN: u32 = 10;
+    }
+
+    pub mod keys {
+        pub const DBURL: &str = "DATABASE_URL";
+
+        pub mod error {
+            pub const ERROR: &str = "DATABASE_URL must be set in .env";
+        }
+    }
+
+    pub async fn create_pool() -> Result<sqlx::PgPool, sqlx::Error> {
+        let database_url = get_db_url().await;
+        println!("Database url: {:?}", database_url);
+
+        PgPoolOptions::new()
+            .max_connections(connection_settings::MAXCONN)
+            .connect(&database_url)
+            .await
+    }
+
+    async fn get_db_url() -> String {
+        dotenvy::dotenv().ok();
+        env::var(keys::DBURL).expect(keys::error::ERROR)
+    }
+
+    pub async fn migrations(pool: &sqlx::PgPool) {
+        // Run migrations using the sqlx::migrate! macro
+        // Assumes your migrations are in a ./migrations folder relative to Cargo.toml
+        sqlx::migrate!("./migrations")
+            .run(pool)
+            .await
+            .expect("Failed to run migrations");
+    }
+}
 
 #[tokio::main]
 async fn main() {
     // initialize tracing
     tracing_subscriber::fmt::init();
 
-    // build our application with a route
-    let app = Router::new()
-        // `GET /` goes to `root`
-        .route("/", get(root));
-    // `POST /users` goes to `create_user`
-    // .route("/users", post(create_user));
+    let pool = db::create_pool().await.expect("Failed to create pool");
+    db::migrations(&pool).await;
+
+    // build our application with a route
+    let app = init::app().await;
 
-    // run our app with hyper, listening globally on port 3000
     let listener = tokio::net::TcpListener::bind(get_full()).await.unwrap();
     axum::serve(listener, app).await.unwrap();
 }
 
+pub mod init {
+    use axum::routing::{get, post};
+    use std::time::Duration;
+    use tower_http::timeout::TimeoutLayer;
+
+    pub async fn routes() -> axum::Router {
+        axum::Router::new()
+            .route(crate::ROOT, get(crate::root))
+            .route(
+                crate::callers::endpoints::QUEUESONG,
+                post(crate::callers::song::endpoint::queue_song),
+            )
+    }
+
+    pub async fn app() -> axum::Router {
+        let pool = crate::db::create_pool()
+            .await
+            .expect("Failed to create pool");
+        crate::db::migrations(&pool).await;
+
+        routes()
+            .await
+            .layer(axum::Extension(pool))
+            .layer(axum::extract::DefaultBodyLimit::max(1024 * 1024 * 1024))
+            .layer(TimeoutLayer::new(Duration::from_secs(300)))
+    }
+}
+
 fn get_full() -> String {
     get_address() + ":" + &get_port()
 }
@@ -35,7 +96,153 @@ fn get_port() -> String {
     String::from("3000")
 }
 
+pub const ROOT: &str = "/";
 // basic handler that responds with a static string
-async fn root() -> &'static str {
+pub async fn root() -> &'static str {
     "Hello, World!"
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::db;
+
+    use common_multipart_rfc7578::client::multipart::{
+        Body as MultipartBody, Form as MultipartForm,
+    };
+    use std::{time::Duration, usize};
+    use tower::ServiceExt;
+    use tower_http::timeout::TimeoutLayer;
+
+    mod db_mgr {
+        use std::str::FromStr;
+
+        use crate::db;
+
+        pub const LIMIT: usize = 6;
+
+        pub async fn get_pool() -> Result<sqlx::PgPool, sqlx::Error> {
+            dotenvy::dotenv().ok();
+            let tm_db_url = std::env::var(db::keys::DBURL).expect("DATABASE_URL must be present");
+            let tm_options = sqlx::postgres::PgConnectOptions::from_str(&tm_db_url).unwrap();
+            sqlx::PgPool::connect_with(tm_options).await
+        }
+
+        pub async fn generate_db_name() -> String {
+            let db_name =
+                get_database_name().unwrap() + &"_" + &uuid::Uuid::new_v4().to_string()[..LIMIT];
+            db_name
+        }
+
+        pub async fn connect_to_db(db_name: &str) -> Result<sqlx::PgPool, sqlx::Error> {
+            dotenvy::dotenv().ok();
+            let db_url =
+                std::env::var(db::keys::DBURL).expect("DATABASE_URL must be set for tests");
+            let options = sqlx::postgres::PgConnectOptions::from_str(&db_url)?.database(db_name);
+            sqlx::PgPool::connect_with(options).await
+        }
+
+        pub async fn create_database(
+            template_pool: &sqlx::PgPool,
+            db_name: &str,
+        ) -> Result<(), sqlx::Error> {
+            let create_query = format!("CREATE DATABASE {}", db_name);
+            match sqlx::query(&create_query).execute(template_pool).await {
+                Ok(_) => Ok(()),
+                Err(e) => Err(e),
+            }
+        }
+
+        // Function to drop a database
+        pub async fn drop_database(
+            template_pool: &sqlx::PgPool,
+            db_name: &str,
+        ) -> Result<(), sqlx::Error> {
+            let drop_query = format!("DROP DATABASE IF EXISTS {} WITH (FORCE)", db_name);
+            sqlx::query(&drop_query).execute(template_pool).await?;
+            Ok(())
+        }
+
+        pub fn get_database_name() -> Result<String, Box<dyn std::error::Error>> {
+            dotenvy::dotenv().ok(); // Load .env file if it exists
+
+            match std::env::var(db::keys::DBURL) {
+                Ok(database_url) => {
+                    let parsed_url = url::Url::parse(&database_url)?;
+                    if parsed_url.scheme() == "postgres" || parsed_url.scheme() == "postgresql" {
+                        match parsed_url
+                            .path_segments()
+                            .and_then(|segments| segments.last().map(|s| s.to_string()))
+                        {
+                            Some(sss) => Ok(sss),
+                            None => Err("Error parsing".into()),
+                        }
+                    } else {
+                        // Handle other database types if needed
+                        Err("Error parsing".into())
+                    }
+                }
+                Err(_) => {
+                    // DATABASE_URL environment variable not found
+                    Err("Error parsing".into())
+                }
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn test_song_queue() {
+        let tm_pool = db_mgr::get_pool().await.unwrap();
+        let db_name = db_mgr::generate_db_name().await;
+
+        match db_mgr::create_database(&tm_pool, &db_name).await {
+            Ok(_) => {
+                println!("Success");
+            }
+            Err(err) => {
+                assert!(false, "Error: {:?}", err);
+            }
+        }
+
+        let pool = db_mgr::connect_to_db(&db_name).await.unwrap();
+        db::migrations(&pool).await;
+
+        let app = crate::init::routes()
+            .await
+            .layer(axum::Extension(pool))
+            .layer(axum::extract::DefaultBodyLimit::max(1024 * 1024 * 1024))
+            .layer(TimeoutLayer::new(Duration::from_secs(300)));
+
+        // Create multipart form
+        let mut form = MultipartForm::default();
+        let _ = form.add_file("flac", "tests/Machine_gun/track01.flac");
+
+        // Create request
+        let content_type = form.content_type();
+        let body = MultipartBody::from(form);
+        let req = axum::http::Request::builder()
+            .method(axum::http::Method::POST)
+            .uri(crate::callers::endpoints::QUEUESONG)
+            .header(axum::http::header::CONTENT_TYPE, content_type)
+            .body(axum::body::Body::from_stream(body))
+            .unwrap();
+
+        // Send request
+        match app.oneshot(req).await {
+            Ok(response) => {
+                let body = axum::body::to_bytes(response.into_body(), usize::MAX)
+                    .await
+                    .unwrap();
+                println!("Body: {:?}", body);
+                let resp: crate::callers::song::response::Response =
+                    serde_json::from_slice(&body).unwrap();
+                assert_eq!(false, resp.data.is_empty(), "Should not be empty");
+                assert_eq!(false, resp.data[0].is_nil(), "Should not be empty");
+            }
+            Err(err) => {
+                assert!(false, "Error: {:?}", err);
+            }
+        };
+
+        let _ = db_mgr::drop_database(&tm_pool, &db_name).await;
+    }
+}