feat: Bulk added CLI support for tracks and album functionalities in Lidarr

src/network/lidarr_network/library/albums/lidarr_albums_network_tests.rs

@@ -1,11 +1,18 @@
 #[cfg(test)]
 mod tests {
-  use crate::models::lidarr_models::{Album, DeleteParams, LidarrSerdeable};
+  use crate::models::lidarr_models::{
+    Album, DeleteParams, LidarrHistoryItem, LidarrRelease, LidarrSerdeable,
+  };
+  use crate::models::servarr_data::lidarr::modals::AlbumDetailsModal;
+  use crate::models::stateful_table::SortOption;
   use crate::network::lidarr_network::LidarrEvent;
-  use crate::network::lidarr_network::lidarr_network_test_utils::test_utils::ALBUM_JSON;
+  use crate::network::lidarr_network::lidarr_network_test_utils::test_utils::{
+    ALBUM_JSON, lidarr_history_item, torrent_release,
+  };
   use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
   use mockito::Matcher;
   use pretty_assertions::assert_eq;
+  use rstest::rstest;
   use serde_json::{Value, json};
 
   #[tokio::test]
@@ -128,4 +135,397 @@ mod tests {
 
     assert_eq!(album, expected_album);
   }
+
+  #[rstest]
+  #[tokio::test]
+  async fn test_handle_get_lidarr_album_history_event(
+    #[values(true, false)] use_custom_sorting: bool,
+  ) {
+    let history_json = json!([{
+      "id": 123,
+      "sourceTitle": "z album",
+      "albumId": 1007,
+      "artistId": 1007,
+      "quality": { "quality": { "name": "Lossless" } },
+      "date": "2023-01-01T00:00:00Z",
+      "eventType": "grabbed",
+      "data": {
+        "droppedPath": "/nfs/nzbget/completed/music/Something/cool.mp3",
+        "importedPath": "/nfs/music/Something/Album 1/Cool.mp3"
+      }
+    },
+    {
+      "id": 456,
+      "sourceTitle": "An Album",
+      "albumId": 2001,
+      "artistId": 2001,
+      "quality": { "quality": { "name": "Lossless" } },
+      "date": "2023-01-01T00:00:00Z",
+      "eventType": "grabbed",
+      "data": {
+        "droppedPath": "/nfs/nzbget/completed/music/Something/cool.mp3",
+        "importedPath": "/nfs/music/Something/Album 1/Cool.mp3"
+      }
+    }]);
+    let response: Vec<LidarrHistoryItem> = serde_json::from_value(history_json.clone()).unwrap();
+    let mut expected_history_items = vec![
+      LidarrHistoryItem {
+        id: 123,
+        artist_id: 1007,
+        album_id: 1007,
+        source_title: "z album".into(),
+        ..lidarr_history_item()
+      },
+      LidarrHistoryItem {
+        id: 456,
+        artist_id: 2001,
+        album_id: 2001,
+        source_title: "An Album".into(),
+        ..lidarr_history_item()
+      },
+    ];
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(history_json)
+      .query("artistId=1&albumId=1")
+      .build_for(LidarrEvent::GetAlbumHistory(1, 1))
+      .await;
+    app.lock().await.data.lidarr_data.album_details_modal = Some(AlbumDetailsModal::default());
+    if use_custom_sorting {
+      let cmp_fn = |a: &LidarrHistoryItem, b: &LidarrHistoryItem| {
+        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
+        .lidarr_data
+        .album_details_modal
+        .as_mut()
+        .unwrap()
+        .album_history
+        .sorting(vec![history_sort_option]);
+    }
+    app
+      .lock()
+      .await
+      .data
+      .lidarr_data
+      .album_details_modal
+      .as_mut()
+      .unwrap()
+      .album_history
+      .sort_asc = true;
+    app.lock().await.server_tabs.set_index(2);
+    let mut network = test_network(&app);
+
+    let LidarrSerdeable::LidarrHistoryItems(history) = network
+      .handle_lidarr_event(LidarrEvent::GetAlbumHistory(1, 1))
+      .await
+      .unwrap()
+    else {
+      panic!("Expected LidarrHistoryItems")
+    };
+    mock.assert_async().await;
+    assert_eq!(
+      app
+        .lock()
+        .await
+        .data
+        .lidarr_data
+        .album_details_modal
+        .as_ref()
+        .unwrap()
+        .album_history
+        .items,
+      expected_history_items
+    );
+    assert!(
+      app
+        .lock()
+        .await
+        .data
+        .lidarr_data
+        .album_details_modal
+        .as_ref()
+        .unwrap()
+        .album_history
+        .sort_asc
+    );
+    assert_eq!(history, response);
+  }
+
+  #[tokio::test]
+  async fn test_handle_get_lidarr_album_history_event_empty_album_details_modal() {
+    let history_json = json!([{
+      "id": 123,
+      "sourceTitle": "z album",
+      "albumId": 1007,
+      "artistId": 1007,
+      "quality": { "quality": { "name": "Lossless" } },
+      "date": "2023-01-01T00:00:00Z",
+      "eventType": "grabbed",
+      "data": {
+        "droppedPath": "/nfs/nzbget/completed/music/Something/cool.mp3",
+        "importedPath": "/nfs/music/Something/Album 1/Cool.mp3"
+      }
+    },
+    {
+      "id": 456,
+      "sourceTitle": "An Album",
+      "albumId": 2001,
+      "artistId": 2001,
+      "quality": { "quality": { "name": "Lossless" } },
+      "date": "2023-01-01T00:00:00Z",
+      "eventType": "grabbed",
+      "data": {
+        "droppedPath": "/nfs/nzbget/completed/music/Something/cool.mp3",
+        "importedPath": "/nfs/music/Something/Album 1/Cool.mp3"
+      }
+    }]);
+    let response: Vec<LidarrHistoryItem> = serde_json::from_value(history_json.clone()).unwrap();
+    let expected_history_items = vec![
+      LidarrHistoryItem {
+        id: 123,
+        artist_id: 1007,
+        album_id: 1007,
+        source_title: "z album".into(),
+        ..lidarr_history_item()
+      },
+      LidarrHistoryItem {
+        id: 456,
+        artist_id: 2001,
+        album_id: 2001,
+        source_title: "An Album".into(),
+        ..lidarr_history_item()
+      },
+    ];
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(history_json)
+      .query("artistId=1&albumId=1")
+      .build_for(LidarrEvent::GetAlbumHistory(1, 1))
+      .await;
+    app.lock().await.server_tabs.set_index(2);
+    let mut network = test_network(&app);
+
+    let LidarrSerdeable::LidarrHistoryItems(history) = network
+      .handle_lidarr_event(LidarrEvent::GetAlbumHistory(1, 1))
+      .await
+      .unwrap()
+    else {
+      panic!("Expected LidarrHistoryItems")
+    };
+    mock.assert_async().await;
+    let app = app.lock().await;
+    assert_some!(&app.data.lidarr_data.album_details_modal);
+    assert_eq!(
+      app
+        .data
+        .lidarr_data
+        .album_details_modal
+        .as_ref()
+        .unwrap()
+        .album_history
+        .items,
+      expected_history_items
+    );
+    assert!(
+      !app
+        .data
+        .lidarr_data
+        .album_details_modal
+        .as_ref()
+        .unwrap()
+        .album_history
+        .sort_asc
+    );
+    assert_eq!(history, response);
+  }
+
+  #[tokio::test]
+  async fn test_handle_get_album_releases_event() {
+    let release_json = json!([
+      {
+        "guid": "1234",
+        "protocol": "torrent",
+        "age": 1,
+        "title": "Test Release",
+        "indexer": "kickass torrents",
+        "indexerId": 2,
+        "artistName": "Alex",
+        "albumTitle": "Something",
+        "size": 1234,
+        "rejected": true,
+        "rejections": [ "Unknown quality profile", "Release is already mapped" ],
+        "seeders": 2,
+        "leechers": 1,
+        "quality": { "quality": { "name": "Lossless" }},
+        "discography": true
+      },
+      {
+        "guid": "4567",
+        "protocol": "torrent",
+        "age": 1,
+        "title": "Test Release",
+        "indexer": "kickass torrents",
+        "indexerId": 2,
+        "artistName": "Alex",
+        "albumTitle": "Something",
+        "size": 1234,
+        "rejected": true,
+        "rejections": [ "Unknown quality profile", "Release is already mapped" ],
+        "seeders": 2,
+        "leechers": 1,
+        "quality": { "quality": { "name": "Lossless" }},
+      }
+    ]);
+    let expected_filtered_lidarr_release = LidarrRelease {
+      guid: "4567".to_owned(),
+      ..torrent_release()
+    };
+    let expected_raw_lidarr_releases = vec![
+      LidarrRelease {
+        discography: true,
+        ..torrent_release()
+      },
+      LidarrRelease {
+        guid: "4567".to_owned(),
+        ..torrent_release()
+      },
+    ];
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(release_json)
+      .query("artistId=1&albumId=1")
+      .build_for(LidarrEvent::GetAlbumReleases(1, 1))
+      .await;
+    app.lock().await.data.lidarr_data.album_details_modal = Some(AlbumDetailsModal::default());
+    app.lock().await.server_tabs.set_index(2);
+    let mut network = test_network(&app);
+
+    let LidarrSerdeable::Releases(releases_vec) = network
+      .handle_lidarr_event(LidarrEvent::GetAlbumReleases(1, 1))
+      .await
+      .unwrap()
+    else {
+      panic!("Expected Releases")
+    };
+
+    mock.assert_async().await;
+    assert_eq!(
+      app
+        .lock()
+        .await
+        .data
+        .lidarr_data
+        .album_details_modal
+        .as_ref()
+        .unwrap()
+        .album_releases
+        .items,
+      vec![expected_filtered_lidarr_release]
+    );
+    assert_eq!(releases_vec, expected_raw_lidarr_releases);
+  }
+
+  #[tokio::test]
+  async fn test_handle_get_album_releases_event_empty_album_details_modal() {
+    let release_json = json!([
+      {
+        "guid": "1234",
+        "protocol": "torrent",
+        "age": 1,
+        "title": "Test Release",
+        "indexer": "kickass torrents",
+        "indexerId": 2,
+        "artistName": "Alex",
+        "albumTitle": "Something",
+        "size": 1234,
+        "rejected": true,
+        "rejections": [ "Unknown quality profile", "Release is already mapped" ],
+        "seeders": 2,
+        "leechers": 1,
+        "quality": { "quality": { "name": "Lossless" }},
+        "discography": true
+      },
+      {
+        "guid": "4567",
+        "protocol": "torrent",
+        "age": 1,
+        "title": "Test Release",
+        "indexer": "kickass torrents",
+        "indexerId": 2,
+        "artistName": "Alex",
+        "albumTitle": "Something",
+        "size": 1234,
+        "rejected": true,
+        "rejections": [ "Unknown quality profile", "Release is already mapped" ],
+        "seeders": 2,
+        "leechers": 1,
+        "quality": { "quality": { "name": "Lossless" }},
+      }
+    ]);
+    let expected_lidarr_release = LidarrRelease {
+      guid: "4567".to_owned(),
+      ..torrent_release()
+    };
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(release_json)
+      .query("artistId=1&albumId=1")
+      .build_for(LidarrEvent::GetAlbumReleases(1, 1))
+      .await;
+    app.lock().await.server_tabs.set_index(2);
+    let mut network = test_network(&app);
+
+    assert_ok!(
+      network
+        .handle_lidarr_event(LidarrEvent::GetAlbumReleases(1, 1))
+        .await
+    );
+
+    mock.assert_async().await;
+    assert_eq!(
+      app
+        .lock()
+        .await
+        .data
+        .lidarr_data
+        .album_details_modal
+        .as_ref()
+        .unwrap()
+        .album_releases
+        .items,
+      vec![expected_lidarr_release]
+    );
+  }
+
+  #[tokio::test]
+  async fn test_handle_trigger_automatic_album_search_event() {
+    let (mock, app, _server) = MockServarrApi::post()
+      .with_request_body(json!({
+        "name": "AlbumSearch",
+        "albumIds": [1]
+      }))
+      .returns(json!({}))
+      .build_for(LidarrEvent::TriggerAutomaticAlbumSearch(1))
+      .await;
+    app.lock().await.server_tabs.set_index(2);
+    let mut network = test_network(&app);
+
+    assert!(
+      network
+        .handle_lidarr_event(LidarrEvent::TriggerAutomaticAlbumSearch(1))
+        .await
+        .is_ok()
+    );
+
+    mock.assert_async().await;
+  }
 }

src/network/lidarr_network/library/albums/mod.rs

@@ -1,4 +1,7 @@
-use crate::models::lidarr_models::{Album, DeleteParams};
+use crate::models::lidarr_models::{
+  Album, DeleteParams, LidarrCommandBody, LidarrHistoryItem, LidarrRelease,
+};
+use crate::models::servarr_data::lidarr::modals::AlbumDetailsModal;
 use crate::network::lidarr_network::LidarrEvent;
 use crate::network::{Network, RequestMethod};
 use anyhow::Result;
@@ -57,6 +60,88 @@ impl Network<'_, '_> {
       .await
   }
 
+  pub(in crate::network::lidarr_network) async fn get_lidarr_album_history(
+    &mut self,
+    artist_id: i64,
+    album_id: i64,
+  ) -> Result<Vec<LidarrHistoryItem>> {
+    let event = LidarrEvent::GetAlbumHistory(artist_id, album_id);
+    info!("Fetching history for artist with ID: {artist_id} and album with ID: {album_id}");
+
+    let params = format!("artistId={artist_id}&albumId={album_id}");
+    let request_props = self
+      .request_props_from(event, RequestMethod::Get, None::<()>, None, Some(params))
+      .await;
+
+    self
+      .handle_request::<(), Vec<LidarrHistoryItem>>(request_props, |history_items, mut app| {
+        if app.data.lidarr_data.album_details_modal.is_none() {
+          app.data.lidarr_data.album_details_modal = Some(AlbumDetailsModal::default());
+        }
+
+        let mut history_vec = history_items;
+        history_vec.sort_by(|a, b| a.id.cmp(&b.id));
+        app
+          .data
+          .lidarr_data
+          .album_details_modal
+          .as_mut()
+          .unwrap()
+          .album_history
+          .set_items(history_vec);
+        app
+          .data
+          .lidarr_data
+          .album_details_modal
+          .as_mut()
+          .unwrap()
+          .album_history
+          .apply_sorting_toggle(false);
+      })
+      .await
+  }
+
+  pub(in crate::network::lidarr_network) async fn get_album_releases(
+    &mut self,
+    artist_id: i64,
+    album_id: i64,
+  ) -> Result<Vec<LidarrRelease>> {
+    let event = LidarrEvent::GetAlbumReleases(artist_id, album_id);
+    info!("Fetching releases for artist with ID: {artist_id} and album with ID: {album_id}");
+
+    let request_props = self
+      .request_props_from(
+        event,
+        RequestMethod::Get,
+        None::<()>,
+        None,
+        Some(format!("artistId={artist_id}&albumId={album_id}")),
+      )
+      .await;
+
+    self
+      .handle_request::<(), Vec<LidarrRelease>>(request_props, |release_vec, mut app| {
+        if app.data.lidarr_data.album_details_modal.is_none() {
+          app.data.lidarr_data.album_details_modal = Some(AlbumDetailsModal::default());
+        }
+
+        let album_releases_vec = release_vec
+          .into_iter()
+          .filter(|release| !release.discography)
+          .collect();
+
+        app
+          .data
+          .lidarr_data
+          .album_details_modal
+          .as_mut()
+          .unwrap()
+          .album_releases
+          .set_items(album_releases_vec);
+      })
+      .await
+  }
+
   pub(in crate::network::lidarr_network) async fn delete_album(
     &mut self,
     delete_album_params: DeleteParams,
@@ -150,4 +235,26 @@ impl Network<'_, '_> {
       }
     }
   }
