Add sonarr search option (#18)

* added Sonarr search type option

* updated test data

* fixed duplicated Sonarr search items when using search type Season

* added enhanced logging option along with Sonarr and Radarr enhanced logs

* switched to ghcr.io

code/Infrastructure/Infrastructure.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
         <TargetFramework>net8.0</TargetFramework>
@@ -14,7 +14,6 @@
     <ItemGroup>
       <PackageReference Include="FLM.Transmission" Version="1.0.0" />
       <PackageReference Include="Microsoft.Extensions.Http" Version="8.0.0" />
-      <PackageReference Include="Microsoft.Extensions.Options" Version="8.0.1" />
       <PackageReference Include="QBittorrent.Client" Version="1.9.24285.1" />
       <PackageReference Include="Quartz" Version="3.13.1" />
     </ItemGroup>

code/Infrastructure/Verticals/Arr/ArrClient.cs

@@ -1,19 +1,25 @@
 using Common.Configuration;
+using Common.Configuration.Arr;
+using Common.Configuration.Logging;
 using Domain.Arr.Queue;
+using Domain.Models.Arr;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
 using Newtonsoft.Json;
 
 namespace Infrastructure.Verticals.Arr;
 
 public abstract class ArrClient
 {
-    private protected ILogger<ArrClient> _logger;
-    private protected HttpClient _httpClient;
+    protected readonly ILogger<ArrClient> _logger;
+    protected readonly HttpClient _httpClient;
+    protected readonly LoggingConfig _loggingConfig;
     
-    protected ArrClient(ILogger<ArrClient> logger, IHttpClientFactory httpClientFactory)
+    protected ArrClient(ILogger<ArrClient> logger, IHttpClientFactory httpClientFactory, IOptions<LoggingConfig> loggingConfig)
     {
         _logger = logger;
         _httpClient = httpClientFactory.CreateClient();
+        _loggingConfig = loggingConfig.Value;
     }
 
     public virtual async Task<QueueListResponse> GetQueueItemsAsync(ArrInstance arrInstance, int page)
@@ -68,7 +74,7 @@ public abstract class ArrClient
         }
     }
 
