phoenix
67d2729c46
All checks were successful
Rust Build / Check (pull_request) Successful in 38s
Rust Build / Clippy (pull_request) Successful in 34s
Rust Build / Rustfmt (pull_request) Successful in 38s
Rust Build / Test Suite (pull_request) Successful in 38s
Rust Build / build (pull_request) Successful in 35s
607 lines
24 KiB
Rust
607 lines
24 KiB
Rust
pub mod api;
|
|
pub mod config;
|
|
pub mod responses;
|
|
pub mod the_rest;
|
|
pub mod update_queued_song;
|
|
pub mod util;
|
|
|
|
use std::io::Write;
|
|
|
|
pub const SECONDS_TO_SLEEP: u64 = 5;
|
|
|
|
#[tokio::main]
|
|
async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
|
let mut app = config::App {
|
|
uri: icarus_envy::environment::get_icarus_base_api_url().await,
|
|
auth_uri: icarus_envy::environment::get_icarus_auth_base_api_url().await,
|
|
..Default::default()
|
|
};
|
|
match auth::get_token(&app).await {
|
|
Ok(login_result) => {
|
|
app.token = login_result;
|
|
}
|
|
Err(err) => {
|
|
eprintln!("Error: {err:?}");
|
|
std::process::exit(-1);
|
|
}
|
|
};
|
|
|
|
loop {
|
|
println!("Base URL: {:?}", app.uri);
|
|
println!("Auth URL: {:?}", app.auth_uri);
|
|
println!("Token: {:?}", app.token);
|
|
|
|
if auth::did_token_expire(&app.token).await {
|
|
println!("Token expired");
|
|
app.token = match auth::get_refresh_token(&app).await {
|
|
Ok(login_result) => login_result,
|
|
Err(err) => {
|
|
eprintln!("Error: {err:?}");
|
|
continue;
|
|
}
|
|
};
|
|
|
|
println!("Token refreshed");
|
|
println!("Refreshed token: {:?}", app.token);
|
|
} else {
|
|
println!("Token did not expire");
|
|
}
|
|
|
|
match is_queue_empty(&app).await {
|
|
Ok((empty, song_queue_item)) => {
|
|
if !empty {
|
|
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, &song_queue_id, &user_id).await {
|
|
Ok((
|
|
_song,
|
|
_coverart,
|
|
(song_queue_id, song_queue_path),
|
|
(coverart_queue_id, coverart_queue_path),
|
|
)) => {
|
|
match wipe_data_from_queues(&app, &song_queue_id, &coverart_queue_id)
|
|
.await
|
|
{
|
|
Ok(_) => {
|
|
match cleanup(&song_queue_path, &coverart_queue_path).await {
|
|
Ok(_) => {
|
|
println!("Successful cleanup");
|
|
}
|
|
Err(err) => {
|
|
eprintln!("Error: {err:?}");
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
eprintln!("Error: {err:?}");
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
eprintln!("Error: {err:?}");
|
|
}
|
|
}
|
|
} else {
|
|
println!("Queue is empty");
|
|
}
|
|
}
|
|
Err(err) => {
|
|
eprintln!("Error checking if queue is empty: {err:?}");
|
|
}
|
|
}
|
|
|
|
println!("Sleeping");
|
|
tokio::time::sleep(tokio::time::Duration::from_secs(SECONDS_TO_SLEEP)).await;
|
|
}
|
|
}
|
|
|
|
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,
|
|
});
|
|
|
|
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,
|
|
coverart_queue_id: &uuid::Uuid,
|
|
) -> Result<(), std::io::Error> {
|
|
match the_rest::wipe_data::song_queue::wipe_data(app, song_queue_id).await {
|
|
Ok(response) => match response
|
|
.json::<the_rest::wipe_data::song_queue::response::Response>()
|
|
.await
|
|
{
|
|
Ok(_resp) => {
|
|
match the_rest::wipe_data::coverart_queue::wipe_data(app, coverart_queue_id).await {
|
|
Ok(inner_response) => match inner_response
|
|
.json::<the_rest::wipe_data::coverart_queue::response::Response>()
|
|
.await
|
|
{
|
|
Ok(_inner_resp) => {
|
|
println!("Wiped data from CoverArt queue");
|
|
println!("Resp: {_inner_resp:?}");
|
|
Ok(())
|
|
}
|
|
Err(err) => Err(std::io::Error::other(err.to_string())),
|
|
},
|
|
Err(err) => Err(std::io::Error::other(err.to_string())),
|
|
}
|
|
}
|
|
Err(err) => Err(std::io::Error::other(err.to_string())),
|
|
},
|
|
Err(err) => Err(std::io::Error::other(err.to_string())),
|
|
}
|
|
}
|
|
|
|
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(
|
|
app: &config::App,
|
|
) -> Result<(bool, responses::fetch_next_queue_item::SongQueueItem), reqwest::Error> {
|
|
match api::fetch_next_queue_item(app).await {
|
|
Ok(response) => {
|
|
match response
|
|
.json::<responses::fetch_next_queue_item::SongQueueItem>()
|
|
.await
|
|
{
|
|
Ok(response) => {
|
|
if response.data.is_empty() {
|
|
Ok((true, response))
|
|
} else {
|
|
Ok((false, response))
|
|
}
|
|
}
|
|
Err(err) => Err(err),
|
|
}
|
|
}
|
|
Err(err) => Err(err),
|
|
}
|
|
}
|
|
|
|
async fn some_work(
|
|
app: &crate::config::App,
|
|
song_queue_id: &uuid::Uuid,
|
|
user_id: &uuid::Uuid,
|
|
) -> Result<
|
|
(
|
|
icarus_models::song::Song,
|
|
icarus_models::coverart::CoverArt,
|
|
(uuid::Uuid, String),
|
|
(uuid::Uuid, String),
|
|
),
|
|
std::io::Error,
|
|
> {
|
|
match prep_song(app, song_queue_id).await {
|
|
Ok((song_queue_path, coverart_queue_path, metadata, coverart_queue_id)) => {
|
|
match apply_metadata(&song_queue_path, &coverart_queue_path, &metadata).await {
|
|
Ok(_applied) => {
|
|
match update_queued_song::update_queued_song(
|
|
app,
|
|
&song_queue_path,
|
|
song_queue_id,
|
|
)
|
|
.await
|
|
{
|
|
Ok(response) => {
|
|
match response
|
|
.json::<update_queued_song::response::Response>()
|
|
.await
|
|
{
|
|
Ok(_inner_response) => {
|
|
println!("Response: {_inner_response:?}");
|
|
|
|
// TODO: Place this somewhere else
|
|
let song_type = String::from("flac");
|
|
|
|
match the_rest::create_song::create(
|
|
app, &metadata, user_id, &song_type,
|
|
)
|
|
.await
|
|
{
|
|
Ok(response) => match response
|
|
.json::<the_rest::create_song::response::Response>()
|
|
.await
|
|
{
|
|
Ok(resp) => {
|
|
println!("Response: {resp:?}");
|
|
|
|
let song = &resp.data[0];
|
|
match the_rest::create_coverart::create(app, &song.id, &coverart_queue_id).await {
|
|
Ok(response) => match response.json::<the_rest::create_coverart::response::Response>().await {
|
|
Ok(resp) => {
|
|
println!("CoverArt sent and successfully parsed response");
|
|
println!("json: {resp:?}");
|
|
let coverart = &resp.data[0];
|
|
Ok((song.clone(), coverart.clone(), (metadata.song_queue_id, song_queue_path), (coverart_queue_id, coverart_queue_path)))
|
|
}
|
|
Err(err) => {
|
|
Err(std::io::Error::other(err.to_string()))
|
|
}
|
|
}
|
|
Err(err) => {
|
|
Err(std::io::Error::other(err.to_string()))
|
|
}
|
|
}
|
|
}
|
|
Err(err) => Err(std::io::Error::other(err.to_string())),
|
|
},
|
|
Err(err) => Err(std::io::Error::other(err.to_string())),
|
|
}
|
|
}
|
|
Err(err) => Err(std::io::Error::other(err.to_string())),
|
|
}
|
|
}
|
|
Err(err) => Err(std::io::Error::other(err.to_string())),
|
|
}
|
|
}
|
|
Err(err) => Err(err),
|
|
}
|
|
}
|
|
Err(err) => Err(std::io::Error::other(err.to_string())),
|
|
}
|
|
}
|
|
|
|
async fn prep_song(
|
|
app: &crate::config::App,
|
|
song_queue_id: &uuid::Uuid,
|
|
) -> Result<
|
|
(
|
|
String,
|
|
String,
|
|
api::get_metadata_queue::response::Metadata,
|
|
uuid::Uuid,
|
|
),
|
|
reqwest::Error,
|
|
> {
|
|
match api::fetch_song_queue_data::get_data(app, song_queue_id).await {
|
|
Ok(response) => {
|
|
// Process data here...
|
|
match api::parsing::parse_response_into_bytes(response).await {
|
|
Ok(song_bytes) => {
|
|
let (directory, filename) = generate_song_queue_dir_and_filename().await;
|
|
let song_queue_path = save_file_to_fs(&directory, &filename, &song_bytes).await;
|
|
|
|
println!("Saved at: {song_queue_path:?}");
|
|
|
|
match api::get_metadata_queue::get(app, song_queue_id).await {
|
|
Ok(response) => {
|
|
match response
|
|
.json::<api::get_metadata_queue::response::Response>()
|
|
.await
|
|
{
|
|
Ok(response) => {
|
|
let id = &response.data[0].id;
|
|
let created_at = &response.data[0].created_at;
|
|
let metadata = &response.data[0].metadata;
|
|
println!("Id: {id:?}");
|
|
println!("Metadata: {metadata:?}");
|
|
println!("Created at: {created_at:?}");
|
|
|
|
println!("Getting coverart queue");
|
|
match api::get_coverart_queue::get(app, song_queue_id).await {
|
|
Ok(response) => {
|
|
match response.json::<api::get_coverart_queue::response::Response>().await {
|
|
Ok(response) => {
|
|
let coverart_queue_id = &response.data[0].id;
|
|
println!("Coverart queue Id: {coverart_queue_id:?}");
|
|
|
|
match api::get_coverart_queue::get_data(app, coverart_queue_id).await {
|
|
Ok(response) => match api::parsing::parse_response_into_bytes(response).await {
|
|
Ok(coverart_queue_bytes) => {
|
|
let (directory, filename) = generate_coverart_queue_dir_and_filename().await;
|
|
let coverart_queue_path = save_file_to_fs(&directory, &filename, &coverart_queue_bytes).await;
|
|
|
|
println!("Saved coverart queue file at: {coverart_queue_path:?}");
|
|
|
|
let c_path = util::path_buf_to_string(&coverart_queue_path);
|
|
let s_path = util::path_buf_to_string(&song_queue_path);
|
|
Ok((s_path, c_path, metadata.clone(), *coverart_queue_id))
|
|
}
|
|
Err(err) => {
|
|
Err(err)
|
|
}
|
|
}
|
|
Err(err) => {
|
|
Err(err)
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
Err(err)
|
|
}
|
|
}
|
|
}
|
|
Err(err) => Err(err),
|
|
}
|
|
}
|
|
Err(err) => Err(err),
|
|
}
|
|
}
|
|
Err(err) => Err(err),
|
|
}
|
|
}
|
|
Err(err) => Err(err),
|
|
}
|
|
}
|
|
Err(err) => Err(err),
|
|
}
|
|
}
|
|
|
|
// TODO: Consider having something like this in icarus_models
|
|
pub async fn generate_song_queue_dir_and_filename() -> (String, String) {
|
|
let mut song = icarus_models::song::Song::default();
|
|
song.filename = song.generate_filename(icarus_models::types::MusicTypes::FlacExtension, true);
|
|
|
|
song.directory = icarus_envy::environment::get_root_directory().await;
|
|
|
|
(song.directory, song.filename)
|
|
}
|
|
|
|
// TODO: Consider having something like this in icarus_models
|
|
pub async fn generate_coverart_queue_dir_and_filename() -> (String, String) {
|
|
use rand::Rng;
|
|
|
|
let mut filename: String = String::new();
|
|
let filename_len = 10;
|
|
|
|
let some_chars: String = String::from("abcdefghij0123456789");
|
|
let mut rng = rand::rng();
|
|
|
|
for _i in 0..filename_len {
|
|
let random_number: i32 = rng.random_range(0..=19);
|
|
let index = random_number as usize;
|
|
let rando_char = some_chars.chars().nth(index);
|
|
|
|
if let Some(c) = rando_char {
|
|
filename.push(c);
|
|
}
|
|
}
|
|
|
|
// TODO: Do not hard code the file extension
|
|
filename += ".jpeg";
|
|
|
|
// TODO: Consider separating song and coverart when saving to the filesystem
|
|
let directory = icarus_envy::environment::get_root_directory().await;
|
|
|
|
(directory, filename)
|
|
}
|
|
|
|
// TODO: Check to see if this is available in icarus_models
|
|
pub async fn save_file_to_fs(
|
|
directory: &String,
|
|
filename: &String,
|
|
data: &[u8],
|
|
) -> std::path::PathBuf {
|
|
// TODO: Add function to save bytes to a file in icarus_models
|
|
// repo
|
|
let dir = std::path::Path::new(directory);
|
|
let save_path = dir.join(filename);
|
|
|
|
let mut file = std::fs::File::create(&save_path).unwrap();
|
|
file.write_all(data).unwrap();
|
|
|
|
save_path
|
|
}
|
|
|
|
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),
|
|
}
|
|
}
|