Ein leeres Jahrfeld ist eine Angabe, kein Versehen

Wer bei der Zuordnung kein Jahr einträgt, sagt damit, dass er keines
weiss. Der Server reichte trotzdem eines nach — das aus dem Dateinamen —,
und das leere Feld hatte überhaupt keine Wirkung. Gerade bei einem falsch
benannten Film ist der Dateiname aber die unzuverlässigste Quelle, die es
gibt: „Plan B (2010)" heisst bei TMDB „DivertiMento – Plan B" und ist von
2011. Mit dem nachgereichten 2010 kam nie ein Treffer, und es gab keinen
Weg daran vorbei.

Ohne Angabe wird jetzt ohne Jahr gesucht. Der Platzhalter sagt es auch.

Auf der Detailseite stand im Feld bisher das Jahr der bestehenden
Zuordnung — also genau der, die gerade korrigiert werden soll. „Doctor
Strange" war auf ein Making-of von 2022 gelaufen; mit dessen Jahr konnte
der richtige Film von 2016 gar nicht erscheinen. Das Feld bleibt jetzt
leer, und leer heisst überall dasselbe.

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

server/src/Flaro.Api/Endpoints/MatchEndpoints.cs

@@ -253,15 +253,21 @@ public static class MatchEndpoints
             // — nicht der angezeigte Titel, der ja gerade der falsche ist.
             var vorschläge = await anbieter.SearchMoviesAsync(
                 string.IsNullOrWhiteSpace(query) ? film.ParsedTitle : query.Trim(),
-                // **Das Jahr aus dem Dateinamen, nicht das aus der Zuordnung.**
+                // **Kein Jahr heisst: ohne Jahr suchen.**
                 //
-                // Hier stand `film.Year` — und das kommt von genau der
-                // Zuordnung, die gerade korrigiert werden soll. „Doctor
-                // Strange" war fälschlich auf ein Making-of von 2022
-                // gelaufen; die Suche hängte daraufhin `year=2022` an, und der
-                // richtige Film von 2016 konnte gar nicht mehr auftauchen. Ein
-                // falscher Treffer verhinderte so seine eigene Korrektur.
-                year ?? film.ParsedYear);
+                // Die Maske trägt das Jahr aus dem Dateinamen schon ein; wer
+                // es herausnimmt, sagt damit, dass er es nicht weiss. Hier
+                // stand ein Rückfall auf eben dieses Jahr — das leere Feld
+                // hatte also keine Wirkung, und ein falsch benannter Film
+                // liess sich nicht finden. „Plan B (2010)" heisst bei TMDB
+                // „DivertiMento – Plan B" und ist von 2011; mit dem Jahr aus
+                // dem Dateinamen kam nie ein Treffer.
+                //
+                // Davor stand hier `film.Year`, also das Jahr aus der
+                // Zuordnung, die gerade korrigiert werden soll — ein falscher
+                // Treffer verhinderte so seine eigene Korrektur. Auch das ist
+                // damit erledigt.
+                year);
 
             return Results.Ok(vorschläge.Select(v =>
                 new MatchCandidate(v.ProviderId, v.Title, v.Year, v.Overview, v.Poster?.Url)).ToList());
@@ -319,8 +325,8 @@ public static class MatchEndpoints
 
             var vorschläge = await anbieter.SearchSeriesAsync(
                 string.IsNullOrWhiteSpace(query) ? serie.ParsedTitle : query.Trim(),
-                // Siehe oben: aus dem Dateinamen, nicht aus der Zuordnung.
-                year ?? serie.ParsedYear);
+                // Siehe oben: ein leeres Jahr ist eine Angabe, kein Fehlen.
+                year);
 
             return Results.Ok(vorschläge.Select(v =>
                 new MatchCandidate(v.ProviderId, v.Title, v.Year, v.Overview, v.Poster?.Url)).ToList());

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

@@ -65,8 +65,18 @@ public class MatchCorrectionTests
         public Task<MovieMetadata?> FindMovieAsync(string t, int? j, CancellationToken ct = default) =>
             Task.FromResult<MovieMetadata?>(Falsch);
 
-        public Task<IReadOnlyList<MovieMetadata>> SearchMoviesAsync(string t, int? j, CancellationToken ct = default) =>
-            Task.FromResult<IReadOnlyList<MovieMetadata>>([Falsch, Richtig]);
+        /// <summary>Womit zuletzt gesucht wurde — die Prüfungen unten lesen es.</summary>
+        public static int? ZuletztesJahr { get; private set; }
+        public static bool Gefragt { get; private set; }
+
+        public Task<IReadOnlyList<MovieMetadata>> SearchMoviesAsync(string t, int? j, CancellationToken ct = default)
+        {
+            ZuletztesJahr = j;
+            Gefragt = true;
+            return Task.FromResult<IReadOnlyList<MovieMetadata>>([Falsch, Richtig]);
+        }
+
+        public static void Vergessen() { ZuletztesJahr = null; Gefragt = false; }
 
         public Task<MovieMetadata?> GetMovieAsync(int id, CancellationToken ct = default) =>
             Task.FromResult<MovieMetadata?>(
@@ -133,6 +143,46 @@ public class MatchCorrectionTests
         Assert.That(vorschläge!.Select(v => v.Title), Does.Contain("Dark"));
     }
 
