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,22 +1,22 @@
 # UmlautAdaptarr
 
-## English description coming soon
+ A tool to work around Sonarr, Radarr, Lidarr and Readarrs problems with foreign languages.
+
+## Detailed English description coming soon
 
 ## Beschreibung
-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, Readarr und Lidarr schon Auswirkungen (abgesehen vom Caching).
 
 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?
 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, dass die Arrs sie einwandfrei erkennen.
-Einige Beispiele finden sich [weiter unten](https://github.com/PCJones/UmlautAdaptarr/edit/develop/README.md#beispiel-funktionalit%C3%A4t).
+Einige Beispiele finden sich [weiter unten](https://github.com/PCJones/UmlautAdaptarr?tab=readme-ov-file#beispiel-funktionalit%C3%A4t).
 
 
 ## Features
@@ -30,27 +30,31 @@ Einige Beispiele finden sich [weiter unten](https://github.com/PCJones/UmlautAda
 | 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 12 Minuten zur Reduzierung der API-Zugriffe   | ✓             |
+| Anfragen-Caching für 12 Minuten zur Reduzierung der API-Zugriff   |✓              |
 | Usenet (newznab) Support                                          |✓              |
 | Torrent (torznab) Support                                         |✓              |
-| Radarr Support                                                    | Geplant       |
+| Support von mehreren *arr-Instanzen des gleichen Typs (z.B. 2x Sonarr)|✓          |             
-| Prowlarr Unterstützung für "DE" SceneNZBs Kategorien              | Geplant       |
+| 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
-Momentan ist Docker dafür nötig, wer kein Docker nutzt muss sich noch etwas gedulden. Eine Unraid-App gibt es auch, einfach nach `umlautadaptarr` suchen.
+- [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)
 
-[Link zum Docker Image](https://hub.docker.com/r/pcjones/umlautadaptarr)
+Nicht benötigte Umgebungsvariablen, z.B. falls Readarr oder Lidarr nicht genutzt werden, können entfernt werden.
-
-Nicht benötigte Umgebungsvariablen, z.B. wenn Readarr oder Lidarr nicht benötigt 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) In Prowlarr: Settings>Indexers bzw. Einstellungen>Indexer öffnen
+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) Lege einen neuen HTTP-Proxy an:
+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)
 
@@ -59,19 +63,20 @@ Das ist die **empfohlene** Methode um den UmlautAdaptarr einzurichten. Sie hat d
 - 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.
-3) Gehe zur Indexer-Übersichtsseite
+4) Gehe zur Indexer-Übersichtsseite
-4) Für alle Indexer/Tracker, die den UmlautAdaptarr nutzen sollen:
+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).
-5) 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.
+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.
 
-Dafür musst du einfach nur alle Indexer, bei denen der UmlautAdaptarr greifen soll, bearbeiten:
+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:
 
@@ -116,11 +121,13 @@ 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
-PayPal: https://paypal.me/pcjones1
+
+<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!
 
@@ -128,3 +135,7 @@ Für andere Spendenmöglichkeiten gerne auf Discord oder Telegram melden - danke
 - 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,19 +1,30 @@
 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(ProxyRequestService proxyRequestService) : ControllerBase
+    public class CapsController(ProxyRequestService proxyRequestService, IOptions<GlobalOptions> options, ILogger<CapsController> logger) : ControllerBase
     {
         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.");
             }

UmlautAdaptarr/Controllers/SearchController.cs

@@ -1,30 +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(ProxyRequestService proxyRequestService, TitleMatchingService titleMatchingService) : ControllerBase
+    public abstract class SearchControllerBase(ProxyRequestService proxyRequestService, TitleMatchingService titleMatchingService, IOptions<GlobalOptions> options, ILogger<SearchControllerBase> logger) : ControllerBase
     {
         // 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;
                 }
@@ -50,6 +56,8 @@ 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);
 
@@ -109,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,
@@ -150,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(ProxyRequestService proxyRequestService,
                                   TitleMatchingService titleMatchingService,
-                                  SearchItemLookupService searchItemLookupService) : SearchControllerBase(proxyRequestService, 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,
@@ -198,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));
@@ -229,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

