admin.py

import json
import logging

from admin_auto_filters.filters import AutocompleteFilter
from admin_auto_filters.filters import AutocompleteFilterFactory

from django import forms
from django.contrib import messages
from django.contrib.admin import SimpleListFilter
from django.contrib.admin.utils import unquote
from django.contrib.gis import admin
from django.contrib.gis.db import models
from django.contrib.postgres.fields import ArrayField
from django.db.models.deletion import ProtectedError
from django.forms import CharField
from django.forms import Textarea
from django.http import HttpResponseRedirect
from django.template.defaultfilters import filesizeformat
from django.template.response import TemplateResponse
from django.urls import path
from django.urls import reverse
from django.utils.html import format_html
from django.utils.translation import gettext_lazy as _

from stac_api.models.collection import Collection
from stac_api.models.collection import CollectionAsset
from stac_api.models.collection import CollectionLink
from stac_api.models.general import BBOX_CH
from stac_api.models.general import LandingPage
from stac_api.models.general import LandingPageLink
from stac_api.models.general import Provider
from stac_api.models.item import Asset
from stac_api.models.item import AssetUpload
from stac_api.models.item import Item
from stac_api.models.item import ItemLink
from stac_api.utils import build_asset_href
from stac_api.utils import get_query_params
from stac_api.validators import StacExtension
from stac_api.validators import validate_text_to_geometry

logger = logging.getLogger(__name__)


class LandingPageLinkInline(admin.TabularInline):
    model = LandingPageLink
    extra = 0


@admin.register(LandingPage)
class LandingPageAdmin(admin.ModelAdmin):
    inlines = [LandingPageLinkInline]
    formfield_overrides = {
        ArrayField: {
            'widget': Textarea(attrs={
                'rows': 10, 'cols': 60
            })
        },
    }


class ProviderInline(admin.TabularInline):
    model = Provider
    extra = 0
    formfield_overrides = {
        models.TextField: {
            'widget': Textarea(attrs={
                'rows': 4, 'cols': 40
            }),
            'empty_value': None,
        },
    }

    def formfield_for_dbfield(self, db_field, request, **kwargs):
        # Set default scheme of URLs to https to resolve deprecation warning, can be removed with
        # django 6+
        if isinstance(db_field, models.URLField):
            kwargs['assume_scheme'] = 'https'
        return super().formfield_for_dbfield(db_field, request, **kwargs)


class LinkInline(admin.TabularInline):

    def formfield_for_dbfield(self, db_field, request, **kwargs):
        # make the hreflang field a bit shorter so that the inline
        # will not be rendered too wide
        if db_field.attname == 'hreflang':
            attrs = {'size': 10}
            kwargs['widget'] = forms.TextInput(attrs=attrs)
        # Set default scheme of URLs to https to resolve deprecation warning, can be removed with
        # django 6+
        if isinstance(db_field, models.URLField):
            kwargs['assume_scheme'] = 'https'
        return super().formfield_for_dbfield(db_field, request, **kwargs)


class CollectionLinkInline(LinkInline):
    model = CollectionLink
    extra = 0


class CollectionAssetInline(admin.StackedInline):
    model = CollectionAsset
    readonly_fields = [
        'file',
        'file_size',
    ]
    extra = 0


# helper form to render stac_extensions_enabled as a suggested multi-select instead of a plain
# comma-separated text field (the default ArrayField widget)
class CollectionAdminForm(forms.ModelForm):
    stac_extensions_enabled = forms.MultipleChoiceField(
        choices=StacExtension.choices,
        required=False,
        widget=forms.CheckboxSelectMultiple,
        help_text=(
            "STAC extensions that are enabled for the Items in this Collection. Only Items "
            "using one of the selected extensions can be created or updated. This field is for "
            "internal/admin use only, it is not exposed through the STAC API."
        )
    )


class StacExtensionsEnabledFilter(SimpleListFilter):
    title = _('STAC extensions enabled')
    parameter_name = 'stac_extensions_enabled'
    template = 'admin/stac_extensions_enabled_filter.html'

    value_none = 'none'
    value_forecast = StacExtension.FORECAST
    value_timestamps = StacExtension.TIMESTAMPS

    def lookups(self, request, model_admin):
        return [
            (self.value_none, _('None')),
            (self.value_forecast, _('Forecast')),
            (self.value_timestamps, _('Timestamps')),
        ]

    def queryset(self, request, queryset):
        values = request.GET.getlist(self.parameter_name)
        if not values:
            return queryset

        if self.value_none in values:
            return queryset.filter(stac_extensions_enabled=[])

        return queryset.filter(stac_extensions_enabled__contains=values)

    def choices(self, changelist):
        values = set(self.request.GET.getlist(self.parameter_name))
        for lookup, title in self.lookup_choices:
            yield {
                'selected': str(lookup) in values,
                'value': lookup,
                'display': title,
            }


