3559 von 5884 Dateien verschwanden lautlos

Der Scan erfindet keine Serie mehr, wenn weder Ordner noch Dateiname
eine nennen — richtig so. Nur wurde die Datei dann übersprungen, ohne
Zeile, ohne Spur. In der Mediathek standen 58 Serien und niemand konnte
sagen, wo die anderen geblieben sind.

Jetzt bekommt jede solche Datei eine Zeile ohne Zuordnung. Damit ist sie
zählbar, auflistbar und nach einer besseren Regel nachträglich
zuzuordnen. Untersucht wird sie nicht: ffprobe auf 3559 Dateien kostet
eine halbe Stunde für Angaben, die niemand zu sehen bekommt, und sobald
die Zuordnung steht, holt der nächste Lauf es nach.

Dazu ein Abschnitt "Nicht zugeordnet" in der Verwaltung, nach Grund
gebündelt und mit den Pfaden zum Aufklappen. Zwei Gründe gibt es, und
sie verlangen Verschiedenes: fehlt die Folgennummer, muss umbenannt
werden; fehlt der Serienname, genügt ein Ordner darum herum. Die Liste
lässt sich als Datei herunterladen — eine, die man markieren und
kopieren muss, schickt niemand.

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

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

@@ -20,6 +20,11 @@ public sealed record SystemInfo(
 public sealed record Speicherort(
     string Name, string Variable, string Pfad, long Belegt, long? Frei, long? Bilder);
 
+/// <summary>Dateien, die zu keinem Titel gehören — mit Begründung.</summary>
+public sealed record Unzugeordnet(int Gesamt, IReadOnlyList<UnzugeordneteDatei> Dateien);
+
+public sealed record UnzugeordneteDatei(Guid Id, string Pfad, string Grund);
+
 public sealed record ServerNameRequest(string Name);
 
 public sealed record SetupRequest(string UserName, string Password);

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

@@ -1,5 +1,6 @@
 using Flaro.Api.Auth;
 using Flaro.Core.Libraries;
+using Flaro.Core.Library;
 using Flaro.Core.Users;
 using Flaro.Data;
 using Microsoft.EntityFrameworkCore;
@@ -148,6 +149,35 @@ public static class ManagementEndpoints
             return betroffen > 0 ? Results.NoContent() : Results.NotFound();
         }).RequireAuthorization(FlaroPolicies.Administrator);
 
+        // **Was zu keinem Titel gehört.**
+        //
+        // Der Scan erfindet keine Serie mehr, wenn weder Ordner noch Dateiname
+        // eine nennen — nur verschwanden die Dateien damit lautlos. Bei 3559
+        // von 5884 war das die halbe Mediathek, und in der Übersicht stand
+        // eine Zahl, die niemand erklären konnte. Hier stehen sie, mit dem
+        // Grund dazu.
+        bibliotheken.MapGet("/{id:guid}/unassigned", async (
+            Guid id, FlaroContext db, int take = 300) =>
+        {
+            var bibliothek = await db.Libraries.AsNoTracking().FirstOrDefaultAsync(l => l.Id == id);
+            if (bibliothek is null) return Results.NotFound();
+
+            var offen = db.MediaFiles.AsNoTracking()
+                .Where(f => f.LibraryId == id && f.MovieId == null && f.EpisodeId == null
+                            && f.MissingSince == null);
+
+            var gesamt = await offen.CountAsync();
+            var pfade = await offen.OrderBy(f => f.Path).Take(Math.Clamp(take, 1, 2000)).ToListAsync();
+
+            // Der Grund wird hier gerechnet, nicht gespeichert: er hängt allein
+            // am Pfad und an der Benennungsregel. Eine Spalte dafür wäre beim
+            // nächsten Regelwechsel veraltet, ohne dass es jemand merkt.
+            return Results.Ok(new Unzugeordnet(
+                gesamt,
+                pfade.Select(f => new UnzugeordneteDatei(
+                    f.Id, f.Path, FileNames.WarumNicht(f.Path, bibliothek.Path))).ToList()));
+        }).RequireAuthorization(FlaroPolicies.Administrator);
+
         bibliotheken.MapGet("/missing", async (FlaroContext db) =>
         {
             var liste = await db.MediaFiles.AsNoTracking()

server/src/Flaro.Core/Library/FileNames.cs

@@ -267,6 +267,31 @@ public static partial class FileNames
             AusOrdner: ausOrdner is not null);
     }
 
