Able to queue song

src/managers/commit_manager.rs

@@ -282,7 +282,7 @@ impl CommitManager {
         };
         tok_mgr.init();
 
-        let token = Runtime::new().unwrap().block_on(tok_mgr.request_token());
+        let token = tok_mgr.request_token().await;
 
         token.unwrap()
     }
@@ -376,10 +376,11 @@ impl CommitManager {
 
                             cover_art.data = cover_art.to_data().unwrap();
 
-                            let mut up = syncers::upload::Upload::default();
+                            // let mut up = syncers::upload::Upload::default();
-                            let host = self.ica_action.retrieve_flag_value(&String::from("-h"));
+                            // let host = self.ica_action.retrieve_flag_value(&String::from("-h"));
-                            up.set_api(&host);
+                            // up.set_api(&host);
 
+                            /*
                             let res = up.upload_song_with_metadata(&token, &s, &cover_art);
 
                             match Runtime::new().unwrap().block_on(res) {
@@ -392,6 +393,16 @@ impl CommitManager {
                                     Err(std::io::Error::other(er.to_string()))
                                 }
                             }
+                            */
+                            let res = self.queue_song(&token, &s).await;
+                            match res {
+                                Ok(val) => {
+                                    Ok(())
+                                },
+                                Err(err) => {
+                                    Err(err)
+                                }
+                            }
                         }
                         Err(err) => {
                             println!("Error: {err:?}");
@@ -408,6 +419,29 @@ impl CommitManager {
         }
     }
 
+    async fn queue_song(&self, token: &icarus_models::token::AccessToken, song: &icarus_models::song::Song) -> Result<()> {
+        let mut up = syncers::upload::Upload::default();
+        let host = self.ica_action.retrieve_flag_value(&String::from("-h"));
+        up.set_api(&host);
+
+        let mut queued_song_id = uuid::Uuid::nil();
+
+        println!("Queueing song");
+
+        match up.queue_song(token, song).await {
+            Ok(id) => {
+                queued_song_id = id;
+            }
+            Err(err) => {
+                eprintln!("Error: {err:?}");
+            }
+        }
+
+        println!("Queued song Id: {queued_song_id:?}");
+
+        Ok(())
+    }
+
     fn get_songs(
         &self,
         metadata_path: &String,

src/syncers/upload.rs

@@ -62,26 +62,40 @@ impl Upload {
     }
 
     pub async fn queue_song(&self, token: &icarus_models::token::AccessToken, song: &icarus_models::song::Song) -> Result<uuid::Uuid, reqwest::Error> {
-        let songpath = song.song_path().unwrap_or_default();
+        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);
+        println!("Song path: {songpath:?}");
+        println!("Token: {}", token.token);
 
-        let mut song_filename = String::from("audio");
+        // let mut song_filename = String::from("audio");
-        song_filename += icarus_models::constants::file_extensions::audio::DEFAULTMUSICEXTENSION;
+        // song_filename += icarus_models::constants::file_extensions::audio::DEFAULTMUSICEXTENSION;
 
         let form = reqwest::multipart::Form::new()
             .part(
                 "file",
-                reqwest::multipart::Part::bytes(std::fs::read(songpath).unwrap())
+                reqwest::multipart::Part::stream(file_body)
-                    .file_name(song_filename),
+                    .file_name(song.filename.clone()).mime_str("application/octet-stream").unwrap(),
             );
 
         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(&token.token.clone()).unwrap(),
+            HeaderValue::from_str(&token.bearer_token()).unwrap(),
         );
-        let client = reqwest::Client::builder().build().unwrap();
+        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::new();
+        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_song::Response>().await {
                 Ok(resp) => {