@admin.register(Collection)
class CollectionAdmin(admin.ModelAdmin):
    form = CollectionAdminForm

    class Media:
        js = ('js/admin/collection_help_search.js',)
        css = {'all': ('style/hover.css',)}

    fields = [
        'name',
        'published',
        'title',
        'description',
        'created',
        'updated',
        'extent_start_datetime',
        'extent_end_datetime',
        'extent_geometry',
        'summaries_proj_epsg',
        'summaries_geoadmin_variant',
        'summaries_geoadmin_lang',
        'summaries_eo_gsd',
        'license',
        'etag',
        'displayed_total_data_size',
        'allow_external_assets',
        'external_asset_whitelist',
        'cache_control_header',
        'stac_extensions_enabled',
    ]
    readonly_fields = [
        'extent_start_datetime',
        'extent_end_datetime',
        'extent_geometry',
        'created',
        'updated',
        'summaries_proj_epsg',
        'summaries_geoadmin_variant',
        'summaries_geoadmin_lang',
        'summaries_eo_gsd',
        'etag',
        'displayed_total_data_size'
    ]
    inlines = [ProviderInline, CollectionLinkInline, CollectionAssetInline]
    search_fields = ['name']
    list_display = ['name', 'published']
    list_filter = ['published', StacExtensionsEnabledFilter]

    #helper function which displays the bytes in human-readable format
    def displayed_total_data_size(self, instance):
        return filesizeformat(instance.total_data_size)

    displayed_total_data_size.short_description = 'Total data size'

    def render_change_form(self, request, context, *args, **kwargs):
        form_instance = context['adminform'].form
        form_instance.fields['external_asset_whitelist'].widget = Textarea(
            attrs={
                'rows': 10,
                'cols': 60,
                'placeholder': 'https://map.geo.admin.ch,https://swisstopo.ch'
            }
        )

        return super().render_change_form(request, context, *args, **kwargs)

    def get_search_results(self, request, queryset, search_term):
        queryset, use_distinct = super().get_search_results(request, queryset, search_term)
        if search_term.startswith('"') and search_term.endswith('"'):
            queryset |= self.model.objects.filter(name__exact=search_term.strip('"'))
        return queryset, use_distinct

    def get_readonly_fields(self, request, obj=None):
        if obj is not None:
            return self.readonly_fields + ['name']
        return self.readonly_fields


class ItemLinkInline(LinkInline):
    model = ItemLink
    extra = 0


class CollectionFilterForItems(AutocompleteFilter):
    title = 'Collection name'  # display title
    field_name = 'collection'  # name of the foreign key


# helper form to add an extra text_geometry field to ItemAdmin
class ItemAdminForm(forms.ModelForm):
    help_text = """Insert either:<br/>
    - An extent in either WGS84 or LV95: "xmin, ymin, xmax, ymax"
    where x is easting and y is northing<br/>
    - A WKT polygon.
    F.ex. "SRID=4326;POLYGON((5.96 45.82, 5.96 47.81, 10.49 47.81, 10.49 45.82, 5.96 45.82))"
    <br/><br/><b>In any case the geometry will be saved as a WKT POLYGON in WGS84.</b>
    """
    text_geometry = CharField(
        label='Geometry text', widget=forms.TextInput(attrs={'size': 150}), help_text=help_text
    )

    def clean_text_geometry(self):
        # validating and transforming the text to a geometry
        self.cleaned_data["text_geometry"] = validate_text_to_geometry(self.data["text_geometry"])
        return self.cleaned_data["text_geometry"]


