Admin view to list uploaded assets (#1960)

* Bugfix: missing required_asset on querystring to enable post to update single asset

* Bugfix: wrong variable name

* Add new view to list uploaded assets

* Admin list view to list all the assets within the same page

* Enable PSF staff to edit uploaded asset information

* Only tries to fetch for file URL if there's an existing file

* Add custom admin list filter by asset type

* Admin list to filter assets by related sponsorship benefits

* Optimize DB queries to display content object

Django does not allow to select related nested FK from generic fks, such
as content_object. Because of that, a lot of collateral queries were being
executed to display the sponsorship name because it depends on both its package
and sponsor names. This commit changes this by filtering all the sponsorships
and organizing it as a in-memory dict that is only load for this page.

* Admin asset list filter by content type (sponsor or sponsorship)

* Asset list filter by with or without value (uploaded asset)

* Admin should prevent user from adding assets

Since assets are created automatically by the process to handle new sponsorship
applications, having the possibility for users to manually add assets can lead
to states that are unknown to the application. This commit prevents that from
happening.

* Minimal working code to return a zipfile as a HTTP response

* Safety check to avoid exporting partial data

* Refactor to check if asset has value

* More helper properties

* Add text assets to the zipfile

* Use temporary files to add images to zipfile

* Use the sponsor name as the directory name within the zipfile

* Unit test action to export assets as a zipfile

* fix AssetsInline class for admin

* register admin views for File/Response assets

Co-authored-by: Ee Durbin <[email protected]>

Author: berinhard

sponsors/admin.py

@@ -1,6 +1,8 @@
 from django.contrib.contenttypes.admin import GenericTabularInline
+from django.contrib.contenttypes.models import ContentType
 from ordered_model.admin import OrderedModelAdmin
-from polymorphic.admin import PolymorphicInlineSupportMixin, StackedPolymorphicInline
+from polymorphic.admin import PolymorphicInlineSupportMixin, StackedPolymorphicInline, PolymorphicParentModelAdmin, \
+    PolymorphicChildModelAdmin
 
 from django.db.models import Subquery
 from django.template import Context, Template
@@ -13,6 +15,7 @@
 
 from mailing.admin import BaseEmailTemplateAdmin
 from sponsors.models import *
+from sponsors.models.benefits import RequiredAssetMixin
 from sponsors import views_admin
 from sponsors.forms import SponsorshipReviewAdminForm, SponsorBenefitAdminInlineForm, RequiredImgAssetConfigurationForm, \
     SponsorshipBenefitAdminForm
@@ -26,14 +29,16 @@ class AssetsInline(GenericTabularInline):
     has_delete_permission = lambda self, request, obj: False
     readonly_fields = ["internal_name", "user_submitted_info", "value"]
 
-    def value(self, request, obj=None):
+    def value(self, obj=None):
         if not obj or not obj.value:
             return ""
         return obj.value
+
     value.short_description = "Submitted information"
 
-    def user_submitted_info(self, request, obj=None):
-        return bool(self.value(request, obj))
+    def user_submitted_info(self, obj=None):
+        return bool(self.value(obj))
+
     user_submitted_info.short_description = "Fullfilled data?"
     user_submitted_info.boolean = True
 
@@ -348,6 +353,7 @@ def get_queryset(self, *args, **kwargs):
 
     def send_notifications(self, request, queryset):
         return views_admin.send_sponsorship_notifications_action(self, request, queryset)
+
     send_notifications.short_description = 'Send notifications to selected'
 
     def get_readonly_fields(self, request, obj):
@@ -431,6 +437,11 @@ def get_urls(self):
                 self.admin_site.admin_view(self.rollback_to_editing_view),
                 name="sponsors_sponsorship_rollback_to_edit",
             ),
+            path(
+                "<int:pk>/list-assets",
+                self.admin_site.admin_view(self.list_uploaded_assets_view),
+                name="sponsors_sponsorship_list_uploaded_assets",
+            ),
         ]
         return my_urls + urls
 
@@ -551,6 +562,9 @@ def approve_sponsorship_view(self, request, pk):
     def approve_signed_sponsorship_view(self, request, pk):
         return views_admin.approve_signed_sponsorship_view(self, request, pk)
 
+    def list_uploaded_assets_view(self, request, pk):
+        return views_admin.list_uploaded_assets(self, request, pk)
+
 
 @admin.register(LegalClause)
 class LegalClauseModelAdmin(OrderedModelAdmin):
