Added the ability to view Radarr updates and remapped the events queue key to 'z'

src/network/radarr_network.rs

@@ -12,7 +12,7 @@ use crate::models::radarr_models::{
   AddMovieBody, AddMovieSearchResult, AddOptions, AddRootFolderBody, Collection, CollectionMovie,
   CommandBody, Credit, CreditType, DiskSpace, DownloadRecord, DownloadsResponse, LogResponse,
   Movie, MovieCommandBody, MovieHistoryItem, QualityProfile, QueueEvent, Release,
-  ReleaseDownloadBody, RootFolder, SystemStatus, Tag, Task,
+  ReleaseDownloadBody, RootFolder, SystemStatus, Tag, Task, Update,
 };
 use crate::models::{HorizontallyScrollableText, Route, Scrollable, ScrollableText};
 use crate::network::{Network, NetworkEvent, RequestMethod, RequestProps};
@@ -47,6 +47,7 @@ pub enum RadarrEvent {
   GetStatus,
   GetTags,
   GetTasks,
+  GetUpdates,
   HealthCheck,
   SearchNewMovie,
   StartTask,
@@ -80,6 +81,7 @@ impl RadarrEvent {
       RadarrEvent::GetStatus => "/system/status",
       RadarrEvent::GetTags => "/tag",
       RadarrEvent::GetTasks => "/system/task",
+      RadarrEvent::GetUpdates => "/update",
       RadarrEvent::StartTask
       | RadarrEvent::GetQueuedEvents
       | RadarrEvent::TriggerAutomaticSearch
@@ -124,6 +126,7 @@ impl<'a, 'b> Network<'a, 'b> {
       RadarrEvent::GetStatus => self.get_status().await,
       RadarrEvent::GetTags => self.get_tags().await,
       RadarrEvent::GetTasks => self.get_tasks().await,
+      RadarrEvent::GetUpdates => self.get_updates().await,
       RadarrEvent::HealthCheck => self.get_healthcheck().await,
       RadarrEvent::SearchNewMovie => self.search_movie().await,
       RadarrEvent::StartTask => self.start_task().await,
@@ -742,6 +745,97 @@ impl<'a, 'b> Network<'a, 'b> {
       .await;
   }
 
+  async fn get_updates(&self) {
+    info!("Fetching Radarr updates");
+
+    let request_props = self
+      .radarr_request_props_from(
+        RadarrEvent::GetUpdates.resource(),
+        RequestMethod::Get,
+        None::<()>,
+      )
+      .await;
+
+    self
+      .handle_request::<(), Vec<Update>>(request_props, |updates_vec, mut app| {
+        let latest_installed = if updates_vec
+          .iter()
+          .any(|update| update.latest && update.installed_on.is_some())
+        {
+          "already".to_owned()
+        } else {
+          "not".to_owned()
+        };
+        let updates = updates_vec
+          .into_iter()
+          .map(|update| {
+            let install_status = if update.installed_on.is_some() {
+              if update.installed {
+                "(Currently Installed)".to_owned()
+              } else {
+                "(Previously Installed)".to_owned()
+              }
+            } else {
+              String::new()
+            };
+            let vec_to_bullet_points = |vec: Vec<String>| {
+              vec
+                .iter()
+                .map(|change| format!("  * {}", change))
+                .collect::<Vec<String>>()
+                .join("\n")
+            };
+
+            let mut update_info = formatdoc!(
+              "{} - {} {}
+              {}",
+              update.version,
+              update.release_date,
+              install_status,
+              "-".repeat(200)
+            );
+
+            if let Some(new_changes) = update.changes.new {
+              let changes = vec_to_bullet_points(new_changes);
+              update_info = formatdoc!(
+                "{}
+              New:
+              {}",
+                update_info,
+                changes
+              )
+            }
+
+            if let Some(fixes) = update.changes.fixed {
+              let fixes = vec_to_bullet_points(fixes);
+              update_info = formatdoc!(
+                "{}
+              Fixed:
+              {}",
+                update_info,
+                fixes
+              );
+            }
+
+            update_info
+          })
+          .reduce(|version_1, version_2| format!("{}\n\n\n{}", version_1, version_2))
+          .unwrap();
+
+        app.data.radarr_data.updates = ScrollableText::with_string(formatdoc!(
+          "{}
+          
+          {}",
+          format!(
+            "The latest version of Radarr is {} installed",
+            latest_installed
+          ),
+          updates
+        ));
+      })
+      .await;
+  }
+
   async fn add_tag(&self, tag: String) {
     info!("Adding a new Radarr tag");
 

src/network/radarr_network_tests.rs

@@ -1065,6 +1065,95 @@ mod test {
     );
   }
 
+  #[tokio::test]
+  async fn test_handle_get_updates_event() {
+    let tasks_json = json!([{
+      "version": "4.3.2.1",
+      "releaseDate": "2023-04-15T02:02:53Z",
+      "installed": true,
+      "installedOn": "2023-04-15T02:02:53Z",
+      "latest": true,
+      "changes": {
+        "new": [
+          "Cool new thing"
+        ],
+        "fixed": [
+          "Some bugs killed"
+        ]
+      },
+    },
+      {
+        "version": "3.2.1.0",
+        "releaseDate": "2023-04-15T02:02:53Z",
+        "installed": false,
+        "installedOn": "2023-04-15T02:02:53Z",
+        "latest": false,
+        "changes": {
+          "new": [
+            "Cool new thing (old)",
+            "Other cool new thing (old)"
+            ],
+        },
+    },
+    {
+      "version": "2.1.0",
+      "releaseDate": "2023-04-15T02:02:53Z",
+      "installed": false,
+      "latest": false,
+      "changes": {
+        "fixed": [
+          "Killed bug 1",
+          "Fixed bug 2"
+        ]
+      },
+    }]);
+    let line_break = "-".repeat(200);
+    let expected_text = ScrollableText::with_string(formatdoc!(
+      "
+    The latest version of Radarr is already installed
+
+    4.3.2.1 - 2023-04-15 02:02:53 UTC (Currently Installed)
+    {}
+    New:
+      * Cool new thing
+    Fixed:
+      * Some bugs killed
+    
+    
+    3.2.1.0 - 2023-04-15 02:02:53 UTC (Previously Installed)
+    {}
+    New:
+      * Cool new thing (old)
+      * Other cool new thing (old)
+    
+    
+    2.1.0 - 2023-04-15 02:02:53 UTC 
+    {}
+    Fixed:
+      * Killed bug 1
+      * Fixed bug 2",
+      line_break.clone(),
+      line_break.clone(),
+      line_break
+    ));
+    let (async_server, app_arc, _server) = mock_radarr_api(
+      RequestMethod::Get,
+      None,
+      Some(tasks_json),
+      RadarrEvent::GetUpdates.resource(),
+    )
+    .await;
+    let network = Network::new(reqwest::Client::new(), &app_arc);
+
+    network.handle_radarr_event(RadarrEvent::GetUpdates).await;
+
+    async_server.assert_async().await;
+    assert_str_eq!(
+      app_arc.lock().await.data.radarr_data.updates.get_text(),
+      expected_text.get_text()
+    );
+  }
+
   #[tokio::test]
   async fn test_add_tag() {
     let (async_server, app_arc, _server) = mock_radarr_api(