-    public abstract Task RefreshItemsAsync(ArrInstance arrInstance, HashSet<int> itemIds);
+    public abstract Task RefreshItemsAsync(ArrInstance arrInstance, ArrConfig config, HashSet<SearchItem>? items);
 
     protected virtual void SetApiKey(HttpRequestMessage request, string apiKey)
     {

code/Infrastructure/Verticals/Arr/ArrQueueIterator.cs

@@ -1,4 +1,5 @@
 using Common.Configuration;
+using Common.Configuration.Arr;
 using Domain.Arr.Queue;
 using Microsoft.Extensions.Logging;
 

code/Infrastructure/Verticals/Arr/RadarrClient.cs

@@ -1,30 +1,38 @@
 using System.Text;
-using Common.Configuration;
+using Common.Configuration.Arr;
+using Common.Configuration.Logging;
+using Domain.Models.Arr;
 using Domain.Models.Radarr;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
 using Newtonsoft.Json;
 
 namespace Infrastructure.Verticals.Arr;
 
 public sealed class RadarrClient : ArrClient
 {
-    public RadarrClient(ILogger<ArrClient> logger, IHttpClientFactory httpClientFactory)
-        : base(logger, httpClientFactory)
+    public RadarrClient(
+        ILogger<ArrClient> logger,
+        IHttpClientFactory httpClientFactory,
+        IOptions<LoggingConfig> loggingConfig
+    ) : base(logger, httpClientFactory, loggingConfig)
     {
     }
 
-    public override async Task RefreshItemsAsync(ArrInstance arrInstance, HashSet<int> itemIds)
+    public override async Task RefreshItemsAsync(ArrInstance arrInstance, ArrConfig config, HashSet<SearchItem>? items)
     {
-        if (itemIds.Count is 0)
+        if (items?.Count is null or 0)
         {
             return;
         }
+
+        List<long> ids = items.Select(item => item.Id).ToList();
         
         Uri uri = new(arrInstance.Url, "/api/v3/command");
         RadarrCommand command = new()
         {
             Name = "MoviesSearch",
-            MovieIds = itemIds
+            MovieIds = ids,
         };
         
         using HttpRequestMessage request = new(HttpMethod.Post, uri);
@@ -36,17 +44,72 @@ public sealed class RadarrClient : ArrClient
         SetApiKey(request, arrInstance.ApiKey);
 
         using HttpResponseMessage response = await _httpClient.SendAsync(request);
+        string? logContext = await ComputeCommandLogContextAsync(arrInstance, command);
 
         try
         {
             response.EnsureSuccessStatusCode();
             
-            _logger.LogInformation("movie search triggered | {url} | movie ids: {ids}", arrInstance.Url, string.Join(",", itemIds));
+            _logger.LogInformation("{log}", GetSearchLog(arrInstance.Url, command, true, logContext));
         }
         catch
         {
-            _logger.LogError("movie search failed | {url} | movie ids: {ids}", arrInstance.Url, string.Join(",", itemIds));
+            _logger.LogError("{log}", GetSearchLog(arrInstance.Url, command, false, logContext));
             throw;
         }
     }
+
+    private static string GetSearchLog(Uri instanceUrl, RadarrCommand command, bool success, string? logContext)
+    {
+        string status = success ? "triggered" : "failed";
+        string message = logContext ?? $"movie ids: {string.Join(',', command.MovieIds)}";
+
+        return $"movie search {status} | {instanceUrl} | {message}";
+    }
+
+    private async Task<string?> ComputeCommandLogContextAsync(ArrInstance arrInstance, RadarrCommand command)
+    {
+        try
+        {
+            if (!_loggingConfig.Enhanced)
+            {
+                return null;
+            }
+
+            StringBuilder log = new();
+
+            foreach (long movieId in command.MovieIds)
+            {
+                Movie? movie = await GetMovie(arrInstance, movieId);
+
+                if (movie is null)
+                {
+                    return null;
+                }
+
+                log.Append($"[{movie.Title}]");
+            }
+
+            return log.ToString();
+        }
+        catch (Exception exception)
+        {
+            _logger.LogDebug(exception, "failed to compute log context");
+        }
+
+        return null;
+    }
+
+    private async Task<Movie?> GetMovie(ArrInstance arrInstance, long movieId)
+    {
+        Uri uri = new(arrInstance.Url, $"api/v3/movie/{movieId}");
+        using HttpRequestMessage request = new(HttpMethod.Get, uri);
+        SetApiKey(request, arrInstance.ApiKey);
+
+        using HttpResponseMessage response = await _httpClient.SendAsync(request);
+        response.EnsureSuccessStatusCode();
+                
+        string responseBody = await response.Content.ReadAsStringAsync();
+        return JsonConvert.DeserializeObject<Movie>(responseBody);
+    }
 }

code/Infrastructure/Verticals/Arr/SonarrClient.cs

@@ -1,50 +1,244 @@
 using System.Text;
-using Common.Configuration;
+using Common.Configuration.Arr;
+using Common.Configuration.Logging;
+using Domain.Models.Arr;
 using Domain.Models.Sonarr;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
 using Newtonsoft.Json;
 
 namespace Infrastructure.Verticals.Arr;
 
 public sealed class SonarrClient : ArrClient
 {
-    public SonarrClient(ILogger<SonarrClient> logger, IHttpClientFactory httpClientFactory)
-        : base(logger, httpClientFactory)
+    public SonarrClient(
+        ILogger<SonarrClient> logger,
+        IHttpClientFactory httpClientFactory,
+        IOptions<LoggingConfig> loggingConfig
+    ) : base(logger, httpClientFactory, loggingConfig)
     {
     }
 
-    public override async Task RefreshItemsAsync(ArrInstance arrInstance, HashSet<int> itemIds)
+    public override async Task RefreshItemsAsync(ArrInstance arrInstance, ArrConfig config, HashSet<SearchItem>? items)
     {
-        foreach (int itemId in itemIds)
+        if (items?.Count is null or 0)
+        {
+            return;
+        }
+
+        SonarrConfig sonarrConfig = (SonarrConfig)config;
+        
+        Uri uri = new(arrInstance.Url, "/api/v3/command");
+        
+        foreach (SonarrCommand command in GetSearchCommands(sonarrConfig.SearchType, items))
         {
-            Uri uri = new(arrInstance.Url, "/api/v3/command");
-            SonarrCommand command = new()
-            {
-                Name = "SeriesSearch",
-                SeriesId = itemId
-            };
-            
             using HttpRequestMessage request = new(HttpMethod.Post, uri);
             request.Content = new StringContent(
-                JsonConvert.SerializeObject(command),
+                JsonConvert.SerializeObject(command, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore }),
                 Encoding.UTF8,
                 "application/json"
             );
             SetApiKey(request, arrInstance.ApiKey);
 
             using HttpResponseMessage response = await _httpClient.SendAsync(request);
+            string? logContext = await ComputeCommandLogContextAsync(arrInstance, command, sonarrConfig.SearchType);
 
             try
             {
                 response.EnsureSuccessStatusCode();
             
-                _logger.LogInformation("series search triggered | {url} | series id: {id}", arrInstance.Url, itemId);
+                _logger.LogInformation("{log}", GetSearchLog(sonarrConfig.SearchType, arrInstance.Url, command, true, logContext));
             }
             catch
             {
-                _logger.LogError("series search failed | {url} | series id: {id}", arrInstance.Url, itemId);
+                _logger.LogError("{log}", GetSearchLog(sonarrConfig.SearchType, arrInstance.Url, command, false, logContext));
                 throw;
             }
         }
     }
+
+    private static string GetSearchLog(
+        SonarrSearchType searchType,
+        Uri instanceUrl,
+        SonarrCommand command,
+        bool success,
+        string? logContext
+    )
+    {
+        string status = success ? "triggered" : "failed";
+        
+        return searchType switch
+        {
+            SonarrSearchType.Episode =>
+                $"episodes search {status} | {instanceUrl} | {logContext ?? $"episode ids: {string.Join(',', command.EpisodeIds)}"}",
+            SonarrSearchType.Season =>
+                $"season search {status} | {instanceUrl} | {logContext ?? $"season: {command.SeasonNumber} series id: {command.SeriesId}"}",
+            SonarrSearchType.Series => $"series search {status} | {instanceUrl} | {logContext ?? $"series id: {command.SeriesId}"}",
+            _ => throw new ArgumentOutOfRangeException(nameof(searchType), searchType, null)
+        };
+    }
+
+    private async Task<string?> ComputeCommandLogContextAsync(ArrInstance arrInstance, SonarrCommand command, SonarrSearchType searchType)
+    {
+        try
+        {
+            if (!_loggingConfig.Enhanced)
+            {
+                return null;
+            }
+            
+            StringBuilder log = new();
+
+            if (searchType is SonarrSearchType.Episode)
+            {
+                var episodes = await GetEpisodesAsync(arrInstance, command.EpisodeIds);
+
+                if (episodes?.Count is null or 0)
+                {
+                    return null;
+                }
+
+                var seriesIds = episodes
+                    .Select(x => x.SeriesId)
+                    .Distinct()
+                    .ToList();
+
+                List<Series> series = [];
+
+                foreach (long id in seriesIds)
+                {
+                    Series? show = await GetSeriesAsync(arrInstance, id);
+
+                    if (show is null)
+                    {
+                        return null;
+                    }
+
+                    series.Add(show);
+                }
+
+                foreach (var group in command.EpisodeIds.GroupBy(id => episodes.First(x => x.Id == id).SeriesId))
+                {
+                    var show = series.First(x => x.Id == group.Key);
+                    var episode = episodes
+                        .Where(ep => group.Any(x => x == ep.Id))
+                        .OrderBy(x => x.SeasonNumber)
+                        .ThenBy(x => x.EpisodeNumber)
+                        .Select(x => $"S{x.SeasonNumber.ToString().PadLeft(2, '0')}E{x.EpisodeNumber.ToString().PadLeft(2, '0')}")
+                        .ToList();
+
+                    log.Append($"[{show.Title} {string.Join(',', episode)}]");
+                }
+            }
+
+            if (searchType is SonarrSearchType.Season)
+            {
+                Series? show = await GetSeriesAsync(arrInstance, command.SeriesId.Value);
+
+                if (show is null)
+                {
+                    return null;
+                }
+
+                log.Append($"[{show.Title} season {command.SeasonNumber}]");
+            }
+
+            if (searchType is SonarrSearchType.Series)
+            {
+                Series? show = await GetSeriesAsync(arrInstance, command.SeriesId.Value);
+
+                if (show is null)
+                {
+                    return null;
+                }
+
+                log.Append($"[{show.Title}]");
+            }
+
+            return log.ToString();
+        }
+        catch (Exception exception)
+        {
+            _logger.LogDebug(exception, "failed to compute log context");
+        }
+
+        return null;
+    }
+
+    private async Task<List<Episode>?> GetEpisodesAsync(ArrInstance arrInstance, List<long> episodeIds)
+    {
+        Uri uri = new(arrInstance.Url, $"api/v3/episode?{string.Join('&', episodeIds.Select(x => $"episodeIds={x}"))}");
+        using HttpRequestMessage request = new(HttpMethod.Get, uri);
+        SetApiKey(request, arrInstance.ApiKey);
+
+        using HttpResponseMessage response = await _httpClient.SendAsync(request);
+        response.EnsureSuccessStatusCode();
+                
+        string responseBody = await response.Content.ReadAsStringAsync();
+        return JsonConvert.DeserializeObject<List<Episode>>(responseBody);
+    }
+
+    private async Task<Series?> GetSeriesAsync(ArrInstance arrInstance, long seriesId)
+    {
+        Uri uri = new(arrInstance.Url, $"api/v3/series/{seriesId}");
+        using HttpRequestMessage request = new(HttpMethod.Get, uri);
+        SetApiKey(request, arrInstance.ApiKey);
+
+        using HttpResponseMessage response = await _httpClient.SendAsync(request);
+        response.EnsureSuccessStatusCode();
+                
+        string responseBody = await response.Content.ReadAsStringAsync();
+        return JsonConvert.DeserializeObject<Series>(responseBody);
+    }
+
+    private List<SonarrCommand> GetSearchCommands(SonarrSearchType searchType, HashSet<SearchItem> items)
+    {
+        const string episodeSearch = "EpisodeSearch";
+        const string seasonSearch = "SeasonSearch";
+        const string seriesSearch = "SeriesSearch";
+        
+        List<SonarrCommand> commands = new();
+
+        foreach (SearchItem item in items)
+        {
+            SonarrCommand command = searchType is SonarrSearchType.Episode
+                ? commands.FirstOrDefault() ?? new() { Name = episodeSearch, EpisodeIds = new() }
+                : new();
+            
+            switch (searchType)
+            {
+                case SonarrSearchType.Episode when command.EpisodeIds is null:
+                    command.EpisodeIds = [item.Id];
+                    break;
+                
+                case SonarrSearchType.Episode when command.EpisodeIds is not null:
+                    command.EpisodeIds.Add(item.Id);
+                    break;
+                
+                case SonarrSearchType.Season:
+                    command.Name = seasonSearch;
+                    command.SeasonNumber = item.Id;
+                    command.SeriesId = ((SonarrSearchItem)item).SeriesId;
+                    break;
+                
+                case SonarrSearchType.Series:
+                    command.Name = seriesSearch;
+                    command.SeriesId = item.Id;
+                    break;
+                
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(searchType), searchType, null);
+            }
+
+            if (searchType is SonarrSearchType.Episode && commands.Count > 0)
+            {
+                // only one command will be generated for episodes search
+                continue;
+            }
+            
+            commands.Add(command);
+        }
+        
+        return commands;
+    }
 }

