Merge pull request #12 from PCJones/develop

v0.4

README.md

@@ -5,7 +5,7 @@
 ## Erste Testversion
 Wer möchte kann den UmlautAdaptarr jetzt gerne testen! Über Feedback würde ich mich sehr freuen!
 
-Es sollte mit allen *arrs funktionieren, hat aber nur bei Sonarr und Lidarr schon Auswirkungen (abgesehen vom Caching).
+Es sollte mit allen *arrs funktionieren, hat aber nur bei Sonarr, Readarr und Lidarr schon Auswirkungen (abgesehen vom Caching).
 
 Momentan ist docker dafür nötig, wer kein Docker nutzt muss sich noch etwas gedulden. 
 
@@ -30,7 +30,7 @@ UmlautAdaptarr löst mehrere Probleme:
 
 # Wie macht UmlautAdaptarr das?
 UmlautAdaptarr tut so, als wäre es ein Indexer. In Wahrheit schaltet sich UmlautAdaptarr aber nur zwischen die *arrs und den echten Indexer und kann somit die Suchen sowie die Ergebnisse abfangen und bearbeiten.
-Am Ende werden die gefundenen Releases immer so umbenannt, das die Arrs sie einwandfrei erkennen.
+Am Ende werden die gefundenen Releases immer so umbenannt, dass die Arrs sie einwandfrei erkennen.
 Einige Beispiele findet ihr unter Features.
 
 
@@ -38,15 +38,17 @@ Einige Beispiele findet ihr unter Features.
 
 | Feature                                                           | Status        |
 |-------------------------------------------------------------------|---------------|
-| Prowlarr Support                                                    | ✓|
+| Prowlarr & NZB Hydra Support                                                    | ✓|
 | Sonarr Support                                         | ✓             |
 | Lidarr Support                                                    | ✓|
+| Readarr Support                                                   | ✓       |
 | Releases mit deutschem Titel werden erkannt   | ✓             |
 | Releases mit TVDB-Alias Titel werden erkannt  | ✓             |
 | Korrekte Suche und Erkennung von Titel mit Umlauten                            | ✓             |
 | Anfragen-Caching für 5 Minuten zur Reduzierung der API-Zugriffe   | ✓             |
+| Usenet (newznab) Support                                          |✓|
+| Torrent Support                                                   | Vorerst nicht geplant |
 | Radarr Support                                                    | Geplant       |
-| Readarr Support                                                   | Geplant       |
 | Prowlarr Unterstützung für "DE" SceneNZBs Kategorien              | Geplant       |
 | Unterstützung weiterer Sprachen neben Deutsch                     | Geplant       |
 | Wünsche?                                                          | Vorschläge?   |
