Kompleta infrastrukturo por pluraj regularoj

core/admin/__init__.py

@@ -0,0 +1,2 @@
+# flake8:noqa
+from .admin import *

core/admin/admin.py

@@ -0,0 +1,189 @@
+from typing import cast
+
+from django.contrib import admin
+from django.contrib.flatpages.admin import FlatPageAdmin
+from django.contrib.flatpages.models import FlatPage
+from django.core.cache import cache
+from django.db import models
+from django.urls import reverse
+from django.utils.html import format_html
+from django.utils.translation import gettext_lazy as _
+
+from djangocodemirror.widgets import CodeMirrorAdminWidget
+from packvers import version
+from solo.admin import SingletonModelAdmin
+
+from hosting.models import Profile
+
+from ..models import Agreement, Policy, SiteConfiguration, UserBrowser
+from .filters import DependentFieldFilter, YearBracketFilter
+
+admin.site.index_template = 'admin/custom_index.html'
+admin.site.disable_action('delete_selected')
+
+admin.site.register(SiteConfiguration, SingletonModelAdmin)
+admin.site.unregister(FlatPage)
+
+
+@admin.register(FlatPage)
+class FlatPageAdmin(FlatPageAdmin):
+    formfield_overrides = {
+        models.TextField: {'widget': CodeMirrorAdminWidget(config_name='html')},
+    }
+
+
+@admin.register(Policy)
+class PolicyAdmin(admin.ModelAdmin):
+    list_display = (
+        'version', 'effective_date', 'requires_consent',
+    )
+    ordering = ('-effective_date', )
+    formfield_overrides = {
+        models.TextField: {'widget': CodeMirrorAdminWidget(config_name='html')},
+    }
+
+    def has_delete_permission(self, request, obj=None):
+        return False
+
+    def save_model(self, request, obj, form, change):
+        super().save_model(request, obj, form, change)
+        if 'version' in form.changed_data or 'effective_date' in form.changed_data:
+            # Bust the cache of references to all policies;
+            # these references are cached indefinitely otherwise.
+            cache.delete('all-policies')
+
+
+@admin.register(Agreement)
+class AgreementAdmin(admin.ModelAdmin):
+    list_display = (
+        'id', 'policy_link', 'user_link', 'created', 'modified', 'withdrawn',
+    )
+    ordering = ('-policy_version', '-modified', 'user__username')
+    search_fields = ('user__username',)
+    list_filter = ('policy_version',)
+    date_hierarchy = 'created'
+    fields = (
+        'user_link', 'policy_link',
+        'created', 'modified', 'withdrawn',
+    )
+    readonly_fields = [f.name for f in Agreement._meta.fields] + ['user_link', 'policy_link']
+
+    @admin.display(
+        description=_("user"),
+        ordering='user__username',
+    )
+    def user_link(self, obj: Agreement):
+        try:
+            link = reverse('admin:auth_user_change', args=[obj.user.pk])
+            account_link = f'<a href="{link}">{obj.user}</a>'
+            try:
+                profile_link = '&nbsp;(<a href="{url}">{name}</a>)</sup>'.format(
+                    url=obj.user.profile.get_admin_url(), name=_("profile"))
+            except Profile.DoesNotExist:
+                profile_link = ''
+            return format_html(" ".join([account_link, profile_link]))
+        except AttributeError:
+            return format_html('{userid} <sup>?</sup>', userid=obj.user_id)
+
+    @admin.display(
+        description=_("version of policy"),
+        ordering='policy_version',
+    )
+    def policy_link(self, obj: Agreement):
+        try:
+            cache = self._policies_cache
+        except AttributeError:
+            cache = self._policies_cache = {}
+        if obj.policy_version in cache:
+            return cache[obj.policy_version]
+        value = obj.policy_version
+        try:
+            policy = Policy.objects.get(version=obj.policy_version)
+            link = reverse('admin:core_policy_change', args=[policy.pk])
+            value = format_html(
+                '<a href="{url}">{policy}</a>',
+                url=link, policy=obj.policy_version)
+        except Policy.DoesNotExist:
+            pass
+        finally:
+            cache[obj.policy_version] = value
+        return value
+
+    def get_queryset(self, request):
+        qs = super().get_queryset(request).select_related('user', 'user__profile')
+        qs = qs.only(
+                *[f.name for f in Agreement._meta.fields],
+                'user__id', 'user__username', 'user__profile__id')
+        return qs
+
+    def has_add_permission(self, request):
+        return False
+
+    def has_change_permission(self, request, obj=None):
+        return False
+
+
+@admin.register(UserBrowser)
+class UserBrowserAdmin(admin.ModelAdmin):
+    list_display = (
+        'user', 'os_name', 'os_version', 'browser_name', 'browser_version', 'added_on',
+    )
+    ordering = ('user__username', '-added_on')
+    search_fields = ('user__username__exact',)
+    list_filter = (
+        'os_name',
+        DependentFieldFilter.configure(
+            'os_name', 'os_version',
+            coerce=lambda version_string: version.parse(version_string),
+            sort=True, sort_reverse=True,
+        ),
+        'browser_name',
+        DependentFieldFilter.configure(
+            'browser_name', 'browser_version',
+            coerce=lambda version_string: version.parse(version_string),
+            sort=True, sort_reverse=True,
+        ),
+        ('added_on', YearBracketFilter.configure(YearBracketFilter.Brackets.SINCE)),
+    )
+    show_full_result_count = False
+    fields = (
+        'user_agent_string', 'user_agent_hash',
+        'os_name', 'os_version', 'browser_name', 'browser_version', 'device_type',
+        'geolocation',
+    )
+    raw_id_fields = ('user',)
+    readonly_fields = ('added_on',)
+
+    @admin.display(
+        description=_("user"),
+        ordering='user__username',
+    )
+    def user_link(self, obj: UserBrowser):
+        try:
+            link = reverse('admin:auth_user_change', args=[obj.user.pk])
+            return format_html('<a href="{link}">{user}</a>', link=link, user=obj.user)
+        except AttributeError:
+            return format_html('{userid} <sup>?</sup>', userid=obj.user_id)
+
+    def get_queryset(self, request):
+        qs = super().get_queryset(request).select_related('user')
+        qs = qs.only(
+                *[f.name for f in UserBrowser._meta.fields],
+                'user__id', 'user__username')
+        return qs
+
+    def get_fields(self, request, obj=None):
+        return (
+            ('user' if obj is None else 'user_link',)
+            + cast(tuple, self.fields)
+            + (('added_on',) if obj is not None else ())
+        )
+
+    def has_change_permission(self, request, obj=None):
+        return False
+
+    def get_form(self, request, *args, **kwargs):
+        form = super().get_form(request, *args, **kwargs)
+        if form.base_fields:
+            form.base_fields['user_agent_string'].widget.attrs['style'] = "width: 50em;"
+        return form