code/Infrastructure/Verticals/ContentBlocker/ContentBlocker.cs

@@ -1,4 +1,5 @@
 using Common.Configuration;
+using Common.Configuration.Arr;
 using Domain.Arr.Queue;
 using Domain.Enums;
 using Infrastructure.Verticals.Arr;

code/Infrastructure/Verticals/DownloadClient/Deluge/DelugeClient.cs

@@ -1,6 +1,7 @@
 using System.Net.Http.Headers;
 using System.Text.Json.Serialization;
 using Common.Configuration;
+using Common.Configuration.DownloadClient;
 using Domain.Models.Deluge.Exceptions;
 using Domain.Models.Deluge.Request;
 using Domain.Models.Deluge.Response;

code/Infrastructure/Verticals/DownloadClient/Deluge/DelugeService.cs

@@ -1,4 +1,5 @@
 using Common.Configuration;
+using Common.Configuration.DownloadClient;
 using Domain.Models.Deluge.Response;
 using Infrastructure.Verticals.ContentBlocker;
 using Microsoft.Extensions.Logging;

code/Infrastructure/Verticals/DownloadClient/DownloadServiceFactory.cs

@@ -1,4 +1,5 @@
 using Common.Configuration;
+using Common.Configuration.DownloadClient;
 using Infrastructure.Verticals.DownloadClient.Deluge;
 using Infrastructure.Verticals.DownloadClient.QBittorrent;
 using Infrastructure.Verticals.DownloadClient.Transmission;

