wagtail 7.2rc1__py3-none-any.whl → 7.3rc1__py3-none-any.whl

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,
+        )

wagtail/admin/views/generic/models.py

@@ -8,7 +8,7 @@ from django.core.exceptions import (
 from django.db import models, transaction
 from django.db.models.constants import LOOKUP_SEP
 from django.db.models.functions import Cast
-from django.http import Http404, HttpResponseRedirect
+from django.http import Http404, HttpResponseRedirect, JsonResponse
 from django.shortcuts import get_object_or_404, redirect
 from django.urls import reverse
 from django.utils.functional import cached_property
@@ -39,7 +39,11 @@ from wagtail.admin.ui.tables import (
     UpdatedAtColumn,
 )
 from wagtail.admin.ui.tables.orderable import OrderableTableMixin
-from wagtail.admin.utils import get_latest_str, get_valid_next_url_from_request
+from wagtail.admin.utils import (
+    get_latest_str,
+    get_valid_next_url_from_request,
+    set_query_params,
+)
 from wagtail.admin.views.mixins import SpreadsheetExportMixin
 from wagtail.admin.widgets.button import (
     BaseButton,
@@ -55,7 +59,13 @@ from wagtail.models.orderable import set_max_order
 from wagtail.search.index import class_is_indexed
 
 from .base import BaseListingView, WagtailAdminTemplateMixin
-from .mixins import BeforeAfterHookMixin, HookResponseMixin, LocaleMixin, PanelMixin
+from .mixins import (
+    BeforeAfterHookMixin,
+    HookResponseMixin,
+    JsonPostResponseMixin,
+    LocaleMixin,
+    PanelMixin,
+)
 from .permissions import PermissionCheckedMixin
 
 
@@ -468,6 +478,7 @@ class CreateView(
     PermissionCheckedMixin,
     BeforeAfterHookMixin,
     WagtailAdminTemplateMixin,
+    JsonPostResponseMixin,
     BaseCreateView,
 ):
     model = None
@@ -475,6 +486,7 @@ class CreateView(
     index_url_name = None
     add_url_name = None
     edit_url_name = None
+    usage_url_name = None
     template_name = "wagtailadmin/generic/create.html"
     page_title = gettext_lazy("New")
     permission_required = "add"
@@ -491,6 +503,32 @@ class CreateView(
         super().setup(request, *args, **kwargs)
         self.action = self.get_action(request)
 
+    def post(self, request, *args, **kwargs):
+        # BaseCreateView.post() would set self.object here, but some subclasses need
+        # to do that during setup() instead, so only do that if it hasn't already been set.
+        if not hasattr(self, "object"):
+            self.object = None
+
+        form = self.get_form()
+        if self.is_valid(form):
+            return self.form_valid(form)
+        else:
+            return self.form_invalid(form)
+
+    def is_valid(self, form):
+        """
+        Validate the form, setting the produced_error_message attribute if validation fails.
+
+        Subclasses that require extra validation conditions not handled by
+        form.is_valid() (such as formsets, or a locked status on the model) should
+        override this method.
+        """
+        result = form.is_valid()
+        if not result:
+            self.produced_error_code = "validation_error"
+            self.produced_error_message = self.get_error_message()
+        return result
+
     def get_action(self, request):
         for action in self.get_available_actions():
             if request.POST.get(f"action-{action}"):
@@ -568,8 +606,13 @@ class CreateView(
         return [messages.button(self.get_edit_url(), _("Edit"))]
 
     def get_error_message(self):
+        """
+        Return the top-level error message to be shown when the form is invalid.
+        """
         if self.error_message is None:
             return None
+        if self.expects_json_response:
+            return _("There are validation errors, click save to highlight them.")
         return capfirst(
             self.error_message
             % {"model_name": self.model and self.model._meta.verbose_name}
@@ -600,6 +643,8 @@ class CreateView(
                     self.request,
                     locale=self.locale,
                     translations=self.translations,
+                    # Show skeleton for usage info if usage_url_name is set
+                    usage_url="" if self.usage_url_name else None,
                 )
             )
         return MediaContainer(side_panels)
@@ -644,16 +689,32 @@ class CreateView(
         log(instance=instance, action="wagtail.create", content_changed=True)
         return instance
 
+    def get_success_json(self):
+        edit_url = self.get_edit_url()
+        hydrate_url = set_query_params(edit_url, {"_w_hydrate_create_view": "1"})
+        result = {
+            "success": True,
+            "pk": self.object.pk,
+            "url": edit_url,
+            "hydrate_url": hydrate_url,
+        }
+        if isinstance(self.form, WagtailAdminModelForm):
+            result["field_updates"] = dict(self.form.get_field_updates_for_resave())
+        return result
+
     def save_action(self):
-        success_message = self.get_success_message(self.object)
-        success_buttons = self.get_success_buttons()
-        if success_message is not None:
-            messages.success(
-                self.request,
-                success_message,
-                buttons=success_buttons,
-            )
-        return redirect(self.get_success_url())
+        if self.expects_json_response:
+            return JsonResponse(self.get_success_json())
+        else:
+            success_message = self.get_success_message(self.object)
+            success_buttons = self.get_success_buttons()
+            if success_message is not None:
+                messages.success(
+                    self.request,
+                    success_message,
+                    buttons=success_buttons,
+                )
+            return redirect(self.get_success_url())
 
     def form_valid(self, form):
         self.form = form
@@ -670,9 +731,15 @@ class CreateView(
 
     def form_invalid(self, form):
         self.form = form
-        error_message = self.get_error_message()
-        if error_message is not None:
-            messages.validation_error(self.request, error_message, form)
+
+        if self.expects_json_response:
+            return self.json_error_response(
+                getattr(self, "produced_error_code", "internal_error"),
+                self.produced_error_message or "",
+            )
+
+        if self.produced_error_message is not None:
+            messages.validation_error(self.request, self.produced_error_message, form)
         return super().form_invalid(form)
 
 
@@ -696,6 +763,7 @@ class EditView(
     PermissionCheckedMixin,
     BeforeAfterHookMixin,
     WagtailAdminTemplateMixin,
+    JsonPostResponseMixin,
     BaseUpdateView,
 ):
     model = None
@@ -710,6 +778,7 @@ class EditView(
     page_title = gettext_lazy("Editing")
     context_object_name = None
     template_name = "wagtailadmin/generic/edit.html"
+    partials_template_name = "wagtailadmin/generic/edit_partials.html"
     permission_required = "change"
     delete_item_label = gettext_lazy("Delete")
     success_message = gettext_lazy("%(model_name)s '%(object)s' updated.")
@@ -722,6 +791,37 @@ class EditView(
         super().setup(request, *args, **kwargs)
         self.action = self.get_action(request)
 
+    def get_template_names(self):
+        if self.hydrate_create_view:
+            return [self.partials_template_name]
+        return super().get_template_names()
+
+    def post(self, request, *args, **kwargs):
+        # BaseUpdateView.post() would set self.object here, but some subclasses need
+        # to do that during setup() instead, so only do that if it hasn't already been set.
+        if not hasattr(self, "object"):
+            self.object = self.get_object()
+
+        form = self.get_form()
+        if self.is_valid(form):
+            return self.form_valid(form)
+        else:
+            return self.form_invalid(form)
+
+    def is_valid(self, form):
+        """
+        Validate the form, setting the produced_error_message attribute if validation fails.
+
+        Subclasses that require extra validation conditions not handled by
+        form.is_valid() (such as formsets, or a locked status on the model) should
+        override this method.
+        """
+        result = form.is_valid()
+        if not result:
+            self.produced_error_code = "validation_error"
+            self.produced_error_message = self.get_error_message()
+        return result
+
     @cached_property
     def object_pk(self):
         # Must be a cached_property to prevent this from being re-run on the unquoted
@@ -896,16 +996,29 @@ class EditView(
 
         return instance
 
+    def get_success_json(self):
+        result = {
+            "success": True,
+            "pk": self.object.pk,
+            "html": self.render_partials(),
+        }
+        if isinstance(self.form, WagtailAdminModelForm):
+            result["field_updates"] = dict(self.form.get_field_updates_for_resave())
+        return result
+
     def save_action(self):
-        success_message = self.get_success_message()
-        success_buttons = self.get_success_buttons()
-        if success_message is not None:
-            messages.success(
-                self.request,
-                success_message,
-                buttons=success_buttons,
-            )
-        return redirect(self.get_success_url())
+        if self.expects_json_response:
+            return JsonResponse(self.get_success_json())
+        else:
+            success_message = self.get_success_message()
+            success_buttons = self.get_success_buttons()
+            if success_message is not None:
+                messages.success(
+                    self.request,
+                    success_message,
+                    buttons=success_buttons,
+                )
+            return redirect(self.get_success_url())
 
     def get_success_message(self):
         if self.success_message is None:
@@ -922,8 +1035,13 @@ class EditView(
         return [messages.button(self.get_edit_url(), _("Edit"))]
 
     def get_error_message(self):
+        """
+        Return the top-level error message to be displayed when form validation fails.
+        """
         if self.error_message is None:
             return None
+        if self.expects_json_response:
+            return _("There are validation errors, click save to highlight them.")
         return capfirst(
             self.error_message
             % {"model_name": self.model and self.model._meta.verbose_name}
@@ -944,15 +1062,25 @@ class EditView(
 
     def form_invalid(self, form):
         self.form = form
-        error_message = self.get_error_message()
-        if error_message is not None:
-            messages.validation_error(self.request, error_message, form)
+
+        if self.expects_json_response:
+            return self.json_error_response(
+                getattr(self, "produced_error_code", "internal_error"),
+                self.produced_error_message or "",
+            )
+
+        if self.produced_error_message is not None:
+            messages.validation_error(self.request, self.produced_error_message, form)
         return super().form_invalid(form)
 
     @cached_property
     def has_unsaved_changes(self):
         return self.form.is_bound
 
+    @cached_property
+    def hydrate_create_view(self):
+        return bool(self.request.GET.get("_w_hydrate_create_view"))
+
     def get_context_data(self, **kwargs):
         context = super().get_context_data(**kwargs)
         self.form = context.get("form")
@@ -964,6 +1092,8 @@ class EditView(
         context["submit_button_label"] = self.submit_button_label
         context["submit_button_active_label"] = self.submit_button_active_label
         context["has_unsaved_changes"] = self.has_unsaved_changes
+        context["is_partial"] = self.expects_json_response or self.hydrate_create_view
+        context["hydrate_create_view"] = self.hydrate_create_view
         context["can_delete"] = self.can_delete
         if context["can_delete"]:
             context["delete_url"] = self.get_delete_url()

wagtail/admin/views/generic/ordering.py

@@ -19,7 +19,7 @@ class ReorderView(PermissionCheckedMixin, View):
         return self.model._default_manager.all().order_by(self.sort_order_field)
 
     def post(self, request, *args, **kwargs):
-        item_to_move = get_object_or_404(self.model, pk=unquote(kwargs.get("pk")))
+        item_to_move = get_object_or_404(self.model, pk=unquote(str(kwargs.get("pk"))))
 
         try:
             # Position is an index in the list of items,

wagtail/admin/views/generic/preview.py

@@ -123,8 +123,8 @@ class PreviewOnEdit(View):
 
         try:
             preview_mode = request.GET.get("mode", self.object.default_preview_mode)
-        except IndexError:
-            raise PermissionDenied
+        except IndexError as e:
+            raise PermissionDenied from e
 
         extra_attrs = self.get_extra_request_attrs()
 
@@ -171,8 +171,8 @@ class PreviewRevision(View):
             preview_mode = request.GET.get(
                 "mode", self.revision_object.default_preview_mode
             )
-        except IndexError:
-            raise PermissionDenied
+        except IndexError as e:
+            raise PermissionDenied from e
 
         return self.revision_object.make_preview_request(request, preview_mode)
 

wagtail/admin/views/home.py

@@ -312,7 +312,9 @@ class HomeView(WagtailAdminTemplateMixin, TemplateView):
 
         return {**context, **site_details}
 
-    def get_media(self, panels=[]):
+    def get_media(self, panels=None):
+        if panels is None:
+            panels = []
         media = Media()
 
         for panel in panels: