wagtail 7.2.1__py3-none-any.whl → 7.3rc1__py3-none-any.whl

wagtail/admin/ui/side_panels.py

@@ -22,13 +22,7 @@ class BaseSidePanel(Component):
             self.panel = panel
 
         def get_context_data(self, parent_context):
-            # Inherit classes from fragments defined in slim_header.html
-            inherit = {
-                "nav_icon_button_classes",
-                "nav_icon_classes",
-                "nav_icon_counter_classes",
-            }
-            context = {key: parent_context.get(key) for key in inherit}
+            context = {}
             context["toggle"] = self
             context["panel"] = self.panel
             context["count"] = 0
@@ -98,16 +92,15 @@ class StatusSidePanel(BaseSidePanel):
                 "wagtailadmin/shared/side_panels/includes/status/locale.html"
             )
 
-        if self.object.pk:
-            if self.locking_enabled:
-                templates.append(
-                    "wagtailadmin/shared/side_panels/includes/status/locked.html"
-                )
+        if self.locking_enabled:
+            templates.append(
+                "wagtailadmin/shared/side_panels/includes/status/locked.html"
+            )
 
-            if self.usage_url:
-                templates.append(
-                    "wagtailadmin/shared/side_panels/includes/status/usage.html"
-                )
+        if self.usage_url is not None:
+            templates.append(
+                "wagtailadmin/shared/side_panels/includes/status/usage.html"
+            )
 
         return templates
 
@@ -211,10 +204,11 @@ class StatusSidePanel(BaseSidePanel):
         }
 
     def get_usage_context(self):
+        usage_count = 0
+        if self.object.pk:
+            usage_count = ReferenceIndex.get_grouped_references_to(self.object).count()
         return {
-            "usage_count": ReferenceIndex.get_grouped_references_to(
-                self.object
-            ).count(),
+            "usage_count": usage_count,
             "usage_url": self.usage_url,
         }
 
@@ -229,9 +223,13 @@ class StatusSidePanel(BaseSidePanel):
         context["history_url"] = self.history_url
         context["status_templates"] = self.get_status_templates(context)
         context["last_updated_info"] = self.last_updated_info
+        context["is_partial"] = parent_context.get("is_partial", False)
+        context["hydrate_create_view"] = parent_context.get(
+            "hydrate_create_view", False
+        )
         context.update(self.get_scheduled_publishing_context(parent_context))
         context.update(self.get_lock_context(parent_context))
-        if self.object.pk and self.usage_url:
+        if self.usage_url is not None:
             context.update(self.get_usage_context())
         return context
 
@@ -240,6 +238,7 @@ class PageStatusSidePanel(StatusSidePanel):
     def __init__(self, *args, **kwargs):
         self.parent_page = kwargs.pop("parent_page", None)
         super().__init__(*args, **kwargs)
+        self.usage_url = ""
         if self.object.pk:
             self.usage_url = reverse("wagtailadmin_pages:usage", args=(self.object.pk,))
 

wagtail/admin/userbar.py

@@ -1,6 +1,6 @@
 from warnings import warn
 
-from django.template.loader import render_to_string
+from django.forms import Media
 from django.utils import translation
 from django.utils.translation import gettext_lazy as _
 
@@ -14,18 +14,18 @@ from wagtail.users.models import UserProfile
 from wagtail.utils.deprecation import RemovedInWagtail80Warning
 
 
-class BaseItem:
-    template = "wagtailadmin/userbar/item_base.html"
+class BaseItem(Component):
+    template_name = "wagtailadmin/userbar/item_base.html"
 
-    def get_context_data(self, request):
-        return {"self": self, "request": request}
-
-    def render(self, request):
-        return render_to_string(self.template, self.get_context_data(request))
+    def get_context_data(self, parent_context):
+        context = super().get_context_data(parent_context)
+        context["self"] = self
+        context["request"] = parent_context.get("request")
+        return context
 
 
 class AdminItem(BaseItem):
