fix(radarr): Construct and pass the edit movie parameters alongside the EditMovie event when publishing to the networking channel

2024-12-17 17:50:07 -07:00
parent 77b8b61079
commit 9a9b13d604
7 changed files with 232 additions and 146 deletions
@@ -14,7 +14,7 @@ use crate::models::radarr_models::{
  RadarrTask, RadarrTaskName, SystemStatus,
 };
 use crate::models::servarr_data::modals::IndexerTestResultModalItem;
-use crate::models::servarr_data::radarr::modals::{EditMovieModal, MovieDetailsModal};
+use crate::models::servarr_data::radarr::modals::MovieDetailsModal;
 use crate::models::servarr_data::radarr::radarr_data::ActiveRadarrBlock;
 use crate::models::servarr_models::{
  AddRootFolderBody, CommandBody, DiskSpace, EditIndexerParams, HostConfig, Indexer, LogResponse,
@@ -47,7 +47,7 @@ pub enum RadarrEvent {
  EditAllIndexerSettings(IndexerSettings),
  EditCollection(EditCollectionParams),
  EditIndexer(EditIndexerParams),
-  EditMovie(Option<EditMovieParams>),
+  EditMovie(EditMovieParams),
  GetBlocklist,
  GetCollections,
  GetDownloads,
@@ -822,16 +822,18 @@ impl<'a, 'b> Network<'a, 'b> {
      .await
  }

-  async fn edit_movie(&mut self, edit_movie_params: Option<EditMovieParams>) -> Result<()> {
+  async fn edit_movie(&mut self, mut edit_movie_params: EditMovieParams) -> Result<()> {
    info!("Editing Radarr movie");
    let detail_event = RadarrEvent::GetMovieDetails(None);
-    let event = RadarrEvent::EditMovie(None);
+    let event = RadarrEvent::EditMovie(edit_movie_params.clone());
+    let movie_id = edit_movie_params.movie_id;
+    if let Some(tag_input_string) = edit_movie_params.tag_input_string.as_ref() {
+      let tag_ids_vec = self
+        .extract_and_add_radarr_tag_ids_vec(tag_input_string.clone())
+        .await;
+      edit_movie_params.tags = Some(tag_ids_vec);
+    }

-    let (movie_id, _) = if let Some(ref params) = edit_movie_params {
-      self.extract_movie_id(Some(params.movie_id)).await
-    } else {
-      self.extract_movie_id(None).await
-    };
    info!("Fetching movie details for movie with ID: {movie_id}");

    let request_props = self
@@ -856,34 +858,34 @@ impl<'a, 'b> Network<'a, 'b> {

    let mut detailed_movie_body: Value = serde_json::from_str(&response)?;
    let (monitored, minimum_availability, quality_profile_id, root_folder_path, tags) =
-      if let Some(params) = edit_movie_params {
-        let monitored = params.monitored.unwrap_or(
+      {
+        let monitored = edit_movie_params.monitored.unwrap_or(
          detailed_movie_body["monitored"]
            .as_bool()
            .expect("Unable to deserialize 'monitored'"),
        );
-        let minimum_availability = params
+        let minimum_availability = edit_movie_params
          .minimum_availability
          .unwrap_or_else(|| {
            serde_json::from_value(detailed_movie_body["minimumAvailability"].clone())
              .expect("Unable to deserialize 'minimumAvailability'")
          })
          .to_string();
-        let quality_profile_id = params.quality_profile_id.unwrap_or_else(|| {
+        let quality_profile_id = edit_movie_params.quality_profile_id.unwrap_or_else(|| {
          detailed_movie_body["qualityProfileId"]
            .as_i64()
            .expect("Unable to deserialize 'qualityProfileId'")
        });
-        let root_folder_path = params.root_folder_path.unwrap_or_else(|| {
+        let root_folder_path = edit_movie_params.root_folder_path.unwrap_or_else(|| {
          detailed_movie_body["path"]
            .as_str()
            .expect("Unable to deserialize 'path'")
            .to_owned()
        });
-        let tags = if params.clear_tags {
+        let tags = if edit_movie_params.clear_tags {
          vec![]
        } else {
-          params.tags.unwrap_or(
+          edit_movie_params.tags.unwrap_or(
            detailed_movie_body["tags"]
              .as_array()
              .expect("Unable to deserialize 'tags'")
@@ -900,53 +902,6 @@ impl<'a, 'b> Network<'a, 'b> {
          root_folder_path,
          tags,
        )
-      } else {
-        let tags = self
-          .app
-          .lock()
-          .await
-          .data
-          .radarr_data
-          .edit_movie_modal
-          .as_ref()
-          .unwrap()
-          .tags
-          .text
-          .clone();
-        let tag_ids_vec = self.extract_and_add_radarr_tag_ids_vec(tags).await;
-        let mut app = self.app.lock().await;
-
-        let params = {
-          let EditMovieModal {
-            monitored,
-            path,
-            minimum_availability_list,
-            quality_profile_list,
-            ..
-          } = app.data.radarr_data.edit_movie_modal.as_ref().unwrap();
-          let quality_profile = quality_profile_list.current_selection();
-          let quality_profile_id = *app
-            .data
-            .radarr_data
-            .quality_profile_map
-            .iter()
-            .filter(|(_, value)| *value == quality_profile)
-            .map(|(key, _)| key)
-            .next()
-            .unwrap();
-
-          (
-            monitored.unwrap_or_default(),
-            minimum_availability_list.current_selection().to_string(),
-            quality_profile_id,
-            path.text.clone(),
-            tag_ids_vec,
-          )
-        };
-
-        app.data.radarr_data.edit_movie_modal = None;
-
-        params
      };

    *detailed_movie_body.get_mut("monitored").unwrap() = json!(monitored);
@@ -9,14 +9,13 @@ mod test {
  use reqwest::Client;
  use rstest::rstest;
  use serde_json::{json, Number, Value};
-  use strum::IntoEnumIterator;
  use tokio::sync::Mutex;
  use tokio_util::sync::CancellationToken;

  use crate::app::ServarrConfig;
  use crate::models::radarr_models::{
    AddMovieOptions, BlocklistItem, BlocklistItemMovie, CollectionMovie, EditCollectionParams,
-    IndexerSettings, MediaInfo, MinimumAvailability, MovieCollection, MovieFile, Rating, RatingsList
+    EditMovieParams, IndexerSettings, MediaInfo, MinimumAvailability, MovieCollection, MovieFile, Rating, RatingsList
  };
  use crate::models::servarr_data::radarr::radarr_data::ActiveRadarrBlock;
  use crate::models::servarr_models::{
@@ -119,7 +118,7 @@ mod test {
  fn test_resource_movie(
    #[values(
      RadarrEvent::AddMovie(AddMovieBody::default()),
-      RadarrEvent::EditMovie(None),
+      RadarrEvent::EditMovie(EditMovieParams::default()),
      RadarrEvent::GetMovies,
      RadarrEvent::GetMovieDetails(None),
      RadarrEvent::DeleteMovie(DeleteMovieParams::default())
@@ -4099,6 +4098,15 @@ mod test {
    *expected_body.get_mut("qualityProfileId").unwrap() = json!(1111);
    *expected_body.get_mut("path").unwrap() = json!("/nfs/Test Path");
    *expected_body.get_mut("tags").unwrap() = json!([1, 2]);
+    let edit_movie_params = EditMovieParams {
+      movie_id: 1,
+      monitored: Some(false),
+      minimum_availability: Some(MinimumAvailability::Announced),
+      quality_profile_id: Some(1111),
+      root_folder_path: Some("/nfs/Test Path".to_owned()),
+      tag_input_string: Some("usenet, testing".into()),
+      ..EditMovieParams::default()
+    };

    let (async_details_server, app_arc, mut server) = mock_servarr_api(
      RequestMethod::Get,
@@ -4113,80 +4121,34 @@ mod test {
    let async_edit_server = server
      .mock(
        "PUT",
-        format!("/api/v3{}/1", RadarrEvent::EditMovie(None).resource()).as_str(),
+        format!("/api/v3{}/1", RadarrEvent::EditMovie(edit_movie_params.clone()).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.radarr_data.tags_map =
-        BiMap::from_iter([(1, "usenet".to_owned()), (2, "testing".to_owned())]);
-      let mut edit_movie = EditMovieModal {
-        tags: "usenet, testing".to_owned().into(),
-        path: "/nfs/Test Path".to_owned().into(),
-        monitored: Some(false),
-        ..EditMovieModal::default()
-      };
-      edit_movie
-        .quality_profile_list
-        .set_items(vec!["Any".to_owned(), "HD - 1080p".to_owned()]);
-      edit_movie
-        .minimum_availability_list
-        .set_items(Vec::from_iter(MinimumAvailability::iter()));
-      app.data.radarr_data.edit_movie_modal = Some(edit_movie);
-      app.data.radarr_data.movies.set_items(vec![Movie {
-        monitored: false,
-        ..movie()
-      }]);
-      app.data.radarr_data.quality_profile_map =
-        BiMap::from_iter([(1111, "Any".to_owned()), (2222, "HD - 1080p".to_owned())]);
-    }
+    app_arc.lock().await.data.radarr_data.tags_map =
+      BiMap::from_iter([(1, "usenet".to_owned()), (2, "testing".to_owned())]);
    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
-      .handle_radarr_event(RadarrEvent::EditMovie(None))
+      .handle_radarr_event(RadarrEvent::EditMovie(edit_movie_params))
      .await
      .is_ok());

    async_details_server.assert_async().await;
    async_edit_server.assert_async().await;
-
-    let app = app_arc.lock().await;
-    assert!(app.data.radarr_data.edit_movie_modal.is_none());
  }

  #[tokio::test]
-  async fn test_handle_edit_movie_event_uses_provided_parameters() {
+  async fn test_handle_edit_movie_event_does_not_overwrite_tags_vec_if_tag_input_string_is_none() {
    let mut expected_body: Value = serde_json::from_str(MOVIE_JSON).unwrap();
    *expected_body.get_mut("monitored").unwrap() = json!(false);
    *expected_body.get_mut("minimumAvailability").unwrap() = json!("announced");
    *expected_body.get_mut("qualityProfileId").unwrap() = json!(1111);
    *expected_body.get_mut("path").unwrap() = json!("/nfs/Test Path");
    *expected_body.get_mut("tags").unwrap() = json!([1, 2]);
-
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(serde_json::from_str(MOVIE_JSON).unwrap()),
-      None,
-      RadarrEvent::GetMovieDetails(None),
-      Some("/1"),
-      None,
-    )
-    .await;
-    let async_edit_server = server
-      .mock(
-        "PUT",
-        format!("/api/v3{}/1", RadarrEvent::EditMovie(None).resource()).as_str(),
-      )
-      .with_status(202)
-      .match_header("X-Api-Key", "test1234")
-      .match_body(Matcher::Json(expected_body))
-      .create_async()
-      .await;
    let edit_movie_params = EditMovieParams {
      movie_id: 1,
      monitored: Some(false),
@@ -4196,10 +4158,32 @@ mod test {
      tags: Some(vec![1, 2]),
      ..EditMovieParams::default()
    };
+    let (async_details_server, app_arc, mut server) = mock_servarr_api(
+      RequestMethod::Get,
+      None,
+      Some(serde_json::from_str(MOVIE_JSON).unwrap()),
+      None,
+      RadarrEvent::GetMovieDetails(None),
+      Some("/1"),
+      None,
+    )
+      .await;
+    let async_edit_server = server
+      .mock(
+        "PUT",
+        format!("/api/v3{}/1", RadarrEvent::EditMovie(edit_movie_params.clone()).resource()).as_str(),
+      )
+      .with_status(202)
+      .match_header("X-Api-Key", "test1234")
+      .match_body(Matcher::Json(expected_body))
+      .create_async()
+      .await;
+    app_arc.lock().await.data.radarr_data.tags_map =
+      BiMap::from_iter([(1, "usenet".to_owned()), (2, "testing".to_owned())]);
    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
-      .handle_radarr_event(RadarrEvent::EditMovie(Some(edit_movie_params)))
+      .handle_radarr_event(RadarrEvent::EditMovie(edit_movie_params))
      .await
      .is_ok());

@@ -4208,7 +4192,7 @@ mod test {
  }

  #[tokio::test]
-  async fn test_handle_edit_movie_event_uses_provided_parameters_defaults_to_previous_values() {
+  async fn test_handle_edit_movie_event_defaults_to_previous_values() {
    let expected_body: Value = serde_json::from_str(MOVIE_JSON).unwrap();
    let (async_details_server, app_arc, mut server) = mock_servarr_api(
      RequestMethod::Get,
@@ -4220,24 +4204,24 @@ mod test {
      None,
    )
    .await;
+    let edit_movie_params = EditMovieParams {
+      movie_id: 1,
+      ..EditMovieParams::default()
+    };
    let async_edit_server = server
      .mock(
        "PUT",
-        format!("/api/v3{}/1", RadarrEvent::EditMovie(None).resource()).as_str(),
+        format!("/api/v3{}/1", RadarrEvent::EditMovie(edit_movie_params.clone()).resource()).as_str(),
      )
      .with_status(202)
      .match_header("X-Api-Key", "test1234")
      .match_body(Matcher::Json(expected_body))
      .create_async()
      .await;
-    let edit_movie_params = EditMovieParams {
-      movie_id: 1,
-      ..EditMovieParams::default()
-    };
    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
-      .handle_radarr_event(RadarrEvent::EditMovie(Some(edit_movie_params)))
+      .handle_radarr_event(RadarrEvent::EditMovie(edit_movie_params))
      .await
      .is_ok());

@@ -4250,7 +4234,6 @@ mod test {
  ) {
    let mut expected_body: Value = serde_json::from_str(MOVIE_JSON).unwrap();
    *expected_body.get_mut("tags").unwrap() = json!([]);
-
    let (async_details_server, app_arc, mut server) = mock_servarr_api(
      RequestMethod::Get,
      None,
@@ -4261,25 +4244,25 @@ mod test {
      None,
    )
    .await;
+    let edit_movie_params = EditMovieParams {
+      movie_id: 1,
+      clear_tags: true,
+      ..EditMovieParams::default()
+    };
    let async_edit_server = server
      .mock(
        "PUT",
-        format!("/api/v3{}/1", RadarrEvent::EditMovie(None).resource()).as_str(),
+        format!("/api/v3{}/1", RadarrEvent::EditMovie(edit_movie_params.clone()).resource()).as_str(),
      )
      .with_status(202)
      .match_header("X-Api-Key", "test1234")
      .match_body(Matcher::Json(expected_body))
      .create_async()
      .await;
-    let edit_movie_params = EditMovieParams {
-      movie_id: 1,
-      clear_tags: true,
-      ..EditMovieParams::default()
-    };
    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
-      .handle_radarr_event(RadarrEvent::EditMovie(Some(edit_movie_params)))
+      .handle_radarr_event(RadarrEvent::EditMovie(edit_movie_params))
      .await
      .is_ok());