+
+  pub(in crate::network::lidarr_network) async fn trigger_automatic_album_search(
+    &mut self,
+    album_id: i64,
+  ) -> Result<Value> {
+    let event = LidarrEvent::TriggerAutomaticAlbumSearch(album_id);
+    info!("Searching indexers for album with ID: {album_id}");
+
+    let body = LidarrCommandBody {
+      name: "AlbumSearch".to_owned(),
+      album_ids: Some(vec![album_id]),
+      ..LidarrCommandBody::default()
+    };
+
+    let request_props = self
+      .request_props_from(event, RequestMethod::Post, Some(body), None, None)
+      .await;
+
+    self
+      .handle_request::<LidarrCommandBody, Value>(request_props, |_, _| ())
+      .await
+  }
 }

src/network/lidarr_network/library/mod.rs

@@ -7,6 +7,7 @@ use serde_json::Value;
 
 mod albums;
 mod artists;
+mod tracks;
 
 #[cfg(test)]
 #[path = "lidarr_library_network_tests.rs"]

src/network/lidarr_network/library/tracks/lidarr_tracks_network_tests.rs

@@ -0,0 +1,173 @@
+#[cfg(test)]
+mod tests {
+  use crate::models::lidarr_models::LidarrSerdeable;
+  use crate::models::servarr_data::lidarr::modals::AlbumDetailsModal;
+  use crate::network::lidarr_network::LidarrEvent;
+  use crate::network::lidarr_network::lidarr_network_test_utils::test_utils::{track, track_file};
+  use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
+  use pretty_assertions::assert_eq;
+  use serde_json::json;
+
+  #[tokio::test]
+  async fn test_handle_delete_lidarr_track_file_event() {
+    let (async_server, app_arc, _server) = MockServarrApi::delete()
+      .path("/1")
+      .build_for(LidarrEvent::DeleteTrackFile(1))
+      .await;
+    app_arc.lock().await.data.lidarr_data.album_details_modal = Some(AlbumDetailsModal::default());
+    app_arc.lock().await.server_tabs.set_index(2);
+    let mut network = test_network(&app_arc);
+
+    assert!(
+      network
+        .handle_lidarr_event(LidarrEvent::DeleteTrackFile(1))
+        .await
+        .is_ok()
+    );
+
+    async_server.assert_async().await;
+  }
+
+  #[tokio::test]
+  async fn test_handle_get_tracks_event() {
+    let expected_tracks = vec![track()];
+    let (mock, app, _server) = MockServarrApi::get()
+      .query("artistId=1&albumId=1")
+      .returns(json!([track()]))
+      .build_for(LidarrEvent::GetTracks(1, 1))
+      .await;
+    app.lock().await.data.lidarr_data.album_details_modal = Some(AlbumDetailsModal::default());
+    app.lock().await.server_tabs.set_index(2);
+    let mut network = test_network(&app);
+
+    let result = network
+      .handle_lidarr_event(LidarrEvent::GetTracks(1, 1))
+      .await;
+
+    mock.assert_async().await;
+
+    let LidarrSerdeable::Tracks(tracks) = result.unwrap() else {
+      panic!("Expected Tracks variant")
+    };
+    assert_eq!(
+      app
+        .lock()
+        .await
+        .data
+        .lidarr_data
+        .album_details_modal
+        .as_ref()
+        .unwrap()
+        .tracks
+        .items,
+      expected_tracks
+    );
+    assert_eq!(tracks, expected_tracks);
+  }
+
+  #[tokio::test]
+  async fn test_handle_get_tracks_event_empty_album_details_modal() {
+    let expected_tracks = vec![track()];
+    let (mock, app, _server) = MockServarrApi::get()
+      .query("artistId=1&albumId=1")
+      .returns(json!([track()]))
+      .build_for(LidarrEvent::GetTracks(1, 1))
+      .await;
+    app.lock().await.server_tabs.set_index(2);
+    let mut network = test_network(&app);
+
+    let result = network
+      .handle_lidarr_event(LidarrEvent::GetTracks(1, 1))
+      .await;
+
+    mock.assert_async().await;
+
+    let LidarrSerdeable::Tracks(tracks) = result.unwrap() else {
+      panic!("Expected Tracks variant")
+    };
+
+    assert_eq!(
+      app
+        .lock()
+        .await
+        .data
+        .lidarr_data
+        .album_details_modal
+        .as_ref()
+        .unwrap()
+        .tracks
+        .items,
+      expected_tracks
+    );
+    assert_eq!(tracks, expected_tracks);
+  }
+
+  #[tokio::test]
+  async fn test_handle_get_track_files_event() {
+    let (async_server, app_arc, _server) = MockServarrApi::get()
+      .returns(json!([track_file()]))
+      .query("albumId=1")
+      .build_for(LidarrEvent::GetTrackFiles(1))
+      .await;
+    app_arc.lock().await.data.lidarr_data.album_details_modal = Some(AlbumDetailsModal::default());
+    app_arc.lock().await.server_tabs.set_index(2);
+    let mut network = test_network(&app_arc);
+
+    let LidarrSerdeable::TrackFiles(track_files) = network
+      .handle_lidarr_event(LidarrEvent::GetTrackFiles(1))
+      .await
+      .unwrap()
+    else {
+      panic!("Expected TrackFiles")
+    };
+    async_server.assert_async().await;
+    assert_eq!(
+      app_arc
+        .lock()
+        .await
+        .data
+        .lidarr_data
+        .album_details_modal
+        .as_ref()
+        .unwrap()
+        .track_files
+        .items,
+      vec![track_file()]
+    );
+    assert_eq!(track_files, vec![track_file()]);
+  }
+
+  #[tokio::test]
+  async fn test_handle_get_track_files_event_empty_album_details_modal() {
+    let (async_server, app_arc, _server) = MockServarrApi::get()
+      .returns(json!([track_file()]))
+      .query("albumId=1")
+      .build_for(LidarrEvent::GetTrackFiles(1))
+      .await;
+    app_arc.lock().await.server_tabs.set_index(2);
+    let mut network = test_network(&app_arc);
+
+    let LidarrSerdeable::TrackFiles(track_files) = network
+      .handle_lidarr_event(LidarrEvent::GetTrackFiles(1))
+      .await
+      .unwrap()
+    else {
+      panic!("Expected TrackFiles")
+    };
+    async_server.assert_async().await;
+    let app = app_arc.lock().await;
+    assert_some!(&app.data.lidarr_data.album_details_modal);
+    assert_eq!(
+      app
+        .data
+        .lidarr_data
+        .album_details_modal
+        .as_ref()
+        .unwrap()
+        .track_files
+        .items,
+      vec![track_file()]
+    );
+    assert_eq!(track_files, vec![track_file()]);
+  }
+}

