Allow admins to manage media files in Django admin

TEKDB/TEKDB/apps.py

@@ -6,3 +6,24 @@
 class TEKDBConfig(AppConfig):
     name = "TEKDB"
     verbose_name = "Records"
+
+    def ready(self):
+        from filebrowser.base import FileObject
+        from .models import Media
+
+        def get_related_media(self):
+            """
+            Returns QuerySet of Media records that reference this file
+            The file field stores paths relative to MEDIA_ROOT
+            """
+            # self.path gives the relative path from MEDIA_ROOT
+            # which should match what's stored in the mediafile field
+            return Media.objects.filter(mediafile=self.path)
+
+        def has_media_record(self):
+            """Check if this file has any related Media records"""
+            return self.get_related_media().exists()
+
+        # Add methods to FileObject
+        FileObject.get_related_media = get_related_media
+        FileObject.has_media_record = has_media_record

TEKDB/TEKDB/settings.py

@@ -47,6 +47,7 @@
 INSTALLED_APPS = [
     "dal",
     "dal_select2",
+    "filebrowser",
     "django.contrib.contenttypes",
     "django.contrib.admin",
     "django.contrib.auth",
@@ -182,6 +183,28 @@
 
 STATIC_ROOT = os.path.join(BASE_DIR, "static")
 
+###########################################
+##            FILEBROWSER               ###
+###########################################
+DIRECTORY = MEDIA_URL
+
+FILEBROWSER_LIST_PER_PAGE = 20
+
+FILEBROWSER_EXCLUDE = []  # Add extensions to exclude from showing in filebrowser. E.g. ['.py',]
+
+FILEBROWSER_VERSIONS = {} # Empty dict because we are not using versions
+
+# Apps to exclude from the export `dumpdata` command. This prevents
+# dumping third-party apps (like `filebrowser`) that may not have tables
+# in the test DB or that you don't want included in project backups.
+EXPORT_DUMP_EXCLUDE = [
+    "filebrowser",
+]
+
+###########################################
+###          END FILEBROWSER            ###
+###########################################
+
 # STATICFILES_DIRS = [
 #    os.path.join(BASE_DIR, "explore", "static"),
 #    os.path.join(BASE_DIR, "TEKDB", "static"),

TEKDB/TEKDB/tekdb_filebrowser.py

@@ -0,0 +1,269 @@
+import os
+from django.core.files.storage import DefaultStorage
+from django.core.paginator import Paginator, EmptyPage
+from django.template.response import TemplateResponse
+from django.contrib import messages
+from django.urls import reverse
+from django.http import HttpResponseRedirect
+from django.conf import settings
+from filebrowser import signals
+from filebrowser.sites import (
+    FileBrowserSite,
+    filebrowser_view,
+    get_settings_var,
+    get_breadcrumbs,
+    admin_site,
+)
+from filebrowser.decorators import path_exists
+from filebrowser.settings import (
+    DEFAULT_SORTING_BY,
+    DEFAULT_SORTING_ORDER,
+    VERSIONS_BASEDIR,
+)
+from filebrowser.templatetags.fb_tags import query_helper
+
+
+def media_matches(media_filter, obj):
+    """Return True if `obj` satisfies the media-record filter.
+
+    Supported values for media_filter:
+    - 'has_record' -> keep objects where obj.has_media_record() is True
+    - 'no_record'  -> keep objects where obj.has_media_record() is False
+    If no media_filter is set, everything matches.
+    """
+    if not media_filter:
+        return True
+    try:
+        has_attr = getattr(obj, "has_media_record", None)
+        if callable(has_attr):
+            has = bool(has_attr())
+        else:
+            has = bool(has_attr)
+    except AttributeError:
+        has = False
+    if media_filter == "has_record":
+        return has
+    if media_filter == "no_record":
+        return not has
+    return True
+
+
+class TekdbFileBrowserSite(FileBrowserSite):
+    def files_folders_to_ignore(self):
+        """Return list of filenames/folders to ignore in deleting media without record."""
+        return ["__pycache__", "__init__.py", VERSIONS_BASEDIR]
+
+    def get_urls(self):
+        from django.urls import re_path
+
+        urls = super().get_urls()
+
+        urls += [
+            re_path(
+                r"^delete-media-without-record-confirm/",
+                path_exists(
+                    self, filebrowser_view(self.delete_media_without_record_confirm)
+                ),
+                name="fb_delete_all_media_without_record_confirm",
+            ),
+            re_path(
+                r"^delete-media-without-record/",
+                path_exists(self, filebrowser_view(self.delete_media_without_record)),
+                name="fb_delete_all_media_without_record",
+            ),
+        ]
+        return urls
+
+    def browse(self, request):
+        """Call upstream browse(), then apply server-side filtering for the
+        `filter_media_record` query parameter. This keeps the UI filter backed
+        by server logic without changing upstream code.
+        """
+        response = super().browse(request)
+
+        # Only proceed if the TemplateResponse has context data we can
+        # mutate.
+        if not hasattr(response, "context_data"):
+            return response
+
+        media_filter = None
+        try:
+            media_filter = request.GET.get("filter_media_record")
+        except AttributeError:
+            media_filter = None
+
+        # dict of original paginator -> new paginator
+        paginator_replacements = {}
+
+        # loop does the following:
+        # 1. filter data if media_filter is set
+        # 2. set response.context_data["page"] to filtered page
+        # 3. build new paginators dict
+        for key, val in list(response.context_data.items()):
+            try:
+                if (
+                    hasattr(val, "paginator")
+                    and hasattr(val, "number")
+                    and key == "page"
+                ):
+                    orig_paginator = val.paginator
+                    try:
+                        full_list = list(orig_paginator.object_list)
+                    except (AttributeError, TypeError):
+                        full_list = list(getattr(val, "object_list", []))
+
+                    filtered_full = [
+                        obj for obj in full_list if media_matches(media_filter, obj)
+                    ]
+
+                    max_per_page = getattr(settings, "FILEBROWSER_LIST_PER_PAGE", None)
+                    if not max_per_page:
+                        max_per_page = getattr(orig_paginator, "per_page", 20)
+
+                    new_paginator = Paginator(filtered_full, max_per_page)
+                    page_number = getattr(val, "number", 1)
+                    try:
+                        new_page = new_paginator.page(page_number)
+                    except EmptyPage:
+                        new_page = new_paginator.page(new_paginator.num_pages)
+                    response.context_data[key] = new_page
+                    paginator_replacements[orig_paginator] = new_paginator
+
+            except AttributeError:
+                # Non-fatal: skip entries we can't process
+                pass
+
+        # Replace response.context_data["p"] with new paginator
+        if paginator_replacements:
+            for key, orig_paginator in list(response.context_data.items()):
+                for orig, new_paginator in list(paginator_replacements.items()):
+                    if orig_paginator is orig:
+                        response.context_data[key] = new_paginator
+
+        # Update results_current and results_total
+        try:
+            filelisting = response.context_data.get("filelisting")
+            if filelisting is not None:
+                # If filelisting exposes a list of current files, try to
+                # update results_current/total conservatively.
+                try:
+                    if hasattr(filelisting, "results_current"):
+                        # get new page set on line 129
+                        page = response.context_data.get("page")
+
+                        if page is not None and hasattr(page, "object_list"):
+                            # update results_current from filtered page
+                            filelisting.results_current = len(list(page.object_list))
+
+                    if hasattr(filelisting, "results_total"):
+                        # derive results_total from a paginator replacement
+                        paginator_new = None
+                        for new_page in paginator_replacements.values():
+                            paginator_new = new_page
+                            break
+
+                        if paginator_new is not None:
+                            try:
+                                total = len(getattr(paginator_new, "object_list", []))
+                            except AttributeError:
+                                total = 0
+
+                            filelisting.results_total = total
+                except AttributeError:
+                    pass
+        except (AttributeError, TypeError):
+            pass
+
+        return response
+
+    def delete_media_without_record_confirm(self, request):
+        """Confirm page to delete selected files that do not have associated media records."""
+
+        query = request.GET
+        path = "%s" % os.path.join(self.directory, query.get("dir", ""))
+
+        filelisting = self.filelisting_class(
+            path,
+            filter_func=lambda fo: not fo.has_media_record()
+            and fo.filename not in self.files_folders_to_ignore(),
+            sorting_by=query.get("o", DEFAULT_SORTING_BY),
+            sorting_order=query.get("ot", DEFAULT_SORTING_ORDER),
+            site=self,
+        )
+        listings = filelisting.files_listing_filtered()
+
+        return TemplateResponse(
+            request,
+            "filebrowser/delete_no_media_record_confirm.html",
+            dict(
+                admin_site.each_context(request),
+                **{
+                    "filelisting": listings,
+                    "query": query,
+                    "title": "Confirm Deletion of Unused Media Files",
+                    "settings_var": get_settings_var(directory=self.directory),
+                    "breadcrumbs": get_breadcrumbs(query, query.get("dir", "")),
+                    "breadcrumbs_title": "Delete Unused Media Files",
+                    "filebrowser_site": self,
+                },
+            ),
+        )
+
+    def delete_media_without_record(self, request):
+        """Delete selected files that do not have associated media records."""
+        query = request.GET
+        path = "%s" % os.path.join(self.directory, query.get("dir", ""))
+
+        filelisting = self.filelisting_class(
+            path,
+            filter_func=lambda fo: not fo.has_media_record()
+            and fo.filename not in self.files_folders_to_ignore(),
+            sorting_by=query.get("o", DEFAULT_SORTING_BY),
+            sorting_order=query.get("ot", DEFAULT_SORTING_ORDER),
+            site=self,
+        )
+        listing = filelisting.files_listing_filtered()
+
+        deleted_files = []
+        for fileobject in listing:
+            try:
+                signals.filebrowser_pre_delete.send(
+                    sender=request,
+                    path=fileobject.path,
+                    name=fileobject.filename,
+                    site=self,
+                )
+                # we have disabled versions for TEKDB,
+                # but keep the call here in case that changes in future
+                # or in the off chance versions exist
+                fileobject.delete_versions()
+                fileobject.delete()
+                deleted_files.append(fileobject.filename)
+                signals.filebrowser_post_delete.send(
+                    sender=request,
+                    path=fileobject.path,
+                    name=fileobject.filename,
+                    site=self,
+                )
+            except OSError:
+                messages.add_message(
+                    request,
+                    messages.ERROR,
+                    f"Error deleting file: {fileobject.filename}",
+                )
+                break
+
+        messages.add_message(
+            request, messages.SUCCESS, f"Deleted files: {', '.join(deleted_files)}"
+        )
+
+        # Redirect back to browse after deletion
+        redirect_url = reverse(
+            "filebrowser:fb_browse", current_app=self.name
+        ) + query_helper(query, "", "filename,filetype")
+        return HttpResponseRedirect(redirect_url)
+
+
+storage = DefaultStorage()
+site = TekdbFileBrowserSite(name="filebrowser", storage=storage)
+site.directory = ""

TEKDB/TEKDB/templates/filebrowser/delete_no_media_record_confirm.html

@@ -0,0 +1,35 @@
+{% extends "admin/base_site.html" %}
+
+<!-- LOADING -->
+{% load static i18n fb_tags fb_compat %}
+
+<!-- BREADCRUMBS -->
+{% block breadcrumbs %}{% include "filebrowser/include/breadcrumbs.html" %}{% endblock %}
+
+<!-- CONTENT -->
+{% block content %}
+    <!-- POP-UP BREADCRUMBS -->
+    {% if query.pop %}
+        {% include "filebrowser/include/breadcrumbs.html" %}
+    {% endif %}
+    {% if filelisting|length > 0 %}
+        <p>Are you sure you want to delete all media files without media records? All of the following related items will be deleted:</p>
+        {% if filelisting %}
+            <ul>
+                {% for fileobject in filelisting %}
+                    <li>{{ fileobject.filename }}</li>
+                {% endfor %}
+            </ul>
+        {% endif %}
+
+        <form action="{% url 'filebrowser:fb_delete_all_media_without_record' %}{% query_string %}" method="post">
+        {% csrf_token %}
+        <div>
+        <input type="submit" value="{% trans "Yes, I'm sure" %}" />
+        </div>
+        </form>
+    {% endif %}
+    {% if filelisting|length == 0  %}
+        <p>There are no media files without media records to delete.</p>
+    {% endif %}
+{% endblock %}