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>
2026-10-04 13:58:33 +02:00
parent 228c318ad2
commit fa18c0d7fa
13 changed files with 490 additions and 76 deletions
@@ -85,13 +85,32 @@ public sealed record Bildauswahl(
 public sealed record BildWahlRequest(string Kind, string? Url);

 /// <summary>Ein Titel, der noch wartet oder geplant ist.</summary>
+///
+/// <remarks>
+/// <b>Eine Zeile je Serie, nicht je Folge.</b> Bei zwanzig neuen Folgen
+/// derselben Serie wären zwanzig Zeilen zwanzig Entscheidungen für eine
+/// Sache. Die Folgen stecken in <see cref="Ids"/>; freigegeben werden sie
+/// gemeinsam.
+/// </remarks>
 public sealed record Pruefeintrag(
-    string Kind, Guid Id, string Title, int? Year, string? PosterImage,
+    /// <summary><c>movie</c> oder <c>series</c>.</summary>
+    string Kind,
+    Guid Id, string Title, int? Year, string? PosterImage,
    /// <summary><c>null</c> heisst: wartet. Ein Zeitpunkt in der Zukunft heisst: geplant.</summary>
+    ///
+    /// <remarks>
+    /// Bei einer Serie nur gesetzt, wenn alle Folgen denselben Termin tragen —
+    /// sonst wäre es eine Behauptung über zwanzig Folgen, von denen eine
+    /// anders liegt.
+    /// </remarks>
    DateTimeOffset? PublishAt,
    string? Path,
    /// <summary>Ob eine Zuordnung besteht — ohne sie fehlen Titel und Bilder.</summary>
-    bool Matched);
+    bool Matched,
+    /// <summary>Wie viele Titel dahinterstecken — bei einer Serie die Zahl der Folgen.</summary>
+    int Count,
+    /// <summary>Worauf eine Freigabe wirkt.</summary>
+    IReadOnlyList<Guid> Ids);

 public sealed record FreigabeRequest(IReadOnlyList<Guid>? Ids, DateTimeOffset? PublishAt);

@@ -26,24 +26,56 @@ public static class FreigabeEndpoints
                .Select(m => new Pruefeintrag(
                    "movie", m.Id, m.Title, m.Year, m.PosterImage, m.PublishAt,
                    db.MediaFiles.Where(f => f.MovieId == m.Id).Select(f => f.Path).FirstOrDefault(),
-                    m.TmdbId != null))
+                    m.TmdbId != null, 1, new List<Guid> { m.Id }))
                .ToListAsync(ct);

-            var folgen = await db.Episodes.AsNoTracking()
+            // **Folgen werden nach Serie gebündelt.** Zwanzig neue Folgen
+            // derselben Serie sind eine Entscheidung, nicht zwanzig.
+            var offeneFolgen = await db.Episodes.AsNoTracking()
                .Where(f => f.PublishAt == null || f.PublishAt > jetzt)
-                .OrderBy(f => f.SeasonNumber).ThenBy(f => f.EpisodeNumber)
-                .Select(f => new Pruefeintrag(
-                    "episode", f.Id,
-                    db.Series.Where(s => s.Id == f.SeriesId).Select(s => s.Title).First()
-                        + $" · S{f.SeasonNumber}E{f.EpisodeNumber}",
-                    null,
-                    db.Series.Where(s => s.Id == f.SeriesId).Select(s => s.PosterImage).First(),
-                    f.PublishAt,
-                    db.MediaFiles.Where(d => d.EpisodeId == f.Id).Select(d => d.Path).FirstOrDefault(),
-                    true))
+                .Select(f => new
+                {
+                    f.Id, f.SeriesId, f.SeasonNumber, f.EpisodeNumber, f.PublishAt,
+                    Pfad = db.MediaFiles.Where(d => d.EpisodeId == f.Id)
+                        .Select(d => d.Path).FirstOrDefault(),
+                })
                .ToListAsync(ct);

-            return Results.Ok(filme.Concat(folgen).ToList());
+            var serienIds = offeneFolgen.Select(f => f.SeriesId).Distinct().ToList();
+            var serien = await db.Series.AsNoTracking()
+                .Where(s => serienIds.Contains(s.Id))
+                .Select(s => new { s.Id, s.Title, s.Year, s.PosterImage, Zugeordnet = s.TmdbId != null })
+                .ToDictionaryAsync(s => s.Id, ct);
+
+            var gebuendelt = offeneFolgen
+                .GroupBy(f => f.SeriesId)
+                .Select(g =>
+                {
+                    var serie = serien.GetValueOrDefault(g.Key);
+                    var termine = g.Select(f => f.PublishAt).Distinct().ToList();
+
+                    return new Pruefeintrag(
+                        "series", g.Key,
+                        serie?.Title ?? "Unbekannte Serie",
+                        serie?.Year,
+                        serie?.PosterImage,
+                        // Nur wenn alle denselben Termin tragen — sonst wäre es
+                        // eine Behauptung über Folgen, die anders liegen.
+                        termine.Count == 1 ? termine[0] : null,
+                        Pfad(g.Select(f => f.Pfad).FirstOrDefault()),
+                        serie?.Zugeordnet ?? false,
+                        g.Count(),
+                        g.OrderBy(f => f.SeasonNumber).ThenBy(f => f.EpisodeNumber)
+                            .Select(f => f.Id).ToList());
+                })
+                .OrderBy(e => e.Title)
+                .ToList();
+
+            return Results.Ok(filme.Concat(gebuendelt).ToList());
+
+            // Bei einer Serie sagt der Ordner mehr als die erste Folgendatei.
+            static string? Pfad(string? datei) =>
+                datei is null ? null : System.IO.Path.GetDirectoryName(datei);
        });

        // Veröffentlichen oder planen. Ohne Zeitpunkt heisst: jetzt.