@@ -85,9 +87,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
-- Reddit: /u/IreliaIsLife
+- Discord: pcjones1 - oder komm in den UsenetDE Discord Server: [https://discord.gg/pZrrMcJMQM](https://discord.gg/pZrrMcJMQM)
 
+## Spenden
+Über eine Spende freue ich mich natürlich immer :D
+PayPal: https://paypal.me/pcjones1
+
+Für andere Spendenmöglichkeiten gerne auf Discord oder Telegram melden - danke!
 
 ### Licenses & Metadata source
 - TV Metadata source: https://thetvdb.com

UmlautAdaptarr/Controllers/SearchController.cs

@@ -8,7 +8,8 @@ namespace UmlautAdaptarr.Controllers
 {
     public abstract class SearchControllerBase(ProxyService proxyService, TitleMatchingService titleMatchingService) : ControllerBase
     {
-        private readonly bool TODO_FORCE_TEXT_SEARCH_ORIGINAL_TITLE = false;
+        // TODO evaluate if this should be set to true by default
+        private readonly bool TODO_FORCE_TEXT_SEARCH_ORIGINAL_TITLE = true;
         private readonly bool TODO_FORCE_TEXT_SEARCH_GERMAN_TITLE = false;
         protected async Task<IActionResult> BaseSearch(string options,
                                                        string domain,
@@ -52,7 +53,7 @@ namespace UmlautAdaptarr.Controllers
 
                     var titleSearchVariations = new List<string>(searchItem?.TitleSearchVariations);
 
-                    string searchQuery = string.Empty;
+                    var searchQuery = string.Empty;
                     if (queryParameters.TryGetValue("q", out string? q))
                     {
                         searchQuery = q ?? string.Empty;
@@ -155,7 +156,8 @@ namespace UmlautAdaptarr.Controllers
                                   TitleMatchingService titleMatchingService,
                                   SearchItemLookupService searchItemLookupService) : SearchControllerBase(proxyService, titleMatchingService)
     {
-        public readonly string[] AUDIO_CATEGORY_IDS = ["3000", "3010", "3020", "3040", "3050"];
+        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)
@@ -180,8 +182,15 @@ namespace UmlautAdaptarr.Controllers
             {
                 if (queryParameters.TryGetValue("cat", out string? categories) && !string.IsNullOrEmpty(categories))
                 {
-                    // Search for audio
-                    if (categories.Split(',').Any(category => AUDIO_CATEGORY_IDS.Contains(category)))
+                    // look for (audio-)book
+                    if (categories.Split(',').Any(category => READARR_CATEGORY_IDS.Contains(category)))
+                    {
+                        var mediaType = "book";
+                        searchItem = await searchItemLookupService.GetOrFetchSearchItemByExternalId(mediaType, title.GetReadarrTitleForExternalId());
+                    }
+
+                    // look for audio (lidarr)
+                    if (searchItem == null && categories.Split(',').Any(category => LIDARR_CATEGORY_IDS.Contains(category)))
                     {
                         var mediaType = "audio";
                         searchItem = await searchItemLookupService.GetOrFetchSearchItemByExternalId(mediaType, title.GetLidarrTitleForExternalId());

UmlautAdaptarr/Models/SearchItem.cs

@@ -37,7 +37,87 @@ namespace UmlautAdaptarr.Models
             ExpectedAuthor = expectedAuthor;
             GermanTitle = germanTitle;
             MediaType = mediaType;
-            if (mediaType == "audio" && expectedAuthor != null)
+            if ((mediaType == "audio" || mediaType == "book") && expectedAuthor != null)
+            {
+                GenerateVariationsForBooksAndAudio(expectedTitle, mediaType, expectedAuthor);
+            }
+            else
+            {
+                // if mediatype is movie/tv and the Expected Title ends with a year but the german title doesn't then append the year to the german title and to aliases
+                // example: https://thetvdb.com/series/385925-avatar-the-last-airbender -> german Title is without 2024
+                var yearAtEndOfTitleMatch = YearAtEndOfTitleRegex().Match(expectedTitle);
+                if (yearAtEndOfTitleMatch.Success)
+                {
+                    string year = yearAtEndOfTitleMatch.Value[1..^1];
+                    if (GermanTitle != null && !GermanTitle.Contains(year))
+                    {
+                        GermanTitle = $"{germanTitle} {year}";
+                    }
+
+                    if (aliases != null)
+                    {
+                        for (int i = 0; i < aliases.Length; i++)
+                        {
+                            if (!aliases[i].Contains(year))
+                            {
+                                aliases[i] = $"{aliases[i]} {year}";
+                            }
+                        }
+                    }
+                }
+
+                GenerateVariationsForTV(GermanTitle, mediaType, aliases);
+            }
+        }
+
+        private void GenerateVariationsForTV(string? germanTitle, string mediaType, string[]? aliases)
+        {
+            TitleSearchVariations = GenerateVariations(germanTitle, mediaType).ToArray();
+
+            var allTitleVariations = new List<string>(TitleSearchVariations);
+
+            // If aliases are not null, generate variations for each and add them to the list
+            // TODO (not necessarily here) only use deu and eng alias
+            if (aliases != null)
+            {
+                foreach (var alias in aliases)
+                {
+                    allTitleVariations.AddRange(GenerateVariations(alias, mediaType));
+
+                    // If title contains ":" also match for "-"
+                    if (alias.Contains(':'))
+                    {
+                        allTitleVariations.Add(alias.Replace(":", " -"));
+                    }
+                }
+            }
+
+            AuthorMatchVariations = [];
+
+            // if a german title ends with (DE) also add a search string that replaces (DE) with GERMAN
+            // also add a matching title without (DE)
+            if (germanTitle?.EndsWith("(DE)") ?? false)
+            {
+                TitleSearchVariations = [.. TitleSearchVariations,
+                    ..
+                    GenerateVariations(
+                        germanTitle.Replace("(DE)", " GERMAN").RemoveExtraWhitespaces(),
+                    mediaType)];
+
+                allTitleVariations.AddRange(GenerateVariations(germanTitle.Replace("(DE)", "").Trim(), mediaType));
+
+            }
+
+            // If title contains ":" also match for "-"
+            if (germanTitle?.Contains(':') ?? false)
+            {
+                allTitleVariations.Add(germanTitle.Replace(":", " -"));
+            }
+
+            TitleMatchVariations = allTitleVariations.Distinct(StringComparer.InvariantCultureIgnoreCase).ToArray();
+        }
+
+        private void GenerateVariationsForBooksAndAudio(string expectedTitle, string mediaType, string? expectedAuthor)
         {
             // e.g. Die Ärzte - best of die Ärzte
             if (expectedTitle.Contains(expectedAuthor))
@@ -54,42 +134,22 @@ namespace UmlautAdaptarr.Models
             {
                 TitleMatchVariations = GenerateVariations(expectedTitle, mediaType).ToArray();
             }
+
             TitleSearchVariations = GenerateVariations($"{expectedAuthor} {expectedTitle}", mediaType).ToArray();
             AuthorMatchVariations = GenerateVariations(expectedAuthor, mediaType).ToArray();
-            }
-            else
+
+            if (mediaType == "book")
             {
-                TitleSearchVariations = GenerateVariations(germanTitle, mediaType).ToArray();
-
-                var allTitleVariations = new List<string>(TitleSearchVariations);
-
-                // If aliases are not null, generate variations for each and add them to the list
-                // TODO (not necessarily here) only use deu and eng alias
-                if (aliases != null)
+                if (expectedAuthor?.Contains(' ') ?? false)
                 {
-                    foreach (var alias in aliases)
-                    {
-                        allTitleVariations.AddRange(GenerateVariations(alias, mediaType));
+                    var nameParts = expectedAuthor.Split(' ', StringSplitOptions.RemoveEmptyEntries);
+                    var lastName = nameParts.Last();
+                    var firstNames = nameParts.Take(nameParts.Length - 1);
+
+                    var alternativeExpectedAuthor = $"{lastName}, {string.Join(" ", firstNames)}";
+                    AuthorMatchVariations = [.. AuthorMatchVariations, .. GenerateVariations(alternativeExpectedAuthor, mediaType)];
                 }
             }
-
-                AuthorMatchVariations = [];
-
-                // if a german title ends with (DE) also add a search string that replaces (DE) with GERMAN
-                // also add a matching title without (DE)
-                if (germanTitle?.EndsWith("(DE)") ?? false)
-                {
-                    TitleSearchVariations = [.. TitleSearchVariations, .. 
-                        GenerateVariations(
-                            germanTitle.Replace("(DE)", " GERMAN").RemoveExtraWhitespaces(),
-                        mediaType)];
-
-                    allTitleVariations.AddRange(GenerateVariations(germanTitle.Replace("(DE)", "").Trim(), mediaType));
-
-                }
-
-                TitleMatchVariations = allTitleVariations.Distinct(StringComparer.InvariantCultureIgnoreCase).ToArray();
-            }
         }
 
         private IEnumerable<string> GenerateVariations(string? title, string mediaType)
@@ -98,6 +158,7 @@ namespace UmlautAdaptarr.Models
             {
                 return [];
             }
+
             var cleanTitle = title.GetCleanTitle();
 
             if (cleanTitle?.Length == 0)
@@ -113,6 +174,11 @@ namespace UmlautAdaptarr.Models
                     cleanTitle.RemoveGermanUmlautDots()
                 };
 
+            if (mediaType == "book" || mediaType == "audio")
+            {
+                baseVariations.Add(cleanTitle.RemoveGermanUmlauts());
+            }
+
             // TODO: determine if this is really needed
             // Additional variations to accommodate titles with "-"
             if (cleanTitle.Contains('-'))
@@ -142,6 +208,7 @@ namespace UmlautAdaptarr.Models
             } else if (cleanTitle.StartsWith("A "))
             {
                 var cleanTitleWithoutArticle = title[2..].Trim();
+                baseVariations.AddRange(GenerateVariations(cleanTitleWithoutArticle, mediaType));
             }
 
             // Remove multiple spaces
@@ -149,5 +216,8 @@ namespace UmlautAdaptarr.Models
 
             return cleanedVariations.Distinct();
         }
+
+        [GeneratedRegex(@"\(\d{4}\)$")]
+        private static partial Regex YearAtEndOfTitleRegex();
     }
 }

