Removing hard coded user_id (#38)

Reviewed-on: #38
Co-authored-by: phoenix <kundeng00@pm.me>
Co-committed-by: phoenix <kundeng00@pm.me>

Cargo.lock

@@ -1255,7 +1255,7 @@ dependencies = [
 
 [[package]]
 name = "songparser"
-version = "0.2.2"
+version = "0.2.3"
 dependencies = [
  "futures",
  "icarus_envy",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "songparser"
-version = "0.2.2"
+version = "0.2.3"
 edition = "2024"
 rust-version = "1.88"
 

src/main.rs

@@ -21,12 +21,13 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                     println!("Queue is not empty");
                     println!("SongQueueItem: {song_queue_item:?}");
                     let song_queue_id = song_queue_item.data[0].id;
+                    let user_id = song_queue_item.data[0].user_id;
 
                     // TODO: Do something with the result later
-                    match some_work(&app_base_url, &song_queue_id).await {
+                    match some_work(&app_base_url, &song_queue_id, &user_id).await {
                         Ok((
-                            song,
-                            coverart,
+                            _song,
+                            _coverart,
                             (song_queue_id, song_queue_path),
                             (coverart_queue_id, coverart_queue_path),
                         )) => {
@@ -38,12 +39,13 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                             )
                             .await
                             {
-                                Ok(_) => {}
+                                Ok(_) => {
+                                    // TODO: Cleanup files in local filesystem
+                                }
                                 Err(err) => {
                                     eprintln!("Error: {err:?}");
                                 }
                             }
-                            // TODO: Cleanup files in local filesystem
                         }
                         Err(err) => {
                             eprintln!("Error: {err:?}");
@@ -73,10 +75,25 @@ async fn wipe_data_from_queues(
             .json::<the_rest::wipe_data::song_queue::response::Response>()
             .await
         {
-            Ok(_resp) => {
-                println!("Wiped data from song queue");
-                Ok(())
-            }
+            Ok(_resp) => match the_rest::wipe_data::coverart_queue::wipe_data(
+                app_base_url,
+                coverart_queue_id,
+            )
+            .await
+            {
+                Ok(inner_response) => match inner_response
+                    .json::<the_rest::wipe_data::coverart_queue::response::Response>()
+                    .await
+                {
+                    Ok(_inner_resp) => {
+                        println!("Wiped data from CoverArt queue");
+                        println!("Resp: {_inner_resp:?}");
+                        Ok(())
+                    }
+                    Err(err) => Err(std::io::Error::other(err.to_string())),
+                },
+                Err(err) => Err(std::io::Error::other(err.to_string())),
+            },
             Err(err) => Err(std::io::Error::other(err.to_string())),
         },
         Err(err) => Err(std::io::Error::other(err.to_string())),
@@ -109,6 +126,7 @@ async fn is_queue_empty(
 async fn some_work(
     app_base_url: &String,
     song_queue_id: &uuid::Uuid,
+    user_id: &uuid::Uuid,
 ) -> Result<
     (
         icarus_models::song::Song,
@@ -137,16 +155,13 @@ async fn some_work(
                                 Ok(_inner_response) => {
                                     println!("Response: {_inner_response:?}");
 
-                                    // TODO: Do not hard code this. Check if one of the existing
-                                    // endpoints already have the user_id
-                                    let user_id = uuid::Uuid::new_v4();
                                     // TODO: Place this somewhere else
                                     let song_type = String::from("flac");
-                                    // Err(std::io::Error::other(err.to_string()))
+
                                     match the_rest::create_song::create(
                                         app_base_url,
                                         &metadata,
-                                        &user_id,
+                                        user_id,
                                         &song_type,
                                     )
                                     .await

src/responses.rs

@@ -6,6 +6,7 @@ pub mod fetch_next_queue_item {
         pub id: uuid::Uuid,
         pub filename: String,
         pub status: String,
+        pub user_id: uuid::Uuid,
     }
 
     #[derive(Debug, Deserialize, Serialize)]

src/the_rest.rs

@@ -99,4 +99,27 @@ pub mod wipe_data {
         }
     }
     // TODO: Wipe data from queued coverart
+    pub mod coverart_queue {
+        pub async fn wipe_data(
+            base_url: &String,
+            coverart_queue_id: &uuid::Uuid,
+        ) -> Result<reqwest::Response, reqwest::Error> {
+            let client = reqwest::Client::builder().build()?;
+            let url = format!("{base_url}/api/v2/coverart/queue/data/wipe");
+            let payload = serde_json::json!({
+                "coverart_queue_id": coverart_queue_id
+            });
+            let request = client.patch(url).json(&payload);
+
+            request.send().await
+        }
+
+        pub mod response {
+            #[derive(Debug, serde::Deserialize, serde::Serialize)]
+            pub struct Response {
+                pub message: String,
+                pub data: Vec<uuid::Uuid>,
+            }
+        }
+    }
 }