@admin.register(Item)
class ItemAdmin(admin.ModelAdmin):
    form = ItemAdminForm
    modifiable = False

    class Media:
        js = ('js/admin/item_help_search.js',)
        css = {'all': ('style/hover.css',)}

    inlines = [ItemLinkInline]
    autocomplete_fields = ['collection']
    search_fields = ['name', 'collection__name']
    readonly_fields = [
        'collection_name',
        'created',
        'updated',
        'etag',
        'displayed_total_data_size',
    ]
    fieldsets = (
        (
            None,
            {
                'fields': (
                    'name',
                    'collection',
                    'created',
                    'updated',
                    'etag',
                    'displayed_total_data_size',
                    'stac_extensions',
                )
            }
        ),
        ('geometry', {
            'fields': ('geometry', 'text_geometry'),
        }),
        (
            'Properties',
            {
                'fields': (
                    'properties_datetime',
                    'properties_start_datetime',
                    'properties_end_datetime',
                    'properties_expires',
                    'properties_title'
                )
            }
        ),
        (
            'Forecast',
            {
                'fields': (
                    'forecast_reference_datetime',
                    'forecast_horizon',
                    'forecast_duration',
                    'forecast_variable',
                    'forecast_perturbed',
                )
            }
        ),
        ('CF Extension', {
            'fields': (
                'cf_standard_name',
                'unit',
            )
        }),
    )

    list_display = ['name', 'collection', 'collection_published']
    list_filter = [CollectionFilterForItems]

    #helper function which displays the bytes in human-readable format
    def displayed_total_data_size(self, instance):
        return filesizeformat(instance.total_data_size)

    displayed_total_data_size.short_description = 'Total data size'

    def get_search_results(self, request, queryset, search_term):
        queryset, use_distinct = super().get_search_results(request, queryset, search_term)

        # The following few lines are a bit hacky and are needed for the item dropdown list
        # to depend on the currently selected collection in the collection dropdown filter.
        # With this "hack", only those items appear in the "filter by item name" dropdown list,
        # that belong to the currently selected collection in the "filter by collection name"
        # dropdown list. Otherwise all items would appear in the dropdown list, which does not
        # make sense.

        # this asserts that the request comes from the autocomplete filters.
        if request.path.endswith("/autocomplete/"):
            collection_filter_param = get_query_params(
                request.headers['Referer'], 'item__collection'
            )
            if collection_filter_param:
                queryset = queryset.filter(collection__pk__exact=collection_filter_param[0])
        if search_term.startswith('"') and search_term.endswith('"'):
            search_terms = search_term.strip('"').split('/', maxsplit=2)
            if len(search_terms) == 2:
                collection_name = search_terms[0]
                item_name = search_terms[1]
            else:
                collection_name = None
                item_name = search_terms[0]
            queryset |= self.model.objects.filter(name__exact=item_name)
            if collection_name:
                queryset &= self.model.objects.filter(collection__name__exact=collection_name)
        return queryset, use_distinct

    def collection_published(self, instance):
        return instance.collection.published

    collection_published.admin_order_field = 'collection__published'
    collection_published.short_description = 'Published'
    collection_published.boolean = True

    # Here we use a special field for read only to avoid adding the extra help text for search
    # functionality
    def collection_name(self, obj):
        return obj.collection.name

    collection_name.admin_order_field = 'collection__name'
    collection_name.short_description = 'Collection Id'

    # We don't want to move the assets on S3
    # That's why some fields like the name of the item and the collection name are set readonly here
    # for update operations. Those fields value are used as key on S3 that's why renaming them
    # would mean that the Asset on S3 should be moved.
    def get_fieldsets(self, request, obj=None):
        fields = super().get_fieldsets(request, obj)
        if obj is None:
            # In case a new Item is added use the normal field 'collection' from model that have
            # a help text fort the search functionality.
            fields[0][1]['fields'] = (
                'name',
                'collection',
                'created',
                'updated',
                'etag',
                'displayed_total_data_size',
                'stac_extensions',
            )
            return fields
        # Otherwise if this is an update operation only display the read only field
        # without help text
        fields[0][1]['fields'] = (
            'name',
            'collection_name',
            'created',
            'updated',
            'etag',
            'displayed_total_data_size',
            'stac_extensions',
        )
        return fields

    # Populate text_geometry field with value of geometry
    def get_form(self, request, obj=None, **kwargs):  # pylint: disable=arguments-differ
        # pylint: disable=attribute-defined-outside-init
        form = super().get_form(request, obj, **kwargs)
        if obj is not None:
            form.base_fields['text_geometry'].initial = obj.geometry
        else:
            form.base_fields['text_geometry'].initial = BBOX_CH
        return form

    # Overwrite value of geometry with value of text_geometry
    def save_model(self, request, obj, form, change):
        obj.geometry = form.cleaned_data['text_geometry']
        return super().save_model(request, obj, form, change)