UmlautAdaptarr/Program.cs

@@ -51,6 +51,7 @@ internal class Program
         builder.Services.AddSingleton<TitleMatchingService>();
         builder.Services.AddSingleton<SonarrClient>();
         builder.Services.AddSingleton<LidarrClient>();
+        builder.Services.AddSingleton<ReadarrClient>();
         builder.Services.AddSingleton<CacheService>();
         builder.Services.AddSingleton<ProxyService>();
 

UmlautAdaptarr/Providers/LidarrClient.cs

@@ -42,6 +42,7 @@ namespace UmlautAdaptarr.Providers
 
                     var lidarrAlbumUrl = $"{_lidarrHost}/api/v1/album?artistId={artistId}&apikey={_lidarrApiKey}";
 
+                    // 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
                     //if (cache.TryGetValue(lidarrAlbumUrl, out List<dynamic>? albums))
                     //{
@@ -49,7 +50,7 @@ namespace UmlautAdaptarr.Providers
                     //}
                     //else
                     //{
-                    logger.LogInformation($"Fetching all albums from artistId {artistId} from Lidarr: {UrlUtilities.RedactApiKey(lidarrArtistsUrl)}");
+                    logger.LogInformation($"Fetching all albums from artistId {artistId} from Lidarr: {UrlUtilities.RedactApiKey(lidarrAlbumUrl)}");
                     var albumApiResponse = await httpClient.GetStringAsync(lidarrAlbumUrl);
                     var albums = JsonConvert.DeserializeObject<List<dynamic>>(albumApiResponse);
                     //}