core/admin/filters.py

@@ -0,0 +1,154 @@
+from enum import Enum
+from typing import Callable, Optional, TypedDict, cast
+
+from django.contrib import admin
+from django.db.models import Model, QuerySet
+from django.http import HttpRequest
+from django.utils.functional import lazy
+from django.utils.translation import gettext_lazy as _
+
+
+class YearBracketFilter(admin.DateFieldListFilter):
+    class Brackets(str, Enum):
+        EXACT = 'exact'
+        SINCE = 'since'
+        UNTIL = 'until'
+
+    @classmethod
+    def configure(cls, bracket=Brackets.EXACT):
+        if bracket not in (cls.Brackets.SINCE, cls.Brackets.UNTIL):
+            bracket = cls.Brackets.EXACT
+        return type(
+            f'YearBracket{bracket.capitalize()}Filter',
+            (cls,),
+            {
+                'bracket': bracket,
+            }
+        )
+
+    def __init__(self, field, request, params, model, model_admin, field_path):
+        original_field_path = field_path
+        field_path = f'{field_path}__year'
+        super().__init__(field, request, params, model, model_admin, field_path)
+        qs = (
+            model_admin
+            .get_queryset(request)
+            .select_related(None)
+            .order_by(f'-{original_field_path}')
+            .only(field_path)
+        )
+        qs.query.annotations.clear()
+        all_years = list(dict.fromkeys(qs.values_list(field_path, flat=True)))
+        if not hasattr(self, 'bracket'):
+            self.bracket = self.Brackets.EXACT
+        self.links = (
+            (_('Any year'), {}),
+        )
+        lookup_kwarg = ''
+        if self.bracket is self.Brackets.SINCE:
+            label_string = _("from %(date)s")
+            self.lookup_kwarg_since = self.field_generic + 'gte'
+            lookup_kwarg = self.lookup_kwarg_since
+        if self.bracket is self.Brackets.UNTIL:
+            label_string = _("until %(date)s")
+            self.lookup_kwarg_until = self.field_generic + 'lte'
+            lookup_kwarg = self.lookup_kwarg_until
+        if self.bracket is self.Brackets.EXACT:
+            self.links += tuple(
+                (str(year), {
+                    self.lookup_kwarg_since: str(year),
+                    self.lookup_kwarg_until: str(year + 1),
+                })
+                for year in all_years if year is not None
+            )
+        else:
+            def label(year):
+                return lazy(
+                    lambda date=year: (label_string % {'date': date}).capitalize(),
+                    str)
+            self.links += tuple(
+                (label(year), {lookup_kwarg: str(year)})
+                for year in all_years if year is not None
+            )
+        if field.null:
+            self.links += (
+                (_('No date'), {self.lookup_kwarg_isnull: str(True)}),
+                (_('Has date'), {self.lookup_kwarg_isnull: str(False)}),
+            )
+
+
+class DependentFieldFilter(admin.SimpleListFilter):
+    origin_field: str
+    related_field: str
+    parameter_name: str
+    coerce_value: Callable
+    SortConfig = TypedDict('SortConfig', {'enabled': bool, 'reverse': bool})
+    sorting: SortConfig
+
+    @classmethod
+    def configure(
+            cls,
+            field: str,
+            related_field: str,
+            coerce: Optional[Callable] = None,
+            sort: bool = False,
+            sort_reverse: Optional[bool] = None,
+    ):
+        if coerce is None or not callable(coerce):
+            coerce = lambda v: v
+        return type(
+            ''.join(related_field.split('_')).capitalize()
+            + 'Per' + ''.join(field.split('_')).capitalize()
+            + 'Filter',
+            (cls,),
+            {
+                'origin_field': field,
+                'related_field': related_field,
+                'parameter_name': related_field,
+                'coerce_value': lambda filter, value: coerce(value),
+                'sorting': {
+                    'enabled': bool(sort),
+                    'reverse': bool(sort_reverse),
+                },
+            }
+        )
+
+    def lookups(self, request: HttpRequest, model_admin: admin.ModelAdmin):
+        qs = (
+            cast(type[Model], model_admin.model)._default_manager.all()
+            .filter(**{self.origin_field: self.dependent_on_value})
+        )
+        all_values = map(
+            self.coerce_value,
+            qs.values_list(self.related_field, flat=True).distinct())
+        if self.sorting['enabled']:
+            all_values = sorted(all_values, reverse=self.sorting['reverse'])
+        for val in all_values:
+            yield (val, str(val))
+
+    def has_output(self):
+        return bool(self.dependent_on_value)
+
+    def value(self):
+        val = self.used_parameters.get(self.parameter_name)
+        if val in (ch[0] for ch in self.lookup_choices):
+            return val
+        else:
+            return None
+
+    def queryset(self, request: HttpRequest, queryset: QuerySet):
+        if self.value():
+            return queryset.filter(**{self.parameter_name: self.value()})
+        else:
+            return queryset
+
+    def __init__(
+            self,
+            request: HttpRequest,
+            params: dict[str, str],
+            model: type[Model],
+            model_admin: admin.ModelAdmin,
+    ):
+        self.title = model._meta.get_field(self.related_field).verbose_name
+        self.dependent_on_value = request.GET.get(self.origin_field)
+        super().__init__(request, params, model, model_admin)