class AssetUploadAdminMixin:
    upload_template_name = "uploadtemplate.html"
    url_suffix = "_upload"

    def get_urls(self):
        urls = super().get_urls()
        my_urls = [
            path(
                "<path:object_id>/change/upload/",
                self.admin_site.admin_view(self.upload_view),
                name=f'{self.model._meta.app_label}_{self.model._meta.model_name}{self.url_suffix}',
            )
        ]
        return my_urls + urls

    def upload_view(self, request, object_id, extra_context=None):
        model = self.model
        obj = self.get_object(request, unquote(object_id))
        if obj is None:
            return self._get_obj_does_not_exist_redirect(request, model._meta, object_id)

        context = dict(
            # Include common variables for rendering the admin template.
            self.admin_site.each_context(request),
            # Anything else you want in the context...
            csrf_token=request.META.get('CSRF_COOKIE'),
            asset_name=obj.name,
            collection_name=obj.get_collection(),
        )

        if hasattr(obj, 'item'):
            context['item_name'] = obj.item.name

        return TemplateResponse(request, self.upload_template_name, context)

    def change_view(self, request, object_id, form_url='', extra_context=None):
        obj = self.model.objects.\
            filter(id=request.resolver_match.kwargs['object_id']).first()

        if getattr(obj, "is_external", False):  #check if the object is external
            return super().change_view(request, object_id, form_url)

        extra_context = extra_context or {}
        property_upload_url = reverse(
            f'admin:{self.model._meta.app_label}_{self.model._meta.model_name}{self.url_suffix}',
            args=[object_id],
        )
        extra_context['property_upload_url'] = property_upload_url
        return super().change_view(request, object_id, form_url, extra_context=extra_context)


class RedirectAfterCreationMixin:

    def response_add(self, request, obj, post_url_continue=None):
        """
        After adding a new object, redirect to the change form for the new object
        unless the user clicked "Save and add another".
        """
        if "_addanother" not in request.POST:
            request.POST = request.POST.copy()
            request.POST["_continue"] = 1

        return super().response_add(request, obj, post_url_continue)


@admin.register(CollectionAsset)
class CollectionAssetAdmin(AssetUploadAdminMixin, RedirectAfterCreationMixin, admin.ModelAdmin):

    class Media:
        js = ('js/admin/asset_help_search.js',)
        css = {'all': ('style/hover.css',)}

    autocomplete_fields = ['collection']
    search_fields = ['name', 'collection__name']
    readonly_fields = [
        'collection_name',
        'href',
        'is_external',
        'checksum_multihash',
        'created',
        'updated',
        'etag',
        'update_interval',
        'displayed_file_size',
    ]
    list_display = ['name', 'collection_name', 'collection_published']
    fieldsets = (
        (None, {
            'fields': ('name', 'collection', 'created', 'updated', 'etag')
        }),
        (
            'File',
            {
                'fields': (
                    'media_type',
                    'href',
                    'checksum_multihash',
                    'update_interval',
                    'displayed_file_size'
                )
            }
        ),
        ('Description', {
            'fields': ('title', 'description', 'roles')
        }),
        ('Attributes', {
            'fields': ['proj_epsg']
        }),
    )

    list_filter = [AutocompleteFilterFactory('Collection name', 'collection', use_pk_exact=True)]

    def get_readonly_fields(self, request, obj=None):
        # If the object is not None it means that is an update action
        if obj:
            # Don't allow to modify Asset name and media type, because they are tightly coupled
            # with the asset data file. Changing them require to re-upload the data.
            return self.readonly_fields + ['name', 'media_type']
        return self.readonly_fields

    def get_search_results(self, request, queryset, search_term):
        queryset, use_distinct = super().get_search_results(request, queryset, search_term)
        if search_term.startswith('"') and search_term.endswith('"'):
            search_terms = search_term.strip('"').split('/', maxsplit=2)
            if len(search_terms) == 2:
                collection_name = search_terms[0]
                asset_name = search_terms[1]
            else:
                collection_name = None
                asset_name = search_terms[0]
            queryset |= self.model.objects.filter(name__exact=asset_name)
            if collection_name:
                queryset &= self.model.objects.filter(collection__name__exact=collection_name)
        return queryset, use_distinct

    def collection_published(self, instance):
        return instance.collection.published

    collection_published.admin_order_field = 'collection__published'
    collection_published.short_description = 'Published'
    collection_published.boolean = True

    def collection_name(self, instance):
        return instance.collection.name

    collection_name.admin_order_field = 'collection__name'
    collection_name.short_description = 'Collection Id'

    def save_model(self, request, obj, form, change):
        if obj.description == '':
            # The admin interface with TextArea uses empty string instead
            # of None. We use None for empty value, None value are stripped
            # then in the output will empty string not.
            obj.description = None

        super().save_model(request, obj, form, change)

    def href(self, instance):
        if instance.is_external:
            url = instance.file.name
        else:
            url = build_asset_href(self.request, instance.file.name)
        return format_html("<a href='{url}'>{url}</a>", url=url)

    #helper function which displays the bytes in human-readable format
    def displayed_file_size(self, instance):
        return filesizeformat(instance.file_size)

    displayed_file_size.short_description = 'File size'

    # We don't want to move the assets on S3
    # That's why some fields like the name of the asset are set readonly here
    # for update operations
    def get_fieldsets(self, request, obj=None):
        """Build the different field sets for the admin page."""

        # Save the request for use in the href field
        self.request = request  # pylint: disable=attribute-defined-outside-init

        if obj is None:
            return [
                (None, {
                    'fields': ('name', 'collection', 'created', 'updated', 'etag')
                }),
                ('File', {
                    'fields': ('media_type',)
                }),
            ]

        return [
            (None, {
                'fields': ('name', 'collection_name', 'created', 'updated', 'etag')
            }),
            (
                'File',
                {
                    'fields': (
                        'is_external',
                        'media_type',
                        'href',
                        'checksum_multihash',
                        'update_interval',
                        'displayed_file_size'
                    )
                }
            ),
            ('Description', {
                'fields': ('title', 'description', 'roles')
            }),
        ]


