Add Lidarr support (#30)

code/Infrastructure/Verticals/Arr/ArrClient.cs

@@ -101,9 +101,9 @@ public abstract class ArrClient
         return false;
     }
     
-    public virtual async Task DeleteQueueItemAsync(ArrInstance arrInstance, QueueRecord queueRecord)
+    public virtual async Task DeleteQueueItemAsync(ArrInstance arrInstance, QueueRecord record)
     {
-        Uri uri = new(arrInstance.Url, $"/api/v3/queue/{queueRecord.Id}?removeFromClient=true&blocklist=true&skipRedownload=true&changeCategory=false");
+        Uri uri = new(arrInstance.Url, GetQueueDeleteUrlPath(record.Id));
         
         using HttpRequestMessage request = new(HttpMethod.Delete, uri);
         SetApiKey(request, arrInstance.ApiKey);
@@ -114,16 +114,16 @@ public abstract class ArrClient
         {
             response.EnsureSuccessStatusCode();
             
-            _logger.LogInformation("queue item deleted | {url} | {title}", arrInstance.Url, queueRecord.Title);
+            _logger.LogInformation("queue item deleted | {url} | {title}", arrInstance.Url, record.Title);
         }
         catch
         {
-            _logger.LogError("queue delete failed | {uri} | {title}", uri, queueRecord.Title);
+            _logger.LogError("queue delete failed | {uri} | {title}", uri, record.Title);
             throw;
         }
     }
 
-    public abstract Task RefreshItemsAsync(ArrInstance arrInstance, ArrConfig config, HashSet<SearchItem>? items);
+    public abstract Task RefreshItemsAsync(ArrInstance arrInstance, HashSet<SearchItem>? items);
 
     public virtual bool IsRecordValid(QueueRecord record)
     {
@@ -143,6 +143,8 @@ public abstract class ArrClient
     }
     
     protected abstract string GetQueueUrlPath(int page);
+
+    protected abstract string GetQueueDeleteUrlPath(long recordId);
     
     protected virtual void SetApiKey(HttpRequestMessage request, string apiKey)
     {

code/Infrastructure/Verticals/Arr/LidarrClient.cs

@@ -0,0 +1,145 @@
+using System.Text;
+using Common.Configuration.Arr;
+using Common.Configuration.Logging;
+using Common.Configuration.QueueCleaner;
+using Domain.Models.Arr;
+using Domain.Models.Arr.Queue;
+using Domain.Models.Lidarr;
+using Infrastructure.Verticals.ItemStriker;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using Newtonsoft.Json;
+
+namespace Infrastructure.Verticals.Arr;
+
+public sealed class LidarrClient : ArrClient
+{
+    public LidarrClient(
+        ILogger<LidarrClient> logger,
+        IHttpClientFactory httpClientFactory,
+        IOptions<LoggingConfig> loggingConfig,
+        IOptions<QueueCleanerConfig> queueCleanerConfig,
+        Striker striker
+    ) : base(logger, httpClientFactory, loggingConfig, queueCleanerConfig, striker)
+    {
+    }
+
+    protected override string GetQueueUrlPath(int page)
+    {
+        return $"/api/v1/queue?page={page}&pageSize=200&includeUnknownArtistItems=true&includeArtist=true&includeAlbum=true";
+    }
+
+    protected override string GetQueueDeleteUrlPath(long recordId)
+    {
+        return $"/api/v1/queue/{recordId}?removeFromClient=true&blocklist=true&skipRedownload=true&changeCategory=false";
+    }
+
+    public override async Task RefreshItemsAsync(ArrInstance arrInstance, HashSet<SearchItem>? items)
+    {
+        if (items?.Count is null or 0) return;
+
+        Uri uri = new(arrInstance.Url, "/api/v1/command");
+
+        foreach (var command in GetSearchCommands(items))
+        {
+            using HttpRequestMessage request = new(HttpMethod.Post, uri);
+            request.Content = new StringContent(
+                JsonConvert.SerializeObject(command, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore }),
+                Encoding.UTF8,
+                "application/json"
+            );
+            SetApiKey(request, arrInstance.ApiKey);
+
+            using var response = await _httpClient.SendAsync(request);
+            string? logContext = await ComputeCommandLogContextAsync(arrInstance, command);
+
+            try
+            {
+                response.EnsureSuccessStatusCode();
+
+                _logger.LogInformation("{log}", GetSearchLog(arrInstance.Url, command, true, logContext));
+            }
+            catch
+            {
+                _logger.LogError("{log}", GetSearchLog(arrInstance.Url, command, false, logContext));
+                throw;
+            }
+        }
+    }
+
+    public override bool IsRecordValid(QueueRecord record)
+    {
+        if (record.ArtistId is 0 || record.AlbumId is 0)
+        {
+            _logger.LogDebug("skip | artist id and/or album id missing | {title}", record.Title);
+            return false;
+        }
+
+        return base.IsRecordValid(record);
+    }
+
+    private static string GetSearchLog(
+        Uri instanceUrl,
+        LidarrCommand command,
+        bool success,
+        string? logContext
+    )
+    {
+        string status = success ? "triggered" : "failed";
+
+        return $"album search {status} | {instanceUrl} | {logContext ?? $"albums: {string.Join(',', command.AlbumIds)}"}";
+    }
+
+    private async Task<string?> ComputeCommandLogContextAsync(ArrInstance arrInstance, LidarrCommand command)
+    {
+        try
+        {
+            if (!_loggingConfig.Enhanced) return null;
+
+            StringBuilder log = new();
+
+            var albums = await GetAlbumsAsync(arrInstance, command.AlbumIds);
+
+            if (albums?.Count is null or 0) return null;
+
+            var groups = albums
+                .GroupBy(x => x.Artist.Id)
+                .ToList();
+
+            foreach (var group in groups)
+            {
+                var first = group.First();
+
+                log.Append($"[{first.Artist.ArtistName} albums {string.Join(',', group.Select(x => x.Title).ToList())}]");
+            }
+
+            return log.ToString();
+        }
+        catch (Exception exception)
+        {
+            _logger.LogDebug(exception, "failed to compute log context");
+        }
+
+        return null;
+    }
+
+    private async Task<List<Album>?> GetAlbumsAsync(ArrInstance arrInstance, List<long> albumIds)
+    {
+        Uri uri = new(arrInstance.Url, $"api/v1/album?{string.Join('&', albumIds.Select(x => $"albumIds={x}"))}");
+        using HttpRequestMessage request = new(HttpMethod.Get, uri);
+        SetApiKey(request, arrInstance.ApiKey);
+
+        using var response = await _httpClient.SendAsync(request);
+        response.EnsureSuccessStatusCode();
+
+        string responseBody = await response.Content.ReadAsStringAsync();
+        return JsonConvert.DeserializeObject<List<Album>>(responseBody);
+    }
+
+    private List<LidarrCommand> GetSearchCommands(HashSet<SearchItem> items)
+    {
+        const string albumSearch = "AlbumSearch";
+
+        return [new LidarrCommand { Name = albumSearch, AlbumIds = items.Select(i => i.Id).ToList() }];
+    }
+}