@@ -108,6 +108,20 @@ 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)
             {
@@ -152,7 +166,7 @@ namespace UmlautAdaptarr.Models
             }
         }
 
-        private IEnumerable<string> GenerateVariations(string? title, string mediaType)
+        private static IEnumerable<string> GenerateVariations(string? title, string mediaType)
         {
             if (title == null)
             {

UmlautAdaptarr/Options/ArrOptions/InstanceOptions/GlobalInstanceOptions.cs

@@ -1,15 +1,17 @@
-namespace UmlautAdaptarr.Options.ArrOptions
+namespace UmlautAdaptarr.Options.ArrOptions.InstanceOptions
 {
-    /// <summary>
+    public class GlobalInstanceOptions
-    /// Base Options for ARR applications
-    /// </summary>
-    public class ArrApplicationBaseOptions
     {
         /// <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>

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/ArrOptions/LidarrInstanceOptions.cs

@@ -1,9 +0,0 @@
-namespace UmlautAdaptarr.Options.ArrOptions
-{
-    /// <summary>
-    /// Lidarr Options
-    /// </summary>
-    public class LidarrInstanceOptions : ArrApplicationBaseOptions
-    {
-    }
-}

UmlautAdaptarr/Options/ArrOptions/ReadarrInstanceOptions.cs

@@ -1,9 +0,0 @@
-namespace UmlautAdaptarr.Options.ArrOptions
-{
-    /// <summary>
-    /// Readarr Options
-    /// </summary>
-    public class ReadarrInstanceOptions : ArrApplicationBaseOptions
-    {
-    }
-}

UmlautAdaptarr/Options/ArrOptions/SonarrInstanceOptions.cs

@@ -1,9 +0,0 @@
-namespace UmlautAdaptarr.Options.ArrOptions
-{
-    /// <summary>
-    /// Sonarr Options
-    /// </summary>
-    public class SonarrInstanceOptions : ArrApplicationBaseOptions
-    {
-    }
-}

UmlautAdaptarr/Options/GlobalOptions.cs

@@ -14,5 +14,25 @@
         /// 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/Options/Proxy.cs

@@ -1,27 +0,0 @@
-namespace UmlautAdaptarr.Options;
-
-/// <summary>
-///     Represents options for proxy configuration.
-/// </summary>
-public class Proxy
-{
-    /// <summary>
-    ///     Gets or sets a value indicating whether to use a proxy.
-    /// </summary>
-    public bool Enabled { get; set; }
-
-    /// <summary>
-    ///     Gets or sets the address of the proxy.
-    /// </summary>
-    public string? Address { get; set; }
-
-    /// <summary>
-    ///     Gets or sets the username for proxy authentication.
-    /// </summary>
-    public string? Username { get; set; }
-
-    /// <summary>
-    ///     Gets or sets the password for proxy authentication.
-    /// </summary>
-    public string? Password { get; set; }
-}

UmlautAdaptarr/Options/ProxyOptions.cs

@@ -1,32 +0,0 @@
-namespace UmlautAdaptarr.Options;
-
-/// <summary>
-///     Represents options for proxy configuration.
-/// </summary>
-public class ProxyOptions
-{
-    /// <summary>
-    ///     Gets or sets a value indicating whether to use a proxy.
-    /// </summary>
-    public bool Enabled { get; set; }
-
-    /// <summary>
-    ///     Gets or sets the address of the proxy.
-    /// </summary>
-    public string? Address { get; set; }
-
-    /// <summary>
-    ///     Gets or sets the username for proxy authentication.
-    /// </summary>
-    public string? Username { get; set; }
-
-    /// <summary>
-    ///     Gets or sets the password for proxy authentication.
-    /// </summary>
-    public string? Password { get; set; }
-
-    /// <summary>
-    ///     Bypass Local Ip Addresses , Proxy will ignore local Ip Addresses
-    /// </summary>
-    public bool BypassOnLocal { get; set; }
-}

UmlautAdaptarr/Program.cs

@@ -1,31 +1,37 @@
 using System.Net;
-using UmlautAdaptarr.Options;
+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
             };
 
-            var proxyOptions = configuration.GetSection("Proxy").Get<ProxyOptions>();
-            handler.ConfigureProxy(proxyOptions);
             return handler;
         });
 
@@ -35,66 +41,82 @@ internal class Program
             //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<SearchItemLookupService>();
         builder.Services.AddSingleton<TitleMatchingService>();
-        builder.AddSonarrSupport();
+        await builder.AddSonarrSupport();
-        builder.AddLidarrSupport();
+        await builder.AddLidarrSupport();
-        builder.AddReadarrSupport();
+        await builder.AddReadarrSupport();
         builder.Services.AddSingleton<CacheService>();
         builder.Services.AddSingleton<ProxyRequestService>();
+        builder.Services.AddSingleton<ArrApplicationFactory>();
+        builder.Services.AddHostedService<ArrSyncBackgroundService>();
         builder.Services.AddSingleton<IHostedService, HttpProxyService>();
 
         var app = builder.Build();
 
+        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/ArrClientFactory.cs

@@ -1,17 +0,0 @@
-namespace UmlautAdaptarr.Providers
-{
-    public static class ArrClientFactory
-    {
-        // TODO, still uses old IConfiguration
-        // TODO not used yet
-        public static IEnumerable<TClient> CreateClients<TClient>(
-            Func<string, TClient> constructor, IConfiguration configuration, string configKey) where TClient : ArrClientBase
-        {
-            var hosts = configuration.GetValue<string>(configKey)?.Split(',') ?? throw new ArgumentException($"{configKey} environment variable must be set if the app is enabled");
-            foreach (var host in hosts)
-            {
-                yield return constructor(host.Trim());
-            }
-        }
-    }
-}

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;
+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;
+    private readonly CacheService _cacheService;
+    private readonly IHttpClientFactory _clientFactory;
+    private readonly ILogger<LidarrClient> _logger;
+    private readonly string _mediaType = "audio";
+
+    public LidarrClient([ServiceKey] string instanceName,
         IHttpClientFactory clientFactory,
         CacheService cacheService,
-        IMemoryCache cache,
+        IMemoryCache cache, IOptionsMonitor<LidarrInstanceOptions> options,
-        ILogger<LidarrClient> logger, IOptions<LidarrInstanceOptions> options) : ArrClientBase()
+        ILogger<LidarrClient> logger)
     {
-        public LidarrInstanceOptions LidarrOptions { get; } = options.Value;
+        _clientFactory = clientFactory;
-        private readonly string _mediaType = "audio";
+        _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 = $"{LidarrOptions.Host}/api/v1/artist?apikey={LidarrOptions.ApiKey}";
+            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 = $"{LidarrOptions.Host}/api/v1/album?artistId={artistId}&apikey={LidarrOptions.ApiKey}";
+                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,64 +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;
+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;
+    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,
-        IOptions<ReadarrInstanceOptions> options,
+        IOptionsMonitor<ReadarrInstanceOptions> options,
-        ILogger<ReadarrClient> logger) : ArrClientBase()
+        ILogger<ReadarrClient> logger)
     {
+        _clientFactory = clientFactory;
+        _cacheService = cacheService;
+        _cache = cache;
+        _logger = logger;
+        InstanceName = instanceName;
+        Options = options.Get(InstanceName);
+        _logger.LogInformation($"Init ReadarrClient ({InstanceName})");
+    }
 
