Zwei Namen für denselben Titel brachen den ganzen Lauf ab

Der Eindeutigkeitsindex aus Punkt 3 stellte die Regel auf, dichtete aber
den einen Weg nicht ab, auf dem sie verletzt wird: der Enricher setzt die
TMDB-Kennung, und sobald zwei Einträge derselben Mediathek dieselbe
bekamen, brach EF die gesamte Speicherung ab — mit "An error occurred
while saving the entity changes", einer Meldung, die den Grund nicht nennt
und den ganzen Scan mitnimmt.

Jetzt wird die Kennung nicht blind gesetzt, sondern vorgemerkt und nach
der Schleife zusammengelegt. Zwei Tests halten den Fall fest: der Anbieter
antwortet auf jede Anfrage mit demselben Film beziehungsweise derselben
Serie, also genau die Lage, die vorher den Lauf zerriss.

Dazu der wahrscheinliche Grund für die siebenhundert Serien: der
Serientitel kam ausschliesslich aus dem Dateinamen. Heisst eine Datei nur
"S01E01.mkv", steht vor der Folgennummer nichts, und der ganze Dateiname
wurde zum Serientitel — zwanzig Folgen ergaben zwanzig Serien namens
"S01E01", "S01E02", und so weiter. Jetzt sagt der Ordner den Namen, wenn
die Datei ihn nicht nennt; der Staffelordner wird dabei übersprungen, sonst
hiesse die Serie "Staffel 1". Plex und Jellyfin lesen ihn seit je so.

Dazu die Prüfliste: Folgen werden nach Serie gebündelt, weil zwanzig neue
Folgen eine Entscheidung sind und nicht zwanzig. Mit Mehrfachauswahl —
anhaken und gemeinsam freigeben oder auf einen Zeitpunkt legen. Und der
Zeitpunkt ist ein datetime-local statt eines Textfelds mit Formvorschrift,
bei dem jeder Tippfehler erst nach dem Absenden auffiel.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

server/tests/Flaro.Api.Tests/MetadataTests.cs

@@ -155,6 +155,73 @@ public class MetadataTests
         Assert.That(bilder.Geholt, Is.EquivalentTo(new[] { "https://bild/p.jpg", "https://bild/b.jpg" }));
     }
 
+    /// <summary>Zwei Namen, ein Film — das darf den Lauf nicht abbrechen.</summary>
+    ///
+    /// <remarks>
+    /// <para>
+    /// <b>Der Fehler, den der Eindeutigkeitsindex selbst verursacht hat.</b>
+    /// Beim Scan heisst der eine Eintrag „Ich einfach unverbesserlich" und
+    /// der andere „Despicable Me"; dass es derselbe Film ist, verrät erst die
+    /// TMDB-Kennung. Wurde sie beiden zugewiesen, verletzte das die Regel —
+    /// und EF brach die gesamte Speicherung ab, mit „An error occurred while
+    /// saving the entity changes". Die Meldung nennt den Grund nicht und
+    /// nimmt den ganzen Lauf mit.
+    /// </para>
+    /// <para>
+    /// Hier antwortet der Anbieter auf jede Anfrage mit demselben Film — also
+    /// genau die Lage, die vorher den Lauf zerriss.
+    /// </para>
+    /// </remarks>
+    [Test]
+    public async Task Zwei_Namen_fuer_denselben_Film_werden_zusammengelegt()
+    {
+        Datei("Despicable Me (2010).mkv");
+        Datei("Ich einfach unverbesserlich (2010).mkv");
+
+        var anbieter = new VorgegebenerAnbieter
+        {
+            Film = new MovieMetadata(20352, "Ich einfach unverbesserlich", 2010, "Gru hat einen Plan.",
+                null, null),
+        };
+
+        using var server = MitAnbieter(anbieter);
+        var (client, bibliothek) = await Einrichten(server, "Movies");
+        var stand = await Scannen(client, bibliothek);
+
+        Assert.That(stand.State, Is.EqualTo("finished"), "Der Lauf darf nicht abbrechen.");
+        Assert.That(stand.Metadata!.Error, Is.Null);
+
+        var filme = await client.GetFromJsonAsync<Page<MovieResponse>>("/api/v1/movies");
+        Assert.That(filme!.Total, Is.EqualTo(1), "Ein Film, nicht zwei.");
+        Assert.That(filme.Items[0].Title, Is.EqualTo("Ich einfach unverbesserlich"));
+        Assert.That(filme.Items[0].Files, Has.Count.EqualTo(2),
+            "Beide Dateien hängen am überlebenden Eintrag — keine darf verlorengehen.");
+    }
+
+    /// <summary>Dasselbe für Serien.</summary>
+    [Test]
+    public async Task Zwei_Namen_fuer_dieselbe_Serie_werden_zusammengelegt()
+    {
+        Datei("Dark/Staffel 1/Dark - S01E01.mkv");
+        Datei("Dark (2017)/Staffel 1/Dark (2017) - S01E02.mkv");
+
+        var anbieter = new VorgegebenerAnbieter
+        {
+            Serie = new SeriesMetadata(70523, "Dark", 2017, "Eine Höhle.", null, null),
+        };
+
+        using var server = MitAnbieter(anbieter);
+        var (client, bibliothek) = await Einrichten(server, "Shows");
+        var stand = await Scannen(client, bibliothek);
+
+        Assert.That(stand.State, Is.EqualTo("finished"));
+
+        var serien = await client.GetFromJsonAsync<Page<SeriesResponse>>("/api/v1/series");
+        Assert.That(serien!.Total, Is.EqualTo(1));
+        Assert.That(serien.Items[0].EpisodeCount, Is.EqualTo(2),
+            "Beide Folgen hängen an der überlebenden Serie.");
+    }
+
     /// <summary>Was die Quelle nicht kennt, bleibt trotzdem in der Mediathek.</summary>
     [Test]
     public async Task Ein_Film_ohne_Treffer_behaelt_seinen_Dateinamen()