code/Infrastructure/Verticals/DownloadClient/QBittorrent/QBitService.cs

@@ -1,4 +1,5 @@
 using Common.Configuration;
+using Common.Configuration.DownloadClient;
 using Infrastructure.Verticals.ContentBlocker;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;

code/Infrastructure/Verticals/DownloadClient/Transmission/TransmissionService.cs

@@ -1,4 +1,5 @@
 using Common.Configuration;
+using Common.Configuration.DownloadClient;
 using Infrastructure.Verticals.ContentBlocker;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;

code/Infrastructure/Verticals/Jobs/GenericHandler.cs

@@ -1,6 +1,7 @@
-using Common.Configuration;
+using Common.Configuration.Arr;
 using Domain.Arr.Queue;
 using Domain.Enums;
+using Domain.Models.Arr;
 using Infrastructure.Verticals.Arr;
 using Infrastructure.Verticals.DownloadClient;
 using Microsoft.Extensions.Logging;
@@ -51,7 +52,7 @@ public abstract class GenericHandler : IDisposable
 
     protected abstract Task ProcessInstanceAsync(ArrInstance instance, InstanceType instanceType);
     
-    protected async Task ProcessArrConfigAsync(ArrConfig config, InstanceType instanceType)
+    private async Task ProcessArrConfigAsync(ArrConfig config, InstanceType instanceType)
     {
         if (!config.Enabled)
         {
@@ -78,13 +79,36 @@ public abstract class GenericHandler : IDisposable
             InstanceType.Radarr => _radarrClient,
             _ => throw new NotImplementedException($"instance type {type} is not yet supported")
         };
-    
-    protected int GetRecordId(InstanceType type, QueueRecord record) =>
+
+    protected ArrConfig GetConfig(InstanceType type) =>
         type switch
         {
-            // TODO add episode id
-            InstanceType.Sonarr => record.SeriesId,
-            InstanceType.Radarr => record.MovieId,
+            InstanceType.Sonarr => _sonarrConfig,
+            InstanceType.Radarr => _radarrConfig,
+            _ => throw new NotImplementedException($"instance type {type} is not yet supported")
+        };
+    
+    protected SearchItem GetRecordSearchItem(InstanceType type, QueueRecord record) =>
+        type switch
+        {
+            InstanceType.Sonarr when _sonarrConfig.SearchType is SonarrSearchType.Episode => new SonarrSearchItem
+            {
+                Id = record.EpisodeId,
+                SeriesId = record.SeriesId
+            },
+            InstanceType.Sonarr when _sonarrConfig.SearchType is SonarrSearchType.Season => new SonarrSearchItem
+            {
+                Id = record.SeasonNumber,
+                SeriesId = record.SeriesId
+            },
+            InstanceType.Sonarr when _sonarrConfig.SearchType is SonarrSearchType.Series => new SonarrSearchItem
+            {
+                Id = record.SeriesId,
+            },
+            InstanceType.Radarr => new SearchItem
+            {
+                Id = record.MovieId,
+            },
             _ => throw new NotImplementedException($"instance type {type} is not yet supported")
         };
 }

