phoenix/icarus_dm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 14 Wiki Activity

tsk-83: Added code to get token before an action begins

Browse Source
This commit is contained in:
kdeng00
2025-10-26 16:23:53 -04:00
parent 37bc71a708
commit 042e803e71
2 changed files with 50 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/main.rs
+1
View File
@@ -33,6 +33,7 @@ async fn main() {
let mut cmt_mgr = managers::commit_manager::CommitManager { let mut cmt_mgr = managers::commit_manager::CommitManager {
ica_action: chosen_act, ica_action: chosen_act,
..Default::default()
}; };
cmt_mgr.commit_action().await; cmt_mgr.commit_action().await;
src/managers/commit_manager.rs
+49 -84
View File
@@ -10,9 +10,11 @@ use crate::parsers;
use crate::syncers; use crate::syncers;
use crate::utilities; use crate::utilities;
#[derive(Debug)] #[derive(Debug, Default)]
pub struct CommitManager { pub struct CommitManager {
pub ica_action: models::icarus_action::IcarusAction, pub ica_action: models::icarus_action::IcarusAction,
pub api: models::api::Api,
pub auth_api: models::api::Api,
} }
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
@@ -84,23 +86,39 @@ pub fn retrieve_song(
impl CommitManager { impl CommitManager {
pub async fn commit_action(&mut self) { pub async fn commit_action(&mut self) {
self.init_api().await;
let action = &self.ica_action.action; let action = &self.ica_action.action;
println!("Committing {action} action"); println!("Committing {action} action");
let mapped_actions = &self.map_actions(); let mapped_actions = &self.map_actions();
// TODO: Move code to get token here and then pass it to the respective functions // TODO: Move code to get token here and then pass it to the respective functions
let token = self.parse_token(&self.auth_api).await;
match self.find_mapped_action(mapped_actions, action) { match self.find_mapped_action(mapped_actions, action) {
ActionValues::DeleteAct => self.delete_song().await, ActionValues::DeleteAct => self.delete_song(&token).await,
ActionValues::DownloadAct => self.download_song().await, ActionValues::DownloadAct => self.download_song(&token).await,
ActionValues::RetrieveAct => self.retrieve_object().await, ActionValues::RetrieveAct => self.retrieve_object(&token).await,
ActionValues::UploadSongWithMetadata => self.upload_song_with_metadata().await, ActionValues::UploadSongWithMetadata => self.upload_song_with_metadata(&token).await,
_ => { _ => {
println!("Nothing good here"); println!("Nothing good here");
} }
} }
} }
async fn init_api(&mut self) {
let mut prsr = parsers::api_parser::APIParser {
apis: vec![models::api::Api::default(), models::api::Api::default()],
ica_act: self.ica_action.clone(),
};
prsr.parse_api(parsers::api_parser::APIType::Main);
prsr.parse_api(parsers::api_parser::APIType::Auth);
let auth_api = prsr.retrieve_api(parsers::api_parser::APIType::Auth);
let api = prsr.retrieve_api(parsers::api_parser::APIType::Main);
self.api = api;
self.auth_api = auth_api;
}
fn find_mapped_action( fn find_mapped_action(
&self, &self,
actions: &HashMap<String, ActionValues>, actions: &HashMap<String, ActionValues>,
@@ -130,19 +148,12 @@ impl CommitManager {
actions actions
} }
async fn delete_song(&self) { async fn delete_song(&self, token: &icarus_models::token::AccessToken) {
let mut prsr = parsers::api_parser::APIParser {
apis: vec![models::api::Api::default(), models::api::Api::default()],
ica_act: self.ica_action.clone(),
};
prsr.parse_api(parsers::api_parser::APIType::Main);
prsr.parse_api(parsers::api_parser::APIType::Auth);
let auth_api = prsr.retrieve_api(parsers::api_parser::APIType::Auth);
let token = self.parse_token(&auth_api).await;
println!("Deleting song"); println!("Deleting song");
let mut del = syncers::delete::Delete {
api: self.api.clone(),
};
let mut song = icarus_models::song::Song::default(); let mut song = icarus_models::song::Song::default();
for arg in &self.ica_action.flags { for arg in &self.ica_action.flags {
@@ -154,12 +165,7 @@ impl CommitManager {
} }
} }
let api = prsr.retrieve_api(parsers::api_parser::APIType::Main); match del.delete_song(token, &song).await {
let mut del = syncers::delete::Delete { api: api.clone() };
println!("Deleting song..");
match del.delete_song(&token, &song).await {
Ok((song, _coverart)) => { Ok((song, _coverart)) => {
println!("Song (Id {:?}) has been successfully deleted", song.id); println!("Song (Id {:?}) has been successfully deleted", song.id);
} }
@@ -169,33 +175,20 @@ impl CommitManager {
} }
} }
async fn download_song(&self) { async fn download_song(&self, token: &icarus_models::token::AccessToken) {
println!("Deleting song"); println!("Downloading song");
let dwn = self.ica_action.retrieve_flag_value(&String::from("-b")); let dwn = self.ica_action.retrieve_flag_value(&String::from("-b"));
let song_id = uuid::Uuid::from_str(dwn.as_str()).unwrap(); let mut dwn_loader = syncers::download::Download {
api: self.api.clone(),
let mut prsr = parsers::api_parser::APIParser {
apis: vec![models::api::Api::default(), models::api::Api::default()],
ica_act: self.ica_action.clone(),
}; };
prsr.parse_api(parsers::api_parser::APIType::Main);
prsr.parse_api(parsers::api_parser::APIType::Auth);
let auth_api = prsr.retrieve_api(parsers::api_parser::APIType::Auth);
let token = self.parse_token(&auth_api).await;
println!("Message: {}", token.message);
let api = prsr.retrieve_api(parsers::api_parser::APIType::Main);
let mut dwn_loader = syncers::download::Download { api: api.clone() };
let mut song = icarus_models::song::Song { let mut song = icarus_models::song::Song {
id: song_id, id: uuid::Uuid::from_str(dwn.as_str()).unwrap(),
..Default::default() ..Default::default()
}; };
match dwn_loader.download_song(&token, &song).await { match dwn_loader.download_song(token, &song).await {
Ok(o) => { Ok(o) => {
println!("Success"); println!("Song downloaded");
song.data = o.as_bytes().to_vec(); song.data = o.as_bytes().to_vec();
song.directory = String::from("."); song.directory = String::from(".");
@@ -226,7 +219,7 @@ impl CommitManager {
} }
} }
async fn retrieve_object(&self) { async fn retrieve_object(&self, token: &icarus_models::token::AccessToken) {
println!("Retrieving song"); println!("Retrieving song");
let rt = self.ica_action.retrieve_flag_value(&String::from("-rt")); let rt = self.ica_action.retrieve_flag_value(&String::from("-rt"));
@@ -234,22 +227,11 @@ impl CommitManager {
panic!("Unsupported -rt: {rt}"); panic!("Unsupported -rt: {rt}");
} }
let mut prsr = parsers::api_parser::APIParser { let mut repo = syncers::retrieve_records::RetrieveRecords {
apis: vec![models::api::Api::default(), models::api::Api::default()], api: self.api.clone(),
ica_act: self.ica_action.clone(),
}; };
prsr.parse_api(parsers::api_parser::APIType::Main);
prsr.parse_api(parsers::api_parser::APIType::Auth);
let auth_api = prsr.retrieve_api(parsers::api_parser::APIType::Auth); match repo.get_all_songs(token).await {
let token = self.parse_token(&auth_api).await;
println!("Token {token:?}");
let api = prsr.retrieve_api(parsers::api_parser::APIType::Main);
let mut repo = syncers::retrieve_records::RetrieveRecords { api: api.clone() };
match repo.get_all_songs(&token).await {
Ok(o) => { Ok(o) => {
println!("Songs"); println!("Songs");
println!("====="); println!("=====");
@@ -288,7 +270,7 @@ impl CommitManager {
token.unwrap() token.unwrap()
} }
async fn upload_song_with_metadata(&mut self) { async fn upload_song_with_metadata(&mut self, token: &icarus_models::token::AccessToken) {
println!("Uplodaring song with metadara"); println!("Uplodaring song with metadara");
let songpath = self.ica_action.retrieve_flag_value(&String::from("-s")); let songpath = self.ica_action.retrieve_flag_value(&String::from("-s"));
@@ -316,10 +298,10 @@ impl CommitManager {
println!("cover art path: {coverpath}"); println!("cover art path: {coverpath}");
let _ = self let _ = self
.sing_target_upload(&songpath, &track_id, &metadata_path, &coverpath) .sing_target_upload(&songpath, &track_id, &metadata_path, &coverpath, token)
.await; .await;
} else if multitarget { } else if multitarget {
let _ = self.multi_target_upload(&uni).await; let _ = self.multi_target_upload(&uni, token).await;
} else { } else {
println!("Single or Multi target has not been chosen"); println!("Single or Multi target has not been chosen");
} }
@@ -332,19 +314,8 @@ impl CommitManager {
track_id: &str, track_id: &str,
meta_path: &String, meta_path: &String,
cover_path: &str, cover_path: &str,
token: &icarus_models::token::AccessToken,
) -> Result<()> { ) -> Result<()> {
let mut prsr = parsers::api_parser::APIParser {
apis: vec![models::api::Api::default(), models::api::Api::default()],
ica_act: self.ica_action.clone(),
};
prsr.parse_api(parsers::api_parser::APIType::Main);
prsr.parse_api(parsers::api_parser::APIType::Auth);
let auth_api = prsr.retrieve_api(parsers::api_parser::APIType::Auth);
let token = self.parse_token(&auth_api).await;
println!("Token: {:?}", token.token);
let song_file = std::path::Path::new(&songpath); let song_file = std::path::Path::new(&songpath);
if !song_file.exists() { if !song_file.exists() {
@@ -377,14 +348,13 @@ impl CommitManager {
println!("Filename: {:?}", s.filename); println!("Filename: {:?}", s.filename);
println!("Path: {:?}", s.song_path()); println!("Path: {:?}", s.song_path());
s.data = icarus_models::song::io::to_data(&s).unwrap(); s.data = icarus_models::song::io::to_data(&s).unwrap();
cover_art.data = cover_art.data =
icarus_models::coverart::io::to_data(&cover_art).unwrap(); icarus_models::coverart::io::to_data(&cover_art).unwrap();
let members = UploadSongMembers { let members = UploadSongMembers {
song: s, song: s,
coverart: cover_art, coverart: cover_art,
token, token: token.clone(),
album, album,
}; };
@@ -523,16 +493,11 @@ impl CommitManager {
} }
} }
async fn multi_target_upload(&mut self, sourcepath: &String) -> std::io::Result<()> { async fn multi_target_upload(
let mut prsr = parsers::api_parser::APIParser { &mut self,
apis: vec![models::api::Api::default(), models::api::Api::default()], sourcepath: &String,
ica_act: self.ica_action.clone(), token: &icarus_models::token::AccessToken,
}; ) -> std::io::Result<()> {
prsr.parse_api(parsers::api_parser::APIType::Main);
prsr.parse_api(parsers::api_parser::APIType::Auth);
let auth_api = prsr.retrieve_api(parsers::api_parser::APIType::Auth);
let token = self.parse_token(&auth_api).await;
let directory_path = std::path::Path::new(&sourcepath); let directory_path = std::path::Path::new(&sourcepath);
if !directory_path.exists() { if !directory_path.exists() {