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>
This commit is contained in:
Scarriffle
co-authored by
Claude Opus 5
Claude Opus 5
parent
705ec87416
commit
c4081ff251
@@ -75,16 +75,26 @@ public sealed record MediaFileResponse(
|
||||
public sealed record MovieResponse(
|
||||
Guid Id, string Title, int? Year, string? Overview,
|
||||
string? PosterImage, string? BackdropImage,
|
||||
IReadOnlyList<MediaFileResponse> Files);
|
||||
IReadOnlyList<MediaFileResponse> Files,
|
||||
ItemStateResponse? State);
|
||||
|
||||
public sealed record SeriesResponse(
|
||||
Guid Id, string Title, int? Year, string? Overview,
|
||||
string? PosterImage, string? BackdropImage,
|
||||
int EpisodeCount, IReadOnlyList<int> Seasons);
|
||||
int EpisodeCount, IReadOnlyList<int> Seasons,
|
||||
/// <summary>Wie viele Folgen dieser Benutzer noch nicht gesehen hat.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// Statt eines Zustands je Serie: eine Serie wird nicht angeschaut,
|
||||
/// ihre Folgen werden es. Was man an der Kachel sehen will, ist die Zahl
|
||||
/// — bei Plex steht sie als Plakette in der Ecke.
|
||||
/// </remarks>
|
||||
int UnwatchedCount);
|
||||
|
||||
public sealed record EpisodeResponse(
|
||||
Guid Id, int Season, int Episode, string? Title, string? Overview, string? StillImage,
|
||||
IReadOnlyList<MediaFileResponse> Files);
|
||||
IReadOnlyList<MediaFileResponse> Files,
|
||||
ItemStateResponse? State);
|
||||
|
||||
public sealed record Page<T>(IReadOnlyList<T> Items, int Total);
|
||||
|
||||
@@ -132,3 +142,41 @@ public sealed record ApplyMatchRequest(int TmdbId);
|
||||
/// <summary>Wie die Zuordnung jetzt aussieht.</summary>
|
||||
public sealed record MatchState(
|
||||
int? TmdbId, string? ImdbId, bool Locked, string Title, int? Year);
|
||||
|
||||
// --- Stufe 4: Fortschritt und Zustand -------------------------------------
|
||||
|
||||
/// <summary>Eine Fortschrittsmeldung.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>In Sekunden, nicht in Ticks.</b> Jellyfin rechnet in Hundertnanosekunden,
|
||||
/// und jeder Client muss das wissen. Sekunden als Gleitkommazahl sind in jeder
|
||||
/// Sprache dasselbe und in der Entwicklerkonsole lesbar.
|
||||
///
|
||||
/// <c>RuntimeSeconds</c> ist freiwillig: kennt der Client die Laufzeit der
|
||||
/// Fassung, die er gerade abspielt, ist seine Angabe genauer als die des
|
||||
/// Servers. Fehlt sie, nimmt der Server die aus der Datei.
|
||||
/// </remarks>
|
||||
public sealed record ProgressRequest(double PositionSeconds, double? RuntimeSeconds);
|
||||
|
||||
public sealed record WatchedRequest(bool Watched);
|
||||
public sealed record FavouriteRequest(bool Favourite);
|
||||
public sealed record RatingRequest(int? Rating);
|
||||
|
||||
/// <summary>Was ein Benutzer mit einem Titel zu tun hatte.</summary>
|
||||
public sealed record ItemStateResponse(
|
||||
double PositionSeconds, double? RuntimeSeconds,
|
||||
bool Watched, int PlayCount, bool Favourite, int? Rating, bool Dismissed,
|
||||
DateTimeOffset? LastPlayedAt);
|
||||
|
||||
/// <summary>Eine Zeile in „Weiterschauen".</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// Film und Folge in einer Form, weil die Reihe beide mischt. Bei einer Folge
|
||||
/// steht in <c>Title</c> die Serie und in <c>SubTitle</c> die Folge — so liest
|
||||
/// sich die Kachel wie bei Plex: oben, worum es geht, darunter, wo man ist.
|
||||
/// </remarks>
|
||||
public sealed record ContinueEntry(
|
||||
Guid Id, string Kind, string Title, string? SubTitle,
|
||||
int? Season, int? Episode, int? Year,
|
||||
string? PosterImage, string? BackdropImage,
|
||||
ItemStateResponse State);
|
||||
|
||||
@@ -1,3 +1,5 @@
|
||||
using System.Security.Claims;
|
||||
using Flaro.Core.Playback;
|
||||
using Flaro.Data;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
|
||||
@@ -45,6 +47,48 @@ public static class LibraryContentEndpoints
|
||||
ILookup<Guid, MediaStreamResponse> spuren) =>
|
||||
new(id, System.IO.Path.GetFileName(pfad), bytes, schachtel, dauer?.TotalSeconds, spuren[id].ToList());
|
||||
|
||||
/// <summary>Die Stände dieses Benutzers zu den genannten Titeln.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// In einer Abfrage für die ganze Seite. Ein Titel ohne Zeile hat keinen
|
||||
/// Stand — das ist kein Fehler, sondern der Normalfall für alles, was
|
||||
/// noch niemand angefasst hat, und die Antwort trägt dort <c>null</c>.
|
||||
/// </remarks>
|
||||
private static async Task<Dictionary<Guid, ItemStateResponse>> ZuständeZu(
|
||||
FlaroContext db, ClaimsPrincipal wer, List<Guid>? filme = null, List<Guid>? folgen = null)
|
||||
{
|
||||
if (PlaybackEndpoints.Benutzer(wer) is not { } benutzer) return [];
|
||||
|
||||
var gesucht = (filme ?? folgen)!;
|
||||
if (gesucht.Count == 0) return [];
|
||||
|
||||
var zeilen = await db.UserItemStates.AsNoTracking()
|
||||
.Where(z => z.UserId == benutzer)
|
||||
.Where(z => filme != null
|
||||
? z.MovieId != null && gesucht.Contains(z.MovieId!.Value)
|
||||
: z.EpisodeId != null && gesucht.Contains(z.EpisodeId!.Value))
|
||||
.ToListAsync();
|
||||
|
||||
return zeilen.ToDictionary(
|
||||
z => (filme != null ? z.MovieId : z.EpisodeId)!.Value,
|
||||
PlaybackEndpoints.Abbild);
|
||||
}
|
||||
|
||||
/// <summary>Welche der genannten Folgen dieser Benutzer gesehen hat.</summary>
|
||||
private static async Task<HashSet<Guid>> GeseheneFolgen(
|
||||
FlaroContext db, ClaimsPrincipal wer, List<Guid> folgen)
|
||||
{
|
||||
if (PlaybackEndpoints.Benutzer(wer) is not { } benutzer || folgen.Count == 0) return [];
|
||||
|
||||
var ids = await db.UserItemStates.AsNoTracking()
|
||||
.Where(z => z.UserId == benutzer && z.Watched
|
||||
&& z.EpisodeId != null && folgen.Contains(z.EpisodeId!.Value))
|
||||
.Select(z => z.EpisodeId!.Value)
|
||||
.ToListAsync();
|
||||
|
||||
return [.. ids];
|
||||
}
|
||||
|
||||
private static void MapScan(IEndpointRouteBuilder app)
|
||||
{
|
||||
app.MapPost("/api/v1/libraries/{id:guid}/scan", async (
|
||||
@@ -82,7 +126,7 @@ public static class LibraryContentEndpoints
|
||||
private static void MapBrowse(IEndpointRouteBuilder app)
|
||||
{
|
||||
app.MapGet("/api/v1/movies", async (
|
||||
FlaroContext db, Guid? library, string? search, int skip = 0, int take = 50) =>
|
||||
ClaimsPrincipal wer, FlaroContext db, Guid? library, string? search, int skip = 0, int take = 50) =>
|
||||
{
|
||||
var abfrage = db.Movies.AsNoTracking();
|
||||
if (library is { } kennung) abfrage = abfrage.Where(m => m.LibraryId == kennung);
|
||||
@@ -105,17 +149,19 @@ public static class LibraryContentEndpoints
|
||||
.Select(f => new { f.Id, f.Path, f.SizeBytes, f.Container, f.Duration, f.MovieId })
|
||||
.ToListAsync();
|
||||
var spuren = await SpurenZu(db, dateien.Select(f => f.Id).ToList());
|
||||
var stände = await ZuständeZu(db, wer, filme: ids);
|
||||
|
||||
var items = kennungen.Select(m => new MovieResponse(
|
||||
m.Id, m.Title, m.Year, m.Overview, m.PosterImage, m.BackdropImage,
|
||||
dateien.Where(f => f.MovieId == m.Id)
|
||||
.Select(f => Datei(f.Id, f.Path, f.SizeBytes, f.Container, f.Duration, spuren)).ToList())).ToList();
|
||||
.Select(f => Datei(f.Id, f.Path, f.SizeBytes, f.Container, f.Duration, spuren)).ToList(),
|
||||
stände.GetValueOrDefault(m.Id))).ToList();
|
||||
|
||||
return Results.Ok(new Page<MovieResponse>(items, gesamt));
|
||||
}).RequireAuthorization();
|
||||
|
||||
app.MapGet("/api/v1/series", async (
|
||||
FlaroContext db, Guid? library, string? search, int skip = 0, int take = 50) =>
|
||||
ClaimsPrincipal wer, FlaroContext db, Guid? library, string? search, int skip = 0, int take = 50) =>
|
||||
{
|
||||
var abfrage = db.Series.AsNoTracking();
|
||||
if (library is { } kennung) abfrage = abfrage.Where(s => s.LibraryId == kennung);
|
||||
@@ -132,21 +178,111 @@ public static class LibraryContentEndpoints
|
||||
var ids = serien.Select(s => s.Id).ToList();
|
||||
var folgen = await db.Episodes.AsNoTracking()
|
||||
.Where(f => ids.Contains(f.SeriesId))
|
||||
.Select(f => new { f.SeriesId, f.SeasonNumber })
|
||||
.Select(f => new { f.Id, f.SeriesId, f.SeasonNumber })
|
||||
.ToListAsync();
|
||||
|
||||
// Gesehene Folgen in **einer** Abfrage, für alle Serien der Seite
|
||||
// zusammen. Je Serie zu fragen wäre bei fünfzig Serien
|
||||
// einundfünfzig Abfragen.
|
||||
var gesehen = await GeseheneFolgen(db, wer, folgen.Select(f => f.Id).ToList());
|
||||
|
||||
var items = serien.Select(s =>
|
||||
{
|
||||
var meine = folgen.Where(f => f.SeriesId == s.Id).ToList();
|
||||
return new SeriesResponse(
|
||||
s.Id, s.Title, s.Year, s.Overview, s.PosterImage, s.BackdropImage, meine.Count,
|
||||
meine.Select(f => f.SeasonNumber).Distinct().Order().ToList());
|
||||
meine.Select(f => f.SeasonNumber).Distinct().Order().ToList(),
|
||||
meine.Count(f => !gesehen.Contains(f.Id)));
|
||||
}).ToList();
|
||||
|
||||
return Results.Ok(new Page<SeriesResponse>(items, gesamt));
|
||||
}).RequireAuthorization();
|
||||
|
||||
app.MapGet("/api/v1/series/{id:guid}/episodes", async (Guid id, FlaroContext db, int? season) =>
|
||||
// **Einzelabruf, weil ein Client nicht immer aus einer Liste kommt.**
|
||||
// Ein Link, ein Wiederaufnehmen nach Neustart, ein Eintrag aus
|
||||
// „Weiterschauen" — in all diesen Fällen hat er nur die Kennung.
|
||||
app.MapGet("/api/v1/movies/{id:guid}", async (
|
||||
Guid id, ClaimsPrincipal wer, FlaroContext db) =>
|
||||
{
|
||||
var film = await db.Movies.AsNoTracking()
|
||||
.Where(m => m.Id == id)
|
||||
.Select(m => new { m.Id, m.Title, m.Year, m.Overview, m.PosterImage, m.BackdropImage })
|
||||
.FirstOrDefaultAsync();
|
||||
if (film is null) return Results.NotFound();
|
||||
|
||||
var dateien = await db.MediaFiles.AsNoTracking()
|
||||
.Where(f => f.MovieId == id)
|
||||
.Select(f => new { f.Id, f.Path, f.SizeBytes, f.Container, f.Duration })
|
||||
.ToListAsync();
|
||||
var spuren = await SpurenZu(db, dateien.Select(f => f.Id).ToList());
|
||||
var stände = await ZuständeZu(db, wer, filme: [id]);
|
||||
|
||||
return Results.Ok(new MovieResponse(
|
||||
film.Id, film.Title, film.Year, film.Overview, film.PosterImage, film.BackdropImage,
|
||||
dateien.Select(f => Datei(f.Id, f.Path, f.SizeBytes, f.Container, f.Duration, spuren)).ToList(),
|
||||
stände.GetValueOrDefault(id)));
|
||||
}).RequireAuthorization();
|
||||
|
||||
app.MapGet("/api/v1/series/{id:guid}", async (
|
||||
Guid id, ClaimsPrincipal wer, FlaroContext db) =>
|
||||
{
|
||||
var serie = await db.Series.AsNoTracking()
|
||||
.Where(x => x.Id == id)
|
||||
.Select(x => new { x.Id, x.Title, x.Year, x.Overview, x.PosterImage, x.BackdropImage })
|
||||
.FirstOrDefaultAsync();
|
||||
if (serie is null) return Results.NotFound();
|
||||
|
||||
var folgen = await db.Episodes.AsNoTracking()
|
||||
.Where(f => f.SeriesId == id)
|
||||
.Select(f => new { f.Id, f.SeasonNumber })
|
||||
.ToListAsync();
|
||||
var gesehen = await GeseheneFolgen(db, wer, folgen.Select(f => f.Id).ToList());
|
||||
|
||||
return Results.Ok(new SeriesResponse(
|
||||
serie.Id, serie.Title, serie.Year, serie.Overview, serie.PosterImage, serie.BackdropImage,
|
||||
folgen.Count, folgen.Select(f => f.SeasonNumber).Distinct().Order().ToList(),
|
||||
folgen.Count(f => !gesehen.Contains(f.Id))));
|
||||
}).RequireAuthorization();
|
||||
|
||||
// **Die nächste Folge nach dieser.** Reihenfolge ist Staffel, dann
|
||||
// Folge — nicht die Kennung: die ist zeitlich geordnet und sagt, wann
|
||||
// der Scan sie fand, nicht wann sie läuft.
|
||||
app.MapGet("/api/v1/episodes/{id:guid}/next", async (
|
||||
Guid id, ClaimsPrincipal wer, FlaroContext db) =>
|
||||
{
|
||||
var diese = await db.Episodes.AsNoTracking()
|
||||
.Where(f => f.Id == id)
|
||||
.Select(f => new { f.SeriesId, f.SeasonNumber, f.EpisodeNumber })
|
||||
.FirstOrDefaultAsync();
|
||||
if (diese is null) return Results.NotFound();
|
||||
|
||||
var naechste = await db.Episodes.AsNoTracking()
|
||||
.Where(f => f.SeriesId == diese.SeriesId)
|
||||
.Where(f => f.SeasonNumber > diese.SeasonNumber
|
||||
|| (f.SeasonNumber == diese.SeasonNumber && f.EpisodeNumber > diese.EpisodeNumber))
|
||||
.OrderBy(f => f.SeasonNumber).ThenBy(f => f.EpisodeNumber)
|
||||
.Select(f => new { f.Id, f.SeasonNumber, f.EpisodeNumber, f.Title, f.Overview, f.StillImage })
|
||||
.FirstOrDefaultAsync();
|
||||
|
||||
// Keine weitere Folge ist kein Fehler — es war die letzte.
|
||||
if (naechste is null) return Results.NoContent();
|
||||
|
||||
var dateien = await db.MediaFiles.AsNoTracking()
|
||||
.Where(d => d.EpisodeId == naechste.Id)
|
||||
.Select(d => new { d.Id, d.Path, d.SizeBytes, d.Container, d.Duration })
|
||||
.ToListAsync();
|
||||
var spuren = await SpurenZu(db, dateien.Select(d => d.Id).ToList());
|
||||
var stände = await ZuständeZu(db, wer, folgen: [naechste.Id]);
|
||||
|
||||
return Results.Ok(new EpisodeResponse(
|
||||
naechste.Id, naechste.SeasonNumber, naechste.EpisodeNumber,
|
||||
naechste.Title, naechste.Overview, naechste.StillImage,
|
||||
dateien.Select(d => Datei(d.Id, d.Path, d.SizeBytes, d.Container, d.Duration, spuren)).ToList(),
|
||||
stände.GetValueOrDefault(naechste.Id)));
|
||||
}).RequireAuthorization();
|
||||
|
||||
app.MapGet("/api/v1/series/{id:guid}/episodes", async (
|
||||
Guid id, ClaimsPrincipal wer, FlaroContext db, int? season) =>
|
||||
{
|
||||
if (!await db.Series.AnyAsync(s => s.Id == id)) return Results.NotFound();
|
||||
|
||||
@@ -164,11 +300,13 @@ public static class LibraryContentEndpoints
|
||||
.Select(d => new { d.Id, d.Path, d.SizeBytes, d.Container, d.Duration, d.EpisodeId })
|
||||
.ToListAsync();
|
||||
var spuren = await SpurenZu(db, dateien.Select(d => d.Id).ToList());
|
||||
var stände = await ZuständeZu(db, wer, folgen: ids);
|
||||
|
||||
var items = folgen.Select(f => new EpisodeResponse(
|
||||
f.Id, f.SeasonNumber, f.EpisodeNumber, f.Title, f.Overview, f.StillImage,
|
||||
dateien.Where(d => d.EpisodeId == f.Id)
|
||||
.Select(d => Datei(d.Id, d.Path, d.SizeBytes, d.Container, d.Duration, spuren)).ToList())).ToList();
|
||||
.Select(d => Datei(d.Id, d.Path, d.SizeBytes, d.Container, d.Duration, spuren)).ToList(),
|
||||
stände.GetValueOrDefault(f.Id))).ToList();
|
||||
|
||||
return Results.Ok(new Page<EpisodeResponse>(items, items.Count));
|
||||
}).RequireAuthorization();
|
||||
|
||||
@@ -0,0 +1,360 @@
|
||||
using System.Security.Claims;
|
||||
using Flaro.Core.Playback;
|
||||
using Flaro.Data;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
|
||||
namespace Flaro.Api.Endpoints;
|
||||
|
||||
/// <summary>Fortschritt, Gesehen-Status, Favoriten — alles je Benutzer.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>Ein Titel wird über seine Kennung allein angesprochen</b>, ohne dass
|
||||
/// der Aufrufer sagen muss, ob es ein Film oder eine Folge ist. Die App hat
|
||||
/// diese Auskunft an der Stelle nicht — sie reicht durch, was eine Liste ihr
|
||||
/// gegeben hat. Der Preis ist eine zusätzliche Abfrage, wenn es eine Folge
|
||||
/// ist; der Gegenwert ist eine Schnittstelle, die man nicht falsch bedienen
|
||||
/// kann.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public static class PlaybackEndpoints
|
||||
{
|
||||
private const int HöchstensJeSeite = 200;
|
||||
|
||||
public static void MapPlayback(this IEndpointRouteBuilder app)
|
||||
{
|
||||
MapZustand(app);
|
||||
MapStartseite(app);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
// Melden
|
||||
// ------------------------------------------------------------------
|
||||
|
||||
private static void MapZustand(IEndpointRouteBuilder app)
|
||||
{
|
||||
var titel = app.MapGroup("/api/v1/items/{id:guid}").RequireAuthorization();
|
||||
|
||||
// Jede Meldung wird abgelegt — es gibt keine, die zu klein wäre.
|
||||
titel.MapPost("/progress", async (
|
||||
Guid id, ProgressRequest anfrage, ClaimsPrincipal wer, FlaroContext db, TimeProvider clock) =>
|
||||
{
|
||||
if (Benutzer(wer) is not { } benutzer) return Results.Unauthorized();
|
||||
|
||||
var zustand = await Zustand(db, benutzer, id);
|
||||
if (zustand is null) return Results.NotFound();
|
||||
|
||||
// Die Laufzeit vom Client hat Vorrang: er misst an der Fassung,
|
||||
// die er gerade abspielt. Fehlt sie, hilft die Datei weiter —
|
||||
// ohne Laufzeit gäbe es keinen Anteil und damit kein „gesehen".
|
||||
var laenge = anfrage.RuntimeSeconds is { } sekunden and > 0
|
||||
? TimeSpan.FromSeconds(sekunden)
|
||||
: zustand.Runtime ?? await Dateilaufzeit(db, zustand);
|
||||
|
||||
var ergebnis = ProgressRule.Apply(TimeSpan.FromSeconds(anfrage.PositionSeconds), laenge);
|
||||
|
||||
// **Das Häkchen wird gesetzt, nicht genommen.** Wer einen
|
||||
// gesehenen Film erneut anfängt, hat ihn trotzdem gesehen — und
|
||||
// soll beides haben: das Häkchen und die neue Stelle.
|
||||
if (ergebnis.Watched && !zustand.Watched)
|
||||
{
|
||||
zustand.Watched = true;
|
||||
zustand.PlayCount++;
|
||||
}
|
||||
|
||||
zustand.Position = ergebnis.Position;
|
||||
zustand.Runtime = laenge;
|
||||
zustand.LastPlayedAt = clock.GetUtcNow();
|
||||
zustand.UpdatedAt = clock.GetUtcNow();
|
||||
|
||||
// Wer weitersieht, hat es sich offenbar anders überlegt.
|
||||
if (ergebnis.Position > TimeSpan.Zero) zustand.Dismissed = false;
|
||||
|
||||
Nachfuehren(zustand);
|
||||
await db.SaveChangesAsync();
|
||||
return Results.Ok(Abbild(zustand));
|
||||
});
|
||||
|
||||
titel.MapPut("/watched", async (
|
||||
Guid id, WatchedRequest anfrage, ClaimsPrincipal wer, FlaroContext db, TimeProvider clock) =>
|
||||
{
|
||||
if (Benutzer(wer) is not { } benutzer) return Results.Unauthorized();
|
||||
|
||||
var zustand = await Zustand(db, benutzer, id);
|
||||
if (zustand is null) return Results.NotFound();
|
||||
|
||||
if (anfrage.Watched)
|
||||
{
|
||||
if (!zustand.Watched) zustand.PlayCount++;
|
||||
zustand.Watched = true;
|
||||
zustand.LastPlayedAt = clock.GetUtcNow();
|
||||
// **Von Hand als gesehen markiert heisst: fertig damit.** Hier
|
||||
// wäre eine stehengebliebene Stelle keine Hilfe, sondern eine
|
||||
// Zeile in „Weiterschauen", die niemand bestellt hat.
|
||||
zustand.Position = TimeSpan.Zero;
|
||||
}
|
||||
else
|
||||
{
|
||||
zustand.Watched = false;
|
||||
zustand.Position = TimeSpan.Zero;
|
||||
zustand.Dismissed = false;
|
||||
}
|
||||
|
||||
zustand.UpdatedAt = clock.GetUtcNow();
|
||||
Nachfuehren(zustand);
|
||||
await db.SaveChangesAsync();
|
||||
return Results.Ok(Abbild(zustand));
|
||||
});
|
||||
|
||||
// Aus „Weiterschauen" nehmen, ohne zu behaupten, man habe es gesehen.
|
||||
titel.MapPost("/dismiss", async (
|
||||
Guid id, ClaimsPrincipal wer, FlaroContext db, TimeProvider clock) =>
|
||||
{
|
||||
if (Benutzer(wer) is not { } benutzer) return Results.Unauthorized();
|
||||
|
||||
var zustand = await Zustand(db, benutzer, id);
|
||||
if (zustand is null) return Results.NotFound();
|
||||
|
||||
zustand.Dismissed = true;
|
||||
zustand.UpdatedAt = clock.GetUtcNow();
|
||||
Nachfuehren(zustand);
|
||||
await db.SaveChangesAsync();
|
||||
return Results.Ok(Abbild(zustand));
|
||||
});
|
||||
|
||||
titel.MapPut("/favourite", async (
|
||||
Guid id, FavouriteRequest anfrage, ClaimsPrincipal wer, FlaroContext db, TimeProvider clock) =>
|
||||
{
|
||||
if (Benutzer(wer) is not { } benutzer) return Results.Unauthorized();
|
||||
|
||||
var zustand = await Zustand(db, benutzer, id);
|
||||
if (zustand is null) return Results.NotFound();
|
||||
|
||||
zustand.Favourite = anfrage.Favourite;
|
||||
zustand.UpdatedAt = clock.GetUtcNow();
|
||||
Nachfuehren(zustand);
|
||||
await db.SaveChangesAsync();
|
||||
return Results.Ok(Abbild(zustand));
|
||||
});
|
||||
|
||||
titel.MapPut("/rating", async (
|
||||
Guid id, RatingRequest anfrage, ClaimsPrincipal wer, FlaroContext db, TimeProvider clock) =>
|
||||
{
|
||||
if (Benutzer(wer) is not { } benutzer) return Results.Unauthorized();
|
||||
if (anfrage.Rating is { } wert && wert is < 1 or > 10)
|
||||
return Results.Problem("Eine Bewertung liegt zwischen 1 und 10.",
|
||||
statusCode: StatusCodes.Status400BadRequest);
|
||||
|
||||
var zustand = await Zustand(db, benutzer, id);
|
||||
if (zustand is null) return Results.NotFound();
|
||||
|
||||
zustand.Rating = anfrage.Rating;
|
||||
zustand.UpdatedAt = clock.GetUtcNow();
|
||||
Nachfuehren(zustand);
|
||||
await db.SaveChangesAsync();
|
||||
return Results.Ok(Abbild(zustand));
|
||||
});
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
// Startseite
|
||||
// ------------------------------------------------------------------
|
||||
|
||||
private static void MapStartseite(IEndpointRouteBuilder app)
|
||||
{
|
||||
var start = app.MapGroup("/api/v1/home").RequireAuthorization();
|
||||
|
||||
start.MapGet("/continue", async (ClaimsPrincipal wer, FlaroContext db, int take = 20) =>
|
||||
{
|
||||
if (Benutzer(wer) is not { } benutzer) return Results.Unauthorized();
|
||||
|
||||
// Die Regel steht in `ProgressRule`; was hier abgefragt wird, ist
|
||||
// ihr festgehaltenes Ergebnis. Siehe `UserItemState.InProgress`.
|
||||
var zustände = await db.UserItemStates.AsNoTracking()
|
||||
.Where(z => z.UserId == benutzer && z.InProgress)
|
||||
.OrderByDescending(z => z.UpdatedAt)
|
||||
.Take(Math.Clamp(take, 1, HöchstensJeSeite))
|
||||
.ToListAsync();
|
||||
|
||||
return Results.Ok(new Page<ContinueEntry>(
|
||||
await Eintraege(db, zustände), zustände.Count));
|
||||
});
|
||||
|
||||
// **Die erste ungesehene Folge je angefangener Serie.**
|
||||
//
|
||||
// Ohne Überschneidung mit „Weiterschauen": was dort schon steht, weil
|
||||
// es mitten drin liegt, taucht hier nicht noch einmal auf. Jellyfin
|
||||
// zeigt beides doppelt; auf einer Startseite mit zwei Reihen
|
||||
// nebeneinander sieht das nach einem Fehler aus.
|
||||
start.MapGet("/next", async (ClaimsPrincipal wer, FlaroContext db, int take = 20) =>
|
||||
{
|
||||
if (Benutzer(wer) is not { } benutzer) return Results.Unauthorized();
|
||||
|
||||
// Welche Serien der Benutzer überhaupt angefasst hat. Ohne diese
|
||||
// Einschränkung stünde die erste Folge jeder Serie der Mediathek
|
||||
// hier — eine Reihe, die nichts über den Benutzer aussagt.
|
||||
var angefasst = await db.UserItemStates.AsNoTracking()
|
||||
.Where(z => z.UserId == benutzer && z.EpisodeId != null)
|
||||
.Join(db.Episodes.AsNoTracking(), z => z.EpisodeId, f => f.Id,
|
||||
(z, f) => new { f.SeriesId, z.UpdatedAt })
|
||||
.GroupBy(x => x.SeriesId)
|
||||
.Select(g => new { SeriesId = g.Key, Zuletzt = g.Max(x => x.UpdatedAt) })
|
||||
.OrderByDescending(x => x.Zuletzt)
|
||||
.Take(Math.Clamp(take, 1, HöchstensJeSeite))
|
||||
.ToListAsync();
|
||||
|
||||
if (angefasst.Count == 0) return Results.Ok(new Page<ContinueEntry>([], 0));
|
||||
|
||||
var serienIds = angefasst.Select(x => x.SeriesId).ToList();
|
||||
|
||||
var folgen = await db.Episodes.AsNoTracking()
|
||||
.Where(f => serienIds.Contains(f.SeriesId))
|
||||
.Select(f => new { f.Id, f.SeriesId, f.SeasonNumber, f.EpisodeNumber, f.Title, f.StillImage })
|
||||
.ToListAsync();
|
||||
|
||||
var folgenIds = folgen.Select(f => f.Id).ToList();
|
||||
var zustände = await db.UserItemStates.AsNoTracking()
|
||||
.Where(z => z.UserId == benutzer && z.EpisodeId != null && folgenIds.Contains(z.EpisodeId!.Value))
|
||||
.ToDictionaryAsync(z => z.EpisodeId!.Value);
|
||||
|
||||
var serien = await db.Series.AsNoTracking()
|
||||
.Where(x => serienIds.Contains(x.Id))
|
||||
.Select(x => new { x.Id, x.Title, x.PosterImage })
|
||||
.ToDictionaryAsync(x => x.Id);
|
||||
|
||||
var liste = new List<ContinueEntry>();
|
||||
foreach (var x in angefasst)
|
||||
{
|
||||
var naechste = folgen
|
||||
.Where(f => f.SeriesId == x.SeriesId)
|
||||
.OrderBy(f => f.SeasonNumber).ThenBy(f => f.EpisodeNumber)
|
||||
.FirstOrDefault(f => zustände.GetValueOrDefault(f.Id) is not { Watched: true });
|
||||
|
||||
// Nichts offen — die Serie ist durch.
|
||||
if (naechste is null) continue;
|
||||
// Mittendrin: steht bereits in „Weiterschauen".
|
||||
if (zustände.GetValueOrDefault(naechste.Id) is { InProgress: true }) continue;
|
||||
if (!serien.TryGetValue(x.SeriesId, out var serie)) continue;
|
||||
|
||||
var zustand = zustände.GetValueOrDefault(naechste.Id);
|
||||
liste.Add(new ContinueEntry(
|
||||
naechste.Id, "episode", serie.Title, naechste.Title,
|
||||
naechste.SeasonNumber, naechste.EpisodeNumber, null,
|
||||
serie.PosterImage, naechste.StillImage ?? serie.PosterImage,
|
||||
zustand is null ? Leer() : Abbild(zustand)));
|
||||
}
|
||||
|
||||
return Results.Ok(new Page<ContinueEntry>(liste, liste.Count));
|
||||
});
|
||||
}
|
||||
|
||||
/// <summary>Der Zustand eines Titels, den noch niemand angefasst hat.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// Lieber eine Antwort mit Nullen als <c>null</c>: die Reihe „Nächste
|
||||
/// Folge" zeigt überwiegend Folgen ohne Stand, und ein Client, der für
|
||||
/// jede davon einen Sonderfall braucht, vergisst ihn irgendwo.
|
||||
/// </remarks>
|
||||
private static ItemStateResponse Leer() => new(0, null, false, 0, false, null, false, null);
|
||||
|
||||
/// <summary>Macht aus Zuständen Einträge mit Titel und Bild.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// In zwei Abfragen statt in einer je Zeile: zwanzig Einträge wären sonst
|
||||
/// zwanzig Abfragen, und SQLite führt die nacheinander aus.
|
||||
/// </remarks>
|
||||
private static async Task<List<ContinueEntry>> Eintraege(FlaroContext db, List<UserItemState> zustände)
|
||||
{
|
||||
var filme = zustände.Where(z => z.MovieId != null).Select(z => z.MovieId!.Value).ToList();
|
||||
var folgen = zustände.Where(z => z.EpisodeId != null).Select(z => z.EpisodeId!.Value).ToList();
|
||||
|
||||
var filmdaten = await db.Movies.AsNoTracking().Where(m => filme.Contains(m.Id))
|
||||
.Select(m => new { m.Id, m.Title, m.Year, m.PosterImage, m.BackdropImage })
|
||||
.ToDictionaryAsync(m => m.Id);
|
||||
|
||||
var folgendaten = await db.Episodes.AsNoTracking().Where(f => folgen.Contains(f.Id))
|
||||
.Join(db.Series.AsNoTracking(), f => f.SeriesId, s => s.Id, (f, s) => new
|
||||
{
|
||||
f.Id, f.SeasonNumber, f.EpisodeNumber, FolgenTitel = f.Title, f.StillImage,
|
||||
SerienId = s.Id, SerienTitel = s.Title, s.PosterImage,
|
||||
})
|
||||
.ToDictionaryAsync(f => f.Id);
|
||||
|
||||
var liste = new List<ContinueEntry>(zustände.Count);
|
||||
foreach (var z in zustände)
|
||||
{
|
||||
if (z.MovieId is { } film && filmdaten.TryGetValue(film, out var m))
|
||||
liste.Add(new ContinueEntry(
|
||||
m.Id, "movie", m.Title, null, null, null, m.Year,
|
||||
m.PosterImage, m.BackdropImage ?? m.PosterImage, Abbild(z)));
|
||||
else if (z.EpisodeId is { } folge && folgendaten.TryGetValue(folge, out var f))
|
||||
liste.Add(new ContinueEntry(
|
||||
f.Id, "episode", f.SerienTitel, f.FolgenTitel, f.SeasonNumber, f.EpisodeNumber, null,
|
||||
f.PosterImage, f.StillImage ?? f.PosterImage, Abbild(z)));
|
||||
}
|
||||
return liste;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
// Gemeinsames
|
||||
// ------------------------------------------------------------------
|
||||
|
||||
/// <summary>Hält fest, was die Regel zu dieser Zeile sagt.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// Nach jeder Änderung aufzurufen. Die einzige Stelle, die
|
||||
/// <see cref="UserItemState.InProgress"/> schreibt — gäbe es eine zweite,
|
||||
/// wäre die Spalte wieder ein zweites Urteil statt eines festgehaltenen.
|
||||
/// </remarks>
|
||||
private static void Nachfuehren(UserItemState zustand) =>
|
||||
zustand.InProgress = ProgressRule.BelongsInContinueWatching(zustand);
|
||||
|
||||
internal static Guid? Benutzer(ClaimsPrincipal wer) =>
|
||||
Guid.TryParse(wer.FindFirstValue(ClaimTypes.NameIdentifier), out var id) ? id : null;
|
||||
|
||||
/// <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.
|
||||
/// </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));
|
||||
if (vorhanden is not null) return vorhanden;
|
||||
|
||||
if (await db.Movies.AnyAsync(m => m.Id == titel))
|
||||
{
|
||||
var neu = new UserItemState { UserId = benutzer, MovieId = titel };
|
||||
db.UserItemStates.Add(neu);
|
||||
return neu;
|
||||
}
|
||||
|
||||
if (await db.Episodes.AnyAsync(f => f.Id == titel))
|
||||
{
|
||||
var neu = new UserItemState { UserId = benutzer, EpisodeId = titel };
|
||||
db.UserItemStates.Add(neu);
|
||||
return neu;
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/// <summary>Die Laufzeit aus der längsten Datei hinter dem Titel.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// Die längste, weil mehrere Fassungen vorliegen können und eine davon
|
||||
/// 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()
|
||||
.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,
|
||||
z.Watched, z.PlayCount, z.Favourite, z.Rating, z.Dismissed, z.LastPlayedAt);
|
||||
}
|
||||
@@ -137,6 +137,7 @@ app.MapLibraryContent();
|
||||
app.MapSettings();
|
||||
app.MapImages();
|
||||
app.MapDelivery();
|
||||
app.MapPlayback();
|
||||
app.MapMatching();
|
||||
|
||||
// Alles, was keine Schnittstelle ist, bekommt die Seite — der Router läuft
|
||||
|
||||
@@ -0,0 +1,88 @@
|
||||
namespace Flaro.Core.Playback;
|
||||
|
||||
/// <summary>Was eine Fortschrittsmeldung am Zustand ändert.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>Keine untere Schwelle. Keine Mindestlaufzeit. Keine verworfene
|
||||
/// Position.</b> Das ist der Anlass für diesen Server, und es lohnt, den
|
||||
/// Vergleich festzuhalten, damit später niemand „das macht Jellyfin doch
|
||||
/// genauso" denkt.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// Jellyfin rechnet in <c>UserDataManager.UpdatePlayState</c> mit drei Werten
|
||||
/// (Vorgaben aus <c>ServerConfiguration</c>): <c>MinResumePct</c> 5,
|
||||
/// <c>MaxResumePct</c> 90, <c>MinResumeDurationSeconds</c> 300. Unterhalb von
|
||||
/// fünf Prozent setzt es die Position auf null — der Kommentar im Quelltext
|
||||
/// lautet wörtlich „ignore progress during the beginning". Bei einem
|
||||
/// Zweistünder sind das die ersten sechs Minuten. Oberhalb von neunzig
|
||||
/// Prozent gilt der Titel als gesehen, und auch dann fällt die Position weg.
|
||||
/// Und alles, was kürzer als fünf Minuten ist, gilt nach dem ersten
|
||||
/// Lebenszeichen als vollständig gesehen, egal an welcher Stelle.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// Flaro behält in allen drei Fällen die Position. Ein gesehener Titel und
|
||||
/// eine Stelle, an der man weitermachen kann, schliessen einander nicht aus —
|
||||
/// wer einen Film ein zweites Mal anfängt, soll beides haben.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public static class ProgressRule
|
||||
{
|
||||
/// <summary>Ab welchem Anteil ein Titel als gesehen gilt.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Eine Schwelle ist hier unvermeidlich</b>, und das ist kein
|
||||
/// Widerspruch zum Obigen: Niemand sieht einen Film bis zur letzten
|
||||
/// Sekunde des Abspanns. Ohne diese Regel stünde jeder zu Ende geschaute
|
||||
/// Film für immer bei 98 % in „Weiterschauen".
|
||||
///
|
||||
/// Der Unterschied zu Jellyfin ist nicht, <i>dass</i> es diese Grenze
|
||||
/// gibt, sondern was sie anrichtet: hier wird ein Häkchen gesetzt, dort
|
||||
/// zusätzlich die Position weggeworfen.
|
||||
/// </remarks>
|
||||
public const double WatchedFraction = 0.90;
|
||||
|
||||
/// <summary>Was aus einer Meldung folgt.</summary>
|
||||
/// <param name="Position">Die Stelle, die abgelegt wird — nie null gesetzt.</param>
|
||||
/// <param name="Watched">Ob der Titel damit als gesehen gilt.</param>
|
||||
public readonly record struct Outcome(TimeSpan Position, bool Watched);
|
||||
|
||||
/// <summary>Rechnet eine gemeldete Stelle in einen Zustand um.</summary>
|
||||
///
|
||||
/// <param name="position">Wo der Client steht.</param>
|
||||
/// <param name="runtime">
|
||||
/// Wie lang der Titel ist, falls bekannt. Ohne Laufzeit gibt es keinen
|
||||
/// Anteil zu rechnen — dann wird die Stelle abgelegt und sonst nichts.
|
||||
/// Zu raten wäre hier schlimmer als nichts zu tun: „gesehen", weil die
|
||||
/// Laufzeit fehlt, ist der Fehler, den man nicht zurücknehmen kann, ohne
|
||||
/// es zu merken.
|
||||
/// </param>
|
||||
public static Outcome Apply(TimeSpan position, TimeSpan? runtime)
|
||||
{
|
||||
// Eine negative Stelle gibt es nicht, und eine jenseits des Endes
|
||||
// auch nicht. Beides kommt vor: der eine Player meldet beim Spulen
|
||||
// kurz Unsinn, der andere beim Beenden die Laufzeit plus Rundung.
|
||||
var stelle = position < TimeSpan.Zero ? TimeSpan.Zero : position;
|
||||
|
||||
if (runtime is not { } laenge || laenge <= TimeSpan.Zero)
|
||||
return new Outcome(stelle, Watched: false);
|
||||
|
||||
if (stelle > laenge) stelle = laenge;
|
||||
|
||||
return new Outcome(stelle, Watched: stelle >= laenge * WatchedFraction);
|
||||
}
|
||||
|
||||
/// <summary>Ob ein Zustand in „Weiterschauen" gehört.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Dieselbe Regel wie in der Abfrage, an einer Stelle.</b> Die
|
||||
/// Serverabfrage kann sie nicht aufrufen — sie wird zu SQL übersetzt —,
|
||||
/// aber die Prüfung kann beides gegeneinanderhalten. Läuft das auseinander,
|
||||
/// fällt es hier auf und nicht beim Benutzer.
|
||||
/// </remarks>
|
||||
public static bool BelongsInContinueWatching(UserItemState zustand) =>
|
||||
zustand is { Dismissed: false, Position.Ticks: > 0 }
|
||||
&& (zustand.Runtime is not { } laenge
|
||||
|| laenge <= TimeSpan.Zero
|
||||
|| zustand.Position < laenge * WatchedFraction);
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
namespace Flaro.Core.Playback;
|
||||
|
||||
/// <summary>Was ein Benutzer mit einem Titel zu tun hatte.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>Je Benutzer, nicht je Server.</b> Zwei Leute im selben Haushalt stehen
|
||||
/// an verschiedenen Stellen desselben Films, und wessen Stand gilt, darf
|
||||
/// nicht davon abhängen, wer zuletzt geschaut hat.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>Der Verweis zeigt auf Film <i>oder</i> Folge</b>, wie bei
|
||||
/// <c>MediaFile</c>. Eine gemeinsame Kennung mit einem Typfeld daneben wäre
|
||||
/// kürzer, aber die Datenbank könnte dann nicht mehr dafür einstehen, dass
|
||||
/// der Verweis irgendwohin zeigt.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public sealed class UserItemState
|
||||
{
|
||||
public Guid Id { get; init; } = Guid.CreateVersion7();
|
||||
public required Guid UserId { get; init; }
|
||||
|
||||
public Guid? MovieId { get; init; }
|
||||
public Guid? EpisodeId { get; init; }
|
||||
|
||||
/// <summary>Wo der Benutzer steht.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Ab der ersten Sekunde, ohne untere Schwelle.</b> Das ist der
|
||||
/// Unterschied, um dessentwillen dieser Server existiert — siehe
|
||||
/// <see cref="ProgressRule"/>.
|
||||
/// </remarks>
|
||||
public TimeSpan Position { get; set; }
|
||||
|
||||
/// <summary>Wie lang der Titel ist, so wie der Client es gemeldet hat.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// Hier abgelegt, damit „wie weit ist er" ohne einen Blick in die Dateien
|
||||
/// zu beantworten ist. Bei zwei Fassungen eines Films — 4K und 1080p —
|
||||
/// können sich die Laufzeiten um Sekunden unterscheiden; was zählt, ist
|
||||
/// die, gegen die gemessen wurde.
|
||||
/// </remarks>
|
||||
public TimeSpan? Runtime { get; set; }
|
||||
|
||||
public bool Watched { get; set; }
|
||||
public int PlayCount { get; set; }
|
||||
public DateTimeOffset? LastPlayedAt { get; set; }
|
||||
|
||||
/// <summary>Aus „Weiterschauen" genommen, ohne als gesehen zu gelten.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Der Fall, für den es sonst nichts gibt.</b> Nach einer halben Stunde
|
||||
/// keine Lust mehr — der Film ist weder gesehen noch ungesehen, er soll
|
||||
/// nur nicht weiter oben stehen. „Als gesehen" wäre eine Lüge, „als
|
||||
/// ungesehen" täte nichts: die Position bliebe.
|
||||
///
|
||||
/// Die Position bleibt auch hier erhalten. Wer doch weitermacht, fängt
|
||||
/// nicht von vorn an.
|
||||
/// </remarks>
|
||||
public bool Dismissed { get; set; }
|
||||
|
||||
public bool Favourite { get; set; }
|
||||
|
||||
/// <summary>Eine eigene Bewertung von 1 bis 10, oder keine.</summary>
|
||||
public int? Rating { get; set; }
|
||||
|
||||
/// <summary>Ob dieser Titel in „Weiterschauen" gehört.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Kein zweites Urteil, sondern das festgehaltene Ergebnis des
|
||||
/// ersten.</b> Geschrieben wird es ausschliesslich aus
|
||||
/// <see cref="ProgressRule.BelongsInContinueWatching"/>, bei jeder
|
||||
/// Änderung an dieser Zeile.
|
||||
///
|
||||
/// Warum überhaupt eine Spalte: die Regel vergleicht die Stelle mit einem
|
||||
/// Anteil der Laufzeit, und diese Rechnung lässt sich nicht nach SQL
|
||||
/// übersetzen. Die Regel daneben ein zweites Mal als Abfrage zu schreiben
|
||||
/// wäre die Variante, bei der beide irgendwann auseinanderlaufen — und
|
||||
/// zwar unbemerkt, weil keine von beiden dabei falsch aussieht.
|
||||
/// </remarks>
|
||||
public bool InProgress { get; set; }
|
||||
|
||||
public DateTimeOffset UpdatedAt { get; set; } = DateTimeOffset.UtcNow;
|
||||
}
|
||||
@@ -2,6 +2,7 @@ using Flaro.Core;
|
||||
using Flaro.Core.Auth;
|
||||
using Flaro.Core.Libraries;
|
||||
using Flaro.Core.Library;
|
||||
using Flaro.Core.Playback;
|
||||
using Flaro.Core.Users;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
|
||||
@@ -32,6 +33,7 @@ public sealed class FlaroContext(DbContextOptions<FlaroContext> options) : DbCon
|
||||
public DbSet<Series> Series => Set<Series>();
|
||||
public DbSet<Episode> Episodes => Set<Episode>();
|
||||
public DbSet<MediaStream> MediaStreams => Set<MediaStream>();
|
||||
public DbSet<UserItemState> UserItemStates => Set<UserItemState>();
|
||||
|
||||
/// <summary>Gilt für jede Zeitangabe im Modell, ohne sie einzeln zu nennen.</summary>
|
||||
///
|
||||
@@ -150,6 +152,37 @@ public sealed class FlaroContext(DbContextOptions<FlaroContext> options) : DbCon
|
||||
e.HasOne<MediaFile>().WithMany().HasForeignKey(x => x.MediaFileId).OnDelete(DeleteBehavior.Cascade);
|
||||
});
|
||||
|
||||
b.Entity<UserItemState>(e =>
|
||||
{
|
||||
e.HasKey(x => x.Id);
|
||||
|
||||
// **Je Benutzer und Titel genau eine Zeile.** Ohne diese Regel
|
||||
// legen zwei Fortschrittsmeldungen, die sich überholen, zwei
|
||||
// Zeilen an — und welche davon später gelesen wird, entscheidet
|
||||
// der Zufall.
|
||||
//
|
||||
// Gefiltert, weil die jeweils andere Spalte leer ist: eine
|
||||
// ungefilterte Regel über (UserId, MovieId) liesse zwar beliebig
|
||||
// viele Folgen-Zeilen zu (NULL gilt als verschieden), aber das
|
||||
// wäre Verlass auf eine Eigenheit statt auf eine Aussage.
|
||||
e.HasIndex(x => new { x.UserId, x.MovieId }).IsUnique()
|
||||
.HasFilter("\"MovieId\" IS NOT NULL");
|
||||
e.HasIndex(x => new { x.UserId, x.EpisodeId }).IsUnique()
|
||||
.HasFilter("\"EpisodeId\" IS NOT NULL");
|
||||
|
||||
// Der Weg von „Weiterschauen": die offenen Zeilen eines
|
||||
// Benutzers, neueste zuerst. Ohne Index ein vollständiger
|
||||
// Durchlauf je Aufruf der Startseite.
|
||||
e.HasIndex(x => new { x.UserId, x.InProgress, x.UpdatedAt });
|
||||
|
||||
e.HasOne<User>().WithMany().HasForeignKey(x => x.UserId).OnDelete(DeleteBehavior.Cascade);
|
||||
// Verschwindet ein Film aus der Mediathek, verschwindet auch der
|
||||
// Stand dazu. Ein Fortschritt zu einem Titel, den es nicht mehr
|
||||
// gibt, ist keine Erinnerung, sondern Datenmüll.
|
||||
e.HasOne<Movie>().WithMany().HasForeignKey(x => x.MovieId).OnDelete(DeleteBehavior.Cascade);
|
||||
e.HasOne<Episode>().WithMany().HasForeignKey(x => x.EpisodeId).OnDelete(DeleteBehavior.Cascade);
|
||||
});
|
||||
|
||||
b.Entity<Episode>(e =>
|
||||
{
|
||||
e.HasKey(x => x.Id);
|
||||
|
||||
@@ -0,0 +1,587 @@
|
||||
// <auto-generated />
|
||||
using System;
|
||||
using Flaro.Data;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Microsoft.EntityFrameworkCore.Infrastructure;
|
||||
using Microsoft.EntityFrameworkCore.Migrations;
|
||||
using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
|
||||
|
||||
#nullable disable
|
||||
|
||||
namespace Flaro.Data.Migrations
|
||||
{
|
||||
[DbContext(typeof(FlaroContext))]
|
||||
[Migration("20261003192048_Sehfortschritt")]
|
||||
partial class Sehfortschritt
|
||||
{
|
||||
/// <inheritdoc />
|
||||
protected override void BuildTargetModel(ModelBuilder modelBuilder)
|
||||
{
|
||||
#pragma warning disable 612, 618
|
||||
modelBuilder.HasAnnotation("ProductVersion", "10.0.12");
|
||||
|
||||
modelBuilder.Entity("Flaro.Core.Auth.AuthCode", b =>
|
||||
{
|
||||
b.Property<Guid>("Id")
|
||||
.ValueGeneratedOnAdd()
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<Guid?>("ApprovedByUserId")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<string>("Code")
|
||||
.IsRequired()
|
||||
.HasMaxLength(16)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<long?>("ConsumedAt")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<long>("CreatedAt")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<string>("DeviceId")
|
||||
.IsRequired()
|
||||
.HasMaxLength(128)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<string>("DeviceName")
|
||||
.IsRequired()
|
||||
.HasMaxLength(128)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<long>("ExpiresAt")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<string>("HandleFingerprint")
|
||||
.IsRequired()
|
||||
.HasMaxLength(64)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.HasKey("Id");
|
||||
|
||||
b.HasIndex("Code");
|
||||
|
||||
b.HasIndex("HandleFingerprint")
|
||||
.IsUnique();
|
||||
|
||||
b.ToTable("AuthCodes");
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Flaro.Core.Auth.DeviceToken", b =>
|
||||
{
|
||||
b.Property<Guid>("Id")
|
||||
.ValueGeneratedOnAdd()
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<long>("CreatedAt")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<string>("DeviceId")
|
||||
.IsRequired()
|
||||
.HasMaxLength(128)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<string>("DeviceName")
|
||||
.IsRequired()
|
||||
.HasMaxLength(128)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<long>("LastSeenAt")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<long?>("RevokedAt")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<string>("TokenFingerprint")
|
||||
.IsRequired()
|
||||
.HasMaxLength(64)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<Guid>("UserId")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.HasKey("Id");
|
||||
|
||||
b.HasIndex("TokenFingerprint")
|
||||
.IsUnique();
|
||||
|
||||
b.HasIndex("UserId");
|
||||
|
||||
b.ToTable("DeviceTokens");
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Flaro.Core.Libraries.Library", b =>
|
||||
{
|
||||
b.Property<Guid>("Id")
|
||||
.ValueGeneratedOnAdd()
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<long>("CreatedAt")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<string>("Kind")
|
||||
.IsRequired()
|
||||
.HasMaxLength(32)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<string>("Name")
|
||||
.IsRequired()
|
||||
.HasMaxLength(128)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<string>("Path")
|
||||
.IsRequired()
|
||||
.HasMaxLength(1024)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.HasKey("Id");
|
||||
|
||||
b.ToTable("Libraries");
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Flaro.Core.Library.Episode", b =>
|
||||
{
|
||||
b.Property<Guid>("Id")
|
||||
.ValueGeneratedOnAdd()
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<long>("AddedAt")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<int>("EpisodeNumber")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<string>("Overview")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<int>("SeasonNumber")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<Guid>("SeriesId")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<string>("StillImage")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<string>("Title")
|
||||
.HasMaxLength(512)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.HasKey("Id");
|
||||
|
||||
b.HasIndex("SeriesId", "SeasonNumber", "EpisodeNumber")
|
||||
.IsUnique();
|
||||
|
||||
b.ToTable("Episodes");
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Flaro.Core.Library.MediaFile", b =>
|
||||
{
|
||||
b.Property<Guid>("Id")
|
||||
.ValueGeneratedOnAdd()
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<long?>("BitRate")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<string>("Container")
|
||||
.HasMaxLength(32)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<long?>("Duration")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<Guid?>("EpisodeId")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<Guid>("LibraryId")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<long>("ModifiedAt")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<Guid?>("MovieId")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<string>("Path")
|
||||
.IsRequired()
|
||||
.HasMaxLength(1024)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<long?>("ProbedAt")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<long>("SeenAt")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<long>("SizeBytes")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.HasKey("Id");
|
||||
|
||||
b.HasIndex("EpisodeId");
|
||||
|
||||
b.HasIndex("MovieId");
|
||||
|
||||
b.HasIndex("LibraryId", "Path")
|
||||
.IsUnique();
|
||||
|
||||
b.ToTable("MediaFiles");
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Flaro.Core.Library.MediaStream", b =>
|
||||
{
|
||||
b.Property<Guid>("Id")
|
||||
.ValueGeneratedOnAdd()
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<int?>("Channels")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<string>("Codec")
|
||||
.HasMaxLength(64)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<int?>("Height")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<int>("Index")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<bool>("IsDefault")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<bool>("IsForced")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<string>("Kind")
|
||||
.IsRequired()
|
||||
.HasMaxLength(16)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<string>("Language")
|
||||
.HasMaxLength(16)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<Guid>("MediaFileId")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<string>("Title")
|
||||
.HasMaxLength(256)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<int?>("Width")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.HasKey("Id");
|
||||
|
||||
b.HasIndex("MediaFileId", "Index")
|
||||
.IsUnique();
|
||||
|
||||
b.ToTable("MediaStreams");
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Flaro.Core.Library.Movie", b =>
|
||||
{
|
||||
b.Property<Guid>("Id")
|
||||
.ValueGeneratedOnAdd()
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<long>("AddedAt")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<string>("BackdropImage")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<string>("ImdbId")
|
||||
.HasMaxLength(32)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<Guid>("LibraryId")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<bool>("MatchLocked")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<string>("Overview")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<string>("ParsedTitle")
|
||||
.IsRequired()
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<int?>("ParsedYear")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<string>("PosterImage")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<string>("SortTitleValue")
|
||||
.IsRequired()
|
||||
.HasMaxLength(512)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<string>("Title")
|
||||
.IsRequired()
|
||||
.HasMaxLength(512)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<int?>("TmdbId")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<int?>("Year")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.HasKey("Id");
|
||||
|
||||
b.HasIndex("LibraryId", "SortTitleValue");
|
||||
|
||||
b.ToTable("Movies");
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Flaro.Core.Library.Series", b =>
|
||||
{
|
||||
b.Property<Guid>("Id")
|
||||
.ValueGeneratedOnAdd()
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<long>("AddedAt")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<string>("BackdropImage")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<string>("ImdbId")
|
||||
.HasMaxLength(32)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<Guid>("LibraryId")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<bool>("MatchLocked")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<string>("Overview")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<string>("ParsedTitle")
|
||||
.IsRequired()
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<int?>("ParsedYear")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<string>("PosterImage")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<string>("SortTitleValue")
|
||||
.IsRequired()
|
||||
.HasMaxLength(512)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<string>("Title")
|
||||
.IsRequired()
|
||||
.HasMaxLength(512)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<int?>("TmdbId")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<int?>("Year")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.HasKey("Id");
|
||||
|
||||
b.HasIndex("LibraryId", "SortTitleValue");
|
||||
|
||||
b.ToTable("Series");
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Flaro.Core.Playback.UserItemState", b =>
|
||||
{
|
||||
b.Property<Guid>("Id")
|
||||
.ValueGeneratedOnAdd()
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<bool>("Dismissed")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<Guid?>("EpisodeId")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<bool>("Favourite")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<bool>("InProgress")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<long?>("LastPlayedAt")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<Guid?>("MovieId")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<int>("PlayCount")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<long>("Position")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<int?>("Rating")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<long?>("Runtime")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<long>("UpdatedAt")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<Guid>("UserId")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<bool>("Watched")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.HasKey("Id");
|
||||
|
||||
b.HasIndex("EpisodeId");
|
||||
|
||||
b.HasIndex("MovieId");
|
||||
|
||||
b.HasIndex("UserId", "EpisodeId")
|
||||
.IsUnique()
|
||||
.HasFilter("\"EpisodeId\" IS NOT NULL");
|
||||
|
||||
b.HasIndex("UserId", "MovieId")
|
||||
.IsUnique()
|
||||
.HasFilter("\"MovieId\" IS NOT NULL");
|
||||
|
||||
b.HasIndex("UserId", "InProgress", "UpdatedAt");
|
||||
|
||||
b.ToTable("UserItemStates");
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Flaro.Core.ServerSetting", b =>
|
||||
{
|
||||
b.Property<string>("Key")
|
||||
.HasMaxLength(128)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<string>("Value")
|
||||
.IsRequired()
|
||||
.HasMaxLength(4096)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.HasKey("Key");
|
||||
|
||||
b.ToTable("Settings");
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Flaro.Core.Users.User", b =>
|
||||
{
|
||||
b.Property<Guid>("Id")
|
||||
.ValueGeneratedOnAdd()
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<long>("CreatedAt")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<bool>("IsAdministrator")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<string>("PasswordHash")
|
||||
.IsRequired()
|
||||
.HasMaxLength(256)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<string>("UserName")
|
||||
.IsRequired()
|
||||
.HasMaxLength(64)
|
||||
.HasColumnType("TEXT")
|
||||
.UseCollation("NOCASE");
|
||||
|
||||
b.HasKey("Id");
|
||||
|
||||
b.HasIndex("UserName")
|
||||
.IsUnique();
|
||||
|
||||
b.ToTable("Users");
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Flaro.Core.Auth.DeviceToken", b =>
|
||||
{
|
||||
b.HasOne("Flaro.Core.Users.User", null)
|
||||
.WithMany()
|
||||
.HasForeignKey("UserId")
|
||||
.OnDelete(DeleteBehavior.Cascade)
|
||||
.IsRequired();
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Flaro.Core.Library.Episode", b =>
|
||||
{
|
||||
b.HasOne("Flaro.Core.Library.Series", null)
|
||||
.WithMany()
|
||||
.HasForeignKey("SeriesId")
|
||||
.OnDelete(DeleteBehavior.Cascade)
|
||||
.IsRequired();
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Flaro.Core.Library.MediaFile", b =>
|
||||
{
|
||||
b.HasOne("Flaro.Core.Libraries.Library", null)
|
||||
.WithMany()
|
||||
.HasForeignKey("LibraryId")
|
||||
.OnDelete(DeleteBehavior.Cascade)
|
||||
.IsRequired();
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Flaro.Core.Library.MediaStream", b =>
|
||||
{
|
||||
b.HasOne("Flaro.Core.Library.MediaFile", null)
|
||||
.WithMany()
|
||||
.HasForeignKey("MediaFileId")
|
||||
.OnDelete(DeleteBehavior.Cascade)
|
||||
.IsRequired();
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Flaro.Core.Library.Movie", b =>
|
||||
{
|
||||
b.HasOne("Flaro.Core.Libraries.Library", null)
|
||||
.WithMany()
|
||||
.HasForeignKey("LibraryId")
|
||||
.OnDelete(DeleteBehavior.Cascade)
|
||||
.IsRequired();
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Flaro.Core.Library.Series", b =>
|
||||
{
|
||||
b.HasOne("Flaro.Core.Libraries.Library", null)
|
||||
.WithMany()
|
||||
.HasForeignKey("LibraryId")
|
||||
.OnDelete(DeleteBehavior.Cascade)
|
||||
.IsRequired();
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Flaro.Core.Playback.UserItemState", b =>
|
||||
{
|
||||
b.HasOne("Flaro.Core.Library.Episode", null)
|
||||
.WithMany()
|
||||
.HasForeignKey("EpisodeId")
|
||||
.OnDelete(DeleteBehavior.Cascade);
|
||||
|
||||
b.HasOne("Flaro.Core.Library.Movie", null)
|
||||
.WithMany()
|
||||
.HasForeignKey("MovieId")
|
||||
.OnDelete(DeleteBehavior.Cascade);
|
||||
|
||||
b.HasOne("Flaro.Core.Users.User", null)
|
||||
.WithMany()
|
||||
.HasForeignKey("UserId")
|
||||
.OnDelete(DeleteBehavior.Cascade)
|
||||
.IsRequired();
|
||||
});
|
||||
#pragma warning restore 612, 618
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,93 @@
|
||||
using System;
|
||||
using Microsoft.EntityFrameworkCore.Migrations;
|
||||
|
||||
#nullable disable
|
||||
|
||||
namespace Flaro.Data.Migrations
|
||||
{
|
||||
/// <inheritdoc />
|
||||
public partial class Sehfortschritt : Migration
|
||||
{
|
||||
/// <inheritdoc />
|
||||
protected override void Up(MigrationBuilder migrationBuilder)
|
||||
{
|
||||
migrationBuilder.CreateTable(
|
||||
name: "UserItemStates",
|
||||
columns: table => new
|
||||
{
|
||||
Id = table.Column<Guid>(type: "TEXT", nullable: false),
|
||||
UserId = table.Column<Guid>(type: "TEXT", nullable: false),
|
||||
MovieId = table.Column<Guid>(type: "TEXT", nullable: true),
|
||||
EpisodeId = table.Column<Guid>(type: "TEXT", nullable: true),
|
||||
Position = table.Column<long>(type: "INTEGER", nullable: false),
|
||||
Runtime = table.Column<long>(type: "INTEGER", nullable: true),
|
||||
Watched = table.Column<bool>(type: "INTEGER", nullable: false),
|
||||
PlayCount = table.Column<int>(type: "INTEGER", nullable: false),
|
||||
LastPlayedAt = table.Column<long>(type: "INTEGER", nullable: true),
|
||||
Dismissed = table.Column<bool>(type: "INTEGER", nullable: false),
|
||||
Favourite = table.Column<bool>(type: "INTEGER", nullable: false),
|
||||
Rating = table.Column<int>(type: "INTEGER", nullable: true),
|
||||
InProgress = table.Column<bool>(type: "INTEGER", nullable: false),
|
||||
UpdatedAt = table.Column<long>(type: "INTEGER", nullable: false)
|
||||
},
|
||||
constraints: table =>
|
||||
{
|
||||
table.PrimaryKey("PK_UserItemStates", x => x.Id);
|
||||
table.ForeignKey(
|
||||
name: "FK_UserItemStates_Episodes_EpisodeId",
|
||||
column: x => x.EpisodeId,
|
||||
principalTable: "Episodes",
|
||||
principalColumn: "Id",
|
||||
onDelete: ReferentialAction.Cascade);
|
||||
table.ForeignKey(
|
||||
name: "FK_UserItemStates_Movies_MovieId",
|
||||
column: x => x.MovieId,
|
||||
principalTable: "Movies",
|
||||
principalColumn: "Id",
|
||||
onDelete: ReferentialAction.Cascade);
|
||||
table.ForeignKey(
|
||||
name: "FK_UserItemStates_Users_UserId",
|
||||
column: x => x.UserId,
|
||||
principalTable: "Users",
|
||||
principalColumn: "Id",
|
||||
onDelete: ReferentialAction.Cascade);
|
||||
});
|
||||
|
||||
migrationBuilder.CreateIndex(
|
||||
name: "IX_UserItemStates_EpisodeId",
|
||||
table: "UserItemStates",
|
||||
column: "EpisodeId");
|
||||
|
||||
migrationBuilder.CreateIndex(
|
||||
name: "IX_UserItemStates_MovieId",
|
||||
table: "UserItemStates",
|
||||
column: "MovieId");
|
||||
|
||||
migrationBuilder.CreateIndex(
|
||||
name: "IX_UserItemStates_UserId_EpisodeId",
|
||||
table: "UserItemStates",
|
||||
columns: new[] { "UserId", "EpisodeId" },
|
||||
unique: true,
|
||||
filter: "\"EpisodeId\" IS NOT NULL");
|
||||
|
||||
migrationBuilder.CreateIndex(
|
||||
name: "IX_UserItemStates_UserId_InProgress_UpdatedAt",
|
||||
table: "UserItemStates",
|
||||
columns: new[] { "UserId", "InProgress", "UpdatedAt" });
|
||||
|
||||
migrationBuilder.CreateIndex(
|
||||
name: "IX_UserItemStates_UserId_MovieId",
|
||||
table: "UserItemStates",
|
||||
columns: new[] { "UserId", "MovieId" },
|
||||
unique: true,
|
||||
filter: "\"MovieId\" IS NOT NULL");
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
protected override void Down(MigrationBuilder migrationBuilder)
|
||||
{
|
||||
migrationBuilder.DropTable(
|
||||
name: "UserItemStates");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -395,6 +395,70 @@ namespace Flaro.Data.Migrations
|
||||
b.ToTable("Series");
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Flaro.Core.Playback.UserItemState", b =>
|
||||
{
|
||||
b.Property<Guid>("Id")
|
||||
.ValueGeneratedOnAdd()
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<bool>("Dismissed")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<Guid?>("EpisodeId")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<bool>("Favourite")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<bool>("InProgress")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<long?>("LastPlayedAt")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<Guid?>("MovieId")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<int>("PlayCount")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<long>("Position")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<int?>("Rating")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<long?>("Runtime")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<long>("UpdatedAt")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<Guid>("UserId")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<bool>("Watched")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.HasKey("Id");
|
||||
|
||||
b.HasIndex("EpisodeId");
|
||||
|
||||
b.HasIndex("MovieId");
|
||||
|
||||
b.HasIndex("UserId", "EpisodeId")
|
||||
.IsUnique()
|
||||
.HasFilter("\"EpisodeId\" IS NOT NULL");
|
||||
|
||||
b.HasIndex("UserId", "MovieId")
|
||||
.IsUnique()
|
||||
.HasFilter("\"MovieId\" IS NOT NULL");
|
||||
|
||||
b.HasIndex("UserId", "InProgress", "UpdatedAt");
|
||||
|
||||
b.ToTable("UserItemStates");
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Flaro.Core.ServerSetting", b =>
|
||||
{
|
||||
b.Property<string>("Key")
|
||||
@@ -495,6 +559,25 @@ namespace Flaro.Data.Migrations
|
||||
.OnDelete(DeleteBehavior.Cascade)
|
||||
.IsRequired();
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Flaro.Core.Playback.UserItemState", b =>
|
||||
{
|
||||
b.HasOne("Flaro.Core.Library.Episode", null)
|
||||
.WithMany()
|
||||
.HasForeignKey("EpisodeId")
|
||||
.OnDelete(DeleteBehavior.Cascade);
|
||||
|
||||
b.HasOne("Flaro.Core.Library.Movie", null)
|
||||
.WithMany()
|
||||
.HasForeignKey("MovieId")
|
||||
.OnDelete(DeleteBehavior.Cascade);
|
||||
|
||||
b.HasOne("Flaro.Core.Users.User", null)
|
||||
.WithMany()
|
||||
.HasForeignKey("UserId")
|
||||
.OnDelete(DeleteBehavior.Cascade)
|
||||
.IsRequired();
|
||||
});
|
||||
#pragma warning restore 612, 618
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user