feat(network): Added support for fetching Sonarr queued events

src/network/radarr_network.rs

@@ -11,15 +11,15 @@ use crate::models::radarr_models::{
   CollectionMovie, CommandBody, Credit, CreditType, DeleteMovieParams, DiskSpace, DownloadRecord,
   DownloadsResponse, EditCollectionParams, EditIndexerParams, EditMovieParams, IndexerSettings,
   IndexerTestResult, LogResponse, Movie, MovieCommandBody, MovieHistoryItem, QualityProfile,
-  QueueEvent, RadarrSerdeable, Release, ReleaseDownloadBody, RootFolder, SystemStatus, Tag, Task,
-  TaskName, Update,
+  RadarrSerdeable, Release, ReleaseDownloadBody, RootFolder, SystemStatus, Tag, Task, TaskName,
+  Update,
 };
 use crate::models::servarr_data::radarr::modals::{
   AddMovieModal, EditCollectionModal, EditIndexerModal, EditMovieModal, IndexerTestResultModalItem,
   MovieDetailsModal,
 };
 use crate::models::servarr_data::radarr::radarr_data::ActiveRadarrBlock;
-use crate::models::servarr_models::{HostConfig, Indexer, SecurityConfig};
+use crate::models::servarr_models::{HostConfig, Indexer, QueueEvent, SecurityConfig};
 use crate::models::stateful_table::StatefulTable;
 use crate::models::{HorizontallyScrollableText, Route, Scrollable, ScrollableText};
 use crate::network::{Network, NetworkEvent, RequestMethod};