@@ -108,6 +109,7 @@ namespace UmlautAdaptarr.Providers
             try
             {
                 // For now we have to fetch all items every time
+                // TODO if possible look at the author in search query and only update for author
                 var searchItems = await FetchAllItemsAsync();
                 foreach (var searchItem in searchItems ?? [])
                 {

UmlautAdaptarr/Providers/ReadarrClient.cs

@@ -0,0 +1,172 @@
+using Microsoft.Extensions.Caching.Memory;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using UmlautAdaptarr.Models;
+using UmlautAdaptarr.Services;
+using UmlautAdaptarr.Utilities;
+
+namespace UmlautAdaptarr.Providers
+{
+    public class ReadarrClient(
+        IHttpClientFactory clientFactory,
+        IConfiguration configuration,
+        CacheService cacheService,
+        IMemoryCache cache,
+        ILogger<ReadarrClient> logger) : ArrClientBase()
+    {
+        private readonly string _readarrHost = configuration.GetValue<string>("READARR_HOST") ?? throw new ArgumentException("READARR_HOST environment variable must be set");
+        private readonly string _readarrApiKey = configuration.GetValue<string>("READARR_API_KEY") ?? throw new ArgumentException("READARR_API_KEY environment variable must be set");
+        private readonly string _mediaType = "book";
+
+        public override async Task<IEnumerable<SearchItem>> FetchAllItemsAsync()
+        {
+            var httpClient = clientFactory.CreateClient();
+            var items = new List<SearchItem>();
+
+            try
+            {
+                var readarrAuthorUrl = $"{_readarrHost}/api/v1/author?apikey={_readarrApiKey}";
+                logger.LogInformation($"Fetching all authors from Readarr: {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");
+                    return items;
+                }
+                logger.LogInformation($"Successfully fetched {authors.Count} authors from Readarr.");
+                foreach (var author in authors)
+                {
+                    var authorId = (int)author.id;
+
+                    var readarrBookUrl = $"{_readarrHost}/api/v1/book?authorId={authorId}&apikey={_readarrApiKey}";
+
+                    // TODO add caching here
+                    logger.LogInformation($"Fetching all books from authorId {authorId} from Readarr: {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");
+                        continue;
+                    }
+
+                    logger.LogInformation($"Successfully fetched {books.Count} books for authorId {authorId} from Readarr.");
+
+                    // Cache books for 3 minutes
+                    cache.Set(readarrBookUrl, books, TimeSpan.FromMinutes(3));
+
+                    foreach (var book in books)
+                    {
+                        var authorName = (string)author.authorName;
+                        var bookTitle = GetSearchBookTitle((string)book.title, authorName);
+
+                        var expectedTitle = $"{bookTitle} {authorName}";
+
+                        string[]? aliases = null;
+
+                        // Abuse externalId to set the search string Readarr uses
+                        // TODO use own method or rename
+                        var externalId = expectedTitle.GetReadarrTitleForExternalId();
+
+                        var searchItem = new SearchItem
+                        (
+                            arrId: authorId,
+                            externalId: externalId,
+                            title: bookTitle,
+                            expectedTitle: bookTitle,
+                            germanTitle: null,
+                            aliases: aliases,
+                            mediaType: _mediaType,
+                            expectedAuthor: authorName
+                        );
+
+                        items.Add(searchItem);
+                    }
+                }
+
+                logger.LogInformation($"Finished fetching all items from Readarr");
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"Error fetching all authors from Readarr: {ex.Message}");
+            }
+
+            return items;
+        }
+
+        // Logic based on https://github.com/Readarr/Readarr/blob/develop/src/NzbDrone.Core/Parser/Parser.cs#L541
+        public static string GetSearchBookTitle(string bookTitle, string authorName)
+        {
+            // 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('(');
+            int firstColonIndex = bookTitle.IndexOf(':');
+
+            if (firstParenthesisIndex > -1)
+            {
+                int endParenthesisIndex = bookTitle.IndexOf(')', firstParenthesisIndex);
+                if (endParenthesisIndex > -1 && bookTitle.Substring(firstParenthesisIndex + 1, endParenthesisIndex - firstParenthesisIndex - 1).Contains(' '))
+                {
+                    bookTitle = bookTitle[..firstParenthesisIndex].Trim();
+                }
+            }
+            else if (firstColonIndex > -1)
+            {
+                bookTitle = bookTitle[..firstColonIndex].Trim();
+            }
+
+            return bookTitle;
+        }
+
+
+        public override async Task<SearchItem?> FetchItemByExternalIdAsync(string externalId)
+        {
+            try
+            {
+                // For now we have to fetch all items every time
+                // 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);
+                    }
+                    catch (Exception ex)
+                    {
+                        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}");
+            }
+
+            return null;
+        }
+
+        public override async Task<SearchItem?> FetchItemByTitleAsync(string title)
+        {
+            try
+            {
+                // this should never be called at the moment
+                throw new NotImplementedException();
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"Error fetching single author from Readarr: {ex.Message}");
+            }
+
+            return null;
+        }
+    }
+}

UmlautAdaptarr/Providers/SonarrClient.cs

@@ -22,7 +22,6 @@ namespace UmlautAdaptarr.Providers
 
             try
             {
-
                 var sonarrUrl = $"{_sonarrHost}/api/v3/series?includeSeasonImages=false&apikey={_sonarrApiKey}";
                 logger.LogInformation($"Fetching all items from Sonarr: {UrlUtilities.RedactApiKey(sonarrUrl)}");
                 var response = await httpClient.GetStringAsync(sonarrUrl);
@@ -99,7 +98,7 @@ namespace UmlautAdaptarr.Providers
                         mediaType: _mediaType
                     );
 
-                    logger.LogInformation($"Successfully fetched show {searchItem} from Sonarr.");
+                    logger.LogInformation($"Successfully fetched show {searchItem.Title} from Sonarr.");
                     return searchItem;
                 }
             }
@@ -157,7 +156,7 @@ namespace UmlautAdaptarr.Providers
                     mediaType: _mediaType
                 );
 
