Add optional metadata cleanup to Danger Zone bulk delete

- bulk_delete_by_media_type now accepts delete_metadata=true, removing
  Item rows (including cascaded Season/Episode items for tv/anime) that
  are no longer tracked by anyone once the user's rows are deleted.
- For music, also cleans up orphaned Artist/Album catalog rows, which
  have no FK from Item at all.
- Adds an opt-in toggle to the Danger Zone confirm modal explaining the
  cascade to custom lists/collections/calendar entries.

Fixes #971

Author: dannyvfilms

src/templates/users/advanced.html

@@ -364,7 +364,7 @@ <h3 class="text-lg font-semibold text-[var(--color-error-text)]">Clear All Cache
         </template>
       </div>
 
-      <div class="bg-[var(--color-surface-strong)] p-5 rounded-lg mb-6" x-data="{ open: false, confirmOpen: false, selectedMediaType: '', selectedMediaLabel: 'Choose a media type...', deleteConfirmation: '', options: [
+      <div class="bg-[var(--color-surface-strong)] p-5 rounded-lg mb-6" x-data="{ open: false, confirmOpen: false, selectedMediaType: '', selectedMediaLabel: 'Choose a media type...', deleteConfirmation: '', deleteMetadata: false, options: [
         {% for media_type in media_types %}
           { value: '{{ media_type|escapejs }}', label: '{{ media_type|media_type_readable_plural|escapejs }}' }
           {% if not forloop.last %},{% endif %}
@@ -433,6 +433,7 @@ <h3 class="text-base font-medium text-[var(--color-error-text)]">Danger Zone</h3
               class="hidden">
           {% csrf_token %}
           <input type="hidden" name="media_type" x-bind:value="selectedMediaType">
+          <input type="hidden" name="delete_metadata" x-bind:value="deleteMetadata">
         </form>
 
         <template x-teleport="body">
@@ -452,6 +453,21 @@ <h3 class="text-lg font-semibold text-[var(--color-error-text)]">Are you sure?</
                   <strong x-text="selectedMediaLabel.toLowerCase()"></strong>
                   entry in your account. This removes its progress, ratings, notes, and history.
                 </p>
+                <label class="flex items-center justify-between p-3 mb-3 bg-[var(--color-panel)] rounded-md cursor-pointer">
+                  <span class="text-sm text-[var(--color-text-secondary)] pr-3">
+                    Also delete cached metadata (posters, cast/crew, and for music, artists &amp; albums)
+                    with no remaining tracked entries.
+                  </span>
+                  <span class="relative inline-flex items-center shrink-0">
+                    <input class="sr-only peer" type="checkbox" x-model="deleteMetadata">
+                    <div class="w-9 h-5 bg-gray-600 rounded-full peer peer-checked:after:translate-x-full peer-checked:after:border-white after:content-[''] after:absolute after:top-px after:left-0.5 after:bg-white after:border-gray-300 after:border after:rounded-full after:h-4.5 after:w-4.5 after:transition-all peer-checked:bg-indigo-600">
+                    </div>
+                  </span>
+                </label>
+                <p x-show="deleteMetadata" x-cloak class="text-sm text-[var(--color-error-text)] mb-3">
+                  Metadata deletion also removes any custom list entries, collections, or calendar
+                  events still pointing at that now-untracked media.
+                </p>
                 <p class="text-sm text-[var(--color-error-text)] font-medium mb-4">This action cannot be undone.</p>
                 <label class="block text-sm text-[var(--color-text-secondary)] mb-2">
                   Type <strong>DELETE</strong> to confirm.

src/users/tests/views/test_advanced.py

@@ -9,13 +9,20 @@
 from app.history_cache_utils import HISTORY_DAY_PREFIX, HISTORY_INDEX_PREFIX
 from app.models import (
     TV,
+    Album,
+    AlbumTracker,
+    Artist,
+    ArtistTracker,
     Book,
     DeletedMedia,
     DiscoverRowCache,
     DiscoverTasteProfile,
+    Episode,
     Item,
     MediaTypes,
     Movie,
+    Music,
+    Season,
     Sources,
     Status,
 )
@@ -351,6 +358,162 @@ def test_clear_all_caches_clears_search_and_current_users_own_caches(self):
         self.assertEqual(len(messages), 1)
         self.assertIn("search, history, statistics, and discover", str(messages[0]))
 