@@ -219,7 +219,10 @@ impl<'a, 'b> Network<'a, 'b> {
         .get_radarr_quality_profiles()
         .await
         .map(RadarrSerdeable::from),
-      RadarrEvent::GetQueuedEvents => self.get_queued_events().await.map(RadarrSerdeable::from),
+      RadarrEvent::GetQueuedEvents => self
+        .get_queued_radarr_events()
+        .await
+        .map(RadarrSerdeable::from),
       RadarrEvent::GetReleases(movie_id) => {
         self.get_releases(movie_id).await.map(RadarrSerdeable::from)
       }
@@ -1728,7 +1731,7 @@ impl<'a, 'b> Network<'a, 'b> {
       .await
   }
 
-  async fn get_queued_events(&mut self) -> Result<Vec<QueueEvent>> {
+  async fn get_queued_radarr_events(&mut self) -> Result<Vec<QueueEvent>> {
     info!("Fetching Radarr queued events");
     let event = RadarrEvent::GetQueuedEvents;
 

src/network/radarr_network_tests.rs

@@ -2399,7 +2399,7 @@ mod test {
   }
 
   #[tokio::test]
-  async fn test_handle_get_queued_events_event() {
+  async fn test_handle_get_queued_radarr_events_event() {
     let queued_events_json = json!([{
         "name": "RefreshMonitoredDownloads",
         "commandName": "Refresh Monitored Downloads",

src/network/sonarr_network.rs

@@ -9,7 +9,7 @@ use serde_json::{json, Value};
 use crate::{
   models::{
     servarr_data::sonarr::{modals::EpisodeDetailsModal, sonarr_data::ActiveSonarrBlock},
-    servarr_models::{HostConfig, Indexer, SecurityConfig},
+    servarr_models::{HostConfig, Indexer, QueueEvent, SecurityConfig},
     sonarr_models::{
       BlocklistResponse, DownloadRecord, DownloadsResponse, Episode, IndexerSettings, LogResponse,
       QualityProfile, Series, SonarrSerdeable, SystemStatus,
@@ -38,6 +38,7 @@ pub enum SonarrEvent {
   GetEpisodes(Option<i64>),
   GetLogs(Option<u64>),
   GetQualityProfiles,
+  GetQueuedEvents,
   GetSecurityConfig,
   GetStatus,
   HealthCheck,
@@ -57,6 +58,7 @@ impl NetworkResource for SonarrEvent {
       SonarrEvent::GetIndexers => "/indexer",
       SonarrEvent::GetLogs(_) => "/log",
       SonarrEvent::GetQualityProfiles => "/qualityprofile",
+      SonarrEvent::GetQueuedEvents => "/command",
       SonarrEvent::GetStatus => "/system/status",
       SonarrEvent::HealthCheck => "/health",
       SonarrEvent::ListSeries => "/series",
@@ -107,6 +109,10 @@ impl<'a, 'b> Network<'a, 'b> {
         .get_sonarr_quality_profiles()
         .await
         .map(SonarrSerdeable::from),
+      SonarrEvent::GetQueuedEvents => self
+        .get_queued_sonarr_events()
+        .await
+        .map(SonarrSerdeable::from),
       SonarrEvent::GetLogs(events) => self
         .get_sonarr_logs(events)
         .await
@@ -523,6 +529,25 @@ impl<'a, 'b> Network<'a, 'b> {
       .await
   }
 
+  async fn get_queued_sonarr_events(&mut self) -> Result<Vec<QueueEvent>> {
+    info!("Fetching Sonarr queued events");
+    let event = SonarrEvent::GetQueuedEvents;
+
+    let request_props = self
+      .request_props_from(event, RequestMethod::Get, None::<()>, None, None)
+      .await;
+
+    self
+      .handle_request::<(), Vec<QueueEvent>>(request_props, |queued_events_vec, mut app| {
+        app
+          .data
+          .sonarr_data
+          .queued_events
+          .set_items(queued_events_vec);
+      })
+      .await
+  }
+
   async fn get_sonarr_security_config(&mut self) -> Result<SecurityConfig> {
     info!("Fetching Sonarr security config");
     let event = SonarrEvent::GetSecurityConfig;

src/network/sonarr_network_tests.rs

@@ -22,7 +22,9 @@ mod test {
 
   use crate::app::App;
   use crate::models::servarr_data::sonarr::sonarr_data::ActiveSonarrBlock;
-  use crate::models::servarr_models::{HostConfig, Indexer, IndexerField, SecurityConfig};
+  use crate::models::servarr_models::{
+    HostConfig, Indexer, IndexerField, QueueEvent, SecurityConfig,
+  };
   use crate::models::sonarr_models::{
     BlocklistItem, DownloadRecord, DownloadsResponse, Episode, EpisodeFile, Language, LogResponse,
     MediaInfo, QualityProfile,
@@ -145,6 +147,11 @@ mod test {
     assert_str_eq!(event.resource(), "/config/host");
   }
 
+  #[rstest]
+  fn test_resource_command(#[values(SonarrEvent::GetQueuedEvents)] event: SonarrEvent) {
+    assert_str_eq!(event.resource(), "/command");
+  }
+
   #[rstest]
   fn test_resource_indexer(#[values(SonarrEvent::GetIndexers)] event: SonarrEvent) {
     assert_str_eq!(event.resource(), "/indexer");
@@ -1130,6 +1137,57 @@ mod test {
     }
   }
 
+  #[tokio::test]
+  async fn test_handle_get_queued_sonarr_events_event() {
+    let queued_events_json = json!([{
+        "name": "RefreshMonitoredDownloads",
+        "commandName": "Refresh Monitored Downloads",
+        "status": "completed",
+        "queued": "2023-05-20T21:29:16Z",
+        "started": "2023-05-20T21:29:16Z",
+        "ended": "2023-05-20T21:29:16Z",
+        "duration": "00:00:00.5111547",
+        "trigger": "scheduled",
+    }]);
+    let response: Vec<QueueEvent> = serde_json::from_value(queued_events_json.clone()).unwrap();
+    let timestamp = DateTime::from(DateTime::parse_from_rfc3339("2023-05-20T21:29:16Z").unwrap());
+    let expected_event = QueueEvent {
+      name: "RefreshMonitoredDownloads".to_owned(),
+      command_name: "Refresh Monitored Downloads".to_owned(),
+      status: "completed".to_owned(),
+      queued: timestamp,
+      started: Some(timestamp),
+      ended: Some(timestamp),
+      duration: Some("00:00:00.5111547".to_owned()),
+      trigger: "scheduled".to_owned(),
+    };
+
+    let (async_server, app_arc, _server) = mock_servarr_api(
+      RequestMethod::Get,
+      None,
+      Some(queued_events_json),
+      None,
+      SonarrEvent::GetQueuedEvents,
+      None,
+      None,
+    )
+    .await;
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+
+    if let SonarrSerdeable::QueueEvents(events) = network
+      .handle_sonarr_event(SonarrEvent::GetQueuedEvents)
+      .await
+      .unwrap()
+    {
+      async_server.assert_async().await;
+      assert_eq!(
+        app_arc.lock().await.data.sonarr_data.queued_events.items,
+        vec![expected_event]
+      );
+      assert_eq!(events, response);
+    }
+  }
+
   #[rstest]
   #[tokio::test]
   async fn test_handle_get_series_event(#[values(true, false)] use_custom_sorting: bool) {