Adding openssl (#104)

Reviewed-on: #104

.github/workflows/idm.yml

@@ -0,0 +1,37 @@
+name: sidm
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build:
+
+    runs-on: ubuntu-24.04
+
+    steps:
+    - uses: actions/checkout@v6
+    - uses: actions-rust-lang/setup-rust-toolchain@v1
+      with:
+        toolchain: 1.97
+    - uses: Swatinem/rust-cache@v2
+    - name: Build
+      run: |
+        mkdir -p ~/.ssh
+        echo "$EXTREPO_KEY" > ~/.ssh/gitlab_deploy_key
+        chmod 600 ~/.ssh/gitlab_deploy_key
+        ssh-keyscan ${{ secrets.MYHOST }}= >> ~/.ssh/known_hosts
+
+        eval $(ssh-agent -s)
+        ssh-add -v ~/.ssh/gitlab_deploy_key
+        cargo build --release
+      env:
+        EXTREPO_KEY: ${{ secrets.MYREPO_TOKEN }}
+
+    - name: Run tests
+      run: cargo test --verbose

.github/workflows/rust-macos-latest

@@ -1,22 +0,0 @@
-name: Rust
-
-on:
-  push:
-    branches: [ "master" ]
-  pull_request:
-    branches: [ "master" ]
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  build:
-
-    runs-on: macos-latest
-
-    steps:
-    - uses: actions/checkout@v4
-    - name: Build
-      run: cargo build --verbose
-    - name: Run tests
-      run: cargo test --verbose

.github/workflows/rust-ubuntu-latest.yml

@@ -1,39 +0,0 @@
-name: Rust
-
-on:
-  push:
-    branches: [ "master" ]
-  pull_request:
-    branches: [ "master" ]
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v4
-    - name: Install Rust version
-      run: rustup install 1.85.0 && rustup default 1.85.0
-
-    - name: Debug secret
-      run: echo "${{ secrets.MYREPO_TOKEN }}" | head -c 10 ; echo "..."
-    
-    - name: Build
-      run: |
-        mkdir -p ~/.ssh
-        echo "$EXTREPO_KEY" > ~/.ssh/gitlab_deploy_key
-        chmod 600 ~/.ssh/gitlab_deploy_key
-        ssh-keyscan git.kundeng.us ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBLl/OZiKVDxwnyvMxa+rjKvDpKqTxH1GWuGuDPLmENGQMbTVulajZWr9x8Q1cotoJiHZkt7DA5vczcjB/4lwgWA= >> ~/.ssh/known_hosts
-
-        eval $(ssh-agent -s)
-        ssh-add -v ~/.ssh/gitlab_deploy_key
-        cargo build --release
-      env:
-        EXTREPO_KEY: ${{ secrets.MYREPO_TOKEN }}
-
-    - name: Run tests
-      run: cargo test --verbose

.gitignore

@@ -7,4 +7,3 @@
 
 /target
 .vscode/
-Cargo.lock

Cargo.toml

@@ -1,19 +1,19 @@
 [package]
-name = "icarus-dm"
-version = "0.5.0"
+name = "sidm"
+version = "0.10.1"
+rust-version = "1.95"
 edition = "2024"
-
-
-
+license = "MIT"
+description = "CLI tool to download and upload music from soaricarus"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [dependencies]
-futures = { version = "0.3.31" }
-http = { version = "1.3.1" }
-reqwest = { version = "0.12.15", features = ["json", "blocking", "multipart", "stream"] }
-serde = { version = "1.0.219", features = ["derive"] }
-serde_json = "1.0.140"
-tokio = { version = "1.44.1", features = ["full"] }
-tokio-util = { version = "0.7.14", features = ["codec"] }
-icarus-models = { git = "ssh://git@git.kundeng.us/phoenix/icarus-models.git", tag = "v0.1.14" }
+http = { version = "1.4.2" }
+reqwest = { version = "0.13.4", features = ["json", "blocking", "multipart", "stream"] }
+openssl = { version = "0.10.81", features = ["vendored"] }
+serde = { version = "1.0.228", features = ["derive"] }
+serde_json = { version = "1.0.150" }
+tokio = { version = "1.52.4", features = ["full"] }
+tokio-util = { version = "0.7.18", features = ["codec"] }
+uuid = { version = "1.23.4", features = ["v4", "serde"] }
+simodels = { git = "ssh://git@git.kundeng.us/phoenix/simodels.git", tag = "v0.11.3-main-fe9d101bd0-111" }

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019 Kun Deng
+Copyright (c) 2026 Kun Deng
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,67 +1,54 @@
-# IcarusDownloadManager
+# sidm
 
-IcarusDownloadManager is a CLI software client application that has the feature of uploading and downloading songs from the [Icarus](https://github.com/kdeng00/Icarus) Music Server. 
+sidm (SoarIcarusDownloadManager) is a CLI software client application that has the feature of uploading and downloading songs from the [soaricarus_api](https://git.kundeng.us/phoenix/soaricarus_api) Music Server. 
 
 
-## Built With
-
-* Rust
-* Cargo
-* futures
-* http
-* reqwst
-* serde
-* serde_json
-* tokio
-* tokio-util
-
 
 ### Getting Started
 
 Clone the repo
 
 ```BASH
-git clone --recursive https://github.com/kdeng00/IcarusDownloadManager
+git clone git@git.kundeng.us:phoenix/sidm.git
 ```
 
 
 Build the project:
 
 ```BASH
-cd IcarusDownloadManager
+cd sidm
 cargo build
 ```
 
-The program has been built and can be executed by the binary file *icarus-dm*. For information on how to use icarua-dm, merely execute the program without any command line arguments.
 
 ### Downloading Song
 
 ```BASH
-icarus-dm download -u spacecadet -p stellar40 -h https://icarus.com -b 15
+sidm download -u spacecadet -p stellar40 -h https://icarus.com -ha https://auth.icarus.com -b e8407fc6-edd2-44c1-993f-08dd7324d91a
 ```
 
 ### Uploading Song with metadata
 
 ```BASH
-icarus-dm upload-meta -u spacecadet -p stellar40 -h https://icarus.com -s /path/of/song.flac -t 1 -m /path/to/metadata/config/collection.json -ca /path/to/cover/art/image.png
+sidm upload-meta -u spacecadet -p stellar40 -h https://icarus.com -ha https://auth.icarus.com -s /path/of/song.flac -t 1 -m /path/to/metadata/config/collection.json -ca /path/to/cover/art/image.png
 ```
 
 ### Uploading Song with metadata from directory
 
 ```BASH
-icarus-dm upload-meta -u spacecadet -p stellar40 -h https://icarus.com -smca /path/where/songs/and/metadata/exists/
+sidm upload-meta -u spacecadet -p stellar40 -h https://icarus.com -ha https://auth.icarus.com -smca /path/where/songs/and/metadata/exists/
 ```
 
 ### Retrieving Song in json
 
 ```Bash
-icarus-dm retrieve -u spacecadet -p stellar40 -h https://icarus.com -rt songs
+sidm retrieve -u spacecadet -p stellar40 -h https://icarus.com -ha https://auth.icarus.com -rt songs
 ```
 
 ### Deleting Song
 
 ```BASH
-icarus-dm delete -u spacecadet -p stellar40 -h https://icarus.com -D 15
+sidm delete -u spacecadet -p stellar40 -h https://icarus.com -ha https://auth.icarus.com -D e8407fc6-edd2-44c1-993f-08dd7324d91a
 ```
 
 
@@ -69,15 +56,7 @@ icarus-dm delete -u spacecadet -p stellar40 -h https://icarus.com -D 15
 
 Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on the code of conduct, and the process for submitting pull requests to the project.
 
-## Versioning
 
-[v0.4.0](https://github.com/kdeng00/IcarusDownloadManager/releases/tag/v0.4.0)  
-[v0.3.2](https://github.com/kdeng00/IcarusDownloadManager/releases/tag/v0.3.2)  
-[v0.3.0](https://github.com/kdeng00/IcarusDownloadManager/releases/tag/v0.3.0)  
-[v0.2.0](https://github.com/kdeng00/IcarusDownloadManager/releases/tag/v0.2.0)  
-[v0.1.2](https://github.com/kdeng00/IcarusDownloadManager/releases/tag/v0.1.2)  
-[v0.1.1](https://github.com/kdeng00/IcarusDownloadManager/releases/tag/v0.1.1)  
-[v0.1.0](https://github.com/kdeng00/IcarusDownloadManager/releases/tag/0.1.0)
 
 ## License
 

src/help.rs

@@ -12,7 +12,8 @@ pub fn print_help() {
         Required for all actions
             -u username
             -p password
-            -h host
+            -h api host
+            -ha auth api host
 
         Required for upload with metadata
             -s path of song
@@ -29,8 +30,11 @@ pub fn print_help() {
             -rt retrieve type (songs is only accepted)
 
         Required for deleting a song
-            -D song id"#,
+            -D song id
+
+        Print version
+            -v"#,
     );
 
-    println!("{}", msg);
+    println!("{msg}");
 }

src/main.rs

@@ -4,10 +4,12 @@ mod models;
 mod parsers;
 mod syncers;
 mod utilities;
+mod version;
 
 use std::env;
 
-fn main() {
+#[tokio::main]
+async fn main() {
     let args: Vec<String> = env::args().collect();
     let args_len = args.len() as i32;
 
@@ -16,20 +18,25 @@ fn main() {
         utilities::checks::exit_program(-1);
     }
 
-    println!("Argument count: {}", args_len);
-
     let mut act_mgr = managers::action_managers::ActionManager::default();
     act_mgr.set_params(&args);
     act_mgr.initialize();
 
     let chosen_act = act_mgr.retrieve_icarus_action();
+    for act in &chosen_act.flags {
+        if act.flag == "-v" {
+            version::print_version();
+            utilities::checks::exit_program(-1);
+        }
+    }
     chosen_act.print_action_and_flags();
 
     let mut cmt_mgr = managers::commit_manager::CommitManager {
         ica_action: chosen_act,
+        ..Default::default()
     };
 
-    cmt_mgr.commit_action();
+    cmt_mgr.commit_action().await;
 }
 
 #[cfg(test)]
@@ -41,10 +48,10 @@ mod tests {
         let meta_path = String::from("tests/sample2_tracks/album.json");
 
         if !std::path::Path::new(&meta_path).exists() {
-            assert!(false, "File does not exists: {:?}", meta_path);
+            assert!(false, "File does not exists: {meta_path:?}");
         }
 
-        match icarus_models::album::collection::parse_album(&meta_path) {
+        match simodels::album::collection::parse_album(&meta_path) {
             Ok(album) => {
                 for track in 1..3 {
                     let directory_path = std::path::Path::new(&meta_path);
@@ -52,17 +59,17 @@ mod tests {
                     let filename: String = if track < 10 {
                         String::from("track0")
                             + &track.to_string()
-                            + icarus_models::constants::DEFAULTMUSICEXTENSION
+                            + simodels::constants::file_extensions::audio::DEFAULTMUSICEXTENSION
                     } else {
                         String::from("track")
                             + &track.to_string()
-                            + icarus_models::constants::DEFAULTMUSICEXTENSION
+                            + simodels::constants::file_extensions::audio::DEFAULTMUSICEXTENSION
                     };
                     let disc = 1;
                     match managers::commit_manager::retrieve_song(
                         &album, track, disc, &directory, &filename,
                     ) {
-                        Ok(song) => match song.to_data() {
+                        Ok(song) => match simodels::song::io::to_data(&song) {
                             Ok(_) => {
                                 print!("Success");
                             }
@@ -85,7 +92,7 @@ mod tests {
     #[test]
     fn test_minimum_action_and_args() {
         let args: Vec<String> = vec![
-            "icarus-dm".to_string(),
+            "idm".to_string(),
             "download".to_string(),
             "-u".to_string(),
             "jamborie".to_string(),

src/managers/action_managers.rs

@@ -1,8 +1,6 @@
-use serde::{Deserialize, Serialize};
-
 use crate::{models, utilities};
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug)]
 pub struct ActionManager {
     pub action: String,
     pub flags: Vec<models::flags::Flags>,
@@ -23,18 +21,19 @@ impl Default for ActionManager {
 
 impl ActionManager {
     pub fn retrieve_icarus_action(&self) -> models::icarus_action::IcarusAction {
-        return models::icarus_action::IcarusAction {
+        models::icarus_action::IcarusAction {
             flags: self.flags.clone(),
             action: String::from(&self.action),
-        };
+        }
     }
 
     fn supported_flags(&self) -> Vec<String> {
-        return vec![
+        vec![
             String::from("-u"),
             String::from("-p"),
             String::from("-t"),
             String::from("-h"),
+            String::from("-ha"),
             String::from("-s"),
             String::from("-sd"),
             String::from("-sr"),
@@ -47,7 +46,8 @@ impl ActionManager {
             String::from("-ca"),
             String::from("-smca"),
             String::from("-t"),
-        ];
+            String::from("-v"),
+        ]
     }
 
     pub fn initialize(&mut self) {
@@ -56,41 +56,34 @@ impl ActionManager {
         self.action = self.action.to_lowercase();
     }
 
-    pub fn set_params(&mut self, args: &Vec<String>) {
-        self.params = args.clone();
+    pub fn set_params(&mut self, args: &[String]) {
+        self.params = args.to_owned();
         self.param_count = self.params.len() as i32;
     }
 
     fn validate_flags(&mut self) {
-        println!("Validating flags");
-
         let flag_vals = self.parsed_flags();
 
         let mut i = 0;
-        println!("Flag count: {}", flag_vals.len());
 
         while i < flag_vals.len() {
             let flag = &flag_vals[i];
-            println!("Index: {} | Value: {}", i, flag);
-
             let mut flg = models::flags::Flags::default();
 
-            if self.is_valid_flag(flag) && self.does_flag_have_value(flag) {
-                println!("Flag has value");
+            if self.is_valid_flag(flag) {
+                if self.does_flag_have_value(flag) {
                     flg.flag = String::from(flag);
                     flg.value = String::from(&flag_vals[i + 1]);
 
-                i = i + 1;
-            } else if self.is_valid_flag(flag) {
-                println!("Flag does not have a value");
-                flg.flag = String::from(flag);
+                    i += 1;
+                } else {
+                    flg.flag = String::from(flag);
+                }
             } else {
-                println!("Flag {} is not valid", flag);
                 utilities::checks::exit_program(-1);
             }
 
             self.flags.push(flg);
-            println!("");
             i += 1;
         }
     }
@@ -113,34 +106,30 @@ impl ActionManager {
             }
         }
 
-        return found;
+        found
     }
 
     fn does_flag_have_value(&self, flag: &String) -> bool {
         let flags_tmp = self.parsed_flags();
         let mut i_found: i32 = -1;
 
-        for i in 0..flags_tmp.len() {
-            let flg = &flags_tmp[i];
-            if flg == flag {
+        for (i, item) in flags_tmp.iter().enumerate() {
+            let flg = &item;
+            if *flg == flag {
                 i_found = i as i32;
                 break;
             }
         }
 
         if i_found >= 0 {
-            if (i_found + 1) < flags_tmp.len().try_into().unwrap() {
-                return true;
+            (i_found + 1) < flags_tmp.len().try_into().unwrap()
         } else {
-                return false;
-            }
-        } else {
-            return false;
+            false
         }
     }
 
     fn _print_action(&self) {
-        if self.action.len() == 0 {
+        if self.action.is_empty() {
             println!("Action is empty");
         } else {
             println!("Action is {}", self.action);
@@ -158,11 +147,18 @@ impl ActionManager {
     fn parsed_flags(&self) -> Vec<String> {
         let mut parsed: Vec<String> = Vec::new();
 
+        if self.param_count <= 2 {
+            let flag = String::from(&self.params[1]);
+            if flag == "-v" {
+                parsed.push(flag);
+            }
+        } else {
             for i in 2..self.params.len() {
                 let flag = String::from(&self.params[i]);
                 parsed.push(flag);
             }
+        }
 
-        return parsed;
+        parsed
     }
 }

src/managers/commit_manager.rs

@@ -1,21 +1,20 @@
 use std::collections::HashMap;
 use std::default::Default;
 use std::fs::read_dir;
-use std::io::{Result, Write};
+use std::io::Result;
 use std::str::FromStr;
 
-use serde::{Deserialize, Serialize};
-use tokio::runtime::Runtime;
-
 use crate::managers;
 use crate::models::{self};
 use crate::parsers;
 use crate::syncers;
 use crate::utilities;
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Default)]
 pub struct CommitManager {
     pub ica_action: models::icarus_action::IcarusAction,
+    pub api: models::api::Api,
+    pub auth_api: models::api::Api,
 }
 
 #[derive(Clone, Debug)]
@@ -23,7 +22,6 @@ enum ActionValues {
     DeleteAct,
     DownloadAct,
     RetrieveAct,
-    UploadAct,
     UploadSongWithMetadata,
     None,
 }
@@ -36,15 +34,23 @@ enum En {
     Other,
 }
 
+#[derive(Debug)]
+struct UploadSongMembers {
+    pub song: simodels::song::Song,
+    pub coverart: simodels::coverart::CoverArt,
+    pub token: simodels::token::AccessToken,
+    pub album: simodels::album::collection::Album,
+}
+
 pub fn retrieve_song(
-    album: &icarus_models::album::collection::Album,
+    album: &simodels::album::collection::Album,
     track: i32,
     disc: i32,
-    directory: &String,
-    filename: &String,
-) -> Result<icarus_models::song::Song> {
+    directory: &str,
+    filename: &str,
+) -> Result<simodels::song::Song> {
     let mut found = false;
-    let mut song = icarus_models::song::Song::default();
+    let mut song = simodels::song::Song::default();
 
     for song_i in &album.tracks {
         if song_i.track == track && song_i.disc == disc {
@@ -52,17 +58,18 @@ pub fn retrieve_song(
             song.album = album.title.clone();
             song.album_artist = album.artist.clone();
             song.artist = track.artist.clone();
-            song.audio_type = String::from(icarus_models::constants::DEFAULTMUSICEXTENSION);
-            song.disc = track.disc.clone();
-            song.disc_count = album.disc_count.clone();
+            song.audio_type =
+                String::from(simodels::constants::file_extensions::audio::DEFAULTMUSICEXTENSION);
+            song.disc = track.disc;
+            song.disc_count = album.disc_count;
             song.duration = track.duration as i32;
             song.genre = album.genre.clone();
             song.title = track.title.clone();
-            song.year = album.year.clone();
-            song.track = track.track.clone();
-            song.track_count = album.track_count.clone();
-            song.directory = directory.clone();
-            song.filename = filename.clone();
+            song.year = album.year;
+            song.track = track.track;
+            song.track_count = album.track_count;
+            song.directory = directory.to_owned();
+            song.filename = filename.to_owned();
 
             found = true;
             break;
@@ -70,37 +77,44 @@ pub fn retrieve_song(
     }
 
     if found {
-        return Ok(song);
+        Ok(song)
+    } else {
+        Err(std::io::Error::other("Song not found"))
     }
-
-    return Err(std::io::Error::new(
-        std::io::ErrorKind::NotFound,
-        "Song not found",
-    ));
 }
 
 impl CommitManager {
-    pub fn commit_action(&mut self) {
+    pub async fn commit_action(&mut self) {
+        self.init_api().await;
+
         let action = &self.ica_action.action;
-        println!("Committing {} action", action);
+        println!("Committing {action} action");
 
         let mapped_actions = &self.map_actions();
-        let mapped_action = self.find_mapped_action(&mapped_actions, action);
+        let token = self.parse_token(&self.auth_api).await;
 
-        println!("{:?}", mapped_action);
-
-        match mapped_action {
-            ActionValues::DeleteAct => self.delete_song(),
-            ActionValues::DownloadAct => self.download_song(),
-            ActionValues::RetrieveAct => self.retrieve_object(),
-            ActionValues::UploadAct => self.upload_song(),
-            ActionValues::UploadSongWithMetadata => self.upload_song_with_metadata(),
+        match self.find_mapped_action(mapped_actions, action) {
+            ActionValues::DeleteAct => self.delete_song(&token).await,
+            ActionValues::DownloadAct => self.download_song(&token).await,
+            ActionValues::RetrieveAct => self.retrieve_object(&token).await,
+            ActionValues::UploadSongWithMetadata => self.upload_song_with_metadata(&token).await,
             _ => {
                 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);
+        self.api = prsr.retrieve_api(parsers::api_parser::APIType::Main);
+        self.auth_api = prsr.retrieve_api(parsers::api_parser::APIType::Auth);
+    }
+
     fn find_mapped_action(
         &self,
         actions: &HashMap<String, ActionValues>,
@@ -112,128 +126,116 @@ impl CommitManager {
             }
         }
 
-        return ActionValues::None;
+        ActionValues::None
     }
 
     fn map_actions(&self) -> HashMap<String, ActionValues> {
-        let actions: HashMap<String, ActionValues> = HashMap::from([
+        HashMap::from([
             ("download".to_string(), ActionValues::DownloadAct),
             ("download".to_string(), ActionValues::DownloadAct),
-            ("upload".to_string(), ActionValues::UploadAct),
             (
                 "upload-meta".to_string(),
                 ActionValues::UploadSongWithMetadata,
             ),
             ("retrieve".to_string(), ActionValues::RetrieveAct),
             ("delete".to_string(), ActionValues::DeleteAct),
-        ]);
-
-        return actions;
+        ])
     }
 
-    fn delete_song(&self) {
-        let mut prsr = parsers::api_parser::APIParser {
-            ica_act: self.ica_action.clone(),
-            api: models::api::API::default(),
-        };
-        prsr.parse_api();
-        let api = prsr.retrieve_api();
-
-        let token = self.parse_token(&api);
-
+    async fn delete_song(&self, token: &simodels::token::AccessToken) {
         println!("Deleting song");
 
-        let mut song = icarus_models::song::Song::default();
+        let mut del = syncers::delete::Delete {
+            api: self.api.clone(),
+        };
+        let mut song = simodels::song::Song::default();
 
         for arg in &self.ica_action.flags {
             let flag = &arg.flag;
             let value = &arg.value;
 
             if flag == "-D" {
-                song.id = value.parse::<i32>().unwrap();
+                song.id = uuid::Uuid::from_str(value.as_str()).unwrap();
             }
         }
 
-        let mut del = syncers::delete::Delete { api: api.clone() };
-
-        println!("Deleting song..");
-
-        let res_fut = del.delete_song(&token, &song);
-        let result = Runtime::new().unwrap().block_on(res_fut);
-        match result {
-            Ok(o) => {
-                println!("Song (Id {:?}) has been successfully deleted", o.id);
+        match del.delete_song(token, &song).await {
+            Ok((song, _coverart)) => {
+                println!("Song (Id {:?}) has been successfully deleted", song.id);
             }
             Err(er) => {
-                println!("Error {:?}", er);
+                println!("Error {er:?}");
             }
         }
     }
 
-    fn download_song(&self) {
-        println!("Deleting song");
+    async fn download_song(&self, token: &simodels::token::AccessToken) {
+        println!("Downloading song");
         let dwn = self.ica_action.retrieve_flag_value(&String::from("-b"));
-        let id: i32 = dwn.parse::<i32>().unwrap();
-
-        let mut prsr = parsers::api_parser::APIParser {
-            api: models::api::API::default(),
-            ica_act: self.ica_action.clone(),
+        let mut dwn_loader = syncers::download::Download {
+            api: self.api.clone(),
+        };
+        let mut song = simodels::song::Song {
+            id: uuid::Uuid::from_str(dwn.as_str()).unwrap(),
+            ..Default::default()
         };
-        prsr.parse_api();
 
-        let api = prsr.retrieve_api();
-        let token = self.parse_token(&api);
-        println!("Message: {}", token.message);
-
-        let mut dwn_loader = syncers::download::Download { api: api.clone() };
-        let mut song = icarus_models::song::Song::default();
-        song.id = id;
-        let result_fut = dwn_loader.download_song(&token, &song);
-        match Runtime::new().unwrap().block_on(result_fut) {
+        match dwn_loader.download_song(token, &song).await {
             Ok(o) => {
-                println!("Success");
-                let filename =
-                    String::from("audio") + icarus_models::constants::DEFAULTMUSICEXTENSION;
-                let data = o.as_bytes();
-                let mut file = std::fs::File::create(filename).expect("Failed to save");
-                file.write_all(&data)
-                    .expect("Failed to save downloaded song");
+                println!("Song downloaded");
+
+                song.data = o.as_bytes().to_vec();
+                song.directory = String::from(".");
+                song.filename = match simodels::song::generate_filename(
+                    simodels::types::MusicType::FlacExtension,
+                    true,
+                ) {
+                    Ok(filename) => filename,
+                    Err(err) => {
+                        eprintln!("Error generating song filename: {err:?}");
+                        utilities::checks::exit_program(-3);
+                        return;
+                    }
+                };
+                match song.save_to_filesystem() {
+                    Ok(_) => {
+                        println!("Song saved");
+                    }
+                    Err(err) => {
+                        eprintln!("Error saving song: {err:?}");
+                    }
+                }
             }
             Err(er) => {
-                println!("Error {:?}", er);
+                println!("Error {er:?}");
                 match er {
                     syncers::download::MyError::Request(error) => {
-                        println!("Error: {:?}", error);
+                        println!("Error: {error:?}");
                     }
                     syncers::download::MyError::Other(ss) => {
-                        println!("Error: {:?}", ss);
+                        println!("Error: {ss:?}");
                     }
                 }
             }
         }
     }
 
-    fn retrieve_object(&self) {
+    async fn retrieve_object(&self, token: &simodels::token::AccessToken) {
         println!("Retrieving song");
         let rt = self.ica_action.retrieve_flag_value(&String::from("-rt"));
 
         if rt != "songs" {
-            panic!("Unsupported -rt: {}", rt);
+            panic!("Unsupported -rt: {rt}");
         }
 
-        let mut prsr = parsers::api_parser::APIParser {
-            api: models::api::API::default(),
-            ica_act: self.ica_action.clone(),
+        let mut repo = syncers::retrieve_records::RetrieveRecords {
+            api: self.api.clone(),
         };
-        prsr.parse_api();
 
-        let api = prsr.retrieve_api();
-        let token = self.parse_token(&api);
-        let mut repo = syncers::retrieve_records::RetrieveRecords { api: api.clone() };
-        let result_fut = repo.get_all_songs(&token);
-
-        match Runtime::new().unwrap().block_on(result_fut) {
+        match repo.get_all_songs(token).await {
             Ok(o) => {
+                println!("Songs");
+                println!("=====");
                 for song in o {
                     println!("Title: {:?}", song.title);
                     println!("Artist: {:?}", song.artist);
@@ -242,22 +244,17 @@ impl CommitManager {
                 }
             }
             Err(er) => {
-                println!("Error: {:?}", er);
+                println!("Error: {er:?}");
             }
         }
     }
 
-    fn upload_song(&self) {
-        println!("Deleting song");
-        panic!("Not supported");
-    }
-
-    fn parse_token(&self, api: &models::api::API) -> icarus_models::token::AccessToken {
+    async fn parse_token(&self, api: &models::api::Api) -> simodels::token::AccessToken {
         println!("Fetching token");
 
         let mut usr_mgr: managers::user_manager::UserManager =
             managers::user_manager::UserManager {
-                user: icarus_models::user::User::default(),
+                user: simodels::user::User::default(),
                 ica_action: self.ica_action.clone(),
             };
         usr_mgr.parse_user_from_actions();
@@ -269,12 +266,12 @@ impl CommitManager {
         };
         tok_mgr.init();
 
-        let token = Runtime::new().unwrap().block_on(tok_mgr.request_token());
+        let token = tok_mgr.request_token().await;
 
-        return token.unwrap();
+        token.unwrap()
     }
 
-    fn upload_song_with_metadata(&mut self) {
+    async fn upload_song_with_metadata(&mut self, token: &simodels::token::AccessToken) {
         println!("Uplodaring song with metadara");
 
         let songpath = self.ica_action.retrieve_flag_value(&String::from("-s"));
@@ -282,13 +279,13 @@ impl CommitManager {
         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;
+        let single_target = !songpath.is_empty()
+            && !metadata_path.is_empty()
+            && !coverpath.is_empty()
+            && !track_id.is_empty();
 
         let uni = self.ica_action.retrieve_flag_value(&String::from("-smca"));
-        let multitarget = uni.len() > 0;
+        let multitarget = !uni.is_empty();
 
         if single_target && multitarget {
             println!("Cannot upload from source and directory");
@@ -296,37 +293,30 @@ impl CommitManager {
         }
 
         if single_target {
-            println!("Song path: {}", songpath);
-            println!("Track ID: {}", track_id);
-            println!("metadata path: {}", metadata_path);
-            println!("cover art path: {}", coverpath);
+            println!("Song path: {songpath}");
+            println!("Track ID: {track_id}");
+            println!("metadata path: {metadata_path}");
+            println!("cover art path: {coverpath}");
 
-            let _ = self.sing_target_upload(&songpath, &track_id, &metadata_path, &coverpath);
+            let _ = self
+                .sing_target_upload(&songpath, &track_id, &metadata_path, &coverpath, token)
+                .await;
         } else if multitarget {
-            let _ = self.multi_target_upload(&uni);
+            let _ = self.multi_target_upload(&uni, token).await;
         } else {
-            println!("Single or Multi target has not been chosen");
+            eprintln!("Single or Multi target has not been chosen");
         }
     }
 
-    fn sing_target_upload(
+    /// Only uploading one song
+    async fn sing_target_upload(
         &mut self,
         songpath: &String,
-        track_id: &String,
+        track_id: &str,
         meta_path: &String,
-        cover_path: &String,
+        cover_path: &str,
+        token: &simodels::token::AccessToken,
     ) -> Result<()> {
-        let mut prsr = parsers::api_parser::APIParser {
-            api: models::api::API::default(),
-            ica_act: self.ica_action.clone(),
-        };
-        prsr.parse_api();
-
-        let api = prsr.retrieve_api();
-        let token = self.parse_token(&api);
-
-        println!("Token: {:?}", token.token);
-
         let song_file = std::path::Path::new(&songpath);
 
         if !song_file.exists() {
@@ -334,20 +324,21 @@ impl CommitManager {
             panic!("Error");
         }
 
-        let mut cover_art = icarus_models::coverart::CoverArt {
-            id: 0,
-            title: String::new(),
-            path: cover_path.clone(),
-            data: Vec::new(),
+        let pa = std::path::Path::new(&cover_path);
+
+        let mut cover_art = simodels::coverart::CoverArt {
+            directory: String::from(pa.parent().unwrap().to_str().unwrap()),
+            filename: String::from(pa.file_name().unwrap().to_str().unwrap()),
+            ..Default::default()
         };
         let file_name = std::ffi::OsString::from(&song_file.file_name().unwrap());
 
         match self.find_file_extension(&file_name) {
             En::SongFile => match utilities::string::o_to_string(&file_name) {
                 Ok(s) => {
-                    println!("file name: {:?}", file_name);
+                    println!("file name: {file_name:?}");
 
-                    match icarus_models::album::collection::parse_album(&meta_path) {
+                    match simodels::album::collection::parse_album(meta_path) {
                         Ok(album) => {
                             let filename = s.clone();
                             let directory = song_file.parent().unwrap().display().to_string();
@@ -357,163 +348,225 @@ impl CommitManager {
                             println!("Directory: {:?}", s.directory);
                             println!("Filename: {:?}", s.filename);
                             println!("Path: {:?}", s.song_path());
-                            s.data = s.to_data().unwrap();
+                            s.data = simodels::song::io::to_data(&s).unwrap();
+                            cover_art.data = simodels::coverart::io::to_data(&cover_art).unwrap();
 
-                            cover_art.data = cover_art.to_data().unwrap();
+                            let members = UploadSongMembers {
+                                song: s,
+                                coverart: cover_art,
+                                token: token.clone(),
+                                album,
+                            };
 
+                            match self.upload_song_process(&members).await {
+                                Ok(_) => Ok(()),
+                                Err(err) => Err(err),
+                            }
+                        }
+                        Err(err) => {
+                            println!("Error: {err:?}");
+                            Err(std::io::Error::other(err.to_string()))
+                        }
+                    }
+                }
+                Err(er) => {
+                    println!("Error: {er:?}");
+                    Err(std::io::Error::other(er.to_string()))
+                }
+            },
+            _ => Err(std::io::Error::other("No sutitable file found".to_owned())),
+        }
+    }
+
+    /// Upload song to the queue to get processed
+    async fn upload_song_process(&self, data: &UploadSongMembers) -> Result<()> {
         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);
+        let token = &data.token;
+        let song = &data.song;
+        let album = &data.album;
+        let coverart = &data.coverart;
 
-                            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(),
-                                    ))
-                                }
+        println!("Queueing song");
+
+        let queued_song_id = match up.queue_song(token, song).await {
+            Ok(id) => id,
+            Err(err) => {
+                return Err(std::io::Error::other(err.to_string()));
             }
+        };
+
+        println!("Queued song Id: {queued_song_id:?}");
+
+        match up.link_user_to_queued_song(token, &queued_song_id).await {
+            Ok(_) => {
+                println!("Queued song linked to user");
             }
             Err(err) => {
-                            println!("Error: {:?}", err);
-                            Err(std::io::Error::new(
-                                std::io::ErrorKind::Other,
-                                err.to_string(),
-                            ))
+                return Err(std::io::Error::other(err.to_string()));
             }
         }
+
+        let queued_metadata_id = match up.queue_metadata(token, album, song, &queued_song_id).await
+        {
+            Ok(id) => id,
+            Err(err) => {
+                return Err(std::io::Error::other(err.to_string()));
             }
-                Err(er) => {
-                    println!("Error: {:?}", er);
-                    return Err(std::io::Error::new(
-                        std::io::ErrorKind::Other,
-                        er.to_string(),
-                    ));
+        };
+
+        println!("Queued metadata Id: {queued_metadata_id:?}");
+
+        match up.queue_coverart(token, coverart).await {
+            Ok(id) => match up
+                .link_queued_song_to_queued_coverart(token, &queued_song_id, &id)
+                .await
+            {
+                Ok(_) => match up
+                    .update_queued_song_status(token, &queued_song_id, "ready")
+                    .await
+                {
+                    Ok(_) => {
+                        println!("Queued coverart Id: {id:?}");
+                        println!("Linked queued song to queued coverart");
+                        println!("Queued status updated");
+                        Ok(())
                     }
+                    Err(err) => Err(std::io::Error::other(err.to_string())),
                 },
-            _ => {
-                return Err(std::io::Error::new(
-                    std::io::ErrorKind::Other,
-                    "No sutitable file found".to_owned(),
-                ));
-            }
+                Err(err) => Err(std::io::Error::other(err.to_string())),
+            },
+            Err(err) => Err(std::io::Error::other(err.to_string())),
         }
     }
 
     fn get_songs(
         &self,
         metadata_path: &String,
-        source_directory: &String,
-    ) -> Result<Vec<icarus_models::song::Song>> {
-        match icarus_models::album::collection::parse_album(metadata_path) {
+        source_directory: &str,
+    ) -> Result<Vec<simodels::song::Song>> {
+        match simodels::album::collection::parse_album(metadata_path) {
             Ok(albums) => {
-                let mut songs: Vec<icarus_models::song::Song> = Vec::new();
+                let mut songs: Vec<simodels::song::Song> = Vec::new();
 
                 for track in &albums.tracks {
-                    let filename = if track.track < 10 {
+                    let song_filename = if track.track < 10 {
                         "track0".to_owned()
                             + &track.track.to_string()
-                            + icarus_models::constants::DEFAULTMUSICEXTENSION
+                            + simodels::constants::file_extensions::audio::DEFAULTMUSICEXTENSION
                     } else {
                         "track".to_owned()
                             + &track.track.to_string()
-                            + icarus_models::constants::DEFAULTMUSICEXTENSION
+                            + simodels::constants::file_extensions::audio::DEFAULTMUSICEXTENSION
                     };
 
-                    songs.push(icarus_models::song::Song {
-                        id: -1,
+                    songs.push(simodels::song::Song {
                         title: track.title.clone(),
                         artist: track.artist.clone(),
-                        disc: track.disc.clone(),
-                        track: track.track.clone(),
-                        duration: track.duration.clone() as i32,
-                        year: albums.year.clone(),
+                        disc: track.disc,
+                        track: track.track,
+                        duration: track.duration as i32,
+                        year: albums.year,
                         album_artist: albums.artist.clone(),
                         genre: albums.genre.clone(),
-                        disc_count: albums.disc_count.clone(),
-                        track_count: albums.track_count.clone(),
+                        disc_count: albums.disc_count,
+                        track_count: albums.track_count,
                         album: albums.title.clone(),
                         audio_type: String::from("FLAC"),
-                        directory: source_directory.clone(),
-                        filename: filename,
-                        user_id: -1,
-                        data: Vec::new(),
-                        date_created: String::new(),
+                        directory: source_directory.to_owned(),
+                        filename: song_filename,
+                        ..Default::default()
                     });
                 }
                 Ok(songs)
             }
-            Err(_) => Ok(Vec::new()),
+            Err(_) => Err(std::io::Error::other("Songs not retrieved")),
         }
     }
 
-    fn multi_target_upload(&mut self, sourcepath: &String) -> std::io::Result<()> {
-        let mut prsr = parsers::api_parser::APIParser {
-            api: models::api::API::default(),
-            ica_act: self.ica_action.clone(),
-        };
-        prsr.parse_api();
-        let api = prsr.retrieve_api();
-        let token = self.parse_token(&api);
-
+    async fn multi_target_upload(
+        &mut self,
+        sourcepath: &String,
+        token: &simodels::token::AccessToken,
+    ) -> std::io::Result<()> {
         let directory_path = std::path::Path::new(&sourcepath);
 
         if !directory_path.exists() {
             panic!("Directory does not exist");
         }
 
-        let mut cover_art = icarus_models::coverart::CoverArt {
-            id: 0,
-            title: String::new(),
-            path: match self.get_cover_art_path(&sourcepath) {
-                Ok(o) => o,
-                Err(_) => String::new(),
-            },
-            data: Vec::new(),
-        };
-        let metadatapath = match self.get_metadata_path(&sourcepath) {
-            Ok(o) => o,
-            Err(_) => String::new(),
-        };
+        let (coverart_directory, coverart_filename) =
+            self.get_coverart_dir_and_filename(sourcepath).unwrap();
+        let mut cover_art = simodels::coverart::init::init_coverart_dir_and_filename(
+            &coverart_directory,
+            &coverart_filename,
+        );
+        let metadatapath = self.get_metadata_path(sourcepath).unwrap_or_default();
 
         let mut up = syncers::upload::Upload::default();
         let host = self.ica_action.retrieve_flag_value(&String::from("-h"));
         up.set_api(&host);
 
-        cover_art.data = cover_art.to_data().unwrap();
+        cover_art.data = simodels::coverart::io::to_data(&cover_art).unwrap();
 
-        println!("");
-
-        match self.get_songs(&metadatapath, &sourcepath) {
-            Ok(sngs) => {
+        match self.get_songs(&metadatapath, sourcepath) {
+            Ok(sngs) => match simodels::album::collection::parse_album(&metadatapath) {
+                Ok(album) => {
                     for song in sngs {
-                    match Runtime::new()
-                        .unwrap()
-                        .block_on(up.upload_song_with_metadata(&token, &song, &cover_art))
-                    {
+                        let members = UploadSongMembers {
+                            song,
+                            coverart: cover_art.clone(),
+                            token: token.clone(),
+                            album: album.clone(),
+                        };
+
+                        match self.upload_song_process(&members).await {
                             Ok(o) => {
-                            println!("Response: {:?}", o);
+                                println!("Response: {o:?}");
                             }
                             Err(err) => {
-                            println!("Error: {:?}", err);
+                                eprintln!("Error: {err:?}");
+                                return Err(err);
                             }
-                    };
-                }
-            }
-            Err(error) => {
-                println!("Error: {:?}", error);
                         }
                     }
 
                     Ok(())
                 }
+                Err(err) => {
+                    eprintln!("Error: {err:?}");
+                    Err(std::io::Error::other(err.to_string()))
+                }
+            },
+            Err(error) => {
+                eprintln!("Error: {error:?}");
+                Err(std::io::Error::other(error.to_string()))
+            }
+        }
+    }
+
+    fn get_coverart_dir_and_filename(&self, directory: &str) -> Result<(String, String)> {
+        for entry in read_dir(std::path::Path::new(directory))? {
+            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:?}");
+
+            if let En::ImageFile = self.find_file_extension(&file_name) {
+                let fname = utilities::string::o_to_string(&file_name);
+                return Ok((directory.to_string(), fname.unwrap()));
+            }
+        }
+
+        Err(std::io::Error::other(
+            "CoverArt directory and filename not found",
+        ))
+    }
 
     fn find_file_extension(&self, file_name: &std::ffi::OsString) -> En {
         let file_name_str = Some(file_name.clone().into_string());
@@ -540,13 +593,14 @@ impl CommitManager {
                     index += 1;
                 }
 
-                if extension == icarus_models::constants::WAVEXTENSION[1..]
-                    || extension == icarus_models::constants::FLACEXTENSION[1..]
+                if extension == simodels::constants::file_extensions::audio::WAVEXTENSION[1..]
+                    || extension == simodels::constants::file_extensions::audio::FLACEXTENSION[1..]
                 {
                     return En::SongFile;
                 } else if extension == "json" {
                     return En::MetadataFile;
-                } else if extension == icarus_models::constants::JPGEXTENSION[1..]
+                } else if extension
+                    == simodels::constants::file_extensions::image::JPGEXTENSION[1..]
                     || extension == "jpeg"
                     || extension == "png"
                 {
@@ -558,31 +612,7 @@ impl CommitManager {
             }
         }
 
-        return En::Other;
-    }
-
-    fn get_cover_art_path(&self, directory_path: &String) -> Result<String> {
-        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())
+        En::Other
     }
 
     fn get_metadata_path(&self, directory_path: &String) -> Result<String> {
@@ -592,28 +622,16 @@ impl CommitManager {
             let file_type = entry.file_type();
             let file_name = entry.file_name();
 
-            println!("file type: {:?}", file_type);
-            println!("file name: {:?}", file_name);
+            println!("file type: {file_type:?}");
+            println!("file name: {file_name:?}");
 
-            match self.find_file_extension(&file_name) {
-                En::MetadataFile => {
+            if let En::MetadataFile = self.find_file_extension(&file_name) {
                 let directory_part = directory_path.clone();
                 let fname = utilities::string::o_to_string(&file_name);
-                    return Ok(directory_part + "/" + &fname.unwrap());
-                }
-                _ => {}
+                return Ok(format!("{}/{}", 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" {
-                return true;
-            }
-        }
-        return false;
+        Err(std::io::Error::other("Metadata path not found"))
     }
 }

src/managers/token_manager.rs

@@ -2,34 +2,42 @@ use std::default::Default;
 
 use crate::models;
 
+mod response {
+    pub mod token {
+        #[derive(Debug, serde::Deserialize, serde::Serialize)]
+        pub struct Response {
+            pub message: String,
+            pub data: Vec<simodels::login_result::LoginResult>,
+        }
+    }
+}
+
 pub struct TokenManager {
-    pub user: icarus_models::user::User,
-    pub api: models::api::API,
+    pub user: simodels::user::User,
+    pub api: models::api::Api,
 }
 
 impl Default for TokenManager {
     fn default() -> Self {
         let mut token = TokenManager {
-            user: icarus_models::user::User::default(),
-            api: models::api::API::default(),
+            user: simodels::user::User::default(),
+            api: models::api::Api::default(),
         };
-
         token.init();
 
-        return token;
+        token
     }
 }
 
 impl TokenManager {
-    pub async fn request_token(&self) -> Result<icarus_models::token::AccessToken, std::io::Error> {
+    pub async fn request_token(&self) -> Result<simodels::token::AccessToken, std::io::Error> {
         println!("Sending request for a token");
 
         let url = self.retrieve_url();
+        println!("URL: {url}");
 
-        println!("URL: {}", url);
-
-        let mut token = icarus_models::token::AccessToken {
-            user_id: -1,
+        let mut token = simodels::token::AccessToken {
+            user_id: uuid::Uuid::nil(),
             username: String::new(),
             token: String::new(),
             token_type: String::new(),
@@ -43,37 +51,36 @@ impl TokenManager {
         match response.status() {
             reqwest::StatusCode::OK => {
                 // on success, parse our JSON to an APIResponse
-                let s = response.json::<icarus_models::token::AccessToken>().await;
-                match s {
-                    //
-                    Ok(parsed) => {
-                        token = parsed;
+                match response.json::<response::token::Response>().await {
+                    Ok(response) => {
+                        let login_result = &response.data[0];
+                        token.user_id = login_result.id;
+                        token.username = login_result.username.clone();
+                        token.token = login_result.token.clone();
+                        token.token_type = login_result.token_type.clone();
+                        token.expiration = login_result.expiration;
+                        token.message = response.message;
+                        Ok(token)
+                    }
+                    Err(err) => Err(std::io::Error::other(err.to_string())),
                 }
-                    Err(_) => println!("Hm, the response didn't match the shape we expected."),
-                };
             }
             reqwest::StatusCode::UNAUTHORIZED => {
-                println!("Need to grab a new token");
+                Err(std::io::Error::other("Need to grab a new token"))
             }
             other => {
-                panic!("Uh oh! Something unexpected happened: {:?}", other);
+                panic!("Uh oh! Something unexpected happened: {other:?}");
             }
         }
-
-        return Ok(token);
     }
 
     pub fn init(&mut self) {
         let api = &mut self.api;
-        api.version = String::from("v1");
-        api.endpoint = String::from(format!("api/{}/login", api.version));
+        api.version = String::from(crate::parsers::api_parser::API_VERSION);
+        api.endpoint = 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.endpoint);
-
-        return url;
+        format!("{}{}", self.api.url, self.api.endpoint)
     }
 }

src/managers/user_manager.rs

@@ -1,27 +1,16 @@
 use std::default::Default;
 
-use serde::{Deserialize, Serialize};
-
 use crate::models::{self};
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Default)]
 pub struct UserManager {
-    pub user: icarus_models::user::User,
+    pub user: simodels::user::User,
     pub ica_action: models::icarus_action::IcarusAction,
 }
 
-impl Default for UserManager {
-    fn default() -> Self {
-        UserManager {
-            user: icarus_models::user::User::default(),
-            ica_action: models::icarus_action::IcarusAction::default(),
-        }
-    }
-}
-
 impl UserManager {
-    pub fn retrieve_user(&self) -> icarus_models::user::User {
-        return self.user.clone();
+    pub fn retrieve_user(&self) -> simodels::user::User {
+        self.user.clone()
     }
 
     pub fn parse_user_from_actions(&mut self) {

src/models/api.rs

@@ -1,20 +1,8 @@
 use std::default::Default;
 
-use serde::{Deserialize, Serialize};
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct API {
+#[derive(Clone, Debug, Default)]
+pub struct Api {
     pub url: String,
     pub endpoint: String,
     pub version: String,
 }
-
-impl Default for API {
-    fn default() -> Self {
-        API {
-            url: String::new(),
-            endpoint: String::new(),
-            version: String::new(),
-        }
-    }
-}

src/models/flags.rs

@@ -1,18 +1,7 @@
 use std::default::Default;
 
-use serde::{Deserialize, Serialize};
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
+#[derive(Clone, Debug, Default)]
 pub struct Flags {
     pub flag: String,
     pub value: String,
 }
-
-impl Default for Flags {
-    fn default() -> Self {
-        Flags {
-            flag: String::new(),
-            value: String::new(),
-        }
-    }
-}

src/models/icarus_action.rs

@@ -1,24 +1,13 @@
 use std::default::Default;
 
-use serde::{Deserialize, Serialize};
-
 use crate::models;
 
-#[derive(Clone, Debug, Deserialize, Serialize)]
+#[derive(Clone, Debug, Default)]
 pub struct IcarusAction {
     pub action: String,
     pub flags: Vec<models::flags::Flags>,
 }
 
-impl Default for IcarusAction {
-    fn default() -> Self {
-        IcarusAction {
-            action: String::new(),
-            flags: Vec::new(),
-        }
-    }
-}
-
 impl IcarusAction {
     pub fn retrieve_flag_value(&self, flag: &String) -> String {
         let mut val: String = String::new();
@@ -30,7 +19,7 @@ impl IcarusAction {
             }
         }
 
-        return val;
+        val
     }
 
     pub fn print_action_and_flags(&self) {

src/models/mod.rs

@@ -1,4 +1,3 @@
 pub mod api;
 pub mod flags;
 pub mod icarus_action;
-pub mod upload_form;

src/models/upload_form.rs

@@ -1,18 +0,0 @@
-use std::default::Default;
-
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Deserialize, Serialize)]
-pub struct UploadForm {
-    pub url: Option<String>,
-    pub filepath: Option<String>,
-}
-
-impl Default for UploadForm {
-    fn default() -> Self {
-        UploadForm {
-            url: None,
-            filepath: None,
-        }
-    }
-}

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 fn retrieve_api(&self) -> models::api::API {
-        return self.api.clone();
+pub const API_VERSION: &str = "v2";
+
+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,32 @@ 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 = format!("{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 = format!("{value}/");
+                        }
+                        break;
+                    }
+                }
+            }
+        }
 
-        self.api.version = "v1".to_string();
+        for api in &mut self.apis {
+            api.version = String::from(API_VERSION);
+        }
     }
 }

src/syncers/common.rs

@@ -0,0 +1,26 @@
+use crate::models;
+
+pub fn retrieve_url(api: &models::api::Api, with_id: bool, id: &uuid::Uuid) -> String {
+    if with_id {
+        retrieve_url_with_id(api, id)
+    } else {
+        retrieve_url_reg(api)
+    }
+}
+
+fn retrieve_url_reg(api: &models::api::Api) -> String {
+    format!("{}api/{}/{}/", api.url, api.version, api.endpoint)
+}
+
+fn retrieve_url_with_id(api: &models::api::Api, id: &uuid::Uuid) -> String {
+    format!("{}api/{}/{}/{}", api.url, api.version, api.endpoint, id)
+}
+
+pub async fn auth_header(
+    token: &simodels::token::AccessToken,
+) -> Result<(http::HeaderName, http::HeaderValue), http::header::InvalidHeaderValue> {
+    match http::HeaderValue::from_str(&token.bearer_token()) {
+        Ok(auth_value) => Ok((reqwest::header::AUTHORIZATION, auth_value)),
+        Err(err) => Err(err),
+    }
+}

src/syncers/delete.rs

@@ -4,15 +4,23 @@ use reqwest;
 
 use crate::models;
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Default)]
 pub struct Delete {
-    pub api: models::api::API,
+    pub api: models::api::Api,
 }
 
-impl Default for Delete {
-    fn default() -> Self {
-        Delete {
-            api: models::api::API::default(),
+mod response {
+    pub mod delete_song {
+        #[derive(Debug, serde::Deserialize)]
+        pub struct SongAndCoverArt {
+            pub song: simodels::song::Song,
+            pub coverart: simodels::coverart::CoverArt,
+        }
+
+        #[derive(Debug, serde::Deserialize)]
+        pub struct Response {
+            pub message: String,
+            pub data: Vec<SongAndCoverArt>,
         }
     }
 }
@@ -20,11 +28,13 @@ impl Default for Delete {
 impl Delete {
     pub async fn delete_song(
         &mut self,
-        token: &icarus_models::token::AccessToken,
-        song: &icarus_models::song::Song,
-    ) -> Result<icarus_models::song::Song, std::io::Error> {
-        self.api.endpoint = "song/data/delete".to_owned();
-        let url = self.retrieve_url(&song);
+        token: &simodels::token::AccessToken,
+        song: &simodels::song::Song,
+    ) -> Result<(simodels::song::Song, simodels::coverart::CoverArt), std::io::Error> {
+        self.api.endpoint = "api/v2/song".to_owned();
+        let url = format!("{}{}/{}", self.api.url, self.api.endpoint, song.id);
+        println!("Url: {url:?}");
+
         let client = reqwest::Client::builder().build().unwrap();
         let access_token = token.bearer_token();
         let response = client
@@ -33,39 +43,21 @@ impl Delete {
             .send()
             .await
             .unwrap();
-        let mut sng = icarus_models::song::Song::default();
 
         match response.status() {
             reqwest::StatusCode::OK => {
                 println!("Success!");
-                let s = response.json::<icarus_models::song::Song>().await;
-                match s {
-                    Ok(parsed) => {
-                        sng = parsed;
-                    }
-                    Err(er) => {
-                        println!("Error {:?}", er);
-                    }
-                };
-            }
-            other => {
-                panic!("Issue occurred: {:?}", other);
-            }
-        }
 
-        return Ok(sng);
+                match response.json::<response::delete_song::Response>().await {
+                    Ok(resp) => {
+                        println!("Response message: {:?}", resp.message);
+                        let data = &resp.data[0];
+                        Ok((data.song.clone(), data.coverart.clone()))
+                    }
+                    Err(er) => Err(std::io::Error::other(er.to_string())),
+                }
+            }
+            other => Err(std::io::Error::other(other.to_string())),
         }
-
-    fn retrieve_url(&self, song: &icarus_models::song::Song) -> String {
-        let api = &self.api;
-        let mut url: String = String::from(&api.url);
-        url += &String::from("api/");
-        url += &String::from(&api.version);
-        url += &String::from("/");
-        url += &String::from(&api.endpoint);
-        url += &String::from("/");
-        url += &song.id.to_string();
-
-        return url;
     }
 }

src/syncers/download.rs

@@ -1,17 +1,11 @@
 use std::default::Default;
 
 use crate::models;
+use crate::syncers;
 
+#[derive(Default)]
 pub struct Download {
-    pub api: models::api::API,
-}
-
-impl Default for Download {
-    fn default() -> Self {
-        Download {
-            api: models::api::API::default(),
-        }
-    }
+    pub api: models::api::Api,
 }
 
 #[derive(Debug)]
@@ -23,64 +17,34 @@ pub enum MyError {
 impl Download {
     pub async fn download_song(
         &mut self,
-        token: &icarus_models::token::AccessToken,
-        song: &icarus_models::song::Song,
+        token: &simodels::token::AccessToken,
+        song: &simodels::song::Song,
     ) -> Result<String, MyError> {
-        self.api.endpoint = String::from("song/data/download");
-        let url = self.retrieve_url(&song);
+        self.api.endpoint = String::from("song/download");
+        let url = syncers::common::retrieve_url(&self.api, true, &song.id);
         let access_token = token.bearer_token();
 
-        let mut headers = reqwest::header::HeaderMap::new();
-        headers.insert(
-            reqwest::header::AUTHORIZATION,
-            http::header::HeaderValue::from_str(&access_token.clone()).unwrap(),
-        );
+        println!("Url: {url:?}");
 
         let client = reqwest::Client::builder().build().unwrap();
-        let response = client
+
+        match client
             .get(&url)
             .header(reqwest::header::AUTHORIZATION, &access_token)
             .send()
-            .await;
-
-        match response {
+            .await
+        {
             Ok(rep) => match rep.status() {
-                reqwest::StatusCode::OK => {
-                    let data = rep.text();
-                    match data.await {
-                        Ok(e) => {
-                            return Ok(e);
-                        }
-                        Err(er) => {
-                            println!("Error {:?}", er);
-                        }
-                    }
-                }
-                reqwest::StatusCode::UNAUTHORIZED => {
-                    println!("Need to grab a new token");
-                }
-                other => {
-                    panic!("Uh oh! Something unexpected happened: {:?}", other);
-                }
+                reqwest::StatusCode::OK => match rep.text().await {
+                    Ok(e) => Ok(e),
+                    Err(er) => Err(MyError::Other(er.to_string())),
                 },
-            Err(er) => {
-                return Err(MyError::Request(er));
+                reqwest::StatusCode::UNAUTHORIZED => {
+                    Err(MyError::Other(String::from("Need to grab a new token")))
+                }
+                other => Err(MyError::Other(other.to_string())),
+            },
+            Err(er) => Err(MyError::Request(er)),
         }
     }
-
-        return Err(MyError::Other(String::from("Error downloading")));
-    }
-
-    fn retrieve_url(&self, song: &icarus_models::song::Song) -> String {
-        let api = &self.api;
-        let mut url: String = String::from(&api.url);
-        url += &String::from("api/");
-        url += &String::from(&api.version);
-        url += &String::from("/");
-        url += &String::from(&api.endpoint);
-        url += &String::from("/");
-        url += &song.id.to_string();
-
-        return url;
-    }
 }

src/syncers/mod.rs

@@ -1,3 +1,4 @@
+pub mod common;
 pub mod delete;
 pub mod download;
 pub mod retrieve_records;

src/syncers/retrieve_records.rs

@@ -3,14 +3,17 @@ use std::io::Error;
 
 use crate::models;
 
+#[derive(Default)]
 pub struct RetrieveRecords {
-    pub api: models::api::API,
+    pub api: models::api::Api,
 }
 
-impl Default for RetrieveRecords {
-    fn default() -> Self {
-        RetrieveRecords {
-            api: models::api::API::default(),
+mod response {
+    pub mod get_all_songs {
+        #[derive(Debug, serde::Deserialize)]
+        pub struct Response {
+            pub message: String,
+            pub data: Vec<simodels::song::Song>,
         }
     }
 }
@@ -18,22 +21,13 @@ impl Default for RetrieveRecords {
 impl RetrieveRecords {
     pub async fn get_all_songs(
         &mut self,
-        token: &icarus_models::token::AccessToken,
-    ) -> Result<Vec<icarus_models::song::Song>, Error> {
-        self.api.endpoint = String::from("song");
-        let mut songs: Vec<icarus_models::song::Song> = Vec::new();
-        let url = self.retrieve_url();
+        token: &simodels::token::AccessToken,
+    ) -> Result<Vec<simodels::song::Song>, Error> {
+        self.api.endpoint = String::from("api/v2/song/all");
+        let url = format!("{}{}", self.api.url, self.api.endpoint);
         let access_token = token.bearer_token();
 
-        let mut headers = reqwest::header::HeaderMap::new();
-        headers.insert(
-            reqwest::header::AUTHORIZATION,
-            http::header::HeaderValue::from_str(&access_token.clone()).unwrap(),
-        );
-        headers.insert(
-            reqwest::header::CONTENT_TYPE,
-            http::header::HeaderValue::from_static("application/json"),
-        );
+        println!("url: {url:?}");
 
         let client = reqwest::Client::builder().build().unwrap();
         let response = client
@@ -46,35 +40,18 @@ impl RetrieveRecords {
         match response.status() {
             reqwest::StatusCode::OK => {
                 // on success, parse our JSON to an API Response
-                let s = response.json::<Vec<icarus_models::song::Song>>().await;
-                match s {
-                    //
+                match response.json::<response::get_all_songs::Response>().await {
                     Ok(parsed) => {
-                        songs = parsed;
+                        println!("Response message: {:?}", parsed.message);
+                        Ok(parsed.data)
+                    }
+                    Err(err) => Err(std::io::Error::other(err.to_string())),
                 }
-                    Err(_) => println!("Hm, the response didn't match the shape we expected."),
-                };
             }
             reqwest::StatusCode::UNAUTHORIZED => {
-                println!("Need to grab a new token");
+                Err(std::io::Error::other("Need to grab a new token"))
             }
-            other => {
-                panic!("Uh oh! Something unexpected happened: {:?}", other);
+            other => Err(std::io::Error::other(other.to_string())),
         }
     }
-
-        return Ok(songs);
-    }
-
-    fn retrieve_url(&self) -> String {
-        let api = &self.api;
-        let mut url: String = String::from(&api.url);
-        url += &String::from("api/");
-        url += &String::from(&api.version);
-        url += &String::from("/");
-        url += &String::from(&api.endpoint);
-        url += &String::from("/");
-
-        return url;
-    }
 }

src/syncers/upload.rs

@@ -4,47 +4,74 @@ use http::HeaderValue;
 use reqwest;
 
 use crate::models;
+use crate::syncers;
 
+#[derive(Default)]
 pub struct Upload {
-    pub api: models::api::API,
+    pub api: models::api::Api,
 }
 
-impl Default for Upload {
-    fn default() -> Self {
-        Upload {
-            api: models::api::API::default(),
+mod response {
+    pub mod queue_song {
+        #[derive(Debug, serde::Deserialize)]
+        pub struct Response {
+            pub message: String,
+            pub data: Vec<uuid::Uuid>,
+        }
+    }
+
+    pub mod queue_metadata {
+        #[derive(Debug, serde::Deserialize)]
+        pub struct Response {
+            pub message: String,
+            pub data: Vec<uuid::Uuid>,
+        }
+    }
+
+    pub mod queue_coverart {
+        #[derive(Debug, serde::Deserialize)]
+        pub struct Response {
+            pub message: String,
+            pub data: Vec<uuid::Uuid>,
         }
     }
 }
 
 impl Upload {
-    pub async fn upload_song_with_metadata(
-        &mut self,
-        token: &icarus_models::token::AccessToken,
-        song: &icarus_models::song::Song,
-        cover: &icarus_models::coverart::CoverArt,
-    ) -> Result<reqwest::Response, reqwest::Error> {
-        self.api.endpoint = String::from("song/data/upload/with/data");
-        let url = self.retrieve_url();
-        let access_token = token.bearer_token();
+    pub async fn queue_song(
+        &self,
+        token: &simodels::token::AccessToken,
+        song: &simodels::song::Song,
+    ) -> Result<uuid::Uuid, reqwest::Error> {
+        let songpath = song.song_path().unwrap();
+        let file = tokio::fs::File::open(&songpath).await.unwrap();
+        let stream = tokio_util::codec::FramedRead::new(file, tokio_util::codec::BytesCodec::new());
+        let file_body = reqwest::Body::wrap_stream(stream);
 
-        if url.is_empty() {
-            println!("Url is empty");
-        }
+        let form = reqwest::multipart::Form::new().part(
+            "file",
+            reqwest::multipart::Part::stream(file_body)
+                .file_name(song.filename.clone())
+                .mime_str("application/octet-stream")
+                .unwrap(),
+        );
 
-        println!("Url: {}", url);
-        println!("Token: {}", access_token);
-        println!("Path: {:?}", song.song_path());
+        let endpoint = String::from("api/v2/song/queue");
+        let url = format!("{}/{endpoint}", self.api.url);
+        println!("Url: {url:?}");
 
         let mut headers = reqwest::header::HeaderMap::new();
-        headers.insert(
-            reqwest::header::AUTHORIZATION,
-            HeaderValue::from_str(&access_token.clone()).unwrap(),
-        );
-        headers.insert(reqwest::header::ACCEPT, HeaderValue::from_static("*/*"));
+        let (auth, auth_val) = syncers::common::auth_header(token).await.unwrap();
+        headers.insert(auth, auth_val);
+        headers.insert("Accept", HeaderValue::from_str("*/*").unwrap());
+        headers.insert("Connection", HeaderValue::from_str("keep-alive").unwrap());
+        headers.insert("Cache-Control", HeaderValue::from_str("no-cache").unwrap());
 
-        let form = self.init_form(&song, &cover);
-        let client = reqwest::Client::builder().build().unwrap();
+        let client = reqwest::Client::builder()
+            .timeout(std::time::Duration::from_secs(300))
+            .pool_idle_timeout(std::time::Duration::from_secs(30))
+            .build()
+            .unwrap();
         match client
             .post(url)
             .headers(headers)
@@ -52,76 +79,226 @@ impl Upload {
             .send()
             .await
         {
-            Ok(r) => {
-                return Ok(r);
-            }
-            Err(err) => {
-                return Err(err);
+            Ok(response) => match response.json::<response::queue_song::Response>().await {
+                Ok(resp) => {
+                    println!("Message: {:?}", resp.message);
+                    Ok(resp.data[0])
                 }
+                Err(err) => Err(err),
+            },
+            Err(err) => Err(err),
         }
     }
 
-    fn init_form(
+    pub async fn link_user_to_queued_song(
         &self,
-        song: &icarus_models::song::Song,
-        cover: &icarus_models::coverart::CoverArt,
-    ) -> reqwest::multipart::Form {
-        let songpath = match song.song_path() {
-            Ok(s) => s,
-            Err(_) => String::new(),
-        };
-        let coverpath = cover.path.clone();
-        println!("Cover path: {:?}", coverpath);
-        let song_detail = match song.to_metadata_json(true) {
-            Ok(s) => s,
-            Err(_) => String::new(),
-        };
+        token: &simodels::token::AccessToken,
+        queued_song_id: &uuid::Uuid,
+    ) -> Result<(), reqwest::Error> {
+        let endpoint = String::from("api/v2/song/queue/link");
+        let url = format!("{}/{endpoint}", self.api.url);
 
-        println!("\n{}\n", song_detail);
+        let mut headers = reqwest::header::HeaderMap::new();
+        let (auth, auth_val) = syncers::common::auth_header(token).await.unwrap();
+        headers.insert(auth, auth_val);
 
-        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;
+        let payload = serde_json::json!({
+            "song_queue_id": queued_song_id,
+            "user_id": token.user_id
+        });
 
-        let form = reqwest::multipart::Form::new()
-            .part(
-                "file",
-                reqwest::multipart::Part::bytes(std::fs::read(songpath).unwrap())
-                    .file_name(song_filename),
-            )
-            .part(
-                "cover",
-                reqwest::multipart::Part::bytes(std::fs::read(coverpath).unwrap())
-                    .file_name(cover_filename),
-            )
-            .text("metadata", song_detail);
+        let client = reqwest::Client::builder().build().unwrap();
 
-        return form;
+        match client
+            .patch(url)
+            .headers(headers)
+            .json(&payload)
+            .send()
+            .await
+        {
+            Ok(_) => Ok(()),
+            Err(err) => Err(err),
+        }
     }
 
-    pub fn set_api(&mut self, host: &String) {
-        let mut api = models::api::API::default();
-        api.url = host.clone();
-        api.version = String::from("v1");
+    pub async fn queue_metadata(
+        &self,
+        token: &simodels::token::AccessToken,
+        album: &simodels::album::collection::Album,
+        song: &simodels::song::Song,
+        queued_song_id: &uuid::Uuid,
+    ) -> Result<uuid::Uuid, reqwest::Error> {
+        let endpoint = String::from("api/v2/song/metadata/queue");
+        let url = format!("{}/{endpoint}", self.api.url);
+
+        let mut headers = reqwest::header::HeaderMap::new();
+        let (auth, auth_val) = syncers::common::auth_header(token).await.unwrap();
+        headers.insert(auth, auth_val);
+
+        let payload = serde_json::json!({
+            "song_queue_id": queued_song_id,
+            "title": song.title,
+            "artist": song.artist,
+            "album_artist": album.artist,
+            "album": album.title,
+            "genre": song.genre,
+            "track": song.track,
+            "track_count": album.track_count,
+            "disc": song.disc,
+            "disc_count": album.disc_count,
+            "year": album.year,
+            "duration": song.duration,
+        });
+
+        let client = reqwest::Client::builder().build().unwrap();
+
+        match client
+            .post(url)
+            .headers(headers)
+            .json(&payload)
+            .send()
+            .await
+        {
+            Ok(response) => match response.json::<response::queue_metadata::Response>().await {
+                Ok(resp) => {
+                    println!("Message: {:?}", resp.message);
+
+                    Ok(resp.data[0])
+                }
+                Err(err) => Err(err),
+            },
+            Err(err) => Err(err),
+        }
+    }
+
+    pub async fn queue_coverart(
+        &self,
+        token: &simodels::token::AccessToken,
+        coverart: &simodels::coverart::CoverArt,
+    ) -> Result<uuid::Uuid, reqwest::Error> {
+        let coverartpath = coverart.get_path().unwrap();
+        let file = tokio::fs::File::open(&coverartpath).await.unwrap();
+        let stream = tokio_util::codec::FramedRead::new(file, tokio_util::codec::BytesCodec::new());
+        let file_body = reqwest::Body::wrap_stream(stream);
+
+        let file_name = std::path::Path::new(&coverartpath)
+            .file_name()
+            .and_then(|name| name.to_str())
+            .map(String::from)
+            .unwrap_or("file".to_string());
+
+        let form = reqwest::multipart::Form::new().part(
+            "file",
+            reqwest::multipart::Part::stream(file_body)
+                .file_name(file_name)
+                .mime_str("application/octet-stream")
+                .unwrap(),
+        );
+
+        let endpoint = String::from("api/v2/coverart/queue");
+        let url = format!("{}/{endpoint}", self.api.url);
+        println!("Url: {url:?}");
+
+        let mut headers = reqwest::header::HeaderMap::new();
+        let (auth, auth_val) = syncers::common::auth_header(token).await.unwrap();
+        headers.insert(auth, auth_val);
+        headers.insert("Accept", HeaderValue::from_str("*/*").unwrap());
+        headers.insert("Connection", HeaderValue::from_str("keep-alive").unwrap());
+        headers.insert("Cache-Control", HeaderValue::from_str("no-cache").unwrap());
+
+        let client = reqwest::Client::builder()
+            .timeout(std::time::Duration::from_secs(300))
+            .pool_idle_timeout(std::time::Duration::from_secs(30))
+            .build()
+            .unwrap();
+        match client
+            .post(url)
+            .headers(headers)
+            .multipart(form)
+            .send()
+            .await
+        {
+            Ok(response) => match response.json::<response::queue_coverart::Response>().await {
+                Ok(resp) => {
+                    println!("Message: {:?}", resp.message);
+                    Ok(resp.data[0])
+                }
+                Err(err) => Err(err),
+            },
+            Err(err) => Err(err),
+        }
+    }
+
+    pub async fn link_queued_song_to_queued_coverart(
+        &self,
+        token: &simodels::token::AccessToken,
+        queued_song_id: &uuid::Uuid,
+        queued_coverart_id: &uuid::Uuid,
+    ) -> Result<(), reqwest::Error> {
+        let endpoint = String::from("api/v2/coverart/queue/link");
+        let url = format!("{}/{endpoint}", self.api.url);
+
+        let mut headers = reqwest::header::HeaderMap::new();
+        let (auth, auth_val) = syncers::common::auth_header(token).await.unwrap();
+        headers.insert(auth, auth_val);
+
+        let payload = serde_json::json!({
+            "song_queue_id": queued_song_id,
+            "coverart_id": queued_coverart_id
+        });
+
+        let client = reqwest::Client::builder().build().unwrap();
+
+        match client
+            .patch(url)
+            .headers(headers)
+            .json(&payload)
+            .send()
+            .await
+        {
+            Ok(_) => Ok(()),
+            Err(err) => Err(err),
+        }
+    }
+
+    pub async fn update_queued_song_status(
+        &self,
+        token: &simodels::token::AccessToken,
+        queued_song_id: &uuid::Uuid,
+        status: &str,
+    ) -> Result<(), reqwest::Error> {
+        let endpoint = String::from("api/v2/song/queue");
+        let url = format!("{}/{endpoint}", self.api.url);
+
+        let mut headers = reqwest::header::HeaderMap::new();
+        let (auth, auth_val) = syncers::common::auth_header(token).await.unwrap();
+        headers.insert(auth, auth_val);
+
+        let payload = serde_json::json!({
+            "id": queued_song_id,
+            "status": status
+        });
+
+        let client = reqwest::Client::builder().build().unwrap();
+
+        match client
+            .patch(url)
+            .headers(headers)
+            .json(&payload)
+            .send()
+            .await
+        {
+            Ok(_) => Ok(()),
+            Err(err) => Err(err),
+        }
+    }
+
+    pub fn set_api(&mut self, host: &str) {
+        let api = models::api::Api {
+            url: host.to_owned(),
+            version: String::from(crate::parsers::api_parser::API_VERSION),
+            endpoint: String::new(),
+        };
         self.api = api;
     }
-
-    fn retrieve_url(&self) -> String {
-        let api = &self.api;
-        let mut buffer = api.url.clone();
-        let count = buffer.len();
-
-        if buffer.chars().nth(count - 1) != Some('/') {
-            buffer += "/";
-        }
-
-        let mut url: String = String::from(&buffer);
-        url += &String::from("api/");
-        url += &String::from(&api.version);
-        url += &String::from("/");
-        url += &String::from(&api.endpoint);
-
-        return url;
-    }
 }

src/utilities/checks.rs

@@ -1,32 +1,3 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Deserialize, Serialize)]
-pub struct Checks {}
-
-impl Checks {
-    pub fn _is_numeric(text: &String) -> bool {
-        text.parse::<f64>().is_ok()
-    }
-
-    pub fn _index_of_item_in_container<F>(container: &String, item: &char, func: F) -> i32
-    where
-        F: Fn(&char, &char) -> bool,
-    {
-        let mut index = -1;
-
-        for c in container.chars() {
-            if func(&c, item) {
-                index += 1;
-                break;
-            }
-
-            index += 1;
-        }
-
-        return index;
-    }
-}
-
 pub fn exit_program(code: i32) {
     std::process::exit(code);
 }

src/utilities/string.rs

@@ -1,9 +1,12 @@
 pub fn o_to_string(val: &std::ffi::OsString) -> Result<std::string::String, std::io::Error> {
     match val.clone().into_string() {
         Ok(value) => Ok(value),
-        Err(_) => Err(std::io::Error::new(
-            std::io::ErrorKind::Other,
-            String::from("Error"),
-        )),
+        Err(err) => match err.into_string() {
+            Ok(res) => Err(std::io::Error::other(res.to_string())),
+            Err(err) => match err.to_str() {
+                Some(err) => Err(std::io::Error::other(err)),
+                None => Err(std::io::Error::other("Undefined error")),
+            },
+        },
     }
 }

src/version.rs

@@ -0,0 +1,6 @@
+pub fn print_version() {
+    let name = env!("CARGO_PKG_NAME");
+    let version = env!("CARGO_PKG_VERSION");
+
+    println!("{name:?} {version:?}");
+}