feat(graphql): return remote track url

cargo-bazel-lock.json

@@ -1,5 +1,5 @@
 {
-  "checksum": "2996b43c92b533a3fbe28004e48e8315d16088515bf0fa7f798508d3560f36ea",
+  "checksum": "5a7e8bcc015de861e75a5e424861340d76395ab76e1fcac19f1dea3ee4976241",
   "crates": {
     "Inflector 0.11.4": {
       "name": "Inflector",

graphql/src/schema/devices.rs

@@ -82,12 +82,20 @@ impl DevicesMutation {
         let io_device = ctx.data::<Arc<TokioMutex<CurrentDevice>>>().unwrap();
         let mut io_device = io_device.lock().await;
 
+        let base_url = match devices.clone().into_iter().find(|device| {
+            device.id == id.to_string() && (device.service == "http" || device.app == "xbmc")
+        }) {
+            Some(device) => Some(format!("http://{}:{}", device.host, device.port)),
+            None => None,
+        };
+
         match devices.into_iter().find(|device| {
             device.id == id.to_string() && (device.service == "grpc" || device.app == "xbmc")
         }) {
             Some(device) => {
-                let current_device =
-                    types::Device::from(device.clone()).is_connected(Some(&device.clone()));
+                let current_device = types::Device::from(device.clone())
+                    .is_connected(Some(&device.clone()))
+                    .with_base_url(base_url);
                 connected_device
                     .lock()
                     .unwrap()

graphql/src/schema/library.rs

@@ -1,4 +1,4 @@
-use std::sync::Arc;
+use std::{collections::HashMap, sync::Arc, sync::Mutex as StdMutex};
 
 use async_graphql::{futures_util::FutureExt, *};
 use music_player_addons::CurrentDevice;
@@ -8,12 +8,11 @@ use music_player_storage::{
     repo::{album::AlbumRepository, artist::ArtistRepository, track::TrackRepository},
     Database,
 };
+use music_player_types::types;
 use sea_orm::{ActiveModelTrait, ActiveValue};
 use tokio::sync::Mutex;
 
-use super::{
-    objects::{album::Album, artist::Artist, search_result::SearchResult, track::Track},
-};
+use super::objects::{album::Album, artist::Artist, search_result::SearchResult, track::Track};
 
 #[derive(Default)]
 pub struct LibraryQuery;
@@ -26,15 +25,31 @@ impl LibraryQuery {
         offset: Option<i32>,
         limit: Option<i32>,
     ) -> Result<Vec<Track>, Error> {
+        let connected_device = ctx
+            .data::<Arc<StdMutex<HashMap<String, types::Device>>>>()
+            .unwrap();
         let current_device = ctx.data::<Arc<Mutex<CurrentDevice>>>().unwrap();
         let mut device = current_device.lock().await;
 
         if device.source.is_some() {
             let source = device.source.as_mut().unwrap();
-            let tracks = source
+            let result = source
                 .tracks(offset.unwrap_or(0), limit.unwrap_or(100))
                 .await?;
-            return Ok(tracks.into_iter().map(Into::into).collect());
+
+            let device = connected_device.lock().unwrap();
+            let device = device.get("current_device").unwrap();
+            let base_url = device.base_url.as_ref().unwrap();
+
+            let tracks: Vec<Track> = result.into_iter().map(Into::into).collect();
+
+            return Ok(tracks
+                .into_iter()
+                .map(|mut track| {
+                    track.uri = format!("{}/tracks/{}", base_url, track.id.to_string());
+                    track
+                })
+                .collect());
         }
 
         let db = ctx.data::<Arc<Mutex<Database>>>().unwrap();
@@ -78,6 +93,9 @@ impl LibraryQuery {
         offset: Option<i32>,
         limit: Option<i32>,
     ) -> Result<Vec<Album>, Error> {
+        let connected_device = ctx
+            .data::<Arc<StdMutex<HashMap<String, types::Device>>>>()
+            .unwrap();
         let current_device = ctx.data::<Arc<Mutex<CurrentDevice>>>().unwrap();
         let mut device = current_device.lock().await;
 
@@ -86,7 +104,23 @@ impl LibraryQuery {
             let albums = source
                 .albums(offset.unwrap_or(0), limit.unwrap_or(100))
                 .await?;
-            return Ok(albums.into_iter().map(Into::into).collect());
+
+            let device = connected_device.lock().unwrap();
+            let device = device.get("current_device").unwrap();
+            let base_url = device.base_url.as_ref().unwrap();
+
+            let result: Vec<Album> = albums.into_iter().map(Into::into).collect();
+
+            return Ok(result
+                .into_iter()
+                .map(|mut album| {
+                    album.cover = match album.cover {
+                        Some(cover) => Some(format!("{}/covers/{}", base_url, cover)),
+                        None => None,
+                    };
+                    album
+                })
+                .collect());
         }
 
         let db = ctx.data::<Arc<Mutex<Database>>>().unwrap();

types/src/types.rs

@@ -299,6 +299,14 @@ pub struct Device {
     pub service: String,
     pub app: String,
     pub is_connected: bool,
+    pub base_url: Option<String>,
+}
+
+impl Device {
+    pub fn with_base_url(&mut self, base_url: Option<String>) -> Self {
+        self.base_url = base_url;
+        self.clone()
+    }
 }
 
 impl From<ServiceInfo> for Device {
@@ -320,6 +328,7 @@ impl From<ServiceInfo> for Device {
                 service: srv.get_fullname().to_owned(),
                 app: "xbmc".to_owned(),
                 is_connected: false,
+                base_url: None,
             };
         }
 
@@ -347,6 +356,7 @@ impl From<ServiceInfo> for Device {
                 service: srv.get_fullname().split("-").collect::<Vec<&str>>()[0].to_owned(),
                 app: "music-player".to_owned(),
                 is_connected: false,
+                base_url: None,
             };
         }