+    /// <summary>Ein leeres Jahrfeld heisst „ich weiss es nicht", nicht „nimm das vom Dateinamen".</summary>
+    ///
+    /// <remarks>
+    /// <b>Der Anlass.</b> „Plan B (2010)" heisst bei TMDB „DivertiMento –
+    /// Plan B" und ist von 2011. Wer das Jahr aus der Maske herausnahm, um
+    /// ohne es zu suchen, bekam trotzdem keinen Treffer: der Server reichte
+    /// das Jahr aus dem Dateinamen nach. Das leere Feld hatte damit gar
+    /// keine Wirkung, und ein falsch benannter Film war von Hand nicht zu
+    /// finden.
+    /// </remarks>
+    [Test]
+    public async Task Ohne_Jahr_wird_wirklich_ohne_Jahr_gesucht()
+    {
+        var (client, film) = await Eingelesen(beiwerkSchreiben: false);
+        ZweiTreffer.Vergessen();
+
+        await client.GetFromJsonAsync<List<MatchCandidate>>(
+            $"/api/v1/movies/{film.Id}/matches?query=Plan%20B");
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(ZweiTreffer.Gefragt, Is.True, "die Suche muss überhaupt stattgefunden haben");
+            Assert.That(ZweiTreffer.ZuletztesJahr, Is.Null,
+                "das Jahr aus dem Dateinamen darf nicht nachgereicht werden");
+        });
+    }
+
+    /// <summary>Ein angegebenes Jahr geht unverändert weiter.</summary>
+    [Test]
+    public async Task Ein_angegebenes_Jahr_kommt_an()
+    {
+        var (client, film) = await Eingelesen(beiwerkSchreiben: false);
+        ZweiTreffer.Vergessen();
+
+        await client.GetFromJsonAsync<List<MatchCandidate>>(
+            $"/api/v1/movies/{film.Id}/matches?query=Plan%20B&year=2011");
+
+        Assert.That(ZweiTreffer.ZuletztesJahr, Is.EqualTo(2011));
+    }
+
     [Test]
     public async Task Eine_Korrektur_greift_sofort()
     {

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

@@ -885,15 +885,25 @@ public class MetadataTests
     /// <summary>Eine falsche Zuordnung darf ihre eigene Korrektur nicht verhindern.</summary>
     ///
     /// <remarks>
+    /// <para>
     /// <b>Aus dem echten Bestand.</b> „Doctor Strange" war fälschlich auf ein
     /// Making-of von 2022 gelaufen. Beim Korrigieren hängte die Suche
     /// <c>year=2022</c> an — aus genau der Zuordnung, die gerade weg sollte —
     /// und lieferte nur noch Titel von 2022. Der richtige Film von 2016 konnte
-    /// gar nicht erscheinen. Gesucht wird deshalb mit dem Jahr aus dem
-    /// Dateinamen, nie mit dem aus dem Treffer.
+    /// gar nicht erscheinen.
+    /// </para>
+    /// <para>
+    /// <b>Danach stand hier das Jahr aus dem Dateinamen, und auch das war
+    /// falsch.</b> Ein leeres Jahrfeld heisst „ich weiss es nicht" — und
+    /// gerade bei einem falsch benannten Film ist der Dateiname die
+    /// unzuverlässigste Quelle, die es gibt. „Plan B (2010)" heisst bei TMDB
+    /// „DivertiMento – Plan B" und ist von 2011; mit dem nachgereichten 2010
+    /// kam nie ein Treffer, und das leere Feld hatte keine Wirkung. Ohne
+    /// Angabe wird jetzt ohne Jahr gesucht.
+    /// </para>
     /// </remarks>
     [Test]
-    public async Task Die_Vorschlagssuche_nimmt_das_Jahr_aus_dem_Dateinamen()
+    public async Task Die_Vorschlagssuche_nimmt_ohne_Angabe_gar_kein_Jahr()
     {
         Datei("Doctor Strange (2016).mkv");
         var anbieter = new VorgegebenerAnbieter
@@ -916,8 +926,9 @@ public class MetadataTests
         await client.GetFromJsonAsync<List<MatchCandidate>>(
             $"/api/v1/movies/{filme.Items[0].Id}/matches");
 
-        Assert.That(anbieter.Gefragt, Does.Contain("suchFilm:Doctor Strange:2016"),
-            "Gesucht wird mit 2016 aus dem Dateinamen, nicht mit 2022 aus dem Treffer.");
+        Assert.That(anbieter.Gefragt, Does.Contain("suchFilm:Doctor Strange:"),
+            "Ohne Angabe wird ohne Jahr gesucht — weder mit 2022 aus dem Treffer "
+            + "noch mit 2016 aus dem Dateinamen.");
     }
 
     /// <summary>Zwei Dateien auf denselben Film zu legen ist kein Fehler.</summary>