Zwei Teile, ein Treffer — und einer verschwand
Du hast drei Filme vermisst, und die Zahlen sagten schon, wo sie sind: 448 Filme plus 13 zweite Fassungen sind genau die 461 Dateien. Es fehlte keine Datei; drei Filme steckten als Fassung in einem anderen. Gemessen, warum. Der Dateinamenleser ist unschuldig — „Teil 2" bleibt im Titel. TMDB aber liefert für „Heiligtümer des Todes Teil 1" wie für „Teil 2" denselben Treffer zuerst, sobald ohne Jahr gesucht werden muss. Und weil zwei Einträge dieselbe Kennung nicht teilen dürfen, wurde der zweite geschluckt. Zwei Dateien, deren Namen verschiedene Jahre nennen, sind jetzt verschiedene Filme. Der erste Anlauf hatte ein Jahr Abstand als Toleranz erlaubt — für Dezember-Erstaufführungen — und verschluckte damit genau den Fall, um den es geht: Teil 1 ist von 2010, Teil 2 von 2011. Dazu sieht man endlich, was nicht zugeordnet werden konnte. „Nicht zugeordnet" listete bisher nur Dateien ganz ohne Titel, und die gibt es bei Filmen nie — deshalb standen dort nur Serien. Daneben eine Liste der Titel mit mehreren Dateien: zwei Fassungen sind die Regel, zwei verschiedene Filme der Fehler, und an den Dateinamen sieht man es sofort. Der Bearbeiten-Dialog hat jetzt Reiter statt Knöpfe, die weitere Fenster öffnen — ein Fenster über einem Fenster, und man wusste nicht mehr, was man zumacht. „Titel ändern" und „Bilder bearbeiten" sind aus dem Kontextmenü raus; über „Bearbeiten" kommt man an beides. Beim Prüfen gefunden: ein Dialog blieb nach einem Seitenwechsel über der neuen Seite stehen. Er hängt an body, nicht am Inhaltsbereich. 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
fcf40e4394
commit
c3124ba27c
@@ -23,6 +23,28 @@ public sealed record Speicherort(
|
||||
/// <summary>Dateien, die zu keinem Titel gehören — mit Begründung.</summary>
|
||||
public sealed record Unzugeordnet(int Gesamt, IReadOnlyList<UnzugeordneteDatei> Dateien);
|
||||
|
||||
/// <summary>Ein Titel, zu dem die Metadatenquelle nichts hergab.</summary>
|
||||
///
|
||||
/// <param name="Art">„movie" oder „series" — damit der Client weiss, wohin.</param>
|
||||
/// <param name="Dateien">Wie viele Dateien daran hängen.</param>
|
||||
/// <param name="Beispiel">Ein Dateiname, damit man den Titel wiedererkennt.</param>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Weil die Zahl allein nichts erklärt.</b> In der Übersicht standen 448
|
||||
/// Filme, in Plex 451 — und nirgends stand, welche drei fehlen oder warum.
|
||||
/// Eine Mediathek, die etwas nicht zuordnen konnte, muss sagen was.
|
||||
/// </remarks>
|
||||
public sealed record OhneZuordnung(
|
||||
Guid Id, string Art, string Titel, int? Jahr, int Dateien, string? Beispiel);
|
||||
|
||||
/// <param name="Titel">Titel mit mehr als einer Datei — dort versteckt sich Falsches.</param>
|
||||
public sealed record Mehrfachbericht(
|
||||
int Gesamt, IReadOnlyList<Mehrfachtitel> Titel);
|
||||
|
||||
/// <param name="Dateien">Die Namen der Dateien, die an diesem einen Titel hängen.</param>
|
||||
public sealed record Mehrfachtitel(
|
||||
Guid Id, string Art, string Titel, int? Jahr, IReadOnlyList<string> Dateien);
|
||||
|
||||
public sealed record UnzugeordneteDatei(Guid Id, string Pfad, string Grund);
|
||||
|
||||
/// <summary>Wie viele Titel in welcher Sprache vorliegen.</summary>
|
||||
|
||||
@@ -227,6 +227,92 @@ public static class ManagementEndpoints
|
||||
f.Id, f.Path, FileNames.WarumNicht(f.Path, bibliothek.Path))).ToList()));
|
||||
}).RequireAuthorization(FlaroPolicies.Administrator);
|
||||
|
||||
// **Was die Metadatenquelle nicht hergab.**
|
||||
//
|
||||
// `/unassigned` listet Dateien ganz ohne Titel — bei einer
|
||||
// Filmbibliothek ist das immer leer, weil der Scan für jede Datei
|
||||
// einen Eintrag anlegt. Sichtbar war damit nur die Hälfte: dass ein
|
||||
// Film zwar dasteht, aber unter seinem Dateinamen und ohne Plakat,
|
||||
// erfuhr niemand. In der Übersicht standen 448 Filme, in Plex 451 —
|
||||
// und nirgends, welche drei fehlen.
|
||||
bibliotheken.MapGet("/{id:guid}/unmatched", async (
|
||||
Guid id, FlaroContext db, int take = 300) =>
|
||||
{
|
||||
if (!await db.Libraries.AsNoTracking().AnyAsync(l => l.Id == id)) return Results.NotFound();
|
||||
|
||||
var grenze = Math.Clamp(take, 1, 2000);
|
||||
|
||||
var filme = await db.Movies.AsNoTracking()
|
||||
.Where(m => m.LibraryId == id && m.TmdbId == null)
|
||||
.OrderBy(m => m.SortTitleValue)
|
||||
.Take(grenze)
|
||||
.Select(m => new
|
||||
{
|
||||
m.Id, m.Title, Jahr = m.ParsedYear ?? m.Year,
|
||||
Dateien = db.MediaFiles.Count(f => f.MovieId == m.Id),
|
||||
Beispiel = db.MediaFiles.Where(f => f.MovieId == m.Id)
|
||||
.Select(f => f.Path).FirstOrDefault(),
|
||||
})
|
||||
.ToListAsync();
|
||||
|
||||
var serien = await db.Series.AsNoTracking()
|
||||
.Where(x => x.LibraryId == id && x.TmdbId == null)
|
||||
.OrderBy(x => x.SortTitleValue)
|
||||
.Take(grenze)
|
||||
.Select(x => new
|
||||
{
|
||||
x.Id, x.Title, Jahr = x.ParsedYear ?? x.Year,
|
||||
Dateien = db.Episodes.Count(f => f.SeriesId == x.Id),
|
||||
Beispiel = db.Episodes.Where(f => f.SeriesId == x.Id)
|
||||
.Join(db.MediaFiles, f => f.Id, d => d.EpisodeId, (_, d) => d.Path)
|
||||
.FirstOrDefault(),
|
||||
})
|
||||
.ToListAsync();
|
||||
|
||||
var liste = filme
|
||||
.Select(m => new OhneZuordnung(
|
||||
m.Id, "movie", m.Title, m.Jahr, m.Dateien, Dateiname(m.Beispiel)))
|
||||
.Concat(serien.Select(x => new OhneZuordnung(
|
||||
x.Id, "series", x.Title, x.Jahr, x.Dateien, Dateiname(x.Beispiel))))
|
||||
.OrderBy(x => x.Titel, StringComparer.CurrentCultureIgnoreCase)
|
||||
.ToList();
|
||||
|
||||
return Results.Ok(liste);
|
||||
}).RequireAuthorization(FlaroPolicies.Administrator);
|
||||
|
||||
// **Titel mit mehr als einer Datei — dort versteckt sich Falsches.**
|
||||
//
|
||||
// Zwei Dateien an einem Film sind meist zwei Fassungen und völlig in
|
||||
// Ordnung. Manchmal sind es aber zwei verschiedene Filme, die bei der
|
||||
// Metadatenquelle auf denselben Treffer liefen — und dann ist einer
|
||||
// davon lautlos verschwunden. Wer die Liste durchsieht, erkennt das
|
||||
// an den Dateinamen in zwei Sekunden.
|
||||
bibliotheken.MapGet("/{id:guid}/versions", async (
|
||||
Guid id, FlaroContext db, int take = 300) =>
|
||||
{
|
||||
if (!await db.Libraries.AsNoTracking().AnyAsync(l => l.Id == id)) return Results.NotFound();
|
||||
|
||||
var mehrfach = await db.Movies.AsNoTracking()
|
||||
.Where(m => m.LibraryId == id && db.MediaFiles.Count(f => f.MovieId == m.Id) > 1)
|
||||
.OrderBy(m => m.SortTitleValue)
|
||||
.Take(Math.Clamp(take, 1, 2000))
|
||||
.Select(m => new
|
||||
{
|
||||
m.Id, m.Title, Jahr = m.ParsedYear ?? m.Year,
|
||||
Pfade = db.MediaFiles.Where(f => f.MovieId == m.Id)
|
||||
.Select(f => f.Path).ToList(),
|
||||
})
|
||||
.ToListAsync();
|
||||
|
||||
var liste = mehrfach
|
||||
.Select(m => new Mehrfachtitel(
|
||||
m.Id, "movie", m.Title, m.Jahr,
|
||||
m.Pfade.Select(p => Dateiname(p) ?? p).ToList()))
|
||||
.ToList();
|
||||
|
||||
return Results.Ok(new Mehrfachbericht(liste.Count, liste));
|
||||
}).RequireAuthorization(FlaroPolicies.Administrator);
|
||||
|
||||
bibliotheken.MapGet("/missing", async (FlaroContext db) =>
|
||||
{
|
||||
var liste = await db.MediaFiles.AsNoTracking()
|
||||
@@ -395,6 +481,10 @@ public static class ManagementEndpoints
|
||||
return Results.NoContent();
|
||||
}).RequireAuthorization(FlaroPolicies.Administrator);
|
||||
}
|
||||
|
||||
/// <summary>Nur der Dateiname — der volle Pfad geht niemanden etwas an.</summary>
|
||||
private static string? Dateiname(string? pfad) =>
|
||||
pfad is null ? null : Path.GetFileName(pfad);
|
||||
}
|
||||
|
||||
public static class FlaroPolicies
|
||||
|
||||
@@ -110,6 +110,12 @@ public sealed class MetadataEnricher(
|
||||
.Where(m => m.LibraryId == libraryId && m.TmdbId != null)
|
||||
.ToDictionaryAsync(m => m.TmdbId!.Value, m => m.Id, ct);
|
||||
|
||||
// Welches Jahr im Dateinamen des schon zugeordneten stand — daran
|
||||
// entscheidet sich, ob ein zweiter Treffer wirklich derselbe Film ist.
|
||||
var jahreNachId = await db.Movies
|
||||
.Where(m => m.LibraryId == libraryId && m.TmdbId != null)
|
||||
.ToDictionaryAsync(m => m.Id, m => m.ParsedYear, ct);
|
||||
|
||||
var zusammenzulegen = new List<(Guid Sieger, Guid Verlierer)>();
|
||||
|
||||
foreach (var film in offen)
|
||||
@@ -155,11 +161,41 @@ public sealed class MetadataEnricher(
|
||||
// aus wie „die Spracheinstellung wirkt nicht".
|
||||
if (vergeben.TryGetValue(gefunden.ProviderId, out var schonDa) && schonDa != film.Id)
|
||||
{
|
||||
// **Verschiedene Jahre heissen: verschiedene Filme.**
|
||||
//
|
||||
// „…Heiligtümer des Todes Teil 1 (2010)" und „Teil 2 (2011)"
|
||||
// landen bei TMDB auf demselben Treffer, wenn ohne Jahr
|
||||
// gesucht werden musste — die Suche liefert für beide Titel
|
||||
// Teil 2 zuerst. Zusammengelegt verschwand damit ein ganzer
|
||||
// Film als „zweite Fassung" des anderen, und niemand erfuhr
|
||||
// davon. Gemessen am echten Bestand: 448 Filme und 13 zweite
|
||||
// Fassungen bei 461 Dateien.
|
||||
//
|
||||
// Das Jahr aus dem Dateinamen ändert sich nie und ist deshalb
|
||||
// der verlässlichste Unterschied, den es hier gibt. Kennt nur
|
||||
// einer von beiden eines, sagt das nichts — dann bleibt es
|
||||
// beim Zusammenlegen, denn „Despicable Me" und „Ich einfach
|
||||
// unverbesserlich" sind wirklich derselbe Film.
|
||||
if (JahreWidersprechen(film.ParsedYear, jahreNachId.GetValueOrDefault(schonDa)))
|
||||
{
|
||||
fortschritt?.Report(new Scanschritt(Scanphase.Vermerk,
|
||||
$"„{film.ParsedTitle ?? film.Title}“ ({film.ParsedYear}) und ein anderer Titel "
|
||||
+ $"führen beide auf {gefunden.ProviderId} — verschiedene Jahre, also nicht "
|
||||
+ "zusammengelegt. Dieser bleibt ohne Zuordnung."));
|
||||
durch++;
|
||||
continue;
|
||||
}
|
||||
|
||||
zusammenzulegen.Add((Sieger: schonDa, Verlierer: film.Id));
|
||||
continue;
|
||||
}
|
||||
|
||||
vergeben[gefunden.ProviderId] = film.Id;
|
||||
// **Auch das Jahr, und zwar sofort.** Die beiden Tabellen müssen
|
||||
// im Gleichschritt wachsen: wird nur `vergeben` fortgeschrieben,
|
||||
// findet der zweite Film zwar den ersten, kennt aber dessen Jahr
|
||||
// nicht — und legt wieder zusammen, was nicht zusammengehört.
|
||||
jahreNachId[film.Id] = film.ParsedYear;
|
||||
film.TmdbId = gefunden.ProviderId;
|
||||
film.ImdbId = gefunden.ImdbId;
|
||||
// **Ein Titel von Hand bleibt stehen.** Wie bei den Bildern: ohne
|
||||
@@ -237,6 +273,30 @@ public sealed class MetadataEnricher(
|
||||
return (new ProviderIds(ausNfo.Tmdb ?? ausPfad.Tmdb, ausNfo.Imdb ?? ausPfad.Imdb), Nfo.ReadLocked(nfo));
|
||||
}
|
||||
|
||||
/// <summary>Ob zwei Jahre einander widersprechen.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>Nur wenn beide bekannt sind.</b> Eine Lücke ist keine Aussage: wer
|
||||
/// seine Dateien ohne Jahr benennt, bekäme sonst nie eine Dublette
|
||||
/// erkannt — und „Despicable Me" und „Ich einfach unverbesserlich"
|
||||
/// gehören wirklich zusammen.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>Dafür schon ab einem Jahr Abstand, und das ist gemessen.</b> Erst
|
||||
/// stand hier eine Toleranz von einem Jahr — für den Fall, dass eine
|
||||
/// Erstaufführung im Dezember hier im Januar läuft. Genau die Toleranz
|
||||
/// verschluckte den Fall, um den es geht: „Heiligtümer des Todes Teil 1"
|
||||
/// ist von 2010, „Teil 2" von 2011. Zwei Dateien, deren Namen
|
||||
/// verschiedene Jahre nennen, sind verschiedene Filme — und wenn doch
|
||||
/// nicht, steht der zweite in der Liste der nicht zugeordneten Titel und
|
||||
/// lässt sich in zwei Klicks geradeziehen. Das ist allemal besser, als
|
||||
/// ihn lautlos verschwinden zu lassen.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
private static bool JahreWidersprechen(int? eines, int? anderes) =>
|
||||
eines is { } a && anderes is { } b && a != b;
|
||||
|
||||
private async Task<int> SerienZuordnen(
|
||||
Guid libraryId, bool erneut, IProgress<Scanschritt>? fortschritt, CancellationToken ct,
|
||||
string? nurSprache = null, IReadOnlySet<Guid>? nurDiese = null)
|
||||
|
||||
@@ -377,6 +377,141 @@ public class MetadataTests
|
||||
return null!;
|
||||
}
|
||||
|
||||
/* ---------- Zwei Teile, ein Treffer ---------- */
|
||||
|
||||
/// <summary>Zwei Filme verschiedener Jahre werden nicht zusammengelegt.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>Aus dem echten Bestand, und es kostete drei Filme.</b> „Harry Potter
|
||||
/// und die Heiligtümer des Todes Teil 1" und „Teil 2" landen bei TMDB auf
|
||||
/// demselben Treffer, sobald ohne Jahr gesucht werden muss — gemessen:
|
||||
/// die Suche liefert für <i>beide</i> Titel Teil 2 zuerst. Weil zwei
|
||||
/// Einträge dieselbe Kennung nicht teilen dürfen, wurde der zweite als
|
||||
/// „zweite Fassung" des ersten geschluckt. In der Übersicht standen dann
|
||||
/// 448 Filme und 13 zweite Fassungen, in Plex 451 Filme — und nirgends
|
||||
/// stand, welche drei fehlen.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// Das Jahr aus dem Dateinamen ändert sich nie. Widersprechen sich zwei,
|
||||
/// sind es verschiedene Filme, und dann bleibt der zweite lieber ohne
|
||||
/// Zuordnung — sichtbar in der Liste der nicht zugeordneten Titel — als
|
||||
/// lautlos verschwunden.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
[Test]
|
||||
public async Task Zwei_Teile_mit_verschiedenen_Jahren_bleiben_zwei_Filme()
|
||||
{
|
||||
Datei("Heiligtuemer des Todes Teil 1 (2010)/Heiligtuemer des Todes Teil 1 (2010).mkv");
|
||||
Datei("Heiligtuemer des Todes Teil 2 (2011)/Heiligtuemer des Todes Teil 2 (2011).mkv");
|
||||
|
||||
// Die Quelle liefert für jede Suche denselben Film — genau wie TMDB
|
||||
// es ohne Jahr tut.
|
||||
var anbieter = new VorgegebenerAnbieter
|
||||
{
|
||||
Film = new MovieMetadata(12445, "Heiligtümer des Todes – Teil 2", 2011, null, null, null),
|
||||
};
|
||||
|
||||
using var server = MitAnbieter(anbieter);
|
||||
var (client, bibliothek) = await Einrichten(server, "Movies");
|
||||
await Scannen(client, bibliothek);
|
||||
|
||||
var filme = await client.GetFromJsonAsync<Page<MovieResponse>>("/api/v1/movies");
|
||||
|
||||
Assert.That(filme!.Items, Has.Count.EqualTo(2),
|
||||
"zwei Dateien, zwei Jahre — also zwei Filme, nicht einer mit zwei Fassungen");
|
||||
|
||||
var ohne = await client.GetFromJsonAsync<List<OhneZuordnung>>(
|
||||
$"/api/v1/libraries/{bibliothek}/unmatched");
|
||||
|
||||
Assert.That(ohne, Has.Count.EqualTo(1),
|
||||
"der zweite bleibt ohne Zuordnung — und steht dafür in der Liste");
|
||||
}
|
||||
|
||||
/// <summary>Derselbe Film in zwei Ordnern wird weiterhin zusammengelegt.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Die Gegenprobe, und sie ist wichtiger als sie aussieht.</b> „Despicable
|
||||
/// Me" und „Ich einfach unverbesserlich" sind wirklich derselbe Film —
|
||||
/// gleiches Jahr, zwei Ordner. Diesen Fall mit zu verbieten hiesse, einen
|
||||
/// Fehler durch einen anderen zu ersetzen.
|
||||
/// </remarks>
|
||||
[Test]
|
||||
public async Task Derselbe_Film_in_zwei_Ordnern_wird_weiter_zusammengelegt()
|
||||
{
|
||||
Datei("Despicable Me (2010)/Despicable Me (2010).mkv");
|
||||
Datei("Ich einfach unverbesserlich (2010)/Ich einfach unverbesserlich (2010).mkv");
|
||||
|
||||
var anbieter = new VorgegebenerAnbieter
|
||||
{
|
||||
Film = new MovieMetadata(20352, "Ich einfach unverbesserlich", 2010, null, null, null),
|
||||
};
|
||||
|
||||
using var server = MitAnbieter(anbieter);
|
||||
var (client, bibliothek) = await Einrichten(server, "Movies");
|
||||
await Scannen(client, bibliothek);
|
||||
|
||||
var filme = await client.GetFromJsonAsync<Page<MovieResponse>>("/api/v1/movies");
|
||||
|
||||
Assert.Multiple(() =>
|
||||
{
|
||||
Assert.That(filme!.Items, Has.Count.EqualTo(1), "ein Film");
|
||||
Assert.That(filme.Items[0].Files, Has.Count.EqualTo(2), "mit zwei Dateien");
|
||||
});
|
||||
}
|
||||
|
||||
/// <summary>Ohne Jahr im Namen wird weiter zusammengelegt.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Eine Lücke ist keine Aussage.</b> Wer seine Dateien ohne Jahr
|
||||
/// benennt, bekäme sonst nie eine Dublette erkannt — und zwei Ordner
|
||||
/// desselben Films blieben für immer zwei Einträge.
|
||||
/// </remarks>
|
||||
[Test]
|
||||
public async Task Ohne_Jahr_im_Namen_wird_weiter_zusammengelegt()
|
||||
{
|
||||
Datei("Despicable Me/Despicable Me.mkv");
|
||||
Datei("Ich einfach unverbesserlich/Ich einfach unverbesserlich.mkv");
|
||||
|
||||
var anbieter = new VorgegebenerAnbieter
|
||||
{
|
||||
Film = new MovieMetadata(20352, "Ich einfach unverbesserlich", 2010, null, null, null),
|
||||
};
|
||||
|
||||
using var server = MitAnbieter(anbieter);
|
||||
var (client, bibliothek) = await Einrichten(server, "Movies");
|
||||
await Scannen(client, bibliothek);
|
||||
|
||||
var filme = await client.GetFromJsonAsync<Page<MovieResponse>>("/api/v1/movies");
|
||||
Assert.That(filme!.Items, Has.Count.EqualTo(1));
|
||||
}
|
||||
|
||||
/// <summary>Titel ohne Zuordnung stehen in einer Liste — mit Dateinamen.</summary>
|
||||
[Test]
|
||||
public async Task Nicht_zugeordnete_Filme_stehen_in_der_Liste()
|
||||
{
|
||||
Datei("Ein Mitschnitt ohne Titel/Ein Mitschnitt ohne Titel.mkv");
|
||||
|
||||
// Die Quelle findet nichts.
|
||||
var anbieter = new VorgegebenerAnbieter { Film = null };
|
||||
|
||||
using var server = MitAnbieter(anbieter);
|
||||
var (client, bibliothek) = await Einrichten(server, "Movies");
|
||||
await Scannen(client, bibliothek);
|
||||
|
||||
var ohne = await client.GetFromJsonAsync<List<OhneZuordnung>>(
|
||||
$"/api/v1/libraries/{bibliothek}/unmatched");
|
||||
|
||||
Assert.That(ohne, Has.Count.EqualTo(1));
|
||||
Assert.Multiple(() =>
|
||||
{
|
||||
Assert.That(ohne![0].Art, Is.EqualTo("movie"));
|
||||
Assert.That(ohne[0].Dateien, Is.EqualTo(1));
|
||||
Assert.That(ohne[0].Beispiel, Does.EndWith(".mkv"));
|
||||
Assert.That(ohne[0].Beispiel, Does.Not.Contain("/"), "nur der Dateiname, nicht der Pfad");
|
||||
});
|
||||
}
|
||||
|
||||
/// <summary>Eine falsche Zuordnung darf ihre eigene Korrektur nicht verhindern.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
|
||||
Reference in New Issue
Block a user