src/network/lidarr_network/library/tracks/mod.rs

@@ -0,0 +1,106 @@
+use crate::models::lidarr_models::{Track, TrackFile};
+use crate::models::servarr_data::lidarr::modals::AlbumDetailsModal;
+use crate::network::lidarr_network::LidarrEvent;
+use crate::network::{Network, RequestMethod};
+use anyhow::Result;
+use log::info;
+
+#[cfg(test)]
+#[path = "lidarr_tracks_network_tests.rs"]
+mod lidarr_tracks_network_tests;
+
+impl Network<'_, '_> {
+  pub(in crate::network::lidarr_network) async fn delete_lidarr_track_file(
+    &mut self,
+    track_file_id: i64,
+  ) -> Result<()> {
+    let event = LidarrEvent::DeleteTrackFile(track_file_id);
+    info!("Deleting Lidarr track file for track file with id: {track_file_id}");
+
+    let request_props = self
+      .request_props_from(
+        event,
+        RequestMethod::Delete,
+        None::<()>,
+        Some(format!("/{track_file_id}")),
+        None,
+      )
+      .await;
+
+    self
+      .handle_request::<(), ()>(request_props, |_, _| ())
+      .await
+  }
+
+  pub(in crate::network::lidarr_network) async fn get_tracks(
+    &mut self,
+    artist_id: i64,
+    album_id: i64,
+  ) -> Result<Vec<Track>> {
+    let event = LidarrEvent::GetTracks(artist_id, album_id);
+    info!("Fetching tracks for Lidarr artist with ID: {artist_id} and album with ID: {album_id}");
+
+    let request_props = self
+      .request_props_from(
+        event,
+        RequestMethod::Get,
+        None::<()>,
+        None,
+        Some(format!("artistId={artist_id}&albumId={album_id}")),
+      )
+      .await;
+
+    self
+      .handle_request::<(), Vec<Track>>(request_props, |mut track_vec, mut app| {
+        track_vec.sort_by(|a, b| a.id.cmp(&b.id));
+        if app.data.lidarr_data.album_details_modal.is_none() {
+          app.data.lidarr_data.album_details_modal = Some(AlbumDetailsModal::default());
+        }
+
+        app
+          .data
+          .lidarr_data
+          .album_details_modal
+          .as_mut()
+          .unwrap()
+          .tracks
+          .set_items(track_vec);
+      })
+      .await
+  }
+
+  pub(in crate::network::lidarr_network) async fn get_track_files(
+    &mut self,
+    album_id: i64,
+  ) -> Result<Vec<TrackFile>> {
+    let event = LidarrEvent::GetTrackFiles(album_id);
+    info!("Fetching tracks files for Lidarr album with ID: {album_id}");
+
+    let request_props = self
+      .request_props_from(
+        event,
+        RequestMethod::Get,
+        None::<()>,
+        None,
+        Some(format!("albumId={album_id}")),
+      )
+      .await;
+
+    self
+      .handle_request::<(), Vec<TrackFile>>(request_props, |track_file_vec, mut app| {
+        if app.data.lidarr_data.album_details_modal.is_none() {
+          app.data.lidarr_data.album_details_modal = Some(AlbumDetailsModal::default());
+        }
+
+        app
+          .data
+          .lidarr_data
+          .album_details_modal
+          .as_mut()
+          .unwrap()
+          .track_files
+          .set_items(track_file_vec);
+      })
+      .await
+  }
+}

