Ein Klick, der nichts tat, und niemand sagte warum

Eine Serienkachel kannte der Server als Titel nicht: „als gesehen markieren"
lief in eine 404, und weil das Kontextmenü die Ablehnung verschluckte, geschah
sichtbar gar nichts. Dasselbe beim Favoriten. UserItemState bekommt eine
Serienkennung, das Häkchen zieht alle Folgen mit, und was wirft, erscheint als
Meldung statt in der Browserkonsole.

Dazu eine Mehrfachauswahl in der Mediathek — gesehen, ungesehen, Metadaten
neu holen für das Gewählte, in einer Anfrage statt in zweihundert. Ein neues
Plakat steht sofort auf der Kachel, und ein Titel, den es nicht mehr gibt,
endet nicht mehr in einer Sackgasse.

Gemessen: ein POST auf /refresh ohne Rumpf antwortete nach der Erweiterung mit
404 — also genau der Aufruf „alles auffrischen", den es länger gibt als die
Auswahl. Der Rumpf wird jetzt von Hand gelesen, und beide Formen stehen in
einer Prüfung.

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

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

@@ -22,6 +22,15 @@ public static class PlaybackEndpoints
 {
     private const int HöchstensJeSeite = 200;
 
+    /// <summary>Wie viele Titel eine Sammelanfrage höchstens trägt.</summary>
+    ///
+    /// <remarks>
+    /// <b>Grosszügig, aber nicht offen.</b> Eine Mediathek mit 500 Filmen
+    /// lässt sich damit in einem Zug abhaken; eine Anfrage mit 50 000
+    /// Kennungen ist keine Bedienung mehr, sondern ein Angriff.
+    /// </remarks>
+    private const int HöchstensJeZug = 1000;
+
     public static void MapPlayback(this IEndpointRouteBuilder app)
     {
         MapZustand(app);
@@ -114,12 +123,66 @@ public static class PlaybackEndpoints
                 zustand.Dismissed = false;
             }
 
+            // **Eine Serie zieht ihre Folgen mit.** Sonst stünde das Häkchen an
+            // der Serie und daneben „noch 42 offen".
+            if (zustand.SeriesId is { } serie)
+                await FolgenSetzen(db, benutzer, serie, anfrage.Watched, clock);
+
             zustand.UpdatedAt = clock.GetUtcNow();
             Nachfuehren(zustand);
             await db.SaveChangesAsync();
             return Results.Ok(Abbild(zustand));
         });
 
+        // **Viele auf einmal.** Eigene Route, weil `/items/{id}` eine Kennung
+        // im Pfad trägt und eine Liste keine hat.
+        app.MapPut("/api/v1/items/watched", async (
+            BulkWatchedRequest anfrage, ClaimsPrincipal wer, FlaroContext db, TimeProvider clock) =>
+        {
+            if (Benutzer(wer) is not { } benutzer) return Results.Unauthorized();
+            if (anfrage.Ids.Count == 0)
+                return Results.Ok(new BulkWatchedResponse(0, []));
+            if (anfrage.Ids.Count > HöchstensJeZug)
+                return Results.Problem(
+                    $"Mehr als {HöchstensJeZug} Titel auf einmal gehen nicht. "
+                    + "Nimm weniger und wiederhole es.",
+                    statusCode: StatusCodes.Status400BadRequest);
+
+            var jetzt = clock.GetUtcNow();
+            var unbekannt = new List<Guid>();
+            var geaendert = 0;
+
+            // **Nacheinander, nicht in einem Rutsch.** Eine Serie zieht ihre
+            // Folgen mit, und dafür gibt es keine Mengenoperation, die das
+            // ebenso richtig täte. Gespeichert wird einmal am Ende.
+            foreach (var id in anfrage.Ids.Distinct())
+            {
+                var zustand = await Zustand(db, benutzer, id);
+                if (zustand is null) { unbekannt.Add(id); continue; }
+
+                if (zustand.Watched == anfrage.Watched && zustand.Position == TimeSpan.Zero) continue;
+
+                if (anfrage.Watched && !zustand.Watched)
+                {
+                    zustand.PlayCount++;
+                    zustand.LastPlayedAt = jetzt;
+                }
+                zustand.Watched = anfrage.Watched;
+                zustand.Position = TimeSpan.Zero;
+                zustand.Dismissed = false;
+                zustand.UpdatedAt = jetzt;
+                Nachfuehren(zustand);
+
+                if (zustand.SeriesId is { } serie)
+                    await FolgenSetzen(db, benutzer, serie, anfrage.Watched, clock);
+
+                geaendert++;
+            }
+
+            await db.SaveChangesAsync();
+            return Results.Ok(new BulkWatchedResponse(geaendert, unbekannt));
+        }).RequireAuthorization();
+
         // Aus „Weiterschauen" nehmen, ohne zu behaupten, man habe es gesehen.
         titel.MapPost("/dismiss", async (
             Guid id, ClaimsPrincipal wer, FlaroContext db, TimeProvider clock) =>
@@ -455,14 +518,23 @@ public static class PlaybackEndpoints
     /// <summary>Holt den Stand oder legt ihn an — <c>null</c>, wenn es den Titel nicht gibt.</summary>
     ///
     /// <remarks>
-    /// <b>Erst Film, dann Folge.</b> Zwei Abfragen im schlechteren Fall. Eine
-    /// gemeinsame Tabelle für beides würde eine sparen und dafür an jeder
-    /// anderen Stelle im Modell kosten.
+    /// <para>
+    /// <b>Erst Film, dann Folge, dann Serie.</b> Drei Abfragen im schlechtesten
+    /// Fall. Eine gemeinsame Tabelle für alles würde zwei sparen und dafür an
+    /// jeder anderen Stelle im Modell kosten.
+    /// </para>
+    /// <para>
+    /// <b>Dass die Serie fehlte, war ein stiller Fehler.</b> Jede Aktion auf
+    /// einer Serienkachel — als gesehen markieren, zu den Favoriten — bekam
+    /// eine 404, und weil das Kontextmenü die Ablehnung verschluckte, geschah
+    /// sichtbar gar nichts.
+    /// </para>
     /// </remarks>
     private static async Task<UserItemState?> Zustand(FlaroContext db, Guid benutzer, Guid titel)
     {
         var vorhanden = await db.UserItemStates
-            .FirstOrDefaultAsync(z => z.UserId == benutzer && (z.MovieId == titel || z.EpisodeId == titel));
+            .FirstOrDefaultAsync(z => z.UserId == benutzer
+                && (z.MovieId == titel || z.EpisodeId == titel || z.SeriesId == titel));
         if (vorhanden is not null) return vorhanden;
 
         if (await db.Movies.AnyAsync(m => m.Id == titel))
@@ -479,9 +551,67 @@ public static class PlaybackEndpoints
             return neu;
         }
 
+        if (await db.Series.AnyAsync(s => s.Id == titel))
+        {
+            var neu = new UserItemState { UserId = benutzer, SeriesId = titel };
+            db.UserItemStates.Add(neu);
+            return neu;
+        }
+
         return null;
     }
 