-        public ReadarrInstanceOptions ReadarrOptions { get; } = options.Value;
+    public ReadarrInstanceOptions Options { get; init; }
-        private readonly string _mediaType = "book";
 
     public override async Task<IEnumerable<SearchItem>> FetchAllItemsAsync()
     {
-            var httpClient = clientFactory.CreateClient();
+        var httpClient = _clientFactory.CreateClient();
         var items = new List<SearchItem>();
 
         try
         {
-                var readarrAuthorUrl = $"{ReadarrOptions.Host}/api/v1/author?apikey={ReadarrOptions.ApiKey}";
+            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 = $"{ReadarrOptions.Host}/api/v1/book?authorId={authorId}&apikey={ReadarrOptions.ApiKey}";
+                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)
                 {
@@ -75,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
@@ -89,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;
@@ -104,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)
         {
@@ -137,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;
@@ -165,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,53 +1,94 @@
 using Microsoft.Extensions.Options;
 using Newtonsoft.Json;
 using UmlautAdaptarr.Models;
-using UmlautAdaptarr.Options.ArrOptions;
+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;
+    private readonly ILogger<SonarrClient> _logger;
+
+    private readonly string _mediaType = "tv";
+    private readonly TitleApiService _titleService;
+
+
+    public SonarrClient([ServiceKey] string instanceName,
         IHttpClientFactory clientFactory,
         TitleApiService titleService,
-        IOptions<SonarrInstanceOptions> options,
+        IOptionsMonitor<SonarrInstanceOptions> options,
-        ILogger<SonarrClient> logger) : ArrClientBase()
+        ILogger<SonarrClient> logger)
     {
-        public SonarrInstanceOptions SonarrOptions { get; } = options.Value;
+        _clientFactory = clientFactory;
-        private readonly string _mediaType = "tv";
+        _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 = $"{SonarrOptions.Host}/api/v3/series?includeSeasonImages=false&apikey={SonarrOptions.ApiKey}";
+            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
                     );
@@ -56,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;
@@ -68,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 = $"{SonarrOptions.Host}/api/v3/series?tvdbId={externalId}&includeSeasonImages=false&apikey={SonarrOptions.ApiKey}";
+            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];
@@ -83,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.Title} 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;
@@ -113,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 = $"{SonarrOptions.Host}/api/v3/series?tvdbId={tvdbId}&includeSeasonImages=false&apikey={SonarrOptions.ApiKey}";
+            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.Title} 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,27 +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,
-        ILogger<ArrSyncBackgroundService> logger) : BackgroundService
+    ILogger<ArrSyncBackgroundService> logger)
+    : BackgroundService
 {
+    public ArrApplicationFactory ArrApplicationFactory { get; } = arrApplicationFactory;
+
+
     protected override async Task ExecuteAsync(CancellationToken stoppingToken)
     {
         logger.LogInformation("ArrSyncBackgroundService is starting.");
-            bool lastRunSuccess = true;
+        var lastRunSuccess = true;
 
         while (!stoppingToken.IsCancellationRequested)
         {
@@ -39,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);
                 }
             }