+    /// <summary>Warum sich eine Datei keiner Serie zuordnen liess.</summary>
+    ///
+    /// <remarks>
+    /// <b>Zwei Gründe, und sie verlangen Verschiedenes.</b> Fehlt die
+    /// Folgennummer, muss die Datei umbenannt werden. Fehlt der Serienname,
+    /// genügt ein Ordner darum herum. „Nicht zugeordnet" allein sagt beides
+    /// nicht — und bei 3559 Dateien ist der Unterschied die ganze Arbeit.
+    /// </remarks>
+    public static string WarumNicht(string dateiname, string? wurzel = null)
+    {
+        var roh = Rohname(dateiname);
+        var treffer = StaffelUndFolge().Match(roh);
+        if (!treffer.Success) treffer = KreuzSchreibweise().Match(roh);
+
+        if (!treffer.Success)
+        {
+            return "keine Folgennummer im Dateinamen (erwartet wird etwa S01E02 oder 1x02).";
+        }
+
+        return wurzel is { Length: > 0 } && SerieAusOrdner(dateiname, wurzel) is null
+            ? "liegt ohne Ordner direkt in der Mediathek, und vor der Folgennummer "
+              + "steht kein Serienname."
+            : "vor der Folgennummer steht kein Serienname.";
+    }
+
     /// <summary>Der Serienname aus dem Pfad.</summary>
     ///
     /// <remarks>

server/src/Flaro.Data/LibraryScanner.cs

@@ -162,16 +162,25 @@ public sealed class LibraryScanner(
                 var name = FileNames.ParseEpisode(datei.Path, bibliothek.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.
+                    // **Nicht raten — aber auch nicht verschweigen.**
+                    //
+                    // Eine erfundene Staffel 1 landete unter einer Serie, zu
+                    // der die Datei nicht gehört, und dort fände sie niemand je
+                    // wieder. Die Datei einfach zu überspringen war aber die
+                    // andere Hälfte des Fehlers: 3559 von 5884 Dateien
+                    // verschwanden lautlos, und in der Mediathek stand eine
+                    // Zahl, die keiner erklären konnte.
+                    //
+                    // Jetzt bekommt sie eine Zeile ohne Zuordnung. Damit ist
+                    // sie zählbar, auflistbar und beim nächsten Lauf — oder
+                    // nach einer besseren Regel — nachträglich zuzuordnen.
                     unerkannt++;
                     log.LogInformation("Scan: {Pfad} liess sich keiner Serie zuordnen.", datei.Path);
                     fortschritt?.Report(new Scanschritt(Scanphase.Vermerk,
-                        $"Nicht zugeordnet: {datei.Path} — weder ein Ordner noch der "
-                        + "Dateiname nennen eine Serie."));
-                    continue;
+                        $"Nicht zugeordnet: {datei.Path} — {FileNames.WarumNicht(datei.Path, bibliothek.Path)}"));
                 }
+                if (name is not null)
+                {
                 var vorher = serien.Count;
                 var serie = SerieFinden(serien, libraryId, name.SeriesTitle);
 
@@ -188,6 +197,7 @@ public sealed class LibraryScanner(
                 }
 
                 folgeId = FolgeFinden(folgen, serie.Id, name).Id;
+                }
             }
 
             MediaFile eintrag;
@@ -264,7 +274,13 @@ public sealed class LibraryScanner(
                 mussUntersucht = true;
             }
 
-            if (mussUntersucht && await UntersuchenAsync(eintrag, laufZeit, ct)) untersucht++;
+            // **Was keiner Serie gehört, wird nicht untersucht.** Ein
+            // ffprobe-Durchgang kostet rund fünfzig Millisekunden; bei 3559
+            // unzugeordneten Dateien ist das eine halbe Stunde für Angaben,
+            // die niemand zu sehen bekommt. Sobald die Zuordnung steht, holt
+            // der nächste Lauf es nach — `ProbedAt` ist dann noch leer.
+            var gehoertDazu = filmId is not null || folgeId is not null;
+            if (gehoertDazu && mussUntersucht && await UntersuchenAsync(eintrag, laufZeit, ct)) untersucht++;
 
             // **Zwischendurch schreiben, nicht erst am Ende.**
             //