icarus_models -> simodels

src/auth/mod.rs

@@ -40,7 +40,7 @@ pub async fn auth<B>(
 
     let mut validation = Validation::new(jsonwebtoken::Algorithm::HS256);
     validation.set_audience(&["icarus"]); // Must match exactly what's in the token
-    let _claims = decode::<icarus_models::token::UserClaims>(
+    let _claims = decode::<simodels::token::UserClaims>(
         &token,
         &DecodingKey::from_secret(secret_key.as_ref()),
         &validation,

src/callers/coverart.rs

@@ -20,7 +20,7 @@ pub mod response {
         #[derive(Debug, Default, serde::Deserialize, serde::Serialize, utoipa::ToSchema)]
         pub struct Response {
             pub message: String,
-            pub data: Vec<icarus_models::coverart::CoverArt>,
+            pub data: Vec<simodels::coverart::CoverArt>,
         }
     }
 
@@ -28,7 +28,7 @@ pub mod response {
         #[derive(Debug, Default, serde::Deserialize, serde::Serialize, utoipa::ToSchema)]
         pub struct Response {
             pub message: String,
-            pub data: Vec<icarus_models::coverart::CoverArt>,
+            pub data: Vec<simodels::coverart::CoverArt>,
         }
     }
 }
@@ -74,15 +74,15 @@ pub mod endpoint {
                         let coverart_type = if file_type.file_type
                             == icarus_meta::detection::coverart::constants::JPEG_TYPE
                         {
-                            icarus_models::types::CoverArtType::JpegExtension
+                            simodels::types::CoverArtType::JpegExtension
                         } else if file_type.file_type
                             == icarus_meta::detection::coverart::constants::JPG_TYPE
                         {
-                            icarus_models::types::CoverArtType::JpgExtension
+                            simodels::types::CoverArtType::JpgExtension
                         } else if file_type.file_type
                             == icarus_meta::detection::coverart::constants::PNG_TYPE
                         {
-                            icarus_models::types::CoverArtType::PngExtension
+                            simodels::types::CoverArtType::PngExtension
                         } else {
                             response.message = String::from("Invalid CoverArt type");
                             return (
@@ -91,13 +91,11 @@ pub mod endpoint {
                             );
                         };
                         let filename =
-                            icarus_models::coverart::generate_filename(coverart_type, true)
-                                .unwrap();
+                            simodels::coverart::generate_filename(coverart_type, true).unwrap();
 
-                        let mut coverart =
-                            icarus_models::coverart::init::init_coverart_dir_and_filename(
-                                &directory, &filename,
-                            );
+                        let mut coverart = simodels::coverart::init::init_coverart_dir_and_filename(
+                            &directory, &filename,
+                        );
                         coverart.title = song.album.clone();
                         coverart.file_type = file_type.file_type;
                         coverart.data = data;
@@ -200,7 +198,7 @@ pub mod endpoint {
         axum::extract::Path(id): axum::extract::Path<uuid::Uuid>,
     ) -> (axum::http::StatusCode, axum::response::Response) {
         match repo::coverart::get_coverart(&pool, &id).await {
-            Ok(coverart) => match icarus_models::coverart::io::to_data(&coverart) {
+            Ok(coverart) => match simodels::coverart::io::to_data(&coverart) {
                 Ok(data) => {
                     let (file_type, img_type) =
                         match icarus_meta::detection::coverart::file_type_from_data(&data) {
@@ -208,15 +206,15 @@ pub mod endpoint {
                                 if file_type.file_type
                                     == icarus_meta::detection::coverart::constants::JPEG_TYPE
                                 {
-                                    (file_type, icarus_models::types::CoverArtType::JpegExtension)
+                                    (file_type, simodels::types::CoverArtType::JpegExtension)
                                 } else if file_type.file_type
                                     == icarus_meta::detection::coverart::constants::JPG_TYPE
                                 {
-                                    (file_type, icarus_models::types::CoverArtType::JpgExtension)
+                                    (file_type, simodels::types::CoverArtType::JpgExtension)
                                 } else if file_type.file_type
                                     == icarus_meta::detection::coverart::constants::PNG_TYPE
                                 {
-                                    (file_type, icarus_models::types::CoverArtType::PngExtension)
+                                    (file_type, simodels::types::CoverArtType::PngExtension)
                                 } else {
                                     return (
                                         axum::http::StatusCode::INTERNAL_SERVER_ERROR,
@@ -235,8 +233,7 @@ pub mod endpoint {
                     let bytes = axum::body::Bytes::from(data);
                     let mut response = bytes.into_response();
                     let headers = response.headers_mut();
-                    let filename =
-                        icarus_models::coverart::generate_filename(img_type, true).unwrap();
+                    let filename = simodels::coverart::generate_filename(img_type, true).unwrap();
                     headers.insert(
                         axum::http::header::CONTENT_TYPE,
                         file_type.mime.parse().unwrap(),

src/callers/queue/coverart.rs

@@ -331,23 +331,22 @@ pub mod endpoint {
                 let coverart_type = if file_type.file_type
                     == icarus_meta::detection::coverart::constants::JPEG_TYPE
                 {
-                    icarus_models::types::CoverArtType::JpegExtension
+                    simodels::types::CoverArtType::JpegExtension
                 } else if file_type.file_type
                     == icarus_meta::detection::coverart::constants::JPG_TYPE
                 {
-                    icarus_models::types::CoverArtType::JpgExtension
+                    simodels::types::CoverArtType::JpgExtension
                 } else if file_type.file_type
                     == icarus_meta::detection::coverart::constants::PNG_TYPE
                 {
-                    icarus_models::types::CoverArtType::PngExtension
+                    simodels::types::CoverArtType::PngExtension
                 } else {
                     return (
                         axum::http::StatusCode::INTERNAL_SERVER_ERROR,
                         axum::response::Response::default(),
                     );
                 };
-                let filename =
-                    icarus_models::coverart::generate_filename(coverart_type, true).unwrap();
+                let filename = simodels::coverart::generate_filename(coverart_type, true).unwrap();
                 headers.insert(
                     axum::http::header::CONTENT_DISPOSITION,
                     format!("attachment; filename=\"{filename}\"")

src/callers/song.rs

@@ -36,8 +36,8 @@ pub mod request {
                     || !self.song_queue_id.is_nil()
             }
 
-            pub fn to_song(&self) -> icarus_models::song::Song {
-                icarus_models::song::Song {
+            pub fn to_song(&self) -> simodels::song::Song {
+                simodels::song::Song {
                     id: uuid::Uuid::nil(),
                     title: self.title.clone(),
                     artist: self.artist.clone(),
@@ -71,7 +71,7 @@ pub mod response {
         #[derive(Debug, Default, serde::Deserialize, serde::Serialize, utoipa::ToSchema)]
         pub struct Response {
             pub message: String,
-            pub data: Vec<icarus_models::song::Song>,
+            pub data: Vec<simodels::song::Song>,
         }
     }
 
@@ -79,15 +79,15 @@ pub mod response {
         #[derive(Debug, Default, serde::Deserialize, serde::Serialize, utoipa::ToSchema)]
         pub struct Response {
             pub message: String,
-            pub data: Vec<icarus_models::song::Song>,
+            pub data: Vec<simodels::song::Song>,
         }
     }
 
     pub mod delete_song {
         #[derive(Debug, Default, serde::Deserialize, serde::Serialize, utoipa::ToSchema)]
         pub struct SongAndCoverArt {
-            pub song: icarus_models::song::Song,
-            pub coverart: icarus_models::coverart::CoverArt,
+            pub song: simodels::song::Song,
+            pub coverart: simodels::coverart::CoverArt,
         }
 
         #[derive(Debug, Default, serde::Deserialize, serde::Serialize, utoipa::ToSchema)]
@@ -134,11 +134,9 @@ pub mod endpoint {
 
         if payload.is_valid() {
             let mut song = payload.to_song();
-            song.filename = icarus_models::song::generate_filename(
-                icarus_models::types::MusicType::FlacExtension,
-                true,
-            )
-            .unwrap();
+            song.filename =
+                simodels::song::generate_filename(simodels::types::MusicType::FlacExtension, true)
+                    .unwrap();
             song.directory = sienvy::environment::get_root_directory().value;
 
             match repo_queue::song::get_data(&pool, &payload.song_queue_id).await {
@@ -340,7 +338,7 @@ pub mod endpoint {
         axum::extract::Path(id): axum::extract::Path<uuid::Uuid>,
     ) -> (axum::http::StatusCode, axum::response::Response) {
         match repo::song::get_song(&pool, &id).await {
-            Ok(song) => match icarus_models::song::io::to_data(&song) {
+            Ok(song) => match simodels::song::io::to_data(&song) {
                 Ok(data) => {
                     let bytes = axum::body::Bytes::from(data);
                     let mut response = bytes.into_response();

src/main.rs

@@ -160,14 +160,14 @@ mod tests {
         let key: String = sienvy::environment::get_secret_main_key().value;
         let (message, issuer, audience) = token_fields();
 
-        let token_resource = icarus_models::token::TokenResource {
+        let token_resource = simodels::token::TokenResource {
             message: message,
             issuer: issuer,
             audiences: vec![audience],
             id: TEST_USER_ID,
         };
 
-        match icarus_models::token::create_token(&key, &token_resource, time::Duration::hours(1)) {
+        match simodels::token::create_token(&key, &token_resource, time::Duration::hours(1)) {
             Ok((access_token, _some_time)) => Ok(access_token),
             Err(err) => Err(err),
         }
@@ -913,10 +913,10 @@ mod tests {
                             let temp_file =
                                 tempfile::tempdir().expect("Could not create test directory");
                             let test_dir = String::from(temp_file.path().to_str().unwrap());
-                            let song = icarus_models::song::Song {
+                            let song = simodels::song::Song {
                                 directory: test_dir,
-                                filename: icarus_models::song::generate_filename(
-                                    icarus_models::types::MusicType::FlacExtension,
+                                filename: simodels::song::generate_filename(
+                                    simodels::types::MusicType::FlacExtension,
                                     true,
                                 )
                                 .unwrap(),
@@ -2219,20 +2219,20 @@ mod tests {
             coverart_directory: &String,
             coverart_filename: &String,
         ) -> Result<(Vec<u8>, Vec<u8>), std::io::Error> {
-            let song = icarus_models::song::Song {
+            let song = simodels::song::Song {
                 directory: song_directory.clone(),
                 filename: song_filename.clone(),
                 ..Default::default()
             };
 
-            let coverart = icarus_models::coverart::CoverArt {
+            let coverart = simodels::coverart::CoverArt {
                 directory: coverart_directory.clone(),
                 filename: coverart_filename.clone(),
                 ..Default::default()
             };
 
-            match icarus_models::song::io::to_data(&song) {
-                Ok(song_data) => match icarus_models::coverart::io::to_data(&coverart) {
+            match simodels::song::io::to_data(&song) {
+                Ok(song_data) => match simodels::coverart::io::to_data(&coverart) {
                     Ok(coverart_data) => Ok((song_data, coverart_data)),
                     Err(err) => Err(err),
                 },
@@ -2248,14 +2248,14 @@ mod tests {
             coverart_filename: &String,
             coverart_data: Vec<u8>,
         ) -> Result<(), std::io::Error> {
-            let song = icarus_models::song::Song {
+            let song = simodels::song::Song {
                 directory: song_directory.clone(),
                 filename: song_filename.clone(),
                 data: song_data,
                 ..Default::default()
             };
 
-            let coverart = icarus_models::coverart::CoverArt {
+            let coverart = simodels::coverart::CoverArt {
                 directory: coverart_directory.clone(),
                 filename: coverart_filename.clone(),
                 data: coverart_data,

src/repo/coverart.rs

@@ -2,7 +2,7 @@ use sqlx::Row;
 
 pub async fn create(
     pool: &sqlx::PgPool,
-    coverart: &icarus_models::coverart::CoverArt,
+    coverart: &simodels::coverart::CoverArt,
     song_id: &uuid::Uuid,
 ) -> Result<uuid::Uuid, sqlx::Error> {
     let result = sqlx::query(
@@ -36,7 +36,7 @@ pub async fn create(
 pub async fn get_coverart(
     pool: &sqlx::PgPool,
     id: &uuid::Uuid,
-) -> Result<icarus_models::coverart::CoverArt, sqlx::Error> {
+) -> Result<simodels::coverart::CoverArt, sqlx::Error> {
     let result = sqlx::query(
         r#"
         SELECT id, title, directory, filename, file_type, song_id FROM "coverart" WHERE id = $1;
@@ -50,7 +50,7 @@ pub async fn get_coverart(
     });
 
     match result {
-        Ok(row) => Ok(icarus_models::coverart::CoverArt {
+        Ok(row) => Ok(simodels::coverart::CoverArt {
             id: row
                 .try_get("id")
                 .map_err(|_e| sqlx::Error::RowNotFound)
@@ -84,7 +84,7 @@ pub async fn get_coverart(
 pub async fn get_coverart_with_song_id(
     pool: &sqlx::PgPool,
     song_id: &uuid::Uuid,
-) -> Result<icarus_models::coverart::CoverArt, sqlx::Error> {
+) -> Result<simodels::coverart::CoverArt, sqlx::Error> {
     let result = sqlx::query(
         r#"
         SELECT id, title, directory, filename, file_type, song_id FROM "coverart" WHERE song_id = $1;
@@ -98,7 +98,7 @@ pub async fn get_coverart_with_song_id(
     });
 
     match result {
-        Ok(row) => Ok(icarus_models::coverart::CoverArt {
+        Ok(row) => Ok(simodels::coverart::CoverArt {
             id: row
                 .try_get("id")
                 .map_err(|_e| sqlx::Error::RowNotFound)
@@ -132,7 +132,7 @@ pub async fn get_coverart_with_song_id(
 pub async fn delete_coverart(
     pool: &sqlx::PgPool,
     id: &uuid::Uuid,
-) -> Result<icarus_models::coverart::CoverArt, sqlx::Error> {
+) -> Result<simodels::coverart::CoverArt, sqlx::Error> {
     let result = sqlx::query(
         r#"
         DELETE FROM "coverart"
@@ -148,7 +148,7 @@ pub async fn delete_coverart(
     });
 
     match result {
-        Ok(row) => Ok(icarus_models::coverart::CoverArt {
+        Ok(row) => Ok(simodels::coverart::CoverArt {
             id: row
                 .try_get("id")
                 .map_err(|_e| sqlx::Error::RowNotFound)

src/repo/song.rs

@@ -2,7 +2,7 @@ use sqlx::Row;
 
 pub async fn insert(
     pool: &sqlx::PgPool,
-    song: &icarus_models::song::Song,
+    song: &simodels::song::Song,
 ) -> Result<(time::OffsetDateTime, uuid::Uuid), sqlx::Error> {
     let result = sqlx::query(
         r#"
@@ -52,7 +52,7 @@ pub async fn insert(
 pub async fn get_song(
     pool: &sqlx::PgPool,
     id: &uuid::Uuid,
-) -> Result<icarus_models::song::Song, sqlx::Error> {
+) -> Result<simodels::song::Song, sqlx::Error> {
     let result = sqlx::query(
         r#"
         SELECT * FROM "song" WHERE id = $1
@@ -72,7 +72,7 @@ pub async fn get_song(
                 .map_err(|_e| sqlx::Error::RowNotFound)
                 .unwrap();
 
-            Ok(icarus_models::song::Song {
+            Ok(simodels::song::Song {
                 id: row
                     .try_get("id")
                     .map_err(|_e| sqlx::Error::RowNotFound)
@@ -145,9 +145,7 @@ pub async fn get_song(
     }
 }
 
-pub async fn get_all_songs(
-    pool: &sqlx::PgPool,
-) -> Result<Vec<icarus_models::song::Song>, sqlx::Error> {
+pub async fn get_all_songs(pool: &sqlx::PgPool) -> Result<Vec<simodels::song::Song>, sqlx::Error> {
     let result = sqlx::query(
         r#"
         SELECT * FROM "song";
@@ -161,7 +159,7 @@ pub async fn get_all_songs(
 
     match result {
         Ok(rows) => {
-            let mut songs: Vec<icarus_models::song::Song> = Vec::new();
+            let mut songs: Vec<simodels::song::Song> = Vec::new();
 
             for row in rows {
                 let date_created_time: time::OffsetDateTime = row
@@ -169,7 +167,7 @@ pub async fn get_all_songs(
                     .map_err(|_e| sqlx::Error::RowNotFound)
                     .unwrap();
 
-                let song = icarus_models::song::Song {
+                let song = simodels::song::Song {
                     id: row
                         .try_get("id")
                         .map_err(|_e| sqlx::Error::RowNotFound)
@@ -250,9 +248,9 @@ pub async fn get_all_songs(
 pub async fn delete_song(
     pool: &sqlx::PgPool,
     id: &uuid::Uuid,
-) -> Result<icarus_models::song::Song, sqlx::Error> {
+) -> Result<simodels::song::Song, sqlx::Error> {
     let result = sqlx::query(
-        // icarus_models::song::Song,
+        // simodels::song::Song,
         r#"
         DELETE FROM "song"
         WHERE id = $1
@@ -273,7 +271,7 @@ pub async fn delete_song(
                 .map_err(|_e| sqlx::Error::RowNotFound)
                 .unwrap();
 
-            Ok(icarus_models::song::Song {
+            Ok(simodels::song::Song {
                 id: row
                     .try_get("id")
                     .map_err(|_e| sqlx::Error::RowNotFound)