-    template = "wagtailadmin/userbar/item_admin.html"
+    template_name = "wagtailadmin/userbar/item_admin.html"
 
 
 class AccessibilityItem(BaseItem):
@@ -37,7 +37,7 @@ class AccessibilityItem(BaseItem):
         """Whether the accessibility checker is being run in the page editor."""
 
     #: The template to use for rendering the item.
-    template = "wagtailadmin/userbar/item_accessibility.html"
+    template_name = "wagtailadmin/userbar/item_accessibility.html"
 
     #: A list of CSS selector(s) to test specific parts of the page.
     #: For more details, see `Axe documentation <https://github.com/dequelabs/axe-core/blob/master/doc/context.md#the-include-property>`__.
@@ -212,21 +212,23 @@ class AccessibilityItem(BaseItem):
             "spec": self.get_axe_spec(request),
         }
 
-    def get_context_data(self, request):
-        return {
-            **super().get_context_data(request),
-            "axe_configuration": self.get_axe_configuration(request),
-        }
+    def get_context_data(self, parent_context):
+        context = super().get_context_data(parent_context)
+        context["axe_configuration"] = self.get_axe_configuration(
+            parent_context.get("request")
+        )
+        return context
 
 
 class AddPageItem(BaseItem):
-    template = "wagtailadmin/userbar/item_page_add.html"
+    template_name = "wagtailadmin/userbar/item_page_add.html"
 
     def __init__(self, page):
         self.page = page
         self.parent_page = page.get_parent()
 
-    def render(self, request):
+    def render_html(self, parent_context):
+        request = parent_context.get("request")
         # Don't render if the page doesn't have an id
         if not self.page.id:
             return ""
@@ -236,17 +238,18 @@ class AddPageItem(BaseItem):
         if not permission_checker.can_add_subpage():
             return ""
 
-        return super().render(request)
+        return super().render_html(parent_context)
 
 
 class ExplorePageItem(BaseItem):
-    template = "wagtailadmin/userbar/item_page_explore.html"
+    template_name = "wagtailadmin/userbar/item_page_explore.html"
 
     def __init__(self, page):
         self.page = page
         self.parent_page = page.get_parent()
 
-    def render(self, request):
+    def render_html(self, parent_context):
+        request = parent_context.get("request")
         # Don't render if the page doesn't have an id
         if not self.page.id:
             return ""
@@ -259,16 +262,17 @@ class ExplorePageItem(BaseItem):
         ):
             return ""
 
-        return super().render(request)
+        return super().render_html(parent_context)
 
 
 class EditPageItem(BaseItem):
-    template = "wagtailadmin/userbar/item_page_edit.html"
+    template_name = "wagtailadmin/userbar/item_page_edit.html"
 
     def __init__(self, page):
         self.page = page
 
-    def render(self, request):
+    def render_html(self, parent_context):
+        request = parent_context.get("request")
         # Don't render if the page doesn't have an id
         if not self.page.id:
             return ""
@@ -286,7 +290,7 @@ class EditPageItem(BaseItem):
         if not permission_checker.can_edit():
             return ""
 
-        return super().render(request)
+        return super().render_html(parent_context)
 
 
 def apply_userbar_hooks(request, items, page):
@@ -359,10 +363,26 @@ class Userbar(Component):
             apply_userbar_hooks(request, items, self.object)
 
             # Render the items
-            rendered_items = [item.render(request) for item in items]
+            rendered_items = []
+            media = Media()
+            for item in items:
+                # Backwards compatibility for legacy items with a render method.
+                if hasattr(item, "render"):
+                    warn(
+                        "Userbar items now use the `render_html(parent_context)` method instead of `render(request)` -"
+                        f" view the `construct_wagtail_userbar` docs to update {item.__class__.__name__}",
+                        RemovedInWagtail80Warning,
+                    )
+
+                    content = item.render(request)
+                else:
+                    content = item.render_html(parent_context)
+                if content:
+                    rendered_items.append(content)
 