server/tests/Flaro.Core.Tests/FileNameTests.cs

@@ -165,3 +165,36 @@ public class MedienDateienTests
         Assert.That(MediaExtensions.IsSkippedDirectory(name), Is.EqualTo(erwartet));
     }
 }
+
+/// <summary>Woher der Serienname kommt, wenn der Dateiname ihn nicht nennt.</summary>
+///
+/// <remarks>
+/// <b>Der Fall, der aus einer Serie siebenhundert machte.</b> Heisst eine
+/// Datei nur „S01E01.mkv", steht vor der Folgennummer nichts — und bis dahin
+/// wurde der ganze Dateiname zum Serientitel. Zwanzig Folgen ergaben zwanzig
+/// Serien namens „S01E01", „S01E02", und so weiter.
+/// </remarks>
+public class SerieAusOrdnerTests
+{
+    [TestCase("Dark/Staffel 1/S01E01.mkv", "Dark")]
+    [TestCase("Dark/Season 2/S02E05.mkv", "Dark")]
+    [TestCase("Doctor Who (2005)/Staffel 12/S12E04.mkv", "Doctor Who")]
+    [TestCase("Serien/Dark/S01E01.mkv", "Dark")]
+    [TestCase("Dark/Specials/S00E01.mkv", "Dark")]
+    public void Ohne_Namen_in_der_Datei_gilt_der_Ordner(string pfad, string erwartet) =>
+        Assert.That(FileNames.ParseEpisode(pfad)?.SeriesTitle, Is.EqualTo(erwartet));
+
+    /// <summary>Steht er im Dateinamen, hat er Vorrang — er ist genauer.</summary>
+    [Test]
+    public void Der_Dateiname_sticht_den_Ordner() =>
+        Assert.That(FileNames.ParseEpisode("Irgendwas/Staffel 1/Dark - S01E01 - Geheimnisse.mkv")?.SeriesTitle,
+            Is.EqualTo("Dark"));
+
+    [Test]
+    public void Staffel_und_Folge_bleiben_richtig()
+    {
+        var name = FileNames.ParseEpisode("Dark/Staffel 2/S02E05.mkv");
+        Assert.That(name!.Season, Is.EqualTo(2));
+        Assert.That(name.Episode, Is.EqualTo(5));
+    }
+}