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

feat(network): Support for adding a new series to Sonarr

Browse Source
This commit is contained in:
Alex Clarke
2024-11-24 13:18:02 -07:00
parent c98828aec7
commit 5ba3f2b1ba
9 changed files with 668 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/network/radarr_network.rs
+4 -4
View File
@@ -299,7 +299,7 @@ impl<'a, 'b> Network<'a, 'b> {
.tags
.text
.clone();
let tag_ids_vec = self.extract_and_add_tag_ids_vec(tags).await;
let tag_ids_vec = self.extract_and_add_radarr_tag_ids_vec(tags).await;
let mut app = self.app.lock().await;
let AddMovieModal {
root_folder_list,
@@ -1037,7 +1037,7 @@ impl<'a, 'b> Network<'a, 'b> {
.tags
.text
.clone();
let tag_ids_vec = self.extract_and_add_tag_ids_vec(tags).await;
let tag_ids_vec = self.extract_and_add_radarr_tag_ids_vec(tags).await;
let mut app = self.app.lock().await;
let params = {
@@ -1222,7 +1222,7 @@ impl<'a, 'b> Network<'a, 'b> {
.tags
.text
.clone();
let tag_ids_vec = self.extract_and_add_tag_ids_vec(tags).await;
let tag_ids_vec = self.extract_and_add_radarr_tag_ids_vec(tags).await;
let mut app = self.app.lock().await;
let params = {
@@ -2237,7 +2237,7 @@ impl<'a, 'b> Network<'a, 'b> {
.await
}
async fn extract_and_add_tag_ids_vec(&mut self, edit_tags: String) -> Vec<i64> {
async fn extract_and_add_radarr_tag_ids_vec(&mut self, edit_tags: String) -> Vec<i64> {
let tags_map = self.app.lock().await.data.radarr_data.tags_map.clone();
let tags = edit_tags.clone();
let missing_tags_vec = edit_tags
src/network/radarr_network_tests.rs
+4 -4
View File
@@ -4876,7 +4876,7 @@ mod test {
}
#[tokio::test]
async fn test_extract_and_add_tag_ids_vec() {
async fn test_extract_and_add_radarr_tag_ids_vec() {
let app_arc = Arc::new(Mutex::new(App::default()));
let tags = " test,hi ,, usenet ".to_owned();
{
@@ -4890,13 +4890,13 @@ mod test {
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
assert_eq!(
network.extract_and_add_tag_ids_vec(tags).await,
network.extract_and_add_radarr_tag_ids_vec(tags).await,
vec![2, 3, 1]
);
}
#[tokio::test]
async fn test_extract_and_add_tag_ids_vec_add_missing_tags_first() {
async fn test_extract_and_add_radarr_tag_ids_vec_add_missing_tags_first() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Post,
Some(json!({ "label": "testing" })),
@@ -4919,7 +4919,7 @@ mod test {
}
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let tag_ids_vec = network.extract_and_add_tag_ids_vec(tags).await;
let tag_ids_vec = network.extract_and_add_radarr_tag_ids_vec(tags).await;
async_server.assert_async().await;
assert_eq!(tag_ids_vec, vec![1, 2, 3]);
src/network/sonarr_network.rs
+144 -8
View File
@@ -9,7 +9,7 @@ use crate::{
servarr_data::{
modals::IndexerTestResultModalItem,
sonarr::{
modals::{EpisodeDetailsModal, SeasonDetailsModal},
modals::{AddSeriesModal, EpisodeDetailsModal, SeasonDetailsModal},
sonarr_data::ActiveSonarrBlock,
},
},
@@ -18,10 +18,10 @@ use crate::{
QualityProfile, QueueEvent, RootFolder, SecurityConfig, Tag, Update,
},
sonarr_models::{
BlocklistResponse, DeleteSeriesParams, DownloadRecord, DownloadsResponse, Episode,
IndexerSettings, Series, SonarrCommandBody, SonarrHistoryItem, SonarrHistoryWrapper,
SonarrRelease, SonarrReleaseDownloadBody, SonarrSerdeable, SonarrTask, SonarrTaskName,
SystemStatus,
AddSeriesBody, AddSeriesOptions, AddSeriesSearchResult, BlocklistResponse,
DeleteSeriesParams, DownloadRecord, DownloadsResponse, Episode, IndexerSettings, Series,
SonarrCommandBody, SonarrHistoryItem, SonarrHistoryWrapper, SonarrRelease,
SonarrReleaseDownloadBody, SonarrSerdeable, SonarrTask, SonarrTaskName, SystemStatus,
},
stateful_table::StatefulTable,
HorizontallyScrollableText, Route, Scrollable, ScrollableText,
@@ -38,6 +38,7 @@ mod sonarr_network_tests;
#[derive(Debug, Eq, PartialEq, Clone)]
pub enum SonarrEvent {
AddRootFolder(Option<String>),
AddSeries(Option<AddSeriesBody>),
AddTag(String),
ClearBlocklist,
DeleteBlocklistItem(Option<i64>),
@@ -120,9 +121,10 @@ impl NetworkResource for SonarrEvent {
SonarrEvent::GetTasks => "/system/task",
SonarrEvent::GetUpdates => "/update",
SonarrEvent::HealthCheck => "/health",
SonarrEvent::ListSeries | SonarrEvent::GetSeriesDetails(_) | SonarrEvent::DeleteSeries(_) => {
"/series"
}
SonarrEvent::AddSeries(_)
| SonarrEvent::ListSeries
| SonarrEvent::GetSeriesDetails(_)
| SonarrEvent::DeleteSeries(_) => "/series",
SonarrEvent::MarkHistoryItemAsFailed(_) => "/history/failed",
SonarrEvent::TestIndexer(_) => "/indexer/test",
SonarrEvent::TestAllIndexers => "/indexer/testall",
@@ -146,6 +148,10 @@ impl<'a, 'b> Network<'a, 'b> {
.add_sonarr_root_folder(path)
.await
.map(SonarrSerdeable::from),
SonarrEvent::AddSeries(body) => self
.add_sonarr_series(body)
.await
.map(SonarrSerdeable::from),
SonarrEvent::AddTag(tag) => self.add_sonarr_tag(tag).await.map(SonarrSerdeable::from),
SonarrEvent::ClearBlocklist => self
.clear_sonarr_blocklist()
@@ -327,6 +333,106 @@ impl<'a, 'b> Network<'a, 'b> {
.await
}
async fn add_sonarr_series(
&mut self,
add_series_body_option: Option<AddSeriesBody>,
) -> Result<Value> {
info!("Adding new series to Sonarr");
let event = SonarrEvent::AddSeries(None);
let body = if let Some(add_series_body) = add_series_body_option {
add_series_body
} else {
let tags = self
.app
.lock()
.await
.data
.sonarr_data
.add_series_modal
.as_ref()
.unwrap()
.tags
.text
.clone();
let tag_ids_vec = self.extract_and_add_sonarr_tag_ids_vec(tags).await;
let mut app = self.app.lock().await;
let AddSeriesModal {
root_folder_list,
monitor_list,
quality_profile_list,
language_profile_list,
series_type_list,
use_season_folder,
..
} = app.data.sonarr_data.add_series_modal.as_ref().unwrap();
let season_folder = *use_season_folder;
let (tvdb_id, title) = {
let AddSeriesSearchResult { tvdb_id, title, .. } = app
.data
.sonarr_data
.add_searched_series
.as_ref()
.unwrap()
.current_selection()
.clone();
(tvdb_id, title.text)
};
let quality_profile = quality_profile_list.current_selection();
let quality_profile_id = *app
.data
.sonarr_data
.quality_profile_map
.iter()
.filter(|(_, value)| *value == quality_profile)
.map(|(key, _)| key)
.next()
.unwrap();
let language_profile = language_profile_list.current_selection();
let language_profile_id = *app
.data
.sonarr_data
.language_profiles_map
.iter()
.filter(|(_, value)| *value == language_profile)
.map(|(key, _)| key)
.next()
.unwrap();
let path = root_folder_list.current_selection().path.clone();
let monitor = monitor_list.current_selection().to_string();
let series_type = series_type_list.current_selection().to_string();
app.data.sonarr_data.add_series_modal = None;
AddSeriesBody {
tvdb_id,
title,
monitored: true,
root_folder_path: path,
quality_profile_id,
language_profile_id,
series_type,
season_folder,
tags: tag_ids_vec,
add_options: AddSeriesOptions {
monitor,
search_for_cutoff_unmet_episodes: true,
search_for_missing_episodes: true,
},
}
};
debug!("Add series body: {body:?}");
let request_props = self
.request_props_from(event, RequestMethod::Post, Some(body), None, None)
.await;
self
.handle_request::<AddSeriesBody, Value>(request_props, |_, _| ())
.await
}
async fn add_sonarr_tag(&mut self, tag: String) -> Result<Tag> {
info!("Adding a new Sonarr tag");
let event = SonarrEvent::AddTag(String::new());
@@ -1703,6 +1809,36 @@ impl<'a, 'b> Network<'a, 'b> {
.await
}
async fn extract_and_add_sonarr_tag_ids_vec(&mut self, edit_tags: String) -> Vec<i64> {
let tags_map = self.app.lock().await.data.sonarr_data.tags_map.clone();
let tags = edit_tags.clone();
let missing_tags_vec = edit_tags
.split(',')
.filter(|&tag| !tag.is_empty() && tags_map.get_by_right(tag.trim()).is_none())
.collect::<Vec<&str>>();
for tag in missing_tags_vec {
self
.add_sonarr_tag(tag.trim().to_owned())
.await
.expect("Unable to add tag");
}
let app = self.app.lock().await;
tags
.split(',')
.filter(|tag| !tag.is_empty())
.map(|tag| {
*app
.data
.sonarr_data
.tags_map
.get_by_right(tag.trim())
.unwrap()
})
.collect()
}
async fn extract_series_id(&mut self, series_id: Option<i64>) -> (i64, String) {
let series_id = if let Some(id) = series_id {
id
src/network/sonarr_network_tests.rs
+354 -2
View File
@@ -11,13 +11,21 @@ mod test {
use rstest::rstest;
use serde_json::json;
use serde_json::{Number, Value};
use strum::IntoEnumIterator;
use tokio::sync::Mutex;
use tokio_util::sync::CancellationToken;
use crate::models::sonarr_models::{
AddSeriesBody, AddSeriesOptions, AddSeriesSearchResult, AddSeriesSearchResultStatistics,
SeriesMonitor,
};
use crate::app::App;
use crate::models::radarr_models::IndexerTestResult;
use crate::models::servarr_data::modals::IndexerTestResultModalItem;
use crate::models::servarr_data::sonarr::modals::{EpisodeDetailsModal, SeasonDetailsModal};
use crate::models::servarr_data::sonarr::modals::{
AddSeriesModal, EpisodeDetailsModal, SeasonDetailsModal,
};
use crate::models::servarr_data::sonarr::sonarr_data::ActiveSonarrBlock;
use crate::models::servarr_models::{
DiskSpace, HostConfig, Indexer, IndexerField, Language, LogResponse, Quality, QualityProfile,
@@ -33,7 +41,7 @@ mod test {
use crate::models::sonarr_models::{SonarrTask, SystemStatus};
use crate::models::stateful_table::StatefulTable;
use crate::models::{sonarr_models::SonarrSerdeable, stateful_table::SortOption};
use crate::models::{HorizontallyScrollableText, ScrollableText};
use crate::models::{HorizontallyScrollableText, Scrollable, ScrollableText};
use crate::network::sonarr_network::get_episode_status;
use crate::{
@@ -138,6 +146,7 @@ mod test {
#[rstest]
fn test_resource_series(
#[values(
SonarrEvent::AddSeries(None),
SonarrEvent::ListSeries,
SonarrEvent::GetSeriesDetails(None),
SonarrEvent::DeleteSeries(None)
@@ -321,6 +330,267 @@ mod test {
.is_none());
}
#[tokio::test]
async fn test_handle_add_sonarr_series_event() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Post,
Some(json!({
"tvdbId": 1234,
"title": "Test",
"monitored": true,
"rootFolderPath": "/nfs2",
"qualityProfileId": 2222,
"languageProfileId": 2222,
"seriesType": "standard",
"seasonFolder": true,
"tags": [1, 2],
"addOptions": {
"monitor": "all",
"searchForCutoffUnmetEpisodes": true,
"searchForMissingEpisodes": true
}
})),
Some(json!({})),
None,
SonarrEvent::AddSeries(None),
None,
None,
)
.await;
{
let mut app = app_arc.lock().await;
let mut add_series_modal = AddSeriesModal {
use_season_folder: true,
tags: "usenet, testing".into(),
..AddSeriesModal::default()
};
add_series_modal.root_folder_list.set_items(vec![
RootFolder {
id: 1,
path: "/nfs".to_owned(),
accessible: true,
free_space: 219902325555200,
unmapped_folders: None,
},
RootFolder {
id: 2,
path: "/nfs2".to_owned(),
accessible: true,
free_space: 21990232555520,
unmapped_folders: None,
},
]);
add_series_modal.root_folder_list.state.select(Some(1));
add_series_modal
.quality_profile_list
.set_items(vec!["HD - 1080p".to_owned()]);
add_series_modal
.language_profile_list
.set_items(vec!["English".to_owned()]);
add_series_modal
.monitor_list
.set_items(Vec::from_iter(SeriesMonitor::iter()));
add_series_modal
.series_type_list
.set_items(Vec::from_iter(SeriesType::iter()));
app.data.sonarr_data.add_series_modal = Some(add_series_modal);
app.data.sonarr_data.quality_profile_map =
BiMap::from_iter([(2222, "HD - 1080p".to_owned())]);
app.data.sonarr_data.language_profiles_map = BiMap::from_iter([(2222, "English".to_owned())]);
app.data.sonarr_data.tags_map =
BiMap::from_iter([(1, "usenet".to_owned()), (2, "testing".to_owned())]);
let mut add_searched_series = StatefulTable::default();
add_searched_series.set_items(vec![add_series_search_result()]);
app.data.sonarr_data.add_searched_series = Some(add_searched_series);
}
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
assert!(network
.handle_sonarr_event(SonarrEvent::AddSeries(None))
.await
.is_ok());
async_server.assert_async().await;
assert!(app_arc
.lock()
.await
.data
.sonarr_data
.add_series_modal
.is_none());
}
#[tokio::test]
async fn test_handle_add_sonarr_series_event_uses_provided_body() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Post,
Some(json!({
"tvdbId": 1234,
"title": "Test",
"monitored": true,
"rootFolderPath": "/nfs2",
"qualityProfileId": 2222,
"languageProfileId": 2222,
"seriesType": "standard",
"seasonFolder": true,
"tags": [1, 2],
"addOptions": {
"monitor": "standard",
"searchForCutoffUnmetEpisodes": true,
"searchForMissingEpisodes": true
}
})),
Some(json!({})),
None,
SonarrEvent::AddSeries(None),
None,
None,
)
.await;
let body = AddSeriesBody {
tvdb_id: 1234,
title: "Test".to_owned(),
monitored: true,
root_folder_path: "/nfs2".to_owned(),
quality_profile_id: 2222,
language_profile_id: 2222,
series_type: "standard".to_owned(),
season_folder: true,
tags: vec![1, 2],
add_options: AddSeriesOptions {
monitor: "standard".to_owned(),
search_for_cutoff_unmet_episodes: true,
search_for_missing_episodes: true,
},
};
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
assert!(network
.handle_sonarr_event(SonarrEvent::AddSeries(Some(body)))
.await
.is_ok());
async_server.assert_async().await;
assert!(app_arc
.lock()
.await
.data
.sonarr_data
.add_series_modal
.is_none());
}
#[tokio::test]
async fn test_handle_add_sonarr_series_event_reuse_existing_table_if_search_already_performed() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Post,
Some(json!({
"tvdbId": 5678,
"title": "Test",
"monitored": true,
"rootFolderPath": "/nfs2",
"qualityProfileId": 2222,
"languageProfileId": 2222,
"seriesType": "standard",
"seasonFolder": true,
"tags": [1, 2],
"addOptions": {
"monitor": "all",
"searchForCutoffUnmetEpisodes": true,
"searchForMissingEpisodes": true
}
})),
Some(json!({})),
None,
SonarrEvent::AddSeries(None),
None,
None,
)
.await;
{
let mut app = app_arc.lock().await;
let mut add_series_modal = AddSeriesModal {
use_season_folder: true,
tags: "usenet, testing".into(),
..AddSeriesModal::default()
};
add_series_modal.root_folder_list.set_items(vec![
RootFolder {
id: 1,
path: "/nfs".to_owned(),
accessible: true,
free_space: 219902325555200,
unmapped_folders: None,
},
RootFolder {
id: 2,
path: "/nfs2".to_owned(),
accessible: true,
free_space: 21990232555520,
unmapped_folders: None,
},
]);
add_series_modal.root_folder_list.state.select(Some(1));
add_series_modal
.quality_profile_list
.set_items(vec!["HD - 1080p".to_owned()]);
add_series_modal
.language_profile_list
.set_items(vec!["English".to_owned()]);
add_series_modal
.monitor_list
.set_items(Vec::from_iter(SeriesMonitor::iter()));
add_series_modal
.series_type_list
.set_items(Vec::from_iter(SeriesType::iter()));
app.data.sonarr_data.add_series_modal = Some(add_series_modal);
app.data.sonarr_data.quality_profile_map =
BiMap::from_iter([(2222, "HD - 1080p".to_owned())]);
app.data.sonarr_data.language_profiles_map = BiMap::from_iter([(2222, "English".to_owned())]);
app.data.sonarr_data.tags_map =
BiMap::from_iter([(1, "usenet".to_owned()), (2, "testing".to_owned())]);
let secondary_search_result = AddSeriesSearchResult {
tvdb_id: 5678,
..add_series_search_result()
};
let mut add_searched_series = StatefulTable::default();
add_searched_series.set_items(vec![add_series_search_result(), secondary_search_result]);
add_searched_series.scroll_to_bottom();
app.data.sonarr_data.add_searched_series = Some(add_searched_series);
}
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
assert!(network
.handle_sonarr_event(SonarrEvent::AddSeries(None))
.await
.is_ok());
async_server.assert_async().await;
assert!(app_arc
.lock()
.await
.data
.sonarr_data
.add_series_modal
.is_none());
assert_eq!(
app_arc
.lock()
.await
.data
.sonarr_data
.add_searched_series
.as_ref()
.unwrap()
.current_selection()
.tvdb_id,
5678
);
}
#[tokio::test]
async fn test_handle_add_sonarr_tag() {
let tag_json = json!({ "id": 3, "label": "testing" });
@@ -4851,6 +5121,64 @@ mod test {
async_server.assert_async().await;
}
#[tokio::test]
async fn test_extract_and_add_sonarr_tag_ids_vec() {
let app_arc = Arc::new(Mutex::new(App::default()));
let tags = " test,hi ,, usenet ".to_owned();
{
let mut app = app_arc.lock().await;
app.data.sonarr_data.tags_map = BiMap::from_iter([
(1, "usenet".to_owned()),
(2, "test".to_owned()),
(3, "hi".to_owned()),
]);
}
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
assert_eq!(
network.extract_and_add_sonarr_tag_ids_vec(tags).await,
vec![2, 3, 1]
);
}
#[tokio::test]
async fn test_extract_and_add_sonarr_tag_ids_vec_add_missing_tags_first() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Post,
Some(json!({ "label": "testing" })),
Some(json!({ "id": 3, "label": "testing" })),
None,
SonarrEvent::GetTags,
None,
None,
)
.await;
let tags = "usenet, test, testing".to_owned();
{
let mut app = app_arc.lock().await;
app.data.sonarr_data.add_series_modal = Some(AddSeriesModal {
tags: tags.clone().into(),
..AddSeriesModal::default()
});
app.data.sonarr_data.tags_map =
BiMap::from_iter([(1, "usenet".to_owned()), (2, "test".to_owned())]);
}
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let tag_ids_vec = network.extract_and_add_sonarr_tag_ids_vec(tags).await;
async_server.assert_async().await;
assert_eq!(tag_ids_vec, vec![1, 2, 3]);
assert_eq!(
app_arc.lock().await.data.sonarr_data.tags_map,
BiMap::from_iter([
(1, "usenet".to_owned()),
(2, "test".to_owned()),
(3, "testing".to_owned())
])
);
}
#[tokio::test]
async fn test_extract_series_id() {
let app_arc = Arc::new(Mutex::new(App::default()));
@@ -5084,6 +5412,26 @@ mod test {
);
}
fn add_series_search_result() -> AddSeriesSearchResult {
AddSeriesSearchResult {
tvdb_id: 1234,
title: HorizontallyScrollableText::from("Test"),
status: Some("continuing".to_owned()),
ended: false,
overview: Some("New series blah blah blah".to_owned()),
genres: genres(),
year: 2023,
network: Some("Prime Video".to_owned()),
runtime: 60,
ratings: Some(rating()),
statistics: Some(add_series_search_result_statistics()),
}
}
fn add_series_search_result_statistics() -> AddSeriesSearchResultStatistics {
AddSeriesSearchResultStatistics { season_count: 3 }
}
fn blocklist_item() -> BlocklistItem {
BlocklistItem {
id: 1,
@@ -5151,6 +5499,10 @@ mod test {
}
}
fn genres() -> Vec<String> {
vec!["cool".to_owned(), "family".to_owned(), "fun".to_owned()]
}
fn history_data() -> SonarrHistoryData {
SonarrHistoryData {
dropped_path: Some("/nfs/nzbget/completed/series/Coolness/something.cool.mkv".to_owned()),