Clarify error message on indexer request error

* Add newzbay categories; add title lookup API

* Update dependencies

* Update docker compose

* Fix title lookup colon workaround

* Remove rid and tmdbid from text search queries

Dockerfile.arm64

@@ -0,0 +1,11 @@
+FROM --platform=linux/arm64 mcr.microsoft.com/dotnet/sdk:8.0 AS build-env
+WORKDIR /app
+
+COPY . ./
+RUN dotnet restore
+RUN dotnet publish -c Release -o out
+
+FROM --platform=linux/arm64 mcr.microsoft.com/dotnet/aspnet:8.0
+WORKDIR /app
+COPY --from=build-env /app/out .
+ENTRYPOINT ["dotnet", "UmlautAdaptarr.dll"]

README.md

@@ -1,37 +1,22 @@
 # UmlautAdaptarr
 
-## English description coming soon
+ A tool to work around Sonarr, Radarr, Lidarr and Readarrs problems with foreign languages.
 
-## Erste Testversion
+## Detailed English description coming soon
-Wer möchte kann den UmlautAdaptarr jetzt gerne testen! Über Feedback würde ich mich sehr freuen!
 
-Es sollte mit allen *arrs funktionieren, hat aber nur bei Sonarr und Lidarr schon Auswirkungen (abgesehen vom Caching).
+## Beschreibung
 
