Stufe 2a: Der Bestand wird gelesen, nicht mehr nur verwaltet
Dateinamen erkennen, Verzeichnisse durchlaufen, abgleichen, blättern. Noch ohne TMDB — die Titel kommen vorerst aus den Dateinamen, und genau daran entscheidet sich später, ob die Metadatenquelle etwas findet. **Der Dateiname ist die Stelle, an der Medienserver in der Praxis scheitern.** Was auf der Platte liegt, heisst nicht „Der Fall", sondern `Notruf.Hafenkante.S01E01.German.1080p.WEB-DL.x264-GRP.mkv`. Das Verfahren schneidet ab dem ersten Technik-Merkmal ab, statt einzelne Tags herauszulösen: Letzteres klingt gründlicher, lässt aber bei jedem unbekannten Tag Bruchstücke stehen — und unbekannte Tags gibt es immer. Drei Fälle, an denen sich die Regeln entscheiden, alle geprüft: - **„Blade Runner 2049" behält seine Zahl.** Eine Jahreszahl muss plausibel sein; was weit in der Zukunft liegt, gehört zum Titel. Ohne diese Grenze hiesse der Film „Blade Runner", erschienen 2049, und keine Metadatenquelle fände ihn so. - **„S.W.A.T." behält seine Punkte.** Trennpunkte werden nur dort zu Leerzeichen, wo sonst keine sind — stehen welche im Namen, hat jemand von Hand benannt, und seine Punkte sind gewollt. (Der Schlusspunkt fiel erst einem Test auf.) - **Ohne Folgennummer wird nichts geraten.** Eine erfundene Staffel 1 landete unter einer Serie, zu der die Datei nicht gehört. **`@eaDir` ist der Grund, warum der Walker von Hand absteigt.** Synologys Vorschauablage enthält eine Kopie *jeder* Datei; mit `SearchOption.AllDirectories` — der bequemen Fassung — stünde jeder Film zweimal in der Mediathek, zur Hälfte als unbrauchbare Kopie. Äste beschneiden kann nur, wer selbst absteigt. Ein gesperrter Unterordner bricht den Lauf nicht ab, sondern wird vermerkt. **Die Datei zeigt auf den Titel, nicht umgekehrt.** Sieht herumgedreht aus und ist Absicht: ein Film liegt oft als 4K *und* als 1080p vor. Trüge der Film den Verweis auf seine eine Datei, wäre die zweite Fassung ein Umbau am Datenmodell — so ist sie eine Zeile mehr. Geprüft. **Der Scan läuft im Hintergrund**, nicht in der Anfrage: ein Bestand mit 40 000 Titeln braucht Minuten, und eine so lange offene Anfrage läuft hinter jedem Reverse Proxy ins Zeitlimit. Einer je Bibliothek, sonst löschen sich zwei Läufe gegenseitig die Einträge. Aufgeräumt wird über den Zeitstempel des Laufs — billiger, als sich alle gesehenen Pfade zu merken. Zweimal scannen ergibt dasselbe wie einmal. Das ist der Fehler, den man sonst erst nach Wochen bemerkt, wenn jeder Film fünfmal dasteht. 131 Tests grün (88 Kern, 43 Schnittstelle). 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
156c740330
commit
78b7e3bcb8
@@ -31,3 +31,31 @@ public sealed record CreateUserRequest(string UserName, string Password, bool Is
|
||||
public sealed record LibraryResponse(Guid Id, string Name, string Kind, string Path);
|
||||
|
||||
public sealed record CreateLibraryRequest(string Name, string Kind, string Path);
|
||||
|
||||
// --- Stufe 2: Bibliothek -------------------------------------------------
|
||||
|
||||
public sealed record ScanProblem(string Path, string Reason);
|
||||
|
||||
public sealed record ScanStatus(
|
||||
string State,
|
||||
DateTimeOffset? StartedAt,
|
||||
DateTimeOffset? FinishedAt,
|
||||
int? FilesFound,
|
||||
int? Added,
|
||||
int? Updated,
|
||||
int? Removed,
|
||||
int? Unrecognised,
|
||||
IReadOnlyList<ScanProblem>? Problems,
|
||||
string? Error);
|
||||
|
||||
public sealed record MediaFileResponse(Guid Id, string Path, long SizeBytes);
|
||||
|
||||
public sealed record MovieResponse(
|
||||
Guid Id, string Title, int? Year, string? Overview, IReadOnlyList<MediaFileResponse> Files);
|
||||
|
||||
public sealed record SeriesResponse(Guid Id, string Title, int? Year, int EpisodeCount, IReadOnlyList<int> Seasons);
|
||||
|
||||
public sealed record EpisodeResponse(
|
||||
Guid Id, int Season, int Episode, string? Title, IReadOnlyList<MediaFileResponse> Files);
|
||||
|
||||
public sealed record Page<T>(IReadOnlyList<T> Items, int Total);
|
||||
|
||||
@@ -0,0 +1,144 @@
|
||||
using Halo.Data;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
|
||||
namespace Halo.Api.Endpoints;
|
||||
|
||||
public static class LibraryContentEndpoints
|
||||
{
|
||||
/// <summary>Mehr als das liefert keine Anfrage — auch wenn sie danach fragt.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// Ohne Obergrenze holt ein <c>?take=100000</c> die ganze Mediathek in
|
||||
/// einem Zug, und zwar sowohl in den Arbeitsspeicher des Servers als auch
|
||||
/// über die Leitung. Eine Grenze, die der Aufrufer setzt, ist keine.
|
||||
/// </remarks>
|
||||
private const int HöchstensJeSeite = 200;
|
||||
|
||||
public static void MapLibraryContent(this IEndpointRouteBuilder app)
|
||||
{
|
||||
MapScan(app);
|
||||
MapBrowse(app);
|
||||
}
|
||||
|
||||
private static void MapScan(IEndpointRouteBuilder app)
|
||||
{
|
||||
app.MapPost("/api/v1/libraries/{id:guid}/scan", async (
|
||||
Guid id, HaloContext db, ScanCoordinator koordinator) =>
|
||||
{
|
||||
if (!await db.Libraries.AnyAsync(l => l.Id == id)) return Results.NotFound();
|
||||
|
||||
return koordinator.TryStart(id)
|
||||
? Results.AcceptedAtRoute("Scanstand", new { id })
|
||||
: Results.Problem(
|
||||
"Für diese Bibliothek läuft bereits ein Scan.",
|
||||
statusCode: StatusCodes.Status409Conflict);
|
||||
}).RequireAuthorization(HaloPolicies.Administrator);
|
||||
|
||||
app.MapGet("/api/v1/libraries/{id:guid}/scan", (Guid id, ScanCoordinator koordinator) =>
|
||||
{
|
||||
var zustand = koordinator.State(id);
|
||||
if (zustand is null)
|
||||
return Results.Ok(new ScanStatus("idle", null, null, null, null, null, null, null, null, null));
|
||||
|
||||
var bericht = zustand.Report;
|
||||
return Results.Ok(new ScanStatus(
|
||||
zustand.Status, zustand.StartedAt, zustand.FinishedAt,
|
||||
bericht?.FilesFound, bericht?.Added, bericht?.Updated, bericht?.Removed, bericht?.Unrecognised,
|
||||
bericht?.Problems.Select(p => new ScanProblem(p.Path, p.Reason)).ToList(),
|
||||
zustand.Error));
|
||||
}).WithName("Scanstand").RequireAuthorization();
|
||||
}
|
||||
|
||||
private static void MapBrowse(IEndpointRouteBuilder app)
|
||||
{
|
||||
app.MapGet("/api/v1/movies", async (
|
||||
HaloContext 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);
|
||||
if (!string.IsNullOrWhiteSpace(search))
|
||||
abfrage = abfrage.Where(m => EF.Functions.Like(m.Title, $"%{search.Trim()}%"));
|
||||
|
||||
var gesamt = await abfrage.CountAsync();
|
||||
var kennungen = await abfrage
|
||||
.OrderBy(m => m.SortTitleValue).ThenBy(m => m.Year)
|
||||
.Skip(Math.Max(0, skip)).Take(Math.Clamp(take, 1, HöchstensJeSeite))
|
||||
.Select(m => new { m.Id, m.Title, m.Year, m.Overview })
|
||||
.ToListAsync();
|
||||
|
||||
// Dateien in **einer** Abfrage nachholen statt je Film einer.
|
||||
// Andernfalls kostet eine Seite mit fünfzig Titeln einundfünfzig
|
||||
// Abfragen, und SQLite führt die nacheinander aus.
|
||||
var ids = kennungen.Select(m => m.Id).ToList();
|
||||
var dateien = await db.MediaFiles.AsNoTracking()
|
||||
.Where(f => f.MovieId != null && ids.Contains(f.MovieId!.Value))
|
||||
.Select(f => new { f.Id, f.Path, f.SizeBytes, f.MovieId })
|
||||
.ToListAsync();
|
||||
|
||||
var items = kennungen.Select(m => new MovieResponse(
|
||||
m.Id, m.Title, m.Year, m.Overview,
|
||||
dateien.Where(f => f.MovieId == m.Id)
|
||||
.Select(f => new MediaFileResponse(f.Id, f.Path, f.SizeBytes)).ToList())).ToList();
|
||||
|
||||
return Results.Ok(new Page<MovieResponse>(items, gesamt));
|
||||
}).RequireAuthorization();
|
||||
|
||||
app.MapGet("/api/v1/series", async (
|
||||
HaloContext 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);
|
||||
if (!string.IsNullOrWhiteSpace(search))
|
||||
abfrage = abfrage.Where(s => EF.Functions.Like(s.Title, $"%{search.Trim()}%"));
|
||||
|
||||
var gesamt = await abfrage.CountAsync();
|
||||
var serien = await abfrage
|
||||
.OrderBy(s => s.SortTitleValue)
|
||||
.Skip(Math.Max(0, skip)).Take(Math.Clamp(take, 1, HöchstensJeSeite))
|
||||
.Select(s => new { s.Id, s.Title, s.Year })
|
||||
.ToListAsync();
|
||||
|
||||
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 })
|
||||
.ToListAsync();
|
||||
|
||||
var items = serien.Select(s =>
|
||||
{
|
||||
var meine = folgen.Where(f => f.SeriesId == s.Id).ToList();
|
||||
return new SeriesResponse(
|
||||
s.Id, s.Title, s.Year, meine.Count,
|
||||
meine.Select(f => f.SeasonNumber).Distinct().Order().ToList());
|
||||
}).ToList();
|
||||
|
||||
return Results.Ok(new Page<SeriesResponse>(items, gesamt));
|
||||
}).RequireAuthorization();
|
||||
|
||||
app.MapGet("/api/v1/series/{id:guid}/episodes", async (Guid id, HaloContext db, int? season) =>
|
||||
{
|
||||
if (!await db.Series.AnyAsync(s => s.Id == id)) return Results.NotFound();
|
||||
|
||||
var abfrage = db.Episodes.AsNoTracking().Where(f => f.SeriesId == id);
|
||||
if (season is { } staffel) abfrage = abfrage.Where(f => f.SeasonNumber == staffel);
|
||||
|
||||
var folgen = await abfrage
|
||||
.OrderBy(f => f.SeasonNumber).ThenBy(f => f.EpisodeNumber)
|
||||
.Select(f => new { f.Id, f.SeasonNumber, f.EpisodeNumber, f.Title })
|
||||
.ToListAsync();
|
||||
|
||||
var ids = folgen.Select(f => f.Id).ToList();
|
||||
var dateien = await db.MediaFiles.AsNoTracking()
|
||||
.Where(d => d.EpisodeId != null && ids.Contains(d.EpisodeId!.Value))
|
||||
.Select(d => new { d.Id, d.Path, d.SizeBytes, d.EpisodeId })
|
||||
.ToListAsync();
|
||||
|
||||
var items = folgen.Select(f => new EpisodeResponse(
|
||||
f.Id, f.SeasonNumber, f.EpisodeNumber, f.Title,
|
||||
dateien.Where(d => d.EpisodeId == f.Id)
|
||||
.Select(d => new MediaFileResponse(d.Id, d.Path, d.SizeBytes)).ToList())).ToList();
|
||||
|
||||
return Results.Ok(new Page<EpisodeResponse>(items, items.Count));
|
||||
}).RequireAuthorization();
|
||||
}
|
||||
}
|
||||
@@ -57,6 +57,8 @@ builder.Services.AddRateLimiter(o =>
|
||||
_ => new FixedWindowRateLimiterOptions { PermitLimit = beimNachfragen, Window = TimeSpan.FromMinutes(1) }));
|
||||
});
|
||||
|
||||
builder.Services.AddScoped<LibraryScanner>();
|
||||
builder.Services.AddSingleton<ScanCoordinator>();
|
||||
builder.Services.AddProblemDetails();
|
||||
|
||||
var app = builder.Build();
|
||||
@@ -77,6 +79,7 @@ app.UseAuthorization();
|
||||
app.MapSystem();
|
||||
app.MapAuth();
|
||||
app.MapManagement();
|
||||
app.MapLibraryContent();
|
||||
|
||||
app.Run();
|
||||
|
||||
|
||||
@@ -0,0 +1,87 @@
|
||||
using System.Collections.Concurrent;
|
||||
using Halo.Data;
|
||||
|
||||
namespace Halo.Api;
|
||||
|
||||
public sealed record ScanState(
|
||||
string Status,
|
||||
DateTimeOffset StartedAt,
|
||||
DateTimeOffset? FinishedAt,
|
||||
ScanReport? Report,
|
||||
string? Error);
|
||||
|
||||
/// <summary>Lässt Scans im Hintergrund laufen und weiss, wie weit sie sind.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>Nicht in der Anfrage.</b> Ein Bestand mit 40 000 Titeln braucht Minuten;
|
||||
/// eine HTTP-Anfrage, die so lange offen steht, läuft hinter jedem Reverse
|
||||
/// Proxy ins Zeitlimit — und der Anwender sieht einen Fehler, während der Scan
|
||||
/// in Wahrheit tadellos weiterläuft.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>Einer je Bibliothek, nicht mehr.</b> Zwei gleichzeitige Läufe über
|
||||
/// dasselbe Verzeichnis würden sich beim Aufräumen gegenseitig die Einträge
|
||||
/// löschen: der eine schreibt seine Startzeit, der andere hält sie für alt.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// Der Zustand liegt im Arbeitsspeicher und nicht in der Datenbank. Ein
|
||||
/// Neustart bricht den Scan ohnehin ab, und ein „läuft" aus einem früheren
|
||||
/// Leben wäre dann eine Lüge, die niemand mehr aufräumt.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public sealed class ScanCoordinator(
|
||||
IServiceScopeFactory scopes,
|
||||
TimeProvider clock,
|
||||
ILogger<ScanCoordinator> log)
|
||||
{
|
||||
private readonly ConcurrentDictionary<Guid, ScanState> _zustand = new();
|
||||
|
||||
public ScanState? State(Guid libraryId) => _zustand.GetValueOrDefault(libraryId);
|
||||
|
||||
public bool IsRunning(Guid libraryId) => State(libraryId)?.Status == "running";
|
||||
|
||||
/// <summary>Startet einen Lauf — oder sagt, dass schon einer läuft.</summary>
|
||||
public bool TryStart(Guid libraryId)
|
||||
{
|
||||
var start = new ScanState("running", clock.GetUtcNow(), null, null, null);
|
||||
|
||||
var vorher = _zustand.AddOrUpdate(
|
||||
libraryId,
|
||||
start,
|
||||
(_, alt) => alt.Status == "running" ? alt : start);
|
||||
|
||||
// Lief schon einer, steht hier dessen Zustand und nicht unserer.
|
||||
if (!ReferenceEquals(vorher, start)) return false;
|
||||
|
||||
_ = Task.Run(() => Laufen(libraryId));
|
||||
return true;
|
||||
}
|
||||
|
||||
private async Task Laufen(Guid libraryId)
|
||||
{
|
||||
try
|
||||
{
|
||||
using var bereich = scopes.CreateScope();
|
||||
var scanner = bereich.ServiceProvider.GetRequiredService<LibraryScanner>();
|
||||
var bericht = await scanner.ScanAsync(libraryId);
|
||||
|
||||
_zustand[libraryId] = _zustand[libraryId] with
|
||||
{
|
||||
Status = "finished",
|
||||
FinishedAt = clock.GetUtcNow(),
|
||||
Report = bericht,
|
||||
};
|
||||
}
|
||||
catch (Exception fehler)
|
||||
{
|
||||
log.LogError(fehler, "Scan der Bibliothek {Kennung} ist gescheitert.", libraryId);
|
||||
_zustand[libraryId] = _zustand[libraryId] with
|
||||
{
|
||||
Status = "failed",
|
||||
FinishedAt = clock.GetUtcNow(),
|
||||
Error = fehler.Message,
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,211 @@
|
||||
using System.Globalization;
|
||||
using System.Text.RegularExpressions;
|
||||
|
||||
namespace Halo.Core.Library;
|
||||
|
||||
public sealed record MovieName(string Title, int? Year);
|
||||
|
||||
public sealed record EpisodeName(string SeriesTitle, int Season, int Episode, string? EpisodeTitle);
|
||||
|
||||
/// <summary>Macht aus einem Dateinamen wieder Titel, Jahr, Staffel und Folge.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>Hier scheitern Medienserver in der Praxis.</b> Was auf der Platte liegt,
|
||||
/// heisst nicht „Der Fall", sondern
|
||||
/// <c>Notruf.Hafenkante.S01E01.German.1080p.WEB-DL.x264-GRP.mkv</c>, und was
|
||||
/// davon Titel ist und was Beiwerk, steht nirgends. Rät man falsch, sucht die
|
||||
/// Metadatenquelle nach „Notruf Hafenkante German 1080p" und findet nichts —
|
||||
/// der Titel bleibt dann für immer der Dateiname.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>Das Verfahren: abschneiden, nicht herauslösen.</b> Alles ab dem ersten
|
||||
/// Beiwerk-Merkmal fliegt weg. Einzelne Tags zu entfernen und den Rest
|
||||
/// zusammenzuschieben klingt gründlicher, lässt aber bei jedem unbekannten Tag
|
||||
/// Bruchstücke im Titel stehen — und unbekannte Tags gibt es immer.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public static partial class FileNames
|
||||
{
|
||||
/// <summary>Merkmale, ab denen nur noch Technik kommt.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// Nicht vollständig und kann es nicht sein. Es muss nur das erste treffen
|
||||
/// — alles dahinter fällt ohnehin weg.
|
||||
/// </remarks>
|
||||
private static readonly HashSet<string> Beiwerk = new(StringComparer.OrdinalIgnoreCase)
|
||||
{
|
||||
// Quelle
|
||||
"bluray", "blu-ray", "bdrip", "brrip", "bdremux", "remux", "dvdrip", "dvd", "dvdr",
|
||||
"webrip", "web-dl", "webdl", "web", "hdtv", "pdtv", "hdrip", "cam", "ts", "tc", "r5",
|
||||
"uhdbd", "uhd", "hddvd",
|
||||
// Bild
|
||||
"x264", "x265", "h264", "h265", "hevc", "avc", "xvid", "divx", "av1", "mpeg2", "vc1",
|
||||
"hdr", "hdr10", "hdr10plus", "dolbyvision", "dovi", "sdr", "10bit", "8bit",
|
||||
// Ton
|
||||
"aac", "ac3", "eac3", "dts", "dtshd", "dts-hd", "truehd", "atmos", "flac", "opus",
|
||||
"mp3", "dd", "ddp", "dd5", "ddp5", "lpcm", "pcm",
|
||||
// Fassung
|
||||
"proper", "repack", "rerip", "extended", "unrated", "uncut", "remastered", "imax",
|
||||
"theatrical", "limited", "internal", "complete", "retail", "subbed", "dubbed",
|
||||
// Sprache und Herkunft, wie die Szene sie schreibt
|
||||
"german", "englisch", "english", "multi", "dual", "dl", "ger", "eng", "vo", "vost",
|
||||
"omu", "subs", "sub",
|
||||
};
|
||||
|
||||
/// <summary>Auflösungen wie 1080p, 2160p, 720i — und 4K.</summary>
|
||||
[GeneratedRegex(@"^\d{3,4}[pi]$|^[48]k$", RegexOptions.IgnoreCase)]
|
||||
private static partial Regex Auflösung();
|
||||
|
||||
/// <summary>S01E02, s1e2, S01.E02, S01E02E03 — die erste Folge zählt.</summary>
|
||||
[GeneratedRegex(@"\bS(?<staffel>\d{1,3})[\s._-]*E(?<folge>\d{1,4})", RegexOptions.IgnoreCase)]
|
||||
private static partial Regex StaffelUndFolge();
|
||||
|
||||
/// <summary>1x02, 01x02 — die ältere Schreibweise.</summary>
|
||||
[GeneratedRegex(@"(?<![\dx])(?<staffel>\d{1,2})x(?<folge>\d{2,3})(?![\dx])", RegexOptions.IgnoreCase)]
|
||||
private static partial Regex KreuzSchreibweise();
|
||||
|
||||
/// <summary>Ein Jahr in Klammern: (1999) oder [1999].</summary>
|
||||
[GeneratedRegex(@"[\(\[](?<jahr>(?:18|19|20)\d{2})[\)\]]")]
|
||||
private static partial Regex JahrInKlammern();
|
||||
|
||||
[GeneratedRegex(@"\s+")]
|
||||
private static partial Regex Leerraum();
|
||||
|
||||
/// <summary>Liest Titel und Jahr aus einem Filmdateinamen.</summary>
|
||||
public static MovieName ParseMovie(string dateiname)
|
||||
{
|
||||
var (worte, jahrAusKlammern) = Zerlegen(dateiname);
|
||||
var (titel, jahr) = TitelBis(worte, grenze: worte.Length);
|
||||
return new MovieName(titel.Length > 0 ? titel : Rohname(dateiname), jahrAusKlammern ?? jahr);
|
||||
}
|
||||
|
||||
/// <summary>Liest Serie, Staffel, Folge und Folgentitel — oder <c>null</c>.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <c>null</c> heisst: hier steht keine Folgennummer. Dann ist es entweder
|
||||
/// ein Film oder etwas, das niemand benennen kann — in beiden Fällen wäre
|
||||
/// eine geratene Staffel 1 schlimmer als gar keine.
|
||||
/// </remarks>
|
||||
public static EpisodeName? ParseEpisode(string dateiname)
|
||||
{
|
||||
var roh = Rohname(dateiname);
|
||||
|
||||
var treffer = StaffelUndFolge().Match(roh);
|
||||
if (!treffer.Success) treffer = KreuzSchreibweise().Match(roh);
|
||||
if (!treffer.Success) return null;
|
||||
|
||||
if (!int.TryParse(treffer.Groups["staffel"].Value, out var staffel) ||
|
||||
!int.TryParse(treffer.Groups["folge"].Value, out var folge)) return null;
|
||||
|
||||
var davor = roh[..treffer.Index];
|
||||
var danach = roh[(treffer.Index + treffer.Length)..];
|
||||
|
||||
var (worteDavor, _) = Zerlegen(davor, istDateiname: false);
|
||||
var (serie, _) = TitelBis(worteDavor, worteDavor.Length);
|
||||
|
||||
var (worteDanach, _) = Zerlegen(danach, istDateiname: false);
|
||||
var (folgenTitel, _) = TitelBis(worteDanach, worteDanach.Length);
|
||||
|
||||
return new EpisodeName(
|
||||
SeriesTitle: serie.Length > 0 ? serie : Rohname(dateiname),
|
||||
Season: staffel,
|
||||
Episode: folge,
|
||||
EpisodeTitle: folgenTitel.Length > 0 ? folgenTitel : null);
|
||||
}
|
||||
|
||||
/// <summary>Nimmt Worte, bis das erste Beiwerk oder eine Jahreszahl kommt.</summary>
|
||||
private static (string Titel, int? Jahr) TitelBis(string[] worte, int grenze)
|
||||
{
|
||||
var genommen = new List<string>();
|
||||
int? jahr = null;
|
||||
|
||||
for (var i = 0; i < grenze; i++)
|
||||
{
|
||||
var wort = worte[i];
|
||||
|
||||
if (IstBeiwerk(wort)) break;
|
||||
|
||||
// Eine Jahreszahl beendet den Titel — aber nur, wenn schon etwas
|
||||
// davorsteht. Sonst verlöre „2012" seinen ganzen Namen.
|
||||
if (genommen.Count > 0 && IstPlausiblesJahr(wort, out var gelesen))
|
||||
{
|
||||
jahr = gelesen;
|
||||
break;
|
||||
}
|
||||
|
||||
genommen.Add(wort);
|
||||
}
|
||||
|
||||
return (Säubern(string.Join(' ', genommen)), jahr);
|
||||
}
|
||||
|
||||
private static bool IstBeiwerk(string wort)
|
||||
{
|
||||
var blank = wort.Trim('[', ']', '(', ')', '{', '}', '-', '_');
|
||||
if (blank.Length == 0) return false;
|
||||
if (Beiwerk.Contains(blank) || Auflösung().IsMatch(blank)) return true;
|
||||
|
||||
// „x264-GRP" und „DD5.1" hängen am Beiwerk fest.
|
||||
var vorStrich = blank.Split('-', '.')[0];
|
||||
return vorStrich.Length > 1 && (Beiwerk.Contains(vorStrich) || Auflösung().IsMatch(vorStrich));
|
||||
}
|
||||
|
||||
/// <summary>Vier Ziffern allein machen noch kein Jahr.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>„Blade Runner 2049" ist der Fall, an dem sich das entscheidet.</b>
|
||||
/// Eine Obergrenze knapp über heute trennt eine Jahreszahl von einer Zahl
|
||||
/// im Titel — alles, was weit in der Zukunft liegt, gehört zum Namen.
|
||||
/// </remarks>
|
||||
private static bool IstPlausiblesJahr(string wort, out int jahr)
|
||||
{
|
||||
jahr = 0;
|
||||
var blank = wort.Trim('[', ']', '(', ')');
|
||||
if (blank.Length != 4 || !int.TryParse(blank, NumberStyles.None, CultureInfo.InvariantCulture, out var zahl))
|
||||
return false;
|
||||
|
||||
if (zahl < 1880 || zahl > DateTime.UtcNow.Year + 2) return false;
|
||||
jahr = zahl;
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>Dateiname ohne Pfad und ohne Endung.</summary>
|
||||
private static string Rohname(string dateiname) => Path.GetFileNameWithoutExtension(dateiname);
|
||||
|
||||
/// <summary>Zerlegt in Worte und holt ein eingeklammertes Jahr heraus.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Punkte werden nur dann zu Leerzeichen, wenn sonst keine da sind.</b>
|
||||
/// „The.Matrix.1999" braucht es; „S.W.A.T. (2003)" verlöre dadurch seinen
|
||||
/// Namen. Dass im Namen überhaupt Leerzeichen stehen, heisst: hier hat
|
||||
/// jemand von Hand benannt, und seine Punkte sind gewollt.
|
||||
/// </remarks>
|
||||
private static (string[] Worte, int? JahrInKlammern) Zerlegen(string eingabe, bool istDateiname = true)
|
||||
{
|
||||
var text = istDateiname ? Rohname(eingabe) : eingabe;
|
||||
|
||||
int? jahr = null;
|
||||
var geklammert = JahrInKlammern().Match(text);
|
||||
if (geklammert.Success && int.TryParse(geklammert.Groups["jahr"].Value, out var gelesen))
|
||||
{
|
||||
jahr = gelesen;
|
||||
text = text.Remove(geklammert.Index, geklammert.Length);
|
||||
}
|
||||
|
||||
text = text.Replace('_', ' ');
|
||||
if (!text.Contains(' ')) text = text.Replace('.', ' ');
|
||||
|
||||
return (Leerraum().Split(text.Trim()).Where(w => w.Length > 0).ToArray(), jahr);
|
||||
}
|
||||
|
||||
/// <summary>Räumt Trennzeichen weg, die am Rand übrig bleiben.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Der Punkt steht ausdrücklich nicht dabei.</b> Aus „S.W.A.T." würde
|
||||
/// sonst „S.W.A.T" — und ein Punkt am Titelende ist ohnehin selten, weil
|
||||
/// Trennpunkte schon beim Zerlegen zu Leerzeichen werden.
|
||||
/// </remarks>
|
||||
private static string Säubern(string roh) =>
|
||||
Leerraum().Replace(roh.Replace('_', ' '), " ").Trim(' ', '-', '–', ',', '[', ']', '(', ')');
|
||||
}
|
||||
@@ -0,0 +1,93 @@
|
||||
namespace Halo.Core.Library;
|
||||
|
||||
/// <summary>Eine gefundene Datei, so wie das Dateisystem sie beschreibt.</summary>
|
||||
public sealed record ScannedFile(string Path, long SizeBytes, DateTimeOffset ModifiedAt);
|
||||
|
||||
/// <summary>Was beim Durchlaufen schiefging, ohne den Lauf abzubrechen.</summary>
|
||||
public sealed record WalkProblem(string Path, string Reason);
|
||||
|
||||
public sealed record WalkResult(IReadOnlyList<ScannedFile> Files, IReadOnlyList<WalkProblem> Problems);
|
||||
|
||||
/// <summary>Läuft ein Bibliotheksverzeichnis ab und sammelt Videodateien.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>Von Hand rekursiv statt mit <c>AllDirectories</c>.</b> Die bequeme
|
||||
/// Fassung läuft auch in <c>@eaDir</c> hinein — Synologys Vorschauablage, die
|
||||
/// eine Kopie <i>jeder</i> Datei enthält. Wer sie mitnimmt, hat seine
|
||||
/// Mediathek doppelt, zur Hälfte mit unbrauchbaren Dateien. Äste beschneiden
|
||||
/// kann nur, wer selbst absteigt.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>Ein gesperrtes Unterverzeichnis bricht den Lauf nicht ab</b>, sondern
|
||||
/// wird vermerkt. Sonst entschiede ein einzelner falsch gesetzter Ordner
|
||||
/// darüber, ob überhaupt etwas gefunden wird — und die Mediathek bliebe leer,
|
||||
/// ohne dass jemand sagen könnte, warum.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public static class LibraryWalker
|
||||
{
|
||||
/// <summary>Tiefer als das ist kein Bestand, sondern eine Schleife.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// Verweise im Dateisystem können im Kreis zeigen. Ohne Grenze liefe der
|
||||
/// Scan, bis der Arbeitsspeicher voll ist.
|
||||
/// </remarks>
|
||||
private const int MaximaleTiefe = 12;
|
||||
|
||||
public static WalkResult Walk(string wurzel)
|
||||
{
|
||||
var gefunden = new List<ScannedFile>();
|
||||
var probleme = new List<WalkProblem>();
|
||||
|
||||
if (!Directory.Exists(wurzel))
|
||||
{
|
||||
probleme.Add(new WalkProblem(wurzel, "Das Verzeichnis gibt es nicht."));
|
||||
return new WalkResult(gefunden, probleme);
|
||||
}
|
||||
|
||||
Absteigen(wurzel, 0, gefunden, probleme);
|
||||
return new WalkResult(gefunden, probleme);
|
||||
}
|
||||
|
||||
private static void Absteigen(string ordner, int tiefe, List<ScannedFile> gefunden, List<WalkProblem> probleme)
|
||||
{
|
||||
if (tiefe > MaximaleTiefe)
|
||||
{
|
||||
probleme.Add(new WalkProblem(ordner, $"Tiefer als {MaximaleTiefe} Ebenen — hier wird nicht weitergesucht."));
|
||||
return;
|
||||
}
|
||||
|
||||
string[] dateien, unterordner;
|
||||
try
|
||||
{
|
||||
dateien = Directory.GetFiles(ordner);
|
||||
unterordner = Directory.GetDirectories(ordner);
|
||||
}
|
||||
catch (Exception fehler) when (fehler is UnauthorizedAccessException or IOException)
|
||||
{
|
||||
probleme.Add(new WalkProblem(ordner, fehler.Message));
|
||||
return;
|
||||
}
|
||||
|
||||
foreach (var datei in dateien)
|
||||
{
|
||||
if (!MediaExtensions.IsVideo(datei)) continue;
|
||||
try
|
||||
{
|
||||
var angaben = new FileInfo(datei);
|
||||
gefunden.Add(new ScannedFile(datei, angaben.Length, angaben.LastWriteTimeUtc));
|
||||
}
|
||||
catch (Exception fehler) when (fehler is UnauthorizedAccessException or IOException)
|
||||
{
|
||||
probleme.Add(new WalkProblem(datei, fehler.Message));
|
||||
}
|
||||
}
|
||||
|
||||
foreach (var unter in unterordner)
|
||||
{
|
||||
if (MediaExtensions.IsSkippedDirectory(Path.GetFileName(unter))) continue;
|
||||
Absteigen(unter, tiefe + 1, gefunden, probleme);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,79 @@
|
||||
namespace Halo.Core.Library;
|
||||
|
||||
/// <summary>Eine Datei auf der Platte, so wie der Scan sie vorgefunden hat.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>Die Datei zeigt auf den Titel, nicht umgekehrt.</b> Das sieht
|
||||
/// herumgedreht aus und ist Absicht: ein Film liegt oft zweimal vor, als 4K
|
||||
/// und als 1080p. Trüge der Film den Verweis auf seine eine Datei, wäre die
|
||||
/// zweite Fassung ein Umbau am Datenmodell — so ist sie eine Zeile mehr.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// Genau dasselbe gilt für Folgen.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public sealed class MediaFile
|
||||
{
|
||||
public Guid Id { get; init; } = Guid.CreateVersion7();
|
||||
public required Guid LibraryId { get; init; }
|
||||
|
||||
/// <summary>Der Pfad, wie der Server ihn sieht — im Container, nicht auf dem Wirt.</summary>
|
||||
public required string Path { get; set; }
|
||||
|
||||
public long SizeBytes { get; set; }
|
||||
public DateTimeOffset ModifiedAt { get; set; }
|
||||
|
||||
/// <summary>Wann der letzte Scan diese Datei noch vorgefunden hat.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// Daran hängt das Aufräumen: Was ein Lauf nicht gesehen hat, liegt nicht
|
||||
/// mehr da. Ohne diese Angabe müsste der Scan sich merken, was er gesehen
|
||||
/// hat, und das wächst mit dem Bestand.
|
||||
/// </remarks>
|
||||
public DateTimeOffset SeenAt { get; set; }
|
||||
|
||||
public Guid? MovieId { get; set; }
|
||||
public Guid? EpisodeId { get; set; }
|
||||
}
|
||||
|
||||
public sealed class Movie
|
||||
{
|
||||
public Guid Id { get; init; } = Guid.CreateVersion7();
|
||||
public required Guid LibraryId { get; init; }
|
||||
public required string Title { get; set; }
|
||||
|
||||
/// <summary>Ohne führenden Artikel — siehe <see cref="SortTitle"/>.</summary>
|
||||
public required string SortTitleValue { get; set; }
|
||||
|
||||
public int? Year { get; set; }
|
||||
public string? Overview { get; set; }
|
||||
|
||||
/// <summary>Die Kennung bei TMDB, sobald zugeordnet.</summary>
|
||||
public int? TmdbId { get; set; }
|
||||
|
||||
public DateTimeOffset AddedAt { get; init; } = DateTimeOffset.UtcNow;
|
||||
}
|
||||
|
||||
public sealed class Series
|
||||
{
|
||||
public Guid Id { get; init; } = Guid.CreateVersion7();
|
||||
public required Guid LibraryId { get; init; }
|
||||
public required string Title { get; set; }
|
||||
public required string SortTitleValue { get; set; }
|
||||
public int? Year { get; set; }
|
||||
public string? Overview { get; set; }
|
||||
public int? TmdbId { get; set; }
|
||||
public DateTimeOffset AddedAt { get; init; } = DateTimeOffset.UtcNow;
|
||||
}
|
||||
|
||||
public sealed class Episode
|
||||
{
|
||||
public Guid Id { get; init; } = Guid.CreateVersion7();
|
||||
public required Guid SeriesId { get; init; }
|
||||
public required int SeasonNumber { get; init; }
|
||||
public required int EpisodeNumber { get; init; }
|
||||
public string? Title { get; set; }
|
||||
public string? Overview { get; set; }
|
||||
public DateTimeOffset AddedAt { get; init; } = DateTimeOffset.UtcNow;
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
namespace Halo.Core.Library;
|
||||
|
||||
/// <summary>Welche Dateien überhaupt als Medien gelten.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Eine Erlaubnisliste, keine Verbotsliste.</b> Ein Bestand enthält
|
||||
/// Bildchen, Untertitel, `.nfo`, `.DS_Store`, Papierkörbe und angefangene
|
||||
/// Downloads. Alles aufzunehmen, was nicht ausdrücklich verboten ist, hiesse,
|
||||
/// in der Mediathek irgendwann eine `Thumbs.db` als Film zu finden.
|
||||
/// </remarks>
|
||||
public static class MediaExtensions
|
||||
{
|
||||
private static readonly HashSet<string> Video = new(StringComparer.OrdinalIgnoreCase)
|
||||
{
|
||||
".mkv", ".mp4", ".m4v", ".avi", ".mov", ".ts", ".m2ts", ".mpg", ".mpeg",
|
||||
".wmv", ".flv", ".webm", ".vob", ".iso", ".divx", ".ogv", ".3gp",
|
||||
};
|
||||
|
||||
/// <summary>Was unterwegs oder unvollständig ist und deshalb nicht zählt.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// Ein laufender Download heisst oft `.mkv.part` oder liegt in einem
|
||||
/// Ordner, der mit einem Punkt anfängt. Ihn aufzunehmen hiesse: ein Titel
|
||||
/// erscheint, verschwindet wieder, und beim Abspielen bricht er mittendrin
|
||||
/// ab.
|
||||
/// </remarks>
|
||||
private static readonly string[] UnfertigeEndungen = [".part", ".!qb", ".crdownload", ".tmp", ".partial"];
|
||||
|
||||
public static bool IsVideo(string pfad)
|
||||
{
|
||||
var name = Path.GetFileName(pfad);
|
||||
if (name.Length == 0 || name[0] == '.') return false;
|
||||
if (UnfertigeEndungen.Any(e => name.EndsWith(e, StringComparison.OrdinalIgnoreCase))) return false;
|
||||
return Video.Contains(Path.GetExtension(name));
|
||||
}
|
||||
|
||||
/// <summary>Verzeichnisse, die in einem Bestand nichts Abspielbares enthalten.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// `@eaDir` ist Synologys Vorschaubild-Ablage und enthält Kopien **jeder**
|
||||
/// Datei — wer sie mitscannt, verdoppelt seine Mediathek mit unbrauchbaren
|
||||
/// Dateien. Die übrigen sind Papierkörbe und Wiederherstellungspunkte.
|
||||
/// </remarks>
|
||||
private static readonly HashSet<string> ÜbersprungeneOrdner = new(StringComparer.OrdinalIgnoreCase)
|
||||
{
|
||||
"@eaDir", "#recycle", "$RECYCLE.BIN", "lost+found", ".Trashes", ".AppleDouble",
|
||||
"System Volume Information", "extras", "featurettes", "behind the scenes", "trailers",
|
||||
};
|
||||
|
||||
public static bool IsSkippedDirectory(string name) =>
|
||||
name.Length > 0 && (name[0] == '.' || ÜbersprungeneOrdner.Contains(name));
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
namespace Halo.Core.Library;
|
||||
|
||||
/// <summary>Der Titel, nach dem sortiert wird — ohne den Artikel davor.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// Sonst stünde die halbe Mediathek unter „D": „Der Untergang", „Die Welle",
|
||||
/// „Das Boot". Gezeigt wird weiterhin der richtige Titel; nur die Reihenfolge
|
||||
/// richtet sich nach dem, was danach kommt.
|
||||
/// </remarks>
|
||||
public static class SortTitle
|
||||
{
|
||||
/// <summary>Deutsch und Englisch — die beiden Sprachen, in denen Bestände hier vorliegen.</summary>
|
||||
private static readonly string[] Artikel = ["der ", "die ", "das ", "the ", "a ", "an ", "ein ", "eine "];
|
||||
|
||||
public static string For(string titel)
|
||||
{
|
||||
var blank = titel.Trim();
|
||||
foreach (var artikel in Artikel)
|
||||
{
|
||||
if (!blank.StartsWith(artikel, StringComparison.OrdinalIgnoreCase)) continue;
|
||||
|
||||
var rest = blank[artikel.Length..].TrimStart();
|
||||
// „Die" allein ist ein Titel, kein Artikel — dann bliebe nichts übrig.
|
||||
if (rest.Length > 0) return rest;
|
||||
}
|
||||
return blank;
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,7 @@
|
||||
using Halo.Core;
|
||||
using Halo.Core.Auth;
|
||||
using Halo.Core.Libraries;
|
||||
using Halo.Core.Library;
|
||||
using Halo.Core.Users;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
|
||||
@@ -26,6 +27,11 @@ public sealed class HaloContext(DbContextOptions<HaloContext> options) : DbConte
|
||||
public DbSet<Library> Libraries => Set<Library>();
|
||||
public DbSet<ServerSetting> Settings => Set<ServerSetting>();
|
||||
|
||||
public DbSet<MediaFile> MediaFiles => Set<MediaFile>();
|
||||
public DbSet<Movie> Movies => Set<Movie>();
|
||||
public DbSet<Series> Series => Set<Series>();
|
||||
public DbSet<Episode> Episodes => Set<Episode>();
|
||||
|
||||
/// <summary>Gilt für jede Zeitangabe im Modell, ohne sie einzeln zu nennen.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
@@ -90,5 +96,50 @@ public sealed class HaloContext(DbContextOptions<HaloContext> options) : DbConte
|
||||
e.Property(x => x.Key).HasMaxLength(128);
|
||||
e.Property(x => x.Value).HasMaxLength(4096);
|
||||
});
|
||||
|
||||
b.Entity<MediaFile>(e =>
|
||||
{
|
||||
e.HasKey(x => x.Id);
|
||||
// Ein Pfad je Bibliothek, und zwar zwingend: ohne diese Regel legt
|
||||
// ein zweimal angestossener Scan jede Datei zweimal an, und die
|
||||
// Mediathek wächst bei jedem Lauf.
|
||||
e.HasIndex(x => new { x.LibraryId, x.Path }).IsUnique();
|
||||
e.HasIndex(x => x.MovieId);
|
||||
e.HasIndex(x => x.EpisodeId);
|
||||
e.Property(x => x.Path).HasMaxLength(1024);
|
||||
e.HasOne<Core.Libraries.Library>().WithMany().HasForeignKey(x => x.LibraryId)
|
||||
.OnDelete(DeleteBehavior.Cascade);
|
||||
});
|
||||
|
||||
b.Entity<Movie>(e =>
|
||||
{
|
||||
e.HasKey(x => x.Id);
|
||||
e.HasIndex(x => new { x.LibraryId, x.SortTitleValue });
|
||||
e.Property(x => x.Title).HasMaxLength(512);
|
||||
e.Property(x => x.SortTitleValue).HasMaxLength(512);
|
||||
e.HasOne<Core.Libraries.Library>().WithMany().HasForeignKey(x => x.LibraryId)
|
||||
.OnDelete(DeleteBehavior.Cascade);
|
||||
});
|
||||
|
||||
b.Entity<Series>(e =>
|
||||
{
|
||||
e.HasKey(x => x.Id);
|
||||
e.HasIndex(x => new { x.LibraryId, x.SortTitleValue });
|
||||
e.Property(x => x.Title).HasMaxLength(512);
|
||||
e.Property(x => x.SortTitleValue).HasMaxLength(512);
|
||||
e.HasOne<Core.Libraries.Library>().WithMany().HasForeignKey(x => x.LibraryId)
|
||||
.OnDelete(DeleteBehavior.Cascade);
|
||||
});
|
||||
|
||||
b.Entity<Episode>(e =>
|
||||
{
|
||||
e.HasKey(x => x.Id);
|
||||
// Eine Folgennummer gibt es in einer Staffel genau einmal. Liegen
|
||||
// zwei Dateien dafür vor, sind es zwei Fassungen derselben Folge —
|
||||
// und die hängen beide an diesem einen Eintrag.
|
||||
e.HasIndex(x => new { x.SeriesId, x.SeasonNumber, x.EpisodeNumber }).IsUnique();
|
||||
e.Property(x => x.Title).HasMaxLength(512);
|
||||
e.HasOne<Series>().WithMany().HasForeignKey(x => x.SeriesId).OnDelete(DeleteBehavior.Cascade);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,221 @@
|
||||
using Halo.Core.Libraries;
|
||||
using Halo.Core.Library;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Microsoft.Extensions.Logging;
|
||||
|
||||
namespace Halo.Data;
|
||||
|
||||
public sealed record ScanReport(
|
||||
int FilesFound,
|
||||
int Added,
|
||||
int Updated,
|
||||
int Removed,
|
||||
int Unrecognised,
|
||||
IReadOnlyList<WalkProblem> Problems);
|
||||
|
||||
/// <summary>Gleicht ab, was auf der Platte liegt, mit dem, was in der Datenbank steht.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>Der Scan ist beliebig oft wiederholbar.</b> Zweimal laufen zu lassen
|
||||
/// muss dasselbe Ergebnis haben wie einmal — sonst wächst die Mediathek bei
|
||||
/// jedem Lauf. Dafür sorgt der eindeutige Index auf Bibliothek und Pfad und
|
||||
/// das Nachschlagen statt Anlegen.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>Weggeräumt wird über den Zeitstempel.</b> Jede vorgefundene Datei
|
||||
/// bekommt die Startzeit des Laufs eingetragen; was danach eine ältere Zeit
|
||||
/// trägt, lag nicht mehr da. Das ist billiger, als sich die gesehenen Pfade zu
|
||||
/// merken — jene Liste wüchse mit dem Bestand.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public sealed class LibraryScanner(HaloContext db, TimeProvider clock, ILogger<LibraryScanner> log)
|
||||
{
|
||||
public async Task<ScanReport> ScanAsync(Guid libraryId, CancellationToken ct = default)
|
||||
{
|
||||
var bibliothek = await db.Libraries.FindAsync([libraryId], ct)
|
||||
?? throw new InvalidOperationException($"Keine Bibliothek mit der Kennung {libraryId}.");
|
||||
|
||||
var laufZeit = clock.GetUtcNow();
|
||||
var ergebnis = LibraryWalker.Walk(bibliothek.Path);
|
||||
|
||||
foreach (var problem in ergebnis.Problems)
|
||||
log.LogWarning("Scan: {Pfad} übersprungen — {Grund}", problem.Path, problem.Reason);
|
||||
|
||||
// In den Speicher geholt, weil beim Abgleich jede Datei dagegen
|
||||
// nachschlägt. Einzeln zu fragen hiesse: eine Abfrage je Datei, und
|
||||
// SQLite führt die nacheinander aus.
|
||||
var bekannteDateien = await db.MediaFiles
|
||||
.Where(f => f.LibraryId == libraryId)
|
||||
.ToDictionaryAsync(f => f.Path, ct);
|
||||
|
||||
var filme = bibliothek.Kind == LibraryKind.Movies
|
||||
? await db.Movies.Where(m => m.LibraryId == libraryId).ToListAsync(ct)
|
||||
: [];
|
||||
var serien = bibliothek.Kind == LibraryKind.Shows
|
||||
? await db.Series.Where(s => s.LibraryId == libraryId).ToListAsync(ct)
|
||||
: [];
|
||||
var folgen = bibliothek.Kind == LibraryKind.Shows
|
||||
? await db.Episodes.Where(f => serien.Select(s => s.Id).Contains(f.SeriesId)).ToListAsync(ct)
|
||||
: [];
|
||||
|
||||
int neu = 0, geändert = 0, unerkannt = 0;
|
||||
|
||||
foreach (var datei in ergebnis.Files)
|
||||
{
|
||||
ct.ThrowIfCancellationRequested();
|
||||
|
||||
Guid? filmId = null, folgeId = null;
|
||||
|
||||
if (bibliothek.Kind == LibraryKind.Movies)
|
||||
{
|
||||
var name = FileNames.ParseMovie(datei.Path);
|
||||
filmId = FilmFinden(filme, libraryId, name).Id;
|
||||
}
|
||||
else
|
||||
{
|
||||
var name = FileNames.ParseEpisode(datei.Path);
|
||||
if (name is null)
|
||||
{
|
||||
// **Nicht raten.** Eine erfundene Staffel 1 landete unter
|
||||
// einer Serie, zu der die Datei nicht gehört, und dort
|
||||
// fände sie niemand je wieder.
|
||||
unerkannt++;
|
||||
log.LogInformation("Scan: {Pfad} trägt keine Folgennummer und bleibt liegen.", datei.Path);
|
||||
continue;
|
||||
}
|
||||
var serie = SerieFinden(serien, libraryId, name.SeriesTitle);
|
||||
folgeId = FolgeFinden(folgen, serie.Id, name).Id;
|
||||
}
|
||||
|
||||
if (bekannteDateien.TryGetValue(datei.Path, out var bekannt))
|
||||
{
|
||||
var vorher = (bekannt.SizeBytes, bekannt.ModifiedAt, bekannt.MovieId, bekannt.EpisodeId);
|
||||
bekannt.SizeBytes = datei.SizeBytes;
|
||||
bekannt.ModifiedAt = datei.ModifiedAt;
|
||||
bekannt.MovieId = filmId;
|
||||
bekannt.EpisodeId = folgeId;
|
||||
bekannt.SeenAt = laufZeit;
|
||||
if (vorher != (datei.SizeBytes, datei.ModifiedAt, filmId, folgeId)) geändert++;
|
||||
}
|
||||
else
|
||||
{
|
||||
db.MediaFiles.Add(new MediaFile
|
||||
{
|
||||
LibraryId = libraryId,
|
||||
Path = datei.Path,
|
||||
SizeBytes = datei.SizeBytes,
|
||||
ModifiedAt = datei.ModifiedAt,
|
||||
SeenAt = laufZeit,
|
||||
MovieId = filmId,
|
||||
EpisodeId = folgeId,
|
||||
});
|
||||
neu++;
|
||||
}
|
||||
}
|
||||
|
||||
await db.SaveChangesAsync(ct);
|
||||
|
||||
// Was dieser Lauf nicht gesehen hat, liegt nicht mehr da.
|
||||
var entfernt = await db.MediaFiles
|
||||
.Where(f => f.LibraryId == libraryId && f.SeenAt < laufZeit)
|
||||
.ExecuteDeleteAsync(ct);
|
||||
|
||||
await VerwaisteAufraeumen(libraryId, ct);
|
||||
|
||||
log.LogInformation(
|
||||
"Scan von „{Name}“ fertig: {Gefunden} Dateien, {Neu} neu, {Geändert} geändert, {Entfernt} entfernt, {Unerkannt} unerkannt.",
|
||||
bibliothek.Name, ergebnis.Files.Count, neu, geändert, entfernt, unerkannt);
|
||||
|
||||
return new ScanReport(ergebnis.Files.Count, neu, geändert, entfernt, unerkannt, ergebnis.Problems);
|
||||
}
|
||||
|
||||
/// <summary>Löscht Titel, zu denen keine Datei mehr gehört.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// In dieser Reihenfolge, und das ist keine Geschmacksfrage: erst Folgen
|
||||
/// ohne Datei, dann Serien ohne Folgen. Andersherum bliebe eine Serie
|
||||
/// stehen, deren letzte Folge im selben Lauf verschwindet.
|
||||
/// </remarks>
|
||||
private async Task VerwaisteAufraeumen(Guid libraryId, CancellationToken ct)
|
||||
{
|
||||
await db.Movies
|
||||
.Where(m => m.LibraryId == libraryId && !db.MediaFiles.Any(f => f.MovieId == m.Id))
|
||||
.ExecuteDeleteAsync(ct);
|
||||
|
||||
await db.Episodes
|
||||
.Where(f => db.Series.Any(s => s.Id == f.SeriesId && s.LibraryId == libraryId)
|
||||
&& !db.MediaFiles.Any(d => d.EpisodeId == f.Id))
|
||||
.ExecuteDeleteAsync(ct);
|
||||
|
||||
await db.Series
|
||||
.Where(s => s.LibraryId == libraryId && !db.Episodes.Any(f => f.SeriesId == s.Id))
|
||||
.ExecuteDeleteAsync(ct);
|
||||
}
|
||||
|
||||
/// <summary>Sucht den Film — oder legt ihn an.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// Titel **und** Jahr entscheiden. Nur über den Titel zu gehen würfe die
|
||||
/// beiden „Dune" von 1984 und 2021 zusammen; nur über die Datei zu gehen
|
||||
/// machte aus 4K- und 1080p-Fassung zwei Filme.
|
||||
/// </remarks>
|
||||
private Movie FilmFinden(List<Movie> bekannt, Guid libraryId, MovieName name)
|
||||
{
|
||||
var treffer = bekannt.FirstOrDefault(m =>
|
||||
string.Equals(m.Title, name.Title, StringComparison.OrdinalIgnoreCase) && m.Year == name.Year);
|
||||
if (treffer is not null) return treffer;
|
||||
|
||||
var neu = new Movie
|
||||
{
|
||||
LibraryId = libraryId,
|
||||
Title = name.Title,
|
||||
SortTitleValue = SortTitle.For(name.Title),
|
||||
Year = name.Year,
|
||||
};
|
||||
db.Movies.Add(neu);
|
||||
bekannt.Add(neu);
|
||||
return neu;
|
||||
}
|
||||
|
||||
private Series SerieFinden(List<Series> bekannt, Guid libraryId, string titel)
|
||||
{
|
||||
var treffer = bekannt.FirstOrDefault(s => string.Equals(s.Title, titel, StringComparison.OrdinalIgnoreCase));
|
||||
if (treffer is not null) return treffer;
|
||||
|
||||
var neu = new Series
|
||||
{
|
||||
LibraryId = libraryId,
|
||||
Title = titel,
|
||||
SortTitleValue = SortTitle.For(titel),
|
||||
};
|
||||
db.Series.Add(neu);
|
||||
bekannt.Add(neu);
|
||||
return neu;
|
||||
}
|
||||
|
||||
private Episode FolgeFinden(List<Episode> bekannt, Guid serieId, EpisodeName name)
|
||||
{
|
||||
var treffer = bekannt.FirstOrDefault(f =>
|
||||
f.SeriesId == serieId && f.SeasonNumber == name.Season && f.EpisodeNumber == name.Episode);
|
||||
if (treffer is not null)
|
||||
{
|
||||
// Ein Folgentitel, der erst später auftaucht, wird nachgetragen —
|
||||
// aber ein vorhandener nie überschrieben: er kann von TMDB kommen
|
||||
// und ist dann besser als alles im Dateinamen.
|
||||
treffer.Title ??= name.EpisodeTitle;
|
||||
return treffer;
|
||||
}
|
||||
|
||||
var neu = new Episode
|
||||
{
|
||||
SeriesId = serieId,
|
||||
SeasonNumber = name.Season,
|
||||
EpisodeNumber = name.Episode,
|
||||
Title = name.EpisodeTitle,
|
||||
};
|
||||
db.Episodes.Add(neu);
|
||||
bekannt.Add(neu);
|
||||
return neu;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,387 @@
|
||||
// <auto-generated />
|
||||
using System;
|
||||
using Halo.Data;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Microsoft.EntityFrameworkCore.Infrastructure;
|
||||
using Microsoft.EntityFrameworkCore.Migrations;
|
||||
using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
|
||||
|
||||
#nullable disable
|
||||
|
||||
namespace Halo.Data.Migrations
|
||||
{
|
||||
[DbContext(typeof(HaloContext))]
|
||||
[Migration("20261003115256_Mediathek")]
|
||||
partial class Mediathek
|
||||
{
|
||||
/// <inheritdoc />
|
||||
protected override void BuildTargetModel(ModelBuilder modelBuilder)
|
||||
{
|
||||
#pragma warning disable 612, 618
|
||||
modelBuilder.HasAnnotation("ProductVersion", "10.0.12");
|
||||
|
||||
modelBuilder.Entity("Halo.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("Halo.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("Halo.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("Halo.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>("Title")
|
||||
.HasMaxLength(512)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.HasKey("Id");
|
||||
|
||||
b.HasIndex("SeriesId", "SeasonNumber", "EpisodeNumber")
|
||||
.IsUnique();
|
||||
|
||||
b.ToTable("Episodes");
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Halo.Core.Library.MediaFile", b =>
|
||||
{
|
||||
b.Property<Guid>("Id")
|
||||
.ValueGeneratedOnAdd()
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
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>("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("Halo.Core.Library.Movie", b =>
|
||||
{
|
||||
b.Property<Guid>("Id")
|
||||
.ValueGeneratedOnAdd()
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<long>("AddedAt")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<Guid>("LibraryId")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<string>("Overview")
|
||||
.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("Halo.Core.Library.Series", b =>
|
||||
{
|
||||
b.Property<Guid>("Id")
|
||||
.ValueGeneratedOnAdd()
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<long>("AddedAt")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<Guid>("LibraryId")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<string>("Overview")
|
||||
.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("Halo.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("Halo.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("Halo.Core.Auth.DeviceToken", b =>
|
||||
{
|
||||
b.HasOne("Halo.Core.Users.User", null)
|
||||
.WithMany()
|
||||
.HasForeignKey("UserId")
|
||||
.OnDelete(DeleteBehavior.Cascade)
|
||||
.IsRequired();
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Halo.Core.Library.Episode", b =>
|
||||
{
|
||||
b.HasOne("Halo.Core.Library.Series", null)
|
||||
.WithMany()
|
||||
.HasForeignKey("SeriesId")
|
||||
.OnDelete(DeleteBehavior.Cascade)
|
||||
.IsRequired();
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Halo.Core.Library.MediaFile", b =>
|
||||
{
|
||||
b.HasOne("Halo.Core.Libraries.Library", null)
|
||||
.WithMany()
|
||||
.HasForeignKey("LibraryId")
|
||||
.OnDelete(DeleteBehavior.Cascade)
|
||||
.IsRequired();
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Halo.Core.Library.Movie", b =>
|
||||
{
|
||||
b.HasOne("Halo.Core.Libraries.Library", null)
|
||||
.WithMany()
|
||||
.HasForeignKey("LibraryId")
|
||||
.OnDelete(DeleteBehavior.Cascade)
|
||||
.IsRequired();
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Halo.Core.Library.Series", b =>
|
||||
{
|
||||
b.HasOne("Halo.Core.Libraries.Library", null)
|
||||
.WithMany()
|
||||
.HasForeignKey("LibraryId")
|
||||
.OnDelete(DeleteBehavior.Cascade)
|
||||
.IsRequired();
|
||||
});
|
||||
#pragma warning restore 612, 618
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,158 @@
|
||||
using System;
|
||||
using Microsoft.EntityFrameworkCore.Migrations;
|
||||
|
||||
#nullable disable
|
||||
|
||||
namespace Halo.Data.Migrations
|
||||
{
|
||||
/// <inheritdoc />
|
||||
public partial class Mediathek : Migration
|
||||
{
|
||||
/// <inheritdoc />
|
||||
protected override void Up(MigrationBuilder migrationBuilder)
|
||||
{
|
||||
migrationBuilder.CreateTable(
|
||||
name: "MediaFiles",
|
||||
columns: table => new
|
||||
{
|
||||
Id = table.Column<Guid>(type: "TEXT", nullable: false),
|
||||
LibraryId = table.Column<Guid>(type: "TEXT", nullable: false),
|
||||
Path = table.Column<string>(type: "TEXT", maxLength: 1024, nullable: false),
|
||||
SizeBytes = table.Column<long>(type: "INTEGER", nullable: false),
|
||||
ModifiedAt = table.Column<long>(type: "INTEGER", nullable: false),
|
||||
SeenAt = table.Column<long>(type: "INTEGER", nullable: false),
|
||||
MovieId = table.Column<Guid>(type: "TEXT", nullable: true),
|
||||
EpisodeId = table.Column<Guid>(type: "TEXT", nullable: true)
|
||||
},
|
||||
constraints: table =>
|
||||
{
|
||||
table.PrimaryKey("PK_MediaFiles", x => x.Id);
|
||||
table.ForeignKey(
|
||||
name: "FK_MediaFiles_Libraries_LibraryId",
|
||||
column: x => x.LibraryId,
|
||||
principalTable: "Libraries",
|
||||
principalColumn: "Id",
|
||||
onDelete: ReferentialAction.Cascade);
|
||||
});
|
||||
|
||||
migrationBuilder.CreateTable(
|
||||
name: "Movies",
|
||||
columns: table => new
|
||||
{
|
||||
Id = table.Column<Guid>(type: "TEXT", nullable: false),
|
||||
LibraryId = table.Column<Guid>(type: "TEXT", nullable: false),
|
||||
Title = table.Column<string>(type: "TEXT", maxLength: 512, nullable: false),
|
||||
SortTitleValue = table.Column<string>(type: "TEXT", maxLength: 512, nullable: false),
|
||||
Year = table.Column<int>(type: "INTEGER", nullable: true),
|
||||
Overview = table.Column<string>(type: "TEXT", nullable: true),
|
||||
TmdbId = table.Column<int>(type: "INTEGER", nullable: true),
|
||||
AddedAt = table.Column<long>(type: "INTEGER", nullable: false)
|
||||
},
|
||||
constraints: table =>
|
||||
{
|
||||
table.PrimaryKey("PK_Movies", x => x.Id);
|
||||
table.ForeignKey(
|
||||
name: "FK_Movies_Libraries_LibraryId",
|
||||
column: x => x.LibraryId,
|
||||
principalTable: "Libraries",
|
||||
principalColumn: "Id",
|
||||
onDelete: ReferentialAction.Cascade);
|
||||
});
|
||||
|
||||
migrationBuilder.CreateTable(
|
||||
name: "Series",
|
||||
columns: table => new
|
||||
{
|
||||
Id = table.Column<Guid>(type: "TEXT", nullable: false),
|
||||
LibraryId = table.Column<Guid>(type: "TEXT", nullable: false),
|
||||
Title = table.Column<string>(type: "TEXT", maxLength: 512, nullable: false),
|
||||
SortTitleValue = table.Column<string>(type: "TEXT", maxLength: 512, nullable: false),
|
||||
Year = table.Column<int>(type: "INTEGER", nullable: true),
|
||||
Overview = table.Column<string>(type: "TEXT", nullable: true),
|
||||
TmdbId = table.Column<int>(type: "INTEGER", nullable: true),
|
||||
AddedAt = table.Column<long>(type: "INTEGER", nullable: false)
|
||||
},
|
||||
constraints: table =>
|
||||
{
|
||||
table.PrimaryKey("PK_Series", x => x.Id);
|
||||
table.ForeignKey(
|
||||
name: "FK_Series_Libraries_LibraryId",
|
||||
column: x => x.LibraryId,
|
||||
principalTable: "Libraries",
|
||||
principalColumn: "Id",
|
||||
onDelete: ReferentialAction.Cascade);
|
||||
});
|
||||
|
||||
migrationBuilder.CreateTable(
|
||||
name: "Episodes",
|
||||
columns: table => new
|
||||
{
|
||||
Id = table.Column<Guid>(type: "TEXT", nullable: false),
|
||||
SeriesId = table.Column<Guid>(type: "TEXT", nullable: false),
|
||||
SeasonNumber = table.Column<int>(type: "INTEGER", nullable: false),
|
||||
EpisodeNumber = table.Column<int>(type: "INTEGER", nullable: false),
|
||||
Title = table.Column<string>(type: "TEXT", maxLength: 512, nullable: true),
|
||||
Overview = table.Column<string>(type: "TEXT", nullable: true),
|
||||
AddedAt = table.Column<long>(type: "INTEGER", nullable: false)
|
||||
},
|
||||
constraints: table =>
|
||||
{
|
||||
table.PrimaryKey("PK_Episodes", x => x.Id);
|
||||
table.ForeignKey(
|
||||
name: "FK_Episodes_Series_SeriesId",
|
||||
column: x => x.SeriesId,
|
||||
principalTable: "Series",
|
||||
principalColumn: "Id",
|
||||
onDelete: ReferentialAction.Cascade);
|
||||
});
|
||||
|
||||
migrationBuilder.CreateIndex(
|
||||
name: "IX_Episodes_SeriesId_SeasonNumber_EpisodeNumber",
|
||||
table: "Episodes",
|
||||
columns: new[] { "SeriesId", "SeasonNumber", "EpisodeNumber" },
|
||||
unique: true);
|
||||
|
||||
migrationBuilder.CreateIndex(
|
||||
name: "IX_MediaFiles_EpisodeId",
|
||||
table: "MediaFiles",
|
||||
column: "EpisodeId");
|
||||
|
||||
migrationBuilder.CreateIndex(
|
||||
name: "IX_MediaFiles_LibraryId_Path",
|
||||
table: "MediaFiles",
|
||||
columns: new[] { "LibraryId", "Path" },
|
||||
unique: true);
|
||||
|
||||
migrationBuilder.CreateIndex(
|
||||
name: "IX_MediaFiles_MovieId",
|
||||
table: "MediaFiles",
|
||||
column: "MovieId");
|
||||
|
||||
migrationBuilder.CreateIndex(
|
||||
name: "IX_Movies_LibraryId_SortTitleValue",
|
||||
table: "Movies",
|
||||
columns: new[] { "LibraryId", "SortTitleValue" });
|
||||
|
||||
migrationBuilder.CreateIndex(
|
||||
name: "IX_Series_LibraryId_SortTitleValue",
|
||||
table: "Series",
|
||||
columns: new[] { "LibraryId", "SortTitleValue" });
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
protected override void Down(MigrationBuilder migrationBuilder)
|
||||
{
|
||||
migrationBuilder.DropTable(
|
||||
name: "Episodes");
|
||||
|
||||
migrationBuilder.DropTable(
|
||||
name: "MediaFiles");
|
||||
|
||||
migrationBuilder.DropTable(
|
||||
name: "Movies");
|
||||
|
||||
migrationBuilder.DropTable(
|
||||
name: "Series");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -137,6 +137,156 @@ namespace Halo.Data.Migrations
|
||||
b.ToTable("Libraries");
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Halo.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>("Title")
|
||||
.HasMaxLength(512)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.HasKey("Id");
|
||||
|
||||
b.HasIndex("SeriesId", "SeasonNumber", "EpisodeNumber")
|
||||
.IsUnique();
|
||||
|
||||
b.ToTable("Episodes");
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Halo.Core.Library.MediaFile", b =>
|
||||
{
|
||||
b.Property<Guid>("Id")
|
||||
.ValueGeneratedOnAdd()
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
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>("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("Halo.Core.Library.Movie", b =>
|
||||
{
|
||||
b.Property<Guid>("Id")
|
||||
.ValueGeneratedOnAdd()
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<long>("AddedAt")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<Guid>("LibraryId")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<string>("Overview")
|
||||
.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("Halo.Core.Library.Series", b =>
|
||||
{
|
||||
b.Property<Guid>("Id")
|
||||
.ValueGeneratedOnAdd()
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<long>("AddedAt")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<Guid>("LibraryId")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<string>("Overview")
|
||||
.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("Halo.Core.ServerSetting", b =>
|
||||
{
|
||||
b.Property<string>("Key")
|
||||
@@ -192,6 +342,42 @@ namespace Halo.Data.Migrations
|
||||
.OnDelete(DeleteBehavior.Cascade)
|
||||
.IsRequired();
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Halo.Core.Library.Episode", b =>
|
||||
{
|
||||
b.HasOne("Halo.Core.Library.Series", null)
|
||||
.WithMany()
|
||||
.HasForeignKey("SeriesId")
|
||||
.OnDelete(DeleteBehavior.Cascade)
|
||||
.IsRequired();
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Halo.Core.Library.MediaFile", b =>
|
||||
{
|
||||
b.HasOne("Halo.Core.Libraries.Library", null)
|
||||
.WithMany()
|
||||
.HasForeignKey("LibraryId")
|
||||
.OnDelete(DeleteBehavior.Cascade)
|
||||
.IsRequired();
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Halo.Core.Library.Movie", b =>
|
||||
{
|
||||
b.HasOne("Halo.Core.Libraries.Library", null)
|
||||
.WithMany()
|
||||
.HasForeignKey("LibraryId")
|
||||
.OnDelete(DeleteBehavior.Cascade)
|
||||
.IsRequired();
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Halo.Core.Library.Series", b =>
|
||||
{
|
||||
b.HasOne("Halo.Core.Libraries.Library", null)
|
||||
.WithMany()
|
||||
.HasForeignKey("LibraryId")
|
||||
.OnDelete(DeleteBehavior.Cascade)
|
||||
.IsRequired();
|
||||
});
|
||||
#pragma warning restore 612, 618
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user