tsk-55: Utilize the expiration methods in icarus_models (#59)

Closes #55

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

Cargo.lock

@@ -1293,7 +1293,7 @@ dependencies = [
 
 [[package]]
 name = "songparser"
-version = "0.4.2"
+version = "0.4.3"
 dependencies = [
  "futures",
  "icarus_envy",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "songparser"
-version = "0.4.2"
+version = "0.4.3"
 edition = "2024"
 rust-version = "1.90"
 

src/auth/mod.rs

@@ -0,0 +1,57 @@
+pub async fn get_token(
+    app: &crate::config::App,
+) -> Result<icarus_models::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().await.value,
+    });
+
+    match client.post(api_url).json(&payload).send().await {
+        Ok(response) => match response
+            .json::<crate::api::service_token::response::Response>()
+            .await
+        {
+            Ok(resp) => {
+                if resp.data.is_empty() {
+                    Err(std::io::Error::other(String::from("No token returned")))
+                } else {
+                    Ok(resp.data[0].clone())
+                }
+            }
+            Err(err) => Err(std::io::Error::other(err.to_string())),
+        },
+        Err(err) => Err(std::io::Error::other(err.to_string())),
+    }
+}
+
+pub async fn get_refresh_token(
+    app: &crate::config::App,
+) -> Result<icarus_models::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);
+
+    let payload = serde_json::json!({
+        "access_token": app.token.token
+    });
+
+    match client.post(api_url).json(&payload).send().await {
+        Ok(response) => match response
+            .json::<crate::api::refresh_token::response::Response>()
+            .await
+        {
+            Ok(resp) => {
+                if resp.data.is_empty() {
+                    Err(std::io::Error::other(String::from("No token returned")))
+                } else {
+                    Ok(resp.data[0].clone())
+                }
+            }
+            Err(err) => Err(std::io::Error::other(err.to_string())),
+        },
+        Err(err) => Err(std::io::Error::other(err.to_string())),
+    }
+}

src/main.rs

@@ -1,5 +1,7 @@
 pub mod api;
+pub mod auth;
 pub mod config;
+pub mod metadata;
 pub mod util;
 
 pub const SECONDS_TO_SLEEP: u64 = 5;