@@ -58,27 +54,34 @@ namespace UmlautAdaptarr.Services
         try
         {
             var success = true;
-                if (readarrClient.ReadarrOptions.Enabled)
+
-                {
+
-                    var syncSuccess = await FetchItemsFromReadarrAsync();
+            if (ArrApplicationFactory.SonarrInstances.Any())
-                    success = success && syncSuccess;
-                }
-                if (sonarrClient.SonarrOptions.Enabled)
             {
                 var syncSuccess = await FetchItemsFromSonarrAsync();
                 success = success && syncSuccess;
             }
-                if (lidarrClient.LidarrOptions.Enabled)
+
+            if (ArrApplicationFactory.ReadarrInstances.Any())
+            {
+                var syncSuccess = await FetchItemsFromReadarrAsync();
+                success = success && syncSuccess;
+            }
+
+            if (ArrApplicationFactory.ReadarrInstances.Any())
             {
                 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;
     }
 
@@ -86,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;
         }
@@ -94,6 +105,7 @@ namespace UmlautAdaptarr.Services
         {
             logger.LogError(ex, "An error occurred while updating search item from Sonarr.");
         }
+
         return false;
     }
 
@@ -101,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;
         }
@@ -109,6 +128,7 @@ namespace UmlautAdaptarr.Services
         {
             logger.LogError(ex, "An error occurred while updating search item from Lidarr.");
         }
+
         return false;
     }
 
@@ -116,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;
         }
