feat(readarr): fetch Readarr book history and expose it on the CLI

src/cli/readarr/list_command_handler.rs

@@ -46,6 +46,21 @@ pub enum ReadarrListCommand {
     )]
     book_id: i64,
   },
+  #[command(about = "Fetch all history events for the book with the given ID")]
+  BookHistory {
+    #[arg(
+      long,
+      help = "The Readarr ID of the author who wrote the book whose history you wish to fetch",
+      required = true
+    )]
+    author_id: i64,
+    #[arg(
+      long,
+      help = "The Readarr ID of the book whose history you wish to fetch",
+      required = true
+    )]
+    book_id: i64,
+  },
   #[command(about = "List all books for the author with the given ID")]
   Books {
     #[arg(
@@ -138,6 +153,13 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, ReadarrListCommand> for ReadarrListComman
           .await?;
         serde_json::to_string_pretty(&resp)?
       }
+      ReadarrListCommand::BookHistory { author_id, book_id } => {
+        let resp = self
+          .network
+          .handle_network_event(ReadarrEvent::GetBookHistory(author_id, book_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
       ReadarrListCommand::Books { author_id } => {
         let resp = self
           .network

src/cli/readarr/list_command_handler_tests.rs

@@ -164,6 +164,45 @@ mod tests {
       assert_eq!(book_files_command, expected_args);
     }
 
+    #[test]
+    fn test_list_book_history_requires_author_id_and_book_id() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "readarr", "list", "book-history"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_list_book_history_success() {
+      let expected_args = ReadarrListCommand::BookHistory {
+        author_id: 1,
+        book_id: 2,
+      };
+      let result = Cli::try_parse_from([
+        "managarr",
+        "readarr",
+        "list",
+        "book-history",
+        "--author-id",
+        "1",
+        "--book-id",
+        "2",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Readarr(ReadarrCommand::List(book_history_command))) =
+        result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(book_history_command, expected_args);
+    }
+
     #[test]
     fn test_list_books_success() {
       let expected_args = ReadarrListCommand::Books { author_id: 1 };
@@ -341,6 +380,36 @@ mod tests {
       assert_ok!(&result);
     }
 
+    #[tokio::test]
+    async fn test_handle_list_book_history_command() {
+      let expected_author_id = 1;
+      let expected_book_id = 2;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          ReadarrEvent::GetBookHistory(expected_author_id, expected_book_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Readarr(ReadarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let list_book_history_command = ReadarrListCommand::BookHistory {
+        author_id: 1,
+        book_id: 2,
+      };
+
+      let result =
+        ReadarrListCommandHandler::with(&app_arc, list_book_history_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
     #[tokio::test]
     async fn test_handle_list_disk_space_command() {
       let mut mock_network = MockNetworkTrait::new();

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

@@ -1,7 +1,9 @@
 use anyhow::Result;
 use log::info;
 
-use crate::models::readarr_models::{Book, BookFile, Edition};
+use crate::models::Route;
+use crate::models::readarr_models::{Book, BookFile, Edition, ReadarrHistoryItem};
+use crate::models::servarr_data::readarr::readarr_data::ActiveReadarrBlock;
 use crate::network::readarr_network::ReadarrEvent;
 use crate::network::{Network, RequestMethod};
 
@@ -117,4 +119,44 @@ impl Network<'_, '_> {
       })
       .await
   }
+
+  pub(in crate::network::readarr_network) async fn get_readarr_book_history(
+    &mut self,
+    author_id: i64,
+    book_id: i64,
+  ) -> Result<Vec<ReadarrHistoryItem>> {
+    info!("Fetching Readarr book history for book with ID: {book_id}");
+    let event = ReadarrEvent::GetBookHistory(author_id, book_id);
+
+    let request_props = self
+      .request_props_from(
+        event,
+        RequestMethod::Get,
+        None::<()>,
+        None,
+        Some(format!("authorId={author_id}&bookId={book_id}")),
+      )
+      .await;
+
+    self
+      .handle_request::<(), Vec<ReadarrHistoryItem>>(request_props, |mut history_vec, mut app| {
+        let is_sorting = matches!(
+          app.get_current_route(),
+          Route::Readarr(ActiveReadarrBlock::BookHistorySortPrompt, _)
+        );
+
+        let book_details_modal = app
+          .data
+          .readarr_data
+          .book_details_modal
+          .get_or_insert_default();
+
+        if !is_sorting {
+          history_vec.sort_by_key(|item| item.id);
+          book_details_modal.book_history.set_items(history_vec);
+          book_details_modal.book_history.apply_sorting_toggle(false);
+        }
+      })
+      .await
+  }
 }

src/network/readarr_network/library/books/readarr_books_network_tests.rs

@@ -1,13 +1,19 @@
 #[cfg(test)]
 mod tests {
-  use crate::models::readarr_models::{Book, BookFile, Edition, ReadarrSerdeable};
+  use crate::models::readarr_models::{
+    Book, BookFile, Edition, ReadarrHistoryItem, ReadarrSerdeable,
+  };
   use crate::models::servarr_data::readarr::modals::BookDetailsModal;
+  use crate::models::servarr_data::readarr::readarr_data::ActiveReadarrBlock;
+  use crate::models::stateful_table::SortOption;
   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::{
-    BOOK_FILE_JSON, BOOK_JSON, EDITION_JSON, stale_book, stale_book_file, stale_edition,
+    BOOK_FILE_JSON, BOOK_JSON, EDITION_JSON, readarr_history_item, stale_book, stale_book_file,
+    stale_edition, stale_readarr_history_item,
   };
   use pretty_assertions::assert_eq;
+  use rstest::rstest;
   use serde_json::{Value, json};
 
   #[tokio::test]
@@ -477,4 +483,290 @@ mod tests {
     assert_err!(result);
     assert_eq!(app.lock().await.data.readarr_data.books.items, stale_books);
   }
+
+  #[rstest]
+  #[tokio::test]
+  async fn test_handle_get_readarr_book_history_event(
+    #[values(true, false)] use_custom_sorting: bool,
+  ) {
+    let history_json = json!([{
+      "id": 456,
+      "authorId": 2001,
+      "bookId": 2001,
+      "sourceTitle": "An Anthology",
+      "quality": { "quality": { "name": "AZW3" } },
+      "date": "2023-01-01T00:00:00Z",
+      "eventType": "grabbed",
+      "data": {
+        "droppedPath": "/nfs/nzbget/completed/books/Something/cool.azw3",
+        "importedPath": "/nfs/books/Test Author/Book 1/Cool.azw3"
+      }
+    },
+    {
+      "id": 123,
+      "authorId": 1007,
+      "bookId": 1007,
+      "sourceTitle": "z book",
+      "quality": { "quality": { "name": "AZW3" } },
+      "date": "2023-01-01T00:00:00Z",
+      "eventType": "grabbed",
+      "data": {
+        "droppedPath": "/nfs/nzbget/completed/books/Something/cool.azw3",
+        "importedPath": "/nfs/books/Test Author/Book 1/Cool.azw3"
+      }
+    }]);
+    let response: Vec<ReadarrHistoryItem> = serde_json::from_value(history_json.clone()).unwrap();
+    let mut expected_history_items = vec![
+      ReadarrHistoryItem {
+        id: 123,
+        author_id: 1007,
+        book_id: 1007,
+        source_title: "z book".into(),
+        ..readarr_history_item()
+      },
+      ReadarrHistoryItem {
+        id: 456,
+        author_id: 2001,
+        book_id: 2001,
+        source_title: "An Anthology".into(),
+        ..readarr_history_item()
+      },
+    ];
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(history_json)
+      .query("authorId=1&bookId=2")
+      .build_for(ReadarrEvent::GetBookHistory(1, 2))
+      .await;
+    app.lock().await.data.readarr_data.book_details_modal = Some(BookDetailsModal::default());
+    if use_custom_sorting {
+      let cmp_fn = |a: &ReadarrHistoryItem, b: &ReadarrHistoryItem| {
+        a.source_title
+          .text
+          .to_lowercase()
+          .cmp(&b.source_title.text.to_lowercase())
+      };
+      expected_history_items.sort_by(cmp_fn);
+
+      let history_sort_option = SortOption {
+        name: "Source Title",
+        cmp_fn: Some(cmp_fn),
+      };
+      app
+        .lock()
+        .await
+        .data
+        .readarr_data
+        .book_details_modal
+        .as_mut()
+        .unwrap()
+        .book_history
+        .sorting(vec![history_sort_option]);
+    }
+    {
+      let mut app = app.lock().await;
+      app.server_tabs.set_index(3);
+      app
+        .data
+        .readarr_data
+        .book_details_modal
+        .as_mut()
+        .unwrap()
+        .book_history
+        .sort_asc = true;
+    }
+    let mut network = test_network(&app);
+
+    let result = network
+      .handle_readarr_event(ReadarrEvent::GetBookHistory(1, 2))
+      .await;
+
+    mock.assert_async().await;
+
+    let ReadarrSerdeable::ReadarrHistoryItems(history_items) = result.unwrap() else {
+      panic!("Expected ReadarrHistoryItems")
+    };
+
+    assert_eq!(history_items, response);
+    let app = app.lock().await;
+    let book_details_modal = app.data.readarr_data.book_details_modal.as_ref().unwrap();
+    assert_eq!(
+      book_details_modal.book_history.items,
+      expected_history_items
+    );
+    assert!(book_details_modal.book_history.sort_asc);
+  }
+
+  #[tokio::test]
+  async fn test_handle_get_readarr_book_history_event_no_op_when_user_is_selecting_sort_options() {
+    let history_json = json!([{
+      "id": 456,
+      "authorId": 2001,
+      "bookId": 2001,
+      "sourceTitle": "An Anthology",
+      "quality": { "quality": { "name": "AZW3" } },
+      "date": "2023-01-01T00:00:00Z",
+      "eventType": "grabbed",
+      "data": {
+        "droppedPath": "/nfs/nzbget/completed/books/Something/cool.azw3",
+        "importedPath": "/nfs/books/Test Author/Book 1/Cool.azw3"
+      }
+    },
+    {
+      "id": 123,
+      "authorId": 1007,
+      "bookId": 1007,
+      "sourceTitle": "z book",
+      "quality": { "quality": { "name": "AZW3" } },
+      "date": "2023-01-01T00:00:00Z",
+      "eventType": "grabbed",
+      "data": {
+        "droppedPath": "/nfs/nzbget/completed/books/Something/cool.azw3",
+        "importedPath": "/nfs/books/Test Author/Book 1/Cool.azw3"
+      }
+    }]);
+    let response: Vec<ReadarrHistoryItem> = serde_json::from_value(history_json.clone()).unwrap();
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(history_json)
+      .query("authorId=1&bookId=2")
+      .build_for(ReadarrEvent::GetBookHistory(1, 2))
+      .await;
+    {
+      let mut app = app.lock().await;
+      app.server_tabs.set_index(3);
+      let mut book_details_modal = BookDetailsModal::default();
+      book_details_modal.book_history.sort_asc = true;
+      app.data.readarr_data.book_details_modal = Some(book_details_modal);
+      app.push_navigation_stack(ActiveReadarrBlock::BookHistorySortPrompt.into());
+    }
+    let mut network = test_network(&app);
+
+    let result = network
+      .handle_readarr_event(ReadarrEvent::GetBookHistory(1, 2))
+      .await;
+
+    mock.assert_async().await;
+
+    let ReadarrSerdeable::ReadarrHistoryItems(history_items) = result.unwrap() else {
+      panic!("Expected ReadarrHistoryItems")
+    };
+
+    assert_eq!(history_items, response);
+    let app = app.lock().await;
+    let book_details_modal = app.data.readarr_data.book_details_modal.as_ref().unwrap();
+    assert_is_empty!(book_details_modal.book_history);
+    assert!(book_details_modal.book_history.sort_asc);
+  }
+
+  #[tokio::test]
+  async fn test_handle_get_readarr_book_history_event_empty_book_details_modal() {
+    let history_json = json!([{
+      "id": 123,
+      "authorId": 1007,
+      "bookId": 1007,
+      "sourceTitle": "z book",
+      "quality": { "quality": { "name": "AZW3" } },
+      "date": "2023-01-01T00:00:00Z",
+      "eventType": "grabbed",
+      "data": {
+        "droppedPath": "/nfs/nzbget/completed/books/Something/cool.azw3",
+        "importedPath": "/nfs/books/Test Author/Book 1/Cool.azw3"
+      }
+    }]);
+    let expected_history_items = vec![ReadarrHistoryItem {
+      id: 123,
+      author_id: 1007,
+      book_id: 1007,
+      source_title: "z book".into(),
+      ..readarr_history_item()
+    }];
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(history_json)
+      .query("authorId=1&bookId=2")
+      .build_for(ReadarrEvent::GetBookHistory(1, 2))
+      .await;
+    app.lock().await.server_tabs.set_index(3);
+    let mut network = test_network(&app);
+
+    let result = network
+      .handle_readarr_event(ReadarrEvent::GetBookHistory(1, 2))
+      .await;
+
+    mock.assert_async().await;
+
+    let ReadarrSerdeable::ReadarrHistoryItems(history_items) = result.unwrap() else {
+      panic!("Expected ReadarrHistoryItems")
+    };
+
+    assert_eq!(history_items, expected_history_items);
+
+    let app = app.lock().await;
+
+    assert_some!(&app.data.readarr_data.book_details_modal);
+    assert_eq!(
+      app
+        .data
+        .readarr_data
+        .book_details_modal
+        .as_ref()
+        .unwrap()
+        .book_history
+        .items,
+      expected_history_items
+    );
+  }
+
+  #[tokio::test]
+  async fn test_handle_get_readarr_book_history_event_failure() {
+    let history_json = json!([{
+      "id": 123,
+      "authorId": 1007,
+      "bookId": 1007,
+      "sourceTitle": "z book",
+      "quality": { "quality": { "name": "AZW3" } },
+      "date": "2023-01-01T00:00:00Z",
+      "eventType": "grabbed",
+      "data": {
+        "droppedPath": "/nfs/nzbget/completed/books/Something/cool.azw3",
+        "importedPath": "/nfs/books/Test Author/Book 1/Cool.azw3"
+      }
+    }]);
+    let stale_history_items = vec![stale_readarr_history_item()];
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(history_json)
+      .status(500)
+      .query("authorId=1&bookId=2")
+      .build_for(ReadarrEvent::GetBookHistory(1, 2))
+      .await;
+    {
+      let mut app = app.lock().await;
+      app.server_tabs.set_index(3);
+      let mut book_details_modal = BookDetailsModal::default();
+      book_details_modal
+        .book_history
+        .set_items(stale_history_items.clone());
+      app.data.readarr_data.book_details_modal = Some(book_details_modal);
+    }
+    let mut network = test_network(&app);
+
+    let result = network
+      .handle_readarr_event(ReadarrEvent::GetBookHistory(1, 2))
+      .await;
+
+    mock.assert_async().await;
+
+    assert_err!(result);
+    assert_eq!(
+      app
+        .lock()
+        .await
+        .data
+        .readarr_data
+        .book_details_modal
+        .as_ref()
+        .unwrap()
+        .book_history
+        .items,
+      stale_history_items
+    );
+  }
 }

src/network/readarr_network/mod.rs

@@ -36,6 +36,7 @@ pub enum ReadarrEvent {
   GetBookDetails(i64),
   GetBookEditions(i64),
   GetBookFiles(i64),
+  GetBookHistory(i64, i64),
   GetBooks(i64),
   GetDiskSpace,
   GetHostConfig,
@@ -80,7 +81,7 @@ impl NetworkResource for ReadarrEvent {
       ReadarrEvent::GetDiskSpace => "/diskspace",
       ReadarrEvent::GetBookEditions(_) => "/edition",
       ReadarrEvent::HealthCheck => "/health",
-      ReadarrEvent::GetAuthorHistory(_) => "/history/author",
+      ReadarrEvent::GetAuthorHistory(_) | ReadarrEvent::GetBookHistory(_, _) => "/history/author",
       ReadarrEvent::GetLogs(_) => "/log",
       ReadarrEvent::GetMetadataProfiles => "/metadataprofile",
       ReadarrEvent::GetQualityProfiles => "/qualityprofile",
@@ -149,6 +150,10 @@ impl Network<'_, '_> {
         .get_book_files(book_id)
         .await
         .map(ReadarrSerdeable::from),
+      ReadarrEvent::GetBookHistory(author_id, book_id) => self
+        .get_readarr_book_history(author_id, book_id)
+        .await
+        .map(ReadarrSerdeable::from),
       ReadarrEvent::GetBooks(author_id) => {
         self.get_books(author_id).await.map(ReadarrSerdeable::from)
       }

src/network/readarr_network/readarr_network_tests.rs

@@ -36,6 +36,7 @@ mod tests {
   #[case(ReadarrEvent::GetBookEditions(1), "/edition")]
   #[case(ReadarrEvent::HealthCheck, "/health")]
   #[case(ReadarrEvent::GetAuthorHistory(1), "/history/author")]
+  #[case(ReadarrEvent::GetBookHistory(1, 2), "/history/author")]
   #[case(ReadarrEvent::GetLogs(500), "/log")]
   #[case(ReadarrEvent::GetMetadataProfiles, "/metadataprofile")]
   #[case(ReadarrEvent::GetQualityProfiles, "/qualityprofile")]