Lidarr optimizations

README.md

@@ -2,10 +2,10 @@
 
 ## English description coming soon
 
-## 12.02.2024: Erste Testversion
+## 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 schon Auswirkungen (abgesehen vom Caching).
+Es sollte mit allen *arrs funktionieren, hat aber nur bei Sonarr und Lidarr schon Auswirkungen (abgesehen vom Caching).
 
 Momentan ist docker dafür nötig, wer kein Docker nutzt muss sich noch etwas gedulden. 
 
@@ -15,7 +15,7 @@ Zusätzlich müsst ihr in Sonarr oder Prowlarr einen neuen Indexer hinzufügen (
 
 Am Beispiel von sceneNZBs:
 
-![grafik](https://github.com/PCJones/UmlautAdaptarr/assets/377223/97ca0aef-1a9e-4560-9374-c3a8215dafd2)
+![grafik](https://github.com/PCJones/UmlautAdaptarr/assets/377223/07c7ca45-e0e5-4a82-af63-365bb23c55c9)
 
 Also alles wie immer, nur dass ihr als API-URL nicht direkt z.B. `https://scenenzbs.com` eingebt, sondern 
 `http://localhost:5005/_/scenenzbs.com`
@@ -38,14 +38,15 @@ Einige Beispiele findet ihr unter Features.
 
 | Feature                                                           | Status        |
 |-------------------------------------------------------------------|---------------|
-| Sonarr & Prowlarr Support                                         | ✓             |
+| Prowlarr Support                                                    | ✓|
+| Sonarr Support                                         | ✓             |
+| Lidarr 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   | ✓             |
 | Radarr Support                                                    | Geplant       |
 | Readarr Support                                                   | Geplant       |
-| Lidarr Support                                                    | Geplant       |
 | Prowlarr Unterstützung für "DE" SceneNZBs Kategorien              | Geplant       |
 | Unterstützung weiterer Sprachen neben Deutsch                     | Geplant       |
 | Wünsche?                                                          | Vorschläge?   |
@@ -54,16 +55,18 @@ Einige Beispiele findet ihr unter Features.
 In den Klammern am Ende des Releasenamens (Bild 2 & 4) steht zu Anschauungszwecken der deutsche Titel der vorher nicht gefunden bzw. akzeptiert wurde. Das bleibt natürlich nicht so ;)
 
 **Vorher:** Release wird zwar gefunden, kann aber kann nicht zu geordnet werden.
-![Vorherige Suche ohne deutsche Titel](https://i.imgur.com/7pfRzgH.png)  
+![Vorherige Suche ohne deutsche Titel](https://github.com/PCJones/UmlautAdaptarr/assets/377223/1fce2909-a36c-4f1b-8497-85903357fee3)
 
 **Jetzt:** 2-3 weitere Releases werden gefunden, außerdem meckert Sonarr nicht mehr über den Namen und würde es bei einer automatischen Suche ohne Probleme importieren.
-![Jetzige Suche mit deutschen Titeln](https://i.imgur.com/k55YIN9.png)  
+![Jetzige Suche mit deutschen Titeln](https://github.com/PCJones/UmlautAdaptarr/assets/377223/0edf43ba-2beb-4f22-aaf4-30f9a619dbd6)
+
 
 **Vorher:** Es werden nur Releases mit dem englischen Titel der Serie gefunden
-![Vorherige Suche, englische Titel](https://i.imgur.com/pbRlOeX.png)  
+![Vorherige Suche, englische Titel](https://github.com/PCJones/UmlautAdaptarr/assets/377223/ed7ca0fa-ac36-4584-87ac-b29f32dd9ace)
 
 **Jetzt:**  Es werden auch Titel mit dem deutschen Namen gefunden :D (haben nicht alle Suchergebnisse auf den Screenshot gepasst)
-![Jetzige Suche, deutsche und englische Titel](https://i.imgur.com/eeq0Voj.png)  
+![Jetzige Suche, deutsche und englische Titel](https://github.com/PCJones/UmlautAdaptarr/assets/377223/1c2dbe1a-5943-4fc4-91ef-29708082900e)
+
 
 **Vorher:** Die deutsche Produktion `Alone - Überlebe die Wildnis` hat auf [TheTVDB](https://thetvdb.com/series/alone-uberlebe-die-wildnis) den Englischen Namen `Alone Germany`.
 

UmlautAdaptarr/Controllers/SearchController.cs

@@ -1,9 +1,5 @@
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.AspNetCore.Mvc.Formatters;
-using Newtonsoft.Json.Linq;
-using System.Linq;
 using System.Text;
-using System.Xml.Linq;
 using UmlautAdaptarr.Models;
 using UmlautAdaptarr.Services;
 using UmlautAdaptarr.Utilities;
@@ -188,7 +184,7 @@ namespace UmlautAdaptarr.Controllers
                     if (categories.Split(',').Any(category => AUDIO_CATEGORY_IDS.Contains(category)))
                     {
                         var mediaType = "audio";
-                        searchItem = await searchItemLookupService.GetOrFetchSearchItemByExternalId(mediaType, title.ToLower());
+                        searchItem = await searchItemLookupService.GetOrFetchSearchItemByExternalId(mediaType, title.GetLidarrTitleForExternalId());
                     }
                 }
             }

UmlautAdaptarr/Models/SearchItem.cs

@@ -12,6 +12,7 @@ namespace UmlautAdaptarr.Models
         public bool HasUmlaut => Title?.HasUmlauts() ?? false;
         public string ExpectedTitle { get; set; }
         public string? ExpectedAuthor { get; set; }
+        // TODO rename GermanTitle into Foreign or LocalTitle?
         public string? GermanTitle { get; set; }
         public string[] TitleSearchVariations { get; set; }
         public string[] TitleMatchVariations { get; set; }
@@ -42,6 +43,11 @@ namespace UmlautAdaptarr.Models
                 if (expectedTitle.Contains(expectedAuthor))
                 {
                     var titleWithoutAuthorName = expectedTitle.Replace(expectedAuthor, string.Empty).RemoveExtraWhitespaces().Trim();
+
+                    if (titleWithoutAuthorName.Length < 2)
+                    {
+                        // TODO log warning that this album can't be searched for automatically
+                    }
                     TitleMatchVariations = GenerateVariations(titleWithoutAuthorName, mediaType).ToArray();
                 }
                 else
@@ -54,6 +60,7 @@ namespace UmlautAdaptarr.Models
             else
             {
                 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
@@ -66,17 +73,37 @@ namespace UmlautAdaptarr.Models
                     }
                 }
 
-                TitleMatchVariations = allTitleVariations.Distinct().ToArray();
+                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? germanTitle, string mediaType)
+        private IEnumerable<string> GenerateVariations(string? title, string mediaType)
         {
-            if (germanTitle == null)
+            if (title == null)
+            {
+                return [];
+            }
+            var cleanTitle = title.GetCleanTitle();
+
+            if (cleanTitle?.Length == 0)
             {
                 return [];
             }
-            var cleanTitle = germanTitle.RemoveAccentButKeepGermanUmlauts().GetCleanTitle();
 
             // Start with base variations including handling umlauts
             var baseVariations = new List<string>
@@ -105,11 +132,16 @@ namespace UmlautAdaptarr.Models
                 });
             }
 
-            // If a german title starts with der/die/das also accept variations without it
+            // If a title starts with der/die/das also accept variations without it
-            if (mediaType != "audio" && cleanTitle.StartsWith("Der") || cleanTitle.StartsWith("Die") || cleanTitle.StartsWith("Das"))
+            // Same for english the, an, a
+            if (cleanTitle.StartsWith("Der ") || cleanTitle.StartsWith("Die ") || cleanTitle.StartsWith("Das ")
+                || cleanTitle.StartsWith("The ") || cleanTitle.StartsWith("An "))
             {
-                var cleanTitleWithoutArticle = germanTitle[3..].Trim();
+                var cleanTitleWithoutArticle = title[3..].Trim();
                 baseVariations.AddRange(GenerateVariations(cleanTitleWithoutArticle, mediaType));
+            } else if (cleanTitle.StartsWith("A "))
+            {
+                var cleanTitleWithoutArticle = title[2..].Trim();
             }
 
             // Remove multiple spaces

UmlautAdaptarr/Providers/LidarrClient.cs

@@ -1,4 +1,5 @@
-using Newtonsoft.Json;
+using Microsoft.Extensions.Caching.Memory;
+using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using UmlautAdaptarr.Models;
 using UmlautAdaptarr.Services;
@@ -9,7 +10,8 @@ namespace UmlautAdaptarr.Providers
     public class LidarrClient(
         IHttpClientFactory clientFactory,
         IConfiguration configuration,
-        TitleApiService titleService,
+        CacheService cacheService,
+        IMemoryCache cache,
         ILogger<LidarrClient> logger) : ArrClientBase()
     {
         private readonly string _lidarrHost = configuration.GetValue<string>("LIDARR_HOST") ?? throw new ArgumentException("LIDARR_HOST environment variable must be set");
@@ -23,7 +25,6 @@ namespace UmlautAdaptarr.Providers
 
             try
             {
-
                 var lidarrArtistsUrl = $"{_lidarrHost}/api/v1/artist?apikey={_lidarrApiKey}";
                 logger.LogInformation($"Fetching all artists from Lidarr: {UrlUtilities.RedactApiKey(lidarrArtistsUrl)}");
                 var artistsApiResponse = await httpClient.GetStringAsync(lidarrArtistsUrl);
@@ -40,9 +41,18 @@ namespace UmlautAdaptarr.Providers
                     var artistId = (int)artist.id;
 
                     var lidarrAlbumUrl = $"{_lidarrHost}/api/v1/album?artistId={artistId}&apikey={_lidarrApiKey}";
+
+                    // 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))
+                    //{
+                    //    logger.LogInformation($"Using cached albums for {UrlUtilities.RedactApiKey(lidarrAlbumUrl)}");
+                    //}
+                    //else
+                    //{
                     logger.LogInformation($"Fetching all albums from artistId {artistId} from Lidarr: {UrlUtilities.RedactApiKey(lidarrArtistsUrl)}");
                     var albumApiResponse = await httpClient.GetStringAsync(lidarrAlbumUrl);
                     var albums = JsonConvert.DeserializeObject<List<dynamic>>(albumApiResponse);
+                    //}
 
                     if (albums == null)
                     {
@@ -52,6 +62,9 @@ namespace UmlautAdaptarr.Providers
 
                     logger.LogInformation($"Successfully fetched {albums.Count} albums for artistId {artistId} from Lidarr.");
 
+                    // Cache albums for 3 minutes
+                    cache.Set(lidarrAlbumUrl, albums, TimeSpan.FromMinutes(3));
+
                     foreach (var album in albums)
                     {
                         var artistName = (string)album.artist.artistName;
@@ -62,7 +75,7 @@ namespace UmlautAdaptarr.Providers
                         string[]? aliases = null;
 
                         // Abuse externalId to set the search string Lidarr uses
-                        var externalId = expectedTitle.RemoveGermanUmlautDots().RemoveAccent().RemoveSpecialCharacters().RemoveExtraWhitespaces().ToLower();
+                        var externalId = expectedTitle.GetLidarrTitleForExternalId();
 
                         var searchItem = new SearchItem
                         (
@@ -92,42 +105,20 @@ namespace UmlautAdaptarr.Providers
 
         public override async Task<SearchItem?> FetchItemByExternalIdAsync(string externalId)
         {
-            var httpClient = clientFactory.CreateClient();
-
             try
             {
-                var lidarrUrl = $"{_lidarrHost}/api/v1/series?mbId={externalId}&includeSeasonImages=false&apikey={_lidarrApiKey}";
+                // For now we have to fetch all items every time
-                logger.LogInformation($"Fetching item by external ID from Lidarr: {UrlUtilities.RedactApiKey(lidarrUrl)}");
+                var searchItems = await FetchAllItemsAsync();
-                var response = await httpClient.GetStringAsync(lidarrUrl);
+                foreach (var searchItem in searchItems ?? [])
-                var artists = JsonConvert.DeserializeObject<dynamic>(response);
-                var artist = artists?[0];
-
-                if (artist != null)
                 {
-                    var mbId = (string)artist.mbId;
+                    try
-                    if (mbId == null)
                     {
-                        logger.LogWarning($"Lidarr Artist {artist.id} doesn't have a mbId.");
+                        cacheService.CacheSearchItem(searchItem);
-                        return null;
+                    }
+                    catch (Exception ex)
+                    {
+                        logger.LogError(ex, $"An error occurred while caching search item with ID {searchItem.ArrId}.");
                     }
-                    (var germanTitle, var aliases) = await titleService.FetchGermanTitleAndAliasesByExternalIdAsync(_mediaType, mbId);
-
-                    throw new NotImplementedException();
-
-                    var searchItem = new SearchItem
-                    (
-                        arrId: (int)artist.id,
-                        externalId: mbId,
-                        title: (string)artist.title,
-                        expectedTitle: (string)artist.title,
-                        germanTitle: germanTitle,
-                        aliases: aliases,
-                        mediaType: _mediaType,
-                        expectedAuthor: "TODO"
-                    ); ;
-
-                    logger.LogInformation($"Successfully fetched artist {searchItem} from Lidarr.");
-                    return searchItem;
                 }
             }
             catch (Exception ex)
@@ -140,54 +131,10 @@ namespace UmlautAdaptarr.Providers
 
         public override async Task<SearchItem?> FetchItemByTitleAsync(string title)
         {
-            var httpClient = clientFactory.CreateClient();
-
             try
             {
-                (string? germanTitle, string? mbId, string[]? aliases) = await titleService.FetchGermanTitleAndExternalIdAndAliasesByTitle(_mediaType, title);
+               // this should never be called at the moment
-
-                if (mbId == null)
-                {
-                    return null;
-                }
-
-                var lidarrUrl = $"{_lidarrHost}/api/v1/series?mbId={mbId}&includeSeasonImages=false&apikey={_lidarrApiKey}";
-                var lidarrApiResponse = await httpClient.GetStringAsync(lidarrUrl);
-                var artists = JsonConvert.DeserializeObject<dynamic>(lidarrApiResponse);
-
-                if (artists == null)
-                {
-                    logger.LogError($"Parsing Lidarr API response for MB ID {mbId} resulted in null");
-                    return null;
-                }
-                else if (artists.Count == 0)
-                {
-                    logger.LogWarning($"No results found for MB ID {mbId}");
-                    return null;
-                }
-
-                var expectedTitle = (string)artists[0].title;
-                if (expectedTitle == null)
-                {
-                    logger.LogError($"Lidarr Title for MB ID {mbId} is null");
-                    return null;
-                }
-
                 throw new NotImplementedException();
-                var searchItem = new SearchItem
-                (
-                    arrId: (int)artists[0].id,
-                    externalId: mbId,
-                    title: (string)artists[0].title,
-                    expectedTitle: (string)artists[0].title,
-                    germanTitle: germanTitle,
-                    aliases: aliases,
-                    mediaType: _mediaType,
-                    expectedAuthor: "TODO"
-                );
-
-                logger.LogInformation($"Successfully fetched artist {searchItem} from Lidarr.");
-                return searchItem;
             }
             catch (Exception ex)
             {

UmlautAdaptarr/Providers/SonarrClient.cs

@@ -39,6 +39,7 @@ namespace UmlautAdaptarr.Providers
                             logger.LogWarning($"Sonarr Show {show.id} doesn't have a tvdbId.");
                             continue;
                         }
+
                         (var germanTitle, var aliases) = await titleService.FetchGermanTitleAndAliasesByExternalIdAsync(_mediaType, tvdbId);
                         var searchItem = new SearchItem
                         (

UmlautAdaptarr/Services/CacheService.cs

@@ -1,4 +1,6 @@
-using Microsoft.Extensions.Caching.Memory;
+using Microsoft.AspNetCore.Mvc.Formatters;
+using Microsoft.Extensions.Caching.Memory;
+using System.Reflection.Metadata.Ecma335;
 using System.Text.RegularExpressions;
 using UmlautAdaptarr.Models;
 using UmlautAdaptarr.Utilities;
@@ -8,16 +10,17 @@ namespace UmlautAdaptarr.Services
     public partial class CacheService(IMemoryCache cache)
     {
         private readonly Dictionary<string, HashSet<string>> VariationIndex = [];
-        private readonly Dictionary<string, List<SearchItem>> AudioFuzzyIndex = [];
+        private readonly Dictionary<string, List<(HashSet<string> TitleVariations, string CacheKey)>> AudioVariationIndex = [];
         private const int VARIATION_LOOKUP_CACHE_LENGTH = 5;
 
         public void CacheSearchItem(SearchItem item)
         {
             var prefix = item.MediaType;
-            cache.Set($"{prefix}_extid_{item.ExternalId}", item);
+            var cacheKey = $"{prefix}_extid_{item.ExternalId}";
+            cache.Set(cacheKey, item);
             if (item.MediaType == "audio")
             {
-                CacheAudioSearchItem(item);
+                CacheAudioSearchItem(item, cacheKey);
                 return;
             }
 
@@ -28,7 +31,7 @@ namespace UmlautAdaptarr.Services
             foreach (var variation in item.TitleMatchVariations)
             {
                 var normalizedVariation = variation.RemoveAccentButKeepGermanUmlauts().ToLower();
-                var cacheKey = $"{prefix}_var_{normalizedVariation}";
+                cacheKey = $"{prefix}_var_{normalizedVariation}";
                 cache.Set(cacheKey, item);
 
                 // Indexing by prefix
@@ -41,30 +44,32 @@ namespace UmlautAdaptarr.Services
             }
         }
 
-        private void CacheAudioSearchItem(SearchItem item)
+        public void CacheAudioSearchItem(SearchItem item, string cacheKey)
         {
-            // Normalize and simplify the title and author for fuzzy matching
+            // Index author and title variations
-            var key = NormalizeForFuzzyMatching(item.ExternalId);
+            foreach (var authorVariation in item.AuthorMatchVariations)
+            {
+                var normalizedAuthor = authorVariation.NormalizeForComparison();
 
-            if (!AudioFuzzyIndex.ContainsKey(key))
+                if (!AudioVariationIndex.ContainsKey(normalizedAuthor))
                 {
-                AudioFuzzyIndex[key] = new List<SearchItem>();
+                    AudioVariationIndex[normalizedAuthor] = [];
-            }
-            AudioFuzzyIndex[key].Add(item);
                 }
 
-        private string NormalizeForFuzzyMatching(string input)
+                var titleVariations = item.TitleMatchVariations.Select(titleMatchVariation => titleMatchVariation.NormalizeForComparison()).ToHashSet();
-        {
+                AudioVariationIndex[normalizedAuthor].Add((titleVariations, cacheKey));
-            // Normalize the input string by removing accents, converting to lower case, and removing non-alphanumeric characters
+            }
-            var normalized = input.RemoveAccentButKeepGermanUmlauts().RemoveSpecialCharacters().ToLower();
-            normalized = WhiteSpaceRegex().Replace(normalized, "");
-            return normalized;
         }
 
         public SearchItem? SearchItemByTitle(string mediaType, string title)
         {
             var normalizedTitle = title.RemoveAccentButKeepGermanUmlauts().ToLower();
 
+            if (mediaType == "audio")
+            {
+                return FindBestMatchForAudio(normalizedTitle.NormalizeForComparison());
+            }
+
             // Use the first few characters of the normalized title for cache prefix search
             var cacheSearchPrefix = normalizedTitle[..Math.Min(VARIATION_LOOKUP_CACHE_LENGTH, normalizedTitle.Length)];
 
@@ -79,7 +84,7 @@ namespace UmlautAdaptarr.Services
                             continue;
                         }
                         // After finding a potential item, compare normalizedTitle with each German title variation
-                        foreach (var variation in item?.TitleSearchVariations ?? [])
+                        foreach (var variation in item?.TitleMatchVariations ?? [])
                         {
                             var normalizedVariation = variation.RemoveAccentButKeepGermanUmlauts().ToLower();
                             if (normalizedTitle.StartsWith(variation, StringComparison.OrdinalIgnoreCase))
@@ -107,10 +112,12 @@ namespace UmlautAdaptarr.Services
         {
             var normalizedTitle = title.RemoveAccentButKeepGermanUmlauts().ToLower();
 
+
             if (mediaType == "generic")
             {
                 // TODO
             }
+
             cache.TryGetValue($"{mediaType}_var_{normalizedTitle}", out SearchItem? item);
             if (item == null)
             {
@@ -119,6 +126,31 @@ namespace UmlautAdaptarr.Services
             return item;
         }
 
+        private SearchItem? FindBestMatchForAudio(string normalizedOriginalTitle)
+        {
+            foreach (var authorEntry in AudioVariationIndex)
+            {
+                if (normalizedOriginalTitle.Contains(authorEntry.Key))
+                {
+                    var sortedEntries = authorEntry.Value.OrderByDescending(entry => entry.TitleVariations.FirstOrDefault()?.Length).ToList();
+
+                    foreach (var (titleVariations, cacheKey) in sortedEntries)
+                    {
+                        if (titleVariations.Any(normalizedOriginalTitle.Contains))
+                        {
+                            if (cache.TryGetValue(cacheKey, out SearchItem? item))
+                            {
+                                return item;
+                            }
+                        }
+                    }
+                }
+            }
+
+            return null;
+        }
+
+
         [GeneratedRegex("\\s")]
         private static partial Regex WhiteSpaceRegex();
     }

UmlautAdaptarr/Services/SearchItemLookupService.cs

@@ -62,6 +62,8 @@ namespace UmlautAdaptarr.Services
                         fetchedItem = await sonarrClient.FetchItemByTitleAsync(title);
                     }
                     break;
+                case "audio":
+                    break;
                     // TODO add cases for other sources as needed, such as Radarr, Lidarr, etc.
             }
 
@@ -74,5 +76,4 @@ namespace UmlautAdaptarr.Services
             return fetchedItem;
         }
     }
-
 }

UmlautAdaptarr/Services/TitleMatchingService.cs

@@ -1,4 +1,5 @@
-using System.Text.RegularExpressions;
+using Microsoft.Extensions.FileSystemGlobbing.Internal;
+using System.Text.RegularExpressions;
 using System.Xml.Linq;
 using UmlautAdaptarr.Models;
 using UmlautAdaptarr.Utilities;
@@ -19,7 +20,7 @@ namespace UmlautAdaptarr.Services
                 if (titleElement != null)
                 {
                     var originalTitle = titleElement.Value;
-                    var normalizedOriginalTitle = NormalizeTitle(originalTitle);
+                    var cleanTitleSeperatedBySpace = ReplaceSeperatorsWithSpace(originalTitle.RemoveAccentButKeepGermanUmlauts());
 
                     var categoryElement = item.Element("category");
                     var category = categoryElement?.Value;
@@ -33,7 +34,7 @@ namespace UmlautAdaptarr.Services
                     if (useCacheService)
                     {
                         // Use CacheService to find a matching SearchItem by title
-                        searchItem = cacheService.SearchItemByTitle(mediaType, normalizedOriginalTitle);
+                        searchItem = cacheService.SearchItemByTitle(mediaType, cleanTitleSeperatedBySpace);
                     }
 
                     if (searchItem == null)
@@ -45,13 +46,13 @@ namespace UmlautAdaptarr.Services
                     switch (mediaType)
                     {
                         case "tv":
-                            FindAndReplaceForMoviesAndTV(logger, searchItem, titleElement, originalTitle, normalizedOriginalTitle!);
+                            FindAndReplaceForMoviesAndTV(logger, searchItem, titleElement, originalTitle, cleanTitleSeperatedBySpace!);
                             break;
                         case "movie":
-                            FindAndReplaceForMoviesAndTV(logger, searchItem, titleElement, originalTitle, normalizedOriginalTitle!);
+                            FindAndReplaceForMoviesAndTV(logger, searchItem, titleElement, originalTitle, cleanTitleSeperatedBySpace!);
                             break;
                         case "audio":
-                            ReplaceForAudio(searchItem, titleElement, originalTitle, normalizedOriginalTitle!);
+                            FindAndReplaceForAudio(searchItem, titleElement, originalTitle!);
                             break;
                         default:
                             throw new NotImplementedException();
@@ -62,26 +63,27 @@ namespace UmlautAdaptarr.Services
             return xDoc.ToString();
         }
 
-        private string NormalizeString(string text)
+        public void FindAndReplaceForAudio(SearchItem searchItem, XElement? titleElement, string originalTitle)
         {
-            return text.RemoveGermanUmlautDots().RemoveAccent().RemoveSpecialCharacters().Replace(" ", "").Trim().ToLower();
+            var authorMatch = FindBestMatch(searchItem.AuthorMatchVariations, originalTitle.NormalizeForComparison(), originalTitle);
+            var titleMatch = FindBestMatch(searchItem.TitleMatchVariations, originalTitle.NormalizeForComparison(), originalTitle);
+
+            if (authorMatch.foundMatch && titleMatch.foundMatch)
+            {
+                int matchEndPositionInOriginal = Math.Max(authorMatch.bestEndInOriginal, titleMatch.bestEndInOriginal);
+
+                // Check and adjust for immediate following delimiter
+                char[] delimiters = [' ', '-', '_', '.'];
+                if (matchEndPositionInOriginal < originalTitle.Length && delimiters.Contains(originalTitle[matchEndPositionInOriginal]))
+                {
+                    matchEndPositionInOriginal++; // Skip the delimiter if it's immediately after the match
                 }
 
-
-        public void ReplaceForAudio(SearchItem searchItem, XElement? titleElement, string originalTitle, string normalizedOriginalTitle)
-        {
-            var authorMatch = FindBestMatch(searchItem.AuthorMatchVariations, NormalizeString(normalizedOriginalTitle), originalTitle);
-            var titleMatch = FindBestMatch(searchItem.TitleMatchVariations, NormalizeString(normalizedOriginalTitle), originalTitle);
-
-            if (authorMatch.Item1 && titleMatch.Item1)
-            {
-                int matchEndPositionInOriginal = Math.Max(authorMatch.Item3, titleMatch.Item3);
-
                 // Ensure we trim any leading delimiters from the suffix
-                string suffix = originalTitle.Substring(matchEndPositionInOriginal).TrimStart([' ', '-', '_']);
+                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}-[{suffix}]";
 
                 // Update the title element
                 titleElement.Value = updatedTitle;
@@ -94,7 +96,7 @@ namespace UmlautAdaptarr.Services
         }
 
 
-        private Tuple<bool, int, int> FindBestMatch(string[] variations, string normalizedOriginal, string originalTitle)
+        private (bool foundMatch, int bestStart, int bestEndInOriginal) FindBestMatch(string[] variations, string normalizedOriginal, string originalTitle)
         {
             bool found = false;
             int bestStart = int.MaxValue;
@@ -102,7 +104,7 @@ namespace UmlautAdaptarr.Services
 
             foreach (var variation in variations)
             {
-                var normalizedVariation = NormalizeString(variation);
+                var normalizedVariation = variation.NormalizeForComparison();
                 int startNormalized = normalizedOriginal.IndexOf(normalizedVariation);
 
                 if (startNormalized >= 0)
@@ -117,8 +119,8 @@ namespace UmlautAdaptarr.Services
                 }
             }
 
-            if (!found) return Tuple.Create(false, 0, 0);
+            if (!found) return (false, 0, 0);
-            return Tuple.Create(found, bestStart, bestEndInOriginal);
+            return (found, bestStart, bestEndInOriginal);
         }
 
         // Maps an index from the normalized string back to a corresponding index in the original string
@@ -148,17 +150,16 @@ namespace UmlautAdaptarr.Services
                 originalIndex = i;
             }
 
-            return originalIndex + 1; // +1 to move past the matched character or to the next character in the original title
+            return originalIndex;
         }
 
-
-
         // 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)
         {
             var titleMatchVariations = searchItem.TitleMatchVariations;
             var expectedTitle = searchItem.ExpectedTitle;
             var variationsOrderedByLength = titleMatchVariations!.OrderByDescending(variation => variation.Length);
+
             // Attempt to find a variation that matches the start of the original title
             foreach (var variation in variationsOrderedByLength)
             {
@@ -174,12 +175,6 @@ namespace UmlautAdaptarr.Services
                 // Check if the originalTitle starts with the variation (ignoring case and separators)
                 if (Regex.IsMatch(normalizedOriginalTitle, variationMatchPattern, RegexOptions.IgnoreCase))
                 {
-                    // 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))
-                    {
-                        logger.LogWarning($"TitleMatchingService - Didn't rename: '{originalTitle}' because the expected title '{expectedTitle}' starts with the variation '{variation}'");
-                        continue;
-                    }
                     var originalTitleMatchPattern = "^" + Regex.Escape(variation).Replace("\\ ", "[._ ]");
 
                     // Find the first separator used in the original title for consistent replacement
@@ -191,8 +186,21 @@ namespace UmlautAdaptarr.Services
                     var variationLength = variation.Length;
                     var suffix = originalTitle[Math.Min(variationLength, originalTitle.Length)..];
 
-                    // Clean up any leading separators from the suffix
+                    // Workaround for the rare case of e.g. "Frieren: Beyond Journey's End" that also has the alias "Frieren"
-                    suffix = Regex.Replace(suffix, "^[._ ]+", "");
+                    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
+                        // - that won't help with movies but with tv shows
+                        var seasonMatchingPattern = $"^{separator}S\\d{{1,2}}E\\d{{1,2}}";
+                        if (!Regex.IsMatch(suffix, seasonMatchingPattern))
+                        {
+                            logger.LogWarning($"TitleMatchingService - Didn't rename: '{originalTitle}' because the expected title '{expectedTitle}' starts with the variation '{variation}'");
+                            continue;
+                        }
+                    }
+
+                    // 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
                     // can lead to problems with shows such as "dark" that have international dubs
@@ -218,9 +226,8 @@ namespace UmlautAdaptarr.Services
             }
         }
 
-        private static string NormalizeTitle(string title)
+        private static string ReplaceSeperatorsWithSpace(string title)
         {
-            title = title.RemoveAccentButKeepGermanUmlauts();
             // Replace all known separators with space for normalization
             return WordSeperationCharRegex().Replace(title, " ".ToString());
         }

UmlautAdaptarr/Utilities/Extensions.cs

@@ -47,15 +47,46 @@ namespace UmlautAdaptarr.Utilities
             return stringBuilder.ToString().Normalize(NormalizationForm.FormC);
         }
 
-        // TODO possibly replace GetCleanTitle with RemoveSpecialCharacters
+        public static string GetLidarrTitleForExternalId(this string text)
-        public static string GetCleanTitle(this string text)
         {
-            return text.Replace("(", "").Replace(")", "").Replace("?","").Replace(":", "").Replace("'", "");
+            text = text.RemoveGermanUmlautDots()
+                       .GetCleanTitle()
+                       .ToLower();
+
+            // Lidarr removes the, an and a
+            return TitlePrefixRegex()
+                .Replace(text, "")
+                .RemoveExtraWhitespaces()
+                .Trim();
         }
 
-        public static string RemoveSpecialCharacters(this string text)
+        public static string GetCleanTitle(this string text)
         {
-            return SpecialCharactersRegex().Replace(text, "");
+            return text
+                .Replace(".", " ")
+                .Replace(":", " ")
+                .RemoveAccentButKeepGermanUmlauts()
+                .RemoveSpecialCharacters(removeUmlauts: false)
+                .RemoveExtraWhitespaces()
+                .Trim();
+        }
+
+        public static string NormalizeForComparison(this string text)
+        {
+            // TODO see if we can replace RemoveGermanUmlautDots() with RemoveSpecialCharacters(removeUmlauts: false);
+            return text.RemoveGermanUmlautDots().RemoveAccent().RemoveSpecialCharacters().Replace(" ", "").Trim().ToLower();
+        }
+
+        public static string RemoveSpecialCharacters(this string text, bool removeUmlauts = true)
+        {
+            if (removeUmlauts)
+            {
+                return NoSpecialCharactersRegex().Replace(text, "");
+            }
+            else
+            {
+                return NoSpecialCharactersExceptUmlautsRegex().Replace(text, "");
+            }
         }
 
 
@@ -96,9 +127,15 @@ namespace UmlautAdaptarr.Utilities
         }
 
         [GeneratedRegex("[^a-zA-Z0-9 ]+", RegexOptions.Compiled)]
-        private static partial Regex SpecialCharactersRegex();
+        private static partial Regex NoSpecialCharactersRegex();
+
+        [GeneratedRegex("[^a-zA-Z0-9 öäüßÖÄÜ]+", RegexOptions.Compiled)]
+        private static partial Regex NoSpecialCharactersExceptUmlautsRegex();
 
         [GeneratedRegex(@"\s+")]
         private static partial Regex MultipleWhitespaceRegex();
+
+        [GeneratedRegex(@"\b(the|an|a)\b", RegexOptions.IgnoreCase, "de-DE")]
+        private static partial Regex TitlePrefixRegex();
     }
 }

UmlautAdaptarr/Utilities/UrlUtilities.cs

@@ -5,7 +5,7 @@ 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-]+)+.*)$")]
         private static partial Regex UrlMatchingRegex();
         public static bool IsValidDomain(string domain)
         {

build_and_push_docker_image.bat

@@ -0,0 +1,18 @@
+@echo off
+SET IMAGE_NAME=pcjones/umlautadaptarr
+
+echo Enter the version number for the Docker image:
+set /p VERSION="Version: "
+
+echo Building Docker image with version %VERSION%...
+docker build -t %IMAGE_NAME%:%VERSION% .
+docker tag %IMAGE_NAME%:%VERSION% %IMAGE_NAME%:latest
+
+echo Pushing Docker image with version %VERSION%...
+docker push %IMAGE_NAME%:%VERSION%
+
+echo Pushing Docker image with tag latest...
+docker push %IMAGE_NAME%:latest
+
+echo Done.
+pause