@@ -124,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);
@@ -141,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)
         {
@@ -196,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

@@ -1,6 +1,8 @@
-using System.Net;
+using Microsoft.Extensions.Options;
+using System.Net;
 using System.Net.Sockets;
 using System.Text;
+using UmlautAdaptarr.Options;
 
 namespace UmlautAdaptarr.Services
 {
@@ -8,15 +10,18 @@ namespace UmlautAdaptarr.Services
     {
         private TcpListener _listener;
         private readonly ILogger<HttpProxyService> _logger;
-        private readonly int _proxyPort = 5006; // TODO move to appsettings.json
         private readonly IHttpClientFactory _clientFactory;
-        private HashSet<string> _knownHosts = [];
+        private readonly GlobalOptions _options;
-        private readonly object _hostsLock = new object();
+        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)
-        public HttpProxyService(ILogger<HttpProxyService> logger, IHttpClientFactory clientFactory)
         {
+            _options = options.Value;
             _logger = logger;
+            _configuration = configuration;
             _clientFactory = clientFactory;
             _knownHosts.Add("prowlarr.servarr.com");
         }
@@ -34,9 +39,27 @@ namespace UmlautAdaptarr.Services
         {
             using var clientStream = new NetworkStream(clientSocket, ownsSocket: true);
             var buffer = new byte[8192];
-            var bytesRead = await clientStream.ReadAsync(buffer, 0, buffer.Length);
+            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
@@ -49,6 +72,19 @@ namespace UmlautAdaptarr.Services
             }
         }
         
+        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);
@@ -91,7 +127,12 @@ namespace UmlautAdaptarr.Services
                     }
                 }
 
-                var modifiedUri = $"http://localhost:5005/_/{uri.Host}{uri.PathAndQuery}";  // TODO read port from appsettings?
+                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);
@@ -123,21 +164,21 @@ namespace UmlautAdaptarr.Services
         {
             var headers = new Dictionary<string, string>();
             var headerString = Encoding.ASCII.GetString(buffer, 0, length);
-            var lines = headerString.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
+            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.Substring(0, colonIndex).Trim();
+                    var key = line[..colonIndex].Trim();
-                    var value = line.Substring(colonIndex + 1).Trim();
+                    var value = line[(colonIndex + 1)..].Trim();
                     headers[key] = value;
                 }
             }
             return headers;
         }
 
-        private (string host, int port) ParseTargetInfo(string requestLine)
+        private static (string host, int port) ParseTargetInfo(string requestLine)
         {
             var parts = requestLine.Split(' ')[1].Split(':');
             return (parts[0], int.Parse(parts[1]));
@@ -150,7 +191,7 @@ namespace UmlautAdaptarr.Services
             await Task.WhenAll(clientToTargetTask, targetToClientTask);
         }
 
