From ce3452f0fdfbb82877519c94aafbdbf20cf0d89d Mon Sep 17 00:00:00 2001 From: phoenix Date: Tue, 25 Mar 2025 21:17:50 -0400 Subject: [PATCH] Code refactoring --- src/managers/commit_manager.rs | 214 ++++++++++++++++++--------------- src/syncers/upload.rs | 101 ++-------------- 2 files changed, 127 insertions(+), 188 deletions(-) diff --git a/src/managers/commit_manager.rs b/src/managers/commit_manager.rs index 57768a3..0afa123 100644 --- a/src/managers/commit_manager.rs +++ b/src/managers/commit_manager.rs @@ -337,59 +337,72 @@ impl CommitManager { let mut cover_art = icarus_models::coverart::CoverArt { id: 0, title: String::new(), - path: String::new(), + path: cover_path.clone(), data: Vec::new(), }; - let mut filenames = Vec::new(); let file_name = std::ffi::OsString::from(&song_file.file_name().unwrap()); - let mut directory: String = String::new(); - let mut filename: String = String::new(); match self.find_file_extension(&file_name) { - En::ImageFile => {} - En::MetadataFile => {} En::SongFile => match utilities::string::o_to_string(&file_name) { Ok(s) => { println!("file name: {:?}", file_name); - filenames.push(s.clone()); - filename = s.clone(); - directory = song_file.parent().unwrap().display().to_string(); + + match icarus_models::album::collection::parse_album(&meta_path) { + Ok(album) => { + let filename = s.clone(); + let directory = song_file.parent().unwrap().display().to_string(); + let trck = i32::from_str(track_id).unwrap(); + let mut s = + retrieve_song(&album, trck, 1, &directory, &filename).unwrap(); + println!("Directory: {:?}", s.directory); + println!("Filename: {:?}", s.filename); + println!("Path: {:?}", s.song_path()); + s.data = s.to_data().unwrap(); + + cover_art.data = cover_art.to_data().unwrap(); + + let mut up = syncers::upload::Upload::default(); + let host = self.ica_action.retrieve_flag_value(&String::from("-h")); + up.set_api(&host); + + let res = up.upload_song_with_metadata(&token, &s, &cover_art); + + match Runtime::new().unwrap().block_on(res) { + Ok(o) => { + println!("Successfully sent {:?}", o); + Ok(()) + } + Err(er) => { + println!("Some error {:?}", er); + Err(std::io::Error::new( + std::io::ErrorKind::Other, + er.to_string(), + )) + } + } + } + Err(err) => { + println!("Error: {:?}", err); + Err(std::io::Error::new( + std::io::ErrorKind::Other, + err.to_string(), + )) + } + } + } + Err(er) => { + println!("Error: {:?}", er); + return Err(std::io::Error::new( + std::io::ErrorKind::Other, + er.to_string(), + )); } - Err(er) => println!("Error: {:?}", er), }, - _ => {} - } - - cover_art.path = cover_path.clone(); - - let album = self.retrieve_metadata(&meta_path); - let trck = i32::from_str(track_id).unwrap(); - let mut s = retrieve_song(&album, trck, 1, &directory, &filename).unwrap(); - println!("Directory: {:?}", s.directory); - println!("Filename: {:?}", s.filename); - println!("Path: {:?}", s.song_path()); - s.data = s.to_data().unwrap(); - - cover_art.data = cover_art.to_data().unwrap(); - - let mut up = syncers::upload::Upload::default(); - let host = self.ica_action.retrieve_flag_value(&String::from("-h")); - up.set_api(&host); - - let res = up.upload_song_with_metadata(&token, &s, &cover_art, &album); - let tken = Runtime::new().unwrap().block_on(res); - - match &tken { - Ok(o) => { - println!("Successfully sent {:?}", o); - Ok(()) - } - Err(er) => { - println!("Some error {:?}", er); - Err(std::io::Error::new( + _ => { + return Err(std::io::Error::new( std::io::ErrorKind::Other, - er.to_string(), - )) + "No sutitable file found".to_owned(), + )); } } } @@ -459,43 +472,16 @@ impl CommitManager { let mut cover_art = icarus_models::coverart::CoverArt { id: 0, title: String::new(), - path: String::new(), + path: match self.get_cover_art_path(&sourcepath) { + Ok(o) => o, + Err(_) => String::new(), + }, data: Vec::new(), }; - let mut filenames: Vec = Vec::new(); - let mut metadatapath: String = String::new(); - - // iterate files in metadatapath - let path = std::path::Path::new(directory_path); - - for entry in read_dir(path)? { - let entry = entry?; - - let file_type = entry.file_type(); - let file_name = entry.file_name(); - - println!("file type: {:?}", file_type); - println!("file name: {:?}", file_name); - - match self.find_file_extension(&file_name) { - En::ImageFile => { - let directory_part = sourcepath.clone(); - let fname = utilities::string::o_to_string(&file_name); - let fullpath = directory_part + "/" + &fname.unwrap(); - cover_art.path = fullpath; - } - En::MetadataFile => { - let directory_part = sourcepath.clone(); - let fname = utilities::string::o_to_string(&file_name); - metadatapath = directory_part + "/" + &fname.unwrap(); - } - _ => {} - } - } - - filenames.sort(); - let songs = self.get_songs(&metadatapath, &sourcepath); - let album = self.retrieve_metadata(&metadatapath); + let metadatapath = match self.get_metadata_path(&sourcepath) { + Ok(o) => o, + Err(_) => String::new(), + }; let mut up = syncers::upload::Upload::default(); let host = self.ica_action.retrieve_flag_value(&String::from("-h")); @@ -505,13 +491,13 @@ impl CommitManager { println!(""); - match songs { + match self.get_songs(&metadatapath, &sourcepath) { Ok(sngs) => { for song in sngs { - println!("Title: {:?}", song.title); - println!("Path: {:?}", song.song_path()); - let res = up.upload_song_with_metadata(&token, &song, &cover_art, &album); - match Runtime::new().unwrap().block_on(res) { + match Runtime::new() + .unwrap() + .block_on(up.upload_song_with_metadata(&token, &song, &cover_art)) + { Ok(o) => { println!("Response: {:?}", o); } @@ -575,6 +561,53 @@ impl CommitManager { return En::Other; } + fn get_cover_art_path(&self, directory_path: &String) -> Result { + for entry in read_dir(std::path::Path::new(directory_path))? { + let entry = entry?; + + let file_type = entry.file_type(); + let file_name = entry.file_name(); + + println!("file type: {:?}", file_type); + println!("file name: {:?}", file_name); + + match self.find_file_extension(&file_name) { + En::ImageFile => { + let directory_part = directory_path.clone(); + let fname = utilities::string::o_to_string(&file_name); + let fullpath = directory_part + "/" + &fname.unwrap(); + return Ok(fullpath); + } + _ => {} + } + } + + Ok(String::new()) + } + + fn get_metadata_path(&self, directory_path: &String) -> Result { + for entry in read_dir(std::path::Path::new(directory_path))? { + let entry = entry?; + + let file_type = entry.file_type(); + let file_name = entry.file_name(); + + println!("file type: {:?}", file_type); + println!("file name: {:?}", file_name); + + match self.find_file_extension(&file_name) { + En::MetadataFile => { + let directory_part = directory_path.clone(); + let fname = utilities::string::o_to_string(&file_name); + return Ok(directory_part + "/" + &fname.unwrap()); + } + _ => {} + } + } + + Ok(String::new()) + } + fn _check_for_no_confirm(&self) -> bool { for flag in self.ica_action.flags.iter() { if flag.flag == "-nc" { @@ -583,21 +616,4 @@ impl CommitManager { } return false; } - - fn retrieve_metadata(&self, path: &String) -> icarus_models::album::collection::Album { - let content = self.retrieve_file_content(&path); - let val = content.unwrap(); - - let converted = serde_json::from_str(&val); - - match &converted { - Ok(_) => println!("Good!"), - Err(er) => println!("Error {:?}", er), - } - return converted.unwrap(); - } - - fn retrieve_file_content(&self, path: &String) -> Result { - return std::fs::read_to_string(path); - } } diff --git a/src/syncers/upload.rs b/src/syncers/upload.rs index 2d558ca..a440208 100644 --- a/src/syncers/upload.rs +++ b/src/syncers/upload.rs @@ -1,9 +1,7 @@ use std::default::Default; -use http::HeaderMap; use http::HeaderValue; use reqwest; -use serde::{Deserialize, Serialize}; use crate::models; @@ -11,29 +9,6 @@ pub struct Upload { pub api: models::api::API, } -#[derive(Debug, Deserialize, Serialize)] -struct Song { - title: String, - album: String, - artist: String, - album_artist: String, - year: i32, - genre: String, - duration: i32, - track: i32, - track_count: i32, - disc: i32, - disc_count: i32, - #[serde(skip_serializing)] - songpath: String, -} - -impl Song { - pub fn to_metadata_json(&self) -> Result { - return serde_json::to_string_pretty(&self); - } -} - impl Default for Upload { fn default() -> Self { Upload { @@ -48,11 +23,10 @@ impl Upload { token: &icarus_models::token::AccessToken, song: &icarus_models::song::Song, cover: &icarus_models::coverart::CoverArt, - album: &icarus_models::album::collection::Album, ) -> Result { self.api.endpoint = String::from("song/data/upload/with/data"); let url = self.retrieve_url(); - let new_song = self.initialize_song(&song, &album); + // let new_song = self.initialize_song(&song, &album); let access_token = token.bearer_token(); if url.is_empty() { @@ -61,7 +35,7 @@ impl Upload { println!("Url: {}", url); println!("Token: {}", access_token); - println!("Path: {:?}", new_song.songpath); + println!("Path: {:?}", song.song_path()); let mut headers = reqwest::header::HeaderMap::new(); headers.insert( @@ -70,7 +44,7 @@ impl Upload { ); headers.insert(reqwest::header::ACCEPT, HeaderValue::from_static("*/*")); - let form = self.init_form(&new_song, &cover); + let form = self.init_form(&song, &cover); let client = reqwest::Client::builder().build().unwrap(); match client .post(url) @@ -88,47 +62,21 @@ impl Upload { } } - fn _initialize_form( - &self, - song_raw_data: Vec, - cover_raw_data: Vec, - song_detail: String, - ) -> reqwest::multipart::Form { - let mut headers = HeaderMap::new(); - headers.insert( - http::header::CONTENT_TYPE, - http::HeaderValue::from_static("application/octet-stream"), - ); - - let file = reqwest::multipart::Part::bytes(song_raw_data).headers(headers); - let mut headers_i = HeaderMap::new(); - headers_i.insert( - http::header::CONTENT_TYPE, - http::HeaderValue::from_static("image/jpeg"), - ); - - let cover = reqwest::multipart::Part::bytes(cover_raw_data).headers(headers_i); - - let mut song_filename = String::from("audio"); - song_filename += icarus_models::constants::DEFAULTMUSICEXTENSION; - let mut cover_filename = String::from("cover"); - cover_filename += icarus_models::constants::JPGEXTENSION; - - return reqwest::multipart::Form::new() - .part("cover", cover.file_name(cover_filename)) - .text("metadata", song_detail) - .part("file", file.file_name(song_filename)); - } - fn init_form( &self, - song: &Song, + song: &icarus_models::song::Song, cover: &icarus_models::coverart::CoverArt, ) -> reqwest::multipart::Form { - let songpath = song.songpath.clone(); + let songpath = match song.song_path() { + Ok(s) => s, + Err(_) => String::new(), + }; let coverpath = cover.path.clone(); println!("Cover path: {:?}", coverpath); - let song_detail = song.to_metadata_json().unwrap(); + let song_detail = match song.to_metadata_json(true) { + Ok(s) => s, + Err(_) => String::new(), + }; println!("\n{}\n", song_detail); @@ -177,29 +125,4 @@ impl Upload { return url; } - - fn initialize_song( - &self, - song: &icarus_models::song::Song, - album: &icarus_models::album::collection::Album, - ) -> Song { - let dur = song.duration.clone(); - println!("Duration: {}", dur); - - return Song { - title: String::from(&song.title.clone()), - album: album.title.clone(), - artist: String::from(&song.artist.clone().clone()), - album_artist: album.artist.clone(), - year: album.year.clone(), - genre: album.genre.clone(), - // duration: f64::round(dur) as i32, - duration: dur, - track: (song.track.clone()), - track_count: album.track_count.clone(), - disc: song.disc.clone(), - disc_count: album.disc_count.clone(), - songpath: song.directory.clone() + "/" + &song.filename.clone(), - }; - } }