src/managers/commit_manager.rs

@@ -181,10 +181,11 @@ impl CommitManager {
         usr_mgr.parse_user_from_actions();
 
         let usr = usr_mgr.retrieve_user();
-        let tok_mgr = managers::token_manager::TokenManager {
+        let mut tok_mgr = managers::token_manager::TokenManager {
             user: usr,
             api: api.clone(),
         };
+        tok_mgr.init();
 
         // let token = tok_mgr.request_token();
         let token = Runtime::new().unwrap().block_on(tok_mgr.request_token());
@@ -193,8 +194,40 @@ impl CommitManager {
     }
     // TODO: Implement
     fn upload_song_with_metadata(&self) {
-        println!("Deleting song");
+        println!("Uplodaring song with metadara");
+
+        let songpath = self.ica_action.retrieve_flag_value(&String::from("-s"));
+        let metadata_path = self.ica_action.retrieve_flag_value(&String::from("-m"));
+        let coverpath = self.ica_action.retrieve_flag_value(&String::from("-ca"));
+        let track_id = self.ica_action.retrieve_flag_value(&String::from("-t"));
+
+        let single_target = songpath.len() > 0 && metadata_path.len() > 0 && coverpath.len() > 0 &&
+            track_id.len() > 0;
+        // !songPath.empty() && !metadataPath.empty() && 
+        // !coverPath.empty() && !trackID.empty() ? true : false;
+
+        let uni = self.ica_action.retrieve_flag_value(&String::from("-smca"));
+        let multitarget = uni.len() > 0;
+
+        if single_target && multitarget {
+            println!("Cannot upload from source and directory");
+        }
+
+
+        if single_target {
+            println!("Song path: {}", songpath);
+            println!("Track ID: {}", track_id);
+            println!("metadata path: {}", coverpath);
+            println!("cover art path: {}", track_id);
+
+            self.sing_target_upload(&songpath, &track_id, &metadata_path, &coverpath);
+        } else if multitarget {
+            self.multi_target_upload(&uni);
+        } else {
+            println!("Single or Multi target has not been chosen");
+        }
     }
+
     // TODO: Implement
     fn sing_target_upload(
         &self,
@@ -221,7 +254,11 @@ impl CommitManager {
             std::process::exit(-1);
         }
 
-        // let mut cover_art = models::
+        let mut cover_art = models::song::CoverArt::default();
+        let mut songs: Vec<models::song::Song> = Vec::new();
+        let mut metadatapath: String = String::new();
+
+        // iterate files in metadatapath
     }
 
     // Standards

src/managers/file_manager.rs

@@ -0,0 +1,59 @@
+use std::default::Default;
+
+
+pub struct FileManager {
+    pub filepath: String,
+    pub filebuffer: String,
+    pub file_read: bool,
+    pub file_buffer_length: i32,
+}
+
+impl Default for FileManager {
+    fn default() -> Self {
+        FileManager {
+            filepath: String::new(),
+            filebuffer: String::new(),
+            file_read: false,
+            file_buffer_length: -1
+        }
+    }
+}
+
+
+impl FileManager {
+// TODO: Implement
+pub fn init(&mut self) {
+    self.read_file()
+}
+    pub fn save_file(&mut self, filepath: &String) {
+        if !self.file_read {
+            self.read_file();
+        }
+
+            let mut file = File::open(filepath)?;
+    let mut buffer = Vec::new();
+    file.read_to_end(&mut buffer)?;
+        self.file_buffer_length = buffer.len();
+    self.filebuffer = String::from_utf8(buffer); // Assuming UTF-8 encoding
+    }
+    pub fn modify_file_path(&mut self, file: &String) {
+        self.filepath = file;
+    }
+
+    pub fn retrieve_file_buffer(&self) -> String {
+        self.filebuffer;
+    }
+
+    pub fn retrieve_file_length(&self) -> i32 {
+        self.file_buffer_length;
+    }
+
+    fn read_file(&mut self) {
+        let mut file = File::open(self.filepath)?;
+        let mut buffer = Vec::new();
+        file.read_to_end(&mut buffer)?;
+        self.file_buffer_length = buffer.len();
+        self.filebuffer = String::from_utf8(buffer); // Assuming UTF-8 encoding
+        self.file_read = true;
+    }
+}

src/managers/token_manager.rs

@@ -24,7 +24,7 @@ impl TokenManager {
     pub async fn request_token(&self) -> Result<models::token::Token, std::io::Error> {
         println!("Sending request for a token");
 
-        let endpoint = self.construct_endpoint();
+        // let endpoint = self.construct_endpoint();
         let mut url = self.retrieve_url();
         // url += &endpoint;
 
@@ -32,7 +32,6 @@ impl TokenManager {
 
         let mut token = models::token::Token::default();
 
-
         let client = reqwest::Client::new();
         let response = client.post(&url)
             .json(&self.user)
@@ -65,22 +64,23 @@ impl TokenManager {
 
     pub fn init(&mut self) {
         let mut api = &mut self.api;
-        api.endpoint = String::from("api/v1/login");
         api.version = String::from("v1");
+        api.endpoint = String::from(format!("api/{}/login", api.version));
     }
 
     pub fn retrieve_url(&self) -> String {
         let api = &self.api;
         let mut url = String::from(&api.url);
-        url += &String::from("api/");
-        url += &String::from(&api.version);
-        url += &String::from("/");
+        // url += &String::from("api/");
+        // url += &String::from(&api.version);
+        // url += &String::from("/");
         url += &String::from(&api.endpoint);
         url += &String::from("/");
 
         return url;
     }
 
+    // NOTE: This can get deleted. Redundant
     fn construct_endpoint(&self) -> String {
         let mut endpoint: String = String::from("api/");
         endpoint += &self.api.version;

src/models/icarus_action.rs

@@ -25,7 +25,7 @@ impl IcarusAction {
 
         for f in self.flags.iter() {
             if f.flag == *flag {
-                val = flag.clone();
+                val = f.value.clone();
                 break;
             }
         }

src/models/token.rs

@@ -4,17 +4,29 @@ use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Deserialize, Serialize)]
 pub struct Token {
+    #[serde(alias = "user_id")]
+    pub user_id: i32,
+    #[serde(alias = "username")]
+    pub username: Option<String>,
+    #[serde(alias = "token")]
     pub access_token: Option<String>,
+    #[serde(alias = "token_type")]
     pub token_type: Option<String>,
+    #[serde(alias = "expiration")]
     pub expiration: Option<i32>,
+    #[serde(alias = "message")]
+    pub message: Option<String>,
 }
 
 impl Default for Token {
     fn default() -> Self {
         Token {
+            user_id: -1,
+            username: None,
             access_token: None,
             token_type: None,
             expiration: None,
+            message: None,
         }
     }
 }