src/network/lidarr_network/lidarr_network_test_utils.rs

@@ -3,9 +3,10 @@
 pub mod test_utils {
   use crate::models::lidarr_models::{
     AddArtistSearchResult, Album, AlbumStatistics, Artist, ArtistStatistics, ArtistStatus,
-    DownloadRecord, DownloadStatus, DownloadsResponse, EditArtistParams, LidarrHistoryData,
-    LidarrHistoryEventType, LidarrHistoryItem, LidarrHistoryWrapper, LidarrRelease, LidarrTask,
-    LidarrTaskName, Member, MetadataProfile, NewItemMonitorType, Ratings, SystemStatus,
+    AudioTags, DownloadRecord, DownloadStatus, DownloadsResponse, EditArtistParams,
+    LidarrHistoryData, LidarrHistoryEventType, LidarrHistoryItem, LidarrHistoryWrapper,
+    LidarrRelease, LidarrTask, LidarrTaskName, MediaInfo, Member, MetadataProfile,
+    NewItemMonitorType, Ratings, SystemStatus, Track, TrackFile,
   };
   use crate::models::servarr_models::IndexerSettings;
   use crate::models::servarr_models::{
@@ -424,4 +425,54 @@ pub mod test_utils {
       quality: quality_wrapper(),
     }
   }
+
+  pub fn audio_tags() -> AudioTags {
+    AudioTags {
+      title: "When I Get There".to_string(),
+      artist_title: "P!nk".to_string(),
+      album_title: "Trustfall".to_string(),
+      disc_number: 1,
+      disc_count: 1,
+      year: 2023,
+      duration: "00:03:20.1802267".to_string(),
+    }
+  }
+
+  pub fn media_info() -> MediaInfo {
+    MediaInfo {
+      audio_bitrate: Some("1563 kbps".to_owned()),
+      audio_channels: 2,
+      audio_codec: Some("FLAC".to_owned()),
+      audio_bits: Some("24bit".to_owned()),
+      audio_sample_rate: Some("44.1kHz".to_owned()),
+    }
+  }
+
+  pub fn track_file() -> TrackFile {
+    TrackFile {
+      id: 1,
+      path: "/music/P!nk/TRUSTFALL/01 - When I Get There.flac".to_string(),
+      size: 39216378,
+      quality: quality_wrapper(),
+      date_added: DateTime::from(DateTime::parse_from_rfc3339("2023-05-20T21:29:16Z").unwrap()),
+      media_info: Some(media_info()),
+      audio_tags: Some(audio_tags()),
+    }
+  }
+
+  pub fn track() -> Track {
+    Track {
+      id: 1,
+      artist_id: 1,
+      foreign_track_id: "test-foreign-track-id".to_string(),
+      track_file_id: 1,
+      album_id: 1,
+      explicit: false,
+      track_number: "1".to_string(),
+      title: "Test title".to_string(),
+      duration: 200173,
+      has_file: false,
+      ratings: ratings(),
+    }
+  }
 }

