Dark-Alex-17/managarr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(network): Support for fetching all Sonarr tasks

Browse Source
This commit is contained in:
Alex Clarke
2024-11-22 16:35:39 -07:00
parent 539ad75fe6
commit c54bd2bab0
17 changed files with 267 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/network/radarr_network.rs
+7 -7
View File
@@ -10,8 +10,8 @@ use crate::models::radarr_models::{
AddMovieBody, AddMovieSearchResult, AddOptions, BlocklistResponse, Collection, CollectionMovie,
CommandBody, Credit, CreditType, DeleteMovieParams, DownloadRecord, DownloadsResponse,
EditCollectionParams, EditIndexerParams, EditMovieParams, IndexerSettings, IndexerTestResult,
Movie, MovieCommandBody, MovieHistoryItem, RadarrSerdeable, ReleaseDownloadBody, SystemStatus,
Task, TaskName, Update,
Movie, MovieCommandBody, MovieHistoryItem, RadarrSerdeable, RadarrTask, RadarrTaskName,
ReleaseDownloadBody, SystemStatus, Update,
};
use crate::models::servarr_data::radarr::modals::{
AddMovieModal, EditCollectionModal, EditIndexerModal, EditMovieModal, IndexerTestResultModalItem,
@@ -73,7 +73,7 @@ pub enum RadarrEvent {
GetUpdates,
HealthCheck,
SearchNewMovie(Option<String>),
StartTask(Option<TaskName>),
StartTask(Option<RadarrTaskName>),
TestIndexer(Option<i64>),
TestAllIndexers,
TriggerAutomaticSearch(Option<i64>),
@@ -243,7 +243,7 @@ impl<'a, 'b> Network<'a, 'b> {
.map(RadarrSerdeable::from),
RadarrEvent::GetStatus => self.get_radarr_status().await.map(RadarrSerdeable::from),
RadarrEvent::GetTags => self.get_radarr_tags().await.map(RadarrSerdeable::from),
RadarrEvent::GetTasks => self.get_tasks().await.map(RadarrSerdeable::from),
RadarrEvent::GetTasks => self.get_radarr_tasks().await.map(RadarrSerdeable::from),
RadarrEvent::GetUpdates => self.get_updates().await.map(RadarrSerdeable::from),
RadarrEvent::HealthCheck => self
.get_radarr_healthcheck()
@@ -1855,7 +1855,7 @@ impl<'a, 'b> Network<'a, 'b> {
.await
}
async fn get_tasks(&mut self) -> Result<Vec<Task>> {
async fn get_radarr_tasks(&mut self) -> Result<Vec<RadarrTask>> {
info!("Fetching Radarr tasks");
let event = RadarrEvent::GetTasks;
@@ -1864,7 +1864,7 @@ impl<'a, 'b> Network<'a, 'b> {
.await;
self
.handle_request::<(), Vec<Task>>(request_props, |tasks_vec, mut app| {
.handle_request::<(), Vec<RadarrTask>>(request_props, |tasks_vec, mut app| {
app.data.radarr_data.tasks.set_items(tasks_vec);
})
.await
@@ -2006,7 +2006,7 @@ impl<'a, 'b> Network<'a, 'b> {
}
}
async fn start_task(&mut self, task: Option<TaskName>) -> Result<Value> {
async fn start_task(&mut self, task: Option<RadarrTaskName>) -> Result<Value> {
let event = RadarrEvent::StartTask(None);
let task_name = if let Some(t_name) = task {
t_name
src/network/radarr_network_tests.rs
+10 -10
View File
@@ -733,9 +733,9 @@ mod test {
.data
.radarr_data
.tasks
.set_items(vec![Task {
task_name: TaskName::default(),
..Task::default()
.set_items(vec![RadarrTask {
task_name: RadarrTaskName::default(),
..RadarrTask::default()
}]);
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
@@ -767,7 +767,7 @@ mod test {
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
if let RadarrSerdeable::Value(value) = network
.handle_radarr_event(RadarrEvent::StartTask(Some(TaskName::default())))
.handle_radarr_event(RadarrEvent::StartTask(Some(RadarrTaskName::default())))
.await
.unwrap()
{
@@ -2666,7 +2666,7 @@ mod test {
}
#[tokio::test]
async fn test_handle_get_tasks_event() {
async fn test_handle_get_radarr_tasks_event() {
let tasks_json = json!([{
"name": "Application Check Update",
"taskName": "ApplicationCheckUpdate",
@@ -2683,20 +2683,20 @@ mod test {
"nextExecution": "2023-05-20T21:29:16Z",
"lastDuration": "00:00:00.5111547",
}]);
let response: Vec<Task> = serde_json::from_value(tasks_json.clone()).unwrap();
let response: Vec<RadarrTask> = serde_json::from_value(tasks_json.clone()).unwrap();
let timestamp = DateTime::from(DateTime::parse_from_rfc3339("2023-05-20T21:29:16Z").unwrap());
let expected_tasks = vec![
Task {
RadarrTask {
name: "Application Check Update".to_owned(),
task_name: TaskName::ApplicationCheckUpdate,
task_name: RadarrTaskName::ApplicationCheckUpdate,
interval: 360,
last_execution: timestamp,
next_execution: timestamp,
last_duration: "00:00:00.5111547".to_owned(),
},
Task {
RadarrTask {
name: "Backup".to_owned(),
task_name: TaskName::Backup,
task_name: RadarrTaskName::Backup,
interval: 10080,
last_execution: timestamp,
next_execution: timestamp,
src/network/sonarr_network.rs
+19 -1
View File
@@ -15,7 +15,7 @@ use crate::{
},
sonarr_models::{
BlocklistResponse, DownloadRecord, DownloadsResponse, Episode, IndexerSettings, Series,
SonarrHistoryItem, SonarrHistoryWrapper, SonarrSerdeable, SystemStatus,
SonarrHistoryItem, SonarrHistoryWrapper, SonarrSerdeable, SonarrTask, SystemStatus,
},
stateful_table::StatefulTable,
HorizontallyScrollableText, Route, Scrollable, ScrollableText,
@@ -60,6 +60,7 @@ pub enum SonarrEvent {
GetSeriesHistory(Option<i64>),
GetStatus,
GetTags,
GetTasks,
HealthCheck,
ListSeries,
MarkHistoryItemAsFailed(i64),
@@ -88,6 +89,7 @@ impl NetworkResource for SonarrEvent {
SonarrEvent::GetSeasonReleases(_) | SonarrEvent::GetEpisodeReleases(_) => "/release",
SonarrEvent::GetSeriesHistory(_) => "/history/series",
SonarrEvent::GetStatus => "/system/status",
SonarrEvent::GetTasks => "/system/task",
SonarrEvent::HealthCheck => "/health",
SonarrEvent::ListSeries | SonarrEvent::GetSeriesDetails(_) => "/series",
SonarrEvent::MarkHistoryItemAsFailed(_) => "/history/failed",
@@ -202,6 +204,7 @@ impl<'a, 'b> Network<'a, 'b> {
.map(SonarrSerdeable::from),
SonarrEvent::GetStatus => self.get_sonarr_status().await.map(SonarrSerdeable::from),
SonarrEvent::GetTags => self.get_sonarr_tags().await.map(SonarrSerdeable::from),
SonarrEvent::GetTasks => self.get_sonarr_tasks().await.map(SonarrSerdeable::from),
SonarrEvent::HealthCheck => self
.get_sonarr_healthcheck()
.await
@@ -1156,6 +1159,21 @@ impl<'a, 'b> Network<'a, 'b> {
.await
}
async fn get_sonarr_tasks(&mut self) -> Result<Vec<SonarrTask>> {
info!("Fetching Sonarr tasks");
let event = SonarrEvent::GetTasks;
let request_props = self
.request_props_from(event, RequestMethod::Get, None::<()>, None, None)
.await;
self
.handle_request::<(), Vec<SonarrTask>>(request_props, |tasks_vec, mut app| {
app.data.sonarr_data.tasks.set_items(tasks_vec);
})
.await
}
async fn mark_sonarr_history_item_as_failed(&mut self, history_item_id: i64) -> Result<Value> {
info!("Marking the Sonarr history item with ID: {history_item_id} as 'failed'");
let event = SonarrEvent::MarkHistoryItemAsFailed(history_item_id);
src/network/sonarr_network_tests.rs
+67 -1
View File
@@ -20,13 +20,14 @@ mod test {
DiskSpace, HostConfig, Indexer, IndexerField, Language, LogResponse, Quality, QualityProfile,
QualityWrapper, QueueEvent, Release, RootFolder, SecurityConfig, Tag,
};
use crate::models::sonarr_models::SystemStatus;
use crate::models::sonarr_models::{
BlocklistItem, DownloadRecord, DownloadsResponse, Episode, EpisodeFile, MediaInfo,
SonarrTaskName,
};
use crate::models::sonarr_models::{
BlocklistResponse, SonarrHistoryData, SonarrHistoryItem, SonarrHistoryWrapper,
};
use crate::models::sonarr_models::{SonarrTask, SystemStatus};
use crate::models::stateful_table::StatefulTable;
use crate::models::HorizontallyScrollableText;
use crate::models::{sonarr_models::SonarrSerdeable, stateful_table::SortOption};
@@ -217,6 +218,7 @@ mod test {
#[case(SonarrEvent::GetLogs(Some(500)), "/log")]
#[case(SonarrEvent::GetQualityProfiles, "/qualityprofile")]
#[case(SonarrEvent::GetStatus, "/system/status")]
#[case(SonarrEvent::GetTasks, "/system/task")]
#[case(SonarrEvent::MarkHistoryItemAsFailed(0), "/history/failed")]
fn test_resource(#[case] event: SonarrEvent, #[case] expected_uri: String) {
assert_str_eq!(event.resource(), expected_uri);
@@ -3675,6 +3677,70 @@ mod test {
}
}
#[tokio::test]
async fn test_handle_get_sonarr_tasks_event() {
let tasks_json = json!([{
"name": "Application Update Check",
"taskName": "ApplicationUpdateCheck",
"interval": 360,
"lastExecution": "2023-05-20T21:29:16Z",
"nextExecution": "2023-05-20T21:29:16Z",
"lastDuration": "00:00:00.5111547",
},
{
"name": "Backup",
"taskName": "Backup",
"interval": 10080,
"lastExecution": "2023-05-20T21:29:16Z",
"nextExecution": "2023-05-20T21:29:16Z",
"lastDuration": "00:00:00.5111547",
}]);
let response: Vec<SonarrTask> = serde_json::from_value(tasks_json.clone()).unwrap();
let timestamp = DateTime::from(DateTime::parse_from_rfc3339("2023-05-20T21:29:16Z").unwrap());
let expected_tasks = vec![
SonarrTask {
name: "Application Update Check".to_owned(),
task_name: SonarrTaskName::ApplicationUpdateCheck,
interval: 360,
last_execution: timestamp,
next_execution: timestamp,
last_duration: "00:00:00.5111547".to_owned(),
},
SonarrTask {
name: "Backup".to_owned(),
task_name: SonarrTaskName::Backup,
interval: 10080,
last_execution: timestamp,
next_execution: timestamp,
last_duration: "00:00:00.5111547".to_owned(),
},
];
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(tasks_json),
None,
SonarrEvent::GetTasks,
None,
None,
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
if let SonarrSerdeable::Tasks(tasks) = network
.handle_sonarr_event(SonarrEvent::GetTasks)
.await
.unwrap()
{
async_server.assert_async().await;
assert_eq!(
app_arc.lock().await.data.sonarr_data.tasks.items,
expected_tasks
);
assert_eq!(tasks, response);
}
}
#[tokio::test]
async fn test_handle_mark_sonarr_history_item_as_failed_event() {
let expected_history_item_id = 1;