Refactoring token fetching code

Adding two APIs. One for auth and the other for the main app

src/managers/action_managers.rs

@@ -35,6 +35,7 @@ impl ActionManager {
             String::from("-p"),
             String::from("-t"),
             String::from("-h"),
+            String::from("-ha"),
             String::from("-s"),
             String::from("-sd"),
             String::from("-sr"),
@@ -75,6 +76,7 @@ impl ActionManager {
 
             let mut flg = models::flags::Flags::default();
 
+            // TODO: Refactor this
             if self.is_valid_flag(flag) && self.does_flag_have_value(flag) {
                 println!("Flag has value");
                 flg.flag = String::from(flag);

src/managers/commit_manager.rs

@@ -88,6 +88,8 @@ impl CommitManager {
 
         println!("{mapped_action:?}");
 
+        // TODO: Move code to get token here and then pass it to the respective functions
+
         match mapped_action {
             ActionValues::DeleteAct => self.delete_song(),
             ActionValues::DownloadAct => self.download_song(),
@@ -132,13 +134,14 @@ impl CommitManager {
 
     fn delete_song(&self) {
         let mut prsr = parsers::api_parser::APIParser {
+            apis: vec![models::api::Api::default(), models::api::Api::default()],
             ica_act: self.ica_action.clone(),
-            api: models::api::Api::default(),
         };
-        prsr.parse_api();
+        prsr.parse_api(parsers::api_parser::APIType::Main);
-        let api = prsr.retrieve_api();
+        prsr.parse_api(parsers::api_parser::APIType::Auth);
+        let auth_api = prsr.retrieve_api(parsers::api_parser::APIType::Auth);
 
-        let token = self.parse_token(&api);
+        let token = self.parse_token(&auth_api);
 
         println!("Deleting song");
 
@@ -153,6 +156,7 @@ impl CommitManager {
             }
         }
 
+        let api = prsr.retrieve_api(parsers::api_parser::APIType::Main);
         let mut del = syncers::delete::Delete { api: api.clone() };
 
         println!("Deleting song..");
@@ -175,14 +179,17 @@ impl CommitManager {
         let song_id = uuid::Uuid::from_str(dwn.as_str()).unwrap();
 
         let mut prsr = parsers::api_parser::APIParser {
-            api: models::api::Api::default(),
+            apis: vec![models::api::Api::default(), models::api::Api::default()],
             ica_act: self.ica_action.clone(),
         };
-        prsr.parse_api();
+        // parsers::api_parser::APIType
+        prsr.parse_api(parsers::api_parser::APIType::Main);
+        prsr.parse_api(parsers::api_parser::APIType::Auth);
 
-        let api = prsr.retrieve_api();
+        let auth_api = prsr.retrieve_api(parsers::api_parser::APIType::Auth);
-        let token = self.parse_token(&api);
+        let token = self.parse_token(&auth_api);
         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 song = icarus_models::song::Song {
@@ -223,15 +230,18 @@ impl CommitManager {
         }
 
         let mut prsr = parsers::api_parser::APIParser {
-            api: models::api::Api::default(),
+            apis: vec![models::api::Api::default(), models::api::Api::default()],
             ica_act: self.ica_action.clone(),
         };
-        prsr.parse_api();
+        prsr.parse_api(parsers::api_parser::APIType::Main);
+        prsr.parse_api(parsers::api_parser::APIType::Auth);
 
-        let api = prsr.retrieve_api();
+        let auth_api = prsr.retrieve_api(parsers::api_parser::APIType::Auth);
-        let token = self.parse_token(&api);
+        let token = self.parse_token(&auth_api);
         println!("Token {token:?}");
 
+        let api = prsr.retrieve_api(parsers::api_parser::APIType::Main);
+
         let mut repo = syncers::retrieve_records::RetrieveRecords { api: api.clone() };
         let result_fut = repo.get_all_songs(&token);
 
@@ -321,13 +331,14 @@ impl CommitManager {
         cover_path: &str,
     ) -> Result<()> {
         let mut prsr = parsers::api_parser::APIParser {
-            api: models::api::Api::default(),
+            apis: vec![models::api::Api::default(), models::api::Api::default()],
             ica_act: self.ica_action.clone(),
         };
-        prsr.parse_api();
+        prsr.parse_api(parsers::api_parser::APIType::Main);
+        prsr.parse_api(parsers::api_parser::APIType::Auth);
 
-        let api = prsr.retrieve_api();
+        let auth_api = prsr.retrieve_api(parsers::api_parser::APIType::Auth);
-        let token = self.parse_token(&api);
+        let token = self.parse_token(&auth_api);
 
         println!("Token: {:?}", token.token);
 
@@ -447,12 +458,13 @@ impl CommitManager {
 
     fn multi_target_upload(&mut self, sourcepath: &String) -> std::io::Result<()> {
         let mut prsr = parsers::api_parser::APIParser {
-            api: models::api::Api::default(),
+            apis: vec![models::api::Api::default(), models::api::Api::default()],
             ica_act: self.ica_action.clone(),
         };
-        prsr.parse_api();
+        prsr.parse_api(parsers::api_parser::APIType::Main);
-        let api = prsr.retrieve_api();
+        prsr.parse_api(parsers::api_parser::APIType::Auth);
-        let token = self.parse_token(&api);
+        let auth_api = prsr.retrieve_api(parsers::api_parser::APIType::Auth);
+        let token = self.parse_token(&auth_api);
 
         let directory_path = std::path::Path::new(&sourcepath);
 

src/managers/token_manager.rs

@@ -63,7 +63,7 @@ impl TokenManager {
 
     pub fn init(&mut self) {
         let api = &mut self.api;
-        api.version = String::from("v1");
+        api.version = String::from(crate::parsers::api_parser::API_VERSION);
         api.endpoint = format!("api/{}/login", api.version);
     }
 

src/parsers/api_parser.rs

@@ -2,16 +2,26 @@ use crate::models;
 
 #[derive(Clone, Debug)]
 pub struct APIParser {
-    pub api: models::api::Api,
+    pub apis: Vec<models::api::Api>,
     pub ica_act: models::icarus_action::IcarusAction,
 }
 
-impl APIParser {
+pub const API_VERSION: &str = "v2";
-    pub fn retrieve_api(&self) -> models::api::Api {
+
-        self.api.clone()
+pub enum APIType {
+    Main,
+    Auth,
 }
 
-    pub fn parse_api(&mut self) {
+impl APIParser {
+    pub fn retrieve_api(&self, api_type: APIType) -> models::api::Api {
+        match api_type {
+            APIType::Main => self.apis[0].clone(),
+            APIType::Auth => self.apis[1].clone()
+        }
+    }
+
+    pub fn parse_api(&mut self, api_type: APIType) {
         let flags = self.ica_act.flags.clone();
         println!("Parsing api");
 
@@ -19,16 +29,33 @@ impl APIParser {
             let arg = elem.flag;
             let value = elem.value;
 
+            match api_type {
+                APIType::Main => {
                     if arg == "-h" {
                         if value.chars().nth(value.len() - 1) == Some('/') {
-                    self.api.url = value;
+                            self.apis[0].url = value;
                         } else {
-                    self.api.url = value + "/";
+                            self.apis[0].url = value + "/";
+                        }
+                        break;
+                    }
+                }, 
+                APIType::Auth => {
+                    if arg == "-ha" {
+                        if value.chars().nth(value.len() - 1) == Some('/') {
+                            self.apis[1].url = value;
+                        } else {
+                            self.apis[1].url = value + "/";
                         }
                         break;
                     }
                 }
+            }
 
-        self.api.version = "v1".to_string();
+        }
+
+        // for api in self.apis {
+        // }
+        // self.api.version = String::from(API_VERSION);
     }
 }