+    /// <summary>Setzt das Häkchen an allen Folgen einer Serie — oder nimmt es weg.</summary>
+    ///
+    /// <remarks>
+    /// <para>
+    /// <b>„Serie gesehen" heisst: jede Folge gesehen.</b> Nur die Zeile der
+    /// Serie zu setzen liesse die Folgenliste unverändert und den Zähler
+    /// „noch 42 offen" daneben stehen — zwei Angaben, die sich widersprechen.
+    /// </para>
+    /// <para>
+    /// <b>Die Stelle bleibt, wo sie ist.</b> Wer eine Serie von Hand abhakt,
+    /// will sie aus dem Weg haben; eine halb gesehene Folge soll dadurch nicht
+    /// ihren Fortschritt verlieren, falls er doch zurückkommt. Nur
+    /// „Weiterschauen" räumt sich auf, weil ein Abgehaktes dort nichts zu
+    /// suchen hat.
+    /// </para>
+    /// </remarks>
+    private static async Task FolgenSetzen(
+        FlaroContext db, Guid benutzer, Guid serie, bool gesehen, TimeProvider clock)
+    {
+        var folgen = await db.Episodes.AsNoTracking()
+            .Where(f => f.SeriesId == serie)
+            .Select(f => f.Id)
+            .ToListAsync();
+        if (folgen.Count == 0) return;
+
+        var staende = await db.UserItemStates
+            .Where(z => z.UserId == benutzer && z.EpisodeId != null && folgen.Contains(z.EpisodeId.Value))
+            .ToListAsync();
+        var bekannt = staende.ToDictionary(z => z.EpisodeId!.Value);
+
+        var jetzt = clock.GetUtcNow();
+        foreach (var folge in folgen)
+        {
+            if (!bekannt.TryGetValue(folge, out var zustand))
+            {
+                // Ungesehen ist der Normalfall — dafür braucht es keine Zeile.
+                if (!gesehen) continue;
+                zustand = new UserItemState { UserId = benutzer, EpisodeId = folge };
+                db.UserItemStates.Add(zustand);
+            }
+
+            if (gesehen && !zustand.Watched) zustand.PlayCount++;
+            zustand.Watched = gesehen;
+            zustand.Position = TimeSpan.Zero;
+            zustand.Dismissed = false;
+            if (gesehen) zustand.LastPlayedAt = jetzt;
+            zustand.UpdatedAt = jetzt;
+            Nachfuehren(zustand);
+        }
+    }
+
     /// <summary>Die Laufzeit aus der längsten Datei hinter dem Titel.</summary>
     ///
     /// <remarks>
@@ -489,10 +619,16 @@ public static class PlaybackEndpoints
     /// eine beschnittene sein mag. Gegen die kürzere zu messen hiesse, einen
     /// Film für gesehen zu halten, der noch zwanzig Minuten vor sich hat.
     /// </remarks>
-    private static async Task<TimeSpan?> Dateilaufzeit(FlaroContext db, UserItemState zustand) =>
-        await db.MediaFiles.AsNoTracking()
+    private static async Task<TimeSpan?> Dateilaufzeit(FlaroContext db, UserItemState zustand)
+    {
+        // Eine Serie hat keine eigene Datei. Ohne diese Zeile verglich die
+        // Abfrage `EpisodeId == null` und nahm die längste herrenlose Datei.
+        if (zustand.MovieId is null && zustand.EpisodeId is null) return null;
+
+        return await db.MediaFiles.AsNoTracking()
             .Where(d => zustand.MovieId != null ? d.MovieId == zustand.MovieId : d.EpisodeId == zustand.EpisodeId)
             .MaxAsync(d => (TimeSpan?)d.Duration);
+    }
 
     internal static ItemStateResponse Abbild(UserItemState z) => new(
         z.Position.TotalSeconds, z.Runtime?.TotalSeconds,