class NotUploadedYetFilter(SimpleListFilter):
    """Provide a filter for assets that helps with sorting out invalid items"""

    title = 'Not uploaded yet'
    parameter_name = 'file_size'

    def lookups(self, request, model_admin):
        return [
            ('0', _('Upload in progress')), ('none', _('Not found on s3'))
        ]

    def queryset(self, request, queryset):
        if self.value() == '0':
            return queryset.filter(file_size=0)
        if self.value() == 'none':
            return queryset.filter(file_size=None)
        return queryset


@admin.register(Asset)
class AssetAdmin(AssetUploadAdminMixin, RedirectAfterCreationMixin, admin.ModelAdmin):

    class Media:
        js = ('js/admin/asset_help_search.js',)
        css = {'all': ('style/hover.css',)}

    autocomplete_fields = ['item']
    search_fields = ['name', 'item__name', 'item__collection__name']

    # We don't want to move the assets on S3
    # That's why some fields like the name of the asset are set readonly here
    # for update operations
    readonly_fields = [
        'item_name',
        'collection_name',
        'is_external',
        'href',
        'checksum_multihash',
        'created',
        'updated',
        'etag',
        'update_interval',
        'displayed_file_size',
    ]

    list_display = [
        'name', 'item_name', 'collection_name', 'collection_published', 'created', 'updated'
    ]

    list_filter = [
        AutocompleteFilterFactory('Item name', 'item', use_pk_exact=True),
        AutocompleteFilterFactory('Collection name', 'item__collection', use_pk_exact=True),
        NotUploadedYetFilter
    ]

    def get_readonly_fields(self, request, obj=None):
        # If the object is not None it means that is an update action
        if obj:
            # Don't allow to modify Asset name and media type, because they are tightly coupled
            # with the asset data file. Changing them require to re-upload the data.
            return self.readonly_fields + ['name', 'media_type']
        return self.readonly_fields

    def get_search_results(self, request, queryset, search_term):
        queryset, use_distinct = super().get_search_results(request, queryset, search_term)
        if search_term.startswith('"') and search_term.endswith('"'):
            search_terms = search_term.strip('"').split('/', maxsplit=3)
            if len(search_terms) == 3:
                collection_name = search_terms[0]
                item_name = search_terms[1]
                asset_name = search_terms[2]
            elif len(search_terms) == 2:
                collection_name = None
                item_name = search_terms[0]
                asset_name = search_terms[1]
            else:
                collection_name = None
                item_name = None
                asset_name = search_terms[0]
            queryset |= self.model.objects.filter(name__exact=asset_name)
            if item_name:
                queryset &= self.model.objects.filter(item__name__exact=item_name)
            if collection_name:
                queryset &= self.model.objects.filter(item__collection__name__exact=collection_name)
        return queryset, use_distinct

    def collection_published(self, instance):
        return instance.item.collection.published

    collection_published.admin_order_field = 'item__collection__published'
    collection_published.short_description = 'Published'
    collection_published.boolean = True

    def collection_name(self, instance):
        return instance.item.collection.name

    collection_name.admin_order_field = 'item__collection__name'
    collection_name.short_description = 'Collection Id'

    def item_name(self, instance):
        return instance.item.name

    item_name.admin_order_field = 'item__name'
    item_name.short_description = 'Item Id'

    def save_model(self, request, obj, form, change):
        if obj.description == '':
            # The admin interface with TextArea uses empty string instead
            # of None. We use None for empty value, None value are stripped
            # then in the output will empty string not.
            obj.description = None

        super().save_model(request, obj, form, change)

    def href(self, instance):
        if instance.is_external:
            url = instance.file.name
        else:
            url = build_asset_href(self.request, instance.file.name)
        return format_html("<a href='{url}'>{url}</a>", url=url)

    #helper function which displays the bytes in human-readable format
    def displayed_file_size(self, instance):
        return filesizeformat(instance.file_size)

    displayed_file_size.short_description = 'File size'

    def get_fieldsets(self, request, obj=None):
        """Build the different field sets for the admin page

        The create page takes less fields than the edit page.
        """

        # Save the request for use in the href field
        self.request = request  # pylint: disable=attribute-defined-outside-init

        if obj is None:
            return [
                (None, {
                    'fields': ('name', 'item', 'created', 'updated', 'etag')
                }),
                ('File', {
                    'fields': ('media_type',)
                }),
            ]

        return [
            (
                None, {
                    'fields':
                        ('name', 'item_name', 'collection_name', 'created', 'updated', 'etag')
                }
            ),
            (
                'File',
                {
                    'fields': (
                        'is_external',
                        'media_type',
                        'href',
                        'checksum_multihash',
                        'update_interval',
                        'displayed_file_size'
                    )
                }
            ),
            ('Description', {
                'fields': ('title', 'description', 'roles')
            }),
            (
                'Attributes', {
                    'fields': ('eo_gsd', 'proj_epsg', 'geoadmin_variant', 'geoadmin_lang')
                }
            ),
        ]