-        private async Task RelayStream(NetworkStream input, NetworkStream output)
+        private static async Task RelayStream(NetworkStream input, NetworkStream output)
         {
             byte[] buffer = new byte[8192];
             int bytesRead;
@@ -163,7 +204,7 @@ namespace UmlautAdaptarr.Services
 
         public Task StartAsync(CancellationToken cancellationToken)
         {
-            _listener = new TcpListener(IPAddress.Any, _proxyPort);
+            _listener = new TcpListener(IPAddress.Any, _options.ProxyPort);
             _listener.Start();
             Task.Run(() => HandleRequests(cancellationToken), cancellationToken);
             return Task.CompletedTask;

UmlautAdaptarr/Services/ProxyRequestService.cs

@@ -54,6 +54,7 @@ namespace UmlautAdaptarr.Services
             }
 
             await EnsureMinimumDelayAsync(targetUri);
+            var targetHost = new Uri(targetUri).Host;
 
             var requestMessage = new HttpRequestMessage
             {
@@ -81,14 +82,21 @@ namespace UmlautAdaptarr.Services
 
                 if (responseMessage.IsSuccessStatusCode)
                 {
-                    _cache.Set(targetUri, responseMessage, TimeSpan.FromMinutes(12));
+                    _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);
 
                 var errorResponse = new HttpResponseMessage(System.Net.HttpStatusCode.InternalServerError)
                 {
@@ -97,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,12 +1,11 @@
 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)
     {
         public async Task<SearchItem?> GetOrFetchSearchItemByExternalId(string mediaType, string externalId)
         {
@@ -22,24 +21,41 @@ namespace UmlautAdaptarr.Services
             switch (mediaType)
             {
                 case "tv":
-                    if (sonarrClient.SonarrOptions.Enabled)
+
+                    var sonarrInstances = arrApplicationFactory.SonarrInstances;
+
+                    if (sonarrInstances.Any())
+                    {
+                        foreach (var sonarrClient in sonarrInstances)
                         {
                             fetchedItem = await sonarrClient.FetchItemByExternalIdAsync(externalId);
                         }
+                    }
                     break;
                 case "audio":
-                    if (lidarrClient.LidarrOptions.Enabled)
+
+                    var lidarrInstances = arrApplicationFactory.LidarrInstances;
+
+                    if (lidarrInstances.Any())
+                    {
+                        foreach (var lidarrClient in lidarrInstances)
                         {
                             await lidarrClient.FetchItemByExternalIdAsync(externalId);
                             fetchedItem = cacheService.GetSearchItemByExternalId(mediaType, externalId);
                         }
+                    }
                     break;
                 case "book":
-                    if (readarrClient.ReadarrOptions.Enabled)
+
+                    var readarrInstances = arrApplicationFactory.ReadarrInstances;
+                    if (readarrInstances.Any())
+                    {
+                        foreach (var readarrClient in readarrInstances)
                         {
                             await readarrClient.FetchItemByExternalIdAsync(externalId);
                             fetchedItem = cacheService.GetSearchItemByExternalId(mediaType, externalId);
                         }
+                    }
                     break;
             }
 
@@ -66,7 +82,9 @@ namespace UmlautAdaptarr.Services
             switch (mediaType)
             {
                 case "tv":
-                    if (sonarrClient.SonarrOptions.Enabled)
+
+                    var sonarrInstances = arrApplicationFactory.SonarrInstances;
+                    foreach (var sonarrClient in sonarrInstances)
                     {
                         fetchedItem = await sonarrClient.FetchItemByTitleAsync(title);
                     }

UmlautAdaptarr/Services/TitleApiService.cs

@@ -1,6 +1,7 @@
 using Microsoft.Extensions.Options;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
+using System.Text;
 using UmlautAdaptarr.Options;
 using UmlautAdaptarr.Utilities;
 
@@ -22,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
@@ -68,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

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,16 +217,8 @@ 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) ? "" : suffix.StartsWith(separator) ? suffix : $"{separator}{suffix}");
@@ -226,13 +226,60 @@ namespace UmlautAdaptarr.Services
                     // 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;
                 }
             }
         }
 
+        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
@@ -262,23 +309,23 @@ namespace UmlautAdaptarr.Services
                 return null;
             }
 
-            if (category == "7000" || 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 == "2000" || category.StartsWith("Movies", StringComparison.OrdinalIgnoreCase))
+            else if (category == "2000" || category.StartsWith("Movies", StringComparison.OrdinalIgnoreCase) || category.StartsWith("Filme", StringComparison.OrdinalIgnoreCase))
             {
                 return "movies";
             }
-            else if (category == "5000" || category.StartsWith("TV", StringComparison.OrdinalIgnoreCase))
+            else if (category == "5000" || category.StartsWith("TV", StringComparison.OrdinalIgnoreCase) || category.StartsWith("Serien", StringComparison.OrdinalIgnoreCase))
             {
                 return "tv";
             }
-            else if (category == "3030" || 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 == "3000" || category.StartsWith("Audio"))
+            else if (category == "3000" || category.StartsWith("Audio", StringComparison.OrdinalIgnoreCase) || category.StartsWith("Musik", StringComparison.OrdinalIgnoreCase))
             {
                 return "audio";
             }

UmlautAdaptarr/UmlautAdaptarr.csproj