@@ -31,7 +33,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     loop {
         println!("Token: {:?}", app.token);
 
-        if auth::did_token_expire(&app.token).await {
+        if app.token.token_expired() {
             println!("Token expired");
             app.token = match auth::get_refresh_token(&app).await {
                 Ok(login_result) => login_result,
@@ -97,74 +99,6 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     }
 }
 
-mod auth {
-    pub async fn get_token(
-        app: &crate::config::App,
-    ) -> Result<icarus_models::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().await.value,
-        });
-
-        match client.post(api_url).json(&payload).send().await {
-            Ok(response) => match response
-                .json::<crate::api::service_token::response::Response>()
-                .await
-            {
-                Ok(resp) => {
-                    if resp.data.is_empty() {
-                        Err(std::io::Error::other(String::from("No token returned")))
-                    } else {
-                        Ok(resp.data[0].clone())
-                    }
-                }
-                Err(err) => Err(std::io::Error::other(err.to_string())),
-            },
-            Err(err) => Err(std::io::Error::other(err.to_string())),
-        }
-    }
-
-    // TODO: Might want to put the functionality within icarus_models at some point
-    pub async fn did_token_expire(login_result: &icarus_models::login_result::LoginResult) -> bool {
-        let current_time = time::OffsetDateTime::now_utc();
-        let expire_time =
-            time::OffsetDateTime::from_unix_timestamp(login_result.expiration).unwrap();
-        current_time > expire_time
-    }
-
-    pub async fn get_refresh_token(
-        app: &crate::config::App,
-    ) -> Result<icarus_models::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);
-
-        let payload = serde_json::json!({
-            "access_token": app.token.token
-        });
-
-        match client.post(api_url).json(&payload).send().await {
-            Ok(response) => match response
-                .json::<crate::api::refresh_token::response::Response>()
-                .await
-            {
-                Ok(resp) => {
-                    if resp.data.is_empty() {
-                        Err(std::io::Error::other(String::from("No token returned")))
-                    } else {
-                        Ok(resp.data[0].clone())
-                    }
-                }
-                Err(err) => Err(std::io::Error::other(err.to_string())),
-            },
-            Err(err) => Err(std::io::Error::other(err.to_string())),
-        }
-    }
-}
-
 async fn wipe_data_from_queues(
     app: &config::App,
     song_queue_id: &uuid::Uuid,
@@ -279,7 +213,8 @@ async fn some_work(
 
             println!("CoverArt path: {coverart_queue_path:?}");
 
-            match apply_metadata(&song_queue_path, &coverart_queue_path, &metadata).await {
+            match metadata::apply_metadata(&song_queue_path, &coverart_queue_path, &metadata).await
+            {
                 Ok(_applied) => {
                     match api::update_queued_song::update_queued_song(
                         app,
@@ -505,143 +440,3 @@ pub async fn generate_coverart_queue_dir_and_filename() -> (String, String) {
 
     (directory, filename)
 }
-
-pub async fn apply_metadata(
-    song_queue_path: &String,
-    coverart_queue_path: &String,
-    metadata: &api::get_metadata_queue::response::Metadata,
-) -> Result<bool, std::io::Error> {
-    // Apply metadata fields
-    let types = icarus_meta::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, song_queue_path, meta_type) {
-                    Ok(_) => {}
-                    Err(_err) => {
-                        return Err(_err);
-                    }
-                }
-            }
-            icarus_meta::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, song_queue_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, song_queue_path, meta_type) {
-                    Ok(_) => {}
-                    Err(_err) => {
-                        return Err(_err);
-                    }
-                }
-            }
-            icarus_meta::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, song_queue_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, song_queue_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, song_queue_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, song_queue_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, song_queue_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, song_queue_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, song_queue_path, meta_type) {
-                    Ok(_) => {}
-                    Err(_err) => {
-                        return Err(_err);
-                    }
-                }
-            }
-        }
-    }
-
-    // Apply coverart
-    match icarus_meta::meta::coverart::contains_coverart(song_queue_path) {
-        Ok((exists, size)) => {
-            if exists {
-                println!("Coverart exists: {size:?} size");
-                match icarus_meta::meta::coverart::remove_coverart(song_queue_path) {
-                    Ok(_data) => {}
-                    Err(err) => {
-                        return Err(err);
-                    }
-                }
-            }
-
-            match icarus_meta::meta::coverart::set_coverart(song_queue_path, coverart_queue_path) {
-                Ok(_data) => {
-                    if _data.is_empty() {
-                        println!("There was an issue");
-                        Ok(false)
-                    } else {
-                        println!("Success in applying coverart to song");
-                        Ok(true)
-                    }
-                }
-                Err(err) => Err(err),
-            }
-        }
-        Err(err) => Err(err),
-    }
-}

src/metadata/mod.rs

@@ -0,0 +1,139 @@
+pub async fn apply_metadata(
+    song_queue_path: &String,
+    coverart_queue_path: &String,
+    metadata: &crate::api::get_metadata_queue::response::Metadata,
+) -> Result<bool, std::io::Error> {
+    // Apply metadata fields
+    let types = icarus_meta::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, song_queue_path, meta_type) {
+                    Ok(_) => {}
+                    Err(_err) => {
+                        return Err(_err);
+                    }
+                }
+            }
+            icarus_meta::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, song_queue_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, song_queue_path, meta_type) {
+                    Ok(_) => {}
+                    Err(_err) => {
+                        return Err(_err);
+                    }
+                }
+            }
+            icarus_meta::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, song_queue_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, song_queue_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, song_queue_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, song_queue_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, song_queue_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, song_queue_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, song_queue_path, meta_type) {
+                    Ok(_) => {}
+                    Err(_err) => {
+                        return Err(_err);
+                    }
+                }
+            }
+        }
+    }
+
+    // Apply coverart
+    match icarus_meta::meta::coverart::contains_coverart(song_queue_path) {
+        Ok((exists, size)) => {
+            if exists {
+                println!("Coverart exists: {size:?} size");
+                match icarus_meta::meta::coverart::remove_coverart(song_queue_path) {
+                    Ok(_data) => {}
+                    Err(err) => {
+                        return Err(err);
+                    }
+                }
+            }
+
+            match icarus_meta::meta::coverart::set_coverart(song_queue_path, coverart_queue_path) {
+                Ok(_data) => {
+                    if _data.is_empty() {
+                        println!("There was an issue");
+                        Ok(false)
+                    } else {
+                        println!("Success in applying coverart to song");
+                        Ok(true)
+                    }
+                }
+                Err(err) => Err(err),
+            }
+        }
+        Err(err) => Err(err),
+    }
+}