-                logger.LogInformation($"Successfully fetched show {searchItem} from Sonarr.");
+                logger.LogInformation($"Successfully fetched show {searchItem.Title} from Sonarr.");
                 return searchItem;
             }
             catch (Exception ex)

UmlautAdaptarr/Services/ArrSyncBackgroundService.cs

@@ -14,15 +14,18 @@ namespace UmlautAdaptarr.Services
     public class ArrSyncBackgroundService(
         SonarrClient sonarrClient,
         LidarrClient lidarrClient,
+        ReadarrClient readarrClient,
         CacheService cacheService,
         IConfiguration configuration,
         ILogger<ArrSyncBackgroundService> logger) : BackgroundService
     {
         private readonly bool _sonarrEnabled = configuration.GetValue<bool>("SONARR_ENABLED");
         private readonly bool _lidarrEnabled = configuration.GetValue<bool>("LIDARR_ENABLED");
+        private readonly bool _readarrEnabled = configuration.GetValue<bool>("READARR_ENABLED");
         protected override async Task ExecuteAsync(CancellationToken stoppingToken)
         {
             logger.LogInformation("ArrSyncBackgroundService is starting.");
+            bool lastRunSuccess = true;
 
             while (!stoppingToken.IsCancellationRequested)
             {
@@ -32,14 +35,24 @@ namespace UmlautAdaptarr.Services
 
                 if (syncSuccess)
                 {
+                    lastRunSuccess = true;
                     await Task.Delay(TimeSpan.FromHours(12), stoppingToken);
                 }
                 else
                 {
-                    logger.LogInformation("ArrSyncBackgroundService is sleeping for one hour only because not all syncs were successful.");
+                    if (lastRunSuccess)
+                    {
+                        lastRunSuccess = false;
+                        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.");
                         await Task.Delay(TimeSpan.FromHours(1), stoppingToken);
                     }
                 }
+            }
 
             logger.LogInformation("ArrSyncBackgroundService is stopping.");
         }
@@ -49,13 +62,20 @@ namespace UmlautAdaptarr.Services
             try
             {
                 var success = true;
+                if (_readarrEnabled)
+                {
+                    var syncSuccess = await FetchItemsFromReadarrAsync();
+                    success = success && syncSuccess;
+                }
                 if (_sonarrEnabled)
                 {
-                    success = await FetchItemsFromSonarrAsync();
+                    var syncSuccess = await FetchItemsFromSonarrAsync();
+                    success = success && syncSuccess;
                 }
                 if (_lidarrEnabled)
                 {
-                    success = await FetchItemsFromLidarrAsync();
+                    var syncSuccess = await FetchItemsFromLidarrAsync();
+                    success = success && syncSuccess;
                 }
                 return success;
             }
@@ -96,6 +116,21 @@ namespace UmlautAdaptarr.Services
             return false;
         }
 
+        private async Task<bool> FetchItemsFromReadarrAsync()
+        {
+            try
+            {
+                var items = await readarrClient.FetchAllItemsAsync();
+                UpdateSearchItems(items);
+                return items?.Any() ?? false;
+            }
+            catch (Exception ex)
+            {
+                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 ?? [])

UmlautAdaptarr/Services/CacheService.cs

@@ -10,6 +10,7 @@ namespace UmlautAdaptarr.Services
     public partial class CacheService(IMemoryCache cache)
     {
         private readonly Dictionary<string, HashSet<string>> VariationIndex = [];
+        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;
 
@@ -23,6 +24,11 @@ namespace UmlautAdaptarr.Services
                 CacheAudioSearchItem(item, cacheKey);
                 return;
             }
+            else if (item.MediaType == "book")
+            {
+                    CacheBookSearchItem(item, cacheKey);
+                    return;
+            }
 
             var normalizedTitle = item.Title.RemoveAccentButKeepGermanUmlauts().ToLower();
 
@@ -61,13 +67,30 @@ namespace UmlautAdaptarr.Services
             }
         }
 
+        public void CacheBookSearchItem(SearchItem item, string cacheKey)
+        {
+            // Index author and title variations
+            foreach (var authorVariation in item.AuthorMatchVariations)
+            {
+                var normalizedAuthor = authorVariation.NormalizeForComparison();
+
+                if (!BookVariationIndex.ContainsKey(normalizedAuthor))
+                {
+                    BookVariationIndex[normalizedAuthor] = [];
+                }
+
+                var titleVariations = item.TitleMatchVariations.Select(titleMatchVariation => titleMatchVariation.NormalizeForComparison()).ToHashSet();
+                BookVariationIndex[normalizedAuthor].Add((titleVariations, cacheKey));
+            }
+        }
+
         public SearchItem? SearchItemByTitle(string mediaType, string title)
         {
             var normalizedTitle = title.RemoveAccentButKeepGermanUmlauts().ToLower();
 
-            if (mediaType == "audio")
+            if (mediaType == "audio" || mediaType == "book")
             {
-                return FindBestMatchForAudio(normalizedTitle.NormalizeForComparison());
+                return FindBestMatchForBooksAndAudio(normalizedTitle.NormalizeForComparison(), mediaType);
             }
 
             // Use the first few characters of the normalized title for cache prefix search
@@ -126,9 +149,11 @@ namespace UmlautAdaptarr.Services
             return item;
         }
 