-Momentan ist docker dafür nötig, wer kein Docker nutzt muss sich noch etwas gedulden. 
-
-[Link zum Docker Image](https://hub.docker.com/r/pcjones/umlautadaptarr)
-
-Zusätzlich müsst ihr in Sonarr oder Prowlarr einen neuen Indexer hinzufügen (für jeden Indexer, bei dem UmlautAdapdarr greifen soll).
-
-Am Beispiel von sceneNZBs:
-
-![grafik](https://github.com/PCJones/UmlautAdaptarr/assets/377223/07c7ca45-e0e5-4a82-af63-365bb23c55c9)
-
-Also alles wie immer, nur dass ihr als API-URL nicht direkt z.B. `https://scenenzbs.com` eingebt, sondern 
-`http://localhost:5005/_/scenenzbs.com`
-
-Den API-Key müsst ihr natürlich auch ganz normal setzen.
-
-## Was macht UmlautAdaptarr überhaupt?
 UmlautAdaptarr löst mehrere Probleme:
-- Releases mit Umlauten werden grundsätzlich nicht korrekt von den *Arrs importiert
+- Releases mit Umlauten werden grundsätzlich nicht korrekt von den *arrs importiert
-- Releases mit Umlauten werden oft nicht korrekt gefunden (*Arrs suchen nach "o" statt "ö" & es fehlt häufig die korrekte Zuordnung zur Serie/zum Film beim Indexer)
+- Releases mit Umlauten werden oft nicht korrekt gefunden (*arrs suchen nach "o" statt "ö" & es fehlt häufig die korrekte Zuordnung zur Serie/zum Film beim Indexer)
 - Sonarr & Radarr erwarten immer den englischen Titel von https://thetvdb.com/ bzw. https://www.themoviedb.org/. Das führt bei deutschen Produktionen oder deutschen Übersetzungen oft zu Problemen - falls die *arrs schon mal etwas mit der Meldung `Found matching series/movie via grab history, but release was matched to series by ID. Automatic import is not possible/` nicht importiert haben, dann war das der Grund.
+- Releases mit schlechtem Naming (z.B. von der Group TvR die kein "GERMAN" in den Releasename tun) werden korrigiert, so dass Sonarr&Radarr diese korrekt erkennen (optional)
+- Zusätzlich werden einige andere Fehler behoben, die häufig dazu führen, dass Titel nicht erfolgreich gefunden, geladen oder importiert werden.
 
-# Wie macht UmlautAdaptarr das?
+## Wie macht UmlautAdaptarr das?
 UmlautAdaptarr tut so, als wäre es ein Indexer. In Wahrheit schaltet sich UmlautAdaptarr aber nur zwischen die *arrs und den echten Indexer und kann somit die Suchen sowie die Ergebnisse abfangen und bearbeiten.
-Am Ende werden die gefundenen Releases immer so umbenannt, das die Arrs sie einwandfrei erkennen.
+Am Ende werden die gefundenen Releases immer so umbenannt, dass die Arrs sie einwandfrei erkennen.
-Einige Beispiele findet ihr unter Features.
+Einige Beispiele finden sich [weiter unten](https://github.com/PCJones/UmlautAdaptarr?tab=readme-ov-file#beispiel-funktionalit%C3%A4t).
 
 
 ## Features
@@ -45,12 +30,63 @@ Einige Beispiele findet ihr unter Features.
 | Releases mit deutschem Titel werden erkannt                       |✓              |
 | Releases mit TVDB-Alias Titel werden erkannt                      |✓              |
 | Korrekte Suche und Erkennung von Titel mit Umlauten               |✓              |
-| Anfragen-Caching für 5 Minuten zur Reduzierung der API-Zugriffe   | ✓             |
+| Anfragen-Caching für 12 Minuten zur Reduzierung der API-Zugriff   |✓              |
-| Radarr Support                                                    | Geplant       |
+| Usenet (newznab) Support                                          |✓              |
-| Prowlarr Unterstützung für "DE" SceneNZBs Kategorien              | Geplant       |
+| Torrent (torznab) Support                                         |✓              |
+| Support von mehreren *arr-Instanzen des gleichen Typs (z.B. 2x Sonarr)|✓          |             
+| Releases mit mit schlechtem Naming werden korrekt umbenannt (optional) | in Arbeit|
+| Radarr Support                                                    | in Arbeit     |
+| Webinterface                                                      | Geplant       |
 | Unterstützung weiterer Sprachen neben Deutsch                     | Geplant       |
 | Wünsche?                                                          | Vorschläge?   |
 
+
+## Installation
+- [Docker](https://hub.docker.com/r/pcjones/umlautadaptarr)
+- Unraid: nach `umlautadaptarr` suchen
+- [Proxmox LXC (unofficial)](https://community-scripts.github.io/ProxmoxVE/scripts?id=umlautadaptarr) - appsettings.json muss nach Installation konfiguriert werden
+- [Seedbox/Binary](https://github.com/PCJones/UmlautAdaptarr/blob/master/run_on_seedbox.sh)
+
+Nicht benötigte Umgebungsvariablen, z.B. falls Readarr oder Lidarr nicht genutzt werden, können entfernt werden.
+
+### Konfiguration in Prowlarr (**empfohlen**)
+Das ist die **empfohlene** Methode um den UmlautAdaptarr einzurichten. Sie hat den Vorteil, dass es, sofern man mehrere Indexer nutzt, keinen Geschwindigkeitsverlust bei der Suche geben sollte.
+
+1) Setze die benötigten [Docker Umgebungsvariablen](https://hub.docker.com/r/pcjones/umlautadaptarr) in deiner docker-compose Datei bzw. in deinem docker run Befehl
+2) In Prowlarr: Settings>Indexers bzw. Einstellungen>Indexer öffnen
+3) Lege einen neuen HTTP-Proxy an:
+
+![Image](https://github.com/PCJones/UmlautAdaptarr/assets/377223/b97418d8-d972-4e3c-9d2f-3a830a5ac0a3)
+
+- Name: UmlautAdaptarr HTTP Proxy (Beispiel)
+- Port: `5006` (Port beachten!) 
+- Tag: `umlautadaptarr`
+- Host: Je nachdem, wie deine Docker-Konfiguration ist, kann es sein, dass du entweder `umlautadaptarr` oder `localhost`, oder ggf. die IP des Host setzen musst. Probiere es sonst einfach aus, indem du auf Test klickst.
+- Die Username- und Passwort-Felder können leergelassen werden.
+4) Gehe zur Indexer-Übersichtsseite
+5) Für alle Indexer/Tracker, die den UmlautAdaptarr nutzen sollen:
+
+![grafik](https://github.com/PCJones/UmlautAdaptarr/assets/377223/3daea3f1-7c7b-4982-84e2-ea6a42d90fba)
+
+  - Füge den `umlautadaptarr` Tag hinzu
+  - **Wichtig:** Ändere die URL von `https` zu `http`. (Dies ist erforderlich, damit der UmlautAdaptarr die Anfragen **lokal** abfangen kann. **Ausgehende** Anfragen an den Indexer verwenden natürlich weiterhin https).
+6) Klicke danach auf `Test All Indexers` bzw `Alle Indexer Testen`. Falls du irgendwo noch `https` statt `http` stehen hast, sollte in den UmlautAdaptarr logs eine Warnung auftauchen. Mindestens solltest du aber noch ein zweites Mal alle Indexer durchgehen und überprüfen, ob überall `http` eingestellt ist - Indexer, bei denen noch `https` steht, werden nämlich einwandfrei funktionieren - allerdings ohne, dass der UmlautAdaptarr bei diesen wirken kann.
+
+### Konfiguration in Sonarr/Radarr oder Prowlarr ohne Proxy
+Falls du kein Prowlarr nutzt oder nur 1-3 Indexer nutzt, kannst du diese alternative Konfigurationsmöglichkeit nutzen.
+
+1) Setze die benötigten [Docker Umgebungsvariablen](https://hub.docker.com/r/pcjones/umlautadaptarr) in deiner docker-compose Datei bzw. in deinem docker run Befehl
+2) Bearbeite alle Indexer, bei denen der UmlautAdaptarr greifen soll, wie folgt:
+
+Am Beispiel von sceneNZBs:
+
+![grafik](https://github.com/PCJones/UmlautAdaptarr/assets/377223/07c7ca45-e0e5-4a82-af63-365bb23c55c9)
+
+Also alles wie immer, nur dass als API-URL nicht direkt z.B. `https://scenenzbs.com` gesetzt wird, sondern 
+`http://localhost:5005/_/scenenzbs.com`
+
+Der API-Key muss natürlich auch ganz normal gesetzt werden.
+
 ## Beispiel-Funktionalität
 In den Klammern am Ende des Releasenamens (Bild 2 & 4) steht zu Anschauungszwecken der deutsche Titel der vorher nicht gefunden bzw. akzeptiert wurde. Das bleibt natürlich nicht so ;)
 
@@ -64,7 +100,7 @@ In den Klammern am Ende des Releasenamens (Bild 2 & 4) steht zu Anschauungszweck
 **Vorher:** Es werden nur Releases mit dem englischen Titel der Serie gefunden
 ![Vorherige Suche, englische Titel](https://github.com/PCJones/UmlautAdaptarr/assets/377223/ed7ca0fa-ac36-4584-87ac-b29f32dd9ace)
 
-**Jetzt:**  Es werden auch Titel mit dem deutschen Namen gefunden :D (haben nicht alle Suchergebnisse auf den Screenshot gepasst)
+**Jetzt:**  Es werden auch Titel mit dem deutschen Namen gefunden :D
 ![Jetzige Suche, deutsche und englische Titel](https://github.com/PCJones/UmlautAdaptarr/assets/377223/1c2dbe1a-5943-4fc4-91ef-29708082900e)
 
 
@@ -85,9 +121,21 @@ Sonarr erwartet immer den Englischen Namen, der hier natürlich nicht gegeben is
 ## Kontakt & Support
 - Öffne gerne ein Issue auf GitHub falls du Unterstützung benötigst.
 - [Telegram](https://t.me/pc_jones)
-- Discord: pcjones1 - oder komm in den UsenetDE Discord Server: [https://discord.gg/pZrrMcJMQM](https://discord.gg/pZrrMcJMQM)
+- [UsenetDE Discord Server](https://discord.gg/src6zcH4rr) -> #umlautadaptarr
+
+## Spenden
+Über eine Spende freue ich mich natürlich immer :D
+
+<a href="https://www.buymeacoffee.com/pcjones" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" height="60px" width="217px" ></a>
+<a href="https://coindrop.to/pcjones" target="_blank"><img src="https://coindrop.to/embed-button.png" style="border-radius: 10px; height: 57px !important;width: 229px !important;" alt="Coindrop.to me"></img></a>
+
+Für andere Spendenmöglichkeiten gerne auf Discord oder Telegram melden - danke!
 
 ### Licenses & Metadata source
 - TV Metadata source: https://thetvdb.com
 - Movie Metadata source: https://themoviedb.org
 - Licenses: TODO
+
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=pcjones/umlautadaptarr&type=Date)](https://star-history.com/#pcjones/umlautadaptarr&Date)

UmlautAdaptarr/Controllers/CapsController.cs

@@ -1,26 +1,37 @@
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Options;
 using System.Text;
 using System.Xml.Linq;
+using UmlautAdaptarr.Options;
 using UmlautAdaptarr.Services;
 using UmlautAdaptarr.Utilities;
 
 namespace UmlautAdaptarr.Controllers
 {
-    public class CapsController(ProxyService proxyService) : ControllerBase
+    public class CapsController(ProxyRequestService proxyRequestService, IOptions<GlobalOptions> options, ILogger<CapsController> logger) : ControllerBase
     {
-        private readonly ProxyService _proxyService = proxyService;
+        private readonly ProxyRequestService _proxyRequestService = proxyRequestService;
+        private readonly GlobalOptions _options = options.Value;
+        private readonly ILogger<CapsController> _logger = logger;
+
 
         [HttpGet]
-        public async Task<IActionResult> Caps([FromRoute] string options, [FromRoute] string domain, [FromQuery] string? apikey)
+        public async Task<IActionResult> Caps([FromRoute] string apiKey, [FromRoute] string domain, [FromQuery] string? apikey)
         {
-            if (!UrlUtilities.IsValidDomain(domain))
+            if (!string.IsNullOrEmpty(apikey) && !apiKey.Equals(apiKey))
+            {
+                _logger.LogWarning("Invalid or missing API key for request.");
+                return Unauthorized("Unauthorized: Invalid or missing API key.");
+            }
+
+            if (!domain.StartsWith("localhost") && !UrlUtilities.IsValidDomain(domain))
             {
                 return NotFound($"{domain} is not a valid URL.");
             }
 
             var requestUrl = UrlUtilities.BuildUrl(domain, "caps", apikey);
 
-            var responseMessage = await _proxyService.ProxyRequestAsync(HttpContext, requestUrl);
+            var responseMessage = await _proxyRequestService.ProxyRequestAsync(HttpContext, requestUrl);
 
             var content = await responseMessage.Content.ReadAsStringAsync();
             var encoding = responseMessage.Content.Headers.ContentType?.CharSet != null ?

UmlautAdaptarr/Controllers/SearchController.cs

@@ -1,29 +1,36 @@
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Options;
 using System.Text;
 using UmlautAdaptarr.Models;
+using UmlautAdaptarr.Options;
 using UmlautAdaptarr.Services;
 using UmlautAdaptarr.Utilities;
 
 namespace UmlautAdaptarr.Controllers
 {
-    public abstract class SearchControllerBase(ProxyService proxyService, TitleMatchingService titleMatchingService) : ControllerBase
+    public abstract class SearchControllerBase(ProxyRequestService proxyRequestService, TitleMatchingService titleMatchingService, IOptions<GlobalOptions> options, ILogger<SearchControllerBase> logger) : ControllerBase
     {
-        private readonly bool TODO_FORCE_TEXT_SEARCH_ORIGINAL_TITLE = false;
+        // TODO evaluate if this should be set to true by default
+        private readonly bool TODO_FORCE_TEXT_SEARCH_ORIGINAL_TITLE = true;
         private readonly bool TODO_FORCE_TEXT_SEARCH_GERMAN_TITLE = false;
-        protected async Task<IActionResult> BaseSearch(string options,
+        protected async Task<IActionResult?> BaseSearch(string apiKey,
                                                        string domain,
                                                        IDictionary<string, string> queryParameters,
                                                        SearchItem? searchItem = null)
         {
             try
             {
+                if (!AssureApiKey(apiKey))
+                {
+                    return Unauthorized("Unauthorized: Invalid or missing API key.");
+                }
+
                 if (!UrlUtilities.IsValidDomain(domain))
                 {
                     return NotFound($"{domain} is not a valid URL.");
                 }
 
-                var initialSearchResult = await PerformSingleSearchRequest(domain, queryParameters) as ContentResult;
+                if (await PerformSingleSearchRequest(domain, queryParameters) is not ContentResult initialSearchResult)
-                if (initialSearchResult == null)
                 {
                     return null;
                 }
@@ -49,10 +56,12 @@ namespace UmlautAdaptarr.Controllers
                     queryParameters.Remove("tvdbid");
                     queryParameters.Remove("tvmazeid");
                     queryParameters.Remove("imdbid");
+                    queryParameters.Remove("rid");
+                    queryParameters.Remove("tmdbid");
 
                     var titleSearchVariations = new List<string>(searchItem?.TitleSearchVariations);
 
-                    string searchQuery = string.Empty;
+                    var searchQuery = string.Empty;
                     if (queryParameters.TryGetValue("q", out string? q))
                     {
                         searchQuery = q ?? string.Empty;
@@ -95,7 +104,7 @@ namespace UmlautAdaptarr.Controllers
         private async Task<IActionResult> PerformSingleSearchRequest(string domain, IDictionary<string, string> queryParameters)
         {
             var requestUrl = UrlUtilities.BuildUrl(domain, queryParameters);
-            var responseMessage = await proxyService.ProxyRequestAsync(HttpContext, requestUrl);
+            var responseMessage = await proxyRequestService.ProxyRequestAsync(HttpContext, requestUrl);
             var content = await responseMessage.Content.ReadAsStringAsync();
 
             var encoding = responseMessage.Content.Headers.ContentType?.CharSet != null ?
@@ -108,9 +117,17 @@ namespace UmlautAdaptarr.Controllers
 
 
         private string ProcessContent(string content, SearchItem? searchItem)
+        {
+            try
             {
                 return titleMatchingService.RenameTitlesInContent(content, searchItem);
             }
+            catch (Exception ex)
+            {
+                logger.LogError($"Error at ProcessContent: {ex.Message}{Environment.NewLine}Content:{Environment.NewLine}{content}");
+            }
+            return null;
+        }
 
         public async Task<AggregatedSearchResult> AggregateSearchResults(
             string domain,
@@ -129,7 +146,7 @@ namespace UmlautAdaptarr.Controllers
             {
                 queryParameters["q"] = titleVariation; // Replace the "q" parameter for each variation
                 var requestUrl = UrlUtilities.BuildUrl(domain, queryParameters);
-                var responseMessage = await proxyService.ProxyRequestAsync(HttpContext, requestUrl);
+                var responseMessage = await proxyRequestService.ProxyRequestAsync(HttpContext, requestUrl);
                 var content = await responseMessage.Content.ReadAsStringAsync();
 
                 // Only update encoding from the first response
@@ -149,27 +166,48 @@ namespace UmlautAdaptarr.Controllers
 
             return aggregatedResult;
         }
+
+        internal bool AssureApiKey(string apiKey)
+        {
+            if (!string.IsNullOrEmpty(options.Value.ApiKey) && !apiKey.Equals(options.Value.ApiKey))
+            {
+                logger.LogWarning("Invalid or missing API key for request.");
+                return false;
+            }
+            return true;
+        }
     }
 
-    public class SearchController(ProxyService proxyService,
+    public class SearchController(ProxyRequestService proxyRequestService,
                                   TitleMatchingService titleMatchingService,
-                                  SearchItemLookupService searchItemLookupService) : SearchControllerBase(proxyService, titleMatchingService)
+                                  SearchItemLookupService searchItemLookupService,
+                                  IOptions<GlobalOptions> options,
+                                  ILogger<SearchControllerBase> logger) : SearchControllerBase(proxyRequestService, titleMatchingService, options, logger)
     {
         public readonly string[] LIDARR_CATEGORY_IDS = ["3000", "3010", "3020", "3040", "3050"];
         public readonly string[] READARR_CATEGORY_IDS = ["3030", "3130", "7000", "7010", "7020", "7030", "7100", "7110", "7120", "7130"];
 
         [HttpGet]
-        public async Task<IActionResult> MovieSearch([FromRoute] string options, [FromRoute] string domain)
+        public async Task<IActionResult> MovieSearch([FromRoute] string apiKey, [FromRoute] string domain)
         {
+            if (!AssureApiKey(apiKey))
+            {
+                return Unauthorized("Unauthorized: Invalid or missing API key.");
+            }
+
             var queryParameters = HttpContext.Request.Query.ToDictionary(
                  q => q.Key,
                  q => string.Join(",", q.Value));
-            return await BaseSearch(options, domain, queryParameters);
+            return await BaseSearch(apiKey, domain, queryParameters);
         }
 
         [HttpGet]
-        public async Task<IActionResult> GenericSearch([FromRoute] string options, [FromRoute] string domain)
+        public async Task<IActionResult> GenericSearch([FromRoute] string apiKey, [FromRoute] string domain)
         {
+            if (!AssureApiKey(apiKey))
+            {
+                return Unauthorized("Unauthorized: Invalid or missing API key.");
+            }
 
             var queryParameters = HttpContext.Request.Query.ToDictionary(
                  q => q.Key,
@@ -197,21 +235,31 @@ namespace UmlautAdaptarr.Controllers
                 }
             }
 
-            return await BaseSearch(options, domain, queryParameters, searchItem);
+            return await BaseSearch(apiKey, domain, queryParameters, searchItem);
         }
 
         [HttpGet]
-        public async Task<IActionResult> BookSearch([FromRoute] string options, [FromRoute] string domain)
+        public async Task<IActionResult> BookSearch([FromRoute] string apiKey, [FromRoute] string domain)
         {
+            if (!AssureApiKey(apiKey))
+            {
+                return Unauthorized("Unauthorized: Invalid or missing API key.");
+            }
+
             var queryParameters = HttpContext.Request.Query.ToDictionary(
                  q => q.Key,
                  q => string.Join(",", q.Value));
-            return await BaseSearch(options, domain, queryParameters);
+            return await BaseSearch(apiKey, domain, queryParameters);
         }
 
         [HttpGet]
-        public async Task<IActionResult> TVSearch([FromRoute] string options, [FromRoute] string domain)
+        public async Task<IActionResult> TVSearch([FromRoute] string apiKey, [FromRoute] string domain)
         {
+            if (!AssureApiKey(apiKey))
+            {
+               return Unauthorized("Unauthorized: Invalid or missing API key.");
+            }
+
             var queryParameters = HttpContext.Request.Query.ToDictionary(
                  q => q.Key,
                  q => string.Join(",", q.Value));
@@ -228,16 +276,21 @@ namespace UmlautAdaptarr.Controllers
                 searchItem = await searchItemLookupService.GetOrFetchSearchItemByTitle(mediaType, title);
             }
 
-            return await BaseSearch(options, domain, queryParameters, searchItem);
+            return await BaseSearch(apiKey, domain, queryParameters, searchItem);
         }
 
         [HttpGet]
-        public async Task<IActionResult> MusicSearch([FromRoute] string options, [FromRoute] string domain)
+        public async Task<IActionResult> MusicSearch([FromRoute] string apiKey, [FromRoute] string domain)
         {
+            if (!AssureApiKey(apiKey))
+            {
+                return Unauthorized("Unauthorized: Invalid or missing API key.");
+            }
+
             var queryParameters = HttpContext.Request.Query.ToDictionary(
                  q => q.Key,
                  q => string.Join(",", q.Value));
-            return await BaseSearch(options, domain, queryParameters);
+            return await BaseSearch(apiKey, domain, queryParameters);
         }
     }
 }

UmlautAdaptarr/Controllers/TitleLookupController.cs

@@ -0,0 +1,32 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Options;
+using UmlautAdaptarr.Options;
+using UmlautAdaptarr.Services;
+
+namespace UmlautAdaptarr.Controllers
+{
+	[ApiController]
+	[Route("titlelookup/")]
+	public class TitleLookupController(CacheService cacheService, IOptions<GlobalOptions> options) : ControllerBase
+	{
+		GlobalOptions _options = options.Value;
+		[HttpGet]
+		public IActionResult GetOriginalTitle([FromQuery] string changedTitle)
+		{
+			if (!_options.EnableChangedTitleCache)
+			{
+				return StatusCode(501, "Set SETTINGS__EnableChangedTitleCache to true to use this endpoint.");
+			}
+
+			if (string.IsNullOrWhiteSpace(changedTitle))
+				return BadRequest("changedTitle is required.");
+
+			var originalTitle = cacheService.GetOriginalTitleFromRenamed(changedTitle);
+
+			return originalTitle != null
+				? Ok(new { changedTitle, originalTitle })
+				: NotFound($"Original title not found for '{changedTitle}'.");
+		}
+	}
+
+}

UmlautAdaptarr/Interfaces/IArrApplication.cs

@@ -0,0 +1,10 @@
+using UmlautAdaptarr.Models;
+
+namespace UmlautAdaptarr.Interfaces;
+
+public interface IArrApplication
+{
+    Task<IEnumerable<SearchItem>> FetchAllItemsAsync();
+    Task<SearchItem?> FetchItemByExternalIdAsync(string externalId);
+    Task<SearchItem?> FetchItemByTitleAsync(string title);
+}

UmlautAdaptarr/Models/IpInfo.cs

@@ -0,0 +1,33 @@
+using System.Text.Json.Serialization;
+
+namespace UmlautAdaptarr.Utilities;
+
+public class IpInfo
+{
+    [JsonPropertyName("ip")]
+    public string? Ip { get; set; }
+
+    [JsonPropertyName("hostname")]
+    public string? Hostname { get; set; }
+
+    [JsonPropertyName("city")]
+    public string? City { get; set; }
+
+    [JsonPropertyName("region")]
+    public string? Region { get; set; }
+
+    [JsonPropertyName("country")]
+    public string? Country { get; set; }
+
+    [JsonPropertyName("loc")]
+    public string? Loc { get; set; }
+
+    [JsonPropertyName("org")]
+    public string? Org { get; set; }
+
+    [JsonPropertyName("postal")]
+    public string? Postal { get; set; }
+
+    [JsonPropertyName("timezone")]
+    public string? Timezone { get; set; }
+}

UmlautAdaptarr/Models/SearchItem.cs

@@ -43,7 +43,30 @@ namespace UmlautAdaptarr.Models
             }
             else
             {
-                GenerateVariationsForTV(germanTitle, mediaType, aliases);
+                // if mediatype is movie/tv and the Expected Title ends with a year but the german title doesn't then append the year to the german title and to aliases
+                // example: https://thetvdb.com/series/385925-avatar-the-last-airbender -> german Title is without 2024
+                var yearAtEndOfTitleMatch = YearAtEndOfTitleRegex().Match(expectedTitle);
+                if (yearAtEndOfTitleMatch.Success)
+                {
+                    string year = yearAtEndOfTitleMatch.Value[1..^1];
+                    if (GermanTitle != null && !GermanTitle.Contains(year))
+                    {
+                        GermanTitle = $"{germanTitle} {year}";
+                    }
+
+                    if (aliases != null)
+                    {
+                        for (int i = 0; i < aliases.Length; i++)
+                        {
+                            if (!aliases[i].Contains(year))
+                            {
+                                aliases[i] = $"{aliases[i]} {year}";
+                            }
+                        }
+                    }
+                }
+
+                GenerateVariationsForTV(GermanTitle, mediaType, aliases);
             }
         }
 
@@ -60,6 +83,12 @@ namespace UmlautAdaptarr.Models
                 foreach (var alias in aliases)
                 {
                     allTitleVariations.AddRange(GenerateVariations(alias, mediaType));
+
+                    // If title contains ":" also match for "-"
+                    if (alias.Contains(':'))
+                    {
+                        allTitleVariations.Add(alias.Replace(":", " -"));
+                    }
                 }
             }
 
@@ -79,6 +108,26 @@ namespace UmlautAdaptarr.Models
 
             }
 
+            // if a german title ends with "Germany" (e.g. Good Luck Guys Germany) also add a search string that replaces Germany with GERMAN
+            // (e.g. Good Luck Guys GERMAN). This is because reality shows often have different formats in different countries with the same
+            // name. // also add a matching title without GERMAN
+            if (germanTitle?.EndsWith("germany", StringComparison.OrdinalIgnoreCase) ?? false)
+            {
+                TitleSearchVariations = [.. TitleSearchVariations,
+                    ..
+                    GenerateVariations(
+                        (germanTitle[..^7] + "GERMAN").RemoveExtraWhitespaces(),
+                    mediaType)];
+
+                allTitleVariations.AddRange(GenerateVariations(germanTitle[..^8].Trim(), mediaType));
+            }
+
+            // If title contains ":" also match for "-"
+            if (germanTitle?.Contains(':') ?? false)
+            {
+                allTitleVariations.Add(germanTitle.Replace(":", " -"));
+            }
+
             TitleMatchVariations = allTitleVariations.Distinct(StringComparer.InvariantCultureIgnoreCase).ToArray();
         }
 
@@ -117,12 +166,13 @@ namespace UmlautAdaptarr.Models
             }
         }
 
-        private IEnumerable<string> GenerateVariations(string? title, string mediaType)
+        private static IEnumerable<string> GenerateVariations(string? title, string mediaType)
         {
             if (title == null)
             {
                 return [];
             }
+
             var cleanTitle = title.GetCleanTitle();
 
             if (cleanTitle?.Length == 0)
@@ -180,5 +230,8 @@ namespace UmlautAdaptarr.Models
 
             return cleanedVariations.Distinct();
         }
+
+        [GeneratedRegex(@"\(\d{4}\)$")]
+        private static partial Regex YearAtEndOfTitleRegex();
     }
 }

UmlautAdaptarr/Options/ArrOptions/InstanceOptions/GlobalInstanceOptions.cs

@@ -0,0 +1,25 @@
+namespace UmlautAdaptarr.Options.ArrOptions.InstanceOptions
+{
+    public class GlobalInstanceOptions
+    {
+        /// <summary>
+        /// Indicates whether the Arr application is enabled.
+        /// </summary>
+        public bool Enabled { get; set; }
+
+        /// <summary>
+        /// Name of the Instance
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// The host of the ARR application.
+        /// </summary>
+        public string Host { get; set; }
+
+        /// <summary>
+        /// The API key of the ARR application.
+        /// </summary>
+        public string ApiKey { get; set; }
+    }
+}

UmlautAdaptarr/Options/ArrOptions/InstanceOptions/LidarrInstanceOptions.cs

@@ -0,0 +1,6 @@
+namespace UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
+
+public class LidarrInstanceOptions : GlobalInstanceOptions
+{
+    
+}

UmlautAdaptarr/Options/ArrOptions/InstanceOptions/ReadarrInstanceOptions.cs

@@ -0,0 +1,6 @@
+namespace UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
+
+public class ReadarrInstanceOptions : GlobalInstanceOptions
+{
+    
+}

UmlautAdaptarr/Options/ArrOptions/InstanceOptions/SonarrInstanceOptions.cs

@@ -0,0 +1,6 @@
+namespace UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
+
+public class SonarrInstanceOptions : GlobalInstanceOptions
+{
+    
+}

UmlautAdaptarr/Options/GlobalOptions.cs

@@ -0,0 +1,38 @@
+namespace UmlautAdaptarr.Options
+{
+    /// <summary>
+    /// Global options for the UmlautAdaptarr application.
+    /// </summary>
+    public class GlobalOptions
+    {
+        /// <summary>
+        /// The host of the UmlautAdaptarr API.
+        /// </summary>
+        public string UmlautAdaptarrApiHost { get; set; }
+
+        /// <summary>
+        /// The User-Agent string used in HTTP requests.
+        /// </summary>
+        public string UserAgent { get; set; }
+
+        /// <summary>
+        /// The duration in minutes to cache the indexer requests.
+        /// </summary>  
+        public int IndexerRequestsCacheDurationInMinutes { get; set; } = 12;
+
+        /// <summary>
+        /// API key for requests to the UmlautAdaptarr. Optional.
+        /// </summary>
+        public string? ApiKey { get; set; } = null;
+
+        /// <summary>
+        /// Proxy port for the internal UmlautAdaptarr proxy.
+        /// </summary>
+        public int ProxyPort { get; set; } = 5006;
+
+		/// <summary>
+		/// Enable or disable the cache for changed titles.
+		/// </summary>
+		public bool EnableChangedTitleCache { get; set; } = false;
+	}
+}

UmlautAdaptarr/Program.cs

@@ -1,27 +1,35 @@
-using Microsoft.Extensions.Configuration;
 using System.Net;
-using UmlautAdaptarr.Providers;
+using Serilog;
+using Serilog.Filters;
 using UmlautAdaptarr.Routing;
 using UmlautAdaptarr.Services;
+using UmlautAdaptarr.Services.Factory;
+using UmlautAdaptarr.Utilities;
 
 internal class Program
 {
     private static void Main(string[] args)
+    {
+        MainAsync(args).Wait();
+    }
+
+    private static async Task MainAsync(string[] args)
     {
         // TODO:
         // add option to sort by nzb age
-
-    
         var builder = WebApplication.CreateBuilder(args);
-
         var configuration = builder.Configuration;
+        ConfigureLogger(configuration);
+
+        builder.Services.AddSerilog();
 
         // Add services to the container.
         builder.Services.AddHttpClient("HttpClient").ConfigurePrimaryHttpMessageHandler(() =>
         {
             var handler = new HttpClientHandler
             {
-                AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate | DecompressionMethods.Brotli
+                AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate |
+                                         DecompressionMethods.Brotli
             };
 
             return handler;
@@ -29,68 +37,86 @@ internal class Program
 
         builder.Services.AddMemoryCache(options =>
         {
+            // TODO cache size limit? option?
             //options.SizeLimit = 20000;
         });
 
-
+        builder.Services.AllowResolvingKeyedServicesAsDictionary();
-        // TODO workaround to not log api keys
-        builder.Logging.AddFilter((category, level) =>
-        {
-            // Prevent logging of HTTP request and response if the category is HttpClient
-            if (category.Contains("System.Net.Http.HttpClient") || category.Contains("Microsoft.Extensions.Http.DefaultHttpClientFactory"))
-            {
-                return false;
-            }
-            return true;
-        });
-
         builder.Services.AddControllers();
-        builder.Services.AddHostedService<ArrSyncBackgroundService>();
+        builder.AddTitleLookupService();
-        builder.Services.AddSingleton<TitleApiService>();
         builder.Services.AddSingleton<SearchItemLookupService>();
         builder.Services.AddSingleton<TitleMatchingService>();
-        builder.Services.AddSingleton<SonarrClient>();
+        await builder.AddSonarrSupport();
-        builder.Services.AddSingleton<LidarrClient>();
+        await builder.AddLidarrSupport();
-        builder.Services.AddSingleton<ReadarrClient>();
+        await builder.AddReadarrSupport();
         builder.Services.AddSingleton<CacheService>();
-        builder.Services.AddSingleton<ProxyService>();
+        builder.Services.AddSingleton<ProxyRequestService>();
+        builder.Services.AddSingleton<ArrApplicationFactory>();
+        builder.Services.AddHostedService<ArrSyncBackgroundService>();
+        builder.Services.AddSingleton<IHostedService, HttpProxyService>();
 
         var app = builder.Build();
 
-        app.UseHttpsRedirection();
+        Helper.ShowLogo();
 
+        if (app.Configuration.GetValue<bool>("IpLeakTest:Enabled"))
+        {
+            await Helper.ShowInformation();
+        }
+
+        GlobalStaticLogger.Initialize(app.Services.GetService<ILoggerFactory>()!);
+        app.UseHttpsRedirection();
         app.UseAuthorization();
 
-        app.MapControllerRoute(name: "caps",
+        app.MapControllerRoute("caps",
-                pattern: "{options}/{*domain}",
+            "{apiKey}/{*domain}",
-                defaults: new { controller = "Caps", action = "Caps" },
+            new { controller = "Caps", action = "Caps" },
-                constraints: new { t = new TRouteConstraint("caps") });
+            new { t = new TRouteConstraint("caps") });
 
-        app.MapControllerRoute(name: "movie-search",
+        app.MapControllerRoute("movie-search",
-                pattern: "{options}/{*domain}",
+            "{apiKey}/{*domain}",
-                defaults: new { controller = "Search", action = "MovieSearch" },
+            new { controller = "Search", action = "MovieSearch" },
-                constraints: new { t = new TRouteConstraint("movie") });
+            new { t = new TRouteConstraint("movie") });
 
-        app.MapControllerRoute(name: "tv-search",
+        app.MapControllerRoute("tv-search",
-                pattern: "{options}/{*domain}",
+            "{apiKey}/{*domain}",
-                defaults: new { controller = "Search", action = "TVSearch" },
+            new { controller = "Search", action = "TVSearch" },
-                constraints: new { t = new TRouteConstraint("tvsearch") });
+            new { t = new TRouteConstraint("tvsearch") });
 
-        app.MapControllerRoute(name: "music-search",
+        app.MapControllerRoute("music-search",
-                pattern: "{options}/{*domain}",
+            "{apiKey}/{*domain}",
-                defaults: new { controller = "Search", action = "MusicSearch" },
+            new { controller = "Search", action = "MusicSearch" },
-                constraints: new { t = new TRouteConstraint("music") });
+            new { t = new TRouteConstraint("music") });
 
-        app.MapControllerRoute(name: "book-search",
+        app.MapControllerRoute("book-search",
-               pattern: "{options}/{*domain}",
+            "{apiKey}/{*domain}",
-               defaults: new { controller = "Search", action = "BookSearch" },
+            new { controller = "Search", action = "BookSearch" },
-               constraints: new { t = new TRouteConstraint("book") });
+            new { t = new TRouteConstraint("book") });
-
-        app.MapControllerRoute(name: "generic-search",
-                pattern: "{options}/{*domain}",
-                defaults: new { controller = "Search", action = "GenericSearch" },
-                constraints: new { t = new TRouteConstraint("search") });
 
+        app.MapControllerRoute("generic-search",
+            "{apiKey}/{*domain}",
+            new { controller = "Search", action = "GenericSearch" },
+            new { t = new TRouteConstraint("search") });
         app.Run();
     }
+
+    private static void ConfigureLogger(ConfigurationManager configuration)
+    {
+        Log.Logger = new LoggerConfiguration()
+            .ReadFrom.Configuration(configuration)
+            .WriteTo.Console(outputTemplate: "[{Timestamp:yyyy-MM-dd HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}")
+
+#if RELEASE
+                .Filter.ByExcluding(Matching.FromSource("Microsoft.AspNetCore.Mvc"))
+                .Filter.ByExcluding(Matching.FromSource("Microsoft.AspNetCore.Routing"))
+                .Filter.ByExcluding(Matching.FromSource("Microsoft.AspNetCore.Diagnostics"))
+                .Filter.ByExcluding(Matching.FromSource("Microsoft.AspNetCore.Hosting"))
+#endif
+
+            // TODO workaround to not log api keys
+            .Filter.ByExcluding(Matching.FromSource("System.Net.Http.HttpClient"))
+            .Filter.ByExcluding(Matching.FromSource("Microsoft.Extensions.Http.DefaultHttpClientFactory"))
+            //.Enrich.With(new ApiKeyMaskingEnricher("appsettings.json")) // TODO - Not working currently
+            .CreateLogger();
+    }
 }

UmlautAdaptarr/Providers/ArrClientBase.cs

@@ -1,13 +1,14 @@
-using Microsoft.Extensions.Caching.Memory;
+using UmlautAdaptarr.Interfaces;
 using UmlautAdaptarr.Models;
-using UmlautAdaptarr.Services;
 
-namespace UmlautAdaptarr.Providers
+namespace UmlautAdaptarr.Providers;
-{
+
-    public abstract class ArrClientBase()
+public abstract class ArrClientBase : IArrApplication
 {
+#pragma warning disable CS8618 // Ein Non-Nullable-Feld muss beim Beenden des Konstruktors einen Wert ungleich NULL enthalten. Erwägen Sie die Deklaration als Nullable.
+    public string InstanceName;
+#pragma warning restore CS8618 // Ein Non-Nullable-Feld muss beim Beenden des Konstruktors einen Wert ungleich NULL enthalten. Erwägen Sie die Deklaration als Nullable.
     public abstract Task<IEnumerable<SearchItem>> FetchAllItemsAsync();
     public abstract Task<SearchItem?> FetchItemByExternalIdAsync(string externalId);
     public abstract Task<SearchItem?> FetchItemByTitleAsync(string title);
 }
-}

UmlautAdaptarr/Providers/LidarrClient.cs

@@ -1,46 +1,64 @@
 using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Options;
 using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
 using UmlautAdaptarr.Models;
+using UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
 using UmlautAdaptarr.Services;
 using UmlautAdaptarr.Utilities;
 
-namespace UmlautAdaptarr.Providers
+namespace UmlautAdaptarr.Providers;
+
+public class LidarrClient : ArrClientBase
 {
-    public class LidarrClient(
+    private readonly IMemoryCache _cache;
-        IHttpClientFactory clientFactory,
+    private readonly CacheService _cacheService;
-        IConfiguration configuration,
+    private readonly IHttpClientFactory _clientFactory;
-        CacheService cacheService,
+    private readonly ILogger<LidarrClient> _logger;
-        IMemoryCache cache,
-        ILogger<LidarrClient> logger) : ArrClientBase()
-    {
-        private readonly string _lidarrHost = configuration.GetValue<string>("LIDARR_HOST") ?? throw new ArgumentException("LIDARR_HOST environment variable must be set");
-        private readonly string _lidarrApiKey = configuration.GetValue<string>("LIDARR_API_KEY") ?? throw new ArgumentException("LIDARR_API_KEY environment variable must be set");
     private readonly string _mediaType = "audio";
 
+    public LidarrClient([ServiceKey] string instanceName,
+        IHttpClientFactory clientFactory,
+        CacheService cacheService,
+        IMemoryCache cache, IOptionsMonitor<LidarrInstanceOptions> options,
+        ILogger<LidarrClient> logger)
+    {
+        _clientFactory = clientFactory;
+        _cacheService = cacheService;
+        _cache = cache;
+        _logger = logger;
+        InstanceName = instanceName;
+        Options = options.Get(InstanceName);
+        _logger.LogInformation($"Init Lidarr ({InstanceName})");
+    }
+
+    public LidarrInstanceOptions Options { get; init; }
+
+
     public override async Task<IEnumerable<SearchItem>> FetchAllItemsAsync()
     {
-            var httpClient = clientFactory.CreateClient();
+        var httpClient = _clientFactory.CreateClient();
         var items = new List<SearchItem>();
 
         try
         {
-                var lidarrArtistsUrl = $"{_lidarrHost}/api/v1/artist?apikey={_lidarrApiKey}";
+            var lidarrArtistsUrl = $"{Options.Host}/api/v1/artist?apikey={Options.ApiKey}";
-                logger.LogInformation($"Fetching all artists from Lidarr: {UrlUtilities.RedactApiKey(lidarrArtistsUrl)}");
+            _logger.LogInformation(
+                $"Fetching all artists from Lidarr ({InstanceName}) : {UrlUtilities.RedactApiKey(lidarrArtistsUrl)}");
             var artistsApiResponse = await httpClient.GetStringAsync(lidarrArtistsUrl);
             var artists = JsonConvert.DeserializeObject<List<dynamic>>(artistsApiResponse);
 
             if (artists == null)
             {
-                    logger.LogError($"Lidarr artists API request resulted in null");
+                _logger.LogError($"Lidarr ({InstanceName}) artists API request resulted in null");
                 return items;
             }
-                logger.LogInformation($"Successfully fetched {artists.Count} artists from Lidarr.");
+
+            _logger.LogInformation($"Successfully fetched {artists.Count} artists from Lidarr ({InstanceName}).");
             foreach (var artist in artists)
             {
                 var artistId = (int)artist.id;
 
-                    var lidarrAlbumUrl = $"{_lidarrHost}/api/v1/album?artistId={artistId}&apikey={_lidarrApiKey}";
+                var lidarrAlbumUrl = $"{Options.Host}/api/v1/album?artistId={artistId}&apikey={Options.ApiKey}";
 
                 // TODO add caching here
                 // Disable cache for now as it can result in problems when adding new albums that aren't displayed on the artists page initially
@@ -50,21 +68,24 @@ namespace UmlautAdaptarr.Providers
                 //}
                 //else
                 //{
-                    logger.LogInformation($"Fetching all albums from artistId {artistId} from Lidarr: {UrlUtilities.RedactApiKey(lidarrAlbumUrl)}");
+                _logger.LogInformation(
+                    $"Fetching all albums from artistId {artistId} from Lidarr ({InstanceName}) : {UrlUtilities.RedactApiKey(lidarrAlbumUrl)}");
                 var albumApiResponse = await httpClient.GetStringAsync(lidarrAlbumUrl);
                 var albums = JsonConvert.DeserializeObject<List<dynamic>>(albumApiResponse);
                 //}
 
                 if (albums == null)
                 {
-                        logger.LogWarning($"Lidarr album API request for artistId {artistId} resulted in null");
+                    _logger.LogWarning(
+                        $"Lidarr ({InstanceName}) album API request for artistId {artistId} resulted in null");
                     continue;
                 }
 
-                    logger.LogInformation($"Successfully fetched {albums.Count} albums for artistId {artistId} from Lidarr.");
+                _logger.LogInformation(
+                    $"Successfully fetched {albums.Count} albums for artistId {artistId} from Lidarr ({InstanceName}).");
 
                 // Cache albums for 3 minutes
-                    cache.Set(lidarrAlbumUrl, albums, TimeSpan.FromMinutes(3));
+                _cache.Set(lidarrAlbumUrl, albums, TimeSpan.FromMinutes(3));
 
                 foreach (var album in albums)
                 {
@@ -80,11 +101,11 @@ namespace UmlautAdaptarr.Providers
 
                     var searchItem = new SearchItem
                     (
-                            arrId: artistId,
+                        artistId,
-                            externalId: externalId,
+                        externalId,
-                            title: albumTitle,
+                        albumTitle,
-                            expectedTitle: albumTitle,
+                        albumTitle,
-                            germanTitle: null,
+                        null,
                         aliases: aliases,
                         mediaType: _mediaType,
                         expectedAuthor: artistName
@@ -94,11 +115,11 @@ namespace UmlautAdaptarr.Providers
                 }
             }
 
-                logger.LogInformation($"Finished fetching all items from Lidarr");
+            _logger.LogInformation($"Finished fetching all items from Lidarr ({InstanceName})");
         }
         catch (Exception ex)
         {
-                logger.LogError($"Error fetching all artists from Lidarr: {ex.Message}");
+            _logger.LogError($"Error fetching all artists from Lidarr ({InstanceName}) : {ex.Message}");
         }
 
         return items;
@@ -112,20 +133,19 @@ namespace UmlautAdaptarr.Providers
             // TODO if possible look at the author in search query and only update for author
             var searchItems = await FetchAllItemsAsync();
             foreach (var searchItem in searchItems ?? [])
-                {
                 try
                 {
-                        cacheService.CacheSearchItem(searchItem);
+                    _cacheService.CacheSearchItem(searchItem);
                 }
                 catch (Exception ex)
                 {
-                        logger.LogError(ex, $"An error occurred while caching search item with ID {searchItem.ArrId}.");
+                    _logger.LogError(ex,
-                    }
+                        $"An error occurred while caching search item with ID {searchItem.ArrId} in Lidarr ({InstanceName}).");
                 }
         }
         catch (Exception ex)
         {
-                logger.LogError($"Error fetching single artist from Lidarr: {ex.Message}");
+            _logger.LogError($"Error fetching single artist from Lidarr ({InstanceName}) : {ex.Message}");
         }
 
         return null;
@@ -140,10 +160,9 @@ namespace UmlautAdaptarr.Providers
         }
         catch (Exception ex)
         {
-                logger.LogError($"Error fetching single artist from Lidarr: {ex.Message}");
+            _logger.LogError($"Error fetching single artist from Lidarr ({InstanceName}): {ex.Message}");
         }
 
         return null;
     }
 }
-}

UmlautAdaptarr/Providers/ReadarrClient.cs

@@ -1,62 +1,82 @@
 using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Options;
 using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
 using UmlautAdaptarr.Models;
+using UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
 using UmlautAdaptarr.Services;
 using UmlautAdaptarr.Utilities;
 
-namespace UmlautAdaptarr.Providers
+namespace UmlautAdaptarr.Providers;
+
+public class ReadarrClient : ArrClientBase
 {
-    public class ReadarrClient(
+    private readonly IMemoryCache _cache;
-        IHttpClientFactory clientFactory,
+    private readonly CacheService _cacheService;
-        IConfiguration configuration,
+    private readonly IHttpClientFactory _clientFactory;
+    private readonly ILogger<ReadarrClient> _logger;
+    private readonly string _mediaType = "book";
+
+    public ReadarrClient([ServiceKey] string instanceName, IHttpClientFactory clientFactory,
         CacheService cacheService,
         IMemoryCache cache,
-        ILogger<ReadarrClient> logger) : ArrClientBase()
+        IOptionsMonitor<ReadarrInstanceOptions> options,
+        ILogger<ReadarrClient> logger)
     {
-        private readonly string _readarrHost = configuration.GetValue<string>("READARR_HOST") ?? throw new ArgumentException("READARR_HOST environment variable must be set");
+        _clientFactory = clientFactory;
-        private readonly string _readarrApiKey = configuration.GetValue<string>("READARR_API_KEY") ?? throw new ArgumentException("READARR_API_KEY environment variable must be set");
+        _cacheService = cacheService;
-        private readonly string _mediaType = "book";
+        _cache = cache;
+        _logger = logger;
+        InstanceName = instanceName;
+        Options = options.Get(InstanceName);
+        _logger.LogInformation($"Init ReadarrClient ({InstanceName})");
+    }
+
+    public ReadarrInstanceOptions Options { get; init; }
 
     public override async Task<IEnumerable<SearchItem>> FetchAllItemsAsync()
     {
-            var httpClient = clientFactory.CreateClient();
+        var httpClient = _clientFactory.CreateClient();
         var items = new List<SearchItem>();
 
         try
         {
-                var readarrAuthorUrl = $"{_readarrHost}/api/v1/author?apikey={_readarrApiKey}";
+            var readarrAuthorUrl = $"{Options.Host}/api/v1/author?apikey={Options.ApiKey}";
-                logger.LogInformation($"Fetching all authors from Readarr: {UrlUtilities.RedactApiKey(readarrAuthorUrl)}");
+            _logger.LogInformation(
+                $"Fetching all authors from Readarr ({InstanceName}) : {UrlUtilities.RedactApiKey(readarrAuthorUrl)}");
             var authorApiResponse = await httpClient.GetStringAsync(readarrAuthorUrl);
             var authors = JsonConvert.DeserializeObject<List<dynamic>>(authorApiResponse);
 
             if (authors == null)
             {
-                    logger.LogError($"Readarr authors API request resulted in null");
+                _logger.LogError($"Readarr ({InstanceName}) authors API request resulted in null");
                 return items;
             }
-                logger.LogInformation($"Successfully fetched {authors.Count} authors from Readarr.");
+
+            _logger.LogInformation($"Successfully fetched {authors.Count} authors from Readarr ({InstanceName}).");
             foreach (var author in authors)
             {
                 var authorId = (int)author.id;
 
-                    var readarrBookUrl = $"{_readarrHost}/api/v1/book?authorId={authorId}&apikey={_readarrApiKey}";
+                var readarrBookUrl = $"{Options.Host}/api/v1/book?authorId={authorId}&apikey={Options.ApiKey}";
 
                 // TODO add caching here
-                    logger.LogInformation($"Fetching all books from authorId {authorId} from Readarr: {UrlUtilities.RedactApiKey(readarrBookUrl)}");
+                _logger.LogInformation(
+                    $"Fetching all books from authorId {authorId} from Readarr ({InstanceName}) : {UrlUtilities.RedactApiKey(readarrBookUrl)}");
                 var bookApiResponse = await httpClient.GetStringAsync(readarrBookUrl);
                 var books = JsonConvert.DeserializeObject<List<dynamic>>(bookApiResponse);
 
                 if (books == null)
                 {
-                        logger.LogWarning($"Readarr book API request for authorId {authorId} resulted in null");
+                    _logger.LogWarning(
+                        $"Readarr ({InstanceName}) book API request for authorId {authorId} resulted in null");
                     continue;
                 }
 
-                    logger.LogInformation($"Successfully fetched {books.Count} books for authorId {authorId} from Readarr.");
+                _logger.LogInformation(
+                    $"Successfully fetched {books.Count} books for authorId {authorId} from Readarr ({InstanceName}) .");
 
                 // Cache books for 3 minutes
-                    cache.Set(readarrBookUrl, books, TimeSpan.FromMinutes(3));
+                _cache.Set(readarrBookUrl, books, TimeSpan.FromMinutes(3));
 
                 foreach (var book in books)
                 {
@@ -73,11 +93,11 @@ namespace UmlautAdaptarr.Providers
 
                     var searchItem = new SearchItem
                     (
-                            arrId: authorId,
+                        authorId,
-                            externalId: externalId,
+                        externalId,
-                            title: bookTitle,
+                        bookTitle,
-                            expectedTitle: bookTitle,
+                        bookTitle,
-                            germanTitle: null,
+                        null,
                         aliases: aliases,
                         mediaType: _mediaType,
                         expectedAuthor: authorName
@@ -87,11 +107,11 @@ namespace UmlautAdaptarr.Providers
                 }
             }
 
-                logger.LogInformation($"Finished fetching all items from Readarr");
+            _logger.LogInformation($"Finished fetching all items from Readarr ({InstanceName})");
         }
         catch (Exception ex)
         {
-                logger.LogError($"Error fetching all authors from Readarr: {ex.Message}");
+            _logger.LogError($"Error fetching all authors from Readarr ({InstanceName}): {ex.Message}");
         }
 
         return items;
@@ -102,21 +122,18 @@ namespace UmlautAdaptarr.Providers
     {
         // Remove author prefix from title if present, e.g., "Tom Clancy: Ghost Protocol"
         if (!string.IsNullOrEmpty(authorName) && bookTitle.StartsWith($"{authorName}:"))
-            {
             bookTitle = bookTitle[(authorName.Length + 1)..].Trim();
-            }
 
         // Remove subtitles or additional info enclosed in parentheses or following a colon, if any
-            int firstParenthesisIndex = bookTitle.IndexOf('(');
+        var firstParenthesisIndex = bookTitle.IndexOf('(');
-            int firstColonIndex = bookTitle.IndexOf(':');
+        var firstColonIndex = bookTitle.IndexOf(':');
 
         if (firstParenthesisIndex > -1)
         {
-                int endParenthesisIndex = bookTitle.IndexOf(')', firstParenthesisIndex);
+            var endParenthesisIndex = bookTitle.IndexOf(')', firstParenthesisIndex);
-                if (endParenthesisIndex > -1 && bookTitle.Substring(firstParenthesisIndex + 1, endParenthesisIndex - firstParenthesisIndex - 1).Contains(' '))
+            if (endParenthesisIndex > -1 && bookTitle
-                {
+                    .Substring(firstParenthesisIndex + 1, endParenthesisIndex - firstParenthesisIndex - 1)
-                    bookTitle = bookTitle[..firstParenthesisIndex].Trim();
+                    .Contains(' ')) bookTitle = bookTitle[..firstParenthesisIndex].Trim();
-                }
         }
         else if (firstColonIndex > -1)
         {
@@ -135,20 +152,18 @@ namespace UmlautAdaptarr.Providers
             // TODO if possible look at the author in search query and only update for author
             var searchItems = await FetchAllItemsAsync();
             foreach (var searchItem in searchItems ?? [])
-                {
                 try
                 {
-                        cacheService.CacheSearchItem(searchItem);
+                    _cacheService.CacheSearchItem(searchItem);
                 }
                 catch (Exception ex)
                 {
-                        logger.LogError(ex, $"An error occurred while caching search item with ID {searchItem.ArrId}.");
+                    _logger.LogError(ex, $"An error occurred while caching search item with ID {searchItem.ArrId}.");
-                    }
                 }
         }
         catch (Exception ex)
         {
-                logger.LogError($"Error fetching single author from Readarr: {ex.Message}");
+            _logger.LogError($"Error fetching single author from Readarr ({InstanceName}) : {ex.Message}");
         }
 
         return null;
@@ -163,10 +178,9 @@ namespace UmlautAdaptarr.Providers
         }
         catch (Exception ex)
         {
-                logger.LogError($"Error fetching single author from Readarr: {ex.Message}");
+            _logger.LogError($"Error fetching single author from Readarr ({InstanceName}) : {ex.Message}");
         }
 
         return null;
     }
 }
-}

UmlautAdaptarr/Providers/SonarrClient.cs

@@ -1,52 +1,94 @@
-using Newtonsoft.Json;
+using Microsoft.Extensions.Options;
+using Newtonsoft.Json;
 using UmlautAdaptarr.Models;
+using UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
 using UmlautAdaptarr.Services;
 using UmlautAdaptarr.Utilities;
 
-namespace UmlautAdaptarr.Providers
+namespace UmlautAdaptarr.Providers;
+
+public class SonarrClient : ArrClientBase
 {
-    public class SonarrClient(
+    private readonly IHttpClientFactory _clientFactory;
-        IHttpClientFactory clientFactory,
+    private readonly ILogger<SonarrClient> _logger;
-        IConfiguration configuration,
+
-        TitleApiService titleService,
-        ILogger<SonarrClient> logger) : ArrClientBase()
-    {
-        private readonly string _sonarrHost = configuration.GetValue<string>("SONARR_HOST") ?? throw new ArgumentException("SONARR_HOST environment variable must be set");
-        private readonly string _sonarrApiKey = configuration.GetValue<string>("SONARR_API_KEY") ?? throw new ArgumentException("SONARR_API_KEY environment variable must be set");
     private readonly string _mediaType = "tv";
+    private readonly TitleApiService _titleService;
+
+
+    public SonarrClient([ServiceKey] string instanceName,
+        IHttpClientFactory clientFactory,
+        TitleApiService titleService,
+        IOptionsMonitor<SonarrInstanceOptions> options,
+        ILogger<SonarrClient> logger)
+    {
+        _clientFactory = clientFactory;
+        _titleService = titleService;
+        _logger = logger;
+
+        InstanceName = instanceName;
+        Options = options.Get(InstanceName);
+        _logger.LogInformation($"Init SonarrClient ({InstanceName})");
+    }
+
+    public SonarrInstanceOptions Options { get; init; }
 
     public override async Task<IEnumerable<SearchItem>> FetchAllItemsAsync()
     {
-            var httpClient = clientFactory.CreateClient();
+        var httpClient = _clientFactory.CreateClient();
         var items = new List<SearchItem>();
 
         try
         {
-                var sonarrUrl = $"{_sonarrHost}/api/v3/series?includeSeasonImages=false&apikey={_sonarrApiKey}";
+            var sonarrUrl = $"{Options.Host}/api/v3/series?includeSeasonImages=false&apikey={Options.ApiKey}";
-                logger.LogInformation($"Fetching all items from Sonarr: {UrlUtilities.RedactApiKey(sonarrUrl)}");
+            _logger.LogInformation($"Fetching all items from Sonarr: {UrlUtilities.RedactApiKey(sonarrUrl)}");
             var response = await httpClient.GetStringAsync(sonarrUrl);
             var shows = JsonConvert.DeserializeObject<List<dynamic>>(response);
 
             if (shows != null)
             {
-                    logger.LogInformation($"Successfully fetched {shows.Count} items from Sonarr.");
+                _logger.LogInformation($"Successfully fetched {shows.Count} items from Sonarr ({InstanceName}).");
+                // Bulk request (germanTitle, aliases) for all shows
+                var tvdbIds = new List<string>();
+                foreach (var show in shows)
+                {
+                    if ((string)show.tvdbId is not string tvdbId)
+                    {
+                        continue;
+                    }
+                    tvdbIds.Add(tvdbId);
+                }
+
+                var bulkTitleData = await _titleService.FetchGermanTitlesAndAliasesByExternalIdBulkAsync(tvdbIds);
+                string? germanTitle;
+                string[]? aliases;
+
                 foreach (var show in shows)
                 {
                     var tvdbId = (string)show.tvdbId;
                     if (tvdbId == null)
                     {
-                            logger.LogWarning($"Sonarr Show {show.id} doesn't have a tvdbId.");
+                        _logger.LogWarning($"Sonarr ({InstanceName}) Show {show.id} doesn't have a tvdbId.");
                         continue;
                     }
 
-                        (var germanTitle, var aliases) = await titleService.FetchGermanTitleAndAliasesByExternalIdAsync(_mediaType, tvdbId);
+                    if (bulkTitleData.TryGetValue(tvdbId, out var titleData))
+                    {
+                        (germanTitle, aliases) = titleData;
+                    }
+                    else
+                    {
+                        (germanTitle, aliases) =
+                            await _titleService.FetchGermanTitleAndAliasesByExternalIdAsync(_mediaType, tvdbId);
+                    }
+                    
                     var searchItem = new SearchItem
                     (
-                            arrId: (int)show.id,
+                        (int)show.id,
-                            externalId: tvdbId,
+                        tvdbId,
-                            title: (string)show.title,
+                        (string)show.title,
-                            expectedTitle: (string)show.title,
+                        (string)show.title,
-                            germanTitle: germanTitle,
+                        germanTitle,
                         aliases: aliases,
                         mediaType: _mediaType
                     );
@@ -55,11 +97,11 @@ namespace UmlautAdaptarr.Providers
                 }
             }
 
-                logger.LogInformation($"Finished fetching all items from Sonarr");
+            _logger.LogInformation($"Finished fetching all items from Sonarr ({InstanceName})");
         }
         catch (Exception ex)
         {
-                logger.LogError($"Error fetching all shows from Sonarr: {ex.Message}");
+            _logger.LogError($"Error fetching all shows from Sonarr ({InstanceName}) : {ex.Message}");
         }
 
         return items;
@@ -67,12 +109,14 @@ namespace UmlautAdaptarr.Providers
 
     public override async Task<SearchItem?> FetchItemByExternalIdAsync(string externalId)
     {
-            var httpClient = clientFactory.CreateClient();
+        var httpClient = _clientFactory.CreateClient();
 
         try
         {
-                var sonarrUrl = $"{_sonarrHost}/api/v3/series?tvdbId={externalId}&includeSeasonImages=false&apikey={_sonarrApiKey}";
+            var sonarrUrl =
-                logger.LogInformation($"Fetching item by external ID from Sonarr: {UrlUtilities.RedactApiKey(sonarrUrl)}");
+                $"{Options.Host}/api/v3/series?tvdbId={externalId}&includeSeasonImages=false&apikey={Options.ApiKey}";
+            _logger.LogInformation(
+                $"Fetching item by external ID from Sonarr ({InstanceName}): {UrlUtilities.RedactApiKey(sonarrUrl)}");
             var response = await httpClient.GetStringAsync(sonarrUrl);
             var shows = JsonConvert.DeserializeObject<dynamic>(response);
             var show = shows?[0];
@@ -82,29 +126,31 @@ namespace UmlautAdaptarr.Providers
                 var tvdbId = (string)show.tvdbId;
                 if (tvdbId == null)
                 {
-                        logger.LogWarning($"Sonarr Show {show.id} doesn't have a tvdbId.");
+                    _logger.LogWarning($"Sonarr ({InstanceName}) Show {show.id} doesn't have a tvdbId.");
                     return null;
                 }
-                    (var germanTitle, var aliases) = await titleService.FetchGermanTitleAndAliasesByExternalIdAsync(_mediaType, tvdbId);
+
+                var (germanTitle, aliases) =
+                    await _titleService.FetchGermanTitleAndAliasesByExternalIdAsync(_mediaType, tvdbId);
 
                 var searchItem = new SearchItem
                 (
-                        arrId: (int)show.id,
+                    (int)show.id,
-                        externalId: tvdbId,
+                    tvdbId,
-                        title: (string)show.title,
+                    (string)show.title,
-                        expectedTitle: (string)show.title,
+                    (string)show.title,
-                        germanTitle: germanTitle,
+                    germanTitle,
                     aliases: aliases,
                     mediaType: _mediaType
                 );
 
-                    logger.LogInformation($"Successfully fetched show {searchItem} from Sonarr.");
+                _logger.LogInformation($"Successfully fetched show {searchItem.Title} from Sonarr ({InstanceName}).");
                 return searchItem;
             }
         }
         catch (Exception ex)
         {
-                logger.LogError($"Error fetching single show from Sonarr: {ex.Message}");
+            _logger.LogError($"Error fetching single show from Sonarr ({InstanceName}): {ex.Message}");
         }
 
         return null;
@@ -112,59 +158,58 @@ namespace UmlautAdaptarr.Providers
 
     public override async Task<SearchItem?> FetchItemByTitleAsync(string title)
     {
-            var httpClient = clientFactory.CreateClient();
+        var httpClient = _clientFactory.CreateClient();
 
         try
         {
-                (string? germanTitle, string? tvdbId, string[]? aliases) = await titleService.FetchGermanTitleAndExternalIdAndAliasesByTitle(_mediaType, title);
+            var (germanTitle, tvdbId, aliases) =
+                await _titleService.FetchGermanTitleAndExternalIdAndAliasesByTitle(_mediaType, title);
 
-                if (tvdbId == null)
+            if (tvdbId == null) return null;
-                {
-                    return null;
-                }
 
-                var sonarrUrl = $"{_sonarrHost}/api/v3/series?tvdbId={tvdbId}&includeSeasonImages=false&apikey={_sonarrApiKey}";
+            var sonarrUrl =
+                $"{Options.Host}/api/v3/series?tvdbId={tvdbId}&includeSeasonImages=false&apikey={Options.ApiKey}";
             var sonarrApiResponse = await httpClient.GetStringAsync(sonarrUrl);
             var shows = JsonConvert.DeserializeObject<dynamic>(sonarrApiResponse);
 
             if (shows == null)
             {
-                    logger.LogError($"Parsing Sonarr API response for TVDB ID {tvdbId} resulted in null");
+                _logger.LogError($"Parsing Sonarr ({InstanceName}) API response for TVDB ID {tvdbId} resulted in null");
                 return null;
             }
-                else if (shows.Count == 0)
+
+            if (shows.Count == 0)
             {
-                    logger.LogWarning($"No results found for TVDB ID {tvdbId}");
+                _logger.LogWarning($"No results found for TVDB ID {tvdbId}");
                 return null;
             }
 
             var expectedTitle = (string)shows[0].title;
             if (expectedTitle == null)
             {
-                    logger.LogError($"Sonarr Title for TVDB ID {tvdbId} is null");
+                _logger.LogError($"Sonarr ({InstanceName}) : Title for TVDB ID {tvdbId} is null");
                 return null;
             }
 
             var searchItem = new SearchItem
             (
-                    arrId: (int)shows[0].id,
+                (int)shows[0].id,
-                    externalId: tvdbId,
+                tvdbId,
-                    title: (string)shows[0].title,
+                (string)shows[0].title,
-                    expectedTitle: (string)shows[0].title,
+                (string)shows[0].title,
-                    germanTitle: germanTitle,
+                germanTitle,
                 aliases: aliases,
                 mediaType: _mediaType
             );
 
-                logger.LogInformation($"Successfully fetched show {searchItem} from Sonarr.");
+            _logger.LogInformation($"Successfully fetched show {searchItem.Title} from Sonarr ({InstanceName}).");
             return searchItem;
         }
         catch (Exception ex)
         {
-                logger.LogError($"Error fetching single show from Sonarr: {ex.Message}");
+            _logger.LogError($"Error fetching single show from Sonarr ({InstanceName}) : {ex.Message}");
         }
 
         return null;
     }
 }
-}

UmlautAdaptarr/Services/ArrSyncBackgroundService.cs

@@ -1,31 +1,21 @@
-using Microsoft.Extensions.Caching.Memory;
+using UmlautAdaptarr.Models;
-using Microsoft.Extensions.DependencyInjection;
+using UmlautAdaptarr.Services.Factory;
-using Microsoft.Extensions.Hosting;
+
-using Microsoft.Extensions.Logging;
+namespace UmlautAdaptarr.Services;
-using Newtonsoft.Json;
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-using UmlautAdaptarr.Models;
-using UmlautAdaptarr.Providers;
 
-namespace UmlautAdaptarr.Services
-{
 public class ArrSyncBackgroundService(
-        SonarrClient sonarrClient,
+    ArrApplicationFactory arrApplicationFactory,
-        LidarrClient lidarrClient,
-        ReadarrClient readarrClient,
     CacheService cacheService,
-        IConfiguration configuration,
+    ILogger<ArrSyncBackgroundService> logger)
-        ILogger<ArrSyncBackgroundService> logger) : BackgroundService
+    : BackgroundService
 {
-        private readonly bool _sonarrEnabled = configuration.GetValue<bool>("SONARR_ENABLED");
+    public ArrApplicationFactory ArrApplicationFactory { get; } = arrApplicationFactory;
-        private readonly bool _lidarrEnabled = configuration.GetValue<bool>("LIDARR_ENABLED");
+
-        private readonly bool _readarrEnabled = configuration.GetValue<bool>("READARR_ENABLED");
+
     protected override async Task ExecuteAsync(CancellationToken stoppingToken)
     {
         logger.LogInformation("ArrSyncBackgroundService is starting.");
-            bool lastRunSuccess = true;
+        var lastRunSuccess = true;
 
         while (!stoppingToken.IsCancellationRequested)
         {
@@ -43,12 +33,14 @@ namespace UmlautAdaptarr.Services
                 if (lastRunSuccess)
                 {
                     lastRunSuccess = false;
-                        logger.LogInformation("ArrSyncBackgroundService is trying again in 2 minutes because not all syncs were successful.");
+                    logger.LogInformation(
+                        "ArrSyncBackgroundService is trying again in 2 minutes because not all syncs were successful.");
                     await Task.Delay(TimeSpan.FromMinutes(2), stoppingToken);
                 }
                 else
                 {
-                        logger.LogInformation("ArrSyncBackgroundService is trying again in one hour only because not all syncs were successful twice in a row.");
+                    logger.LogInformation(
+                        "ArrSyncBackgroundService is trying again in one hour only because not all syncs were successful twice in a row.");
                     await Task.Delay(TimeSpan.FromHours(1), stoppingToken);
                 }
             }
@@ -62,24 +54,34 @@ namespace UmlautAdaptarr.Services
         try
         {
             var success = true;
-                if (_readarrEnabled)
+
+
+            if (ArrApplicationFactory.SonarrInstances.Any())
             {
-                    success = success && await FetchItemsFromReadarrAsync();
+                var syncSuccess = await FetchItemsFromSonarrAsync();
+                success = success && syncSuccess;
             }
-                if (_sonarrEnabled)
+
+            if (ArrApplicationFactory.ReadarrInstances.Any())
             {
-                    success = success && await FetchItemsFromSonarrAsync();
+                var syncSuccess = await FetchItemsFromReadarrAsync();
+                success = success && syncSuccess;
             }
-                if (_lidarrEnabled)
+
+            if (ArrApplicationFactory.ReadarrInstances.Any())
             {
-                    success = success && await FetchItemsFromLidarrAsync();
+                var syncSuccess = await FetchItemsFromLidarrAsync();
+                success = success && syncSuccess;
             }
+
+
             return success;
         }
         catch (Exception ex)
         {
             logger.LogError(ex, "An error occurred while fetching items from the Arrs.");
         }
+
         return false;
     }
 
@@ -87,7 +89,15 @@ namespace UmlautAdaptarr.Services
     {
         try
         {
-                var items = await sonarrClient.FetchAllItemsAsync();
+            var items = new List<SearchItem>();
+
+            foreach (var sonarrClient in ArrApplicationFactory.SonarrInstances)
+            {
+                var result = await sonarrClient.FetchAllItemsAsync();
+                items = items.Union(result).ToList();
+            }
+
+
             UpdateSearchItems(items);
             return items?.Any() ?? false;
         }
@@ -95,6 +105,7 @@ namespace UmlautAdaptarr.Services
         {
             logger.LogError(ex, "An error occurred while updating search item from Sonarr.");
         }
+
         return false;
     }
 
@@ -102,7 +113,14 @@ namespace UmlautAdaptarr.Services
     {
         try
         {
-                var items = await lidarrClient.FetchAllItemsAsync();
+            var items = new List<SearchItem>();
+
+            foreach (var lidarrClient in ArrApplicationFactory.LidarrInstances)
+            {
+                var result = await lidarrClient.FetchAllItemsAsync();
+                items = items.Union(result).ToList();
+            }
+
             UpdateSearchItems(items);
             return items?.Any() ?? false;
         }
@@ -110,6 +128,7 @@ namespace UmlautAdaptarr.Services
         {
             logger.LogError(ex, "An error occurred while updating search item from Lidarr.");
         }
+
         return false;
     }
 
@@ -117,7 +136,14 @@ namespace UmlautAdaptarr.Services
     {
         try
         {
-                var items = await readarrClient.FetchAllItemsAsync();
+            var items = new List<SearchItem>();
+
+            foreach (var readarrClient in ArrApplicationFactory.ReadarrInstances)
+            {
+                var result = await readarrClient.FetchAllItemsAsync();
+                items = items.Union(result).ToList();
+            }
+
             UpdateSearchItems(items);
             return items?.Any() ?? false;
         }
@@ -125,13 +151,13 @@ namespace UmlautAdaptarr.Services
         {
             logger.LogError(ex, "An error occurred while updating search item from Lidarr.");
         }
+
         return false;
     }
 
     private void UpdateSearchItems(IEnumerable<SearchItem>? searchItems)
     {
         foreach (var searchItem in searchItems ?? [])
-            {
             try
             {
                 cacheService.CacheSearchItem(searchItem);
@@ -142,5 +168,3 @@ namespace UmlautAdaptarr.Services
             }
     }
 }
-    }
-}

UmlautAdaptarr/Services/CacheService.cs

@@ -1,7 +1,4 @@
-using Microsoft.AspNetCore.Mvc.Formatters;
+using Microsoft.Extensions.Caching.Memory;
-using Microsoft.Extensions.Caching.Memory;
-using System.Reflection.Metadata.Ecma335;
-using System.Text.RegularExpressions;
 using UmlautAdaptarr.Models;
 using UmlautAdaptarr.Utilities;
 
@@ -13,6 +10,8 @@ namespace UmlautAdaptarr.Services
         private readonly Dictionary<string, List<(HashSet<string> TitleVariations, string CacheKey)>> BookVariationIndex = [];
         private readonly Dictionary<string, List<(HashSet<string> TitleVariations, string CacheKey)>> AudioVariationIndex = [];
         private const int VARIATION_LOOKUP_CACHE_LENGTH = 5;
+		private const string TitleRenamePrefix = "title_rename_";
+		private static readonly TimeSpan TitleRenameCacheDuration = TimeSpan.FromHours(12);
 
 		public void CacheSearchItem(SearchItem item)
         {
@@ -96,30 +95,51 @@ namespace UmlautAdaptarr.Services
             // Use the first few characters of the normalized title for cache prefix search
             var cacheSearchPrefix = normalizedTitle[..Math.Min(VARIATION_LOOKUP_CACHE_LENGTH, normalizedTitle.Length)];
 
+            SearchItem? bestSearchItemMatch = null;
+            var bestVariationMatchLength = 0;
+            HashSet<string> checkedSearchItems = [];
+
             if (VariationIndex.TryGetValue(cacheSearchPrefix, out var cacheKeys))
             {
                 foreach (var cacheKey in cacheKeys)
                 {
                     if (cache.TryGetValue(cacheKey, out SearchItem? item))
                     {
-                        if (item?.MediaType != mediaType)
+                        if (item == null || item.MediaType != mediaType)
                         {
                             continue;
                         }
+
+                        var searchItemIdentifier = $"{item.MediaType}_{item.ExternalId}";
+
+                        if (checkedSearchItems.Contains(searchItemIdentifier))
+                        {
+                            continue;
+                        }
+                        else
+                        {
+                            checkedSearchItems.Add(searchItemIdentifier);
+                        }
+
                         // After finding a potential item, compare normalizedTitle with each German title variation
-                        foreach (var variation in item?.TitleMatchVariations ?? [])
+                        foreach (var variation in item.TitleMatchVariations ?? [])
                         {
                             var normalizedVariation = variation.RemoveAccentButKeepGermanUmlauts().ToLower();
                             if (normalizedTitle.StartsWith(variation, StringComparison.OrdinalIgnoreCase))
                             {
-                                return item;
+                                // If we find a variation match that is "longer" then most likely that one is correct and the earlier match was wrong (if it was from another searchItem)
+                                if (variation.Length > bestVariationMatchLength)
+                                {
+                                    bestSearchItemMatch = item;
+                                    bestVariationMatchLength = variation.Length;
+                                }
                             }
                         }
                     }
                 }
             }
 
-            return null;
+            return bestSearchItemMatch;
         }
 
         public SearchItem? GetSearchItemByExternalId(string mediaType, string externalId)
@@ -175,8 +195,26 @@ namespace UmlautAdaptarr.Services
             return null;
         }
 
+		public void CacheTitleRename(string changedTitle, string originalTitle)
+		{
+			if (string.IsNullOrWhiteSpace(changedTitle) || string.IsNullOrWhiteSpace(originalTitle))
+				return;
 
-        [GeneratedRegex("\\s")]
+			var key = $"{TitleRenamePrefix}{changedTitle.Trim().ToLowerInvariant()}";
-        private static partial Regex WhiteSpaceRegex();
+			cache.Set(key, originalTitle, TitleRenameCacheDuration);
+
+			// If title contains ":" also add it as "-" for arr/sabnzbd compatibility
+			if (changedTitle.Contains(':'))
+			{
+				var altKey = $"{TitleRenamePrefix}{changedTitle.Replace(':', '-').Trim().ToLowerInvariant()}";
+				cache.Set(altKey, originalTitle, TitleRenameCacheDuration);
+			}
+		}
+
+		public string? GetOriginalTitleFromRenamed(string changedTitle)
+		{
+			var key = $"{TitleRenamePrefix}{changedTitle.Trim().ToLowerInvariant()}";
+			return cache.TryGetValue(key, out string? originalTitle) ? originalTitle : null;
+		}
 	}
 }

UmlautAdaptarr/Services/Factory/ArrApplicationFactory.cs

@@ -0,0 +1,77 @@
+using UmlautAdaptarr.Interfaces;
+using UmlautAdaptarr.Providers;
+
+namespace UmlautAdaptarr.Services.Factory
+{
+    /// <summary>
+    /// Factory for creating ArrApplication instances.
+    /// </summary>
+    public class ArrApplicationFactory
+    {
+        private readonly ILogger<ArrApplicationFactory> _logger;
+
+        /// <summary>
+        /// Get all IArrApplication instances.
+        /// </summary>
+        public IDictionary<string, IArrApplication> AllInstances { get; init; }
+
+        /// <summary>
+        /// Get all SonarrClient instances.
+        /// </summary>
+        public IEnumerable<SonarrClient> SonarrInstances { get; init; }
+
+        /// <summary>
+        /// Get all LidarrClient instances.
+        /// </summary>
+        public IEnumerable<LidarrClient> LidarrInstances { get; init; }
+
+        /// <summary>
+        /// Get all ReadarrClient instances.
+        /// </summary>
+        public IEnumerable<ReadarrClient> ReadarrInstances { get; init; }
+
+        /// <summary>
+        /// Constructor for the ArrApplicationFactory.
+        /// </summary>
+        /// <param name="arrApplications">A dictionary of IArrApplication instances.</param>
+        /// <param name="logger">Logger Instanz</param>
+        public ArrApplicationFactory(IDictionary<string, IArrApplication> arrApplications, ILogger<ArrApplicationFactory> logger)
+        {
+            _logger = logger;
+            try
+            {
+                SonarrInstances = arrApplications.Values.OfType<SonarrClient>();
+                LidarrInstances = arrApplications.Values.OfType<LidarrClient>();
+                ReadarrInstances = arrApplications.Values.OfType<ReadarrClient>();
+                AllInstances = arrApplications;
+
+                if (AllInstances.Values.Count == 0)
+                {
+                    throw new Exception("No ArrApplication could be successfully initialized. This could be due to a faulty configuration");
+                }
+            }
+            catch (Exception e)
+            {
+                _logger.LogError("Error while registering ArrFactory. This is most likely a config problem, please check your environment variables.", e.Message);
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Returns an IArrApplication instance that matches the given name.
+        /// </summary>
+        /// <param name="nameOfArrInstance">The name of the IArrApplication instance being sought.</param>
+        /// <returns>The IArrApplication instance that matches the given name.</returns>
+        /// <exception cref="ArgumentException">Thrown when no IArrApplication instance with the given name can be found.</exception>
+        public IArrApplication GetArrInstanceByName(string nameOfArrInstance)
+        {
+            var instance = AllInstances.FirstOrDefault(up => up.Key.Equals(nameOfArrInstance)).Value;
+            if (instance == null)
+            {
+                throw new ArgumentException($"No ArrService with the name {nameOfArrInstance} could be found");
+            }
+
+            return instance;
+        }
+    }
+}

UmlautAdaptarr/Services/HttpProxyService.cs

@@ -0,0 +1,219 @@
+using Microsoft.Extensions.Options;
+using System.Net;
+using System.Net.Sockets;
+using System.Text;
+using UmlautAdaptarr.Options;
+
+namespace UmlautAdaptarr.Services
+{
+    public class HttpProxyService : IHostedService
+    {
+        private TcpListener _listener;
+        private readonly ILogger<HttpProxyService> _logger;
+        private readonly IHttpClientFactory _clientFactory;
+        private readonly GlobalOptions _options;
+        private readonly HashSet<string> _knownHosts = [];
+        private readonly object _hostsLock = new();
+        private readonly IConfiguration _configuration;
+        private static readonly string[] newLineSeparator = ["\r\n"];
+
+        public HttpProxyService(ILogger<HttpProxyService> logger, IHttpClientFactory clientFactory, IConfiguration configuration, IOptions<GlobalOptions> options)
+        {
+            _options = options.Value;
+            _logger = logger;
+            _configuration = configuration;
+            _clientFactory = clientFactory;
+            _knownHosts.Add("prowlarr.servarr.com");
+        }
+
+        private async Task HandleRequests(CancellationToken stoppingToken)
+        {
+            while (!stoppingToken.IsCancellationRequested)
+            {
+                var clientSocket = await _listener.AcceptSocketAsync();
+                _ = Task.Run(() => ProcessRequest(clientSocket), stoppingToken);
+            }
+        }
+
+        private async Task ProcessRequest(Socket clientSocket)
+        {
+            using var clientStream = new NetworkStream(clientSocket, ownsSocket: true);
+            var buffer = new byte[8192];
+            var bytesRead = await clientStream.ReadAsync(buffer);
+            var requestString = Encoding.ASCII.GetString(buffer, 0, bytesRead);
+
+            if (!string.IsNullOrEmpty(_options.ApiKey))
+            {
+                var headers = ParseHeaders(buffer, bytesRead);
+
+                if (!headers.TryGetValue("Proxy-Authorization", out var proxyAuthorizationHeader) ||
+                    !ValidateApiKey(proxyAuthorizationHeader))
+                {
+                    var isFirstRequest = !headers.ContainsKey("Proxy-Authorization");
+                    if (!isFirstRequest)
+                    {
+                        _logger.LogWarning("Unauthorized access attempt.");
+                    }
+                    await clientStream.WriteAsync(Encoding.ASCII.GetBytes("HTTP/1.1 407 Proxy Authentication Required\r\nProxy-Authenticate: Basic realm=\"Proxy\"\r\n\r\n"));
+                    clientSocket.Close();
+                    return;
+                }
+            }
+
+            if (requestString.StartsWith("CONNECT"))
+            {
+                // Handle HTTPS CONNECT request
+                await HandleHttpsConnect(requestString, clientStream, clientSocket);
+            }
+            else
+            {
+                // Handle HTTP request
+                await HandleHttp(requestString, clientStream, clientSocket, buffer, bytesRead);
+            }
+        }
+        
+        private bool ValidateApiKey(string proxyAuthorizationHeader)
+        {
+            // Expect the header to be in the format: "Basic <base64encodedApiKey>"
+            if (proxyAuthorizationHeader.StartsWith("Basic ", StringComparison.OrdinalIgnoreCase))
+            {
+                var encodedKey = proxyAuthorizationHeader["Basic ".Length..].Trim();
+                var decodedKey = Encoding.ASCII.GetString(Convert.FromBase64String(encodedKey));
+                var password = decodedKey.Split(':')[^1];
+                return password == _options.ApiKey;
+            }
+            return false;
+        }
+
+        private async Task HandleHttpsConnect(string requestString, NetworkStream clientStream, Socket clientSocket)
+        {
+            var (host, port) = ParseTargetInfo(requestString);
+
+            // Prowlarr will send grab requests via https which cannot be changed
+            if (!_knownHosts.Contains(host))
+            {
+                _logger.LogWarning($"IMPORTANT! {Environment.NewLine} Indexer {host} needs to be set to http:// instead of https:// {Environment.NewLine}" +
+                    $"UmlautAdaptarr will not work for {host}!");
+            }
+            using var targetSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
+            try
+            {
+                await targetSocket.ConnectAsync(host, port);
+                await clientStream.WriteAsync(Encoding.ASCII.GetBytes("HTTP/1.1 200 Connection Established\r\n\r\n"));
+                using var targetStream = new NetworkStream(targetSocket, ownsSocket: true);
+                await RelayTraffic(clientStream, targetStream);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError($"Failed to connect to target: {ex.Message}");
+                clientSocket.Close();
+            }
+        }
+
+        private async Task HandleHttp(string requestString, NetworkStream clientStream, Socket clientSocket, byte[] buffer, int bytesRead)
+        {
+            try
+            {
+                var headers = ParseHeaders(buffer, bytesRead);
+                string userAgent = headers.FirstOrDefault(h => h.Key == "User-Agent").Value;
+                var uri = new Uri(requestString.Split(' ')[1]);
+
+                // Add to known hosts if not already present
+                lock (_hostsLock)
+                {
+                    if (!_knownHosts.Contains(uri.Host))
+                    {
+                        _knownHosts.Add(uri.Host);
+                    }
+                }
+
+                var url = _configuration["Kestrel:Endpoints:Http:Url"];
+                var port = new Uri(url).Port;
+
+                var apiKey = string.IsNullOrEmpty(_options.ApiKey) ? "_" : _options.ApiKey;
+
+                var modifiedUri = $"http://localhost:{port}/{apiKey}/{uri.Host}{uri.PathAndQuery}";
+                using var client = _clientFactory.CreateClient();
+                var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, modifiedUri);
+                httpRequestMessage.Headers.Add("User-Agent", userAgent);
+                var result = await client.SendAsync(httpRequestMessage);
+
+                if (result.IsSuccessStatusCode)
+                {
+                    var responseData = await result.Content.ReadAsByteArrayAsync();
+                    await clientStream.WriteAsync(Encoding.ASCII.GetBytes($"HTTP/1.1 200 OK\r\nContent-Length: {responseData.Length}\r\n\r\n"));
+                    await clientStream.WriteAsync(responseData);
+                }
+                else
+                {
+                    await clientStream.WriteAsync(Encoding.ASCII.GetBytes($"HTTP/1.1 {result.StatusCode}\r\n\r\n"));
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError($"HTTP Proxy error: {ex.Message}");
+                await clientStream.WriteAsync(Encoding.ASCII.GetBytes("HTTP/1.1 500 Internal Server Error\r\n\r\n"));
+            }
+            finally
+            {
+                clientSocket.Close();
+            }
+        }
+
+        private Dictionary<string, string> ParseHeaders(byte[] buffer, int length)
+        {
+            var headers = new Dictionary<string, string>();
+            var headerString = Encoding.ASCII.GetString(buffer, 0, length);
+            var lines = headerString.Split(newLineSeparator, StringSplitOptions.RemoveEmptyEntries);
+            foreach (var line in lines.Skip(1)) // Skip the request line
+            {
+                var colonIndex = line.IndexOf(':');
+                if (colonIndex > 0)
+                {
+                    var key = line[..colonIndex].Trim();
+                    var value = line[(colonIndex + 1)..].Trim();
+                    headers[key] = value;
+                }
+            }
+            return headers;
+        }
+
+        private static (string host, int port) ParseTargetInfo(string requestLine)
+        {
+            var parts = requestLine.Split(' ')[1].Split(':');
+            return (parts[0], int.Parse(parts[1]));
+        }
+
+        private async Task RelayTraffic(NetworkStream clientStream, NetworkStream targetStream)
+        {
+            var clientToTargetTask = RelayStream(clientStream, targetStream);
+            var targetToClientTask = RelayStream(targetStream, clientStream);
+            await Task.WhenAll(clientToTargetTask, targetToClientTask);
+        }
+
+        private static async Task RelayStream(NetworkStream input, NetworkStream output)
+        {
+            byte[] buffer = new byte[8192];
+            int bytesRead;
+            while ((bytesRead = await input.ReadAsync(buffer.AsMemory(0, buffer.Length))) > 0)
+            {
+                await output.WriteAsync(buffer.AsMemory(0, bytesRead));
+                await output.FlushAsync();
+            }
+        }
+
+        public Task StartAsync(CancellationToken cancellationToken)
+        {
+            _listener = new TcpListener(IPAddress.Any, _options.ProxyPort);
+            _listener.Start();
+            Task.Run(() => HandleRequests(cancellationToken), cancellationToken);
+            return Task.CompletedTask;
+        }
+
+        public Task StopAsync(CancellationToken cancellationToken)
+        {
+            _listener.Stop();
+            return Task.CompletedTask;
+        }
+    }
+}

UmlautAdaptarr/Services/ProxyRequestService.cs

@@ -1,21 +1,26 @@
 using Microsoft.Extensions.Caching.Memory;
 using System.Collections.Concurrent;
+using Microsoft.Extensions.Options;
+using UmlautAdaptarr.Options;
 using UmlautAdaptarr.Utilities;
 
 namespace UmlautAdaptarr.Services
 {
-    public class ProxyService
+    public class ProxyRequestService
     {
         private readonly HttpClient _httpClient;
         private readonly string _userAgent;
-        private readonly ILogger<ProxyService> _logger;
+        private readonly ILogger<ProxyRequestService> _logger;
         private readonly IMemoryCache _cache;
+        private readonly GlobalOptions _options;
         private static readonly ConcurrentDictionary<string, DateTimeOffset> _lastRequestTimes = new();
+        private static readonly TimeSpan MINIMUM_DELAY_FOR_SAME_HOST = new(0, 0, 0, 1);
 
-        public ProxyService(IHttpClientFactory clientFactory, IConfiguration configuration, ILogger<ProxyService> logger, IMemoryCache cache)
+        public ProxyRequestService(IHttpClientFactory clientFactory, ILogger<ProxyRequestService> logger, IMemoryCache cache, IOptions<GlobalOptions> options)
         {
+            _options = options.Value;
             _httpClient = clientFactory.CreateClient("HttpClient") ?? throw new ArgumentNullException(nameof(clientFactory));
-            _userAgent = configuration["Settings:UserAgent"] ?? throw new ArgumentException("UserAgent must be set in appsettings.json");
+            _userAgent =  _options.UserAgent ?? throw new ArgumentException("UserAgent must be set in appsettings.json");
             _logger = logger;
             _cache = cache;
         }
@@ -26,9 +31,9 @@ namespace UmlautAdaptarr.Services
             if (_lastRequestTimes.TryGetValue(host, out var lastRequestTime))
             {
                 var timeSinceLastRequest = DateTimeOffset.Now - lastRequestTime;
-                if (timeSinceLastRequest < TimeSpan.FromMilliseconds(1500))
+                if (timeSinceLastRequest < MINIMUM_DELAY_FOR_SAME_HOST)
                 {
-                    await Task.Delay(TimeSpan.FromMilliseconds(1500) - timeSinceLastRequest);
+                    await Task.Delay(MINIMUM_DELAY_FOR_SAME_HOST - timeSinceLastRequest);
                 }
             }
             _lastRequestTimes[host] = DateTimeOffset.Now;
@@ -49,6 +54,7 @@ namespace UmlautAdaptarr.Services
             }
 
             await EnsureMinimumDelayAsync(targetUri);
+            var targetHost = new Uri(targetUri).Host;
 
             var requestMessage = new HttpRequestMessage
             {
@@ -71,21 +77,27 @@ namespace UmlautAdaptarr.Services
 
             try
             {
-                _logger.LogInformation($"ProxyService GET {UrlUtilities.RedactApiKey(targetUri)}");
+                _logger.LogInformation($"ProxyRequestService GET {UrlUtilities.RedactApiKey(targetUri)}");
                 var responseMessage = await _httpClient.SendAsync(requestMessage, HttpCompletionOption.ResponseHeadersRead, context.RequestAborted);
 
                 if (responseMessage.IsSuccessStatusCode)
                 {
-                    _cache.Set(targetUri, responseMessage, TimeSpan.FromMinutes(5));
+                    _cache.Set(targetUri, responseMessage, TimeSpan.FromMinutes(_options.IndexerRequestsCacheDurationInMinutes));
                 }
 
                 return responseMessage;
             }
             catch (Exception ex)
             {
-                _logger.LogError(ex, $"Error proxying request: {UrlUtilities.RedactApiKey(targetUri)}. Error: {ex.Message}");
+                var upstreamMessage = IsTimeoutOrReset(ex)
+                    ? $"{targetHost} timed out or reset the connection. This is an error with your indexer or network, not with UmlautAdaptarr."
+                    : $"{targetHost} request failed. This is an error with your indexer or network, not with UmlautAdaptarr.";
+
+                _logger.LogError(ex, "{UpstreamMessage} Target: {TargetUri} Error: {ErrorMessage}",
+                    upstreamMessage,
+                    UrlUtilities.RedactApiKey(targetUri),
+                    ex.Message);
 
-                // Create a response message indicating an internal server error
                 var errorResponse = new HttpResponseMessage(System.Net.HttpStatusCode.InternalServerError)
                 {
                     Content = new StringContent($"An error occurred while processing your request: {ex.Message}")
@@ -93,5 +105,26 @@ namespace UmlautAdaptarr.Services
                 return errorResponse;
             }
         }
+
+        private static bool IsTimeoutOrReset(Exception ex)
+        {
+            if (ex is TaskCanceledException)
+            {
+                return true;
+            }
+
+            var current = ex;
+            while (current != null)
+            {
+                if (current is System.Net.Sockets.SocketException socketEx)
+                {
+                    return socketEx.SocketErrorCode == System.Net.Sockets.SocketError.TimedOut
+                        || socketEx.SocketErrorCode == System.Net.Sockets.SocketError.ConnectionReset;
+                }
+                current = current.InnerException;
+            }
+
+            return false;
+        }
     }
 }

UmlautAdaptarr/Services/SearchItemLookupService.cs

@@ -1,17 +1,12 @@
 using UmlautAdaptarr.Models;
 using UmlautAdaptarr.Providers;
+using UmlautAdaptarr.Services.Factory;
 
 namespace UmlautAdaptarr.Services
 {
     public class SearchItemLookupService(CacheService cacheService,
-                                         SonarrClient sonarrClient,
+        ArrApplicationFactory arrApplicationFactory)
-                                         ReadarrClient readarrClient,
-                                         LidarrClient lidarrClient,
-                                         IConfiguration configuration)
     {
-        private readonly bool _sonarrEnabled = configuration.GetValue<bool>("SONARR_ENABLED");
-        private readonly bool _lidarrEnabled = configuration.GetValue<bool>("LIDARR_ENABLED");
-        private readonly bool _readarrEnabled = configuration.GetValue<bool>("READARR_ENABLED");
         public async Task<SearchItem?> GetOrFetchSearchItemByExternalId(string mediaType, string externalId)
         {
             // Attempt to get the item from the cache first
@@ -26,24 +21,41 @@ namespace UmlautAdaptarr.Services
             switch (mediaType)
             {
                 case "tv":
-                    if (_sonarrEnabled)
+
+                    var sonarrInstances = arrApplicationFactory.SonarrInstances;
+
+                    if (sonarrInstances.Any())
+                    {
+                        foreach (var sonarrClient in sonarrInstances)
                         {
                             fetchedItem = await sonarrClient.FetchItemByExternalIdAsync(externalId);
                         }
+                    }
                     break;
                 case "audio":
-                    if (_lidarrEnabled)
+
+                    var lidarrInstances = arrApplicationFactory.LidarrInstances;
+
+                    if (lidarrInstances.Any())
                     {
-                        fetchedItem = await lidarrClient.FetchItemByExternalIdAsync(externalId);
+                        foreach (var lidarrClient in lidarrInstances)
+                        {
+                            await lidarrClient.FetchItemByExternalIdAsync(externalId);
                             fetchedItem = cacheService.GetSearchItemByExternalId(mediaType, externalId);
                         }
+                    }
                     break;
                 case "book":
-                    if (_readarrEnabled)
+
+                    var readarrInstances = arrApplicationFactory.ReadarrInstances;
+                    if (readarrInstances.Any())
+                    {
+                        foreach (var readarrClient in readarrInstances)
                         {
                             await readarrClient.FetchItemByExternalIdAsync(externalId);
                             fetchedItem = cacheService.GetSearchItemByExternalId(mediaType, externalId);
                         }
+                    }
                     break;
             }
 
@@ -70,7 +82,9 @@ namespace UmlautAdaptarr.Services
             switch (mediaType)
             {
                 case "tv":
-                    if (_sonarrEnabled)
+
+                    var sonarrInstances = arrApplicationFactory.SonarrInstances;
+                    foreach (var sonarrClient in sonarrInstances)
                     {
                         fetchedItem = await sonarrClient.FetchItemByTitleAsync(title);
                     }

UmlautAdaptarr/Services/TitleApiService.cs

@@ -1,13 +1,16 @@
-using Newtonsoft.Json;
+using Microsoft.Extensions.Options;
+using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
+using System.Text;
+using UmlautAdaptarr.Options;
 using UmlautAdaptarr.Utilities;
 
 namespace UmlautAdaptarr.Services
 {
-    public class TitleApiService(IHttpClientFactory clientFactory, IConfiguration configuration, ILogger<TitleApiService> logger)
+    public class TitleApiService(IHttpClientFactory clientFactory, ILogger<TitleApiService> logger, IOptions<GlobalOptions> options)
     {
-        private readonly string _umlautAdaptarrApiHost = configuration["Settings:UmlautAdaptarrApiHost"]
+        public GlobalOptions Options { get; } = options.Value;
-                                                         ?? throw new ArgumentException("UmlautAdaptarrApiHost must be set in appsettings.json");
+
         private DateTime lastRequestTime = DateTime.MinValue;
 
         private async Task EnsureMinimumDelayAsync()
@@ -20,7 +23,7 @@ namespace UmlautAdaptarr.Services
             lastRequestTime = DateTime.Now;
         }
 
-        // TODO add cache, TODO add bulk request
+        // TODO add caching
         public async Task<(string? germanTitle, string[]? aliases)> FetchGermanTitleAndAliasesByExternalIdAsync(string mediaType, string externalId)
         {
             try
@@ -28,7 +31,7 @@ namespace UmlautAdaptarr.Services
                 await EnsureMinimumDelayAsync();
 
                 var httpClient = clientFactory.CreateClient();
-                var titleApiUrl = $"{_umlautAdaptarrApiHost}/tvshow_german.php?tvdbid={externalId}";
+                var titleApiUrl = $"{Options.UmlautAdaptarrApiHost}/tvshow_german.php?tvdbid={externalId}";
                 logger.LogInformation($"TitleApiService GET {UrlUtilities.RedactApiKey(titleApiUrl)}");
                 var response = await httpClient.GetStringAsync(titleApiUrl);
                 var titleApiResponseData = JsonConvert.DeserializeObject<dynamic>(response);
@@ -66,6 +69,68 @@ namespace UmlautAdaptarr.Services
             return (null, null);
         }
 
+        public async Task<Dictionary<string, (string? germanTitle, string[]? aliases)>> FetchGermanTitlesAndAliasesByExternalIdBulkAsync(IEnumerable<string> tvdbIds)
+        {
+            try
+            {
+                await EnsureMinimumDelayAsync();
+
+                var httpClient = clientFactory.CreateClient();
+                var bulkApiUrl = $"{Options.UmlautAdaptarrApiHost}/tvshow_german.php?bulk=true";
+                logger.LogInformation($"TitleApiService POST {UrlUtilities.RedactApiKey(bulkApiUrl)}");
+
+                // Prepare POST request payload
+                var payload = new { tvdbIds = tvdbIds.ToArray() };
+                var jsonPayload = JsonConvert.SerializeObject(payload);
+                var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
+
+                // Send POST request
+                var response = await httpClient.PostAsync(bulkApiUrl, content);
+                if (!response.IsSuccessStatusCode)
+                {
+                    logger.LogError($"Failed to fetch German titles via bulk API. Status Code: {response.StatusCode}");
+                    return [];
+                }
+
+                var responseContent = await response.Content.ReadAsStringAsync();
+                var bulkApiResponseData = JsonConvert.DeserializeObject<dynamic>(responseContent);
+
+                if (bulkApiResponseData == null || bulkApiResponseData.status != "success")
+                {
+                    logger.LogError($"Parsing UmlautAdaptarr Bulk API response resulted in null or an error status.");
+                    return [];
+                }
+
+                // Process response data
+                var results = new Dictionary<string, (string? germanTitle, string[]? aliases)>();
+                foreach (var entry in bulkApiResponseData.data)
+                {
+                    string tvdbId = entry.tvdbId;
+                    string? germanTitle = entry.germanTitle;
+
+                    string[]? aliases = null;
+                    if (entry.aliases != null)
+                    {
+                        JArray aliasesArray = JArray.FromObject(entry.aliases);
+                        aliases = aliasesArray.Children<JObject>()
+                            .Select(alias => alias["name"].ToString())
+                            .ToArray();
+                    }
+
+                    results[tvdbId] = (germanTitle, aliases);
+                }
+
+                logger.LogInformation($"Successfully fetched German titles for {results.Count} TVDB IDs via bulk API.");
+
+                return results;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"Error fetching German titles in bulk: {ex.Message}");
+                return new Dictionary<string, (string? germanTitle, string[]? aliases)>();
+            }
+        }
+
         public async Task<(string? germanTitle, string? externalId, string[]? aliases)> FetchGermanTitleAndExternalIdAndAliasesByTitle(string mediaType, string title)
         {
             try
@@ -74,7 +139,7 @@ namespace UmlautAdaptarr.Services
 
                 var httpClient = clientFactory.CreateClient();
                 var tvdbCleanTitle = title.Replace("ß", "ss");
-                var titleApiUrl = $"{_umlautAdaptarrApiHost}/tvshow_german.php?title={tvdbCleanTitle}";
+                var titleApiUrl = $"{Options.UmlautAdaptarrApiHost}/tvshow_german.php?title={tvdbCleanTitle}";
                 logger.LogInformation($"TitleApiService GET {UrlUtilities.RedactApiKey(titleApiUrl)}");
                 var titleApiResponse = await httpClient.GetStringAsync(titleApiUrl);
                 var titleApiResponseData = JsonConvert.DeserializeObject<dynamic>(titleApiResponse);

UmlautAdaptarr/Services/TitleMatchingService.cs

@@ -1,13 +1,17 @@
 using Microsoft.Extensions.FileSystemGlobbing.Internal;
+using Microsoft.Extensions.Options;
 using System.Text.RegularExpressions;
 using System.Xml.Linq;
 using UmlautAdaptarr.Models;
+using UmlautAdaptarr.Options;
 using UmlautAdaptarr.Utilities;
 
 namespace UmlautAdaptarr.Services
 {
-    public partial class TitleMatchingService(CacheService cacheService, ILogger<TitleMatchingService> logger)
+    public partial class TitleMatchingService(CacheService cacheService, ILogger<TitleMatchingService> logger, IOptions<GlobalOptions> options)
     {
+		public GlobalOptions _options { get; } = options.Value;
+
 		public string RenameTitlesInContent(string content, SearchItem? searchItem)
         {
             var xDoc = XDocument.Parse(content);
@@ -46,10 +50,10 @@ namespace UmlautAdaptarr.Services
                     switch (mediaType)
                     {
                         case "tv":
-                            FindAndReplaceForMoviesAndTV(logger, searchItem, titleElement, originalTitle, cleanTitleSeperatedBySpace!);
+                            FindAndReplaceForMoviesAndTV(searchItem, titleElement, originalTitle, cleanTitleSeperatedBySpace!);
                             break;
                         case "movie":
-                            FindAndReplaceForMoviesAndTV(logger, searchItem, titleElement, originalTitle, cleanTitleSeperatedBySpace!);
+                            FindAndReplaceForMoviesAndTV(searchItem, titleElement, originalTitle, cleanTitleSeperatedBySpace!);
                             break;
                         case "audio":
                             FindAndReplaceForBooksAndAudio(searchItem, titleElement, originalTitle!);
@@ -69,11 +73,11 @@ namespace UmlautAdaptarr.Services
         public void FindAndReplaceForBooksAndAudio(SearchItem searchItem, XElement? titleElement, string originalTitle)
         {
             var authorMatch = FindBestMatch(searchItem.AuthorMatchVariations, originalTitle.NormalizeForComparison(), originalTitle);
-            var titleMatch = FindBestMatch(searchItem.TitleMatchVariations, originalTitle.NormalizeForComparison(), originalTitle);
+            var (foundMatch, bestStart, bestEndInOriginal) = FindBestMatch(searchItem.TitleMatchVariations, originalTitle.NormalizeForComparison(), originalTitle);
 
-            if (authorMatch.foundMatch && titleMatch.foundMatch)
+            if (authorMatch.foundMatch && foundMatch)
             {
-                int matchEndPositionInOriginal = Math.Max(authorMatch.bestEndInOriginal, titleMatch.bestEndInOriginal);
+                int matchEndPositionInOriginal = Math.Max(authorMatch.bestEndInOriginal, bestEndInOriginal);
 
                 // Check and adjust for immediate following delimiter
                 char[] delimiters = [' ', '-', '_', '.'];
@@ -94,6 +98,10 @@ namespace UmlautAdaptarr.Services
 
                 // Update the title element
                 titleElement.Value = updatedTitle;
+                if (_options.EnableChangedTitleCache)
+                {
+					cacheService.CacheTitleRename(updatedTitle, originalTitle);
+				}
 				logger.LogInformation($"TitleMatchingService - Title changed: '{originalTitle}' to '{updatedTitle}'");
             }
             else
@@ -103,7 +111,7 @@ namespace UmlautAdaptarr.Services
         }
 
 
-        private (bool foundMatch, int bestStart, int bestEndInOriginal) FindBestMatch(string[] variations, string normalizedOriginal, string originalTitle)
+        private static (bool foundMatch, int bestStart, int bestEndInOriginal) FindBestMatch(string[] variations, string normalizedOriginal, string originalTitle)
         {
             bool found = false;
             int bestStart = int.MaxValue;
@@ -131,7 +139,7 @@ namespace UmlautAdaptarr.Services
         }
 
         // Maps an index from the normalized string back to a corresponding index in the original string
-        private int MapNormalizedIndexToOriginal(string normalizedOriginal, string originalTitle, int normalizedIndex)
+        private static int MapNormalizedIndexToOriginal(string normalizedOriginal, string originalTitle, int normalizedIndex)
         {
             // Count non-special characters up to the given index in the normalized string
             int nonSpecialCharCount = 0;
@@ -161,7 +169,7 @@ namespace UmlautAdaptarr.Services
         }
 
         // This method replaces the first variation that starts at the beginning of the release title
-        private static void FindAndReplaceForMoviesAndTV(ILogger<TitleMatchingService> logger, SearchItem searchItem, XElement? titleElement, string originalTitle, string normalizedOriginalTitle)
+        private void FindAndReplaceForMoviesAndTV(SearchItem searchItem, XElement? titleElement, string originalTitle, string normalizedOriginalTitle)
         {
             var titleMatchVariations = searchItem.TitleMatchVariations;
             var expectedTitle = searchItem.ExpectedTitle;
@@ -196,9 +204,9 @@ namespace UmlautAdaptarr.Services
                     // Workaround for the rare case of e.g. "Frieren: Beyond Journey's End" that also has the alias "Frieren"
                     if (expectedTitle!.StartsWith(variation, StringComparison.OrdinalIgnoreCase))
                     {
-                        // See if we already matched the whole title by checking if S01E01 pattern is coming next to avoid false positives
+                        // See if we already matched the whole title by checking if S01E01/S2024E123 pattern is coming next to avoid false positives
                         // - that won't help with movies but with tv shows
-                        var seasonMatchingPattern = $"^{separator}S\\d{{1,2}}E\\d{{1,2}}";
+                        var seasonMatchingPattern = $"^{separator}S\\d{{1,4}}E\\d{{1,4}}";
                         if (!Regex.IsMatch(suffix, seasonMatchingPattern))
                         {
                             logger.LogWarning($"TitleMatchingService - Didn't rename: '{originalTitle}' because the expected title '{expectedTitle}' starts with the variation '{variation}'");
@@ -209,30 +217,69 @@ namespace UmlautAdaptarr.Services
                     // Clean up any leading separator from the suffix
                     suffix = Regex.Replace(suffix, "^ +", "");
 
-                    // TODO EVALUTE! definitely make this optional - this adds GERMAN to the title is the title is german to make sure it's recognized as german
+                    // TODO add this when radarr is implemented
-                    // can lead to problems with shows such as "dark" that have international dubs
+                    // FixBadReleaseNaming
-                    /*
-                    // Check if "german" is not in the original title, ignoring case
-                    if (!Regex.IsMatch(originalTitle, "german", RegexOptions.IgnoreCase))
-                    {
-                        // Insert "GERMAN" after the newTitlePrefix
-                        newTitlePrefix += separator + "GERMAN";
-                    }
-                    */
 
                     // Construct the new title with the original suffix
-                    var newTitle = newTitlePrefix + (string.IsNullOrEmpty(suffix) ? "" : separator + suffix);
+                    var newTitle = newTitlePrefix + (string.IsNullOrEmpty(suffix) ? "" : suffix.StartsWith(separator) ? suffix : $"{separator}{suffix}");
 
                     // Update the title element's value with the new title
                     //titleElement.Value = newTitle + $"({originalTitle.Substring(0, variationLength)})";
                     titleElement.Value = newTitle;
-
+					if (_options.EnableChangedTitleCache)
+					{
+						cacheService.CacheTitleRename(newTitle, originalTitle);
+					}
 					logger.LogInformation($"TitleMatchingService - Title changed: '{originalTitle}' to '{newTitle}'");
-                    break; // Break after the first successful match and modification
+                    break;
                 }
             }
         }
 
+        private static readonly string[] MissingGermanTagReleaseGroups = ["tvr"];
+        private static readonly string[] HEVCInsteadOfx265TagReleaseGroups = ["eisbaer"];
+        private static readonly string[] WrongTagsReleaseGroups = ["eisbaer"];
+        private static string FixBadReleaseNaming(string title, string seperator, ILogger<TitleMatchingService> logger)
+        {
+            var releaseGroup = GetReleaseGroup(title);
+            if (MissingGermanTagReleaseGroups.Contains(releaseGroup))
+            {
+                // Check if "german" is not in the title, ignoring case
+                if (!Regex.IsMatch(title, "german", RegexOptions.IgnoreCase))
+                {
+                    logger.LogInformation($"FixBadReleaseNaming - found missing GERMAN tag for {title}");
+                    // TODO not finished
+                    // Insert "GERMAN" after the newTitlePrefix
+                    //newTitlePrefix += separator + "GERMAN";
+                }
+            }
+
+            if (HEVCInsteadOfx265TagReleaseGroups.Contains(releaseGroup))
+            {
+                if (!title.Contains("REMUX", StringComparison.InvariantCultureIgnoreCase))
+                {
+                    logger.LogInformation($"FixBadReleaseNaming - found HEVC instead of x265 for {title}");
+                    title = title.Replace("HEVC", "x265");
+                }
+            }
+
+            if (WrongTagsReleaseGroups.Contains(releaseGroup))
+            {
+                if (title.Contains($"{seperator}RM{seperator}"))
+                {
+                    logger.LogInformation($"FixBadReleaseNaming - found bad Tag RM instead of REMASTERED for {title}");
+                    title = title.Replace($"{seperator}RM{seperator}", $"{seperator}REMASTERED{seperator}");
+                }
+            }
+
+            return "";
+        }
+
+        private static string? GetReleaseGroup(string title)
+        {
+            return title.Contains('-') ? title[(title.LastIndexOf('-') + 1)..].Trim() : null;
+        }
+
         private static string ReplaceSeperatorsWithSpace(string title)
         {
             // Replace all known separators with space for normalization
@@ -242,7 +289,7 @@ namespace UmlautAdaptarr.Services
         private static char FindFirstSeparator(string title)
         {
             var match = WordSeperationCharRegex().Match(title);
-            return match.Success ? match.Value.First() : ' '; // Default to space if no separator found
+            return match.Success ? match.Value.First() : ' ';
         }
 
         private static string ReconstructTitleWithSeparator(string title, char separator)
@@ -262,23 +309,23 @@ namespace UmlautAdaptarr.Services
                 return null;
             }
 
-            if (category.StartsWith("EBook", StringComparison.OrdinalIgnoreCase) || category.StartsWith("Book", StringComparison.OrdinalIgnoreCase))
+            if (category == "7000" || category.StartsWith("EBook", StringComparison.OrdinalIgnoreCase) || category.StartsWith("Book", StringComparison.OrdinalIgnoreCase) ||category.StartsWith("Bücher", StringComparison.OrdinalIgnoreCase))
             {
                 return "book";
             }
-            else if (category.StartsWith("Movies", StringComparison.OrdinalIgnoreCase))
+            else if (category == "2000" || category.StartsWith("Movies", StringComparison.OrdinalIgnoreCase) || category.StartsWith("Filme", StringComparison.OrdinalIgnoreCase))
             {
                 return "movies";
             }
-            else if (category.StartsWith("TV", StringComparison.OrdinalIgnoreCase))
+            else if (category == "5000" || category.StartsWith("TV", StringComparison.OrdinalIgnoreCase) || category.StartsWith("Serien", StringComparison.OrdinalIgnoreCase))
             {
                 return "tv";
             }
-            else if (category.Contains("Audiobook", StringComparison.OrdinalIgnoreCase))
+            else if (category == "3030" || category.Contains("Audiobook", StringComparison.OrdinalIgnoreCase) || category.Contains("Hörbuch", StringComparison.OrdinalIgnoreCase))
             {
                 return "book";
             }
-            else if (category.StartsWith("Audio"))
+            else if (category == "3000" || category.StartsWith("Audio", StringComparison.OrdinalIgnoreCase) || category.StartsWith("Musik", StringComparison.OrdinalIgnoreCase))
             {
                 return "audio";
             }

UmlautAdaptarr/Services/TitleQueryServiceLegacy.cs

@@ -1,162 +0,0 @@
-using Microsoft.Extensions.Caching.Memory;
-using Newtonsoft.Json;
-using UmlautAdaptarr.Models;
-using UmlautAdaptarr.Providers;
-using UmlautAdaptarr.Utilities;
-
-namespace UmlautAdaptarr.Services
-{
-    public class TitleQueryServiceLegacy(
-        IMemoryCache memoryCache,
-        ILogger<TitleQueryServiceLegacy> logger,
-        IConfiguration configuration,
-        IHttpClientFactory clientFactory,
-        SonarrClient sonarrClient)
-    {
-        private readonly HttpClient _httpClient = clientFactory.CreateClient("HttpClient") ?? throw new ArgumentNullException();
-        private readonly string _sonarrHost = configuration.GetValue<string>("SONARR_HOST") ?? throw new ArgumentException("SONARR_HOST environment variable must be set");
-        private readonly string _sonarrApiKey = configuration.GetValue<string>("SONARR_API_KEY") ?? throw new ArgumentException("SONARR_API_KEY environment variable must be set");
-        private readonly string _umlautAdaptarrApiHost = configuration["Settings:UmlautAdaptarrApiHost"] ?? throw new ArgumentException("UmlautAdaptarrApiHost must be set in appsettings.json");
-
-        /*public async Task<(bool hasGermanUmlaut, string? GermanTitle, string ExpectedTitle)> QueryGermanShowTitleByTVDBId(string tvdbId)
-        {
-            var sonarrCacheKey = $"SearchItem_Sonarr_{tvdbId}";
-
-            if (memoryCache.TryGetValue(sonarrCacheKey, out SearchItem? cachedItem))
-            {
-                return (cachedItem?.HasGermanUmlaut ?? false, cachedItem?.GermanTitle, cachedItem?.ExpectedTitle ?? string.Empty);
-            }
-            else
-            {
-                var sonarrUrl = $"{_sonarrHost}/api/v3/series?tvdbId={tvdbId}&includeSeasonImages=false&apikey={_sonarrApiKey}";
-                var sonarrApiResponse = await _httpClient.GetStringAsync(sonarrUrl);
-                var shows = JsonConvert.DeserializeObject<dynamic>(sonarrApiResponse);
-
-                if (shows == null)
-                {
-                    logger.LogError($"Parsing Sonarr API response for TVDB ID {tvdbId} resulted in null");
-                    return (false, null, string.Empty);
-                }
-                else if (shows.Count == 0)
-                {
-                    logger.LogWarning($"No results found for TVDB ID {tvdbId}");
-                    return (false, null, string.Empty);
-                }
-
-                var expectedTitle = (string)shows[0].title;
-                if (expectedTitle == null)
-                {
-                    logger.LogError($"Sonarr Title for TVDB ID {tvdbId} is null");
-                    return (false, null, string.Empty);
-                }
-
-                string? germanTitle = null;
-                var hasGermanTitle = false;
-
-                var titleApiUrl = $"{_umlautAdaptarrApiHost}/tvshow_german.php?tvdbid={tvdbId}";
-                var titleApiResponse = await _httpClient.GetStringAsync(titleApiUrl);
-                var titleApiResponseData = JsonConvert.DeserializeObject<dynamic>(titleApiResponse);
-
-                if (titleApiResponseData == null)
-                {
-                    logger.LogError($"Parsing UmlautAdaptarr TitleQuery API response for TVDB ID {tvdbId} resulted in null");
-                    return (false, null, string.Empty);
-                }
-
-                if (titleApiResponseData.status == "success" && !string.IsNullOrEmpty((string)titleApiResponseData.germanTitle))
-                {
-                    germanTitle = titleApiResponseData.germanTitle;
-                    hasGermanTitle = true;
-                }
-
-                var hasGermanUmlaut = germanTitle?.HasGermanUmlauts() ?? false;
-
-                var result = (hasGermanUmlaut, germanTitle, expectedTitle);
-                memoryCache.Set(showCacheKey, result, new MemoryCacheEntryOptions
-                {
-                    Size = 1,
-                    SlidingExpiration = hasGermanTitle ? TimeSpan.FromDays(30) : TimeSpan.FromDays(7)
-                });
-
-                return result;
-            }
-        }*/
-
-        // This method is being used if the *arrs do a search with the "q" parameter (text search)
-        public async Task<(bool hasGermanUmlaut, string? GermanTitle, string ExpectedTitle)> QueryGermanShowTitleByTitle(string title)
-        {
-            // TVDB doesn't use ß - TODO: Determine if this is true
-            var tvdbCleanTitle = title.Replace("ß", "ss");
-
-            var cacheKey = $"show_{tvdbCleanTitle}";
-            if (memoryCache.TryGetValue(cacheKey, out (bool hasGermanUmlaut, string? GermanTitle, string ExpectedTitle) cachedResult))
-            {
-                return cachedResult;
-            }
-
-            var titleApiUrl = $"{_umlautAdaptarrApiHost}/tvshow_german.php?title={tvdbCleanTitle}";
-            var titleApiResponse = await _httpClient.GetStringAsync(titleApiUrl);
-            var titleApiResponseData = JsonConvert.DeserializeObject<dynamic>(titleApiResponse);
-
-            if (titleApiResponseData == null)
-            {
-                logger.LogError($"Parsing UmlautAdaptarr TitleQuery API response for title {title} resulted in null");
-                return (false, null, string.Empty);
-            }
-
-            if (titleApiResponseData.status == "success" && !string.IsNullOrEmpty((string)titleApiResponseData.germanTitle))
-            {
-                var tvdbId = (string)titleApiResponseData.tvdbId;
-                if (tvdbId == null)
-                {
-                    logger.LogError($"Parsing UmlautAdaptarr TitleQuery API response tvdbId {titleApiResponseData} resulted in null");
-                    return (false, null, string.Empty);
-                }
-
-                var sonarrUrl = $"{_sonarrHost}/api/v3/series?tvdbId={tvdbId}&includeSeasonImages=false&apikey={_sonarrApiKey}";
-                var sonarrApiResponse = await _httpClient.GetStringAsync(sonarrUrl);
-                var shows = JsonConvert.DeserializeObject<dynamic>(sonarrApiResponse);
-
-                if (shows == null)
-                {
-                    logger.LogError($"Parsing Sonarr API response for TVDB ID {tvdbId} resulted in null");
-                    return (false, null, string.Empty);
-                }
-                else if (shows.Count == 0)
-                {
-                    logger.LogWarning($"No results found for TVDB ID {tvdbId}");
-                    return (false, null, string.Empty);
-                }
-
-                var expectedTitle = (string)shows[0].title;
-                if (expectedTitle == null)
-                {
-                    logger.LogError($"Sonarr Title for TVDB ID {tvdbId} is null");
-                    return (false, null, string.Empty);
-                }
-
-                string germanTitle ;
-                bool hasGermanTitle;
-
-                germanTitle = titleApiResponseData.germanTitle;
-                hasGermanTitle = true;
-
-                var hasGermanUmlaut = germanTitle?.HasUmlauts() ?? false;
-
-                var result = (hasGermanUmlaut, germanTitle, expectedTitle);
-                memoryCache.Set(cacheKey, result, new MemoryCacheEntryOptions
-                {
-                    Size = 1,
-                    SlidingExpiration = hasGermanTitle ? TimeSpan.FromDays(30) : TimeSpan.FromDays(7)
-                });
-
-                return result;
-            }
-            else
-            {
-                logger.LogWarning($"UmlautAdaptarr TitleQuery {titleApiUrl} didn't succeed.");
-                return (false, null, string.Empty);
-            }
-        }
-    }
-}

UmlautAdaptarr/UmlautAdaptarr.csproj

@@ -9,8 +9,13 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="FluentValidation.DependencyInjectionExtensions" Version="12.0.0" />
+    <PackageReference Include="IL.FluentValidation.Extensions.Options" Version="11.0.2" />
+    <PackageReference Include="Microsoft.Extensions.Options" Version="9.0.7" />
+    <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="9.0.7" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
-    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
+    <PackageReference Include="Serilog.AspNetCore" Version="9.0.0" />
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="7.2.0" />
   </ItemGroup>
 
 </Project>

UmlautAdaptarr/Utilities/ApiKeyMaskingEnricher.cs

@@ -0,0 +1,69 @@
+using System.Collections;
+using System.Text.RegularExpressions;
+using Serilog.Core;
+using Serilog.Events;
+
+namespace UmlautAdaptarr.Utilities;
+
+public class ApiKeyMaskingEnricher : ILogEventEnricher
+{
+    private readonly List<string> apiKeys = new();
+
+    public ApiKeyMaskingEnricher(string appsetting)
+    {
+        ExtractApiKeysFromAppSettings(appsetting);
+        ExtractApiKeysFromEnvironmentVariables();
+        apiKeys = new List<string>(apiKeys.Distinct());
+    }
+
+    public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
+    {
+        //if (logEvent.Properties.TryGetValue("apikey", out var value) && value is ScalarValue scalarValue)
+        //{
+            var maskedValue = new ScalarValue("**Hidden Api Key**");
+            foreach (var apikey in apiKeys) logEvent.AddOrUpdateProperty(new LogEventProperty(apikey, maskedValue));
+       // }
+    }
+
+
+    /// <summary>
+    ///     Scan all Env Variabels for known Apikeys
+    /// </summary>
+    /// <returns>List of all Apikeys</returns>
+    public List<string> ExtractApiKeysFromEnvironmentVariables()
+    {
+        var envVariables = Environment.GetEnvironmentVariables();
+
+        foreach (DictionaryEntry envVariable in envVariables)
+            if (envVariable.Key.ToString()!.Contains("ApiKey"))
+                apiKeys.Add(envVariable.Value.ToString());
+
+        return apiKeys;
+    }
+
+
+    public List<string> ExtractApiKeysFromAppSettings(string filePath)
+    {
+        try
+        {
+            if (File.Exists(filePath))
+            {
+                var fileContent = File.ReadAllText(filePath);
+
+                var pattern = "\"ApiKey\": \"(.*?)\"";
+                var regex = new Regex(pattern);
+                var matches = regex.Matches(fileContent);
+
+                foreach (Match match in matches) apiKeys.Add(match.Groups[1].Value);
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.Message);
+        }
+
+        return apiKeys;
+    }
+}
+
+

UmlautAdaptarr/Utilities/Extensions.cs

@@ -99,7 +99,7 @@ namespace UmlautAdaptarr.Utilities
         {
             if (removeUmlauts)
             {
-                return NoSpecialCharactersExceptHypenRegex().Replace(text, "");
+                return NoSpecialCharactersExceptHyphenRegex().Replace(text, "");
             }
             else
             {
@@ -157,9 +157,9 @@ namespace UmlautAdaptarr.Utilities
         }
 
         [GeneratedRegex("[^a-zA-Z0-9 -]+", RegexOptions.Compiled)]
-        private static partial Regex NoSpecialCharactersExceptHypenRegex();
+        private static partial Regex NoSpecialCharactersExceptHyphenRegex();
 
-        [GeneratedRegex("[^a-zA-Z0-9 -öäüßÖÄÜß]+", RegexOptions.Compiled)]
+        [GeneratedRegex("[^a-zA-Z0-9 öäüßÖÄÜß-]+", RegexOptions.Compiled)]
         private static partial Regex NoSpecialCharactersExceptHyphenAndUmlautsRegex();
 
         [GeneratedRegex(@"\s+")]

UmlautAdaptarr/Utilities/GlobalStaticLogger.cs

@@ -0,0 +1,19 @@
+namespace UmlautAdaptarr.Utilities
+{
+    /// <summary>
+    /// Service for providing a static logger to log errors and information. 
+    /// The GlobalStaticLogger is designed to provide a static logger that can be used to log errors and information. 
+    /// It facilitates logging for both static classes and extension methods.
+    /// </summary>
+    public static class GlobalStaticLogger
+    {
+
+        public static ILogger Logger;
+
+        /// <summary>
+        /// Initializes the GlobalStaticLogger with the provided logger factory.
+        /// </summary>
+        /// <param name="loggerFactory">The ILoggerFactory instance used to create loggers.</param>
+        public static void Initialize(ILoggerFactory loggerFactory) => Logger = loggerFactory.CreateLogger("GlobalStaticLogger");
+    }
+}

UmlautAdaptarr/Utilities/Helper.cs

@@ -0,0 +1,56 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace UmlautAdaptarr.Utilities;
+
+public static class Helper
+{
+    public static void ShowLogo()
+    {
+        Console.WriteLine(
+            "\r\n _   _           _             _    ___      _             _                  \r\n| | | |         | |           | |  / _ \\    | |           | |                 \r\n| | | |_ __ ___ | | __ _ _   _| |_/ /_\\ \\ __| | __ _ _ __ | |_ __ _ _ __ _ __ \r\n| | | | '_ ` _ \\| |/ _` | | | | __|  _  |/ _` |/ _` | '_ \\| __/ _` | '__| '__|\r\n| |_| | | | | | | | (_| | |_| | |_| | | | (_| | (_| | |_) | || (_| | |  | |   \r\n \\___/|_| |_| |_|_|\\__,_|\\__,_|\\__\\_| |_/\\__,_|\\__,_| .__/ \\__\\__,_|_|  |_|   \r\n                                                    | |                       \r\n                                                    |_|                       \r\n");
+    }
+
+    public static async Task ShowInformation()
+    {
+        Console.WriteLine("--------------------------[IP Leak Test]-----------------------------");
+        var ipInfo = await GetPublicIpAddressInfoAsync();
+
+        if (ipInfo != null)
+        {
+            Console.WriteLine($"Your Public IP Address is '{ipInfo.Ip}'");
+            Console.WriteLine($"Hostname: {ipInfo.Hostname}");
+            Console.WriteLine($"City: {ipInfo.City}");
+            Console.WriteLine($"Region: {ipInfo.Region}");
+            Console.WriteLine($"Country: {ipInfo.Country}");
+            Console.WriteLine($"Provider: {ipInfo.Org}");
+        }
+        else
+        {
+            Console.ForegroundColor = ConsoleColor.Red;
+            Console.WriteLine("Error: Could not retrieve public IP information.");
+            Console.ResetColor();
+        }
+
+        Console.WriteLine("--------------------------------------------------------------------");
+    }
+
+
+    private static async Task<IpInfo?> GetPublicIpAddressInfoAsync()
+    {
+        using var client = new HttpClient();
+        client.Timeout = TimeSpan.FromSeconds(10);
+
+        try
+        {
+            var response = await client.GetAsync("https://ipinfo.io/json");
+            response.EnsureSuccessStatusCode();
+            var content = await response.Content.ReadAsStringAsync();
+            return JsonSerializer.Deserialize<IpInfo>(content);
+        }
+        catch
+        {
+            return null;
+        }
+    }
+}

UmlautAdaptarr/Utilities/KeyedServiceExtensions.cs

@@ -0,0 +1,74 @@
+using System.Collections;
+using System.Collections.ObjectModel;
+
+namespace UmlautAdaptarr.Utilities
+{
+    // License: This code is published under the MIT license.
+    // Source: https://stackoverflow.com/questions/77559201/
+    public static class KeyedServiceExtensions
+    {
+        public static void AllowResolvingKeyedServicesAsDictionary(
+            this IServiceCollection sc)
+        {
+            // KeyedServiceCache caches all the keys of a given type for a
+            // specific service type. By making it a singleton we only have
+            // determine the keys once, which makes resolving the dict very fast.
+            sc.AddSingleton(typeof(KeyedServiceCache<,>));
+
+            // KeyedServiceCache depends on the IServiceCollection to get
+            // the list of keys. That's why we register that here as well, as it
+            // is not registered by default in MS.DI.
+            sc.AddSingleton(sc);
+
+            // Last we make the registration for the dictionary itself, which maps
+            // to our custom type below. This registration must be  transient, as
+            // the containing services could have any lifetime and this registration
+            // should by itself not cause Captive Dependencies.
+            sc.AddTransient(typeof(IDictionary<,>), typeof(KeyedServiceDictionary<,>));
+
+            // For completeness, let's also allow IReadOnlyDictionary to be resolved.
+            sc.AddTransient(
+                typeof(IReadOnlyDictionary<,>), typeof(KeyedServiceDictionary<,>));
+        }
+
+        // We inherit from ReadOnlyDictionary, to disallow consumers from changing
+        // the wrapped dependencies while reusing all its functionality. This way
+        // we don't have to implement IDictionary<T,V> ourselves; too much work.
+        private sealed class KeyedServiceDictionary<TKey, TService>(
+            KeyedServiceCache<TKey, TService> keys, IServiceProvider provider)
+            : ReadOnlyDictionary<TKey, TService>(Create(keys, provider))
+            where TKey : notnull
+            where TService : notnull
+        {
+            private static Dictionary<TKey, TService> Create(
+                KeyedServiceCache<TKey, TService> keys, IServiceProvider provider)
+            {
+                var dict = new Dictionary<TKey, TService>(capacity: keys.Keys.Length);
+
+                foreach (TKey key in keys.Keys)
+                {
+                    dict[key] = provider.GetRequiredKeyedService<TService>(key);
+                }
+
+                return dict;
+            }
+        }
+
+        private sealed class KeyedServiceCache<TKey, TService>(IServiceCollection sc)
+            where TKey : notnull
+            where TService : notnull
+        {
+            // Once this class is resolved, all registrations are guaranteed to be
+            // made, so we can, at that point, safely iterate the collection to get
+            // the keys for the service type.
+            public TKey[] Keys { get; } = (
+                from service in sc
+                where service.ServiceKey != null
+                where service.ServiceKey!.GetType() == typeof(TKey)
+                where service.ServiceType == typeof(TService)
+                select (TKey)service.ServiceKey!)
+                .ToArray();
+        }
+
+    }
+}

UmlautAdaptarr/Utilities/ServicesExtensions.cs

@@ -0,0 +1,191 @@
+using FluentValidation;
+using System.Linq.Expressions;
+using UmlautAdaptarr.Interfaces;
+using UmlautAdaptarr.Options;
+using UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
+using UmlautAdaptarr.Providers;
+using UmlautAdaptarr.Services;
+using UmlautAdaptarr.Validator;
+
+namespace UmlautAdaptarr.Utilities;
+
+/// <summary>
+///     Extension methods for configuring services related to ARR Applications
+/// </summary>
+public static class ServicesExtensions
+{
+
+    /// <summary>
+    /// Logger instance for logging proxy configurations.
+    /// </summary>
+    private static ILogger Logger = GlobalStaticLogger.Logger;
+
+    /// <summary>
+    ///     Adds a service with specified options and service to the service collection.
+    /// </summary>
+    /// <typeparam name="TOptions">The options type for the service.</typeparam>
+    /// <typeparam name="TService">The service type for the service.</typeparam>
+    /// <typeparam name="TInterface">The Interface of the service type</typeparam>
+    /// <param name="builder">The <see cref="WebApplicationBuilder" /> to configure the service collection.</param>
+    /// <param name="sectionName">The name of the configuration section containing service options.</param>
+    /// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
+    private static async Task<WebApplicationBuilder> AddServicesWithOptions<TOptions, TService, TInterface>(
+        this WebApplicationBuilder builder, string sectionName)
+        where TOptions : class, new()
+        where TService : class, TInterface
+        where TInterface : class
+    {
+        try
+        {
+            if (builder.Services == null) throw new ArgumentNullException(nameof(builder), "Service collection is null.");
+
+            var singleInstance = builder.Configuration.GetSection(sectionName).Get<TOptions>();
+
+            var singleHost = (string?)typeof(TOptions).GetProperty("Host")?.GetValue(singleInstance, null);
+
+            // If we have no Single Instance, we try to parse for an Array
+            var optionsArray = singleHost == null
+                ? builder.Configuration.GetSection(sectionName).Get<TOptions[]>()
+                :
+                [
+                    singleInstance
+                ];
+
+            if (optionsArray == null || !optionsArray.Any())
+                throw new InvalidOperationException(
+                    $"{typeof(TService).Name} options could not be loaded from Configuration or ENV Variable.");
+
+            foreach (var option in optionsArray)
+            {
+              GlobalInstanceOptionsValidator validator = new();
+
+              var results = await validator.ValidateAsync(option as GlobalInstanceOptions);
+
+                if (!results.IsValid)
+                {
+                    foreach (var failure in results.Errors)
+                    {
+                        Console.WriteLine(($"Property {failure.PropertyName } failed validation. Error was: {failure.ErrorMessage}"));
+                    }
+
+                    throw new Exception("Please fix cour environment variables and then Start UmlautAdaptarr again");
+                }
+
+                var instanceState = (bool)(typeof(TOptions).GetProperty("Enabled")?.GetValue(option, null) ?? false);
+
+                // We only want to create instances that are enabled in the Configs
+                if (instanceState)
+                {
+                    // User can give the Instance a readable Name otherwise we use the Host Property
+                    var instanceName = (string)(typeof(TOptions).GetProperty("Name")?.GetValue(option, null) ??
+                                                (string)typeof(TOptions).GetProperty("Host")?.GetValue(option, null)!);
+
+                    // Dark Magic , we don't know the Property's of TOptions , and we won't cast them for each Options
+                    // Todo eventuell schönere Lösung finden
+                    var paraexpression = Expression.Parameter(Type.GetType(option.GetType().FullName), "x");
+
+                    foreach (var prop in option.GetType().GetProperties())
+                    {
+                        var val = Expression.Constant(prop.GetValue(option));
+                        var memberexpression = Expression.PropertyOrField(paraexpression, prop.Name);
+
+                        if (prop.PropertyType == typeof(int) || prop.PropertyType == typeof(string) || prop.PropertyType == typeof(bool))
+                        {
+                            var assign = Expression.Assign(memberexpression, Expression.Convert(val, prop.PropertyType));
+                            var exp = Expression.Lambda<Action<TOptions>>(assign, paraexpression);
+                            builder.Services.Configure(instanceName, exp.Compile());
+                        }
+                        else
+                        {
+                            Logger.LogWarning(prop.PropertyType + "No Support");
+                        }
+                    }
+
+                    builder.Services.AddKeyedSingleton<TInterface, TService>(instanceName);
+                }
+            }
+
+            return builder;
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error in AddServicesWithOptions: {ex.Message}");
+            throw;
+        }
+
+    }
+
+    /// <summary>
+    ///     Adds a service with specified options and service to the service collection.
+    /// </summary>
+    /// <typeparam name="TOptions">The options type for the service.</typeparam>
+    /// <typeparam name="TService">The service type for the service.</typeparam>
+    /// <param name="builder">The <see cref="WebApplicationBuilder" /> to configure the service collection.</param>
+    /// <param name="sectionName">The name of the configuration section containing service options.</param>
+    /// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
+    private static WebApplicationBuilder AddServiceWithOptions<TOptions, TService>(this WebApplicationBuilder builder,
+        string sectionName)
+        where TOptions : class
+        where TService : class
+    {
+        if (builder.Services == null) throw new ArgumentNullException(nameof(builder), "Service collection is null.");
+
+        var options = builder.Configuration.GetSection(sectionName).Get<TOptions>() ?? throw new InvalidOperationException(
+                $"{typeof(TService).Name} options could not be loaded from Configuration or ENV Variable.");
+        builder.Services.Configure<TOptions>(builder.Configuration.GetSection(sectionName));
+        builder.Services.AddSingleton<TService>();
+
+        return builder;
+    }
+
+    /// <summary>
+    ///     Adds support for Sonarr with default options and client.
+    /// </summary>
+    /// <param name="builder">The <see cref="WebApplicationBuilder" /> to configure the service collection.</param>
+    /// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
+    public static Task<WebApplicationBuilder> AddSonarrSupport(this WebApplicationBuilder builder)
+    {
+        //  builder.Serviceses.AddSingleton<IOptionsMonitoSonarrInstanceOptionsns>, OptionsMonitoSonarrInstanceOptionsns>>();
+        return builder.AddServicesWithOptions<SonarrInstanceOptions, SonarrClient, IArrApplication>("Sonarr");
+    }
+
+    /// <summary>
+    ///     Adds support for Lidarr with default options and client.
+    /// </summary>
+    /// <param name="builder">The <see cref="WebApplicationBuilder" /> to configure the service collection.</param>
+    /// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
+    public static Task<WebApplicationBuilder> AddLidarrSupport(this WebApplicationBuilder builder)
+    {
+        return builder.AddServicesWithOptions<LidarrInstanceOptions, LidarrClient, IArrApplication>("Lidarr");
+    }
+
+    /// <summary>
+    ///     Adds support for Readarr with default options and client.
+    /// </summary>
+    /// <param name="builder">The <see cref="WebApplicationBuilder" /> to configure the service collection.</param>
+    /// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
+    public static Task<WebApplicationBuilder> AddReadarrSupport(this WebApplicationBuilder builder)
+    {
+        return builder.AddServicesWithOptions<ReadarrInstanceOptions, ReadarrClient, IArrApplication>("Readarr");
+    }
+
+    /// <summary>
+    ///     Adds a title lookup service to the service collection.
+    /// </summary>
+    /// <param name="builder">The <see cref="WebApplicationBuilder" /> to configure the service collection.</param>
+    /// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
+    public static WebApplicationBuilder AddTitleLookupService(this WebApplicationBuilder builder)
+    {
+        return builder.AddServiceWithOptions<GlobalOptions, TitleApiService>("Settings");
+    }
+
+    /// <summary>
+    ///     Adds a proxy request service to the service collection.
+    /// </summary>
+    /// <param name="builder">The <see cref="WebApplicationBuilder" /> to configure the service collection.</param>
+    /// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
+    public static WebApplicationBuilder AddProxyRequestService(this WebApplicationBuilder builder)
+    {
+        return builder.AddServiceWithOptions<GlobalOptions, ProxyRequestService>("Settings");
+    }
+}

UmlautAdaptarr/Utilities/UrlUtilities.cs

@@ -5,14 +5,15 @@ namespace UmlautAdaptarr.Utilities
 {
     public partial class UrlUtilities
     {
-        [GeneratedRegex(@"^(?!http:\/\/)([a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)+.*)$")]
+        [GeneratedRegex(@"^(?!http:\/\/)([a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)+(:\d+)?(/.*)?)$")]
+
         private static partial Regex UrlMatchingRegex();
         public static bool IsValidDomain(string domain)
         {
             // RegEx für eine einfache URL-Validierung ohne http:// und ohne abschließenden Schrägstrich
             // Erlaubt optionale Subdomains, Domainnamen und TLDs, aber keine Pfade oder Protokolle
             var regex = UrlMatchingRegex();
-            return regex.IsMatch(domain) && !domain.EndsWith("/");
+            return regex.IsMatch(domain);
         }
 
         public static string BuildUrl(string domain, IDictionary<string, string> queryParameters)

UmlautAdaptarr/Validator/GlobalInstanceOptionsValidator.cs

@@ -0,0 +1,71 @@
+using FluentValidation;
+using UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
+
+namespace UmlautAdaptarr.Validator;
+
+public class GlobalInstanceOptionsValidator : AbstractValidator<GlobalInstanceOptions>
+{
+    private readonly static HttpClient httpClient = new()
+    {
+        Timeout = TimeSpan.FromSeconds(3)
+    };
+
+    public GlobalInstanceOptionsValidator()
+    {
+        RuleFor(x => x.Enabled).NotNull();
+
+        When(x => x.Enabled, () =>
+        {
+            RuleFor(x => x.Host)
+                .NotEmpty().WithMessage("Host is required when Enabled is true.")
+                .Must(BeAValidUrl).WithMessage("Host/Url must start with http:// or https:// and be a valid address.");
+
+            RuleFor(x => x.ApiKey)
+                .NotEmpty().WithMessage("ApiKey is required when Enabled is true.");
+
+            RuleFor(x => x)
+                .MustAsync(BeReachable)
+                .WithMessage("Host/Url is not reachable. Please check your Host or your UmlautAdaptrr Settings");
+        });
+    }
+
+    private bool BeAValidUrl(string url)
+    {
+        return Uri.TryCreate(url, UriKind.Absolute, out var uriResult)
+               && (uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps);
+    }
+
+    private static async Task<bool> BeReachable(GlobalInstanceOptions opts, CancellationToken cancellationToken)
+    {
+        var endTime = DateTime.Now.AddMinutes(3);
+        var reachable = false;
+        var url = $"{opts.Host}/api?apikey={opts.ApiKey}";
+
+        while (DateTime.Now < endTime)
+        {
+            try
+            {
+                using var response = await httpClient.GetAsync(url, cancellationToken);
+                if (response.IsSuccessStatusCode)
+                {
+                    reachable = true;
+                    break;
+                }
+                else
+                {
+                    Console.WriteLine($"Reachable check got unexpected status code {response.StatusCode}.");
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine(ex.Message);
+            }
+
+            // Wait for 15 seconds for next try
+            Console.WriteLine($"The URL \"{opts.Host}/api?apikey=[REDACTED]\" is not reachable. Next attempt in 15 seconds...");
+            Thread.Sleep(15000);
+        }
+
+        return reachable;
+    }
+}

UmlautAdaptarr/appsettings.json

@@ -3,18 +3,75 @@
     "LogLevel": {
       "Default": "Information",
       "Microsoft.AspNetCore": "Warning"
+    },
+    "Console": {
+      "TimestampFormat": "yyyy-MM-dd HH:mm:ss::"
     }
   },
   "AllowedHosts": "*",
   "Kestrel": {
     "Endpoints": {
       "Http": {
-        "Url": "http://*:5005"
+        "Url": "http://[::]:5005"
       }
     }
   },
+  // Settings__UserAgent=UmlautAdaptarr/1.0
+  // Settings__UmlautAdaptarrApiHost=https://umlautadaptarr.pcjones.de/api/v1
   "Settings": {
     "UserAgent": "UmlautAdaptarr/1.0",
-    "UmlautAdaptarrApiHost": "https://umlautadaptarr.pcjones.de/api/v1"
+    "UmlautAdaptarrApiHost": "https://umlautadaptarr.pcjones.de/api/v1",
+    "IndexerRequestsCacheDurationInMinutes": 12,
+    "ApiKey": null,
+    "ProxyPort": 5006,
+    "EnableChangedTitleCache": false // Set to true if you are using crowdnfo.net post processing script
+  },
+  "Sonarr": [
+    {
+      // Docker Environment Variables:
+      // - Sonarr__0__Enabled: true (set to false to disable)
+      // - Sonarr__0__Name: Name of the Instance (Optional)
+      // - Sonarr__0__Host: your_sonarr_host_url
+      // - Sonarr__0__ApiKey: your_sonarr_api_key
+      "Enabled": false,
+      "Name": "Sonarr",
+      "Host": "your_sonarr_host_url",
+      "ApiKey": "your_sonarr_api_key"
+    },
+    {
+      // Docker Environment Variables:
+      // - Sonarr__1__Enabled: true (set to false to disable)
+      // - Sonarr__1__Name: Name of the Instance (Optional)
+      // - Sonarr__1__Host: your_sonarr_host_url
+      // - Sonarr__1__ApiKey: your_sonarr_api_key
+      "Enabled": false,
+      "Name": "Sonarr 4k",
+      "Host": "your_other_sonarr_host_url",
+      "ApiKey": "your_other_sonarr_api_key"
+    }
+  ],
+  "Lidarr":
+  // Docker Environment Variables:
+  // - Lidarr__Enabled: true (set to false to disable)
+  // - Lidarr__Host: your_lidarr_host_url
+  // - Lidarr__ApiKey: your_lidarr_api_key
+  {
+    "Enabled": false,
+    "Host": "your_lidarr_host_url",
+    "ApiKey": "your_lidarr_api_key"
+  },
+  "Readarr": {
+    // Docker Environment Variables:
+    // - Readarr__Enabled: true (set to false to disable)
+    // - Readarr__Host: your_readarr_host_url
+    // - Readarr__ApiKey: your_readarr_api_key
+    "Enabled": false,
+    "Host": "your_readarr_host_url",
+    "ApiKey": "your_readarr_api_key"
+  },
+  "IpLeakTest": {
+    // Docker Environment Variables:
+    // - IpLeakTest__Enabled: false (set to true to enable)
+    "Enabled": false
   }
 }

UmlautAdaptarr/secrets_example.json

@@ -1,11 +0,0 @@
-{
-  "SONARR_ENABLED": false,
-  "SONARR_HOST": "http://localhost:8989",
-  "SONARR_API_KEY": "",
-  "LIDARR_ENABLED": false,
-  "LIDARR_HOST": "http://localhost:8686",
-  "LIDARR_API_KEY": "",
-  "READARR_ENABLED": false,
-  "READARR_HOST": "http://localhost:8787",
-  "READARR_API_KEY": ""
-}

build_linux.bat

@@ -0,0 +1,4 @@
+@echo off
+dotnet publish -c Release -r linux-x64 --self-contained
+'dotnet publish -c Release -r linux-x64 --self-contained -p:PublishSingleFile=true -p:IncludeAllContentForSelfExtract=true
+pause

docker-compose.yml

@@ -6,19 +6,37 @@ services:
     build: https://github.com/PCJones/UmlautAdaptarr.git#master
     image: umlautadaptarr
     restart: unless-stopped
+    ports:
+      - "5005:5005" # can be removed if you use the recommended prowlarr+proxy configuration 
+      - "5006:5006" # can be removed if you use the alternative, non-proxy configuration
     environment:
       - TZ=Europe/Berlin
-      - SONARR_ENABLED=false
+      - SONARR__ENABLED=false
-      - SONARR_HOST=http://localhost:8989
+      - SONARR__HOST=http://localhost:8989
-      - SONARR_API_KEY=API_KEY
+      - SONARR__APIKEY=APIKEY
-      - RADARR_ENABLED=false
+      - RADARR__ENABLED=false
-      - RADARR_HOST=http://localhost:7878
+      - RADARR__HOST=http://localhost:7878
-      - RADARR_API_KEY=API_KEY
+      - RADARR__APIKEY=APIKEY
-      - READARR_ENABLED=false
+      - READARR__ENABLED=false
-      - READARR_HOST=http://localhost:8787
+      - READARR__HOST=http://localhost:8787
-      - READARR_API_KEY=API_KEY
+      - READARR__APIKEY=APIKEY
-      - LIDARR_ENABLED=false
+      - LIDARR__ENABLED=false
-      - LIDARR_HOST=http://localhost:8686
+      - LIDARR__HOST=http://localhost:8686
-      - LIDARR_API_KEY=API_KEY
+      - LIDARR__APIKEY=APIKEY
-    ports:
+      ### example for multiple instances of same type
-      - "5005":"5005"
+      #- SONARR__0__NAME=NAME 1 (optional)
+      #- SONARR__0__ENABLED=false
+      #- SONARR__0__HOST=http://localhost:8989
+      #- SONARR__0__APIKEY=APIKEY
+      #- SONARR__1__NAME=NAME 2 (optional)
+      #- SONARR__1__ENABLED=false
+      #- SONARR__1__HOST=http://localhost:8989
+      #- SONARR__1__APIKEY=APIKEY
+
+      ### Advanced options (with default values))
+      #- SETTINGS__EnableChangedTitleCache=false # Enables the changed title API under /titlelookup?changedTitle=$title - enable if you are using crowdnfo.net post processing script.
+      #- SETTINGS__IndexerRequestsCacheDurationInMinutes=12 # How long to cache indexer requests for. Default is 12 minutes.
+      #- SETTINGS__ApiKey= # API key for requests to the UmlautAdaptarr. Optional, probably only needed for seedboxes.
+      #- SETTINGS__ProxyPort=5006 # Proxy port for the internal UmlautAdaptarr proxy used for Prowlarr.
+      #- Kestrel__Endpoints__Http__Url=http://[::]:5005 # HTTP port for the UmlautAdaptarr
+      #- IpLeakTest__Enabled=false

run_on_seedbox.sh

@@ -0,0 +1,53 @@
+#!/bin/bash
+
+# Download linux binary from https://github.com/PCJones/UmlautAdaptarr/releases
+
+# script by schumi4 - THX!
+
+#seedbox fix
+export DOTNET_GCHeapHardLimit=20000000
+
+# Basic Configuration
+export TZ=Europe/Berlin
+
+# Sonarr Configuration
+export SONARR__ENABLED=true
+export SONARR__HOST=https://name.server.usbx.me/sonarr/
+export SONARR__APIKEY=APIKEY
+
+# Radarr Configuration
+export RADARR__ENABLED=false
+export RADARR__HOST=http://localhost:7878
+export RADARR__APIKEY=APIKEY
+
+# Readarr Configuration
+export READARR__ENABLED=false
+export READARR__HOST=http://localhost:8787
+export READARR__APIKEY=APIKEY
+
+# Lidarr Configuration
+export LIDARR__ENABLED=false
+export LIDARR__HOST=http://localhost:8686
+export LIDARR__APIKEY=APIKEY
+
+# Multiple Sonarr Instances (commented out by default)
+#export SONARR__0__NAME="NAME 1"
+#export SONARR__0__ENABLED=false
+#export SONARR__0__HOST=http://localhost:8989
+#export SONARR__0__APIKEY=APIKEY
+#export SONARR__1__NAME="NAME 2"
+#export SONARR__1__ENABLED=false
+#export SONARR__1__HOST=http://localhost:8989
+#export SONARR__1__APIKEY=APIKEY
+
+# Advanced Options
+#export IpLeakTest__Enabled=false
+#export SETTINGS__IndexerRequestsCacheDurationInMinutes=12
+export ASPNETCORE_CONTENTROOT="./publish"
+export SETTINGS__ApiKey="apikey" # Change to something unique! Then in Prowlarr, in the proxy settings set any username and use this ApiKey as password.
+export SETTINGS__ProxyPort=1234 # Port for Proxy
+export Kestrel__Endpoints__Http__Url="http://[::]:1235" # Port for UmlautAdaptarr API
+
+chmod +x ./publish/UmlautAdaptarr
+
+./publish/UmlautAdaptarr