Added better support for contexts now and improved base Radarr UI

src/network/mod.rs

@@ -4,16 +4,14 @@ use reqwest::Client;
 use tokio::sync::Mutex;
 
 use crate::app::App;
+use crate::network::radarr_network::RadarrEvent;
 
-pub(crate) mod radarr;
+pub(crate) mod radarr_network;
 mod utils;
 
-#[derive(Debug, Eq, PartialEq, Hash)]
-pub enum RadarrEvent {
-  HealthCheck,
-  GetOverview,
-  GetStatus,
-  GetMovies,
+#[derive(PartialEq, Eq, Debug)]
+pub enum NetworkEvent {
+  Radarr(RadarrEvent)
 }
 
 pub struct Network<'a> {
@@ -26,4 +24,10 @@ impl<'a> Network<'a> {
   pub fn new(client: Client, app: &'a Arc<Mutex<App>>) -> Self {
     Network { client, app }
   }
+
+  pub async fn handle_network_event(&self, network_event: NetworkEvent) {
+    match network_event {
+      NetworkEvent::Radarr(radarr_event) => self.handle_radarr_event(radarr_event).await
+    }
+  }
 }

src/network/radarr_network.rs

@@ -8,7 +8,17 @@ use serde_json::Number;
 use tokio::sync::MutexGuard;
 
 use crate::app::{App, RadarrConfig};
-use crate::network::{Network, RadarrEvent, utils};
+use crate::network::{Network, NetworkEvent, utils};
+
+#[derive(Debug, Eq, PartialEq)]
+pub enum RadarrEvent {
+  HealthCheck,
+  GetDownloads,
+  GetOverview,
+  GetStatus,
+  GetMovies,
+  GetQualityProfiles,
+}
 
 impl RadarrEvent {
   const fn resource(self) -> &'static str {
@@ -17,10 +27,18 @@ impl RadarrEvent {
       RadarrEvent::GetOverview => "/diskspace",
       RadarrEvent::GetStatus => "/system/status",
       RadarrEvent::GetMovies => "/movie",
+      RadarrEvent::GetDownloads => "/queue",
+      RadarrEvent::GetQualityProfiles => "/qualityprofile"
     }
   }
 }
 