src/network/lidarr_network/lidarr_network_tests.rs

@@ -61,8 +61,11 @@ mod tests {
   }
 
   #[rstest]
-  fn test_resource_history(#[values(LidarrEvent::GetHistory(0))] event: LidarrEvent) {
-    assert_str_eq!(event.resource(), "/history");
+  fn test_resource_artist_history(
+    #[values(LidarrEvent::GetArtistHistory(0), LidarrEvent::GetAlbumHistory(0, 0))]
+    event: LidarrEvent,
+  ) {
+    assert_str_eq!(event.resource(), "/history/artist");
   }
 
   #[rstest]
@@ -89,6 +92,7 @@ mod tests {
     #[values(
       LidarrEvent::UpdateAllArtists,
       LidarrEvent::TriggerAutomaticArtistSearch(0),
+      LidarrEvent::TriggerAutomaticAlbumSearch(0),
       LidarrEvent::UpdateAndScanArtist(0),
       LidarrEvent::UpdateDownloads,
       LidarrEvent::GetQueuedEvents,
@@ -128,13 +132,21 @@ mod tests {
   fn test_resource_release(
     #[values(
       LidarrEvent::GetDiscographyReleases(0),
-      LidarrEvent::DownloadRelease(Default::default())
+      LidarrEvent::DownloadRelease(Default::default()),
+      LidarrEvent::GetAlbumReleases(0, 0)
     )]
     event: LidarrEvent,
   ) {
     assert_str_eq!(event.resource(), "/release");
   }
 
+  #[rstest]
+  fn test_resource_track_file(
+    #[values(LidarrEvent::DeleteTrackFile(0), LidarrEvent::GetTrackFiles(0))] event: LidarrEvent,
+  ) {
+    assert_str_eq!(event.resource(), "/trackfile");
+  }
+
   #[rstest]
   #[case(LidarrEvent::GetDiskSpace, "/diskspace")]
   #[case(LidarrEvent::GetMetadataProfiles, "/metadataprofile")]
@@ -146,9 +158,10 @@ mod tests {
   #[case(LidarrEvent::GetUpdates, "/update")]
   #[case(LidarrEvent::HealthCheck, "/health")]
   #[case(LidarrEvent::MarkHistoryItemAsFailed(0), "/history/failed")]
-  #[case(LidarrEvent::GetArtistHistory(0), "/history/artist")]
+  #[case(LidarrEvent::GetHistory(0), "/history")]
   #[case(LidarrEvent::TestIndexer(0), "/indexer/test")]
   #[case(LidarrEvent::TestAllIndexers, "/indexer/testall")]
+  #[case(LidarrEvent::GetTracks(0, 0), "/track")]
   fn test_resource(#[case] event: LidarrEvent, #[case] expected_uri: &str) {
     assert_str_eq!(event.resource(), expected_uri);
   }

src/network/lidarr_network/mod.rs

@@ -35,12 +35,15 @@ pub enum LidarrEvent {
   DeleteIndexer(i64),
   DeleteRootFolder(i64),
   DeleteTag(i64),
+  DeleteTrackFile(i64),
   DownloadRelease(LidarrReleaseDownloadBody),
   EditArtist(EditArtistParams),
   EditAllIndexerSettings(IndexerSettings),
   EditIndexer(EditIndexerParams),
   GetAlbums(i64),
   GetAlbumDetails(i64),
+  GetAlbumHistory(i64, i64),
+  GetAlbumReleases(i64, i64),
   GetArtistHistory(i64),
   GetAllIndexerSettings,
   GetArtistDetails(i64),
@@ -58,6 +61,8 @@ pub enum LidarrEvent {
   GetRootFolders,
   GetSecurityConfig,
   GetStatus,
+  GetTracks(i64, i64),
+  GetTrackFiles(i64),
   GetUpdates,
   GetTags,
   GetTasks,
@@ -70,6 +75,7 @@ pub enum LidarrEvent {
   ToggleAlbumMonitoring(i64),
   ToggleArtistMonitoring(i64),
   TriggerAutomaticArtistSearch(i64),
+  TriggerAutomaticAlbumSearch(i64),
   UpdateAllArtists,
   UpdateAndScanArtist(i64),
   UpdateDownloads,
@@ -79,6 +85,7 @@ impl NetworkResource for LidarrEvent {
   fn resource(&self) -> &'static str {
     match &self {
       LidarrEvent::AddTag(_) | LidarrEvent::DeleteTag(_) | LidarrEvent::GetTags => "/tag",
+      LidarrEvent::DeleteTrackFile(_) | LidarrEvent::GetTrackFiles(_) => "/trackfile",
       LidarrEvent::GetAllIndexerSettings | LidarrEvent::EditAllIndexerSettings(_) => {
         "/config/indexer"
       }
@@ -92,13 +99,15 @@ impl NetworkResource for LidarrEvent {
       | LidarrEvent::ToggleAlbumMonitoring(_)
       | LidarrEvent::GetAlbumDetails(_)
       | LidarrEvent::DeleteAlbum(_) => "/album",
-      LidarrEvent::GetArtistHistory(_) => "/history/artist",
+      LidarrEvent::GetArtistHistory(_) | LidarrEvent::GetAlbumHistory(_, _) => "/history/artist",
       LidarrEvent::GetLogs(_) => "/log",
       LidarrEvent::GetDiskSpace => "/diskspace",
       LidarrEvent::GetDownloads(_) | LidarrEvent::DeleteDownload(_) => "/queue",
       LidarrEvent::GetHistory(_) => "/history",
       LidarrEvent::MarkHistoryItemAsFailed(_) => "/history/failed",
-      LidarrEvent::GetDiscographyReleases(_) | LidarrEvent::DownloadRelease(_) => "/release",
+      LidarrEvent::GetDiscographyReleases(_)
+      | LidarrEvent::DownloadRelease(_)
+      | LidarrEvent::GetAlbumReleases(_, _) => "/release",
       LidarrEvent::GetHostConfig | LidarrEvent::GetSecurityConfig => "/config/host",
       LidarrEvent::GetIndexers | LidarrEvent::DeleteIndexer(_) | LidarrEvent::EditIndexer(_) => {
         "/indexer"
@@ -108,7 +117,8 @@ impl NetworkResource for LidarrEvent {
       | LidarrEvent::UpdateAndScanArtist(_)
       | LidarrEvent::UpdateDownloads
       | LidarrEvent::GetQueuedEvents
-      | LidarrEvent::StartTask(_) => "/command",
+      | LidarrEvent::StartTask(_)
+      | LidarrEvent::TriggerAutomaticAlbumSearch(_) => "/command",
       LidarrEvent::GetMetadataProfiles => "/metadataprofile",
       LidarrEvent::GetQualityProfiles => "/qualityprofile",
       LidarrEvent::GetRootFolders
@@ -118,6 +128,7 @@ impl NetworkResource for LidarrEvent {
       LidarrEvent::TestAllIndexers => "/indexer/testall",
       LidarrEvent::GetStatus => "/system/status",
       LidarrEvent::GetTasks => "/system/task",
+      LidarrEvent::GetTracks(_, _) => "/track",
       LidarrEvent::GetUpdates => "/update",
       LidarrEvent::HealthCheck => "/health",
       LidarrEvent::SearchNewArtist(_) => "/artist/lookup",
@@ -152,6 +163,10 @@ impl Network<'_, '_> {
         .delete_lidarr_download(download_id)
         .await
         .map(LidarrSerdeable::from),
+      LidarrEvent::DeleteTrackFile(track_file_id) => self
+        .delete_lidarr_track_file(track_file_id)
+        .await
+        .map(LidarrSerdeable::from),
       LidarrEvent::EditAllIndexerSettings(params) => self
         .edit_all_lidarr_indexer_settings(params)
         .await
@@ -191,6 +206,14 @@ impl Network<'_, '_> {
         .get_album_details(album_id)
         .await
         .map(LidarrSerdeable::from),
+      LidarrEvent::GetAlbumHistory(artist_id, album_id) => self
+        .get_lidarr_album_history(artist_id, album_id)
+        .await
+        .map(LidarrSerdeable::from),
+      LidarrEvent::GetAlbumReleases(artist_id, album_id) => self
+        .get_album_releases(artist_id, album_id)
+        .await
+        .map(LidarrSerdeable::from),
       LidarrEvent::GetDiscographyReleases(artist_id) => self
         .get_artist_discography_releases(artist_id)
         .await
@@ -244,6 +267,14 @@ impl Network<'_, '_> {
       LidarrEvent::GetStatus => self.get_lidarr_status().await.map(LidarrSerdeable::from),
       LidarrEvent::GetTags => self.get_lidarr_tags().await.map(LidarrSerdeable::from),
       LidarrEvent::GetTasks => self.get_lidarr_tasks().await.map(LidarrSerdeable::from),
+      LidarrEvent::GetTracks(artist_id, album_id) => self
+        .get_tracks(artist_id, album_id)
+        .await
+        .map(LidarrSerdeable::from),
+      LidarrEvent::GetTrackFiles(album_id) => self
+        .get_track_files(album_id)
+        .await
+        .map(LidarrSerdeable::from),
       LidarrEvent::GetUpdates => self.get_lidarr_updates().await.map(LidarrSerdeable::from),
       LidarrEvent::HealthCheck => self
         .get_lidarr_healthcheck()
@@ -269,6 +300,10 @@ impl Network<'_, '_> {
         .trigger_automatic_artist_search(artist_id)
         .await
         .map(LidarrSerdeable::from),
+      LidarrEvent::TriggerAutomaticAlbumSearch(album_id) => self
+        .trigger_automatic_album_search(album_id)
+        .await
+        .map(LidarrSerdeable::from),
       LidarrEvent::UpdateAllArtists => self.update_all_artists().await.map(LidarrSerdeable::from),
       LidarrEvent::UpdateAndScanArtist(artist_id) => self
         .update_and_scan_artist(artist_id)