pick random song from tracklist

Cargo.toml

@@ -28,6 +28,7 @@ clipboard = "0.5.0"
 crossterm =  "0.16"
 tokio = { version = "0.2", features = ["full"] }
 proc-macro2 = "1.0.9"
+rand="0.7.3"
 
 [[bin]]
 bench = false

src/handlers/track_table.rs

@@ -4,6 +4,8 @@ use super::{
 };
 use crate::event::Key;
 use crate::network::IoEvent;
+use rand::{thread_rng, Rng};
+use serde_json::from_value;
 
 pub fn handler(key: Key, app: &mut App) {
   match key {
@@ -139,6 +141,7 @@ pub fn handler(key: Key, app: &mut App) {
         None => {}
       };
     }
+    Key::Char('S') => play_random_song(app),
     Key::Ctrl('e') => jump_to_end(app),
     Key::Ctrl('a') => jump_to_start(app),
     //recommended song radio
@@ -149,6 +152,108 @@ pub fn handler(key: Key, app: &mut App) {
   }
 }
 
+fn play_random_song(app: &mut App) {
+  let TrackTable { context, .. } = &app.track_table;
+  match &context {
+    Some(context) => match context {
+      TrackTableContext::MyPlaylists => {
+        let (context_uri, track_json) = match (&app.selected_playlist_index, &app.playlists) {
+          (Some(selected_playlist_index), Some(playlists)) => {
+            if let Some(selected_playlist) = playlists.items.get(selected_playlist_index.to_owned())
+            {
+              (
+                Some(selected_playlist.uri.to_owned()),
+                selected_playlist.tracks.get("total"),
+              )
+            } else {
+              (None, None)
+            }
+          }
+          _ => (None, None),
+        };
+
+        if let Some(val) = track_json {
+          let num_tracks: usize = from_value(val.clone()).unwrap();
+          app.dispatch(IoEvent::StartPlayback(
+            context_uri,
+            None,
+            Some(thread_rng().gen_range(0, num_tracks)),
+          ));
+        }
+      }
+      TrackTableContext::RecommendedTracks => {}
+      TrackTableContext::SavedTracks => {
+        if let Some(saved_tracks) = &app.library.saved_tracks.get_results(None) {
+          let track_uris: Vec<String> = saved_tracks
+            .items
+            .iter()
+            .map(|item| item.track.uri.to_owned())
+            .collect();
+          let rand_idx = thread_rng().gen_range(0, track_uris.len());
+          app.dispatch(IoEvent::StartPlayback(
+            None,
+            Some(track_uris),
+            Some(rand_idx),
+          ))
+        }
+      }
+      TrackTableContext::AlbumSearch => {}
+      TrackTableContext::PlaylistSearch => {
+        let (context_uri, playlist_track_json) = match (
+          &app.search_results.selected_playlists_index,
+          &app.search_results.playlists,
+        ) {
+          (Some(selected_playlist_index), Some(playlist_result)) => {
+            if let Some(selected_playlist) = playlist_result
+              .playlists
+              .items
+              .get(selected_playlist_index.to_owned())
+            {
+              (
+                Some(selected_playlist.uri.to_owned()),
+                selected_playlist.tracks.get("total"),
+              )
+            } else {
+              (None, None)
+            }
+          }
+          _ => (None, None),
+        };
+        if let Some(val) = playlist_track_json {
+          let num_tracks: usize = from_value(val.clone()).unwrap();
+          app.dispatch(IoEvent::StartPlayback(
+            context_uri,
+            None,
+            Some(thread_rng().gen_range(0, num_tracks)),
+          ))
+        }
+      }
+      TrackTableContext::MadeForYou => {
+        let (context_uri, track_json) = match app
+          .library
+          .made_for_you_playlists
+          .get_results(Some(0))
+          .unwrap()
+          .items
+          .get(app.made_for_you_index)
+          .unwrap()
+        {
+          playlist => (Some(playlist.uri.to_owned()), playlist.tracks.get("total")),
+        };
+        if let Some(val) = track_json{
+          let num_tracks:usize = from_value(val.clone()).unwrap();
+          app.dispatch(IoEvent::StartPlayback(
+            context_uri,
+            None,
+            Some(thread_rng().gen_range(0, num_tracks))
+          ))
+        }
+      }
+    },
+    None => {}
+  };
+}
+
 fn handle_recommended_tracks(app: &mut App) {
   let (selected_index, tracks) = (&app.track_table.selected_index, &app.track_table.tracks);
   if let Some(track) = tracks.get(*selected_index) {