diff --git a/src/callers/coverart.rs b/src/callers/coverart.rs index b0d760d..e2c918c 100644 --- a/src/callers/coverart.rs +++ b/src/callers/coverart.rs @@ -1,3 +1,9 @@ +#[derive(Debug, Default, serde::Deserialize, serde::Serialize)] +pub struct CoverArtQueue { + pub id: uuid::Uuid, + pub song_queue_id: uuid::Uuid, +} + pub mod request { pub mod link { @@ -7,6 +13,14 @@ pub mod request { pub song_queue_id: uuid::Uuid, } } + + pub mod fetch_coverart_no_data { + #[derive(Debug, Default, serde::Deserialize, serde::Serialize)] + pub struct Params { + pub id: Option, + pub song_queue_id: Option, + } + } } pub mod response { @@ -29,9 +43,17 @@ pub mod response { pub data: Vec, } } + + pub mod fetch_coverart_no_data { + #[derive(Debug, Default, serde::Deserialize, serde::Serialize)] + pub struct Response { + pub message: String, + pub data: Vec, + } + } } -mod db { +pub mod db { use sqlx::Row; pub async fn insert(pool: &sqlx::PgPool, data: &Vec) -> Result { @@ -79,6 +101,68 @@ mod db { Err(_err) => Err(sqlx::Error::RowNotFound), } } + + pub async fn get_coverart_queue_with_id( + pool: &sqlx::PgPool, + id: &uuid::Uuid, + ) -> Result { + let result = sqlx::query( + r#" + SELECT id, song_queue_id FROM "coverartQueue" WHERE id = $1; + "#, + ) + .bind(id) + .fetch_one(pool) + .await + .map_err(|e| { + eprintln!("Error querying data: {:?}", e); + }); + + match result { + Ok(row) => Ok(super::CoverArtQueue { + id: row + .try_get("id") + .map_err(|_e| sqlx::Error::RowNotFound) + .unwrap(), + song_queue_id: row + .try_get("song_queue_id") + .map_err(|_e| sqlx::Error::RowNotFound) + .unwrap(), + }), + Err(_) => Err(sqlx::Error::RowNotFound), + } + } + + pub async fn get_coverart_queue_with_song_queue_id( + pool: &sqlx::PgPool, + song_queue_id: &uuid::Uuid, + ) -> Result { + let result = sqlx::query( + r#" + SELECT id, song_queue_id FROM "coverartQueue" WHERE song_queue_id = $1; + "#, + ) + .bind(song_queue_id) + .fetch_one(pool) + .await + .map_err(|e| { + eprintln!("Error querying data: {:?}", e); + }); + + match result { + Ok(row) => Ok(super::CoverArtQueue { + id: row + .try_get("id") + .map_err(|_e| sqlx::Error::RowNotFound) + .unwrap(), + song_queue_id: row + .try_get("song_queue_id") + .map_err(|_e| sqlx::Error::RowNotFound) + .unwrap(), + }), + Err(_) => Err(sqlx::Error::RowNotFound), + } + } } pub mod endpoint { @@ -153,4 +237,51 @@ pub mod endpoint { } } } + + pub async fn fetch_coverart_no_data( + axum::Extension(pool): axum::Extension, + axum::extract::Query(params): axum::extract::Query< + super::request::fetch_coverart_no_data::Params, + >, + ) -> ( + axum::http::StatusCode, + axum::Json, + ) { + let mut response = super::response::fetch_coverart_no_data::Response::default(); + + match params.id { + Some(id) => match super::db::get_coverart_queue_with_id(&pool, &id).await { + Ok(cover_art_queue) => { + response.message = String::from("Successful"); + response.data.push(cover_art_queue); + (axum::http::StatusCode::OK, axum::Json(response)) + } + Err(err) => { + response.message = err.to_string(); + (axum::http::StatusCode::BAD_REQUEST, axum::Json(response)) + } + }, + _ => match params.song_queue_id { + Some(song_queue_id) => { + match super::db::get_coverart_queue_with_song_queue_id(&pool, &song_queue_id) + .await + { + Ok(cover_art_queue) => { + response.message = String::from("Successful"); + response.data.push(cover_art_queue); + (axum::http::StatusCode::OK, axum::Json(response)) + } + Err(err) => { + response.message = err.to_string(); + (axum::http::StatusCode::BAD_REQUEST, axum::Json(response)) + } + } + } + None => { + response.message = String::from("No valid id provided"); + (axum::http::StatusCode::BAD_REQUEST, axum::Json(response)) + } + }, + } + } } diff --git a/src/main.rs b/src/main.rs index c68d9f0..67feca9 100644 --- a/src/main.rs +++ b/src/main.rs @@ -93,6 +93,10 @@ pub mod init { crate::callers::endpoints::QUEUECOVERART, post(crate::callers::coverart::endpoint::queue), ) + .route( + crate::callers::endpoints::QUEUECOVERART, + get(crate::callers::coverart::endpoint::fetch_coverart_no_data), + ) .route( crate::callers::endpoints::QUEUECOVERARTLINK, patch(crate::callers::coverart::endpoint::link), @@ -298,6 +302,26 @@ mod tests { app.clone().oneshot(req).await } + async fn coverart_queue_song_queue_link_req( + app: &axum::Router, + coverart_id: &uuid::Uuid, + song_queue_id: &uuid::Uuid, + ) -> Result { + let payload = serde_json::json!( + { + "song_queue_id": song_queue_id, + "coverart_id" : coverart_id, + }); + let req = axum::http::Request::builder() + .method(axum::http::Method::PATCH) + .uri(crate::callers::endpoints::QUEUECOVERARTLINK) + .header(axum::http::header::CONTENT_TYPE, "application/json") + .body(axum::body::Body::from(payload.to_string())) + .unwrap(); + + app.clone().oneshot(req).await + } + pub async fn resp_to_bytes( response: axum::response::Response, ) -> Result { @@ -698,22 +722,7 @@ mod tests { let coverart_id = resp.data[0]; assert_eq!(false, coverart_id.is_nil(), "Should not be empty"); - let payload = serde_json::json!( - { - "song_queue_id": song_queue_id, - "coverart_id" : coverart_id, - }); - - match app - .clone() - .oneshot( - axum::http::Request::builder() - .method(axum::http::Method::PATCH) - .uri(crate::callers::endpoints::QUEUECOVERARTLINK) - .header(axum::http::header::CONTENT_TYPE, "application/json") - .body(axum::body::Body::from(payload.to_string())) - .unwrap(), - ) + match coverart_queue_song_queue_link_req(&app, &coverart_id, &song_queue_id) .await { Ok(response) => { @@ -838,4 +847,115 @@ mod tests { let _ = db_mgr::drop_database(&tm_pool, &db_name).await; } + + #[tokio::test] + async fn test_fetch_coverart_queue_without_data() { + 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 = init::app(pool).await; + + match song_queue_req(&app).await { + Ok(response) => { + let resp = + get_resp_data::(response).await; + assert_eq!(false, resp.data.is_empty(), "Should not be empty"); + let song_queue_id = resp.data[0]; + assert_eq!(false, song_queue_id.is_nil(), "Should not be empty"); + + // Send request + match upload_coverart_queue_req(&app).await { + Ok(response) => { + let resp = + get_resp_data::(response) + .await; + assert_eq!(false, resp.data.is_empty(), "Should not be empty"); + let coverart_id = resp.data[0]; + assert_eq!(false, coverart_id.is_nil(), "Should not be empty"); + + match coverart_queue_song_queue_link_req(&app, &coverart_id, &song_queue_id) + .await + { + Ok(response) => { + let resp = get_resp_data::< + crate::callers::coverart::response::link::Response, + >(response) + .await; + assert_eq!(false, resp.data.is_empty(), "Should not be empty"); + let resp_coverart_id = resp.data[0].coverart_id; + let resp_song_queue_id = resp.data[0].song_queue_id; + + assert_eq!(false, resp_coverart_id.is_nil(), "Should not be empty"); + assert_eq!( + false, + resp_song_queue_id.is_nil(), + "Should not be empty" + ); + + let uri = format!( + "{}?id={}", + crate::callers::endpoints::QUEUECOVERART, + resp_coverart_id + ); + + match app + .clone() + .oneshot( + axum::http::Request::builder() + .method(axum::http::Method::GET) + .uri(uri) + .header( + axum::http::header::CONTENT_TYPE, + "application/json", + ) + .body(axum::body::Body::empty()) + .unwrap(), + ) + .await + { + Ok(response) => { + let resp = get_resp_data::< + crate::callers::coverart::response::fetch_coverart_no_data::Response, + >(response) + .await; + assert_eq!( + false, + resp.data.is_empty(), + "Should not be empty" + ); + } + Err(err) => { + assert!(false, "Error: {:?}", err); + } + } + } + Err(err) => { + assert!(false, "Error: {:?}", err); + } + } + } + Err(err) => { + assert!(false, "Error: {:?}", err); + } + } + } + Err(err) => { + assert!(false, "Error: {:?}", err); + } + } + + let _ = db_mgr::drop_database(&tm_pool, &db_name).await; + } }