File cleanup post-parsing (#37)

Reviewed-on: #37
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.3"
+version = "0.2.4"
 dependencies = [
  "futures",
  "icarus_envy",

Cargo.toml

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

src/main.rs

@@ -21,9 +21,10 @@ 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,
@@ -39,7 +40,14 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                             .await
                             {
                                 Ok(_) => {
-                                    // TODO: Cleanup files in local filesystem
+                                    match cleanup(&song_queue_path, &coverart_queue_path).await {
+                                        Ok(_) => {
+                                            println!("Successful cleanup");
+                                        }
+                                        Err(err) => {
+                                            eprintln!("Error: {err:?}");
+                                        }
+                                    }
                                 }
                                 Err(err) => {
                                     eprintln!("Error: {err:?}");
@@ -99,6 +107,23 @@ async fn wipe_data_from_queues(
     }
 }
 
+async fn cleanup(
+    song_queue_path: &String,
+    coverart_queue_path: &String,
+) -> Result<(), std::io::Error> {
+    match the_rest::cleanup::clean_song_queue(song_queue_path) {
+        Ok(_) => {}
+        Err(err) => {
+            eprintln!("Error: Problem cleaning up SongQueue files {err:?}");
+        }
+    }
+
+    match the_rest::cleanup::clean_coverart_queue(coverart_queue_path) {
+        Ok(_) => Ok(()),
+        Err(err) => Err(err),
+    }
+}
+
 async fn is_queue_empty(
     api_url: &String,
 ) -> Result<(bool, responses::fetch_next_queue_item::SongQueueItem), reqwest::Error> {
@@ -125,6 +150,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,
@@ -153,16 +179,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

@@ -123,3 +123,54 @@ pub mod wipe_data {
         }
     }
 }
+
+pub mod cleanup {
+    pub fn clean_song_queue(song_queue_path: &String) -> Result<(), std::io::Error> {
+        let file_path = std::path::Path::new(song_queue_path);
+        if file_path.exists() {
+            match std::fs::remove_file(file_path) {
+                Ok(_) => {
+                    if check_file_existence(song_queue_path) {
+                        Err(std::io::Error::other(String::from(
+                            "SongQueue file exists after a deletion",
+                        )))
+                    } else {
+                        Ok(())
+                    }
+                }
+                Err(err) => Err(std::io::Error::other(err.to_string())),
+            }
+        } else {
+            Err(std::io::Error::other(String::from(
+                "SongQueue file path does not exists",
+            )))
+        }
+    }
+
+    pub fn clean_coverart_queue(coverart_queue_path: &String) -> Result<(), std::io::Error> {
+        let coverart_file_path = std::path::Path::new(coverart_queue_path);
+        if coverart_file_path.exists() {
+            match std::fs::remove_file(coverart_file_path) {
+                Ok(_) => {
+                    if !check_file_existence(coverart_queue_path) {
+                        Ok(())
+                    } else {
+                        Err(std::io::Error::other(String::from(
+                            "CoverArt file stil exists",
+                        )))
+                    }
+                }
+                Err(err) => Err(std::io::Error::other(err.to_string())),
+            }
+        } else {
+            Err(std::io::Error::other(String::from(
+                "CoverArt file does not exists",
+            )))
+        }
+    }
+
+    fn check_file_existence(file_path: &String) -> bool {
+        let path = std::path::Path::new(file_path);
+        path.exists()
+    }
+}