@admin.register(AssetUpload)
class AssetUploadAdmin(admin.ModelAdmin):

    autocomplete_fields = ['asset']
    search_fields = [
        'upload_id', 'asset__name', 'asset__item__name', 'asset__item__collection__name', 'status'
    ]
    readonly_fields = [
        'upload_id',
        'asset_name',
        'item_name',
        'collection_name',
        'created',
        'ended',
        'etag',
        'status',
        'urls_json',
        'number_parts',
        'checksum_multihash',
        'update_interval',
        'content_encoding'
    ]
    list_display = [
        'short_upload_id', 'status', 'asset_name', 'item_name', 'collection_name', 'created'
    ]
    fieldsets = (
        (None, {
            'fields': ('upload_id', 'asset_name', 'item_name', 'collection_name', 'status')
        }),
        (
            'Attributes',
            {
                'fields': (
                    'number_parts',
                    'urls_json',
                    'checksum_multihash',
                    'created',
                    'ended',
                    'update_interval',
                    'content_encoding'
                )
            }
        ),
    )

    def has_add_permission(self, request):
        return False

    def has_change_permission(self, request, obj=None):
        return False

    def short_upload_id(self, instance):
        if len(instance.upload_id) > 32:
            return instance.upload_id[:29] + '...'
        return instance.upload_id

    short_upload_id.admin_order_field = 'upload_id'
    short_upload_id.short_description = 'Upload ID'

    def collection_name(self, instance):
        return instance.asset.item.collection.name

    collection_name.admin_order_field = 'asset__item__collection__name'
    collection_name.short_description = 'Collection Id'

    def item_name(self, instance):
        return instance.asset.item.name

    item_name.admin_order_field = 'asset__item__name'
    item_name.short_description = 'Item Id'

    def asset_name(self, instance):
        return instance.asset.name

    asset_name.admin_order_field = 'asset__name'
    asset_name.short_description = 'Asset Id'

    def urls_json(self, instance):
        return json.dumps(instance.urls, indent=1)

    urls_json.short_description = "Urls"

    def delete_view(self, request, object_id, extra_context=None):
        try:
            return super().delete_view(request, object_id, extra_context)
        except ProtectedError:
            msg = "You cannot delete Asset Upload that are in progress"
            self.message_user(request, msg, messages.ERROR)
            opts = self.model._meta
            return_url = reverse(
                f'admin:{opts.app_label}_{opts.model_name}_change',
                args=(object_id,),
                current_app=self.admin_site.name,
            )
            return HttpResponseRedirect(return_url)