feat(readarr): edit Readarr authors and expose the command on the CLI

src/network/readarr_network/library/authors/mod.rs

@@ -1,9 +1,11 @@
 use anyhow::Result;
-use log::info;
-use serde_json::Value;
+use log::{debug, info};
+use serde_json::{Value, json};
 
 use crate::models::Route;
-use crate::models::readarr_models::{AddAuthorBody, AddAuthorSearchResult, Author};
+use crate::models::readarr_models::{
+  AddAuthorBody, AddAuthorSearchResult, Author, EditAuthorParams,
+};
 use crate::models::servarr_data::readarr::readarr_data::ActiveReadarrBlock;
 use crate::models::stateful_table::StatefulTable;
 use crate::network::readarr_network::ReadarrEvent;
@@ -43,6 +45,123 @@ impl Network<'_, '_> {
       .await
   }
 
+  pub(in crate::network::readarr_network) async fn edit_author(
+    &mut self,
+    mut edit_author_params: EditAuthorParams,
+  ) -> Result<()> {
+    info!("Editing Readarr author");
+    if let Some(tag_input_str) = edit_author_params.tag_input_string.as_ref() {
+      let tag_ids_vec = self
+        .extract_and_add_readarr_tag_ids_vec(tag_input_str)
+        .await;
+      edit_author_params.tags = Some(tag_ids_vec);
+    }
+    let author_id = edit_author_params.author_id;
+    let detail_event = ReadarrEvent::GetAuthorDetails(author_id);
+    let event = ReadarrEvent::EditAuthor(EditAuthorParams::default());
+    info!("Fetching author details for author with ID: {author_id}");
+
+    let request_props = self
+      .request_props_from(
+        detail_event,
+        RequestMethod::Get,
+        None::<()>,
+        Some(format!("/{author_id}")),
+        None,
+      )
+      .await;
+
+    let mut response = String::new();
+
+    self
+      .handle_request::<(), Value>(request_props, |detailed_author_body, _| {
+        response = detailed_author_body.to_string()
+      })
+      .await?;
+
+    info!("Constructing edit author body");
+
+    let mut detailed_author_body: Value = serde_json::from_str(&response)?;
+    let (
+      monitored,
+      monitor_new_items,
+      quality_profile_id,
+      metadata_profile_id,
+      root_folder_path,
+      tags,
+    ) = {
+      let monitored = edit_author_params.monitored.unwrap_or(
+        detailed_author_body["monitored"]
+          .as_bool()
+          .expect("Unable to deserialize 'monitored'"),
+      );
+      let monitor_new_items = edit_author_params.monitor_new_items.unwrap_or_else(|| {
+        serde_json::from_value(detailed_author_body["monitorNewItems"].clone())
+          .expect("Unable to deserialize 'monitorNewItems'")
+      });
+      let quality_profile_id = edit_author_params.quality_profile_id.unwrap_or_else(|| {
+        detailed_author_body["qualityProfileId"]
+          .as_i64()
+          .expect("Unable to deserialize 'qualityProfileId'")
+      });
+      let metadata_profile_id = edit_author_params.metadata_profile_id.unwrap_or_else(|| {
+        detailed_author_body["metadataProfileId"]
+          .as_i64()
+          .expect("Unable to deserialize 'metadataProfileId'")
+      });
+      let root_folder_path = edit_author_params.root_folder_path.unwrap_or_else(|| {
+        detailed_author_body["path"]
+          .as_str()
+          .expect("Unable to deserialize 'path'")
+          .to_owned()
+      });
+      let tags = if edit_author_params.clear_tags {
+        vec![]
+      } else {
+        edit_author_params.tags.unwrap_or(
+          detailed_author_body["tags"]
+            .as_array()
+            .expect("Unable to deserialize 'tags'")
+            .iter()
+            .map(|item| item.as_i64().expect("Unable to deserialize tag ID"))
+            .collect(),
+        )
+      };
+
+      (
+        monitored,
+        monitor_new_items,
+        quality_profile_id,
+        metadata_profile_id,
+        root_folder_path,
+        tags,
+      )
+    };
+
+    *detailed_author_body.get_mut("monitored").unwrap() = json!(monitored);
+    *detailed_author_body.get_mut("monitorNewItems").unwrap() = json!(monitor_new_items);
+    *detailed_author_body.get_mut("qualityProfileId").unwrap() = json!(quality_profile_id);
+    *detailed_author_body.get_mut("metadataProfileId").unwrap() = json!(metadata_profile_id);
+    *detailed_author_body.get_mut("path").unwrap() = json!(root_folder_path);
+    *detailed_author_body.get_mut("tags").unwrap() = json!(tags);
+
+    debug!("Edit author body: {detailed_author_body:?}");
+
+    let request_props = self
+      .request_props_from(
+        event,
+        RequestMethod::Put,
+        Some(detailed_author_body),
+        Some(format!("/{author_id}")),
+        None,
+      )
+      .await;
+
+    self
+      .handle_request::<Value, ()>(request_props, |_, _| ())
+      .await
+  }
+
   pub(in crate::network::readarr_network) async fn get_author_details(
     &mut self,
     author_id: i64,

src/network/readarr_network/library/authors/readarr_authors_network_tests.rs

@@ -1,10 +1,12 @@
 #[cfg(test)]
 mod tests {
   use crate::models::readarr_models::{
-    AddAuthorBody, AddAuthorSearchResult, Author, ReadarrSerdeable,
+    AddAuthorBody, AddAuthorSearchResult, Author, EditAuthorParams, NewItemMonitorType,
+    ReadarrSerdeable,
   };
   use crate::models::servarr_data::readarr::readarr_data::ActiveReadarrBlock;
   use crate::models::stateful_table::StatefulTable;
+  use crate::network::NetworkResource;
   use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
   use crate::network::readarr_network::ReadarrEvent;
   use crate::network::readarr_network::readarr_network_test_utils::test_utils::{
@@ -12,6 +14,7 @@ mod tests {
     stale_author,
   };
   use bimap::BiMap;
+  use mockito::Matcher;
   use pretty_assertions::assert_eq;
   use serde_json::{Value, json};
 
@@ -387,4 +390,239 @@ mod tests {
     mock.assert_async().await;
     assert_err!(result);
   }
+
+  #[tokio::test]
+  async fn test_handle_edit_author_event() {
+    let mut expected_body: Value = serde_json::from_str(AUTHOR_JSON).unwrap();
+    *expected_body.get_mut("monitored").unwrap() = json!(false);
+    *expected_body.get_mut("monitorNewItems").unwrap() = json!("none");
+    *expected_body.get_mut("qualityProfileId").unwrap() = json!(1111);
+    *expected_body.get_mut("metadataProfileId").unwrap() = json!(2222);
+    *expected_body.get_mut("path").unwrap() = json!("/nfs/Test Path");
+    *expected_body.get_mut("tags").unwrap() = json!([1, 2]);
+    let edit_author_params = EditAuthorParams {
+      author_id: 1,
+      monitored: Some(false),
+      monitor_new_items: Some(NewItemMonitorType::None),
+      quality_profile_id: Some(1111),
+      metadata_profile_id: Some(2222),
+      root_folder_path: Some("/nfs/Test Path".to_owned()),
+      tag_input_string: Some("usenet, testing".to_owned()),
+      ..EditAuthorParams::default()
+    };
+    let (async_details_server, app, mut server) = MockServarrApi::get()
+      .returns(serde_json::from_str(AUTHOR_JSON).unwrap())
+      .path("/1")
+      .build_for(ReadarrEvent::GetAuthorDetails(1))
+      .await;
+    let async_edit_server = server
+      .mock(
+        "PUT",
+        format!(
+          "/api/v1{}/1",
+          ReadarrEvent::EditAuthor(edit_author_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.lock().await;
+      app.server_tabs.set_index(3);
+      app.data.readarr_data.tags_map =
+        BiMap::from_iter([(1, "usenet".to_owned()), (2, "testing".to_owned())]);
+      app
+        .data
+        .readarr_data
+        .authors
+        .set_items(vec![stale_author()]);
+    }
+    let mut network = test_network(&app);
+
+    let result = network
+      .handle_readarr_event(ReadarrEvent::EditAuthor(edit_author_params))
+      .await;
+
+    async_details_server.assert_async().await;
+    async_edit_server.assert_async().await;
+    assert_ok!(result);
+    let app = app.lock().await;
+    assert_eq!(app.data.readarr_data.authors.items, vec![stale_author()]);
+  }
+
+  #[tokio::test]
+  async fn test_handle_edit_author_event_does_not_overwrite_tags_vec_when_tag_input_string_is_none()
+  {
+    let mut expected_body: Value = serde_json::from_str(AUTHOR_JSON).unwrap();
+    *expected_body.get_mut("monitored").unwrap() = json!(false);
+    *expected_body.get_mut("monitorNewItems").unwrap() = json!("none");
+    *expected_body.get_mut("qualityProfileId").unwrap() = json!(1111);
+    *expected_body.get_mut("metadataProfileId").unwrap() = json!(2222);
+    *expected_body.get_mut("path").unwrap() = json!("/nfs/Test Path");
+    *expected_body.get_mut("tags").unwrap() = json!([1, 2]);
+    let edit_author_params = EditAuthorParams {
+      author_id: 1,
+      monitored: Some(false),
+      monitor_new_items: Some(NewItemMonitorType::None),
+      quality_profile_id: Some(1111),
+      metadata_profile_id: Some(2222),
+      root_folder_path: Some("/nfs/Test Path".to_owned()),
+      tags: Some(vec![1, 2]),
+      ..EditAuthorParams::default()
+    };
+    let (async_details_server, app, mut server) = MockServarrApi::get()
+      .returns(serde_json::from_str(AUTHOR_JSON).unwrap())
+      .path("/1")
+      .build_for(ReadarrEvent::GetAuthorDetails(1))
+      .await;
+    let async_edit_server = server
+      .mock(
+        "PUT",
+        format!(
+          "/api/v1{}/1",
+          ReadarrEvent::EditAuthor(edit_author_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.lock().await;
+      app.server_tabs.set_index(3);
+      app.data.readarr_data.tags_map =
+        BiMap::from_iter([(1, "usenet".to_owned()), (2, "testing".to_owned())]);
+    }
+    let mut network = test_network(&app);
+
+    let result = network
+      .handle_readarr_event(ReadarrEvent::EditAuthor(edit_author_params))
+      .await;
+
+    async_details_server.assert_async().await;
+    async_edit_server.assert_async().await;
+    assert_ok!(result);
+  }
+
+  #[tokio::test]
+  async fn test_handle_edit_author_event_defaults_to_previous_values() {
+    let edit_author_params = EditAuthorParams {
+      author_id: 1,
+      ..EditAuthorParams::default()
+    };
+    let expected_body: Value = serde_json::from_str(AUTHOR_JSON).unwrap();
+    let (async_details_server, app, mut server) = MockServarrApi::get()
+      .returns(serde_json::from_str(AUTHOR_JSON).unwrap())
+      .path("/1")
+      .build_for(ReadarrEvent::GetAuthorDetails(1))
+      .await;
+    let async_edit_server = server
+      .mock(
+        "PUT",
+        format!(
+          "/api/v1{}/1",
+          ReadarrEvent::EditAuthor(edit_author_params.clone()).resource()
+        )
+        .as_str(),
+      )
+      .with_status(202)
+      .match_header("X-Api-Key", "test1234")
+      .match_body(Matcher::Json(expected_body))
+      .create_async()
+      .await;
+    app.lock().await.server_tabs.set_index(3);
+    let mut network = test_network(&app);
+
+    let result = network
+      .handle_readarr_event(ReadarrEvent::EditAuthor(edit_author_params))
+      .await;
+
+    async_details_server.assert_async().await;
+    async_edit_server.assert_async().await;
+    assert_ok!(result);
+  }
+
+  #[tokio::test]
+  async fn test_handle_edit_author_event_returns_empty_tags_vec_when_clear_tags_is_true() {
+    let mut expected_body: Value = serde_json::from_str(AUTHOR_JSON).unwrap();
+    *expected_body.get_mut("tags").unwrap() = json!([]);
+    let edit_author_params = EditAuthorParams {
+      author_id: 1,
+      clear_tags: true,
+      ..EditAuthorParams::default()
+    };
+    let (async_details_server, app, mut server) = MockServarrApi::get()
+      .returns(serde_json::from_str(AUTHOR_JSON).unwrap())
+      .path("/1")
+      .build_for(ReadarrEvent::GetAuthorDetails(1))
+      .await;
+    let async_edit_server = server
+      .mock(
+        "PUT",
+        format!(
+          "/api/v1{}/1",
+          ReadarrEvent::EditAuthor(edit_author_params.clone()).resource()
+        )
+        .as_str(),
+      )
+      .with_status(202)
+      .match_header("X-Api-Key", "test1234")
+      .match_body(Matcher::Json(expected_body))
+      .create_async()
+      .await;
+    app.lock().await.server_tabs.set_index(3);
+    let mut network = test_network(&app);
+
+    let result = network
+      .handle_readarr_event(ReadarrEvent::EditAuthor(edit_author_params))
+      .await;
+
+    async_details_server.assert_async().await;
+    async_edit_server.assert_async().await;
+    assert_ok!(result);
+  }
+
+  #[tokio::test]
+  async fn test_handle_edit_author_event_failure() {
+    let edit_author_params = EditAuthorParams {
+      author_id: 1,
+      monitored: Some(false),
+      ..EditAuthorParams::default()
+    };
+    let (async_details_server, app, mut server) = MockServarrApi::get()
+      .returns(serde_json::from_str(AUTHOR_JSON).unwrap())
+      .status(404)
+      .path("/1")
+      .build_for(ReadarrEvent::GetAuthorDetails(1))
+      .await;
+    let async_edit_server = server
+      .mock(
+        "PUT",
+        format!(
+          "/api/v1{}/1",
+          ReadarrEvent::EditAuthor(edit_author_params.clone()).resource()
+        )
+        .as_str(),
+      )
+      .with_status(202)
+      .match_header("X-Api-Key", "test1234")
+      .expect(0)
+      .create_async()
+      .await;
+    app.lock().await.server_tabs.set_index(3);
+    let mut network = test_network(&app);
+
+    let result = network
+      .handle_readarr_event(ReadarrEvent::EditAuthor(edit_author_params))
+      .await;
+
+    async_details_server.assert_async().await;
+    async_edit_server.assert_async().await;
+    assert_err!(result);
+  }
 }

src/network/readarr_network/mod.rs

@@ -4,7 +4,7 @@ use serde_json::{Value, json};
 
 use super::{NetworkEvent, NetworkResource};
 use crate::models::readarr_models::{
-  AddAuthorBody, AddReadarrRootFolderBody, ReadarrSerdeable, ReadarrTaskName,
+  AddAuthorBody, AddReadarrRootFolderBody, EditAuthorParams, ReadarrSerdeable, ReadarrTaskName,
 };
 use crate::models::servarr_models::{MetadataProfile, QualityProfile, Tag};
 use crate::network::{Network, RequestMethod};
@@ -28,6 +28,7 @@ pub enum ReadarrEvent {
   AddTag(String),
   DeleteRootFolder(i64),
   DeleteTag(i64),
+  EditAuthor(EditAuthorParams),
   GetAuthorDetails(i64),
   GetDiskSpace,
   GetHostConfig,
@@ -51,6 +52,7 @@ impl NetworkResource for ReadarrEvent {
   fn resource(&self) -> &'static str {
     match &self {
       ReadarrEvent::AddAuthor(_)
+      | ReadarrEvent::EditAuthor(_)
       | ReadarrEvent::GetAuthorDetails(_)
       | ReadarrEvent::ListAuthors => "/author",
       ReadarrEvent::SearchNewAuthor(_) => "/author/lookup",
@@ -98,6 +100,10 @@ impl Network<'_, '_> {
         .delete_readarr_tag(tag_id)
         .await
         .map(ReadarrSerdeable::from),
+      ReadarrEvent::EditAuthor(edit_author_params) => self
+        .edit_author(edit_author_params)
+        .await
+        .map(ReadarrSerdeable::from),
       ReadarrEvent::GetAuthorDetails(author_id) => self
         .get_author_details(author_id)
         .await

src/network/readarr_network/readarr_network_tests.rs

@@ -1,7 +1,9 @@
 #[cfg(test)]
 mod tests {
   use crate::app::App;
-  use crate::models::readarr_models::{AddAuthorBody, AddReadarrRootFolderBody, ReadarrSerdeable};
+  use crate::models::readarr_models::{
+    AddAuthorBody, AddReadarrRootFolderBody, EditAuthorParams, ReadarrSerdeable,
+  };
   use crate::models::servarr_models::{MetadataProfile, QualityProfile, Tag};
   use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
   use crate::network::{NetworkEvent, NetworkResource, readarr_network::ReadarrEvent};
@@ -14,6 +16,7 @@ mod tests {
 
   #[rstest]
   #[case(ReadarrEvent::AddAuthor(AddAuthorBody::default()), "/author")]
+  #[case(ReadarrEvent::EditAuthor(EditAuthorParams::default()), "/author")]
   #[case(ReadarrEvent::GetAuthorDetails(1), "/author")]
   #[case(ReadarrEvent::ListAuthors, "/author")]
   #[case(ReadarrEvent::SearchNewAuthor(String::new()), "/author/lookup")]