Verschwundene Dateien werden gemeldet, nicht stillschweigend gelöscht

Vorher räumte der Scan jede Datei weg, die er nicht mehr sah, und mit der
letzten Datei fiel der Titel samt Sehfortschritt aller Benutzer. Für eine
wirklich gelöschte Datei ist das richtig. Für eine Platte im Ruhezustand,
ein noch nicht eingehängtes Volume oder einen umbenannten Ordner ist es
Datenverlust — und für den Scan sehen alle vier Fälle gleich aus.

Jetzt trägt MediaFile ein MissingSince. Der Eintrag bleibt stehen, steht
in der Verwaltung unter "Nicht mehr gefunden", und gelöscht wird auf
Ansage. Taucht die Datei wieder auf, verschwindet die Markierung von
selbst.

Dazu die Notbremse, und sie ist der eigentliche Grund für den ganzen
Punkt: Fehlt der Wurzelpfad, oder liegt dort keine einzige Mediendatei
mehr, obwohl vorher welche da waren, bricht der Lauf ab und sagt warum.
Ohne sie erklärte ein nicht eingehängtes Volume beim Start des NAS den
gesamten Bestand für verschwunden — bei 458 Titeln.

Der Abschnitt in der Verwaltung erscheint nur, wenn es etwas zu melden
gibt. Ein dauerhaft leerer wäre Rauschen.

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

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

@@ -72,6 +72,57 @@ public static class ManagementEndpoints
                     : filme.GetValueOrDefault(l.Id))).ToList());
         }).RequireAuthorization();
 
+        // **Was nicht mehr da ist, aber noch in der Mediathek steht.**
+        //
+        // Der Scan löscht nichts mehr von selbst — eine kurz nicht eingehängte
+        // Platte hätte sonst Titel samt Sehfortschritt gekostet. Stattdessen
+        // steht es hier, und das Löschen ist eine Entscheidung.
+        bibliotheken.MapGet("/missing", async (FlaroContext db) =>
+        {
+            var liste = await db.MediaFiles.AsNoTracking()
+                .Where(f => f.MissingSince != null)
+                .OrderBy(f => f.Path)
+                .Select(f => new VermissteDatei(
+                    f.Id, f.Path, f.VersionLabel, f.MissingSince!.Value,
+                    db.Libraries.Where(l => l.Id == f.LibraryId).Select(l => l.Name).First(),
+                    f.MovieId != null
+                        ? db.Movies.Where(m => m.Id == f.MovieId).Select(m => m.Title).FirstOrDefault()
+                        : db.Episodes.Where(e => e.Id == f.EpisodeId)
+                            .Select(e => e.Title ?? ("Folge " + e.EpisodeNumber)).FirstOrDefault(),
+                    f.MovieId, f.EpisodeId))
+                .ToListAsync();
+
+            return Results.Ok(liste);
+        }).RequireAuthorization(FlaroPolicies.Administrator);
+
+        // Endgültig weg — mitsamt dem Titel, wenn es seine letzte Datei war.
+        bibliotheken.MapDelete("/missing", async (Guid? fileId, FlaroContext db) =>
+        {
+            var betroffen = db.MediaFiles.Where(f => f.MissingSince != null);
+            if (fileId is { } eine) betroffen = betroffen.Where(f => f.Id == eine);
+
+            // Die Titel merken, bevor die Dateien weg sind — danach lässt sich
+            // nicht mehr feststellen, welche verwaist zurückbleiben.
+            var filme = await betroffen.Where(f => f.MovieId != null)
+                .Select(f => f.MovieId!.Value).Distinct().ToListAsync();
+            var folgen = await betroffen.Where(f => f.EpisodeId != null)
+                .Select(f => f.EpisodeId!.Value).Distinct().ToListAsync();
+
+            var weg = await betroffen.ExecuteDeleteAsync();
+
+            await db.Movies
+                .Where(m => filme.Contains(m.Id) && !db.MediaFiles.Any(f => f.MovieId == m.Id))
+                .ExecuteDeleteAsync();
+            await db.Episodes
+                .Where(e => folgen.Contains(e.Id) && !db.MediaFiles.Any(f => f.EpisodeId == e.Id))
+                .ExecuteDeleteAsync();
+            await db.Series
+                .Where(x => !db.Episodes.Any(e => e.SeriesId == x.Id))
+                .ExecuteDeleteAsync();
+
+            return Results.Ok(new { removed = weg });
+        }).RequireAuthorization(FlaroPolicies.Administrator);
+
         bibliotheken.MapPost("/", async (CreateLibraryRequest anfrage, FlaroContext db) =>
         {
             if (!Enum.TryParse<LibraryKind>(anfrage.Kind, ignoreCase: true, out var art))