src/managers/commit_manager.rs

@@ -36,6 +36,13 @@ enum En {
     Other,
 }
 
+#[derive(Debug)]
+struct UploadSongMembers {
+    pub song: icarus_models::song::Song,
+    pub coverart: icarus_models::coverart::CoverArt,
+    pub token: icarus_models::token::AccessToken,
+}
+
 pub fn retrieve_song(
     album: &icarus_models::album::collection::Album,
     track: i32,
@@ -378,7 +385,13 @@ impl CommitManager {
 
                             cover_art.data = cover_art.to_data().unwrap();
 
-                            match self.queue_song(&token, &s).await {
+                            let members = UploadSongMembers {
+                                song: s,
+                                coverart: cover_art,
+                                token: token,
+                            };
+
+                            match self.upload_song_process(&members).await {
                                 Ok(_) => Ok(()),
                                 Err(err) => Err(err),
                             }
@@ -398,30 +411,34 @@ impl CommitManager {
         }
     }
 
-    async fn queue_song(
+    async fn upload_song_process(&self, data: &UploadSongMembers) -> Result<()> {
-        &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();
+        let token = &data.token;
+        let song = &data.song;
 
         println!("Queueing song");
 
-        match up.queue_song(token, song).await {
+        let queued_song_id = match up.queue_song(token, song).await {
-            Ok(id) => {
+            Ok(id) => id,
-                queued_song_id = id;
-            }
             Err(err) => {
-                eprintln!("Error: {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) => {
+                return Err(std::io::Error::other(err.to_string()));
+            }
+        }
+
         Ok(())
     }
 

src/syncers/common.rs

@@ -19,3 +19,12 @@ fn retrieve_url_with_id(api: &models::api::Api, id: &uuid::Uuid) -> String {
 
     url
 }
+
+pub async fn auth_header(
+    token: &icarus_models::token::AccessToken,
+) -> (http::HeaderName, http::HeaderValue) {
+    let auth = reqwest::header::AUTHORIZATION;
+    let auth_value = http::HeaderValue::from_str(&token.bearer_token()).unwrap();
+
+    (auth, auth_value)
+}

src/syncers/upload.rs

@@ -84,10 +84,8 @@ impl Upload {
         println!("Url: {url:?}");
 
         let mut headers = reqwest::header::HeaderMap::new();
-        headers.insert(
+        let (auth, auth_val) = syncers::common::auth_header(token).await;
-            reqwest::header::AUTHORIZATION,
+        headers.insert(auth, auth_val);
-            HeaderValue::from_str(&token.bearer_token()).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());
@@ -115,6 +113,37 @@ impl Upload {
         }
     }
 
+    pub async fn link_user_to_queued_song(
+        &self,
+        token: &icarus_models::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);
+
+        let mut headers = reqwest::header::HeaderMap::new();
+        let (auth, auth_val) = syncers::common::auth_header(token).await;
+        headers.insert(auth, auth_val);
+
+        let client = reqwest::Client::builder().build().unwrap();
+
+        let payload = serde_json::json!({
+            "song_queue_id": queued_song_id,
+            "user_id": token.user_id
+        });
+
+        match client
+            .patch(url)
+            .headers(headers)
+            .json(&payload)
+            .send()
+            .await
+        {
+            Ok(_) => Ok(()),
+            Err(err) => Err(err),
+        }
+    }
+
     fn init_form(
         &self,
         song: &icarus_models::song::Song,