+    def test_delete_media_type_without_metadata_flag_leaves_item_behind(self):
+        """The default (unchecked) behavior must not change: Item rows survive."""
+        item = Item.objects.create(
+            media_id="orphan-movie",
+            source=Sources.TMDB.value,
+            media_type=MediaTypes.MOVIE.value,
+            title="Orphan",
+        )
+        Movie.objects.create(item=item, user=self.user, status=Status.PLANNING.value)
+
+        response = self.client.post(
+            reverse("bulk_delete_by_media_type"),
+            {"media_type": MediaTypes.MOVIE.value},
+        )
+
+        self.assertRedirects(response, reverse("advanced"))
+        self.assertTrue(Item.objects.filter(id=item.id).exists())
+
+    def test_delete_media_type_with_metadata_flag_removes_orphaned_item(self):
+        """With delete_metadata=true, an Item with no other tracker is deleted."""
+        item = Item.objects.create(
+            media_id="orphan-movie",
+            source=Sources.TMDB.value,
+            media_type=MediaTypes.MOVIE.value,
+            title="Orphan",
+        )
+        Movie.objects.create(item=item, user=self.user, status=Status.PLANNING.value)
+
+        response = self.client.post(
+            reverse("bulk_delete_by_media_type"),
+            {"media_type": MediaTypes.MOVIE.value, "delete_metadata": "true"},
+        )
+
+        self.assertRedirects(response, reverse("advanced"))
+        self.assertFalse(Item.objects.filter(id=item.id).exists())
+        messages = list(get_messages(response.wsgi_request))
+        self.assertIn("Also removed 1 metadata entry", str(messages[0]))
+
+    def test_delete_media_type_with_metadata_flag_keeps_item_tracked_by_other_user(self):
+        """An Item still tracked by another user must survive metadata cleanup."""
+        item = Item.objects.create(
+            media_id="shared-movie",
+            source=Sources.TMDB.value,
+            media_type=MediaTypes.MOVIE.value,
+            title="Shared",
+        )
+        Movie.objects.create(item=item, user=self.user, status=Status.PLANNING.value)
+        Movie.objects.create(
+            item=item,
+            user=self.other_user,
+            status=Status.PLANNING.value,
+        )
+
+        response = self.client.post(
+            reverse("bulk_delete_by_media_type"),
+            {"media_type": MediaTypes.MOVIE.value, "delete_metadata": "true"},
+        )
+
+        self.assertRedirects(response, reverse("advanced"))
+        self.assertTrue(Item.objects.filter(id=item.id).exists())
+
+    def test_delete_tv_with_metadata_flag_cleans_up_seasons_and_episodes(self):
+        """Deleting TV with metadata on also removes now-orphaned Season/Episode Items."""
+        tv_item = Item.objects.create(
+            media_id="tv-show",
+            source=Sources.TVDB.value,
+            media_type=MediaTypes.TV.value,
+            library_media_type=MediaTypes.TV.value,
+            title="Show",
+        )
+        tv = TV.objects.create(item=tv_item, user=self.user, status=Status.PLANNING.value)
+        season_item = Item.objects.create(
+            media_id="tv-show",
+            source=Sources.TVDB.value,
+            media_type=MediaTypes.SEASON.value,
+            season_number=1,
+            title="Show",
+        )
+        season = Season.objects.create(item=season_item, user=self.user, related_tv=tv)
+        episode_item = Item.objects.create(
+            media_id="tv-show",
+            source=Sources.TVDB.value,
+            media_type=MediaTypes.EPISODE.value,
+            season_number=1,
+            episode_number=1,
+            title="Show",
+        )
+        Episode.objects.create(item=episode_item, related_season=season)
+
+        response = self.client.post(
+            reverse("bulk_delete_by_media_type"),
+            {"media_type": MediaTypes.TV.value, "delete_metadata": "true"},
+        )
+
+        self.assertRedirects(response, reverse("advanced"))
+        self.assertFalse(Item.objects.filter(id=tv_item.id).exists())
+        self.assertFalse(Item.objects.filter(id=season_item.id).exists())
+        self.assertFalse(Item.objects.filter(id=episode_item.id).exists())
+
+    def test_delete_music_with_metadata_flag_cleans_orphaned_artist_and_album(self):
+        """Deleting music with metadata on also removes orphaned Artist/Album rows."""
+        artist = Artist.objects.create(name="Orphan Artist")
+        album = Album.objects.create(title="Orphan Album", artist=artist)
+        item = Item.objects.create(
+            media_id="orphan-track",
+            source=Sources.MANUAL.value,
+            media_type=MediaTypes.MUSIC.value,
+            title="Track",
+        )
+        Music.objects.create(
+            item=item,
+            user=self.user,
+            status=Status.COMPLETED.value,
+            artist=artist,
+            album=album,
+        )
+
+        response = self.client.post(
+            reverse("bulk_delete_by_media_type"),
+            {"media_type": MediaTypes.MUSIC.value, "delete_metadata": "true"},
+        )
+
+        self.assertRedirects(response, reverse("advanced"))
+        self.assertFalse(Item.objects.filter(id=item.id).exists())
+        self.assertFalse(Album.objects.filter(id=album.id).exists())
+        self.assertFalse(Artist.objects.filter(id=artist.id).exists())
+
+    def test_delete_music_with_metadata_flag_keeps_artist_with_tracker(self):
+        """An Artist/Album still followed via ArtistTracker/AlbumTracker survives."""
+        artist = Artist.objects.create(name="Followed Artist")
+        album = Album.objects.create(title="Followed Album", artist=artist)
+        ArtistTracker.objects.create(user=self.other_user, artist=artist)
+        AlbumTracker.objects.create(user=self.other_user, album=album)
+        item = Item.objects.create(
+            media_id="tracked-track",
+            source=Sources.MANUAL.value,
+            media_type=MediaTypes.MUSIC.value,
+            title="Track",
+        )
+        Music.objects.create(
+            item=item,
+            user=self.user,
+            status=Status.COMPLETED.value,
+            artist=artist,
+            album=album,
+        )
+
+        response = self.client.post(
+            reverse("bulk_delete_by_media_type"),
+            {"media_type": MediaTypes.MUSIC.value, "delete_metadata": "true"},
+        )
+
+        self.assertRedirects(response, reverse("advanced"))
+        self.assertTrue(Album.objects.filter(id=album.id).exists())
+        self.assertTrue(Artist.objects.filter(id=artist.id).exists())
+
     def test_cache_clear_views_require_post(self):
         """GET requests to any clear-cache endpoint must be rejected."""
         for url_name in (

src/users/views.py

@@ -28,7 +28,7 @@
 from app import history_cache, image_cache, statistics_cache
 from app.discover.feeds import get_external_row_definitions
 from app.discover.registry import DISCOVER_MEDIA_TYPES
-from app.models import Item, MediaTypes, Status
+from app.models import Album, Artist, Item, MediaTypes, Status
 from app.providers import tmdb
 from app.services import metadata_resolution
 from app.templatetags import app_tags
@@ -76,6 +76,7 @@
     TimeFormatChoices,
     TitleDisplayPreferenceChoices,
     TopTalentSortChoices,
+    UiLanguageChoices,
     User,
     WeekStartDayChoices,
 )