-            # Remove any unrendered items
-            rendered_items = [item for item in rendered_items if item]
+                # Always append media even if the item might render nothing.
+                if hasattr(item, "media"):
+                    media += item.media
 
             if request:
                 origin = f"{request.scheme}://{request.get_host()}"
@@ -374,6 +394,7 @@ class Userbar(Component):
                 "request": request,
                 "origin": origin,
                 "items": rendered_items,
+                "media": media,
                 "position": self.position,
                 "page": self.object,
                 "revision_id": revision_id,

wagtail/admin/views/bulk_action/dispatcher.py

@@ -7,8 +7,8 @@ from wagtail.admin.views.bulk_action.registry import bulk_action_registry as reg
 def index(request, app_label, model_name, action):
     try:
         model = apps.get_model(app_label, model_name)
-    except LookupError:
-        raise Http404
+    except LookupError as e:
+        raise Http404 from e
     action_class = registry.get_bulk_action_class(app_label, model_name, action)
     if action_class is not None:
         return action_class(request, model).dispatch(request)

wagtail/admin/views/chooser.py

@@ -243,8 +243,8 @@ class BrowseView(View):
 
         try:
             self.desired_classes = page_models_from_string(page_type_string)
-        except (ValueError, LookupError):
-            raise Http404
+        except (ValueError, LookupError) as e:
+            raise Http404 from e
 
         # Find parent page
         if parent_page_id:
@@ -350,8 +350,8 @@ class BrowseView(View):
         paginator = Paginator(pages, per_page=25)
         try:
             pages = paginator.page(request.GET.get("p", 1))
-        except InvalidPage:
-            raise Http404
+        except InvalidPage as e:
+            raise Http404 from e
 
         # Annotate each page with can_choose/can_descend flags
         for page in pages:
@@ -445,8 +445,8 @@ class SearchView(View):
 
         try:
             desired_classes = page_models_from_string(page_type_string)
-        except (ValueError, LookupError):
-            raise Http404
+        except (ValueError, LookupError) as e:
+            raise Http404 from e
 
         pages = Page.objects.all()
         if self.i18n_enabled:

wagtail/admin/views/editing_sessions.py

@@ -1,3 +1,5 @@
+from datetime import datetime
+
 from django.apps import apps
 from django.contrib.admin.utils import unquote
 from django.contrib.contenttypes.models import ContentType
@@ -18,8 +20,8 @@ from wagtail.models import Page, Revision, RevisionMixin, WorkflowMixin
 def ping(request, app_label, model_name, object_id, session_id):
     try:
         model = apps.get_model(app_label, model_name)
-    except LookupError:
-        raise Http404
+    except LookupError as e:
+        raise Http404 from e
 
     unquoted_object_id = unquote(object_id)
 
@@ -31,9 +33,9 @@ def ping(request, app_label, model_name, object_id, session_id):
     else:
         try:
             permission_policy = model.snippet_viewset.permission_policy
-        except AttributeError:
+        except AttributeError as e:
             # model is neither a Page nor a snippet