+impl From<RadarrEvent> for NetworkEvent {
+  fn from(radarr_event: RadarrEvent) -> Self {
+    NetworkEvent::Radarr(radarr_event)
+  }
+}
+
 #[derive(Deserialize, Debug)]
 #[serde(rename_all = "camelCase")]
 struct DiskSpace {
@@ -45,31 +63,73 @@ pub struct Movie {
   pub id: Number,
   pub title: String,
   #[derivative(Default(value = "Number::from(0)"))]
+  pub size_on_disk: Number,
+  pub status: String,
+  #[derivative(Default(value = "Number::from(0)"))]
   pub year: Number,
   pub monitored: bool,
   pub has_file: bool,
+  #[derivative(Default(value = "Number::from(0)"))]
+  pub runtime: Number,
+  #[derivative(Default(value = "Number::from(0)"))]
+  pub quality_profile_id: Number,
+}
+
+#[derive(Derivative, Deserialize, Debug)]
+#[derivative(Default)]
+#[serde(rename_all = "camelCase")]
+pub struct DownloadsResponse {
+  pub records: Vec<DownloadRecord>
+}
+
+#[derive(Derivative, Deserialize, Debug)]
+#[derivative(Default)]
+#[serde(rename_all = "camelCase")]
+pub struct DownloadRecord {
+  pub title: String,
+  pub status: String,
+  #[derivative(Default(value = "Number::from(0)"))]
+  pub movie_id: Number,
+  #[derivative(Default(value = "Number::from(0)"))]
+  pub size: Number,
+  #[derivative(Default(value = "Number::from(0)"))]
+  pub sizeleft: Number,
+  pub output_path: String,
+  pub indexer: String,
+  pub download_client: String
+}
+
+#[derive(Derivative, Deserialize, Debug)]
+#[derivative(Default)]
+#[serde(rename_all = "camelCase")]
+struct QualityProfile {
+  #[derivative(Default(value = "Number::from(0)"))]
+  pub id: Number,
+  pub name: String
 }
 
 impl<'a> Network<'a> {
   pub async fn handle_radarr_event(&self, radarr_event: RadarrEvent) {
     match radarr_event {
-      RadarrEvent::HealthCheck => self.healthcheck(RadarrEvent::HealthCheck.resource()).await,
-      RadarrEvent::GetOverview => self.diskspace(RadarrEvent::GetOverview.resource()).await,
-      RadarrEvent::GetStatus => self.status(RadarrEvent::GetStatus.resource()).await,
-      RadarrEvent::GetMovies => self.movies(RadarrEvent::GetMovies.resource()).await
+      RadarrEvent::HealthCheck => self.get_healthcheck(RadarrEvent::HealthCheck.resource()).await,
+      RadarrEvent::GetOverview => self.get_diskspace(RadarrEvent::GetOverview.resource()).await,
+      RadarrEvent::GetStatus => self.get_status(RadarrEvent::GetStatus.resource()).await,
+      RadarrEvent::GetMovies => self.get_movies(RadarrEvent::GetMovies.resource()).await,
+      RadarrEvent::GetDownloads => self.get_downloads(RadarrEvent::GetDownloads.resource()).await,
+      RadarrEvent::GetQualityProfiles => self.get_quality_profiles(RadarrEvent::GetQualityProfiles.resource()).await
     }
 
     let mut app = self.app.lock().await;
     app.reset_tick_count();
   }
 
-  async fn healthcheck(&self, resource: &str) {
+  async fn get_healthcheck(&self, resource: &str) {
     if let Err(e) = self.call_radarr_api(resource).await.send().await {
       error!("Healthcheck failed. {:?}", e)
     }
   }
 
-  async fn diskspace(&self, resource: &str) {
+  async fn get_diskspace(&self, resource: &str) {
     self.handle_get_request::<Vec<DiskSpace>>(resource, | disk_space_vec, mut app | {
       let DiskSpace {
         free_space,
@@ -82,19 +142,33 @@ impl<'a> Network<'a> {
     }).await;
   }
 
-  async fn status(&self, resource: &str) {
+  async fn get_status(&self, resource: &str) {
     self.handle_get_request::<SystemStatus>(resource, | system_status, mut app | {
       app.data.radarr_data.version = system_status.version;
       app.data.radarr_data.start_time = system_status.start_time;
     }).await;
   }
 
-  async fn movies(&self, resource: &str) {
+  async fn get_movies(&self, resource: &str) {
     self.handle_get_request::<Vec<Movie>>(resource, |movie_vec, mut app| {
       app.data.radarr_data.movies.set_items(movie_vec);
     }).await;
   }
 
+  async fn get_downloads(&self, resource: &str) {
+    self.handle_get_request::<DownloadsResponse>(resource, |queue_response, mut app | {
+      app.data.radarr_data.downloads.set_items(queue_response.records);
+    }).await
+  }
+
+  async fn get_quality_profiles(&self, resource: &str) {
+    self.handle_get_request::<Vec<QualityProfile>>(resource, | quality_profiles, mut app | {
+      app.data.radarr_data.quality_profile_map = quality_profiles.into_iter()
+          .map(| profile | (profile.id.as_u64().unwrap(), profile.name))
+          .collect();
+    }).await;
+  }
+
   async fn call_radarr_api(&self, resource: &str) -> RequestBuilder {
     debug!("Creating RequestBuilder for resource: {:?}", resource);
     let app = self.app.lock().await;
@@ -128,10 +202,10 @@ impl<'a> Network<'a> {
             let app = self.app.lock().await;
             app_update_fn(value, app);
           }
-          Err(e) => error!("Failed to parse movie response! {:?}", e)
+          Err(e) => error!("Failed to parse response! {:?}", e)
         }
       }
-      Err(e) => error!("Failed to fetch movies. {:?}", e)
+      Err(e) => error!("Failed to fetch resource. {:?}", e)
     }
   }
 }