code/Infrastructure/Verticals/Arr/RadarrClient.cs

@@ -6,7 +6,6 @@ using Domain.Models.Arr;
 using Domain.Models.Arr.Queue;
 using Domain.Models.Radarr;
 using Infrastructure.Verticals.ItemStriker;
-using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using Newtonsoft.Json;
@@ -30,7 +29,12 @@ public sealed class RadarrClient : ArrClient
         return $"/api/v3/queue?page={page}&pageSize=200&includeUnknownMovieItems=true&includeMovie=true";
     }
 
-    public override async Task RefreshItemsAsync(ArrInstance arrInstance, ArrConfig config, HashSet<SearchItem>? items)
+    protected override string GetQueueDeleteUrlPath(long recordId)
+    {
+        return $"/api/v3/queue/{recordId}?removeFromClient=true&blocklist=true&skipRedownload=true&changeCategory=false";
+    }
+
+    public override async Task RefreshItemsAsync(ArrInstance arrInstance, HashSet<SearchItem>? items)
     {
         if (items?.Count is null or 0)
         {
@@ -74,7 +78,7 @@ public sealed class RadarrClient : ArrClient
     {
         if (record.MovieId is 0)
         {
-            _logger.LogDebug("skip | item information missing | {title}", record.Title);
+            _logger.LogDebug("skip | movie id missing | {title}", record.Title);
             return false;
         }
         

code/Infrastructure/Verticals/Arr/SonarrClient.cs

@@ -6,7 +6,6 @@ using Domain.Models.Arr;
 using Domain.Models.Arr.Queue;
 using Domain.Models.Sonarr;
 using Infrastructure.Verticals.ItemStriker;
-using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using Newtonsoft.Json;
@@ -29,8 +28,13 @@ public sealed class SonarrClient : ArrClient
     {
         return $"/api/v3/queue?page={page}&pageSize=200&includeUnknownSeriesItems=true&includeSeries=true";
     }
+    
+    protected override string GetQueueDeleteUrlPath(long recordId)
+    {
+        return $"/api/v3/queue/{recordId}?removeFromClient=true&blocklist=true&skipRedownload=true&changeCategory=false";
+    }
 
-    public override async Task RefreshItemsAsync(ArrInstance arrInstance, ArrConfig config, HashSet<SearchItem>? items)
+    public override async Task RefreshItemsAsync(ArrInstance arrInstance, HashSet<SearchItem>? items)
     {
         if (items?.Count is null or 0)
         {
@@ -70,7 +74,7 @@ public sealed class SonarrClient : ArrClient
     {
         if (record.EpisodeId is 0 || record.SeriesId is 0)
         {
-            _logger.LogDebug("skip | item information missing | {title}", record.Title);
+            _logger.LogDebug("skip | episode id and/or series id missing | {title}", record.Title);
             return false;
         }