@@ -714,9 +728,178 @@ def nullify_contract_view(self, request, pk):
 
 @admin.register(SponsorEmailNotificationTemplate)
 class SponsorEmailNotificationTemplateAdmin(BaseEmailTemplateAdmin):
+
     def get_form(self, request, obj=None, **kwargs):
         help_texts = {
             "content": SPONSOR_TEMPLATE_HELP_TEXT,
         }
         kwargs.update({"help_texts": help_texts})
         return super().get_form(request, obj, **kwargs)
+
+
+class AssetTypeListFilter(admin.SimpleListFilter):
+    title = "Asset Type"
+    parameter_name = 'type'
+
+    @property
+    def assets_types_mapping(self):
+        return {asset_type.__name__: asset_type for asset_type in GenericAsset.all_asset_types()}
+
+    def lookups(self, request, model_admin):
+        return [(k, v._meta.verbose_name_plural) for k, v in self.assets_types_mapping.items()]
+
+    def queryset(self, request, queryset):
+        asset_type = self.assets_types_mapping.get(self.value())
+        if not asset_type:
+            return queryset
+        return queryset.instance_of(asset_type)
+
+
+class AssociatedBenefitListFilter(admin.SimpleListFilter):
+    title = "From Benefit Which Requires Asset"
+    parameter_name = 'from_benefit'
+
+    @property
+    def benefits_with_assets(self):
+        qs = BenefitFeature.objects.required_assets().values_list("sponsor_benefit__sponsorship_benefit",
+                                                                  flat=True).distinct()
+        benefits = SponsorshipBenefit.objects.filter(id__in=Subquery(qs))
+        return {str(b.id): b for b in benefits}
+
+    def lookups(self, request, model_admin):
+        return [(k, b.name) for k, b in self.benefits_with_assets.items()]
+
+    def queryset(self, request, queryset):
+        benefit = self.benefits_with_assets.get(self.value())
+        if not benefit:
+            return queryset
+        internal_names = [
+            cfg.internal_name
+            for cfg in benefit.features_config.all()
+            if hasattr(cfg, "internal_name")
+        ]
+        return queryset.filter(internal_name__in=internal_names)
+
+
+class AssetContentTypeFilter(admin.SimpleListFilter):
+    title = "Related Object"
+    parameter_name = 'content_type'
+
+    def lookups(self, request, model_admin):
+        qs = ContentType.objects.filter(model__in=["sponsorship", "sponsor"])
+        return [(c_type.pk, c_type.model.title()) for c_type in qs]
+
+    def queryset(self, request, queryset):
+        value = self.value()
+        if not value:
+            return queryset
+        return queryset.filter(content_type=value)
+
+
+class AssetWithOrWithoutValueFilter(admin.SimpleListFilter):
+    title = "Value"
+    parameter_name = "value"
+
+    def lookups(self, request, model_admin):
+        return [
+            ("with-value", "With value"),
+            ("no-value", "Without value"),
+        ]
+
+    def queryset(self, request, queryset):
+        value = self.value()
+        if not value:
+            return queryset
+        with_value_id = [asset.pk for asset in queryset if asset.value]
+        if value == "with-value":
+            return queryset.filter(pk__in=with_value_id)
+        else:
+            return queryset.exclude(pk__in=with_value_id)
+
+
+@admin.register(GenericAsset)
+class GenericAssetModelAdmin(PolymorphicParentModelAdmin):
+    list_display = ["id", "internal_name", "get_value", "content_type", "get_related_object"]
+    list_filter = [AssetContentTypeFilter, AssetTypeListFilter, AssetWithOrWithoutValueFilter,
+                   AssociatedBenefitListFilter]
+    actions = ["export_assets_as_zipfile"]
+
+    def get_child_models(self, *args, **kwargs):
+        return GenericAsset.all_asset_types()
+
+    def get_queryset(self, *args, **kwargs):
+        classes = self.get_child_models(*args, **kwargs)
+        return self.model.objects.select_related("content_type").instance_of(*classes)
+
+    def has_delete_permission(self, *args, **kwargs):
+        return False
+
+    def has_add_permission(self, *args, **kwargs):
+        return False
+
+    @cached_property
+    def all_sponsors(self):
+        qs = Sponsor.objects.all()
+        return {sp.id: sp for sp in qs}
+
+    @cached_property
+    def all_sponsorships(self):
+        qs = Sponsorship.objects.all().select_related("package", "sponsor")
+        return {sp.id: sp for sp in qs}
+
+    def get_value(self, obj):
+        html = obj.value
+        if obj.value and getattr(obj.value, "url", None):
+            html = f"<a href='{obj.value.url}' target='_blank'>{obj.value}</a>"
+        return mark_safe(html)
+
+    get_value.short_description = "Value"
+
+    def get_related_object(self, obj):
+        """
+        Returns the content_object as an URL and performs better because
+        of sponsors and sponsorship cached properties
+        """
+        content_object = None
+        if obj.from_sponsorship:
+            content_object = self.all_sponsorships[obj.object_id]
+        elif obj.from_sponsor:
+            content_object = self.all_sponsors[obj.object_id]
+
+        if not content_object:  # safety belt
+            return obj.content_object
+
+        html = f"<a href='{content_object.admin_url}' target='_blank'>{content_object}</a>"
+        return mark_safe(html)
+
+    get_related_object.short_description = "Associated with"
+
+    def export_assets_as_zipfile(self, request, queryset):
+        return views_admin.export_assets_as_zipfile(self, request, queryset)
+    export_assets_as_zipfile.short_description = "Export selected"
+
+
+class GenericAssetChildModelAdmin(PolymorphicChildModelAdmin):
+    """ Base admin class for all GenericAsset child models """
+    base_model = GenericAsset
+    readonly_fields = ["uuid", "content_type", "object_id", "content_object", "internal_name"]
+
+
+@admin.register(TextAsset)
+class TextAssetModelAdmin(GenericAssetChildModelAdmin):
+    base_model = TextAsset
+
+
+@admin.register(ImgAsset)
+class ImgAssetModelAdmin(GenericAssetChildModelAdmin):
+    base_model = ImgAsset
+
+
+@admin.register(FileAsset)
+class ImgAssetModelAdmin(GenericAssetChildModelAdmin):
+    base_model = FileAsset
+
+
+@admin.register(ResponseAsset)
+class ResponseAssetModelAdmin(GenericAssetChildModelAdmin):
+    base_model = ResponseAsset