-        private SearchItem? FindBestMatchForAudio(string normalizedOriginalTitle)
+        private SearchItem? FindBestMatchForBooksAndAudio(string normalizedOriginalTitle, string mediaType)
         {
-            foreach (var authorEntry in AudioVariationIndex)
+            var index = mediaType == "audio" ? AudioVariationIndex : BookVariationIndex;
+            
+            foreach (var authorEntry in index)
             {
                 if (normalizedOriginalTitle.Contains(authorEntry.Key))
                 {

UmlautAdaptarr/Services/ProxyService.cs

@@ -20,6 +20,20 @@ namespace UmlautAdaptarr.Services
             _cache = cache;
         }
 
+        private static async Task EnsureMinimumDelayAsync(string targetUri)
+        {
+            var host = new Uri(targetUri).Host;
+            if (_lastRequestTimes.TryGetValue(host, out var lastRequestTime))
+            {
+                var timeSinceLastRequest = DateTimeOffset.Now - lastRequestTime;
+                if (timeSinceLastRequest < TimeSpan.FromMilliseconds(1500))
+                {
+                    await Task.Delay(TimeSpan.FromMilliseconds(1500) - timeSinceLastRequest);
+                }
+            }
+            _lastRequestTimes[host] = DateTimeOffset.Now;
+        }
+
         public async Task<HttpResponseMessage> ProxyRequestAsync(HttpContext context, string targetUri)
         {
             if (!HttpMethods.IsGet(context.Request.Method))
@@ -27,18 +41,6 @@ namespace UmlautAdaptarr.Services
                 throw new ArgumentException("Only GET requests are supported", context.Request.Method);
             }
 
-            // Throttling mechanism
-            var host = new Uri(targetUri).Host;
-            if (_lastRequestTimes.TryGetValue(host, out var lastRequestTime))
-            {
-                var timeSinceLastRequest = DateTimeOffset.Now - lastRequestTime;
-                if (timeSinceLastRequest < TimeSpan.FromSeconds(3))
-                {
-                    await Task.Delay(TimeSpan.FromSeconds(3) - timeSinceLastRequest);
-                }
-            }
-            _lastRequestTimes[host] = DateTimeOffset.Now;
-
             // Check cache
             if (_cache.TryGetValue(targetUri, out HttpResponseMessage cachedResponse))
             {
@@ -46,6 +48,8 @@ namespace UmlautAdaptarr.Services
                 return cachedResponse!;
             }
 
+            await EnsureMinimumDelayAsync(targetUri);
+
             var requestMessage = new HttpRequestMessage
             {
                 RequestUri = new Uri(targetUri),

UmlautAdaptarr/Services/SearchItemLookupService.cs

@@ -3,10 +3,15 @@ using UmlautAdaptarr.Providers;
 
 namespace UmlautAdaptarr.Services
 {
-    public class SearchItemLookupService(CacheService cacheService, SonarrClient sonarrClient, LidarrClient lidarrClient, IConfiguration configuration)
+    public class SearchItemLookupService(CacheService cacheService,
+                                         SonarrClient sonarrClient,
+                                         ReadarrClient readarrClient,
+                                         LidarrClient lidarrClient,
+                                         IConfiguration configuration)
     {
         private readonly bool _sonarrEnabled = configuration.GetValue<bool>("SONARR_ENABLED");
         private readonly bool _lidarrEnabled = configuration.GetValue<bool>("LIDARR_ENABLED");
+        private readonly bool _readarrEnabled = configuration.GetValue<bool>("READARR_ENABLED");
         public async Task<SearchItem?> GetOrFetchSearchItemByExternalId(string mediaType, string externalId)
         {
             // Attempt to get the item from the cache first
@@ -30,6 +35,14 @@ namespace UmlautAdaptarr.Services
                     if (_lidarrEnabled)
                     {
                         fetchedItem = await lidarrClient.FetchItemByExternalIdAsync(externalId);
+                        fetchedItem = cacheService.GetSearchItemByExternalId(mediaType, externalId);
+                    }
+                    break;
+                case "book":
+                    if (_readarrEnabled)
+                    {
+                        await readarrClient.FetchItemByExternalIdAsync(externalId);
+                        fetchedItem = cacheService.GetSearchItemByExternalId(mediaType, externalId);
                     }
                     break;
             }
@@ -64,6 +77,8 @@ namespace UmlautAdaptarr.Services
                     break;
                 case "audio":
                     break;
+                case "book":
+                    break;
                     // TODO add cases for other sources as needed, such as Radarr, Lidarr, etc.
             }
 

UmlautAdaptarr/Services/TitleApiService.cs

@@ -1,5 +1,6 @@
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
+using UmlautAdaptarr.Utilities;
 
 namespace UmlautAdaptarr.Services
 {
@@ -12,13 +13,14 @@ namespace UmlautAdaptarr.Services
         private async Task EnsureMinimumDelayAsync()
         {
             var sinceLastRequest = DateTime.Now - lastRequestTime;
-            if (sinceLastRequest < TimeSpan.FromSeconds(2))
+            if (sinceLastRequest < TimeSpan.FromSeconds(1))
             {
-                await Task.Delay(TimeSpan.FromSeconds(2) - sinceLastRequest);
+                await Task.Delay(TimeSpan.FromSeconds(1) - sinceLastRequest);
             }
             lastRequestTime = DateTime.Now;
         }
 
+        // TODO add cache, TODO add bulk request
         public async Task<(string? germanTitle, string[]? aliases)> FetchGermanTitleAndAliasesByExternalIdAsync(string mediaType, string externalId)
         {
             try
@@ -27,6 +29,7 @@ namespace UmlautAdaptarr.Services
 
                 var httpClient = clientFactory.CreateClient();
                 var titleApiUrl = $"{_umlautAdaptarrApiHost}/tvshow_german.php?tvdbid={externalId}";
+                logger.LogInformation($"TitleApiService GET {UrlUtilities.RedactApiKey(titleApiUrl)}");
                 var response = await httpClient.GetStringAsync(titleApiUrl);
                 var titleApiResponseData = JsonConvert.DeserializeObject<dynamic>(response);
 
@@ -72,6 +75,7 @@ namespace UmlautAdaptarr.Services
                 var httpClient = clientFactory.CreateClient();
                 var tvdbCleanTitle = title.Replace("ß", "ss");
                 var titleApiUrl = $"{_umlautAdaptarrApiHost}/tvshow_german.php?title={tvdbCleanTitle}";
+                logger.LogInformation($"TitleApiService GET {UrlUtilities.RedactApiKey(titleApiUrl)}");
                 var titleApiResponse = await httpClient.GetStringAsync(titleApiUrl);
                 var titleApiResponseData = JsonConvert.DeserializeObject<dynamic>(titleApiResponse);
 

UmlautAdaptarr/Services/TitleMatchingService.cs

@@ -52,7 +52,10 @@ namespace UmlautAdaptarr.Services
                             FindAndReplaceForMoviesAndTV(logger, searchItem, titleElement, originalTitle, cleanTitleSeperatedBySpace!);
                             break;
                         case "audio":
-                            FindAndReplaceForAudio(searchItem, titleElement, originalTitle!);
+                            FindAndReplaceForBooksAndAudio(searchItem, titleElement, originalTitle!);
+                            break;
+                        case "book":
+                            FindAndReplaceForBooksAndAudio(searchItem, titleElement, originalTitle!);
                             break;
                         default:
                             throw new NotImplementedException();
@@ -63,7 +66,7 @@ namespace UmlautAdaptarr.Services
             return xDoc.ToString();
         }
 
-        public void FindAndReplaceForAudio(SearchItem searchItem, XElement? titleElement, string originalTitle)
+        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);
@@ -83,7 +86,11 @@ namespace UmlautAdaptarr.Services
                 string suffix = originalTitle[matchEndPositionInOriginal..].TrimStart([' ', '-', '_', '.']).Trim();
 
                 // Concatenate the expected title with the remaining suffix
-                var updatedTitle = $"{searchItem.ExpectedAuthor} - {searchItem.ExpectedTitle}-[{suffix}]";
+                var updatedTitle = $"{searchItem.ExpectedAuthor} - {searchItem.ExpectedTitle}";
+                if (suffix.Length >= 3)
+                {
+                    updatedTitle += $"-[{suffix}]";
+                }
 
                 // Update the title element
                 titleElement.Value = updatedTitle;
@@ -91,7 +98,7 @@ namespace UmlautAdaptarr.Services
             }
             else
             {
-                logger.LogInformation("TitleMatchingService - No satisfactory fuzzy match found for both author and title.");
+                logger.LogDebug($"TitleMatchingService - No satisfactory fuzzy match found for both author and title for {originalTitle}.");
             }
         }
 
@@ -214,7 +221,7 @@ namespace UmlautAdaptarr.Services
                     */
 
                     // Construct the new title with the original suffix
-                    var newTitle = newTitlePrefix + (string.IsNullOrEmpty(suffix) ? "" : separator + suffix);
+                    var newTitle = newTitlePrefix + (string.IsNullOrEmpty(suffix) ? "" : suffix.StartsWith(separator) ? suffix : $"{separator}{suffix}");
 
                     // Update the title element's value with the new title
                     //titleElement.Value = newTitle + $"({originalTitle.Substring(0, variationLength)})";
@@ -255,23 +262,23 @@ namespace UmlautAdaptarr.Services
                 return null;
             }
 
-            if (category.StartsWith("EBook", StringComparison.OrdinalIgnoreCase) || category.StartsWith("Book", StringComparison.OrdinalIgnoreCase))
+            if (category == "7000" || category.StartsWith("EBook", StringComparison.OrdinalIgnoreCase) || category.StartsWith("Book", StringComparison.OrdinalIgnoreCase))
             {
                 return "book";
             }
-            else if (category.StartsWith("Movies", StringComparison.OrdinalIgnoreCase))
+            else if (category == "2000" || category.StartsWith("Movies", StringComparison.OrdinalIgnoreCase))
             {
                 return "movies";
             }
-            else if (category.StartsWith("TV", StringComparison.OrdinalIgnoreCase))
+            else if (category == "5000" || category.StartsWith("TV", StringComparison.OrdinalIgnoreCase))
             {
                 return "tv";
             }
-            else if (category.Contains("Audiobook", StringComparison.OrdinalIgnoreCase))
+            else if (category == "3030" || category.Contains("Audiobook", StringComparison.OrdinalIgnoreCase))
             {
                 return "book";
             }
-            else if (category.StartsWith("Audio"))
+            else if (category == "3000" || category.StartsWith("Audio"))
             {
                 return "audio";
             }

UmlautAdaptarr/Utilities/Extensions.cs

@@ -50,16 +50,34 @@ namespace UmlautAdaptarr.Utilities
         public static string GetLidarrTitleForExternalId(this string text)
         {
             text = text.RemoveGermanUmlautDots()
+                       .Replace("-", "")
                        .GetCleanTitle()
                        .ToLower();
 
-            // Lidarr removes the, an and a
+            // Lidarr removes the, an and a at the beginning
             return TitlePrefixRegex()
                 .Replace(text, "")
                 .RemoveExtraWhitespaces()
                 .Trim();
         }
 
+        public static string GetReadarrTitleForExternalId(this string text)
+        {
+            text = text.ToLower();
+
+            // Readarr removes "the" at the beginning
+            if (text.StartsWith("the "))
+            {
+                text = text[4..];
+            }
+
+            return text.RemoveGermanUmlautDots()
+                       .Replace(".", " ")
+                       .Replace("-", " ")
+                       .Replace(":", " ")
+                       .GetCleanTitle();
+        }
+
         public static string GetCleanTitle(this string text)
         {
             return text
@@ -81,11 +99,11 @@ namespace UmlautAdaptarr.Utilities
         {
             if (removeUmlauts)
             {
-                return NoSpecialCharactersRegex().Replace(text, "");
+                return NoSpecialCharactersExceptHypenRegex().Replace(text, "");
             }
             else
             {
-                return NoSpecialCharactersExceptUmlautsRegex().Replace(text, "");
+                return NoSpecialCharactersExceptHyphenAndUmlautsRegex().Replace(text, "");
             }
         }
 
@@ -114,6 +132,18 @@ namespace UmlautAdaptarr.Utilities
                 .Replace("ß", "ss");
         }
 
+        public static string RemoveGermanUmlauts(this string text)
+        {
+            return text
+                .Replace("ö", "")
+                .Replace("ü", "")
+                .Replace("ä", "")
+                .Replace("Ö", "")
+                .Replace("Ü", "")
+                .Replace("Ä", "")
+                .Replace("ß", "");
+        }
+
         public static string RemoveExtraWhitespaces(this string text)
         {
             return MultipleWhitespaceRegex().Replace(text, " ");
@@ -126,11 +156,11 @@ namespace UmlautAdaptarr.Utilities
             return umlauts.Any(text.Contains);
         }
 
-        [GeneratedRegex("[^a-zA-Z0-9 ]+", RegexOptions.Compiled)]
-        private static partial Regex NoSpecialCharactersRegex();
+        [GeneratedRegex("[^a-zA-Z0-9 -]+", RegexOptions.Compiled)]
+        private static partial Regex NoSpecialCharactersExceptHypenRegex();
 
-        [GeneratedRegex("[^a-zA-Z0-9 öäüßÖÄÜ]+", RegexOptions.Compiled)]
-        private static partial Regex NoSpecialCharactersExceptUmlautsRegex();
+        [GeneratedRegex("[^a-zA-Z0-9 -öäüßÖÄÜß]+", RegexOptions.Compiled)]
+        private static partial Regex NoSpecialCharactersExceptHyphenAndUmlautsRegex();
 
         [GeneratedRegex(@"\s+")]
         private static partial Regex MultipleWhitespaceRegex();

UmlautAdaptarr/Utilities/UrlUtilities.cs

@@ -12,7 +12,7 @@ namespace UmlautAdaptarr.Utilities
             // RegEx für eine einfache URL-Validierung ohne http:// und ohne abschließenden Schrägstrich
             // Erlaubt optionale Subdomains, Domainnamen und TLDs, aber keine Pfade oder Protokolle
             var regex = UrlMatchingRegex();
-            return regex.IsMatch(domain) && !domain.EndsWith("/");
+            return regex.IsMatch(domain);
         }
 
         public static string BuildUrl(string domain, IDictionary<string, string> queryParameters)
@@ -35,7 +35,7 @@ namespace UmlautAdaptarr.Utilities
 
             if (!string.IsNullOrEmpty(apiKey))
             {
-                queryParameters["apiKey"] = apiKey;
+                queryParameters["apikey"] = apiKey;
             }
 
             return BuildUrl(domain, queryParameters);

UmlautAdaptarr/secrets_example.json

@@ -4,5 +4,8 @@
   "SONARR_API_KEY": "",
   "LIDARR_ENABLED": false,
   "LIDARR_HOST": "http://localhost:8686",
-  "LIDARR_API_KEY": ""
+  "LIDARR_API_KEY": "",
+  "READARR_ENABLED": false,
+  "READARR_HOST": "http://localhost:8787",
+  "READARR_API_KEY": ""
 }