@@ -9,10 +9,13 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Options" Version="8.0.2" />
+    <PackageReference Include="FluentValidation.DependencyInjectionExtensions" Version="12.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="8.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/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/ProxyExtension.cs

@@ -1,53 +0,0 @@
-using System;
-using System.Net;
-using UmlautAdaptarr.Options;
-
-namespace UmlautAdaptarr.Utilities
-{
-    /// <summary>
-    /// Extension methods for configuring proxies.
-    /// </summary>
-    public static class ProxyExtension
-    {
-        /// <summary>
-        /// Logger instance for logging proxy configurations.
-        /// </summary>
-        private static ILogger Logger = GlobalStaticLogger.Logger;
-
-        /// <summary>
-        /// Configures the proxy settings for the provided HttpClientHandler instance.
-        /// </summary>
-        /// <param name="handler">The HttpClientHandler instance to configure.</param>
-        /// <param name="proxyOptions">ProxyOptions options to be used for configuration.</param>
-        /// <returns>The configured HttpClientHandler instance.</returns>
-        public static HttpClientHandler ConfigureProxy(this HttpClientHandler handler, ProxyOptions? proxyOptions)
-        {
-            try
-            {
-                if (proxyOptions != null && proxyOptions.Enabled)
-                {
-                    Logger.LogInformation("Use Proxy {0}", proxyOptions.Address);
-                    handler.UseProxy = true;
-                    handler.Proxy = new WebProxy(proxyOptions.Address, proxyOptions.BypassOnLocal);
-
-                    if (!string.IsNullOrEmpty(proxyOptions.Username) && !string.IsNullOrEmpty(proxyOptions.Password))
-                    {
-                        Logger.LogInformation("Use Proxy Credentials from User {0}", proxyOptions.Username);
-                        handler.DefaultProxyCredentials =
-                            new NetworkCredential(proxyOptions.Username, proxyOptions.Password);
-                    }
-                }
-                else
-                {
-                    Logger.LogDebug("No proxy was set");
-                }
-            }
-            catch (Exception ex)
-            {
-                Logger.LogError(ex, "Error occurred while configuring proxy, no Proxy will be used!");
-            }
-
-            return handler;
-        }
-    }
-}

UmlautAdaptarr/Utilities/ServicesExtensions.cs

@@ -1,16 +1,120 @@
-using UmlautAdaptarr.Options;
+using FluentValidation;
-using UmlautAdaptarr.Options.ArrOptions;
+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;
 
-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>
@@ -19,23 +123,18 @@ namespace UmlautAdaptarr.Utilities
     /// <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)
+    private static WebApplicationBuilder AddServiceWithOptions<TOptions, TService>(this WebApplicationBuilder builder,
+        string sectionName)
         where TOptions : class
         where TService : class
     {
-            if (builder.Services == null)
+        if (builder.Services == null) throw new ArgumentNullException(nameof(builder), "Service collection is null.");
-            {
-                throw new ArgumentNullException(nameof(builder), "Service collection is null.");
-            }
-
-            var options = builder.Configuration.GetSection(sectionName).Get<TOptions>();
-            if (options == null)
-            {
-                throw new InvalidOperationException($"{typeof(TService).Name} options could not be loaded from Configuration or ENV Variable.");
-            }
 
+        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;
     }
 
@@ -44,9 +143,10 @@ namespace UmlautAdaptarr.Utilities
     /// </summary>
     /// <param name="builder">The <see cref="WebApplicationBuilder" /> to configure the service collection.</param>
     /// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
-        public static WebApplicationBuilder AddSonarrSupport(this WebApplicationBuilder builder)
+    public static Task<WebApplicationBuilder> AddSonarrSupport(this WebApplicationBuilder builder)
     {
-            return builder.AddServiceWithOptions<SonarrInstanceOptions, SonarrClient>("Sonarr");
+        //  builder.Serviceses.AddSingleton<IOptionsMonitoSonarrInstanceOptionsns>, OptionsMonitoSonarrInstanceOptionsns>>();
+        return builder.AddServicesWithOptions<SonarrInstanceOptions, SonarrClient, IArrApplication>("Sonarr");
     }
 
     /// <summary>