sponsors/models/__init__.py

@@ -4,7 +4,7 @@
 structured as a python package.
 """
 
-from .assets import GenericAsset, ImgAsset, TextAsset
+from .assets import GenericAsset, ImgAsset, TextAsset, FileAsset, ResponseAsset
 from .notifications import SponsorEmailNotificationTemplate, SPONSOR_TEMPLATE_HELP_TEXT
 from .sponsors import Sponsor, SponsorContact, SponsorBenefit
 from .benefits import BaseLogoPlacement, BaseTieredQuantity, BaseEmailTargetable, BenefitFeatureConfiguration, \

sponsors/models/assets.py

@@ -9,6 +9,7 @@
 from django.db import models
 from django.contrib.contenttypes.fields import GenericForeignKey
 from django.contrib.contenttypes.models import ContentType
+from django.db.models.fields.files import ImageFieldFile, FileField
 from polymorphic.models import PolymorphicModel
 
 
@@ -51,6 +52,29 @@ class Meta:
     def value(self):
         return None
 
+    @property
+    def is_file(self):
+        return isinstance(self.value, FileField) or isinstance(self.value, ImageFieldFile)
+
+    @property
+    def from_sponsorship(self):
+        return self.content_type.name == "sponsorship"
+
+    @property
+    def from_sponsor(self):
+        return self.content_type.name == "sponsor"
+
+    @property
+    def has_value(self):
+        if self.is_file:
+            return self.value and getattr(self.value, "url", None)
+        else:
+            return bool(self.value)
+
+    @classmethod
+    def all_asset_types(cls):
+        return cls.__subclasses__()
+
 
 class ImgAsset(GenericAsset):
     image = models.ImageField(

sponsors/models/sponsors.py

@@ -4,7 +4,7 @@
 from allauth.account.models import EmailAddress
 from django.conf import settings
 from django.db import models
-from django.core.exceptions import ObjectDoesNotExist
+from django.urls import reverse
 from django_countries.fields import CountryField
 from ordered_model.models import OrderedModel
 from django.contrib.contenttypes.fields import GenericRelation
@@ -102,6 +102,10 @@ def primary_contact(self):
         except SponsorContact.DoesNotExist:
             return None
 
+    @property
+    def admin_url(self):
+        return reverse("admin:sponsors_sponsor_change", args=[self.pk])
+
 
 class SponsorContact(models.Model):
     """