@@ -901,6 +902,7 @@ def preferences(request):
         selected_media_types = request.POST.getlist("media_types_checkboxes")
         date_format = request.POST.get("date_format")
         theme = request.POST.get("theme")
+        ui_language = request.POST.get("ui_language")
         logo_style = request.POST.get("logo_style")
         time_format = request.POST.get("time_format")
         activity_history_view = request.POST.get("activity_history_view")
@@ -981,6 +983,14 @@ def preferences(request):
             request.user.logo_style = logo_style
             fields_to_update.append("logo_style")
 
+        if (
+            ui_language
+            and ui_language in UiLanguageChoices.values
+            and request.user.ui_language != ui_language
+        ):
+            request.user.ui_language = ui_language
+            fields_to_update.append("ui_language")
+
         if (
             time_format
             and time_format in [choice[0] for choice in TimeFormatChoices.choices]
@@ -1230,6 +1240,7 @@ def preferences(request):
         "library_labels_json": json.dumps(library_labels),
         "watch_provider_choices": watch_provider_regions,
         "metadata_language_choices": metadata_language_choices,
+        "ui_language_choices": UiLanguageChoices.choices,
         "tv_metadata_source_choices": tv_metadata_source_choices,
         "anime_metadata_source_choices": anime_metadata_source_choices,
         "anime_library_mode_choices": AnimeLibraryModeChoices.choices,
@@ -1727,11 +1738,22 @@ def bulk_delete_by_media_type(request):
         messages.error(request, "Unknown media type.")
         return redirect("advanced")
 
+    delete_metadata = request.POST.get("delete_metadata") == "true"
+
     media_querysets = _media_querysets_for_bulk_delete(request.user, media_type)
     item_count = sum(queryset.count() for queryset in media_querysets)
+    candidate_item_ids = (
+        _candidate_item_ids_for_metadata_cleanup(media_querysets, media_type)
+        if delete_metadata
+        else set()
+    )
     for queryset in media_querysets:
         queryset.delete()
 
+    metadata_count = 0
+    if delete_metadata and candidate_item_ids:
+        metadata_count = _delete_orphaned_metadata(media_type, candidate_item_ids)
+
     if item_count:
         # Model post-delete signals invalidate runtime caches and schedule
         # refreshes. These payload clears ensure a just-deleted item cannot
@@ -1740,14 +1762,16 @@ def bulk_delete_by_media_type(request):
         cache_management.clear_statistics_cache_for_user(request.user.id)
         cache_management.clear_discover_cache_for_user(request.user.id)
         label = MediaTypes(media_type).label
-        messages.success(
-            request,
-            f"Permanently deleted {item_count} {label} item(s) from your library.",
-        )
+        message = f"Permanently deleted {item_count} {label} item(s) from your library."
+        if delete_metadata:
+            message += f" Also removed {metadata_count} metadata entr{'y' if metadata_count == 1 else 'ies'}."
+        messages.success(request, message)
         logger.info(
-            "Permanently deleted %s %s items for user %s",
+            "Permanently deleted %s %s items (metadata=%s, metadata_count=%s) for user %s",
             item_count,
             media_type,
+            delete_metadata,
+            metadata_count,
             request.user.id,
         )
     else:
@@ -1778,6 +1802,78 @@ def _media_querysets_for_bulk_delete(user, media_type):
     return [queryset]
 
 
+def _candidate_item_ids_for_metadata_cleanup(media_querysets, media_type):
+    """Return Item ids that may become orphaned once media_querysets are deleted.
+
+    Must be called before the querysets are deleted. TV/anime rows cascade-delete
+    their Season and Episode rows, so those Items are candidates too even though
+    they aren't directly represented by media_querysets.
+    """
+    item_ids = set()
+    for queryset in media_querysets:
+        item_ids.update(queryset.values_list("item_id", flat=True))
+
+    if media_type in (MediaTypes.TV.value, MediaTypes.ANIME.value):
+        season_model = apps.get_model(app_label="app", model_name="season")
+        episode_model = apps.get_model(app_label="app", model_name="episode")
+        for tv_queryset in media_querysets:
+            seasons = season_model.objects.filter(related_tv__in=tv_queryset)
+            item_ids.update(seasons.values_list("item_id", flat=True))
+            item_ids.update(
+                episode_model.objects.filter(
+                    related_season__related_tv__in=tv_queryset,
+                ).values_list("item_id", flat=True),
+            )
+
+    return item_ids
+
+
+def _delete_orphaned_metadata(media_type, item_ids):
+    """Delete Item rows (and music catalog rows) no longer tracked by anyone."""
+    tracking_models = [apps.get_model(app_label="app", model_name=media_type)]
+    if media_type in (MediaTypes.TV.value, MediaTypes.ANIME.value):
+        tracking_models = [
+            apps.get_model(app_label="app", model_name="tv"),
+            apps.get_model(app_label="app", model_name="anime"),
+            apps.get_model(app_label="app", model_name="season"),
+            apps.get_model(app_label="app", model_name="episode"),
+        ]
+
+    orphaned_ids = set(item_ids)
+    for model in tracking_models:
+        manager = getattr(model, "all_objects", model.objects)
+        orphaned_ids -= set(
+            manager.filter(item_id__in=item_ids).values_list("item_id", flat=True),
+        )
+
+    item_count, _ = Item.objects.filter(id__in=orphaned_ids).delete()
+
+    if media_type == MediaTypes.MUSIC.value:
+        item_count += _delete_orphaned_music_catalog()
+
+    return item_count
+
+
+def _delete_orphaned_music_catalog():
+    """Delete Artist/Album catalog rows no longer referenced by anyone.
+
+    Track has no independent lifecycle -- it cascades when its Album is deleted.
+    """
+    album_count, _ = Album.objects.filter(
+        music_entries__isnull=True,
+        trackers__isnull=True,
+    ).delete()
+    artist_count, _ = Artist.objects.filter(
+        music_entries__isnull=True,
+        trackers__isnull=True,
+        albums__isnull=True,
+        album_credits__isnull=True,
+        members__isnull=True,
+        bands__isnull=True,
+    ).delete()
+    return album_count + artist_count
+
+
 @require_POST
 def cancel_import_run(request, run_id):
     """Cancel a running import.