wagtail 6.0.2__py3-none-any.whl → 6.1rc1__py3-none-any.whl

wagtail/admin/views/generic/base.py

@@ -16,6 +16,7 @@ from django_filters.filters import (
     DateFromToRangeFilter,
     ModelChoiceFilter,
     ModelMultipleChoiceFilter,
+    MultipleChoiceFilter,
 )
 
 from wagtail.admin import messages
@@ -93,7 +94,6 @@ class WagtailAdminTemplateMixin(TemplateResponseMixin, ContextMixin):
         if self._show_breadcrumbs:
             context["breadcrumbs_items"] = self.get_breadcrumbs_items()
             context["header_buttons"] = self.get_header_buttons()
-            context["header_more_buttons"] = self.get_header_more_buttons()
         return context
 
     def get_template_names(self):
@@ -120,13 +120,16 @@ class BaseObjectMixin:
     def get_pk(self):
         return unquote(str(self.kwargs[self.pk_url_kwarg]))
 
+    def get_base_object_queryset(self):
+        return self.model._default_manager.all()
+
     def get_object(self):
         if not self.model:
             raise ImproperlyConfigured(
                 "Subclasses of wagtail.admin.views.generic.base.BaseObjectMixin must provide a "
                 "model attribute or a get_object method"
             )
-        return get_object_or_404(self.model, pk=self.pk)
+        return get_object_or_404(self.get_base_object_queryset(), pk=self.pk)
 
 
 class BaseOperationView(BaseObjectMixin, View):
@@ -201,7 +204,7 @@ class BaseListingView(WagtailAdminTemplateMixin, BaseListView):
     @cached_property
     def filters(self):
         if self.filterset_class:
-            filterset = self.filterset_class(self.request.GET, request=self.request)
+            filterset = self.filterset_class(**self.get_filterset_kwargs())
             # Don't use the filterset if it has no fields
             if filterset.form.fields:
                 return filterset
@@ -213,6 +216,12 @@ class BaseListingView(WagtailAdminTemplateMixin, BaseListView):
             self.filters and self.filters.is_valid() and self.filters.form.has_changed()
         )
 
+    def get_filterset_kwargs(self):
+        return {
+            "data": self.request.GET,
+            "request": self.request,
+        }
+
     def filter_queryset(self, queryset):
         if self.filters and self.filters.is_valid():
             queryset = self.filters.filter_queryset(queryset)
@@ -262,6 +271,9 @@ class BaseListingView(WagtailAdminTemplateMixin, BaseListView):
             except KeyError:
                 continue  # invalid filter value
 
+            if value == bound_field.initial:
+                continue  # filter value is the same as the default
+
             if isinstance(filter_def, ModelMultipleChoiceFilter):
                 field = filter_def.field
                 for item in value:
@@ -275,6 +287,17 @@ class BaseListingView(WagtailAdminTemplateMixin, BaseListView):
                             ),
                         )
                     )
