tsk-176: Get all songs endpoint (#177)

* tsk-176: Added function to retrieve all songs

* tsk-176: Depdendency version bump

icarus_envy, icarus_meta, and icarus_models

* tsk-176: Fix after icarus_models change

* tsk-176: Test fix

* tsk-176: Formatting

* tsk-176: Endpoint is now available

* tsk-176: Added test

* tsk-176: Cleanup

* tsk-176: Version bump

src/callers/mod.rs

@@ -17,6 +17,7 @@ pub mod endpoints {
 
     pub const CREATESONG: &str = "/api/v2/song";
     pub const GETSONGS: &str = "/api/v2/song";
+    pub const GETALLSONGS: &str = "/api/v2/song/all";
     pub const STREAMSONG: &str = "/api/v2/song/stream/{id}";
     pub const DOWNLOADSONG: &str = "/api/v2/song/download/{id}";
     pub const DELETESONG: &str = "/api/v2/song/{id}";

src/callers/song.rs

@@ -351,6 +351,108 @@ pub mod song_db {
         }
     }
 
+    pub async fn get_all_songs(
+        pool: &sqlx::PgPool,
+    ) -> Result<Vec<icarus_models::song::Song>, sqlx::Error> {
+        let result = sqlx::query(
+            r#"
+            SELECT * FROM "song";
+            "#,
+        )
+        .fetch_all(pool)
+        .await
+        .map_err(|e| {
+            eprintln!("Error querying data: {e:?}");
+        });
+
+        match result {
+            Ok(rows) => {
+                let mut songs: Vec<icarus_models::song::Song> = Vec::new();
+
+                for row in rows {
+                    let date_created_time: time::OffsetDateTime = row
+                        .try_get("date_created")
+                        .map_err(|_e| sqlx::Error::RowNotFound)
+                        .unwrap();
+
+                    let song = icarus_models::song::Song {
+                        id: row
+                            .try_get("id")
+                            .map_err(|_e| sqlx::Error::RowNotFound)
+                            .unwrap(),
+                        title: row
+                            .try_get("title")
+                            .map_err(|_e| sqlx::Error::RowNotFound)
+                            .unwrap(),
+                        artist: row
+                            .try_get("artist")
+                            .map_err(|_e| sqlx::Error::RowNotFound)
+                            .unwrap(),
+                        album_artist: row
+                            .try_get("album_artist")
+                            .map_err(|_e| sqlx::Error::RowNotFound)
+                            .unwrap(),
+                        album: row
+                            .try_get("album")
+                            .map_err(|_e| sqlx::Error::RowNotFound)
+                            .unwrap(),
+                        genre: row
+                            .try_get("genre")
+                            .map_err(|_e| sqlx::Error::RowNotFound)
+                            .unwrap(),
+                        year: row
+                            .try_get("year")
+                            .map_err(|_e| sqlx::Error::RowNotFound)
+                            .unwrap(),
+                        track: row
+                            .try_get("track")
+                            .map_err(|_e| sqlx::Error::RowNotFound)
+                            .unwrap(),
+                        disc: row
+                            .try_get("disc")
+                            .map_err(|_e| sqlx::Error::RowNotFound)
+                            .unwrap(),
+                        track_count: row
+                            .try_get("track_count")
+                            .map_err(|_e| sqlx::Error::RowNotFound)
+                            .unwrap(),
+                        disc_count: row
+                            .try_get("disc_count")
+                            .map_err(|_e| sqlx::Error::RowNotFound)
+                            .unwrap(),
+                        duration: row
+                            .try_get("duration")
+                            .map_err(|_e| sqlx::Error::RowNotFound)
+                            .unwrap(),
+                        audio_type: row
+                            .try_get("audio_type")
+                            .map_err(|_e| sqlx::Error::RowNotFound)
+                            .unwrap(),
+                        filename: row
+                            .try_get("filename")
+                            .map_err(|_e| sqlx::Error::RowNotFound)
+                            .unwrap(),
+                        directory: row
+                            .try_get("directory")
+                            .map_err(|_e| sqlx::Error::RowNotFound)
+                            .unwrap(),
+                        date_created: date_created_time.to_string(),
+                        user_id: row
+                            .try_get("user_id")
+                            .map_err(|_e| sqlx::Error::RowNotFound)
+                            .unwrap(),
+                        data: Vec::new(),
+                    };
+
+                    songs.push(song);
+                }
+
+                Ok(songs)
+            }
+            Err(_err) => Err(sqlx::Error::RowNotFound),
+        }
+    }
+
     pub async fn delete_song(
         pool: &sqlx::PgPool,
         id: &uuid::Uuid,
@@ -1126,6 +1228,27 @@ pub mod endpoint {
         }
     }
 
+    pub async fn get_all_songs(
+        axum::Extension(pool): axum::Extension<sqlx::PgPool>,
+    ) -> (
+        axum::http::StatusCode,
+        axum::Json<super::response::get_songs::Response>,
+    ) {
+        let mut response = super::response::get_songs::Response::default();
+
+        match super::song_db::get_all_songs(&pool).await {
+            Ok(songs) => {
+                response.message = String::from(super::super::response::SUCCESSFUL);
+                response.data = songs;
+                (axum::http::StatusCode::OK, axum::Json(response))
+            }
+            Err(err) => {
+                response.message = err.to_string();
+                (axum::http::StatusCode::NOT_FOUND, axum::Json(response))
+            }
+        }
+    }
+
     pub async fn stream_song(
         axum::Extension(pool): axum::Extension<sqlx::PgPool>,
         axum::extract::Path(id): axum::extract::Path<uuid::Uuid>,