.gitea/scripts/check-tag

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+if [ "$(echo $GITHUB_REF| cut -d'/' -f2)" != "tags" ]; then
+    echo "Not a tag"
+    exit 1;
+fi

.gitea/workflows/release.yml

@@ -15,6 +15,7 @@ jobs:
         target: ["armv7-unknown-linux-gnueabihf", "aarch64-unknown-linux-gnu", "x86_64-unknown-linux-gnu"]
     steps:
       - uses: actions/checkout@v3
+      - run: .gitea/scripts/check-tag
       - run: cargo fmt --check
       - uses: https://github.com/Swatinem/rust-cache@v2
         with:

cbd-tui/src/app/list.rs

@@ -1,6 +1,5 @@
 pub use ratatui::widgets::ListState;
 
-// FIXME: Move marking stuff here, to be able to use it in queue as well
 pub trait StatefulList {
     fn get_size(&self) -> usize;
     fn select(&mut self, idx: Option<usize>);

cbd-tui/src/config.rs

@@ -1,4 +1,9 @@
-use crabidy_core::{clap, clap_serde_derive, serde::Serialize, ClapSerde};
+use crabidy_core::{
+    clap::{self},
+    clap_serde_derive,
+    serde::Serialize,
+    ClapSerde,
+};
 
 #[derive(ClapSerde, Serialize, Debug)]
 #[clap(author, version, about)]

crabidy-server/src/lib.rs

@@ -16,11 +16,7 @@ pub struct QueueManager {
 impl From<QueueManager> for Queue {
     fn from(queue_manager: QueueManager) -> Self {
         Self {
-            timestamp: queue_manager
+            timestamp: queue_manager.created_at.elapsed().unwrap().as_secs(),
-                .created_at
-                .elapsed()
-                .expect("failed to get elapsed time")
-                .as_secs(),
             current_position: queue_manager.current_position() as u32,
             tracks: queue_manager.tracks,
         }
@@ -46,10 +42,6 @@ impl QueueManager {
         }
     }
 
-    pub fn is_last_track(&self) -> bool {
-        self.current_position() == self.tracks.len() - 1
-    }
-
     pub fn shuffle_on(&mut self) {
         self.shuffle = true;
         self.shuffle_before(self.current_offset);
@@ -58,8 +50,6 @@ impl QueueManager {
 
     pub fn shuffle_off(&mut self) {
         self.shuffle = false;
-        let pos = self.current_position();
-        self.current_offset = pos;
         self.play_order = (0..self.tracks.len()).collect();
     }
 
@@ -85,9 +75,6 @@ impl QueueManager {
 
     pub fn next_track(&mut self) -> Option<Track> {
         let len = self.tracks.len();
-        if len == 0 {
-            return None;
-        };
         if self.current_offset < len - 1 {
             self.current_offset += 1;
             let current_pos = self.current_position();
@@ -159,19 +146,36 @@ impl QueueManager {
         }
     }
 
-    pub fn append_tracks(&mut self, tracks: &[Track]) -> Option<Track> {
+    pub fn append_tracks(&mut self, tracks: &[Track]) {
         let len = self.tracks.len();
-        let is_empty = len == 0;
         let order_additions: Vec<usize> = (len..len + tracks.len()).collect();
         self.play_order.extend(order_additions);
         self.tracks.extend(tracks.iter().cloned());
         if self.shuffle {
             self.shuffle_behind(self.current_offset);
         }
-        if is_empty {
+    }
-            self.current_track()
+
-        } else {
+    pub fn queue_tracks(&mut self, tracks: &[Track]) {
-            None
+        let len = self.tracks.len();
+        if len == 0 {
+            self.replace_with_tracks(tracks);
+            return;
+        }
+        let pos = self.current_position();
+        let order_additions: Vec<usize> = (len..len + tracks.len()).collect();
+        self.play_order.extend(order_additions);
+        let tail: Vec<Track> = self
+            .tracks
+            .splice((self.current_position() + 1).., tracks.to_vec())
+            .collect();
+        self.tracks.extend(tail);
+        self.play_order
+            .iter_mut()
+            .filter(|i| (pos as usize) < **i)
+            .for_each(|i| *i += len);
+        if self.shuffle {
+            self.shuffle_behind(self.current_offset);
         }
     }
 
@@ -210,11 +214,8 @@ impl QueueManager {
         }
     }
 
-    pub fn insert_tracks(&mut self, position: u32, tracks: &[Track]) -> Option<Track> {
+    pub fn insert_tracks(&mut self, position: u32, tracks: &[Track]) {
         let len = self.tracks.len();
-        if len == 0 {
-            return self.replace_with_tracks(tracks);
-        }
         let order_additions: Vec<usize> = (len..len + tracks.len()).collect();
         self.play_order.extend(order_additions);
         let tail: Vec<Track> = self
@@ -222,43 +223,9 @@ impl QueueManager {
             .splice((position as usize + 1).., tracks.to_vec())
             .collect();
         self.tracks.extend(tail);
-        let mut changed: Vec<usize> = Vec::new();
-        // in shuffle mode, it might be that we played already postions which are behind
-        // the insertion point and which postions are shifted by the lenght of the inserted
-        // track
-        for i in self
-            .play_order
-            .iter_mut()
-            .take(self.current_offset)
-            .filter(|i| (position as usize) < **i)
-        {
-            *i += len;
-            changed.push(*i);
-        }
-        if !self.shuffle {
-            // if we don't shuffle, there should be no positions alredy played behind the
-            // current track
-            assert!(changed.is_empty());
-        }
-        // the newly inserted indices need to replaced with the ones that we already handled
-        self.play_order
-            .iter_mut()
-            .skip(self.current_offset)
-            .for_each(|i| {
-                if changed.contains(i) {
-                    *i -= len;
-                }
-            });
-
         if self.shuffle {
             self.shuffle_behind(self.current_offset);
         }
-        None
-    }
-
-    pub fn queue_tracks(&mut self, tracks: &[Track]) -> Option<Track> {
-        let pos = self.current_position();
-        self.insert_tracks(pos as u32, tracks)
     }
 
     pub fn clear(&mut self, exclude_current: bool) -> bool {

crabidy-server/src/main.rs

@@ -3,7 +3,7 @@ use crabidy_core::proto::crabidy::{
     crabidy_service_server::CrabidyServiceServer, InitResponse, LibraryNode, PlayState, Track,
 };
 use crabidy_core::{ProviderClient, ProviderError};
-use tracing::{debug_span, error, info, instrument, level_filters, warn, Span};
+use tracing::{debug_span, info, instrument, warn, Span};
 use tracing_subscriber::{filter::Targets, prelude::*};
 
 mod playback;
@@ -22,9 +22,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     }
     let (non_blocking, _guard) = tracing_appender::non_blocking(std::io::stderr());
 
-    let targets_filter = Targets::new()
+    let targets_filter =
-        .with_target("crabidy_server", tracing::level_filters::LevelFilter::DEBUG)
+        Targets::new().with_target("crabidy_server", tracing::level_filters::LevelFilter::DEBUG);
-        .with_target("tidaldy", level_filters::LevelFilter::DEBUG);
     let subscriber = tracing_subscriber::fmt::layer()
         .with_writer(non_blocking)
         .with_file(true)
@@ -40,9 +39,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     info!("audio player started initialized");
 
     let (update_tx, _) = tokio::sync::broadcast::channel(2048);
-    let orchestrator = ProviderOrchestrator::init("")
+    let orchestrator = ProviderOrchestrator::init("").await.unwrap();
-        .await
-        .expect("failed to init orchestrator");
 
     let playback = Playback::new(update_tx.clone(), orchestrator.provider_tx.clone());
 
@@ -79,51 +76,44 @@ fn poll_play_bus(rx: flume::Receiver<PlayerMessage>, tx: flume::Sender<PlaybackM
         let span = debug_span!("play-chan");
         match msg {
             PlayerMessage::EndOfStream => {
-                if let Err(err) = tx.send(PlaybackMessage::Next { span }) {
+                tx.send(PlaybackMessage::Next { span }).unwrap();
-                    error!("failed to send next message: {}", err);
-                }
             }
             PlayerMessage::Stopped => {
-                if let Err(err) = tx.send(PlaybackMessage::StateChanged {
+                tx.send(PlaybackMessage::StateChanged {
                     state: PlayState::Stopped,
                     span,
-                }) {
+                })
-                    error!("failed to send stopped message: {}", err);
+                .unwrap();
-                }
             }
             PlayerMessage::Paused => {
-                if let Err(err) = tx.send(PlaybackMessage::StateChanged {
+                tx.send(PlaybackMessage::StateChanged {
                     state: PlayState::Paused,
                     span,
-                }) {
+                })
-                    error!("failed to send paused message: {}", err);
+                .unwrap();
-                }
             }
             PlayerMessage::Playing => {
-                if let Err(err) = tx.send(PlaybackMessage::StateChanged {
+                tx.send(PlaybackMessage::StateChanged {
                     state: PlayState::Playing,
                     span,
-                }) {
+                })
-                    error!("failed to send playing message: {}", err);
+                .unwrap();
-                }
             }
             PlayerMessage::Elapsed { duration, elapsed } => {
-                if let Err(err) = tx.send(PlaybackMessage::PostitionChanged {
+                tx.send(PlaybackMessage::PostitionChanged {
                     duration: duration.as_millis() as u32,
                     position: elapsed.as_millis() as u32,
                     span,
-                }) {
+                })
-                    error!("failed to send elapsed message: {}", err);
+                .unwrap();
-                }
             }
             PlayerMessage::Duration { duration } => {
-                if let Err(err) = tx.send(PlaybackMessage::PostitionChanged {
+                tx.send(PlaybackMessage::PostitionChanged {
                     duration: duration.as_millis() as u32,
                     position: 0,
                     span,
-                }) {
+                })
-                    error!("failed to send duration message: {}", err);
+                .unwrap();
-                }
             }
         }
     }

crabidy-server/src/playback.rs

@@ -51,10 +51,7 @@ impl Playback {
                         let repeat;
                         let shuffle;
                         let response = {
-                            let Ok(queue) = self.queue.lock() else {
+                            let queue = self.queue.lock().unwrap();
-                                error!("failed to get queue lock");
-                                continue;
-                            };
                             debug!("got queue lock");
                             repeat = queue.repeat;
                             shuffle = queue.shuffle;
@@ -72,11 +69,13 @@ impl Playback {
                             trace!("position {:?}", position);
                             let play_state = {
                                 debug!("getting play state lock");
-                                let Ok(play_state) = self.state.lock() else {
+                                match *self.state.lock().unwrap() {
-                                    error!("failed to get play state lock");
+                                    PlayState::Playing => PlayState::Playing,
-                                    continue;
+                                    PlayState::Paused => PlayState::Paused,
-                                };
+                                    PlayState::Stopped => PlayState::Stopped,
-                                *play_state
+                                    PlayState::Loading => PlayState::Loading,
+                                    _ => PlayState::Unspecified,
+                                }
                             };
                             trace!("play_state {:?}", play_state);
                             debug!("released play state lock");
@@ -91,9 +90,7 @@ impl Playback {
                             }
                         };
                         trace!("response {:?}", response);
-                        if let Err(err) = result_tx.send(response) {
+                        result_tx.send(response).unwrap();
-                            error!("failed to send response: {:#?}", err);
-                        }
                     }
                     PlaybackMessage::Replace { uuids, span } => {
                         let _e = span.enter();
@@ -111,17 +108,12 @@ impl Playback {
                         }
                         trace!("got tracks {:?}", all_tracks);
                         let current = {
-                            let Ok(mut queue) = self.queue.lock() else {
+                            let mut queue = self.queue.lock().unwrap();
-                                debug!("got queue lock");
-                                continue;
-                            };
                             debug!("got queue lock");
                             queue.replace_with_tracks(&all_tracks);
                             let queue_update_tx = self.update_tx.clone();
                             let update = StreamUpdate::Queue(queue.clone().into());
-                            if let Err(err) = queue_update_tx.send(update) {
+                            queue_update_tx.send(update).unwrap();
-                                trace!("{:?}", err)
-                            };
                             queue.current_track()
                         };
                         debug!("got current {:?}", current);
@@ -143,22 +135,17 @@ impl Playback {
                             }
                         }
                         trace!("got tracks {:?}", all_tracks);
-                        let track = {
+                        {
-                            let Ok(mut queue) = self.queue.lock() else {
+                            let mut queue = self.queue.lock().unwrap();
-                                debug!("got queue lock");
-                                continue;
-                            };
                             debug!("got queue lock");
-                            let track = queue.queue_tracks(&all_tracks);
+                            queue.queue_tracks(&all_tracks);
                             let queue_update_tx = self.update_tx.clone();
                             let update = StreamUpdate::Queue(queue.clone().into());
                             if let Err(err) = queue_update_tx.send(update) {
-                                trace!("{:?}", err)
+                                error!("{:?}", err)
                             }
-                            track
+                        }
-                        };
                         debug!("que lock released");
-                        self.play(track).in_current_span().await;
                     }
 
                     PlaybackMessage::Append { uuids, span } => {
@@ -176,59 +163,35 @@ impl Playback {
                             }
                         }
                         trace!("got tracks {:?}", all_tracks);
-                        let track = {
+                        {
-                            let Ok(mut queue) = self.queue.lock() else {
+                            let mut queue = self.queue.lock().unwrap();
-                                debug!("got queue lock");
-                                continue;
-                            };
                             debug!("got queue lock");
-                            let track = queue.append_tracks(&all_tracks);
+                            queue.append_tracks(&all_tracks);
                             let queue_update_tx = self.update_tx.clone();
                             let update = StreamUpdate::Queue(queue.clone().into());
                             if let Err(err) = queue_update_tx.send(update) {
-                                trace!("{:?}", err)
+                                error!("{:?}", err)
                             }
-                            track
+                        }
-                        };
                         debug!("queue lock released");
-                        self.play(track).in_current_span().await;
                     }
 
                     PlaybackMessage::Remove { positions, span } => {
                         let _e = span.enter();
-                        let is_last;
                         debug!("removing");
                         let track = {
-                            let Ok(mut queue) = self.queue.lock() else {
+                            let mut queue = self.queue.lock().unwrap();
-                                debug!("got queue lock");
-                                continue;
-                            };
                             debug!("got queue lock");
-                            is_last = queue.is_last_track();
                             let track = queue.remove_tracks(&positions);
                             let queue_update_tx = self.update_tx.clone();
                             let update = StreamUpdate::Queue(queue.clone().into());
-                            if let Err(err) = queue_update_tx.send(update) {
+                            queue_update_tx.send(update).unwrap();
-                                trace!("{:?}", err)
-                            };
                             track
                         };
                         debug!("queue lock released");
-                        let state = {
+                        let state = *self.state.lock().unwrap();
-                            let Ok(state) = self.state.lock() else {
-                            error!("failed to get play state lock");
-                            continue;
-                        };
-                            *state
-                        };
                         if state == PlayState::Playing {
-                            if is_last {
+                            self.play(track).in_current_span().await;
-                                if let Err(err) = self.player.stop().in_current_span().await {
-                                    error!("{:?}", err)
-                                }
-                            } else {
-                                self.play(track).in_current_span().await;
-                            }
                         }
                     }
 
@@ -251,22 +214,15 @@ impl Playback {
                             }
                         }
                         trace!("got tracks {:?}", all_tracks);
-                        let track = {
+                        {
-                            let Ok(mut queue) = self.queue.lock() else {
+                            let mut queue = self.queue.lock().unwrap();
-                                debug!("got queue lock");
-                                continue;
-                            };
                             debug!("got queue lock");
-                            let track = queue.insert_tracks(position, &all_tracks);
+                            queue.insert_tracks(position, &all_tracks);
                             let queue_update_tx = self.update_tx.clone();
                             let update = StreamUpdate::Queue(queue.clone().into());
-                            if let Err(err) = queue_update_tx.send(update) {
+                            queue_update_tx.send(update).unwrap();
-                                trace!("{:?}", err)
+                        }
-                            };
-                            track
-                        };
                         debug!("queue lock released");
-                        self.play(track).in_current_span().await;
                     }
 
                     PlaybackMessage::Clear {
@@ -276,24 +232,17 @@ impl Playback {
                         let _e = span.enter();
                         debug!("clearing");
                         let should_stop = {
-                            let Ok(mut queue) = self.queue.lock() else {
+                            let mut queue = self.queue.lock().unwrap();
-                                debug!("got queue lock");
-                                continue;
-                            };
                             debug!("got queue lock");
                             let should_stop = queue.clear(exclude_current);
                             let queue_update_tx = self.update_tx.clone();
                             let update = StreamUpdate::Queue(queue.clone().into());
-                            if let Err(err) = queue_update_tx.send(update) {
+                            queue_update_tx.send(update).unwrap();
-                                trace!("{:?}", err)
-                            };
                             should_stop
                         };
                         debug!("queue lock released");
                         if should_stop {
-                            if let Err(err) = self.player.stop().in_current_span().await {
+                            self.player.stop().in_current_span().await;
-                                error!("{:?}", err)
-                            }
                         }
                     }
 
@@ -304,10 +253,7 @@ impl Playback {
                         let _e = span.enter();
                         debug!("setting current");
                         let track = {
-                            let Ok(mut queue) = self.queue.lock() else {
+                            let mut queue = self.queue.lock().unwrap();
-                                debug!("got queue lock");
-                                continue;
-                            };
                             debug!("got queue lock");
                             queue.set_current_position(queue_position);
                             queue.current_track()
@@ -322,10 +268,7 @@ impl Playback {
                         let shuffle;
                         let repeat;
                         {
-                            let Ok(mut queue) = self.queue.lock() else {
+                            let mut queue = self.queue.lock().unwrap();
-                                debug!("got queue lock");
-                                continue;
-                            };
                             debug!("got queue lock");
                             repeat = queue.repeat;
                             if queue.shuffle {
@@ -339,7 +282,7 @@ impl Playback {
                         let queue_update_tx = self.update_tx.clone();
                         let update = StreamUpdate::Mods(QueueModifiers { shuffle, repeat });
                         if let Err(err) = queue_update_tx.send(update) {
-                            trace!("{:?}", err)
+                            error!("{:?}", err)
                         }
                     }
 
@@ -349,10 +292,7 @@ impl Playback {
                         let shuffle;
                         let repeat;
                         {
-                            let Ok(mut queue) = self.queue.lock() else {
+                            let mut queue = self.queue.lock().unwrap();
-                                debug!("got queue lock");
-                                continue;
-                            };
                             debug!("got queue lock");
                             shuffle = queue.shuffle;
                             if queue.repeat {
@@ -366,7 +306,7 @@ impl Playback {
                         let queue_update_tx = self.update_tx.clone();
                         let update = StreamUpdate::Mods(QueueModifiers { shuffle, repeat });
                         if let Err(err) = queue_update_tx.send(update) {
-                            trace!("{:?}", err)
+                            error!("{:?}", err)
                         }
                     }
 
@@ -374,13 +314,7 @@ impl Playback {
                         let _e = span.enter();
                         debug!("toggling play");
                         {
-                            let state = {
+                            let state = *self.state.lock().unwrap();
-                                let Ok(state) = self.state.lock() else {
-                                debug!("got state lock");
-                                continue;
-                            };
-                                *state
-                            };
                             debug!("got state lock");
                             if state == PlayState::Playing {
                                 if let Err(err) = self.player.pause().await {
@@ -424,10 +358,7 @@ impl Playback {
                         let _e = span.enter();
                         debug!("nexting");
                         let track = {
-                            let Ok(mut queue) = self.queue.lock() else {
+                            let mut queue = self.queue.lock().unwrap();
-                                debug!("got queue lock");
-                                continue;
-                            };
                             debug!("got queue lock");
                             queue.next_track()
                         };
@@ -440,10 +371,7 @@ impl Playback {
                         let _e = span.enter();
                         debug!("preving");
                         let track = {
-                            let Ok(mut queue) = self.queue.lock() else {
+                            let mut queue = self.queue.lock().unwrap();
-                                debug!("got queue lock");
-                                continue;
-                            };
                             debug!("got queue lock");
                             queue.prev_track()
                         };
@@ -456,18 +384,14 @@ impl Playback {
                         debug!("state changed");
 
                         let play_state = {
-                            let Ok(mut state_lock) = self.state.lock() else {
+                            *self.state.lock().unwrap() = state;
-                                debug!("got state lock");
-                                continue;
-                            };
-                            *state_lock = state;
                             state
                         };
                         debug!("released state lock and got play state {:?}", play_state);
                         let active_track_tx = self.update_tx.clone();
                         let update = StreamUpdate::PlayState(play_state as i32);
                         if let Err(err) = active_track_tx.send(update) {
-                            trace!("{:?}", err)
+                            error!("{:?}", err)
                         };
                     }
 
@@ -485,7 +409,7 @@ impl Playback {
                         let update_tx = self.update_tx.clone();
                         let update = StreamUpdate::Volume(volume);
                         if let Err(err) = update_tx.send(update) {
-                            trace!("{:?}", err)
+                            error!("{:?}", err)
                         }
                     }
 
@@ -495,7 +419,7 @@ impl Playback {
                         let update_tx = self.update_tx.clone();
                         let update = StreamUpdate::Mute(muted);
                         if let Err(err) = update_tx.send(update) {
-                            trace!("{:?}", err)
+                            error!("{:?}", err)
                         }
                     }
 
@@ -509,7 +433,7 @@ impl Playback {
                         let update_tx = self.update_tx.clone();
                         let update = StreamUpdate::Position(TrackPosition { duration, position });
                         if let Err(err) = update_tx.send(update) {
-                            trace!("{:?}", err)
+                            error!("{:?}", err)
                         }
                     }
                 }
@@ -519,7 +443,6 @@ impl Playback {
 
     #[instrument(skip(self))]
     async fn flatten_node(&self, uuid: &str) -> Vec<Track> {
-        debug!("flattening node");
         let tx = self.provider_tx.clone();
         let (result_tx, result_rx) = flume::bounded(1);
         let span = debug_span!("prov-chan");
@@ -562,7 +485,6 @@ impl Playback {
 
     #[instrument(skip(self))]
     async fn get_urls_for_track(&self, uuid: &str) -> Result<Vec<String>, ProviderError> {
-        debug!("getting urls for track");
         let tx = self.provider_tx.clone();
         let (result_tx, result_rx) = flume::bounded(1);
         let span = tracing::trace_span!("prov-chan");
@@ -583,7 +505,6 @@ impl Playback {
 
     #[instrument(skip(self))]
     async fn play_or_stop(&self, track: Option<Track>) {
-        debug!("play or stop");
         if let Some(track) = track {
             let mut uuid = track.uuid.clone();
             let urls = loop {
@@ -592,10 +513,7 @@ impl Playback {
                     Err(err) => {
                         warn!("no urls found for track {:?}: {}", track.uuid, err);
                         uuid = {
-                            let Ok(mut queue) = self.queue.lock() else {
+                            let mut queue = self.queue.lock().unwrap();
-                                debug!("got queue lock");
-                                continue;
-                            };
                             if let Some(track) = queue.next_track() {
                                 track.uuid.clone()
                             } else {
@@ -606,10 +524,7 @@ impl Playback {
                 }
             };
             {
-                let Ok(queue) = self.queue.lock() else {
+                let queue = self.queue.lock().unwrap();
-                    error!("poisend queue lock");
-                    return
-                };
                 let queue_update_tx = self.update_tx.clone();
                 let track = queue.current_track();
                 let update = StreamUpdate::QueueTrack(QueueTrack {
@@ -617,7 +532,7 @@ impl Playback {
                     track,
                 });
                 if let Err(err) = queue_update_tx.send(update) {
-                    trace!("{:?}", err)
+                    error!("{:?}", err)
                 }
             }
             if let Err(err) = self.player.play(&urls[0]).await {
@@ -630,7 +545,6 @@ impl Playback {
 
     #[instrument(skip(self))]
     async fn play(&self, track: Option<Track>) {
-        debug!("play");
         if let Some(track) = track {
             let mut uuid = track.uuid.clone();
             let urls = loop {
@@ -639,10 +553,7 @@ impl Playback {
                     Err(err) => {
                         warn!("no urls found for track {:?}: {}", track.uuid, err);
                         uuid = {
-                            let Ok(mut queue) = self.queue.lock() else {
+                            let mut queue = self.queue.lock().unwrap();
-                                debug!("poisend queue lock");
-                                return;
-                            };
                             if let Some(track) = queue.next_track() {
                                 track.uuid.clone()
                             } else {
@@ -653,10 +564,7 @@ impl Playback {
                 }
             };
             {
-                let Ok(queue) = self.queue.lock() else {
+                let queue = self.queue.lock().unwrap();
-                    error!("poisend queue lock");
-                    return
-                };
                 let queue_update_tx = self.update_tx.clone();
                 let track = queue.current_track();
                 let update = StreamUpdate::QueueTrack(QueueTrack {
@@ -664,7 +572,7 @@ impl Playback {
                     track,
                 });
                 if let Err(err) = queue_update_tx.send(update) {
-                    trace!("{:?}", err)
+                    error!("{:?}", err)
                 }
             }
             if let Err(err) = self.player.play(&urls[0]).await {

crabidy-server/src/provider.rs

@@ -28,9 +28,11 @@ impl ProviderOrchestrator {
                     } => {
                         let _e = span.enter();
                         let result = self.get_lib_node(&uuid).in_current_span().await;
-                        if let Err(err) = result_tx.send_async(result).in_current_span().await {
+                        result_tx
-                            error!("failed to send result: {}", err);
+                            .send_async(result)
-                        }
+                            .in_current_span()
+                            .await
+                            .unwrap();
                     }
                     ProviderMessage::GetTrack {
                         uuid,
@@ -39,9 +41,11 @@ impl ProviderOrchestrator {
                     } => {
                         let _e = span.enter();
                         let result = self.get_metadata_for_track(&uuid).in_current_span().await;
-                        if let Err(err) = result_tx.send_async(result).in_current_span().await {
+                        result_tx
-                            error!("failed to send result: {}", err);
+                            .send_async(result)
-                        }
+                            .in_current_span()
+                            .await
+                            .unwrap();
                     }
                     ProviderMessage::GetTrackUrls {
                         uuid,
@@ -50,9 +54,11 @@ impl ProviderOrchestrator {
                     } => {
                         let _e = span.enter();
                         let result = self.get_urls_for_track(&uuid).in_current_span().await;
-                        if let Err(err) = result_tx.send_async(result).in_current_span().await {
+                        result_tx
-                            error!("failed to send result: {}", err);
+                            .send_async(result)
-                        }
+                            .in_current_span()
+                            .await
+                            .unwrap();
                     }
                     ProviderMessage::FlattenNode {
                         uuid,
@@ -61,9 +67,11 @@ impl ProviderOrchestrator {
                     } => {
                         let _e = span.enter();
                         let result = self.flatten_node(&uuid).in_current_span().await;
-                        if let Err(err) = result_tx.send_async(result).in_current_span().await {
+                        result_tx
-                            error!("failed to send result: {}", err);
+                            .send_async(result)
-                        }
+                            .in_current_span()
+                            .await
+                            .unwrap();
                     }
                 }
             }
@@ -110,7 +118,7 @@ impl ProviderClient for ProviderOrchestrator {
             tidaldy::Client::init(&raw_toml_settings)
                 .in_current_span()
                 .await
-                .expect("Failed to init Tidal clienta"),
+                .unwrap(),
         );
         let new_toml_config = tidal_client.settings();
         if let Err(err) = tokio::fs::write(&config_file, new_toml_config)
@@ -132,7 +140,6 @@ impl ProviderClient for ProviderOrchestrator {
     }
     #[instrument(skip(self))]
     async fn get_urls_for_track(&self, track_uuid: &str) -> Result<Vec<String>, ProviderError> {
-        debug!("get_urls_for_track");
         self.tidal_client
             .get_urls_for_track(track_uuid)
             .in_current_span()
@@ -148,7 +155,6 @@ impl ProviderClient for ProviderOrchestrator {
     }
     #[instrument(skip(self))]
     fn get_lib_root(&self) -> LibraryNode {
-        debug!("get_lib_root in provider manager");
         let mut root_node = LibraryNode::new();
         let child = LibraryNodeChild::new("node:tidal".to_owned(), "tidal".to_owned(), false);
         root_node.children.push(child);
@@ -156,16 +162,13 @@ impl ProviderClient for ProviderOrchestrator {
     }
     #[instrument(skip(self))]
     async fn get_lib_node(&self, uuid: &str) -> Result<LibraryNode, ProviderError> {
-        debug!("get_lib_node in provider manager");
+        debug!("get_lib_node");
         if uuid == "node:/" {
-            debug!("get global root");
             return Ok(self.get_lib_root());
         }
         if uuid == "node:tidal" {
-            debug!("get tidal root");
             return Ok(self.tidal_client.get_lib_root());
         }
-        debug!("tidal node");
         self.tidal_client.get_lib_node(uuid).in_current_span().await
     }
 }

crabidy-server/src/rpc.rs

@@ -91,16 +91,10 @@ impl CrabidyService for RpcService {
             .recv_async()
             .in_current_span()
             .await
-            .map_err(|e| {
+            .map_err(|_| Status::internal("Failed to receive response from provider channel"))?;
-                error!("{:?}", e);
-                Status::internal("Failed to receive response from provider channel")
-            })?;
         match result {
             Ok(node) => Ok(Response::new(GetLibraryNodeResponse { node: Some(node) })),
-            Err(err) => {
+            Err(err) => Err(Status::internal(err.to_string())),
-                error!("{:?}", err);
-                Err(Status::internal(err.to_string()))
-            }
         }
     }
 
@@ -256,13 +250,11 @@ impl CrabidyService for RpcService {
         debug!("Received toggle_shuffle request");
         let playback_tx = self.playback_tx.clone();
         let span = debug_span!("play-chan");
-        if let Err(err) = playback_tx
+        playback_tx
             .send_async(PlaybackMessage::ToggleShuffle { span })
             .in_current_span()
             .await
-        {
+            .unwrap();
-            error!("Failed to send request via channel: {}", err);
-        }
         let reply = ToggleShuffleResponse {};
         Ok(Response::new(reply))
     }
@@ -275,13 +267,11 @@ impl CrabidyService for RpcService {
         debug!("Received toggle_repeat request");
         let playback_tx = self.playback_tx.clone();
         let span = debug_span!("play-chan");
-        if let Err(err) = playback_tx
+        playback_tx
             .send_async(PlaybackMessage::ToggleRepeat { span })
             .in_current_span()
             .await
-        {
+            .unwrap();
-            error!("Failed to send request via channel: {}", err);
-        }
         let reply = ToggleRepeatResponse {};
         Ok(Response::new(reply))
     }
@@ -330,13 +320,11 @@ impl CrabidyService for RpcService {
         debug!("Received toggle_play request");
         let playback_tx = self.playback_tx.clone();
         let span = debug_span!("play-chan");
-        if let Err(err) = playback_tx
+        playback_tx
             .send_async(PlaybackMessage::TogglePlay { span })
             .in_current_span()
             .await
-        {
+            .unwrap();
-            error!("Failed to send request via channel: {}", err);
-        }
         let reply = TogglePlayResponse {};
         Ok(Response::new(reply))
     }
@@ -349,13 +337,11 @@ impl CrabidyService for RpcService {
         debug!("Received stop request");
         let playback_tx = self.playback_tx.clone();
         let span = debug_span!("play-chan");
-        if let Err(err) = playback_tx
+        playback_tx
             .send_async(PlaybackMessage::Stop { span })
             .in_current_span()
             .await
-        {
+            .unwrap();
-            error!("Failed to send request via channel: {}", err);
-        }
         let reply = StopResponse {};
         Ok(Response::new(reply))
     }
@@ -370,13 +356,11 @@ impl CrabidyService for RpcService {
         debug!("Received change_volume request");
         let playback_tx = self.playback_tx.clone();
         let span = debug_span!("play-chan");
-        if let Err(err) = playback_tx
+        playback_tx
             .send_async(PlaybackMessage::ChangeVolume { delta, span })
             .in_current_span()
             .await
-        {
+            .unwrap();
-            error!("Failed to send request via channel: {}", err);
-        }
         let reply = ChangeVolumeResponse {};
         Ok(Response::new(reply))
     }
@@ -389,13 +373,11 @@ impl CrabidyService for RpcService {
         debug!("Received toggle_mute request");
         let playback_tx = self.playback_tx.clone();
         let span = debug_span!("play-chan");
-        if let Err(err) = playback_tx
+        playback_tx
             .send_async(PlaybackMessage::ToggleMute { span })
             .in_current_span()
             .await
-        {
+            .unwrap();
-            error!("Failed to send request via channel: {}", err);
-        }
         let reply = ToggleMuteResponse {};
         Ok(Response::new(reply))
     }
@@ -408,13 +390,11 @@ impl CrabidyService for RpcService {
         debug!("Received next request");
         let playback_tx = self.playback_tx.clone();
         let span = debug_span!("play-chan");
-        if let Err(err) = playback_tx
+        playback_tx
             .send_async(PlaybackMessage::Next { span })
             .in_current_span()
             .await
-        {
+            .unwrap();
-            error!("Failed to send request via channel: {}", err);
-        }
         let reply = NextResponse {};
         Ok(Response::new(reply))
     }
@@ -427,13 +407,11 @@ impl CrabidyService for RpcService {
         debug!("Received prev request");
         let playback_tx = self.playback_tx.clone();
         let span = debug_span!("play-chan");
-        if let Err(err) = playback_tx
+        playback_tx
             .send_async(PlaybackMessage::Prev { span })
             .in_current_span()
             .await
-        {
+            .unwrap();
-            error!("Failed to send request via channel: {}", err);
-        }
         let reply = PrevResponse {};
         Ok(Response::new(reply))
     }
@@ -446,13 +424,11 @@ impl CrabidyService for RpcService {
         debug!("Received restart_track request");
         let playback_tx = self.playback_tx.clone();
         let span = debug_span!("play-chan");
-        if let Err(err) = playback_tx
+        playback_tx
             .send_async(PlaybackMessage::RestartTrack { span })
             .in_current_span()
             .await
-        {
+            .unwrap();
-            error!("Failed to send request via channel: {}", err);
-        }
         let reply = RestartTrackResponse {};
         Ok(Response::new(reply))
     }

tidaldy/src/lib.rs

@@ -1,11 +1,9 @@
-use std::fmt::format;
-
 /// Lots of stuff and especially the auth handling is shamelessly copied from
 /// https://github.com/MinisculeGirraffe/tdl
 use reqwest::Client as HttpClient;
 use serde::de::DeserializeOwned;
 use tokio::time::{sleep, Duration, Instant};
-use tracing::{debug, error, info, instrument};
+use tracing::{debug, instrument};
 pub mod config;
 pub mod models;
 use async_trait::async_trait;
@@ -77,20 +75,13 @@ impl crabidy_core::ProviderClient for Client {
 
     #[instrument(skip(self))]
     fn get_lib_root(&self) -> crabidy_core::proto::crabidy::LibraryNode {
-        debug!("get_lib_root in tidaldy");
+        debug!("get_lib_root");
         let global_root = crabidy_core::proto::crabidy::LibraryNode::new();
-        let children = vec![
+        let children = vec![crabidy_core::proto::crabidy::LibraryNodeChild::new(
-            crabidy_core::proto::crabidy::LibraryNodeChild::new(
+            "node:userplaylists".to_string(),
-                "node:userplaylists".to_string(),
+            "playlists".to_string(),
-                "playlists".to_string(),
+            false,
-                false,
+        )];
-            ),
-            crabidy_core::proto::crabidy::LibraryNodeChild::new(
-                "node:userartists".to_string(),
-                "artists".to_string(),
-                false,
-            ),
-        ];
         crabidy_core::proto::crabidy::LibraryNode {
             uuid: "node:tidal".to_string(),
             title: "tidal".to_string(),
@@ -109,9 +100,8 @@ impl crabidy_core::ProviderClient for Client {
         let Some(user_id) = self.settings.login.user_id.clone() else {
           return Err(crabidy_core::ProviderError::UnknownUser)
     };
-        debug!("get_lib_node in tidaldy{}", uuid);
+        debug!("get_lib_node {}", uuid);
         let (_kind, module, uuid) = split_uuid(uuid);
-        error!("module:{},uuid: {}", module, uuid);
         let node = match module.as_str() {
             "userplaylists" => {
                 let mut node = crabidy_core::proto::crabidy::LibraryNode {
@@ -148,53 +138,6 @@ impl crabidy_core::ProviderClient for Client {
                 node.parent = Some("node:userplaylists".to_string());
                 node
             }
-            "userartists" => {
-                let mut node = crabidy_core::proto::crabidy::LibraryNode {
-                    uuid: "node:userartists".to_string(),
-                    title: "artists".to_string(),
-                    parent: Some("node:tidal".to_string()),
-                    tracks: Vec::new(),
-                    children: Vec::new(),
-                    is_queable: false,
-                };
-                for artist in self.get_users_artists(&user_id).await? {
-                    let child = crabidy_core::proto::crabidy::LibraryNodeChild::new(
-                        format!("node:artist:{}", artist.item.id),
-                        artist.item.name,
-                        true,
-                    );
-                    node.children.push(child);
-                }
-                node
-            }
-            "artist" => {
-                info!("artist");
-                let mut node: crabidy_core::proto::crabidy::LibraryNode =
-                    self.get_artist(&uuid).await?.into();
-                let children: Vec<crabidy_core::proto::crabidy::LibraryNodeChild> = self
-                    .get_artist_albums(&uuid)
-                    .await?
-                    .iter()
-                    .map(|t| t.into())
-                    .collect();
-                node.children = children;
-                node.parent = Some("node:userartists".to_string());
-                node
-            }
-            "album" => {
-                let album = self.get_album(&uuid).await?;
-                let artis_id = album.artist.clone().unwrap().id;
-                let mut node: crabidy_core::proto::crabidy::LibraryNode = album.into();
-                let tracks: Vec<crabidy_core::proto::crabidy::Track> = self
-                    .get_album_tracks(&uuid)
-                    .await?
-                    .iter()
-                    .map(|t| t.into())
-                    .collect();
-                node.tracks = tracks;
-                node.parent = Some(format!("node:artist:{}", artis_id));
-                node
-            }
             _ => return Err(crabidy_core::ProviderError::MalformedUuid),
         };
         Ok(node)
@@ -223,18 +166,17 @@ impl Client {
         })
     }
 
-    #[instrument(skip(self))]
+    #[instrument]
     pub fn get_user_id(&self) -> Option<String> {
         self.settings.login.user_id.clone()
     }
 
-    #[instrument(skip(self))]
+    #[instrument]
     pub async fn make_request<T: DeserializeOwned>(
         &self,
         uri: &str,
         query: Option<&[(&str, String)]>,
     ) -> Result<T, ClientError> {
-        debug!("make_request {}", uri);
         let Some(ref access_token) = self.settings.login.access_token.clone() else {
             return Err(ClientError::AuthError(
                 "No access token found".to_string(),
@@ -257,27 +199,18 @@ impl Client {
             .bearer_auth(access_token)
             .query(&params)
             .send()
-            .await
+            .await?
-            .map_err(|e| {
-                error!("{:?}", e);
-                e
-            })?
             .json()
-            .await
+            .await?;
-            .map_err(|e| {
-                error!("{:?}", e);
-                e
-            })?;
         Ok(response)
     }
 
-    #[instrument(skip(self))]
+    #[instrument]
     pub async fn make_paginated_request<T: DeserializeOwned>(
         &self,
         uri: &str,
         query: Option<&[(&str, String)]>,
     ) -> Result<Vec<T>, ClientError> {
-        debug!("make_paginated_request {}", uri);
         let Some(ref access_token) = self.settings.login.access_token.clone() else {
             return Err(ClientError::AuthError(
                 "No access token found".to_string(),
@@ -303,17 +236,9 @@ impl Client {
             .bearer_auth(access_token)
             .query(&params)
             .send()
-            .await
+            .await?
-            .map_err(|e| {
-                error!("{:?}", e);
-                e
-            })?
             .json()
-            .await
+            .await?;
-            .map_err(|e| {
-                error!("{:?}", e);
-                e
-            })?;
         let mut items = Vec::with_capacity(response.total_number_of_items);
         items.extend(response.items);
         while response.offset + limit < response.total_number_of_items {
@@ -330,23 +255,15 @@ impl Client {
                 .bearer_auth(access_token)
                 .query(&params)
                 .send()
-                .await
+                .await?
-                .map_err(|e| {
-                    error!("{:?}", e);
-                    e
-                })?
                 .json()
-                .await
+                .await?;
-                .map_err(|e| {
-                    error!("{:?}", e);
-                    e
-                })?;
             items.extend(response.items);
         }
         Ok(items)
     }
 
-    #[instrument(skip(self))]
+    #[instrument]
     pub async fn make_explorer_request(
         &self,
         uri: &str,
@@ -374,22 +291,14 @@ impl Client {
             .bearer_auth(access_token)
             .query(&params)
             .send()
-            .await
+            .await?
-            .map_err(|e| {
-                error!("{:?}", e);
-                e
-            })?
             .text()
-            .await
+            .await?;
-            .map_err(|e| {
-                error!("{:?}", e);
-                e
-            })?;
         println!("{:?}", response);
         Ok(())
     }
 
-    #[instrument(skip(self))]
+    #[instrument]
     pub async fn search(&self, query: &str) -> Result<(), ClientError> {
         let query = vec![("query", query.to_string())];
         self.make_explorer_request(&format!("search/artists"), Some(&query))
@@ -397,7 +306,7 @@ impl Client {
         Ok(())
     }
 
-    #[instrument(skip(self))]
+    #[instrument]
     pub async fn get_playlist_tracks(
         &self,
         playlist_uuid: &str,
@@ -407,35 +316,21 @@ impl Client {
             .await?)
     }
 
-    #[instrument(skip(self))]
+    #[instrument]
     pub async fn get_playlist(&self, playlist_uuid: &str) -> Result<Playlist, ClientError> {
         Ok(self
             .make_request(&format!("playlists/{}", playlist_uuid), None)
             .await?)
     }
 
-    #[instrument(skip(self))]
+    #[instrument]
-    pub async fn get_artist(&self, artist_uuid: &str) -> Result<Artist, ClientError> {
-        Ok(self
-            .make_request(&format!("artists/{}", artist_uuid), None)
-            .await?)
-    }
-
-    #[instrument(skip(self))]
-    pub async fn get_artist_albums(&self, artist_uuid: &str) -> Result<Vec<Album>, ClientError> {
-        Ok(self
-            .make_paginated_request(&format!("artists/{}/albums", artist_uuid), None)
-            .await?)
-    }
-
-    #[instrument(skip(self))]
     pub async fn get_users_playlists(&self, user_id: u64) -> Result<Vec<Playlist>, ClientError> {
         Ok(self
             .make_paginated_request(&format!("users/{}/playlists", user_id), None)
             .await?)
     }
 
-    #[instrument(skip(self))]
+    #[instrument]
     pub async fn get_users_playlists_and_favorite_playlists(
         &self,
         user_id: &str,
@@ -448,7 +343,25 @@ impl Client {
             .await?)
     }
 
-    #[instrument(skip(self))]
+    #[instrument]
+    pub async fn explore_get_users_playlists_and_favorite_playlists(
+        &self,
+        user_id: u64,
+    ) -> Result<(), ClientError> {
+        let limit = 50;
+        let offset = 0;
+        let limit_param = ("limit", limit.to_string());
+        let offset_param = ("offset", offset.to_string());
+        let params: Vec<(&str, String)> = vec![limit_param, offset_param];
+        self.make_explorer_request(
+            &format!("users/{}/playlistsAndFavoritePlaylists", user_id),
+            Some(&params[..]),
+        )
+        .await?;
+        Ok(())
+    }
+
+    #[instrument]
     pub async fn get_users_favorites(&self, user_id: u64) -> Result<(), ClientError> {
         self.make_explorer_request(
             &format!("users/{}/favorites", user_id),
@@ -459,18 +372,7 @@ impl Client {
         Ok(())
     }
 
-    #[instrument(skip(self))]
+    #[instrument]
-    pub async fn get_users_artists(&self, user_id: &str) -> Result<Vec<ArtistItem>, ClientError> {
-        Ok(self
-            .make_paginated_request(
-                &format!("users/{}/favorites/artists", user_id),
-                None,
-                // Some(&query),
-            )
-            .await?)
-    }
-
-    #[instrument(skip(self))]
     pub async fn get_user(&self, user_id: u64) -> Result<(), ClientError> {
         self.make_explorer_request(
             &format!("users/{}", user_id),
@@ -481,19 +383,7 @@ impl Client {
         Ok(())
     }
 
-    #[instrument(skip(self))]
+    #[instrument]
-    pub async fn get_album(&self, album_id: &str) -> Result<Album, ClientError> {
-        self.make_request(&format!("albums/{}/", album_id), None)
-            .await
-    }
-
-    #[instrument(skip(self))]
-    pub async fn get_album_tracks(&self, album_id: &str) -> Result<Vec<Track>, ClientError> {
-        self.make_paginated_request(&format!("albums/{}/tracks", album_id), None)
-            .await
-    }
-
-    #[instrument(skip(self))]
     pub async fn get_track_playback(&self, track_id: &str) -> Result<TrackPlayback, ClientError> {
         let query = vec![
             ("audioquality", "LOSSLESS".to_string()),
@@ -507,14 +397,14 @@ impl Client {
         .await
     }
 
-    #[instrument(skip(self))]
+    #[instrument]
     pub async fn get_track(&self, track_id: &str) -> Result<Track, ClientError> {
         let (_, track_id, _) = split_uuid(track_id);
         self.make_request(&format!("tracks/{}", track_id), None)
             .await
     }
 
-    #[instrument(skip(self))]
+    #[instrument]
     pub async fn login_web(&mut self) -> Result<(), ClientError> {
         let code_response = self.get_device_code().await?;
         let now = Instant::now();
@@ -553,11 +443,7 @@ impl Client {
             .get(format!("{}/sessions", self.settings.base_url))
             .bearer_auth(access_token)
             .send()
-            .await
+            .await?
-            .map_err(|e| {
-                error!("{:?}", e);
-                e
-            })?
             .status()
             .is_success()
         {
@@ -573,7 +459,7 @@ impl Client {
         Ok(())
     }
 
-    #[instrument(skip(self))]
+    #[instrument]
     pub async fn refresh_access_token(&self) -> Result<RefreshResponse, ClientError> {
         let Some(refresh_token) = self.settings.login.refresh_token.clone() else {
         return Err(ClientError::AuthError(
@@ -599,11 +485,7 @@ impl Client {
             )
             .header("Content-Type", "application/x-www-form-urlencoded")
             .send()
-            .await
+            .await?;
-            .map_err(|e| {
-                error!("{:?}", e);
-                e
-            })?;
         if req.status().is_success() {
             let res = req.json::<RefreshResponse>().await?;
             Ok(res)
@@ -613,7 +495,7 @@ impl Client {
             ))
         }
     }
-    #[instrument(skip(self))]
+    #[instrument]
     async fn get_device_code(&self) -> Result<DeviceAuthResponse, ClientError> {
         let req = DeviceAuthRequest {
             client_id: self.settings.oauth.client_id.clone(),
@@ -630,11 +512,7 @@ impl Client {
             .header("Content-Type", "application/x-www-form-urlencoded")
             .body(payload)
             .send()
-            .await
+            .await?;
-            .map_err(|e| {
-                error!("{:?}", e);
-                e
-            })?;
 
         if !res.status().is_success() {
             return Err(ClientError::AuthError(res.status().to_string()));
@@ -643,7 +521,7 @@ impl Client {
         Ok(code)
     }
 
-    #[instrument(skip(self))]
+    #[instrument]
     pub async fn check_auth_status(
         &self,
         device_code: &str,
@@ -666,11 +544,7 @@ impl Client {
             .body(payload)
             .header("Content-Type", "application/x-www-form-urlencoded")
             .send()
-            .await
+            .await?;
-            .map_err(|e| {
-                error!("{:?}", e);
-                e
-            })?;
         if !res.status().is_success() {
             if res.status().is_client_error() {
                 return Err(ClientError::AuthError(format!(
@@ -690,26 +564,25 @@ impl Client {
 
 #[cfg(test)]
 mod tests {
-    use crabidy_core::ProviderClient;
-
     use super::*;
 
-    async fn setup() -> Client {
+    fn setup() -> Client {
-        let raw_toml_settings =
+        let settings = crate::config::Settings::default();
-            std::fs::read_to_string("/home/hans/.config/crabidy/tidaldy.toml").unwrap();
+        Client::new(settings).expect("could not create tidaldy client")
-        Client::init(&raw_toml_settings).await.unwrap()
     }
 
     #[tokio::test]
-    async fn test() {
+    async fn test_get_device_code() {
-        let client = setup().await;
+        let client = setup();
-        let user = client.settings.login.user_id.clone().unwrap();
+        println!("{:#?}", client);
-        let result = client.get_users_artists(&user).await.unwrap();
+        let response = client.get_device_code().await.unwrap();
-        println!("{:?}", result);
+        assert!(!response.device_code.is_empty());
-        let result = client.get_artist("5293333").await.unwrap();
+        assert_eq!(response.device_code.len(), 36);
-        println!("{:?}", result);
+        assert!(!response.user_code.is_empty());
-        let result = client.get_album("244167550").await.unwrap();
+        assert_eq!(response.user_code.len(), 5);
-        println!("{:?}", result);
+        assert!(!response.verification_uri.is_empty());
-        assert!(false);
+        assert!(!response.verification_uri_complete.is_empty());
+        assert!(response.expires_in == 300);
+        assert!(response.interval != 0);
     }
 }

tidaldy/src/models.rs

@@ -1,6 +1,5 @@
 use std::{str::FromStr, string::FromUtf8Error};
 
-use crabidy_core::proto::crabidy::{LibraryNode, LibraryNodeChild};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use thiserror::Error;
@@ -16,58 +15,15 @@ pub struct Page<T> {
 
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct ArtistItem {
+pub struct Item {
-    pub created: String,
-    pub item: Artist,
-}
-
-impl From<ArtistItem> for LibraryNode {
-    fn from(item: ArtistItem) -> Self {
-        Self {
-            uuid: format!("artist:{}", item.item.id),
-            title: item.item.name,
-            children: Vec::new(),
-            parent: None,
-            tracks: Vec::new(),
-            is_queable: true,
-        }
-    }
-}
-
-#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct Artist {
     pub id: i64,
     pub name: String,
-    pub artist_types: Option<Vec<String>>,
+    pub artist_types: Vec<String>,
-    pub url: Option<String>,
+    pub url: String,
-    pub picture: Option<Value>,
+    pub picture: Value,
-    pub popularity: Option<i64>,
+    pub popularity: i64,
-    pub artist_roles: Option<Vec<ArtistRole>>,
+    pub artist_roles: Vec<ArtistRole>,
-    pub mixes: Option<ArtistMixes>,
+    pub mixes: Mixes,
-}
-
-impl From<Artist> for LibraryNode {
-    fn from(artist: Artist) -> Self {
-        Self {
-            uuid: format!("node:artist:{}", artist.id),
-            title: artist.name,
-            children: Vec::new(),
-            parent: None,
-            tracks: Vec::new(),
-            is_queable: true,
-        }
-    }
-}
-
-impl From<Artist> for LibraryNodeChild {
-    fn from(artist: Artist) -> Self {
-        Self {
-            uuid: format!("node:artist:{}", artist.id),
-            title: artist.name,
-            is_queable: true,
-        }
-    }
 }
 
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -170,76 +126,43 @@ impl TrackPlayback {
     }
 }
 
-// #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
-// #[serde(rename_all = "camelCase")]
-// pub struct Track {
-//     pub id: u64,
-//     pub title: String,
-//     pub duration: u64,
-//     pub replay_gain: f64,
-//     pub peak: f64,
-//     pub allow_streaming: bool,
-//     pub stream_ready: bool,
-//     pub stream_start_date: Option<String>,
-//     pub premium_streaming_only: bool,
-//     pub track_number: u64,
-//     pub volume_number: u64,
-//     pub version: Value,
-//     pub popularity: u64,
-//     pub copyright: Option<String>,
-//     pub url: Option<String>,
-//     pub isrc: Option<String>,
-//     pub editable: bool,
-//     pub explicit: bool,
-//     pub audio_quality: String,
-//     pub audio_modes: Vec<String>,
-//     pub artist: Artist,
-//     pub artists: Vec<Artist>,
-//     pub album: Album,
-//     pub mixes: TrackMixes,
-// }
-
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Track {
-    pub id: i64,
+    pub id: u64,
     pub title: String,
-    pub duration: Option<i64>,
+    pub duration: u64,
-    pub replay_gain: Option<f64>,
+    pub replay_gain: f64,
-    pub peak: Option<f64>,
+    pub peak: f64,
-    pub allow_streaming: Option<bool>,
+    pub allow_streaming: bool,
-    pub stream_ready: Option<bool>,
+    pub stream_ready: bool,
-    pub ad_supported_stream_ready: Option<bool>,
     pub stream_start_date: Option<String>,
-    pub premium_streaming_only: Option<bool>,
+    pub premium_streaming_only: bool,
-    pub track_number: Option<i64>,
+    pub track_number: u64,
-    pub volume_number: Option<i64>,
+    pub volume_number: u64,
-    pub version: Option<Value>,
+    pub version: Value,
-    pub popularity: Option<i64>,
+    pub popularity: u64,
     pub copyright: Option<String>,
     pub url: Option<String>,
     pub isrc: Option<String>,
-    pub editable: Option<bool>,
+    pub editable: bool,
-    pub explicit: Option<bool>,
+    pub explicit: bool,
-    pub audio_quality: Option<String>,
+    pub audio_quality: String,
-    pub audio_modes: Option<Vec<String>>,
+    pub audio_modes: Vec<String>,
-    pub media_metadata: Option<MediaMetadata>,
+    pub artist: Artist,
-    pub artist: Option<Artist>,
+    pub artists: Vec<Artist>,
-    pub artists: Option<Vec<Artist>>,
+    pub album: Album,
-    pub album: Option<Album>,
+    pub mixes: Mixes,
-    pub mixes: Option<TrackMixes>,
 }
+
 impl From<Track> for crabidy_core::proto::crabidy::Track {
     fn from(track: Track) -> Self {
         Self {
             uuid: format!("track:{}", track.id),
             title: track.title,
-            artist: match track.artist {
+            artist: track.artist.name,
-                Some(a) => a.name.clone(),
+            album: Some(track.album.into()),
-                None => "".to_string(),
+            duration: Some(track.duration as u32),
-            },
-            album: track.album.map(|a| a.into()),
-            duration: track.duration.map(|d| d as u32 * 1000),
         }
     }
 }
@@ -249,143 +172,42 @@ impl From<&Track> for crabidy_core::proto::crabidy::Track {
         Self {
             uuid: format!("track:{}", track.id),
             title: track.title.clone(),
-            artist: match track.artist.as_ref() {
+            artist: track.artist.name.clone(),
-                Some(a) => a.name.clone(),
+            album: Some(track.album.clone().into()),
-                None => "".to_string(),
+            duration: Some(track.duration as u32),
-            },
-            album: track.album.clone().map(|a| a.into()),
-            duration: track.duration.map(|d| d as u32 * 1000),
         }
     }
 }
 
-// #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
-// #[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase")]
-// pub struct Artist {
+pub struct Artist {
-//     pub id: i64,
+    pub id: i64,
-//     pub name: String,
+    pub name: String,
-//     #[serde(rename = "type")]
+    #[serde(rename = "type")]
-//     pub type_field: String,
+    pub type_field: String,
-//     pub picture: Value,
+    pub picture: Value,
-// }
+}
 
-// #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
-// #[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase")]
-// pub struct Artist2 {
+pub struct Artist2 {
-//     pub id: i64,
+    pub id: i64,
-//     pub name: String,
+    pub name: String,
-//     #[serde(rename = "type")]
+    #[serde(rename = "type")]
-//     pub type_field: String,
+    pub type_field: String,
-//     pub picture: Value,
+    pub picture: Value,
-// }
+}
 
-// #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
-// #[serde(rename_all = "camelCase")]
-// pub struct Album {
-//     pub id: i64,
-//     pub title: String,
-//     pub cover: String,
-//     pub vibrant_color: String,
-//     pub video_cover: Value,
-//     pub release_date: Option<String>,
-// }
-//
-// #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
-// #[serde(rename_all = "camelCase")]
-// pub struct Root {
-//     pub id: i64,
-//     pub title: String,
-//     pub duration: i64,
-//     pub stream_ready: bool,
-//     pub ad_supported_stream_ready: bool,
-//     pub stream_start_date: String,
-//     pub allow_streaming: bool,
-//     pub premium_streaming_only: bool,
-//     pub number_of_tracks: i64,
-//     pub number_of_videos: i64,
-//     pub number_of_volumes: i64,
-//     pub release_date: String,
-//     pub copyright: String,
-//     #[serde(rename = "type")]
-//     pub type_field: String,
-//     pub version: Value,
-//     pub url: String,
-//     pub cover: String,
-//     pub vibrant_color: String,
-//     pub video_cover: Value,
-//     pub explicit: bool,
-//     pub upc: String,
-//     pub popularity: i64,
-//     pub audio_quality: String,
-//     pub audio_modes: Vec<String>,
-//     pub media_metadata: MediaMetadata,
-//     pub artist: Artist,
-//     pub artists: Vec<Artist2>,
-// }
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Album {
     pub id: i64,
     pub title: String,
-    pub cover: Option<String>,
+    pub cover: String,
-    pub vibrant_color: Option<String>,
+    pub vibrant_color: String,
+    pub video_cover: Value,
     pub release_date: Option<String>,
-    pub duration: Option<i64>,
-    pub stream_ready: Option<bool>,
-    pub ad_supported_stream_ready: Option<bool>,
-    pub stream_start_date: Option<String>,
-    pub allow_streaming: Option<bool>,
-    pub premium_streaming_only: Option<bool>,
-    pub number_of_tracks: Option<i64>,
-    pub number_of_videos: Option<i64>,
-    pub number_of_volumes: Option<i64>,
-    pub copyright: Option<String>,
-    #[serde(rename = "type")]
-    pub type_field: Option<String>,
-    pub version: Option<Value>,
-    pub url: Option<String>,
-    pub video_cover: Option<Value>,
-    pub explicit: Option<bool>,
-    pub upc: Option<String>,
-    pub popularity: Option<i64>,
-    pub audio_quality: Option<String>,
-    pub audio_modes: Option<Vec<String>>,
-    pub media_metadata: Option<MediaMetadata>,
-    pub artist: Option<Artist>,
-    pub artists: Option<Vec<Artist>>,
-}
-
-impl From<Album> for crabidy_core::proto::crabidy::LibraryNode {
-    fn from(album: Album) -> Self {
-        Self {
-            uuid: format!("node:album:{}", album.id),
-            title: album.title,
-            children: Vec::new(),
-            parent: None,
-            tracks: Vec::new(),
-            is_queable: true,
-        }
-    }
-}
-
-impl From<Album> for crabidy_core::proto::crabidy::LibraryNodeChild {
-    fn from(album: Album) -> Self {
-        Self {
-            uuid: format!("node:album:{}", album.id),
-            title: album.title,
-            is_queable: true,
-        }
-    }
-}
-
-impl From<&Album> for crabidy_core::proto::crabidy::LibraryNodeChild {
-    fn from(album: &Album) -> Self {
-        Self {
-            uuid: format!("node:album:{}", album.id),
-            title: album.title.clone(),
-            is_queable: true,
-        }
-    }
 }
 
 impl From<Album> for crabidy_core::proto::crabidy::Album {
@@ -399,26 +221,11 @@ impl From<Album> for crabidy_core::proto::crabidy::Album {
 
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct MediaMetadata {
+pub struct Mixes {
-    pub tags: Vec<String>,
-}
-
-#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct TrackMixes {
     #[serde(rename = "TRACK_MIX")]
     pub track_mix: Option<String>,
 }
 
-#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ArtistMixes {
-    #[serde(rename = "MASTER_ARTIST_MIX")]
-    pub master_artist_mix: Option<String>,
-    #[serde(rename = "ARTIST_MIX")]
-    pub artist_mix: Option<String>,
-}
-
 #[derive(Deserialize, Serialize, Debug)]
 #[serde(rename_all(deserialize = "camelCase"))]
 pub struct PlaybackManifest {
@@ -552,7 +359,7 @@ pub struct PlaylistTrack {
     pub artist: Artist,
     pub artists: Vec<Artist>,
     pub album: Album,
-    pub mixes: TrackMixes,
+    pub mixes: Mixes,
     pub date_added: String,
     pub index: i64,
     pub item_uuid: String,