+            elif isinstance(filter_def, MultipleChoiceFilter):
+                choices = {str(id): label for id, label in filter_def.field.choices}
+                for item in value:
+                    filters.append(
+                        ActiveFilter(
+                            bound_field.auto_id,
+                            filter_def.label,
+                            choices.get(str(item), str(item)),
+                            self.get_url_without_filter_param_value(field_name, item),
+                        )
+                    )
             elif isinstance(filter_def, ModelChoiceFilter):
                 field = filter_def.field
                 filters.append(
@@ -288,13 +311,17 @@ class BaseListingView(WagtailAdminTemplateMixin, BaseListView):
             elif isinstance(filter_def, DateFromToRangeFilter):
                 start_date_display = date_format(value.start) if value.start else ""
                 end_date_display = date_format(value.stop) if value.stop else ""
+                widget = filter_def.field.widget
                 filters.append(
                     ActiveFilter(
                         bound_field.auto_id,
                         filter_def.label,
                         "%s - %s" % (start_date_display, end_date_display),
                         self.get_url_without_filter_param(
-                            [f"{field_name}_before", f"{field_name}_after"]
+                            [
+                                widget.suffixed(field_name, suffix)
+                                for suffix in widget.suffixes
+                            ]
                         ),
                     )
                 )

wagtail/admin/views/generic/history.py

@@ -1,8 +1,9 @@
 from datetime import timedelta
 
 import django_filters
-from django.contrib.admin.utils import quote, unquote
+from django.contrib.admin.utils import quote
 from django.core.paginator import Paginator
+from django.forms import CheckboxSelectMultiple
 from django.shortcuts import get_object_or_404
 from django.urls import reverse
 from django.utils.functional import cached_property
@@ -10,8 +11,13 @@ from django.utils.text import capfirst
 from django.utils.translation import gettext, gettext_lazy
 from django.views.generic import TemplateView
 
-from wagtail.admin.filters import DateRangePickerWidget, WagtailFilterSet
+from wagtail.admin.filters import (
+    DateRangePickerWidget,
+    MultipleUserFilter,
+    WagtailFilterSet,
+)
 from wagtail.admin.ui.tables import Column, DateColumn, InlineActionsTable, UserColumn
+from wagtail.admin.utils import get_latest_str
 from wagtail.admin.views.generic.base import (
     BaseListingView,
     BaseObjectMixin,
@@ -23,90 +29,238 @@ from wagtail.log_actions import registry as log_registry
 from wagtail.models import (
     BaseLogEntry,
     DraftStateMixin,
-    ModelLogEntry,
+    PreviewableMixin,
     Revision,
+    RevisionMixin,
     TaskState,
     WorkflowState,
 )
 
 
-def get_actions_for_filter():
+def get_actions_for_filter(queryset):
     # Only return those actions used by model log entries.
-    actions = set(ModelLogEntry.objects.all().get_actions())
+    actions = set(queryset.get_actions())
     return [action for action in log_registry.get_choices() if action[0] in actions]
 
 
-class HistoryReportFilterSet(WagtailFilterSet):
-    action = django_filters.ChoiceFilter(
+class HistoryFilterSet(WagtailFilterSet):
+    action = django_filters.MultipleChoiceFilter(
         label=gettext_lazy("Action"),
+        widget=CheckboxSelectMultiple,
         # choices are set dynamically in __init__()
     )
-    user = django_filters.ModelChoiceFilter(
+    user = MultipleUserFilter(
         label=gettext_lazy("User"),
-        field_name="user",
-        queryset=lambda request: ModelLogEntry.objects.all().get_users(),
+        widget=CheckboxSelectMultiple,
+        # queryset is set dynamically in __init__()
     )
     timestamp = django_filters.DateFromToRangeFilter(
         label=gettext_lazy("Date"), widget=DateRangePickerWidget
     )
 
-    class Meta:
-        model = ModelLogEntry
-        fields = ["action", "user", "timestamp"]
-
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self.filters["action"].extra["choices"] = get_actions_for_filter()
+        actions = get_actions_for_filter(self.queryset)
+        if not actions:
+            del self.filters["action"]
+        else:
+            self.filters["action"].extra["choices"] = actions
+
+        users = self.queryset.get_users()
+        if not users.exists():
+            del self.filters["user"]
+        else:
+            self.filters["user"].extra["queryset"] = users
+
+
+class ActionColumn(Column):
+    def __init__(self, *args, object, url_names, user_can_unschedule, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.object = object
+        self.url_names = url_names
+        self.user_can_unschedule = user_can_unschedule
+        self.revision_enabled = isinstance(object, RevisionMixin)
+        self.draftstate_enabled = isinstance(object, DraftStateMixin)
+
+    @cached_property
+    def cell_template_name(self):
+        if self.revision_enabled:
+            return "wagtailadmin/generic/history/action_cell.html"
+        return super().cell_template_name
+
+    def get_status(self, instance, parent_context):
+        if self.draftstate_enabled:
+            if (
+                instance.action == "wagtail.publish"
+                and instance.revision_id == self.object.live_revision_id
+            ):
+                return gettext("Live version")
+            elif (
+                instance.content_changed
+                and instance.revision_id == self.object.latest_revision_id
+            ):
+                return gettext("Current draft")
+        return None
+
+    def get_actions(self, instance, parent_context):
+        actions = []
+
+        # Do not show the revision actions if the log entry:
+        # - has no revision attached
+        # - has no content changes
+        # - is a "publish" action
+        #   (because we want to show the options on the "edit" action instead)
+        if (
+            not self.revision_enabled
+            or not instance.revision_id
+            or not instance.content_changed
+            or instance.action == "wagtail.publish"
+        ):
+            return actions
+
+        if (
+            isinstance(self.object, PreviewableMixin)
+            and self.object.is_previewable()
+            and (url_name := self.url_names.get("revisions_view"))
+        ):
+            url = reverse(url_name, args=(quote(self.object.pk), instance.revision_id))
+            action = {"url": url, "label": gettext("Preview")}
+            actions.append(action)
+
+        if instance.revision_id == self.object.latest_revision_id:
+            if url_name := self.url_names.get("edit"):
+                url = reverse(url_name, args=(quote(self.object.pk),))
+                action = {"url": url, "label": gettext("Edit")}
+                actions.append(action)
+        elif url_name := self.url_names.get("revisions_revert"):
+            url = reverse(url_name, args=(quote(self.object.pk), instance.revision_id))
+            action = {"url": url, "label": gettext("Review this version")}
+            actions.append(action)
+
+        if url_name := self.url_names.get("revisions_compare"):
+            if instance.previous_revision_id:
+                url = reverse(
+                    url_name,
+                    args=(
+                        quote(self.object.pk),
+                        instance.previous_revision_id,
+                        instance.revision_id,
+                    ),
+                )
+                action = {"url": url, "label": gettext("Compare with previous version")}
+                actions.append(action)
+            if instance.revision_id != self.object.latest_revision_id:
+                url = reverse(
+                    url_name,
+                    args=(quote(self.object.pk), instance.revision_id, "latest"),
+                )
+                action = {"url": url, "label": gettext("Compare with current version")}
+                actions.append(action)
+
+        if (
+            (url_name := self.url_names.get("revisions_unschedule"))
+            and instance.revision.approved_go_live_at
+            and self.user_can_unschedule
+        ):
+            url = reverse(url_name, args=(quote(self.object.pk), instance.revision_id))
+            action = {"url": url, "label": gettext("Cancel scheduled publish")}
+            actions.append(action)
+
+        return actions
+
+    def get_cell_context_data(self, instance, parent_context):
+        context = super().get_cell_context_data(instance, parent_context)
+        context["status"] = self.get_status(instance, parent_context)
+        context["actions"] = self.get_actions(instance, parent_context)
+        return context
 
 
-class HistoryView(PermissionCheckedMixin, BaseListingView):
+class LogEntryUserColumn(UserColumn):
+    def __init__(self, name, **kwargs):
+        # Instead of accepting a blank_display_name arg, we'll make use of the
+        # BaseLogEntry.user_display_name property which also handles the display
+        # name for a deleted user (as the BaseLogEntry still stores the ID).
+        super().__init__(name, blank_display_name=None, **kwargs)
+
+    def get_cell_context_data(self, instance, parent_context):
+        context = super().get_cell_context_data(instance, parent_context)
+        if not context["display_name"]:
+            context["display_name"] = instance.user_display_name
+        return context
+
+
+class HistoryView(PermissionCheckedMixin, BaseObjectMixin, BaseListingView):
     any_permission_required = ["add", "change", "delete"]
     page_title = gettext_lazy("History")
     results_template_name = "wagtailadmin/generic/history_results.html"
-    history_url_name = None
-    history_results_url_name = None
     header_icon = "history"
     is_searchable = False
     paginate_by = 20
-    filterset_class = HistoryReportFilterSet
+    filterset_class = HistoryFilterSet
     table_class = InlineActionsTable
-    columns = [
-        Column("message", label=gettext_lazy("Action")),
-        UserColumn("user", blank_display_name="system"),
-        DateColumn("timestamp", label=gettext_lazy("Date")),
-    ]
+    history_url_name = None
+    history_results_url_name = None
     edit_url_name = None
+    revisions_view_url_name = None
+    revisions_revert_url_name = None
+    revisions_compare_url_name = None
+    revisions_unschedule_url_name = None
 
-    def setup(self, request, *args, pk, **kwargs):
-        self.pk = pk
-        self.object = self.get_object()
-        super().setup(request, *args, **kwargs)
+    @cached_property
+    def columns(self):
+        return [
+            ActionColumn(
+                "message",
+                label=gettext_lazy("Action"),
+                object=self.object,
+                url_names={
+                    "edit": self.edit_url_name,
+                    "revisions_view": self.revisions_view_url_name,
+                    "revisions_revert": self.revisions_revert_url_name,
+                    "revisions_compare": self.revisions_compare_url_name,
+                    "revisions_unschedule": self.revisions_unschedule_url_name,
+                },
+                user_can_unschedule=self.user_can_unschedule(),
+            ),
+            LogEntryUserColumn("user", width="25%"),
+            DateColumn("timestamp", label=gettext_lazy("Date"), width="15%"),
+        ]
 
-    def get_object(self):
-        object = get_object_or_404(self.model, pk=unquote(self.pk))
-        if isinstance(object, DraftStateMixin):
-            return object.get_latest_revision_as_object()
-        return object
+    def get_base_object_queryset(self):
+        queryset = super().get_base_object_queryset()
+        if issubclass(queryset.model, RevisionMixin):
+            return queryset.select_related("latest_revision")
+        return queryset
 
     def get_page_subtitle(self):
-        return str(self.object)
+        return get_latest_str(self.object)
 
     def get_breadcrumbs_items(self):
-        return self.breadcrumbs_items + [
-            {
-                "url": reverse(self.index_url_name),
-                "label": capfirst(self.model._meta.verbose_name_plural),
-            },
-            {
-                "url": self.get_edit_url(self.object),
-                "label": str(self.object),
-            },
+        items = []
+        if self.index_url_name:
+            items.append(
+                {
+                    "url": reverse(self.index_url_name),
+                    "label": capfirst(self.model._meta.verbose_name_plural),
+                }
+            )
+        edit_url = self.get_edit_url(self.object)
+        obj_name = self.get_page_subtitle()
+        if edit_url:
+            items.append(
+                {
+                    "url": edit_url,
+                    "label": obj_name,
+                }
+            )
+        items.append(
             {
                 "url": "",
                 "label": gettext("History"),
-                "sublabel": self.get_page_subtitle(),
-            },
-        ]
+                "sublabel": obj_name,
+            }
+        )
+        return self.breadcrumbs_items + items
 
     @cached_property
     def header_buttons(self):
@@ -136,19 +290,34 @@ class HistoryView(PermissionCheckedMixin, BaseListingView):
     def get_index_results_url(self):
         return self.get_history_results_url(self.object)
 
+    def user_can_unschedule(self):
+        return self.user_has_permission("publish")
+
     def get_context_data(self, *args, object_list=None, **kwargs):
         context = super().get_context_data(*args, object_list=object_list, **kwargs)
         context["object"] = self.object
         context["model_opts"] = BaseLogEntry._meta
         return context
 
-    def get_queryset(self):
-        queryset = log_registry.get_logs_for_instance(self.object).select_related(
-            "revision", "user", "user__wagtail_userprofile"
-        )
-        queryset = self.filter_queryset(queryset)
+    def get_base_queryset(self):
+        queryset = log_registry.get_logs_for_instance(self.object)
+        return self._annotate_queryset(queryset)
+
+    def _annotate_queryset(self, queryset):
+        queryset = queryset.select_related("user", "user__wagtail_userprofile")
+        if isinstance(self.object, RevisionMixin):
+            queryset = queryset.select_related("revision").annotate(
+                previous_revision_id=Revision.objects.previous_revision_id_subquery(),
+            )
         return queryset
 
+    def get_filterset_kwargs(self):
+        # Pass custom queryset so the FilterSet can use it when initialising the
+        # filters, instead of using the default model.objects.all() queryset.
+        kwargs = super().get_filterset_kwargs()
+        kwargs["queryset"] = self.get_base_queryset()
+        return kwargs
+
 
 class WorkflowHistoryView(BaseObjectMixin, WagtailAdminTemplateMixin, TemplateView):
     template_name = "wagtailadmin/shared/workflow_history/index.html"

wagtail/admin/views/generic/mixins.py

@@ -101,10 +101,13 @@ class BeforeAfterHookMixin(HookResponseMixin):
 
 
 class LocaleMixin:
-    def setup(self, request, *args, **kwargs):
-        super().setup(request, *args, **kwargs)
-        self.locale = self.get_locale()
-        self.translations = self.get_translations() if self.locale else []
+    @cached_property
+    def locale(self):
+        return self.get_locale()
+
+    @cached_property
+    def translations(self):
+        return self.get_translations() if self.locale else []
 
     def get_locale(self):
         if not getattr(self, "model", None):

wagtail/admin/views/generic/models.py

@@ -9,6 +9,7 @@ from django.core.exceptions import (
 )
 from django.db import models, transaction
 from django.db.models import Q
+from django.db.models.constants import LOOKUP_SEP
 from django.db.models.functions import Cast
 from django.http import Http404, HttpResponseRedirect
 from django.shortcuts import get_object_or_404, redirect
@@ -41,7 +42,6 @@ from wagtail.admin.ui.tables import (
 from wagtail.admin.utils import get_latest_str, get_valid_next_url_from_request
 from wagtail.admin.views.mixins import SpreadsheetExportMixin
 from wagtail.admin.widgets.button import (
-    Button,
     ButtonWithDropdown,
     HeaderButton,
     ListingButton,
@@ -233,7 +233,7 @@ class IndexView(
             query |= Q(**{field + "__icontains": self.search_query})
         return queryset.filter(query)
 
-    def _get_title_column(self, field_name, column_class=TitleColumn, **kwargs):
+    def _get_title_column_class(self, column_class):
         if not issubclass(column_class, ButtonsColumnMixin):
 
             def get_buttons(column, instance, *args, **kwargs):
@@ -244,6 +244,10 @@ class IndexView(
                 (ButtonsColumnMixin, column_class),
                 {"get_buttons": get_buttons},
             )
+        return column_class
+
+    def _get_title_column(self, field_name, column_class=TitleColumn, **kwargs):
+        column_class = self._get_title_column_class(column_class)
         if not self.model:
             return column_class(
                 "name",
@@ -256,7 +260,32 @@ class IndexView(
         )
 
     def _get_custom_column(self, field_name, column_class=Column, **kwargs):
-        label, attr = label_for_field(field_name, self.model, return_attr=True)
+        lookups = (
+            [field_name]
+            if hasattr(self.model, field_name)
+            else field_name.split(LOOKUP_SEP)
+        )
+        *relations, field = lookups
+        model_class = self.model
+
+        # Iterate over the relation list to try to get the last model
+        # where the field exists
+        foreign_field_name = ""
+        for model in relations:
+            foreign_field = model_class._meta.get_field(model)
+            foreign_field_name = foreign_field.verbose_name
+            model_class = foreign_field.related_model
+
+        label, attr = label_for_field(field, model_class, return_attr=True)
+
+        # For some languages, it may be more appropriate to put the field label
+        # before the related model name
+        if foreign_field_name:
+            label = _("%(related_model_name)s %(field_label)s") % {
+                "related_model_name": foreign_field_name,
+                "field_label": label,
+            }
+
         sort_key = getattr(attr, "admin_order_field", None)
 
         # attr is None if the field is an actual database field,
@@ -264,8 +293,12 @@ class IndexView(
         if attr is None:
             sort_key = field_name
 
+        accessor = field_name
+        # Build the dotted relation if needed, for use in multigetattr
+        if relations:
+            accessor = ".".join(lookups)
         return column_class(
-            field_name,
+            accessor,
             label=capfirst(label),
             sort_key=sort_key,
             **kwargs,
@@ -338,29 +371,6 @@ class IndexView(
             )
         return buttons
 
-    @cached_property
-    def header_more_buttons(self):
-        buttons = []
-        if self.list_export:
-            buttons.append(
-                Button(
-                    _("Download XLSX"),
-                    url=self.xlsx_export_url,
-                    icon_name="download",
-                    priority=90,
-                )
-            )
-            buttons.append(
-                Button(
-                    _("Download CSV"),
-                    url=self.csv_export_url,
-                    icon_name="download",
-                    priority=100,
-                )
-            )
-
-        return buttons
-
     def get_list_more_buttons(self, instance):
         buttons = []
         edit_url = self.get_edit_url(instance)
@@ -597,14 +607,16 @@ class CreateView(
         return context
 
     def get_side_panels(self):
-        side_panels = [
-            StatusSidePanel(
-                self.form.instance,
-                self.request,
-                locale=self.locale,
-                translations=self.translations,
+        side_panels = []
+        if self.locale:
+            side_panels.append(
+                StatusSidePanel(
+                    self.form.instance,
+                    self.request,
+                    locale=self.locale,
+                    translations=self.translations,
+                )
             )
-        ]
         return MediaContainer(side_panels)
 
     def get_translations(self):
@@ -659,7 +671,7 @@ class CreateView(
 
 class CopyView(CreateView):
     def get_object(self, queryset=None):
-        return get_object_or_404(self.model, pk=self.kwargs["pk"])
+        return get_object_or_404(self.model, pk=unquote(str(self.kwargs["pk"])))
 
     def get_form_kwargs(self):
         return {**super().get_form_kwargs(), "instance": self.get_object()}
@@ -710,7 +722,7 @@ class EditView(
         return super().get_object(queryset)
 
     def get_page_subtitle(self):
-        return str(self.object)
+        return get_latest_str(self.object)
 
     def get_breadcrumbs_items(self):
         if not self.model:
@@ -723,7 +735,7 @@ class EditView(
                     "label": capfirst(self.model._meta.verbose_name_plural),
                 }
             )
-        items.append({"url": "", "label": get_latest_str(self.object)})
+        items.append({"url": "", "label": self.get_page_subtitle()})
         return self.breadcrumbs_items + items
 
     def get_side_panels(self):
@@ -745,7 +757,11 @@ class EditView(
         return MediaContainer(side_panels)
 
     def get_last_updated_info(self):
-        return log_registry.get_logs_for_instance(self.object).first()
+        return (
+            log_registry.get_logs_for_instance(self.object)
+            .select_related("user")
+            .first()
+        )
 
     def get_edit_url(self):
         if not self.edit_url_name: