refactor: Network module is now broken out into similar directory structures for each servarr to mimic the rest of the project to make it easier to develop and maintain
This commit is contained in:
@@ -0,0 +1,498 @@
|
||||
use crate::models::servarr_data::sonarr::modals::{EpisodeDetailsModal, SeasonDetailsModal};
|
||||
use crate::models::servarr_data::sonarr::sonarr_data::ActiveSonarrBlock;
|
||||
use crate::models::servarr_models::Language;
|
||||
use crate::models::sonarr_models::{
|
||||
DownloadRecord, DownloadStatus, Episode, EpisodeFile, MonitorEpisodeBody, SonarrCommandBody,
|
||||
SonarrHistoryWrapper, SonarrRelease,
|
||||
};
|
||||
use crate::models::{Route, ScrollableText};
|
||||
use crate::network::sonarr_network::SonarrEvent;
|
||||
use crate::network::{Network, RequestMethod};
|
||||
use crate::utils::convert_to_gb;
|
||||
use anyhow::Result;
|
||||
use indoc::formatdoc;
|
||||
use log::info;
|
||||
use serde_json::{Number, Value};
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "sonarr_episodes_network_tests.rs"]
|
||||
mod sonarr_episodes_network_tests;
|
||||
|
||||
impl Network<'_, '_> {
|
||||
pub(in crate::network::sonarr_network) async fn delete_sonarr_episode_file(
|
||||
&mut self,
|
||||
episode_file_id: i64,
|
||||
) -> Result<()> {
|
||||
let event = SonarrEvent::DeleteEpisodeFile(episode_file_id);
|
||||
info!("Deleting Sonarr episode file for episode file with id: {episode_file_id}");
|
||||
|
||||
let request_props = self
|
||||
.request_props_from(
|
||||
event,
|
||||
RequestMethod::Delete,
|
||||
None::<()>,
|
||||
Some(format!("/{episode_file_id}")),
|
||||
None,
|
||||
)
|
||||
.await;
|
||||
|
||||
self
|
||||
.handle_request::<(), ()>(request_props, |_, _| ())
|
||||
.await
|
||||
}
|
||||
|
||||
pub(in crate::network::sonarr_network) async fn get_episodes(
|
||||
&mut self,
|
||||
series_id: i64,
|
||||
) -> Result<Vec<Episode>> {
|
||||
let event = SonarrEvent::GetEpisodes(series_id);
|
||||
info!("Fetching episodes for Sonarr series with ID: {series_id}");
|
||||
|
||||
let request_props = self
|
||||
.request_props_from(
|
||||
event,
|
||||
RequestMethod::Get,
|
||||
None::<()>,
|
||||
None,
|
||||
Some(format!("seriesId={series_id}")),
|
||||
)
|
||||
.await;
|
||||
|
||||
self
|
||||
.handle_request::<(), Vec<Episode>>(request_props, |mut episode_vec, mut app| {
|
||||
episode_vec.sort_by(|a, b| a.id.cmp(&b.id));
|
||||
if !matches!(
|
||||
app.get_current_route(),
|
||||
Route::Sonarr(ActiveSonarrBlock::EpisodesSortPrompt, _)
|
||||
) {
|
||||
if app.data.sonarr_data.season_details_modal.is_none() {
|
||||
app.data.sonarr_data.season_details_modal = Some(SeasonDetailsModal::default());
|
||||
}
|
||||
|
||||
let season_episodes_vec = if !app.data.sonarr_data.seasons.is_empty() {
|
||||
let season_number = app
|
||||
.data
|
||||
.sonarr_data
|
||||
.seasons
|
||||
.current_selection()
|
||||
.season_number;
|
||||
|
||||
episode_vec
|
||||
.into_iter()
|
||||
.filter(|episode| episode.season_number == season_number)
|
||||
.collect()
|
||||
} else {
|
||||
episode_vec
|
||||
};
|
||||
|
||||
app
|
||||
.data
|
||||
.sonarr_data
|
||||
.season_details_modal
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.episodes
|
||||
.set_items(season_episodes_vec);
|
||||
app
|
||||
.data
|
||||
.sonarr_data
|
||||
.season_details_modal
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.episodes
|
||||
.apply_sorting_toggle(false);
|
||||
}
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
pub(in crate::network::sonarr_network) async fn get_episode_files(
|
||||
&mut self,
|
||||
series_id: i64,
|
||||
) -> Result<Vec<EpisodeFile>> {
|
||||
let event = SonarrEvent::GetEpisodeFiles(series_id);
|
||||
info!("Fetching episodes files for Sonarr series with ID: {series_id}");
|
||||
|
||||
let request_props = self
|
||||
.request_props_from(
|
||||
event,
|
||||
RequestMethod::Get,
|
||||
None::<()>,
|
||||
None,
|
||||
Some(format!("seriesId={series_id}")),
|
||||
)
|
||||
.await;
|
||||
|
||||
self
|
||||
.handle_request::<(), Vec<EpisodeFile>>(request_props, |episode_file_vec, mut app| {
|
||||
if app.data.sonarr_data.season_details_modal.is_none() {
|
||||
app.data.sonarr_data.season_details_modal = Some(SeasonDetailsModal::default());
|
||||
}
|
||||
|
||||
app
|
||||
.data
|
||||
.sonarr_data
|
||||
.season_details_modal
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.episode_files
|
||||
.set_items(episode_file_vec);
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
pub(in crate::network::sonarr_network) async fn get_sonarr_episode_history(
|
||||
&mut self,
|
||||
episode_id: i64,
|
||||
) -> Result<SonarrHistoryWrapper> {
|
||||
info!("Fetching Sonarr history for episode with ID: {episode_id}");
|
||||
let event = SonarrEvent::GetEpisodeHistory(episode_id);
|
||||
|
||||
let params =
|
||||
format!("episodeId={episode_id}&pageSize=1000&sortDirection=descending&sortKey=date");
|
||||
let request_props = self
|
||||
.request_props_from(event, RequestMethod::Get, None::<()>, None, Some(params))
|
||||
.await;
|
||||
|
||||
self
|
||||
.handle_request::<(), SonarrHistoryWrapper>(request_props, |history_response, mut app| {
|
||||
if app.data.sonarr_data.season_details_modal.is_none() {
|
||||
app.data.sonarr_data.season_details_modal = Some(SeasonDetailsModal::default());
|
||||
}
|
||||
|
||||
if app
|
||||
.data
|
||||
.sonarr_data
|
||||
.season_details_modal
|
||||
.as_ref()
|
||||
.unwrap()
|
||||
.episode_details_modal
|
||||
.is_none()
|
||||
{
|
||||
app
|
||||
.data
|
||||
.sonarr_data
|
||||
.season_details_modal
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.episode_details_modal = Some(EpisodeDetailsModal::default());
|
||||
}
|
||||
|
||||
let mut history_vec = history_response.records;
|
||||
history_vec.sort_by(|a, b| a.id.cmp(&b.id));
|
||||
app
|
||||
.data
|
||||
.sonarr_data
|
||||
.season_details_modal
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.episode_details_modal
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.episode_history
|
||||
.set_items(history_vec);
|
||||
app
|
||||
.data
|
||||
.sonarr_data
|
||||
.season_details_modal
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.episode_details_modal
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.episode_history
|
||||
.apply_sorting_toggle(false);
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
pub(in crate::network::sonarr_network) async fn get_episode_details(
|
||||
&mut self,
|
||||
episode_id: i64,
|
||||
) -> Result<Episode> {
|
||||
info!("Fetching Sonarr episode details");
|
||||
let event = SonarrEvent::GetEpisodeDetails(episode_id);
|
||||
|
||||
info!("Fetching episode details for episode with ID: {episode_id}");
|
||||
|
||||
let request_props = self
|
||||
.request_props_from(
|
||||
event,
|
||||
RequestMethod::Get,
|
||||
None::<()>,
|
||||
Some(format!("/{episode_id}")),
|
||||
None,
|
||||
)
|
||||
.await;
|
||||
|
||||
self
|
||||
.handle_request::<(), Episode>(request_props, |episode_response, mut app| {
|
||||
if app.cli_mode {
|
||||
app.data.sonarr_data.season_details_modal = Some(SeasonDetailsModal::default());
|
||||
}
|
||||
|
||||
if app
|
||||
.data
|
||||
.sonarr_data
|
||||
.season_details_modal
|
||||
.as_mut()
|
||||
.expect("Season details modal is empty")
|
||||
.episode_details_modal
|
||||
.is_none()
|
||||
{
|
||||
app
|
||||
.data
|
||||
.sonarr_data
|
||||
.season_details_modal
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.episode_details_modal = Some(EpisodeDetailsModal::default());
|
||||
}
|
||||
|
||||
let Episode {
|
||||
id,
|
||||
title,
|
||||
air_date_utc,
|
||||
overview,
|
||||
has_file,
|
||||
season_number,
|
||||
episode_number,
|
||||
episode_file,
|
||||
..
|
||||
} = episode_response;
|
||||
let status = get_episode_status(has_file, &app.data.sonarr_data.downloads.items, id);
|
||||
let air_date = if let Some(air_date) = air_date_utc {
|
||||
format!("{air_date}")
|
||||
} else {
|
||||
String::new()
|
||||
};
|
||||
let episode_details_modal = app
|
||||
.data
|
||||
.sonarr_data
|
||||
.season_details_modal
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.episode_details_modal
|
||||
.as_mut()
|
||||
.unwrap();
|
||||
episode_details_modal.episode_details = ScrollableText::with_string(formatdoc!(
|
||||
"
|
||||
Title: {}
|
||||
Season: {season_number}
|
||||
Episode Number: {episode_number}
|
||||
Air Date: {air_date}
|
||||
Status: {status}
|
||||
Description: {}",
|
||||
title,
|
||||
overview.unwrap_or_default(),
|
||||
));
|
||||
if let Some(file) = episode_file {
|
||||
let size = convert_to_gb(file.size);
|
||||
episode_details_modal.file_details = formatdoc!(
|
||||
"
|
||||
Relative Path: {}
|
||||
Absolute Path: {}
|
||||
Size: {size:.2} GB
|
||||
Language: {}
|
||||
Date Added: {}",
|
||||
file.relative_path,
|
||||
file.path,
|
||||
file.languages.first().unwrap_or(&Language::default()).name,
|
||||
file.date_added,
|
||||
);
|
||||
|
||||
if let Some(media_info) = file.media_info {
|
||||
episode_details_modal.audio_details = formatdoc!(
|
||||
"
|
||||
Bitrate: {}
|
||||
Channels: {:.1}
|
||||
Codec: {}
|
||||
Languages: {}
|
||||
Stream Count: {}",
|
||||
media_info.audio_bitrate,
|
||||
media_info.audio_channels.as_f64().unwrap(),
|
||||
media_info.audio_codec.unwrap_or_default(),
|
||||
media_info.audio_languages.unwrap_or_default(),
|
||||
media_info.audio_stream_count
|
||||
);
|
||||
|
||||
episode_details_modal.video_details = formatdoc!(
|
||||
"
|
||||
Bit Depth: {}
|
||||
Bitrate: {}
|
||||
Codec: {}
|
||||
FPS: {}
|
||||
Resolution: {}
|
||||
Scan Type: {}
|
||||
Runtime: {}
|
||||
Subtitles: {}",
|
||||
media_info.video_bit_depth,
|
||||
media_info.video_bitrate,
|
||||
media_info.video_codec.unwrap_or_default(),
|
||||
media_info.video_fps.as_f64().unwrap(),
|
||||
media_info.resolution,
|
||||
media_info.scan_type,
|
||||
media_info.run_time,
|
||||
media_info.subtitles.unwrap_or_default()
|
||||
);
|
||||
}
|
||||
};
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
pub(in crate::network::sonarr_network) async fn get_episode_releases(
|
||||
&mut self,
|
||||
episode_id: i64,
|
||||
) -> Result<Vec<SonarrRelease>> {
|
||||
let event = SonarrEvent::GetEpisodeReleases(episode_id);
|
||||
info!("Fetching releases for episode with ID: {episode_id}");
|
||||
|
||||
let request_props = self
|
||||
.request_props_from(
|
||||
event,
|
||||
RequestMethod::Get,
|
||||
None::<()>,
|
||||
None,
|
||||
Some(format!("episodeId={episode_id}")),
|
||||
)
|
||||
.await;
|
||||
|
||||
self
|
||||
.handle_request::<(), Vec<SonarrRelease>>(request_props, |release_vec, mut app| {
|
||||
if app.data.sonarr_data.season_details_modal.is_none() {
|
||||
app.data.sonarr_data.season_details_modal = Some(SeasonDetailsModal::default());
|
||||
}
|
||||
|
||||
if app
|
||||
.data
|
||||
.sonarr_data
|
||||
.season_details_modal
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.episode_details_modal
|
||||
.is_none()
|
||||
{
|
||||
app
|
||||
.data
|
||||
.sonarr_data
|
||||
.season_details_modal
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.episode_details_modal = Some(EpisodeDetailsModal::default());
|
||||
}
|
||||
|
||||
app
|
||||
.data
|
||||
.sonarr_data
|
||||
.season_details_modal
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.episode_details_modal
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.episode_releases
|
||||
.set_items(release_vec);
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
pub(in crate::network::sonarr_network) async fn toggle_sonarr_episode_monitoring(
|
||||
&mut self,
|
||||
episode_id: i64,
|
||||
) -> Result<()> {
|
||||
let event = SonarrEvent::ToggleEpisodeMonitoring(episode_id);
|
||||
let detail_event = SonarrEvent::GetEpisodeDetails(0);
|
||||
|
||||
let monitored = {
|
||||
info!("Fetching episode details for episode id: {episode_id}");
|
||||
let request_props = self
|
||||
.request_props_from(
|
||||
detail_event,
|
||||
RequestMethod::Get,
|
||||
None::<()>,
|
||||
Some(format!("/{episode_id}")),
|
||||
None,
|
||||
)
|
||||
.await;
|
||||
|
||||
let mut monitored = false;
|
||||
|
||||
self
|
||||
.handle_request::<(), Value>(request_props, |detailed_episode_body, _| {
|
||||
monitored = detailed_episode_body
|
||||
.get("monitored")
|
||||
.unwrap()
|
||||
.as_bool()
|
||||
.unwrap();
|
||||
})
|
||||
.await?;
|
||||
|
||||
monitored
|
||||
};
|
||||
|
||||
info!("Toggling monitoring for episode id: {episode_id}");
|
||||
|
||||
let body = MonitorEpisodeBody {
|
||||
episode_ids: vec![episode_id],
|
||||
monitored: !monitored,
|
||||
};
|
||||
|
||||
let request_props = self
|
||||
.request_props_from(event, RequestMethod::Put, Some(body), None, None)
|
||||
.await;
|
||||
|
||||
self
|
||||
.handle_request::<MonitorEpisodeBody, ()>(request_props, |_, _| ())
|
||||
.await
|
||||
}
|
||||
|
||||
pub(in crate::network::sonarr_network) async fn trigger_automatic_episode_search(
|
||||
&mut self,
|
||||
episode_id: i64,
|
||||
) -> Result<Value> {
|
||||
let event = SonarrEvent::TriggerAutomaticEpisodeSearch(episode_id);
|
||||
info!("Searching indexers for episode with ID: {episode_id}");
|
||||
|
||||
let body = SonarrCommandBody {
|
||||
name: "EpisodeSearch".to_owned(),
|
||||
episode_ids: Some(vec![episode_id]),
|
||||
..SonarrCommandBody::default()
|
||||
};
|
||||
|
||||
let request_props = self
|
||||
.request_props_from(event, RequestMethod::Post, Some(body), None, None)
|
||||
.await;
|
||||
|
||||
self
|
||||
.handle_request::<SonarrCommandBody, Value>(request_props, |_, _| ())
|
||||
.await
|
||||
}
|
||||
}
|
||||
|
||||
fn get_episode_status(has_file: bool, downloads_vec: &[DownloadRecord], episode_id: i64) -> String {
|
||||
if !has_file {
|
||||
let default_episode_id = Number::from(-1i64);
|
||||
if let Some(download) = downloads_vec.iter().find(|&download| {
|
||||
download
|
||||
.episode_id
|
||||
.as_ref()
|
||||
.unwrap_or(&default_episode_id)
|
||||
.as_i64()
|
||||
.unwrap()
|
||||
== episode_id
|
||||
}) {
|
||||
if download.status == DownloadStatus::Downloading {
|
||||
return "Downloading".to_owned();
|
||||
}
|
||||
|
||||
if download.status == DownloadStatus::Completed {
|
||||
return "Awaiting Import".to_owned();
|
||||
}
|
||||
}
|
||||
|
||||
return "Missing".to_owned();
|
||||
}
|
||||
|
||||
"Downloaded".to_owned()
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,38 @@
|
||||
use crate::models::sonarr_models::SonarrReleaseDownloadBody;
|
||||
use crate::network::sonarr_network::SonarrEvent;
|
||||
use crate::network::{Network, RequestMethod};
|
||||
use anyhow::Result;
|
||||
use log::info;
|
||||
use serde_json::Value;
|
||||
|
||||
mod episodes;
|
||||
mod seasons;
|
||||
mod series;
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "sonarr_library_network_tests.rs"]
|
||||
mod sonarr_library_network_tests;
|
||||
|
||||
impl Network<'_, '_> {
|
||||
pub(in crate::network::sonarr_network) async fn download_sonarr_release(
|
||||
&mut self,
|
||||
sonarr_release_download_body: SonarrReleaseDownloadBody,
|
||||
) -> Result<Value> {
|
||||
let event = SonarrEvent::DownloadRelease(SonarrReleaseDownloadBody::default());
|
||||
info!("Downloading Sonarr release with params: {sonarr_release_download_body:?}");
|
||||
|
||||
let request_props = self
|
||||
.request_props_from(
|
||||
event,
|
||||
RequestMethod::Post,
|
||||
Some(sonarr_release_download_body),
|
||||
None,
|
||||
None,
|
||||
)
|
||||
.await;
|
||||
|
||||
self
|
||||
.handle_request::<SonarrReleaseDownloadBody, Value>(request_props, |_, _| ())
|
||||
.await
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,199 @@
|
||||
use crate::models::servarr_data::sonarr::modals::SeasonDetailsModal;
|
||||
use crate::models::sonarr_models::{SonarrCommandBody, SonarrHistoryItem, SonarrRelease};
|
||||
use crate::network::sonarr_network::SonarrEvent;
|
||||
use crate::network::{Network, RequestMethod};
|
||||
use anyhow::Result;
|
||||
use log::{debug, info, warn};
|
||||
use serde_json::{json, Value};
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "sonarr_seasons_network_tests.rs"]
|
||||
mod sonarr_seasons_network_tests;
|
||||
|
||||
impl Network<'_, '_> {
|
||||
pub(in crate::network::sonarr_network) async fn toggle_sonarr_season_monitoring(
|
||||
&mut self,
|
||||
series_id_season_number_tuple: (i64, i64),
|
||||
) -> Result<()> {
|
||||
let event = SonarrEvent::ToggleSeasonMonitoring(series_id_season_number_tuple);
|
||||
let (series_id, season_number) = series_id_season_number_tuple;
|
||||
|
||||
let detail_event = SonarrEvent::GetSeriesDetails(series_id);
|
||||
info!("Toggling season monitoring for season {season_number} in series with ID: {series_id}");
|
||||
info!("Fetching series details for series with ID: {series_id}");
|
||||
|
||||
let request_props = self
|
||||
.request_props_from(
|
||||
detail_event,
|
||||
RequestMethod::Get,
|
||||
None::<()>,
|
||||
Some(format!("/{series_id}")),
|
||||
None,
|
||||
)
|
||||
.await;
|
||||
|
||||
let mut response = String::new();
|
||||
|
||||
self
|
||||
.handle_request::<(), Value>(request_props, |detailed_series_body, _| {
|
||||
response = detailed_series_body.to_string()
|
||||
})
|
||||
.await?;
|
||||
|
||||
info!("Constructing toggle season monitoring body");
|
||||
|
||||
match serde_json::from_str::<Value>(&response) {
|
||||
Ok(mut detailed_series_body) => {
|
||||
let monitored = detailed_series_body
|
||||
.get("seasons")
|
||||
.unwrap()
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.find(|season| season["seasonNumber"] == season_number)
|
||||
.unwrap()
|
||||
.get("monitored")
|
||||
.unwrap()
|
||||
.as_bool()
|
||||
.unwrap();
|
||||
|
||||
*detailed_series_body
|
||||
.get_mut("seasons")
|
||||
.unwrap()
|
||||
.as_array_mut()
|
||||
.unwrap()
|
||||
.iter_mut()
|
||||
.find(|season| season["seasonNumber"] == season_number)
|
||||
.unwrap()
|
||||
.get_mut("monitored")
|
||||
.unwrap() = json!(!monitored);
|
||||
|
||||
debug!("Toggle season monitoring body: {detailed_series_body:?}");
|
||||
|
||||
let request_props = self
|
||||
.request_props_from(
|
||||
event,
|
||||
RequestMethod::Put,
|
||||
Some(detailed_series_body),
|
||||
Some(format!("/{series_id}")),
|
||||
None,
|
||||
)
|
||||
.await;
|
||||
|
||||
self
|
||||
.handle_request::<Value, ()>(request_props, |_, _| ())
|
||||
.await
|
||||
}
|
||||
Err(_) => {
|
||||
warn!("Request for detailed series body was interrupted");
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(in crate::network::sonarr_network) async fn get_season_releases(
|
||||
&mut self,
|
||||
series_season_id_tuple: (i64, i64),
|
||||
) -> Result<Vec<SonarrRelease>> {
|
||||
let event = SonarrEvent::GetSeasonReleases(series_season_id_tuple);
|
||||
let (series_id, season_number) = series_season_id_tuple;
|
||||
info!("Fetching releases for series with ID: {series_id} and season number: {season_number}");
|
||||
|
||||
let request_props = self
|
||||
.request_props_from(
|
||||
event,
|
||||
RequestMethod::Get,
|
||||
None::<()>,
|
||||
None,
|
||||
Some(format!("seriesId={series_id}&seasonNumber={season_number}")),
|
||||
)
|
||||
.await;
|
||||
|
||||
self
|
||||
.handle_request::<(), Vec<SonarrRelease>>(request_props, |release_vec, mut app| {
|
||||
if app.data.sonarr_data.season_details_modal.is_none() {
|
||||
app.data.sonarr_data.season_details_modal = Some(SeasonDetailsModal::default());
|
||||
}
|
||||
|
||||
let season_releases_vec = release_vec
|
||||
.into_iter()
|
||||
.filter(|release| release.full_season)
|
||||
.collect();
|
||||
|
||||
app
|
||||
.data
|
||||
.sonarr_data
|
||||
.season_details_modal
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.season_releases
|
||||
.set_items(season_releases_vec);
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
pub(in crate::network::sonarr_network) async fn get_sonarr_season_history(
|
||||
&mut self,
|
||||
series_season_id_tuple: (i64, i64),
|
||||
) -> Result<Vec<SonarrHistoryItem>> {
|
||||
let event = SonarrEvent::GetSeasonHistory(series_season_id_tuple);
|
||||
let (series_id, season_number) = series_season_id_tuple;
|
||||
info!("Fetching history for series with ID: {series_id} and season number: {season_number}");
|
||||
|
||||
let params = format!("seriesId={series_id}&seasonNumber={season_number}",);
|
||||
let request_props = self
|
||||
.request_props_from(event, RequestMethod::Get, None::<()>, None, Some(params))
|
||||
.await;
|
||||
|
||||
self
|
||||
.handle_request::<(), Vec<SonarrHistoryItem>>(request_props, |history_items, mut app| {
|
||||
if app.data.sonarr_data.season_details_modal.is_none() {
|
||||
app.data.sonarr_data.season_details_modal = Some(SeasonDetailsModal::default());
|
||||
}
|
||||
|
||||
let mut history_vec = history_items;
|
||||
history_vec.sort_by(|a, b| a.id.cmp(&b.id));
|
||||
app
|
||||
.data
|
||||
.sonarr_data
|
||||
.season_details_modal
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.season_history
|
||||
.set_items(history_vec);
|
||||
app
|
||||
.data
|
||||
.sonarr_data
|
||||
.season_details_modal
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.season_history
|
||||
.apply_sorting_toggle(false);
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
pub(in crate::network::sonarr_network) async fn trigger_automatic_season_search(
|
||||
&mut self,
|
||||
series_season_id_tuple: (i64, i64),
|
||||
) -> Result<Value> {
|
||||
let event = SonarrEvent::TriggerAutomaticSeasonSearch(series_season_id_tuple);
|
||||
let (series_id, season_number) = series_season_id_tuple;
|
||||
info!("Searching indexers for series with ID: {series_id} and season number: {season_number}");
|
||||
|
||||
let body = SonarrCommandBody {
|
||||
name: "SeasonSearch".to_owned(),
|
||||
season_number: Some(season_number),
|
||||
series_id: Some(series_id),
|
||||
..SonarrCommandBody::default()
|
||||
};
|
||||
|
||||
let request_props = self
|
||||
.request_props_from(event, RequestMethod::Post, Some(body), None, None)
|
||||
.await;
|
||||
|
||||
self
|
||||
.handle_request::<SonarrCommandBody, Value>(request_props, |_, _| ())
|
||||
.await
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,515 @@
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use crate::models::servarr_data::sonarr::modals::SeasonDetailsModal;
|
||||
use crate::models::sonarr_models::{SonarrHistoryItem, SonarrRelease, SonarrSerdeable};
|
||||
use crate::network::network_tests::test_utils::mock_servarr_api;
|
||||
use crate::network::sonarr_network::sonarr_network_test_utils::test_utils::{
|
||||
history_item, release, season, series, SERIES_JSON,
|
||||
};
|
||||
use crate::network::sonarr_network::SonarrEvent;
|
||||
use crate::network::{Network, NetworkResource, RequestMethod};
|
||||
use mockito::Matcher;
|
||||
use pretty_assertions::assert_eq;
|
||||
use reqwest::Client;
|
||||
use serde_json::{json, Value};
|
||||
use tokio_util::sync::CancellationToken;
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_handle_toggle_season_monitoring_event() {
|
||||
let mut expected_body: Value = serde_json::from_str(SERIES_JSON).unwrap();
|
||||
*expected_body
|
||||
.get_mut("seasons")
|
||||
.unwrap()
|
||||
.as_array_mut()
|
||||
.unwrap()
|
||||
.iter_mut()
|
||||
.find(|season| season["seasonNumber"] == 1)
|
||||
.unwrap()
|
||||
.get_mut("monitored")
|
||||
.unwrap() = json!(false);
|
||||
|
||||
let (async_details_server, app_arc, mut server) = mock_servarr_api(
|
||||
RequestMethod::Get,
|
||||
None,
|
||||
Some(serde_json::from_str(SERIES_JSON).unwrap()),
|
||||
None,
|
||||
SonarrEvent::GetSeriesDetails(1),
|
||||
Some("/1"),
|
||||
None,
|
||||
)
|
||||
.await;
|
||||
let async_toggle_server = server
|
||||
.mock(
|
||||
"PUT",
|
||||
format!(
|
||||
"/api/v3{}/1",
|
||||
SonarrEvent::ToggleSeasonMonitoring((1, 1)).resource()
|
||||
)
|
||||
.as_str(),
|
||||
)
|
||||
.with_status(202)
|
||||
.match_header("X-Api-Key", "test1234")
|
||||
.match_body(Matcher::Json(expected_body))
|
||||
.create_async()
|
||||
.await;
|
||||
{
|
||||
let mut app = app_arc.lock().await;
|
||||
app.data.sonarr_data.series.set_items(vec![series()]);
|
||||
app.data.sonarr_data.seasons.set_items(vec![season()]);
|
||||
}
|
||||
app_arc.lock().await.server_tabs.next();
|
||||
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
|
||||
|
||||
assert!(network
|
||||
.handle_sonarr_event(SonarrEvent::ToggleSeasonMonitoring((1, 1)))
|
||||
.await
|
||||
.is_ok());
|
||||
|
||||
async_details_server.assert_async().await;
|
||||
async_toggle_server.assert_async().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_handle_get_season_releases_event() {
|
||||
let release_json = json!([
|
||||
{
|
||||
"guid": "1234",
|
||||
"protocol": "torrent",
|
||||
"age": 1,
|
||||
"title": "Test Release",
|
||||
"indexer": "kickass torrents",
|
||||
"indexerId": 2,
|
||||
"size": 1234,
|
||||
"rejected": true,
|
||||
"rejections": [ "Unknown quality profile", "Release is already mapped" ],
|
||||
"seeders": 2,
|
||||
"leechers": 1,
|
||||
"languages": [ { "id": 1, "name": "English" } ],
|
||||
"quality": { "quality": { "name": "Bluray-1080p" }},
|
||||
"fullSeason": true
|
||||
},
|
||||
{
|
||||
"guid": "4567",
|
||||
"protocol": "torrent",
|
||||
"age": 1,
|
||||
"title": "Test Release",
|
||||
"indexer": "kickass torrents",
|
||||
"indexerId": 2,
|
||||
"size": 1234,
|
||||
"rejected": true,
|
||||
"rejections": [ "Unknown quality profile", "Release is already mapped" ],
|
||||
"seeders": 2,
|
||||
"leechers": 1,
|
||||
"languages": [ { "id": 1, "name": "English" } ],
|
||||
"quality": { "quality": { "name": "Bluray-1080p" }},
|
||||
}
|
||||
]);
|
||||
let expected_filtered_sonarr_release = SonarrRelease {
|
||||
full_season: true,
|
||||
..release()
|
||||
};
|
||||
let expected_raw_sonarr_releases = vec![
|
||||
SonarrRelease {
|
||||
full_season: true,
|
||||
..release()
|
||||
},
|
||||
SonarrRelease {
|
||||
guid: "4567".to_owned(),
|
||||
..release()
|
||||
},
|
||||
];
|
||||
let (async_server, app_arc, _server) = mock_servarr_api(
|
||||
RequestMethod::Get,
|
||||
None,
|
||||
Some(release_json),
|
||||
None,
|
||||
SonarrEvent::GetSeasonReleases((1, 1)),
|
||||
None,
|
||||
Some("seriesId=1&seasonNumber=1"),
|
||||
)
|
||||
.await;
|
||||
app_arc
|
||||
.lock()
|
||||
.await
|
||||
.data
|
||||
.sonarr_data
|
||||
.series
|
||||
.set_items(vec![series()]);
|
||||
app_arc
|
||||
.lock()
|
||||
.await
|
||||
.data
|
||||
.sonarr_data
|
||||
.seasons
|
||||
.set_items(vec![season()]);
|
||||
app_arc.lock().await.data.sonarr_data.season_details_modal =
|
||||
Some(SeasonDetailsModal::default());
|
||||
app_arc.lock().await.server_tabs.next();
|
||||
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
|
||||
|
||||
if let SonarrSerdeable::Releases(releases_vec) = network
|
||||
.handle_sonarr_event(SonarrEvent::GetSeasonReleases((1, 1)))
|
||||
.await
|
||||
.unwrap()
|
||||
{
|
||||
async_server.assert_async().await;
|
||||
assert_eq!(
|
||||
app_arc
|
||||
.lock()
|
||||
.await
|
||||
.data
|
||||
.sonarr_data
|
||||
.season_details_modal
|
||||
.as_ref()
|
||||
.unwrap()
|
||||
.season_releases
|
||||
.items,
|
||||
vec![expected_filtered_sonarr_release]
|
||||
);
|
||||
assert_eq!(releases_vec, expected_raw_sonarr_releases);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_handle_get_season_releases_event_empty_season_details_modal() {
|
||||
let release_json = json!([
|
||||
{
|
||||
"guid": "1234",
|
||||
"protocol": "torrent",
|
||||
"age": 1,
|
||||
"title": "Test Release",
|
||||
"indexer": "kickass torrents",
|
||||
"indexerId": 2,
|
||||
"size": 1234,
|
||||
"rejected": true,
|
||||
"rejections": [ "Unknown quality profile", "Release is already mapped" ],
|
||||
"seeders": 2,
|
||||
"leechers": 1,
|
||||
"languages": [ { "id": 1, "name": "English" } ],
|
||||
"quality": { "quality": { "name": "Bluray-1080p" }},
|
||||
"fullSeason": true
|
||||
},
|
||||
{
|
||||
"guid": "4567",
|
||||
"protocol": "usenet",
|
||||
"age": 1,
|
||||
"title": "Test Release",
|
||||
"indexer": "kickass torrents",
|
||||
"indexerId": 2,
|
||||
"size": 1234,
|
||||
"rejected": true,
|
||||
"rejections": [ "Unknown quality profile", "Release is already mapped" ],
|
||||
"seeders": 2,
|
||||
"leechers": 1,
|
||||
"languages": [ { "id": 1, "name": "English" } ],
|
||||
"quality": { "quality": { "name": "Bluray-1080p" }},
|
||||
}
|
||||
]);
|
||||
let expected_sonarr_release = SonarrRelease {
|
||||
full_season: true,
|
||||
..release()
|
||||
};
|
||||
let (async_server, app_arc, _server) = mock_servarr_api(
|
||||
RequestMethod::Get,
|
||||
None,
|
||||
Some(release_json),
|
||||
None,
|
||||
SonarrEvent::GetSeasonReleases((1, 1)),
|
||||
None,
|
||||
Some("seriesId=1&seasonNumber=1"),
|
||||
)
|
||||
.await;
|
||||
app_arc
|
||||
.lock()
|
||||
.await
|
||||
.data
|
||||
.sonarr_data
|
||||
.series
|
||||
.set_items(vec![series()]);
|
||||
app_arc
|
||||
.lock()
|
||||
.await
|
||||
.data
|
||||
.sonarr_data
|
||||
.seasons
|
||||
.set_items(vec![season()]);
|
||||
app_arc.lock().await.server_tabs.next();
|
||||
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
|
||||
|
||||
assert!(network
|
||||
.handle_sonarr_event(SonarrEvent::GetSeasonReleases((1, 1)))
|
||||
.await
|
||||
.is_ok());
|
||||
|
||||
async_server.assert_async().await;
|
||||
assert_eq!(
|
||||
app_arc
|
||||
.lock()
|
||||
.await
|
||||
.data
|
||||
.sonarr_data
|
||||
.season_details_modal
|
||||
.as_ref()
|
||||
.unwrap()
|
||||
.season_releases
|
||||
.items,
|
||||
vec![expected_sonarr_release]
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_handle_get_sonarr_season_history_event() {
|
||||
let history_json = json!([{
|
||||
"id": 123,
|
||||
"sourceTitle": "z episode",
|
||||
"episodeId": 1007,
|
||||
"quality": { "quality": { "name": "Bluray-1080p" } },
|
||||
"languages": [{ "id": 1, "name": "English" }],
|
||||
"date": "2024-02-10T07:28:45Z",
|
||||
"eventType": "grabbed",
|
||||
"data": {
|
||||
"droppedPath": "/nfs/nzbget/completed/series/Coolness/something.cool.mkv",
|
||||
"importedPath": "/nfs/tv/Coolness/Season 1/Coolness - S01E01 - Something Cool Bluray-1080p.mkv"
|
||||
}
|
||||
},
|
||||
{
|
||||
"id": 456,
|
||||
"sourceTitle": "A Episode",
|
||||
"episodeId": 2001,
|
||||
"quality": { "quality": { "name": "Bluray-1080p" } },
|
||||
"languages": [{ "id": 1, "name": "English" }],
|
||||
"date": "2024-02-10T07:28:45Z",
|
||||
"eventType": "grabbed",
|
||||
"data": {
|
||||
"droppedPath": "/nfs/nzbget/completed/series/Coolness/something.cool.mkv",
|
||||
"importedPath": "/nfs/tv/Coolness/Season 1/Coolness - S01E01 - Something Cool Bluray-1080p.mkv"
|
||||
}
|
||||
}]);
|
||||
let response: Vec<SonarrHistoryItem> = serde_json::from_value(history_json.clone()).unwrap();
|
||||
let expected_history_items = vec![
|
||||
SonarrHistoryItem {
|
||||
id: 123,
|
||||
episode_id: 1007,
|
||||
source_title: "z episode".into(),
|
||||
..history_item()
|
||||
},
|
||||
SonarrHistoryItem {
|
||||
id: 456,
|
||||
episode_id: 2001,
|
||||
source_title: "A Episode".into(),
|
||||
..history_item()
|
||||
},
|
||||
];
|
||||
let (async_server, app_arc, _server) = mock_servarr_api(
|
||||
RequestMethod::Get,
|
||||
None,
|
||||
Some(history_json),
|
||||
None,
|
||||
SonarrEvent::GetSeasonHistory((1, 1)),
|
||||
None,
|
||||
Some("seriesId=1&seasonNumber=1"),
|
||||
)
|
||||
.await;
|
||||
app_arc.lock().await.data.sonarr_data.season_details_modal =
|
||||
Some(SeasonDetailsModal::default());
|
||||
app_arc
|
||||
.lock()
|
||||
.await
|
||||
.data
|
||||
.sonarr_data
|
||||
.series
|
||||
.set_items(vec![series()]);
|
||||
app_arc
|
||||
.lock()
|
||||
.await
|
||||
.data
|
||||
.sonarr_data
|
||||
.seasons
|
||||
.set_items(vec![season()]);
|
||||
app_arc
|
||||
.lock()
|
||||
.await
|
||||
.data
|
||||
.sonarr_data
|
||||
.season_details_modal
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.season_history
|
||||
.sort_asc = true;
|
||||
app_arc.lock().await.server_tabs.next();
|
||||
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
|
||||
|
||||
if let SonarrSerdeable::SonarrHistoryItems(history) = network
|
||||
.handle_sonarr_event(SonarrEvent::GetSeasonHistory((1, 1)))
|
||||
.await
|
||||
.unwrap()
|
||||
{
|
||||
async_server.assert_async().await;
|
||||
assert_eq!(
|
||||
app_arc
|
||||
.lock()
|
||||
.await
|
||||
.data
|
||||
.sonarr_data
|
||||
.season_details_modal
|
||||
.as_ref()
|
||||
.unwrap()
|
||||
.season_history
|
||||
.items,
|
||||
expected_history_items
|
||||
);
|
||||
assert!(
|
||||
app_arc
|
||||
.lock()
|
||||
.await
|
||||
.data
|
||||
.sonarr_data
|
||||
.season_details_modal
|
||||
.as_ref()
|
||||
.unwrap()
|
||||
.season_history
|
||||
.sort_asc
|
||||
);
|
||||
assert_eq!(history, response);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_handle_get_sonarr_season_history_event_empty_season_details_modal() {
|
||||
let history_json = json!([{
|
||||
"id": 123,
|
||||
"sourceTitle": "z episode",
|
||||
"episodeId": 1007,
|
||||
"quality": { "quality": { "name": "Bluray-1080p" } },
|
||||
"languages": [{ "id": 1, "name": "English" }],
|
||||
"date": "2024-02-10T07:28:45Z",
|
||||
"eventType": "grabbed",
|
||||
"data": {
|
||||
"droppedPath": "/nfs/nzbget/completed/series/Coolness/something.cool.mkv",
|
||||
"importedPath": "/nfs/tv/Coolness/Season 1/Coolness - S01E01 - Something Cool Bluray-1080p.mkv"
|
||||
}
|
||||
},
|
||||
{
|
||||
"id": 456,
|
||||
"sourceTitle": "A Episode",
|
||||
"episodeId": 2001,
|
||||
"quality": { "quality": { "name": "Bluray-1080p" } },
|
||||
"languages": [{ "id": 1, "name": "English" }],
|
||||
"date": "2024-02-10T07:28:45Z",
|
||||
"eventType": "grabbed",
|
||||
"data": {
|
||||
"droppedPath": "/nfs/nzbget/completed/series/Coolness/something.cool.mkv",
|
||||
"importedPath": "/nfs/tv/Coolness/Season 1/Coolness - S01E01 - Something Cool Bluray-1080p.mkv"
|
||||
}
|
||||
}]);
|
||||
let response: Vec<SonarrHistoryItem> = serde_json::from_value(history_json.clone()).unwrap();
|
||||
let expected_history_items = vec![
|
||||
SonarrHistoryItem {
|
||||
id: 123,
|
||||
episode_id: 1007,
|
||||
source_title: "z episode".into(),
|
||||
..history_item()
|
||||
},
|
||||
SonarrHistoryItem {
|
||||
id: 456,
|
||||
episode_id: 2001,
|
||||
source_title: "A Episode".into(),
|
||||
..history_item()
|
||||
},
|
||||
];
|
||||
let (async_server, app_arc, _server) = mock_servarr_api(
|
||||
RequestMethod::Get,
|
||||
None,
|
||||
Some(history_json),
|
||||
None,
|
||||
SonarrEvent::GetSeasonHistory((1, 1)),
|
||||
None,
|
||||
Some("seriesId=1&seasonNumber=1"),
|
||||
)
|
||||
.await;
|
||||
app_arc
|
||||
.lock()
|
||||
.await
|
||||
.data
|
||||
.sonarr_data
|
||||
.series
|
||||
.set_items(vec![series()]);
|
||||
app_arc
|
||||
.lock()
|
||||
.await
|
||||
.data
|
||||
.sonarr_data
|
||||
.seasons
|
||||
.set_items(vec![season()]);
|
||||
app_arc.lock().await.server_tabs.next();
|
||||
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
|
||||
|
||||
if let SonarrSerdeable::SonarrHistoryItems(history) = network
|
||||
.handle_sonarr_event(SonarrEvent::GetSeasonHistory((1, 1)))
|
||||
.await
|
||||
.unwrap()
|
||||
{
|
||||
async_server.assert_async().await;
|
||||
assert!(app_arc
|
||||
.lock()
|
||||
.await
|
||||
.data
|
||||
.sonarr_data
|
||||
.season_details_modal
|
||||
.is_some());
|
||||
assert_eq!(
|
||||
app_arc
|
||||
.lock()
|
||||
.await
|
||||
.data
|
||||
.sonarr_data
|
||||
.season_details_modal
|
||||
.as_ref()
|
||||
.unwrap()
|
||||
.season_history
|
||||
.items,
|
||||
expected_history_items
|
||||
);
|
||||
assert!(
|
||||
!app_arc
|
||||
.lock()
|
||||
.await
|
||||
.data
|
||||
.sonarr_data
|
||||
.season_details_modal
|
||||
.as_ref()
|
||||
.unwrap()
|
||||
.season_history
|
||||
.sort_asc
|
||||
);
|
||||
assert_eq!(history, response);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_handle_trigger_automatic_season_search_event() {
|
||||
let (async_server, app_arc, _server) = mock_servarr_api(
|
||||
RequestMethod::Post,
|
||||
Some(json!({
|
||||
"name": "SeasonSearch",
|
||||
"seriesId": 1,
|
||||
"seasonNumber": 1
|
||||
})),
|
||||
Some(json!({})),
|
||||
None,
|
||||
SonarrEvent::TriggerAutomaticSeasonSearch((1, 1)),
|
||||
None,
|
||||
None,
|
||||
)
|
||||
.await;
|
||||
app_arc.lock().await.server_tabs.next();
|
||||
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
|
||||
|
||||
assert!(network
|
||||
.handle_sonarr_event(SonarrEvent::TriggerAutomaticSeasonSearch((1, 1)))
|
||||
.await
|
||||
.is_ok());
|
||||
|
||||
async_server.assert_async().await;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,450 @@
|
||||
use crate::models::servarr_data::sonarr::sonarr_data::ActiveSonarrBlock;
|
||||
use crate::models::sonarr_models::{
|
||||
AddSeriesBody, AddSeriesSearchResult, DeleteSeriesParams, EditSeriesParams, Series,
|
||||
SonarrCommandBody, SonarrHistoryItem,
|
||||
};
|
||||
use crate::models::stateful_table::StatefulTable;
|
||||
use crate::models::Route;
|
||||
use crate::network::sonarr_network::SonarrEvent;
|
||||
use crate::network::{Network, RequestMethod};
|
||||
use anyhow::Result;
|
||||
use log::{debug, info, warn};
|
||||
use serde_json::{json, Value};
|
||||
use urlencoding::encode;
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "sonarr_series_network_tests.rs"]
|
||||
mod sonarr_series_network_tests;
|
||||
|
||||
impl Network<'_, '_> {
|
||||
pub(in crate::network::sonarr_network) async fn add_sonarr_series(
|
||||
&mut self,
|
||||
mut add_series_body: AddSeriesBody,
|
||||
) -> anyhow::Result<Value> {
|
||||
info!("Adding new series to Sonarr");
|
||||
let event = SonarrEvent::AddSeries(AddSeriesBody::default());
|
||||
if let Some(tag_input_str) = add_series_body.tag_input_string.as_ref() {
|
||||
let tag_ids_vec = self.extract_and_add_sonarr_tag_ids_vec(tag_input_str).await;
|
||||
add_series_body.tags = tag_ids_vec;
|
||||
}
|
||||
|
||||
debug!("Add series body: {add_series_body:?}");
|
||||
|
||||
let request_props = self
|
||||
.request_props_from(
|
||||
event,
|
||||
RequestMethod::Post,
|
||||
Some(add_series_body),
|
||||
None,
|
||||
None,
|
||||
)
|
||||
.await;
|
||||
|
||||
self
|
||||
.handle_request::<AddSeriesBody, Value>(request_props, |_, _| ())
|
||||
.await
|
||||
}
|
||||
|
||||
pub(in crate::network::sonarr_network) async fn delete_series(
|
||||
&mut self,
|
||||
delete_series_params: DeleteSeriesParams,
|
||||
) -> Result<()> {
|
||||
let event = SonarrEvent::DeleteSeries(DeleteSeriesParams::default());
|
||||
let DeleteSeriesParams {
|
||||
id,
|
||||
delete_series_files,
|
||||
add_list_exclusion,
|
||||
} = delete_series_params;
|
||||
|
||||
info!("Deleting Sonarr series with ID: {id} with deleteFiles={delete_series_files} and addImportExclusion={add_list_exclusion}");
|
||||
|
||||
let request_props = self
|
||||
.request_props_from(
|
||||
event,
|
||||
RequestMethod::Delete,
|
||||
None::<()>,
|
||||
Some(format!("/{id}")),
|
||||
Some(format!(
|
||||
"deleteFiles={delete_series_files}&addImportExclusion={add_list_exclusion}"
|
||||
)),
|
||||
)
|
||||
.await;
|
||||
|
||||
self
|
||||
.handle_request::<(), ()>(request_props, |_, _| ())
|
||||
.await
|
||||
}
|
||||
|
||||
pub(in crate::network::sonarr_network) async fn edit_sonarr_series(
|
||||
&mut self,
|
||||
mut edit_series_params: EditSeriesParams,
|
||||
) -> Result<()> {
|
||||
info!("Editing Sonarr series");
|
||||
if let Some(tag_input_str) = edit_series_params.tag_input_string.as_ref() {
|
||||
let tag_ids_vec = self.extract_and_add_sonarr_tag_ids_vec(tag_input_str).await;
|
||||
edit_series_params.tags = Some(tag_ids_vec);
|
||||
}
|
||||
let series_id = edit_series_params.series_id;
|
||||
let detail_event = SonarrEvent::GetSeriesDetails(series_id);
|
||||
let event = SonarrEvent::EditSeries(EditSeriesParams::default());
|
||||
info!("Fetching series details for series with ID: {series_id}");
|
||||
|
||||
let request_props = self
|
||||
.request_props_from(
|
||||
detail_event,
|
||||
RequestMethod::Get,
|
||||
None::<()>,
|
||||
Some(format!("/{series_id}")),
|
||||
None,
|
||||
)
|
||||
.await;
|
||||
|
||||
let mut response = String::new();
|
||||
|
||||
self
|
||||
.handle_request::<(), Value>(request_props, |detailed_series_body, _| {
|
||||
response = detailed_series_body.to_string()
|
||||
})
|
||||
.await?;
|
||||
|
||||
info!("Constructing edit series body");
|
||||
|
||||
let mut detailed_series_body: Value = serde_json::from_str(&response)?;
|
||||
let (
|
||||
monitored,
|
||||
use_season_folders,
|
||||
series_type,
|
||||
quality_profile_id,
|
||||
language_profile_id,
|
||||
root_folder_path,
|
||||
tags,
|
||||
) = {
|
||||
let monitored = edit_series_params.monitored.unwrap_or(
|
||||
detailed_series_body["monitored"]
|
||||
.as_bool()
|
||||
.expect("Unable to deserialize 'monitored'"),
|
||||
);
|
||||
let use_season_folders = edit_series_params.use_season_folders.unwrap_or(
|
||||
detailed_series_body["seasonFolder"]
|
||||
.as_bool()
|
||||
.expect("Unable to deserialize 'season_folder'"),
|
||||
);
|
||||
let series_type = edit_series_params
|
||||
.series_type
|
||||
.unwrap_or_else(|| {
|
||||
serde_json::from_value(detailed_series_body["seriesType"].clone())
|
||||
.expect("Unable to deserialize 'seriesType'")
|
||||
})
|
||||
.to_string();
|
||||
let quality_profile_id = edit_series_params.quality_profile_id.unwrap_or_else(|| {
|
||||
detailed_series_body["qualityProfileId"]
|
||||
.as_i64()
|
||||
.expect("Unable to deserialize 'qualityProfileId'")
|
||||
});
|
||||
let language_profile_id = edit_series_params.language_profile_id.unwrap_or_else(|| {
|
||||
detailed_series_body["languageProfileId"]
|
||||
.as_i64()
|
||||
.expect("Unable to deserialize 'languageProfileId'")
|
||||
});
|
||||
let root_folder_path = edit_series_params.root_folder_path.unwrap_or_else(|| {
|
||||
detailed_series_body["path"]
|
||||
.as_str()
|
||||
.expect("Unable to deserialize 'path'")
|
||||
.to_owned()
|
||||
});
|
||||
let tags = if edit_series_params.clear_tags {
|
||||
vec![]
|
||||
} else {
|
||||
edit_series_params.tags.unwrap_or(
|
||||
detailed_series_body["tags"]
|
||||
.as_array()
|
||||
.expect("Unable to deserialize 'tags'")
|
||||
.iter()
|
||||
.map(|item| item.as_i64().expect("Unable to deserialize tag ID"))
|
||||
.collect(),
|
||||
)
|
||||
};
|
||||
|
||||
(
|
||||
monitored,
|
||||
use_season_folders,
|
||||
series_type,
|
||||
quality_profile_id,
|
||||
language_profile_id,
|
||||
root_folder_path,
|
||||
tags,
|
||||
)
|
||||
};
|
||||
|
||||
*detailed_series_body.get_mut("monitored").unwrap() = json!(monitored);
|
||||
*detailed_series_body.get_mut("seasonFolder").unwrap() = json!(use_season_folders);
|
||||
*detailed_series_body.get_mut("seriesType").unwrap() = json!(series_type);
|
||||
*detailed_series_body.get_mut("qualityProfileId").unwrap() = json!(quality_profile_id);
|
||||
*detailed_series_body.get_mut("languageProfileId").unwrap() = json!(language_profile_id);
|
||||
*detailed_series_body.get_mut("path").unwrap() = json!(root_folder_path);
|
||||
*detailed_series_body.get_mut("tags").unwrap() = json!(tags);
|
||||
|
||||
debug!("Edit series body: {detailed_series_body:?}");
|
||||
|
||||
let request_props = self
|
||||
.request_props_from(
|
||||
event,
|
||||
RequestMethod::Put,
|
||||
Some(detailed_series_body),
|
||||
Some(format!("/{series_id}")),
|
||||
None,
|
||||
)
|
||||
.await;
|
||||
|
||||
self
|
||||
.handle_request::<Value, ()>(request_props, |_, _| ())
|
||||
.await
|
||||
}
|
||||
|
||||
pub(in crate::network::sonarr_network) async fn toggle_sonarr_series_monitoring(
|
||||
&mut self,
|
||||
series_id: i64,
|
||||
) -> Result<()> {
|
||||
let event = SonarrEvent::ToggleSeriesMonitoring(series_id);
|
||||
|
||||
let detail_event = SonarrEvent::GetSeriesDetails(series_id);
|
||||
info!("Toggling series monitoring for series with ID: {series_id}");
|
||||
info!("Fetching series details for series with ID: {series_id}");
|
||||
|
||||
let request_props = self
|
||||
.request_props_from(
|
||||
detail_event,
|
||||
RequestMethod::Get,
|
||||
None::<()>,
|
||||
Some(format!("/{series_id}")),
|
||||
None,
|
||||
)
|
||||
.await;
|
||||
|
||||
let mut response = String::new();
|
||||
|
||||
self
|
||||
.handle_request::<(), Value>(request_props, |detailed_series_body, _| {
|
||||
response = detailed_series_body.to_string()
|
||||
})
|
||||
.await?;
|
||||
|
||||
info!("Constructing toggle series monitoring body");
|
||||
|
||||
match serde_json::from_str::<Value>(&response) {
|
||||
Ok(mut detailed_series_body) => {
|
||||
let monitored = detailed_series_body
|
||||
.get("monitored")
|
||||
.unwrap()
|
||||
.as_bool()
|
||||
.unwrap();
|
||||
|
||||
*detailed_series_body.get_mut("monitored").unwrap() = json!(!monitored);
|
||||
|
||||
debug!("Toggle series monitoring body: {detailed_series_body:?}");
|
||||
|
||||
let request_props = self
|
||||
.request_props_from(
|
||||
event,
|
||||
RequestMethod::Put,
|
||||
Some(detailed_series_body),
|
||||
Some(format!("/{series_id}")),
|
||||
None,
|
||||
)
|
||||
.await;
|
||||
|
||||
self
|
||||
.handle_request::<Value, ()>(request_props, |_, _| ())
|
||||
.await
|
||||
}
|
||||
Err(_) => {
|
||||
warn!("Request for detailed series body was interrupted");
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(in crate::network::sonarr_network) async fn get_series_details(
|
||||
&mut self,
|
||||
series_id: i64,
|
||||
) -> Result<Series> {
|
||||
info!("Fetching details for Sonarr series with ID: {series_id}");
|
||||
let event = SonarrEvent::GetSeriesDetails(series_id);
|
||||
|
||||
let request_props = self
|
||||
.request_props_from(
|
||||
event,
|
||||
RequestMethod::Get,
|
||||
None::<()>,
|
||||
Some(format!("/{series_id}")),
|
||||
None,
|
||||
)
|
||||
.await;
|
||||
|
||||
self
|
||||
.handle_request::<(), Series>(request_props, |_, _| ())
|
||||
.await
|
||||
}
|
||||
|
||||
pub(in crate::network::sonarr_network) async fn get_sonarr_series_history(
|
||||
&mut self,
|
||||
series_id: i64,
|
||||
) -> Result<Vec<SonarrHistoryItem>> {
|
||||
info!("Fetching Sonarr series history for series with ID: {series_id}");
|
||||
let event = SonarrEvent::GetSeriesHistory(series_id);
|
||||
|
||||
let request_props = self
|
||||
.request_props_from(
|
||||
event,
|
||||
RequestMethod::Get,
|
||||
None::<()>,
|
||||
None,
|
||||
Some(format!("seriesId={series_id}")),
|
||||
)
|
||||
.await;
|
||||
|
||||
self
|
||||
.handle_request::<(), Vec<SonarrHistoryItem>>(request_props, |mut history_vec, mut app| {
|
||||
if app.data.sonarr_data.series_history.is_none() {
|
||||
app.data.sonarr_data.series_history = Some(StatefulTable::default());
|
||||
}
|
||||
|
||||
if !matches!(
|
||||
app.get_current_route(),
|
||||
Route::Sonarr(ActiveSonarrBlock::SeriesHistorySortPrompt, _)
|
||||
) {
|
||||
history_vec.sort_by(|a, b| a.id.cmp(&b.id));
|
||||
app
|
||||
.data
|
||||
.sonarr_data
|
||||
.series_history
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.set_items(history_vec);
|
||||
app
|
||||
.data
|
||||
.sonarr_data
|
||||
.series_history
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.apply_sorting_toggle(false);
|
||||
}
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
pub(in crate::network::sonarr_network) async fn list_series(&mut self) -> Result<Vec<Series>> {
|
||||
info!("Fetching Sonarr library");
|
||||
let event = SonarrEvent::ListSeries;
|
||||
|
||||
let request_props = self
|
||||
.request_props_from(event, RequestMethod::Get, None::<()>, None, None)
|
||||
.await;
|
||||
|
||||
self
|
||||
.handle_request::<(), Vec<Series>>(request_props, |mut series_vec, mut app| {
|
||||
if !matches!(
|
||||
app.get_current_route(),
|
||||
Route::Sonarr(ActiveSonarrBlock::SeriesSortPrompt, _)
|
||||
) {
|
||||
series_vec.sort_by(|a, b| a.id.cmp(&b.id));
|
||||
app.data.sonarr_data.series.set_items(series_vec);
|
||||
app.data.sonarr_data.series.apply_sorting_toggle(false);
|
||||
}
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
pub(in crate::network::sonarr_network) async fn search_sonarr_series(
|
||||
&mut self,
|
||||
query: String,
|
||||
) -> Result<Vec<AddSeriesSearchResult>> {
|
||||
info!("Searching for specific Sonarr series");
|
||||
let event = SonarrEvent::SearchNewSeries(String::new());
|
||||
|
||||
let request_props = self
|
||||
.request_props_from(
|
||||
event,
|
||||
RequestMethod::Get,
|
||||
None::<()>,
|
||||
None,
|
||||
Some(format!("term={}", encode(&query))),
|
||||
)
|
||||
.await;
|
||||
|
||||
self
|
||||
.handle_request::<(), Vec<AddSeriesSearchResult>>(request_props, |series_vec, mut app| {
|
||||
if series_vec.is_empty() {
|
||||
app.pop_and_push_navigation_stack(ActiveSonarrBlock::AddSeriesEmptySearchResults.into());
|
||||
} else if let Some(add_searched_seriess) = app.data.sonarr_data.add_searched_series.as_mut()
|
||||
{
|
||||
add_searched_seriess.set_items(series_vec);
|
||||
} else {
|
||||
let mut add_searched_seriess = StatefulTable::default();
|
||||
add_searched_seriess.set_items(series_vec);
|
||||
app.data.sonarr_data.add_searched_series = Some(add_searched_seriess);
|
||||
}
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
pub(in crate::network::sonarr_network) async fn trigger_automatic_series_search(
|
||||
&mut self,
|
||||
series_id: i64,
|
||||
) -> Result<Value> {
|
||||
let event = SonarrEvent::TriggerAutomaticSeriesSearch(series_id);
|
||||
info!("Searching indexers for series with ID: {series_id}");
|
||||
|
||||
let body = SonarrCommandBody {
|
||||
name: "SeriesSearch".to_owned(),
|
||||
series_id: Some(series_id),
|
||||
..SonarrCommandBody::default()
|
||||
};
|
||||
|
||||
let request_props = self
|
||||
.request_props_from(event, RequestMethod::Post, Some(body), None, None)
|
||||
.await;
|
||||
|
||||
self
|
||||
.handle_request::<SonarrCommandBody, Value>(request_props, |_, _| ())
|
||||
.await
|
||||
}
|
||||
|
||||
pub(in crate::network::sonarr_network) async fn update_all_series(&mut self) -> Result<Value> {
|
||||
info!("Updating all series");
|
||||
let event = SonarrEvent::UpdateAllSeries;
|
||||
let body = SonarrCommandBody {
|
||||
name: "RefreshSeries".to_owned(),
|
||||
..SonarrCommandBody::default()
|
||||
};
|
||||
|
||||
let request_props = self
|
||||
.request_props_from(event, RequestMethod::Post, Some(body), None, None)
|
||||
.await;
|
||||
|
||||
self
|
||||
.handle_request::<SonarrCommandBody, Value>(request_props, |_, _| ())
|
||||
.await
|
||||
}
|
||||
|
||||
pub(in crate::network::sonarr_network) async fn update_and_scan_series(
|
||||
&mut self,
|
||||
series_id: i64,
|
||||
) -> Result<Value> {
|
||||
let event = SonarrEvent::UpdateAndScanSeries(series_id);
|
||||
info!("Updating and scanning series with ID: {series_id}");
|
||||
let body = SonarrCommandBody {
|
||||
name: "RefreshSeries".to_owned(),
|
||||
series_id: Some(series_id),
|
||||
..SonarrCommandBody::default()
|
||||
};
|
||||
|
||||
let request_props = self
|
||||
.request_props_from(event, RequestMethod::Post, Some(body), None, None)
|
||||
.await;
|
||||
|
||||
self
|
||||
.handle_request::<SonarrCommandBody, Value>(request_props, |_, _| ())
|
||||
.await
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,43 @@
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use crate::models::sonarr_models::SonarrReleaseDownloadBody;
|
||||
use crate::network::network_tests::test_utils::mock_servarr_api;
|
||||
use crate::network::sonarr_network::SonarrEvent;
|
||||
use crate::network::{Network, RequestMethod};
|
||||
use reqwest::Client;
|
||||
use serde_json::json;
|
||||
use tokio_util::sync::CancellationToken;
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_handle_download_sonarr_release_event_uses_provided_params() {
|
||||
let params = SonarrReleaseDownloadBody {
|
||||
guid: "1234".to_owned(),
|
||||
indexer_id: 2,
|
||||
series_id: Some(1),
|
||||
..SonarrReleaseDownloadBody::default()
|
||||
};
|
||||
let (async_server, app_arc, _server) = mock_servarr_api(
|
||||
RequestMethod::Post,
|
||||
Some(json!({
|
||||
"guid": "1234",
|
||||
"indexerId": 2,
|
||||
"seriesId": 1,
|
||||
})),
|
||||
Some(json!({})),
|
||||
None,
|
||||
SonarrEvent::DownloadRelease(params.clone()),
|
||||
None,
|
||||
None,
|
||||
)
|
||||
.await;
|
||||
app_arc.lock().await.server_tabs.next();
|
||||
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
|
||||
|
||||
assert!(network
|
||||
.handle_sonarr_event(SonarrEvent::DownloadRelease(params))
|
||||
.await
|
||||
.is_ok());
|
||||
|
||||
async_server.assert_async().await;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user