Stufe 4: Fortschritt ab der ersten Sekunde, ohne Schwelle

Der Anlass für diesen Server, jetzt als Code. Fortschritt, Gesehen-Status,
Weiterschauen, Nächste Folge, Favoriten und Bewertungen — alles je Benutzer.

**Die Jellyfin-Werte sind jetzt belegt statt behauptet.** Das Entwurfsdokument
hatte das ausdrücklich offengelassen („aus dem Gedächtnis"); hier stehen sie
aus `MediaBrowser.Model/Configuration/ServerConfiguration.cs` und
`Emby.Server.Implementations/Library/UserDataManager.cs`:

| | Vorgabe | Was passiert |
|---|---|---|
| `MinResumePct` | 5 | darunter `positionTicks = 0` — Kommentar im Quelltext: „ignore progress during the beginning" |
| `MaxResumePct` | 90 | darüber gesehen, Position **auf 0** |
| `MinResumeDurationSeconds` | 300 | alles unter fünf Minuten gilt nach dem ersten Lebenszeichen als gesehen |

Bei einem Zweistünder sind die ersten sechs Minuten damit weg. Eine
vierminütige Folge gilt nach dreissig Sekunden als vollständig gesehen. Und
fehlt die Laufzeit, nimmt Jellyfin an, der Titel sei durch — wörtlich:
„we'll just have to assume it was fully played".

**Flaro legt jede Meldung ab und wirft nie eine Position weg.** Eine Grenze
fürs Häkchen gibt es trotzdem — 90 %, sonst stünde jeder zu Ende geschaute
Film für immer bei 98 % in Weiterschauen. Der Unterschied ist nicht, *dass*
es die Grenze gibt, sondern was sie anrichtet: hier wird ein Häkchen gesetzt,
dort zusätzlich die Stelle vernichtet. Wer einen gesehenen Film noch einmal
anfängt, hat beides — das Häkchen und den Punkt, an dem er steht.

Ohne bekannte Laufzeit wird nichts vermutet. Das ist der Fehler, den man
nicht zurücknehmen kann, ohne ihn zu bemerken.

---

**Eine Spalte statt einer zweiten Regel.** „Gehört in Weiterschauen" vergleicht
die Stelle mit einem Anteil der Laufzeit, und diese Rechnung lässt sich nicht
nach SQL übersetzen. Die Regel daneben noch einmal als Abfrage zu schreiben
wäre die Variante, bei der beide irgendwann auseinanderlaufen — unbemerkt,
weil keine von beiden dabei falsch aussieht. Stattdessen hält `InProgress`
das Ergebnis fest, geschrieben an genau einer Stelle. Eine Prüfung hält Reihe
und Regel über vier Stände gegeneinander.

**„Weiterschauen" und „Nächste Folge" überschneiden sich nicht.** Was
angefangen ist, steht links; was ansteht, rechts. Jellyfin zeigt beides
doppelt, und auf einer Startseite mit zwei Reihen nebeneinander sieht das
nach einem Fehler aus.

Dazu, weil die App sie braucht: Einzelabruf für Film und Serie, die nächste
Folge nach einer gegebenen, und der Zustand hängt an jeder Liste mit dran —
in einer Abfrage je Seite, nicht in einer je Titel.

Ein Titel wird über seine Kennung allein angesprochen, ohne dass der Aufrufer
sagen muss, ob es ein Film oder eine Folge ist. Die App hat diese Auskunft an
der Stelle nicht.

348 Tests grün. Im Container nachgewiesen: fünf Minuten „Der Untergang" von
2:36 bleiben stehen, bei Minute 150 kommt das Häkchen und die Stelle bleibt,
beim zweiten Anlauf steht der Film mit beidem wieder in der Reihe — und nach
Folge 1 von Dark zeigt „Nächste Folge" S01E02.

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

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

@@ -0,0 +1,196 @@
+using Flaro.Core.Playback;
+
+namespace Flaro.Core.Tests;
+
+/// <summary>Die Regel, um derentwillen dieser Server existiert.</summary>
+[TestFixture]
+public sealed class ProgressRuleTests
+{
+    private static readonly TimeSpan Zweistünder = TimeSpan.FromHours(2);
+
+    /// <summary>Der Fall, der den Ausschlag gab.</summary>
+    ///
+    /// <remarks>
+    /// Jellyfins <c>MinResumePct</c> steht auf 5. Bei zwei Stunden sind das
+    /// sechs Minuten, und wer nach fünf abbricht, findet beim nächsten Mal
+    /// nichts vor. Hier ist genau diese Stelle abgelegt.
+    /// </remarks>
+    [Test]
+    public void Die_ersten_Minuten_zaehlen_auch()
+    {
+        var ergebnis = ProgressRule.Apply(TimeSpan.FromMinutes(5), Zweistünder);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(ergebnis.Position, Is.EqualTo(TimeSpan.FromMinutes(5)));
+            Assert.That(ergebnis.Watched, Is.False);
+        });
+    }
+
+    [Test]
+    public void Eine_einzige_Sekunde_zaehlt_auch()
+    {
+        var ergebnis = ProgressRule.Apply(TimeSpan.FromSeconds(1), Zweistünder);
+
+        Assert.That(ergebnis.Position, Is.EqualTo(TimeSpan.FromSeconds(1)));
+    }
+
+    /// <summary>Jellyfins <c>MinResumeDurationSeconds</c> steht auf 300.</summary>
+    ///
+    /// <remarks>
+    /// Dort gilt eine vierminütige Folge nach dreissig Sekunden als
+    /// vollständig gesehen. Hier ist sie das, was sie ist: angefangen.
+    /// </remarks>
+    [Test]
+    public void Ein_kurzer_Titel_gilt_nicht_sofort_als_gesehen()
+    {
+        var ergebnis = ProgressRule.Apply(TimeSpan.FromSeconds(30), TimeSpan.FromMinutes(4));
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(ergebnis.Watched, Is.False);
+            Assert.That(ergebnis.Position, Is.EqualTo(TimeSpan.FromSeconds(30)));
+        });
+    }
+
+    [Test]
+    public void Kurz_vor_Schluss_gilt_er_als_gesehen()
+    {
+        var ergebnis = ProgressRule.Apply(TimeSpan.FromMinutes(115), Zweistünder);
+
+        Assert.That(ergebnis.Watched, Is.True);
+    }
+
+    /// <summary>Und die Stelle bleibt trotzdem stehen.</summary>
+    ///
+    /// <remarks>
+    /// Jellyfin setzt sie an dieser Stelle auf null. Wer den Abspann sehen
+    /// oder die letzte Szene nochmal will, fängt dort von vorn an.
+    /// </remarks>
+    [Test]
+    public void Gesehen_wirft_die_Stelle_nicht_weg()
+    {
+        var ergebnis = ProgressRule.Apply(TimeSpan.FromMinutes(118), Zweistünder);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(ergebnis.Watched, Is.True);
+            Assert.That(ergebnis.Position, Is.EqualTo(TimeSpan.FromMinutes(118)));
+        });
+    }
+
+    [Test]
+    public void Genau_an_der_Grenze_gilt_er_als_gesehen()
+    {
+        var ergebnis = ProgressRule.Apply(Zweistünder * ProgressRule.WatchedFraction, Zweistünder);
+
+        Assert.That(ergebnis.Watched, Is.True);
+    }
+
+    [Test]
+    public void Eine_Sekunde_davor_noch_nicht()
+    {
+        var ergebnis = ProgressRule.Apply(
+            Zweistünder * ProgressRule.WatchedFraction - TimeSpan.FromSeconds(1), Zweistünder);
+
+        Assert.That(ergebnis.Watched, Is.False);
+    }
+
+    /// <summary>Ohne Laufzeit gibt es keinen Anteil — also kein Urteil.</summary>
+    ///
+    /// <remarks>
+    /// Jellyfin nimmt in diesem Fall an, der Titel sei vollständig gesehen
+    /// („we'll just have to assume it was fully played"). Das ist die
+    /// Annahme, die man nicht zurücknehmen kann, ohne sie zu bemerken.
+    /// </remarks>
+    [Test]
+    public void Ohne_Laufzeit_wird_nichts_vermutet()
+    {
+        var ergebnis = ProgressRule.Apply(TimeSpan.FromMinutes(90), null);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(ergebnis.Watched, Is.False);
+            Assert.That(ergebnis.Position, Is.EqualTo(TimeSpan.FromMinutes(90)));
+        });
+    }
+
+    [Test]
+    public void Eine_Laufzeit_von_null_ist_keine()
+    {
+        var ergebnis = ProgressRule.Apply(TimeSpan.FromMinutes(3), TimeSpan.Zero);
+
+        Assert.That(ergebnis.Watched, Is.False);
+    }
+
+    /// <summary>Spieler melden beim Spulen und beim Beenden Unsinn.</summary>
+    [Test]
+    public void Eine_negative_Stelle_wird_zu_null()
+    {
+        var ergebnis = ProgressRule.Apply(TimeSpan.FromSeconds(-5), Zweistünder);
+
+        Assert.That(ergebnis.Position, Is.EqualTo(TimeSpan.Zero));
+    }
+
+    [Test]
+    public void Jenseits_des_Endes_wird_auf_das_Ende_gekuerzt()
+    {
+        var ergebnis = ProgressRule.Apply(Zweistünder + TimeSpan.FromSeconds(3), Zweistünder);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(ergebnis.Position, Is.EqualTo(Zweistünder));
+            Assert.That(ergebnis.Watched, Is.True);
+        });
+    }
+
+    // --- Weiterschauen ---------------------------------------------------
+
+    [Test]
+    public void Angefangen_gehoert_in_Weiterschauen()
+    {
+        Assert.That(ProgressRule.BelongsInContinueWatching(
+            Zustand(TimeSpan.FromMinutes(20), Zweistünder)), Is.True);
+    }
+
+    [Test]
+    public void Nie_angefangen_gehoert_nicht_hinein()
+    {
+        Assert.That(ProgressRule.BelongsInContinueWatching(
+            Zustand(TimeSpan.Zero, Zweistünder)), Is.False);
+    }
+
+    [Test]
+    public void Durchgeschaut_gehoert_nicht_hinein()
+    {
+        Assert.That(ProgressRule.BelongsInContinueWatching(
+            Zustand(TimeSpan.FromMinutes(118), Zweistünder)), Is.False);
+    }
+
+    [Test]
+    public void Weggelegtes_gehoert_nicht_hinein()
+    {
+        var zustand = Zustand(TimeSpan.FromMinutes(20), Zweistünder);
+        zustand.Dismissed = true;
+
+        Assert.That(ProgressRule.BelongsInContinueWatching(zustand), Is.False);
+    }
+
+    /// <summary>Ein zweites Mal angefangen — dann steht er wieder da.</summary>
+    ///
+    /// <remarks>
+    /// Das Häkchen bleibt: gesehen hat man ihn ja. Beides nebeneinander ist
+    /// genau das, was ohne weggeworfene Position möglich wird.
+    /// </remarks>
+    [Test]
+    public void Ein_gesehener_Titel_kommt_beim_zweiten_Mal_zurueck()
+    {
+        var zustand = Zustand(TimeSpan.FromMinutes(10), Zweistünder);
+        zustand.Watched = true;
+
+        Assert.That(ProgressRule.BelongsInContinueWatching(zustand), Is.True);
+    }
+
+    private static UserItemState Zustand(TimeSpan stelle, TimeSpan? laenge) =>
+        new() { UserId = Guid.CreateVersion7(), MovieId = Guid.CreateVersion7(), Position = stelle, Runtime = laenge };
+}