@@ -54,9 +154,9 @@ namespace UmlautAdaptarr.Utilities
     /// </summary>
     /// <param name="builder">The <see cref="WebApplicationBuilder" /> to configure the service collection.</param>
     /// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
-        public static WebApplicationBuilder AddLidarrSupport(this WebApplicationBuilder builder)
+    public static Task<WebApplicationBuilder> AddLidarrSupport(this WebApplicationBuilder builder)
     {
-            return builder.AddServiceWithOptions<LidarrInstanceOptions, LidarrClient>("Lidarr");
+        return builder.AddServicesWithOptions<LidarrInstanceOptions, LidarrClient, IArrApplication>("Lidarr");
     }
 
     /// <summary>
@@ -64,9 +164,9 @@ namespace UmlautAdaptarr.Utilities
     /// </summary>
     /// <param name="builder">The <see cref="WebApplicationBuilder" /> to configure the service collection.</param>
     /// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
-        public static WebApplicationBuilder AddReadarrSupport(this WebApplicationBuilder builder)
+    public static Task<WebApplicationBuilder> AddReadarrSupport(this WebApplicationBuilder builder)
     {
-            return builder.AddServiceWithOptions<ReadarrInstanceOptions, ReadarrClient>("Readarr");
+        return builder.AddServicesWithOptions<ReadarrInstanceOptions, ReadarrClient, IArrApplication>("Readarr");
     }
 
     /// <summary>
@@ -89,4 +189,3 @@ namespace UmlautAdaptarr.Utilities
         return builder.AddServiceWithOptions<GlobalOptions, ProxyRequestService>("Settings");
     }
 }
-}

UmlautAdaptarr/Utilities/UrlUtilities.cs

@@ -5,7 +5,8 @@ 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)
         {

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

@@ -20,22 +20,42 @@
   // 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": {
+  "Sonarr": [
+    {
       // Docker Environment Variables:
-    // - Sonarr__Enabled: true (set to false to disable)
+      // - Sonarr__0__Enabled: true (set to false to disable)
-    // - Sonarr__Host: your_sonarr_host_url
+      // - Sonarr__0__Name: Name of the Instance (Optional)
-    // - Sonarr__ApiKey: your_sonarr_api_key
+      // - 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"
     },
-  "Lidarr": {
+    {
+      // 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"
@@ -49,18 +69,9 @@
     "Host": "your_readarr_host_url",
     "ApiKey": "your_readarr_api_key"
   },
-
+  "IpLeakTest": {
     // Docker Environment Variables:
-  // - Proxy__Enabled: true (set to false to disable)
+    // - IpLeakTest__Enabled: false (set to true to enable)
-  // - Proxy__Address: http://yourproxyaddress:port
+    "Enabled": false
-  // - Proxy__Username: your_proxy_username
-  // - Proxy__Password: your_proxy_password
-  // - Proxy__BypassOnLocal: true (set to false to not bypass local IP addresses)
-  "Proxy": {
-    "Enabled": false,
-    "Address": "http://yourproxyaddress:port",
-    "Username": "your_proxy_username",
-    "Password": "your_proxy_password",
-    "BypassOnLocal": true
   }
 }

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,6 +6,9 @@ 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
@@ -20,8 +23,20 @@ services:
       - LIDARR__ENABLED=false
       - LIDARR__HOST=http://localhost:8686
       - LIDARR__APIKEY=APIKEY
-      #- Proxy__Enabled: false
+      ### example for multiple instances of same type
-      #- Proxy__Address: http://yourproxyaddress:port
+      #- SONARR__0__NAME=NAME 1 (optional)
-      #- Proxy__Username: your_proxy_username
+      #- SONARR__0__ENABLED=false
-      #- Proxy__Password: your_proxy_password
+      #- SONARR__0__HOST=http://localhost:8989
-      #- Proxy__BypassOnLocal: true (set to false to not bypass local IP addresses)
+      #- 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