Dependency name change (#3)

Reviewed-on: #3

src/api.rs

@@ -162,7 +162,7 @@ pub mod service_token {
         #[derive(Debug, serde::Deserialize, serde::Serialize)]
         pub struct Response {
             pub message: String,
-            pub data: Vec<icarus_models::login_result::LoginResult>,
+            pub data: Vec<simodels::login_result::LoginResult>,
         }
     }
 }
@@ -172,7 +172,7 @@ pub mod refresh_token {
         #[derive(Debug, serde::Deserialize, serde::Serialize)]
         pub struct Response {
             pub message: String,
-            pub data: Vec<icarus_models::login_result::LoginResult>,
+            pub data: Vec<simodels::login_result::LoginResult>,
         }
     }
 }
@@ -253,7 +253,7 @@ pub mod create_song {
         #[derive(Debug, serde::Deserialize, serde::Serialize)]
         pub struct Response {
             pub message: String,
-            pub data: Vec<icarus_models::song::Song>,
+            pub data: Vec<simodels::song::Song>,
         }
     }
 }
@@ -261,7 +261,7 @@ pub mod create_song {
 pub mod create_coverart {
     pub async fn create(
         app: &crate::config::App,
-        song: &icarus_models::song::Song,
+        song: &simodels::song::Song,
         queued_coverart: &crate::queued_item::QueuedCoverArt,
     ) -> Result<reqwest::Response, reqwest::Error> {
         let client = reqwest::Client::builder().build()?;
@@ -284,7 +284,7 @@ pub mod create_coverart {
         #[derive(Debug, serde::Deserialize, serde::Serialize)]
         pub struct Response {
             pub message: String,
-            pub data: Vec<icarus_models::coverart::CoverArt>,
+            pub data: Vec<simodels::coverart::CoverArt>,
         }
     }
 }

src/auth/mod.rs

@@ -1,12 +1,12 @@
 pub async fn get_token(
     app: &crate::config::App,
-) -> Result<icarus_models::login_result::LoginResult, std::io::Error> {
+) -> Result<simodels::login_result::LoginResult, std::io::Error> {
     let client = reqwest::Client::new();
     let endpoint = String::from("api/v2/service/login");
     let api_url = format!("{}/{endpoint}", app.auth_uri);
 
     let payload = serde_json::json!({
-        "passphrase": icarus_envy::environment::get_service_passphrase().value,
+        "passphrase": sienvy::environment::get_service_passphrase().value,
     });
 
     match client.post(api_url).json(&payload).send().await {
@@ -29,7 +29,7 @@ pub async fn get_token(
 
 pub async fn get_refresh_token(
     app: &crate::config::App,
-) -> Result<icarus_models::login_result::LoginResult, std::io::Error> {
+) -> Result<simodels::login_result::LoginResult, std::io::Error> {
     let client = reqwest::Client::new();
     let endpoint = String::from("api/v2/token/refresh");
     let api_url = format!("{}/{endpoint}", app.auth_uri);

src/config.rs

@@ -2,7 +2,7 @@
 pub struct App {
     pub uri: String,
     pub auth_uri: String,
-    pub token: icarus_models::login_result::LoginResult,
+    pub token: simodels::login_result::LoginResult,
     pub root_directory: String,
 }
 
@@ -15,9 +15,9 @@ impl App {
 
 pub async fn initialize_app_config() -> App {
     App {
-        uri: icarus_envy::environment::get_icarus_base_api_url().value,
-        auth_uri: icarus_envy::environment::get_icarus_auth_base_api_url().value,
-        root_directory: icarus_envy::environment::get_root_directory().value,
+        uri: sienvy::environment::get_soaricarus_base_api_url().value,
+        auth_uri: sienvy::environment::get_soaricarus_auth_base_api_url().value,
+        root_directory: sienvy::environment::get_root_directory().value,
         ..Default::default()
     }
 }

src/metadata/mod.rs

@@ -5,101 +5,96 @@ pub async fn apply_metadata(
     metadata: &crate::api::get_metadata_queue::response::Metadata,
 ) -> Result<bool, std::io::Error> {
     // Apply metadata fields
-    let types = icarus_meta::types::all_metadata_types();
+    let types = simeta::types::all_metadata_types();
 
     for t in types {
         match t {
-            icarus_meta::types::Type::Album => {
-                let meta_type =
-                    icarus_meta::types::MetadataType::from_string(metadata.album.clone());
-                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
+            simeta::types::Type::Album => {
+                let meta_type = simeta::types::MetadataType::from_string(metadata.album.clone());
+                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
                     }
                 }
             }
-            icarus_meta::types::Type::AlbumArtist => {
+            simeta::types::Type::AlbumArtist => {
                 let meta_type =
-                    icarus_meta::types::MetadataType::from_string(metadata.album_artist.clone());
-                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
+                    simeta::types::MetadataType::from_string(metadata.album_artist.clone());
+                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
                     }
                 }
             }
-            icarus_meta::types::Type::Artist => {
-                let meta_type =
-                    icarus_meta::types::MetadataType::from_string(metadata.artist.clone());
-                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
+            simeta::types::Type::Artist => {
+                let meta_type = simeta::types::MetadataType::from_string(metadata.artist.clone());
+                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
                     }
                 }
             }
-            icarus_meta::types::Type::Date => {
+            simeta::types::Type::Date => {
                 // TODO: Do something about this discrepancy
-                let meta_type =
-                    icarus_meta::types::MetadataType::from_string(metadata.year.to_string());
-                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
+                let meta_type = simeta::types::MetadataType::from_string(metadata.year.to_string());
+                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
                     }
                 }
             }
-            icarus_meta::types::Type::Disc => {
-                let meta_type = icarus_meta::types::MetadataType::from_int(metadata.disc);
-                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
+            simeta::types::Type::Disc => {
+                let meta_type = simeta::types::MetadataType::from_int(metadata.disc);
+                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
                     }
                 }
             }
-            icarus_meta::types::Type::Genre => {
-                let meta_type =
-                    icarus_meta::types::MetadataType::from_string(metadata.genre.clone());
-                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
+            simeta::types::Type::Genre => {
+                let meta_type = simeta::types::MetadataType::from_string(metadata.genre.clone());
+                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
                     }
                 }
             }
-            icarus_meta::types::Type::Title => {
-                let meta_type =
-                    icarus_meta::types::MetadataType::from_string(metadata.title.clone());
-                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
+            simeta::types::Type::Title => {
+                let meta_type = simeta::types::MetadataType::from_string(metadata.title.clone());
+                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
                     }
                 }
             }
-            icarus_meta::types::Type::Track => {
-                let meta_type = icarus_meta::types::MetadataType::from_int(metadata.track);
-                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
+            simeta::types::Type::Track => {
+                let meta_type = simeta::types::MetadataType::from_int(metadata.track);
+                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
                     }
                 }
             }
-            icarus_meta::types::Type::TrackCount => {
-                let meta_type = icarus_meta::types::MetadataType::from_int(metadata.track_count);
-                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
+            simeta::types::Type::TrackCount => {
+                let meta_type = simeta::types::MetadataType::from_int(metadata.track_count);
+                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
                     }
                 }
             }
-            icarus_meta::types::Type::DiscCount => {
-                let meta_type = icarus_meta::types::MetadataType::from_int(metadata.disc_count);
-                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
+            simeta::types::Type::DiscCount => {
+                let meta_type = simeta::types::MetadataType::from_int(metadata.disc_count);
+                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
@@ -110,11 +105,11 @@ pub async fn apply_metadata(
     }
 
     // Apply coverart
-    match icarus_meta::meta::coverart::contains_coverart(&queued_song.path) {
+    match simeta::meta::coverart::contains_coverart(&queued_song.path) {
         Ok((exists, size)) => {
             if exists {
                 println!("Coverart exists: {size:?} size");
-                match icarus_meta::meta::coverart::remove_coverart(&queued_song.path) {
+                match simeta::meta::coverart::remove_coverart(&queued_song.path) {
                     Ok(_data) => {}
                     Err(err) => {
                         return Err(err);
@@ -122,10 +117,7 @@ pub async fn apply_metadata(
                 }
             }
 
-            match icarus_meta::meta::coverart::set_coverart(
-                &queued_song.path,
-                &queued_coverart.path,
-            ) {
+            match simeta::meta::coverart::set_coverart(&queued_song.path, &queued_coverart.path) {
                 Ok(_data) => {
                     if _data.is_empty() {
                         println!("There was an issue");

src/parser/mod.rs

@@ -4,8 +4,8 @@ pub async fn some_work(
     user_id: &uuid::Uuid,
 ) -> Result<
     (
-        icarus_models::song::Song,
-        icarus_models::coverart::CoverArt,
+        simodels::song::Song,
+        simodels::coverart::CoverArt,
         crate::api::get_metadata_queue::response::Metadata,
         crate::queued_item::QueuedSong,
         crate::queued_item::QueuedCoverArt,
@@ -30,9 +30,8 @@ pub async fn some_work(
                                     println!("Updated queued song");
                                     println!("Response: {_inner_response:?}");
 
-                                    let song_type = String::from(
-                                        icarus_meta::detection::song::constants::FLAC_TYPE,
-                                    );
+                                    let song_type =
+                                        String::from(simeta::detection::song::constants::FLAC_TYPE);
 
                                     match crate::api::create_song::create(
                                         app, &metadata, user_id, &song_type,
@@ -104,10 +103,10 @@ pub async fn prep_song(
             // Process data here...
             match crate::api::parsing::parse_response_into_bytes(response).await {
                 Ok(song_bytes) => {
-                    let song = icarus_models::song::Song {
-                        directory: icarus_envy::environment::get_root_directory().value,
-                        filename: icarus_models::song::generate_filename(
-                            icarus_models::types::MusicType::FlacExtension,
+                    let song = simodels::song::Song {
+                        directory: sienvy::environment::get_root_directory().value,
+                        filename: simodels::song::generate_filename(
+                            simodels::types::MusicType::FlacExtension,
                             true,
                         )
                         .unwrap(),
@@ -223,18 +222,18 @@ async fn init_queued_coverart(
     bytes: Vec<u8>,
 ) -> crate::queued_item::QueuedCoverArt {
     // TODO: Consider separating song and coverart when saving to the filesystem
-    let covart_type = if file_type == icarus_meta::detection::coverart::constants::PNG_TYPE {
-        icarus_models::types::CoverArtType::PngExtension
-    } else if file_type == icarus_meta::detection::coverart::constants::JPEG_TYPE {
-        icarus_models::types::CoverArtType::JpegExtension
-    } else if file_type == icarus_meta::detection::coverart::constants::JPG_TYPE {
-        icarus_models::types::CoverArtType::JpgExtension
+    let covart_type = if file_type == simeta::detection::coverart::constants::PNG_TYPE {
+        simodels::types::CoverArtType::PngExtension
+    } else if file_type == simeta::detection::coverart::constants::JPEG_TYPE {
+        simodels::types::CoverArtType::JpegExtension
+    } else if file_type == simeta::detection::coverart::constants::JPG_TYPE {
+        simodels::types::CoverArtType::JpgExtension
     } else {
-        icarus_models::types::CoverArtType::None
+        simodels::types::CoverArtType::None
     };
-    let coverart = icarus_models::coverart::CoverArt {
-        directory: icarus_envy::environment::get_root_directory().value,
-        filename: match icarus_models::coverart::generate_filename(covart_type, true) {
+    let coverart = simodels::coverart::CoverArt {
+        directory: sienvy::environment::get_root_directory().value,
+        filename: match simodels::coverart::generate_filename(covart_type, true) {
             Ok(filename) => filename,
             Err(err) => {
                 eprintln!("Error generating CoverArt filename: {err:?}");
@@ -255,8 +254,8 @@ async fn init_queued_coverart(
 }
 
 pub async fn cleanup(
-    song: &icarus_models::song::Song,
-    coverart: &icarus_models::coverart::CoverArt,
+    song: &simodels::song::Song,
+    coverart: &simodels::coverart::CoverArt,
 ) -> Result<(), std::io::Error> {
     match song.remove_from_filesystem() {
         Ok(_) => {}

src/queued_item.rs

@@ -1,13 +1,13 @@
 #[derive(Clone, Debug, Default)]
 pub struct QueuedSong {
     pub id: uuid::Uuid,
-    pub song: icarus_models::song::Song,
+    pub song: simodels::song::Song,
     pub path: String,
 }
 
 #[derive(Clone, Debug, Default)]
 pub struct QueuedCoverArt {
     pub id: uuid::Uuid,
-    pub coverart: icarus_models::coverart::CoverArt,
+    pub coverart: simodels::coverart::CoverArt,
     pub path: String,
 }