code/Infrastructure/Verticals/QueueCleaner/QueueCleaner.cs

@@ -1,6 +1,8 @@
 using Common.Configuration;
+using Common.Configuration.Arr;
 using Domain.Arr.Queue;
 using Domain.Enums;
+using Domain.Models.Arr;
 using Infrastructure.Verticals.Arr;
 using Infrastructure.Verticals.DownloadClient;
 using Infrastructure.Verticals.Jobs;
@@ -25,7 +27,7 @@ public sealed class QueueCleaner : GenericHandler
     
     protected override async Task ProcessInstanceAsync(ArrInstance instance, InstanceType instanceType)
     {
-        HashSet<int> itemsToBeRefreshed = [];
+        HashSet<SearchItem> itemsToBeRefreshed = [];
         ArrClient arrClient = GetClient(instanceType);
 
         await _arrArrQueueIterator.Iterate(arrClient, instance, async items =>
@@ -49,12 +51,12 @@ public sealed class QueueCleaner : GenericHandler
                     continue;
                 }
 
-                itemsToBeRefreshed.Add(GetRecordId(instanceType, record));
+                itemsToBeRefreshed.Add(GetRecordSearchItem(instanceType, record));
 
                 await arrClient.DeleteQueueItemAsync(instance, record);
             }
         });
         
-        await arrClient.RefreshItemsAsync(instance, itemsToBeRefreshed);
+        await arrClient.RefreshItemsAsync(instance, GetConfig(instanceType), itemsToBeRefreshed);
     }
 }