-            raise Http404
+            raise Http404 from e
 
         can_edit = permission_policy.user_has_permission_for_instance(
             request.user, "change", obj
@@ -108,11 +110,22 @@ def ping(request, app_label, model_name, object_id, session_id):
         all_revisions = obj.revisions.defer("content")
         try:
             original_revision = all_revisions.get(id=revision_id)
-        except Revision.DoesNotExist:
-            raise Http404
+        except Revision.DoesNotExist as e:
+            raise Http404 from e
 
+        try:
+            # The created_at of the latest revision when the session was created
+            created_at = datetime.fromisoformat(
+                request.POST.get("revision_created_at", "")
+            )
+        except ValueError:
+            # Invalid or missing, assume it's the same as the real created_at
+            created_at = original_revision.created_at
+
+        # The newest revision may have been updated via autosave after the
+        # session was created, so filter by created_at rather than the pk.
         newest_revision = (
-            all_revisions.filter(created_at__gt=original_revision.created_at)
+            all_revisions.filter(created_at__gt=created_at)
             .order_by("-created_at", "-pk")
             .select_related("user")
             .first()

wagtail/admin/views/generic/__init__.py

@@ -10,6 +10,7 @@ from .mixins import (  # noqa: F401
     CreateEditViewOptionalFeaturesMixin,
     HookResponseMixin,
     IndexViewOptionalFeaturesMixin,
+    JsonPostResponseMixin,
     LocaleMixin,
     PanelMixin,
     RevisionsRevertMixin,

wagtail/admin/views/generic/chooser.py

@@ -257,8 +257,8 @@ class BaseChooseView(
         self.paginator = self.paginator_class(objects, per_page=self.per_page)
         try:
             return self.paginator.page(request.GET.get("p", 1))
-        except InvalidPage:
-            raise Http404
+        except InvalidPage as e:
+            raise Http404 from e
 
     def get(self, request):
         self.filter_form = self.get_filter_form()
@@ -516,9 +516,9 @@ class ChosenViewMixin(ModelLookupMixin):
 
     def get(self, request, pk):
         try:
-            item = self.get_object(unquote(pk))
-        except ObjectDoesNotExist:
-            raise Http404
+            item = self.get_object(unquote(str(pk)))
+        except ObjectDoesNotExist as e:
+            raise Http404 from e
 
         return self.get_chosen_response(item)
 

wagtail/admin/views/generic/mixins.py

@@ -3,8 +3,10 @@ import json
 from django.conf import settings
 from django.contrib.admin.utils import quote
 from django.contrib.contenttypes.models import ContentType
+from django.core.exceptions import PermissionDenied
 from django.db import models, transaction
 from django.forms import Media
+from django.http import JsonResponse
 from django.shortcuts import get_object_or_404
 from django.template.loader import render_to_string
 from django.urls import reverse
@@ -21,6 +23,7 @@ from wagtail.admin.forms.models import WagtailAdminModelForm
 from wagtail.admin.models import EditingSession
 from wagtail.admin.telepath import JSContext
 from wagtail.admin.templatetags.wagtailadmin_tags import user_display_name
+from wagtail.admin.ui.autosave import AutosaveIndicator
 from wagtail.admin.ui.editing_sessions import EditingSessionsModule
 from wagtail.admin.ui.tables import LiveStatusTagColumn, TitleColumn
 from wagtail.admin.utils import get_latest_str, set_query_params
@@ -32,6 +35,7 @@ from wagtail.models import (
     Locale,
     LockableMixin,
     PreviewableMixin,
+    Revision,
     RevisionMixin,
     TranslatableMixin,
     WorkflowMixin,
@@ -279,6 +283,8 @@ class CreateEditViewOptionalFeaturesMixin:
             and issubclass(self.model, LockableMixin)
             and self.view_name != "create"
         )
+        self.autosave_interval = getattr(settings, "WAGTAIL_AUTOSAVE_INTERVAL", 500)
+        self.autosave_enabled = self.revision_enabled and self.autosave_interval > 0
 
         # Set the object before super().setup() as LocaleMixin.setup() needs it
         self.object = self.get_object()
@@ -446,16 +452,6 @@ class CreateEditViewOptionalFeaturesMixin:
             self.confirm_workflow_cancellation_url_name, args=[quote(self.object.pk)]
         )
 
-    def get_error_message(self):
-        if self.action == "cancel-workflow":
-            return None
-        if self.locked_for_user:
-            return capfirst(
-                _("The %(model_name)s could not be saved as it is locked")
-                % {"model_name": self.model._meta.verbose_name}
-            )
-        return super().get_error_message()
-
     def get_success_message(self, instance=None):
         object = instance or self.object
 
@@ -547,8 +543,23 @@ class CreateEditViewOptionalFeaturesMixin:
         # Save revision if the model inherits from RevisionMixin
         self.new_revision = None
         if self.revision_enabled:
+            overwrite_revision_id = self.request.POST.get("overwrite_revision_id")
+            if overwrite_revision_id:
+                try:
+                    overwrite_revision = instance.revisions.get(
+                        pk=overwrite_revision_id
+                    )
+                except Revision.DoesNotExist as e:
+                    raise PermissionDenied(
+                        "Cannot overwrite a revision that does not exist"
+                    ) from e
+            else:
+                overwrite_revision = None
+
             self.new_revision = instance.save_revision(
-                user=self.request.user, clean=not self.saving_as_draft
+                user=self.request.user,
+                clean=not self.saving_as_draft,
+                overwrite_revision=overwrite_revision,
             )
 
         log(
@@ -617,8 +628,14 @@ class CreateEditViewOptionalFeaturesMixin:
 
     def form_valid(self, form):
         self.form = form
-        with transaction.atomic():
-            self.object = self.save_instance()
+        try:
+            with transaction.atomic():
+                self.object = self.save_instance()
+        except PermissionDenied as e:
+            # The revision passed to overwrite_revision was not valid
+            self.produced_error_code = "invalid_revision"
+            self.produced_error_message = str(e)
+            return self.form_invalid(form)
 
         response = self.run_action_method()
         if response is not None:
@@ -632,9 +649,18 @@ class CreateEditViewOptionalFeaturesMixin:
 
         return response
 
+    def get_success_json(self):
+        data = super().get_success_json()
+        if self.revision_enabled and self.new_revision:
+            data["revision_id"] = self.new_revision.id
+            data["revision_created_at"] = self.new_revision.created_at.isoformat()
+        return data
+
     def form_invalid(self, form):
-        # Even if the object is locked due to not having permissions,
-        # the original submitter can still cancel the workflow
+        # Even if the form is invalid, a cancel-workflow action can still proceed. This accommodates
+        # the typical case for a lockable model, where the object is locked to the submitter at the
+        # point of submission (and thus the lock would make the form submission invalid) - but also
+        # applies to other error conditions such as actual validation errors.
         if self.action == "cancel-workflow":
             self.cancel_workflow_action()
             messages.success(
@@ -645,6 +671,10 @@ class CreateEditViewOptionalFeaturesMixin:
             # Refresh the lock object as now WorkflowLock no longer applies
             self.lock = self.get_lock()
             self.locked_for_user = self.lock and self.lock.for_user(self.request.user)
+            # Unset whichever error message was set by is_valid() (most likely "this X could not be
+            # saved as it is locked") so that we just show the success message.
+            self.produced_error_message = None
+
         return super().form_invalid(form)
 
     def get_last_updated_info(self):
@@ -743,7 +773,6 @@ class CreateEditViewOptionalFeaturesMixin:
             object_id=self.object.pk,
             last_seen_at=timezone.now(),
         )
-        revision_id = self.object.latest_revision_id if self.revision_enabled else None
         return EditingSessionsModule(
             session,
             reverse(
@@ -760,15 +789,56 @@ class CreateEditViewOptionalFeaturesMixin:
                 args=(session.id,),
             ),
             [],
-            revision_id,
+            self.latest_revision and self.latest_revision.pk,
+            self.latest_revision_created_at,
         )
 
+    @cached_property
+    def latest_revision(self):
+        return self.revision_enabled and self.object and self.object.latest_revision
+
+    @cached_property
+    def latest_revision_created_at(self):
+        return self.latest_revision and self.latest_revision.created_at.isoformat()
+
+    @cached_property
+    def is_out_of_date(self):
+        if not self.latest_revision:
+            return False
+
+        latest_revision_id = str(self.latest_revision.pk)
+
+        # Two different sessions cannot have the same autosave revision, so if
+        # autosave revision is present, it is either the latest or it is not.
+        if overwrite_revision_id := self.request.POST.get("overwrite_revision_id"):
+            return overwrite_revision_id != latest_revision_id
+
+        # Client has not made an autosave revision, check the loaded revision.
+        if loaded_revision_id := self.request.POST.get("loaded_revision_id"):
+            # If the loaded revision is not the latest revision, it is outdated.
+            if loaded_revision_id != latest_revision_id:
+                return True
+
+            # It's pointing to the latest revision, but that revision may have
+            # been overwritten by another session (via autosave) since the editor
+            # loaded it. The created_at is strictly increasing, so assume the
+            # loaded revision outdated if it doesn't match the latest created_at.
+            return (
+                self.request.POST.get("loaded_revision_created_at", "")
+                != self.latest_revision_created_at
+            )
+
+        # Not enough information to deduce, assume it's up to date.
+        return False
+
     def get_context_data(self, **kwargs):
         context = super().get_context_data(**kwargs)
         context.update(self.get_lock_context())
         context["revision_enabled"] = self.revision_enabled
         context["draftstate_enabled"] = self.draftstate_enabled
         context["workflow_enabled"] = self.workflow_enabled
+        context["autosave_enabled"] = self.autosave_enabled
+        context["autosave_interval"] = self.autosave_interval
         context["workflow_history_url"] = self.get_workflow_history_url()
         context["confirm_workflow_cancellation_url"] = (
             self.get_confirm_workflow_cancellation_url()
@@ -778,27 +848,36 @@ class CreateEditViewOptionalFeaturesMixin:
         ) and bool(self.workflow_tasks)
         context["revisions_compare_url_name"] = self.revisions_compare_url_name
         context["editing_sessions"] = self.get_editing_sessions()
+        context["loaded_revision_created_at"] = self.latest_revision_created_at
+        if self.autosave_enabled:
+            context["autosave_indicator"] = AutosaveIndicator()
         return context
 
-    def post(self, request, *args, **kwargs):
-        form = self.get_form()
+    def is_valid(self, form):
+        # For autosave, we only want to save the page if there are no conflicts
+        if self.expects_json_response and self.is_out_of_date:
+            self.produced_error_code = "invalid_revision"
+            self.produced_error_message = _("Saving will overwrite a newer version.")
+            return False
 
         # Make sure object is not locked
         if self.locked_for_user:
-            return self.form_invalid(form)
+            self.produced_error_code = "locked"
+            self.produced_error_message = capfirst(
+                _("The %(model_name)s could not be saved as it is locked")
+                % {"model_name": self.model._meta.verbose_name}
+            )
+            return False
 
         # If saving as draft, do not enforce full validation
         if self.saving_as_draft and isinstance(form, WagtailAdminModelForm):
             form.defer_required_fields()
-            form_is_valid = form.is_valid()
+            result = super().is_valid(form)
             form.restore_required_fields()
         else:
-            form_is_valid = form.is_valid()
+            result = super().is_valid(form)
 
-        if form_is_valid:
-            return self.form_valid(form)
-        else:
-            return self.form_invalid(form)
+        return result
 
 
 class RevisionsRevertMixin:
@@ -880,4 +959,42 @@ class RevisionsRevertMixin:
         context = super().get_context_data(**kwargs)
         context["revision"] = self.revision
         context["action_url"] = self.get_revisions_revert_url()
+        # Autosave does not make much sense in this view, we want the user to
+        # explicitly confirm they want to revert to the previous revision
+        context["autosave_enabled"] = False
         return context
+
+
+class JsonPostResponseMixin:
+    """
+    Helper methods for create/edit views that return JSON responses when POSTed to with an
+    Accepts: application/json header, rather than the usual "redirect on success, HTML form
+    on failure" behaviour.
+    """
+
+    partials_template_name = None
+
+    @cached_property
+    def expects_json_response(self):
+        return not self.request.accepts("text/html")
+
+    def json_error_response(self, error_code, error_message):
+        return JsonResponse(
+            {
+                "success": False,
+                "error_code": error_code,
+                "error_message": error_message,
+            },
+            status=400,
+        )
+
+    @staticmethod
+    def response_is_json(response):
+        return response.headers.get("Content-Type") == "application/json"
+
+    def render_partials(self):
+        return render_to_string(
+            self.partials_template_name,
+            self.get_context_data(),
+            request=self.request,
+        )