wagtail 7.2.2__py3-none-any.whl → 7.3__py3-none-any.whl

wagtail/admin/views/pages/edit.py

@@ -4,8 +4,9 @@ from urllib.parse import quote
 from django.conf import settings
 from django.contrib.auth import get_user_model
 from django.core.exceptions import PermissionDenied
+from django.db import transaction
 from django.db.models import Prefetch, Q
-from django.http import HttpResponse
+from django.http import HttpResponse, JsonResponse
 from django.shortcuts import get_object_or_404, redirect
 from django.urls import reverse
 from django.utils import timezone
@@ -20,6 +21,7 @@ from wagtail.admin.action_menu import PageActionMenu
 from wagtail.admin.mail import send_notification
 from wagtail.admin.models import EditingSession
 from wagtail.admin.telepath import JSContext
+from wagtail.admin.ui.autosave import AutosaveIndicator
 from wagtail.admin.ui.components import MediaContainer
 from wagtail.admin.ui.editing_sessions import EditingSessionsModule
 from wagtail.admin.ui.side_panels import (
@@ -29,7 +31,7 @@ from wagtail.admin.ui.side_panels import (
     PreviewSidePanel,
 )
 from wagtail.admin.utils import get_valid_next_url_from_request
-from wagtail.admin.views.generic import HookResponseMixin
+from wagtail.admin.views.generic import HookResponseMixin, JsonPostResponseMixin
 from wagtail.admin.views.generic.base import WagtailAdminTemplateMixin
 from wagtail.exceptions import PageClassNotFoundError
 from wagtail.locks import BasicLock, ScheduledForPublishLock, WorkflowLock
@@ -39,13 +41,18 @@ from wagtail.models import (
     CommentReply,
     Page,
     PageSubscription,
+    Revision,
     WorkflowState,
     get_default_page_content_type,
 )
 from wagtail.utils.timestamps import render_timestamp
 
 
-class EditView(WagtailAdminTemplateMixin, HookResponseMixin, View):
+class EditView(
+    WagtailAdminTemplateMixin, HookResponseMixin, JsonPostResponseMixin, View
+):
+    partials_template_name = "wagtailadmin/pages/edit_partials.html"
+
     def get_page_title(self):
         return _("Editing %(page_type)s") % {
             "page_type": self.page_class.get_verbose_name()
@@ -57,7 +64,8 @@ class EditView(WagtailAdminTemplateMixin, HookResponseMixin, View):
     def get_template_names(self):
         if self.page.alias_of_id:
             return ["wagtailadmin/pages/edit_alias.html"]
-
+        elif self.hydrate_create_view:
+            return [self.partials_template_name]
         else:
             return ["wagtailadmin/pages/edit.html"]
 
@@ -370,7 +378,15 @@ class EditView(WagtailAdminTemplateMixin, HookResponseMixin, View):
 
         response = self.run_hook("before_edit_page", self.request, self.page)
         if response:
-            return response
+            if self.expects_json_response and not self.response_is_json(response):
+                # Hook response is not suitable for a JSON response, so construct our own error response
+                return self.json_error_response(
+                    "blocked_by_hook",
+                    _("Request to edit %(model_name)s was blocked by hook.")
+                    % {"model_name": Page._meta.verbose_name},
+                )
+            else:
+                return response
 
         self.subscription, created = PageSubscription.objects.get_or_create(
             page=self.page,
@@ -404,7 +420,10 @@ class EditView(WagtailAdminTemplateMixin, HookResponseMixin, View):
         else:
             self.workflow_tasks = []
 
+        self.has_unsaved_changes = False
         self.errors_debug = None
+        self.autosave_interval = getattr(settings, "WAGTAIL_AUTOSAVE_INTERVAL", 500)
+        self.autosave_enabled = self.autosave_interval > 0
 
         return super().dispatch(request, page_id, **kwargs)
 
@@ -448,8 +467,6 @@ class EditView(WagtailAdminTemplateMixin, HookResponseMixin, View):
             parent_page=self.parent,
             for_user=self.request.user,
         )
-        self.has_unsaved_changes = False
-        self.page_for_status = self.get_page_for_status()
 
         return self.render_to_response(self.get_context_data())
 
@@ -475,12 +492,57 @@ class EditView(WagtailAdminTemplateMixin, HookResponseMixin, View):
             and self.workflow_state.user_can_cancel(self.request.user)
         )
 
+    @cached_property
+    def hydrate_create_view(self):
+        return bool(self.request.GET.get("_w_hydrate_create_view"))
+
+    @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 post(self, request, *args, **kwargs):
         # Don't allow POST requests if the page is an alias
         if self.page.alias_of_id:
             # Return 405 "Method Not Allowed" response
             return HttpResponse(status=405)
 
+        # 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:
+            return self.json_error_response(
+                "invalid_revision",
+                _("Saving will overwrite a newer version."),
+            )
+
         self.form = self.form_class(
             self.request.POST,
             self.request.FILES,
@@ -548,18 +610,43 @@ class EditView(WagtailAdminTemplateMixin, HookResponseMixin, View):
         return self.action_method()
 
     def save_action(self):
-        self.page = self.form.save(commit=not self.page.live)
-        self.subscription.save()
-
-        # Save revision
-        revision = self.page.save_revision(
-            user=self.request.user,
-            log_action=True,  # Always log the new revision on edit
-            previous_revision=self.previous_revision,
-            clean=False,
-        )
+        try:
+            with transaction.atomic():
+                self.page = self.form.save(commit=not self.page.live)
+                self.subscription.save()
+
+                overwrite_revision_id = self.request.POST.get("overwrite_revision_id")
+                if overwrite_revision_id:
+                    try:
+                        overwrite_revision = self.page.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
+
+                # Save revision
+                revision = self.page.save_revision(
+                    user=self.request.user,
+                    log_action=True,  # Always log the new revision on edit
+                    previous_revision=self.previous_revision,
+                    overwrite_revision=overwrite_revision,
+                    clean=False,
+                )
+        except PermissionDenied as e:
+            # The revision passed to overwrite_revision was not valid
+            if self.expects_json_response:
+                return self.json_error_response("invalid_revision", str(e))
+            else:
+                messages.error(self.request, str(e))
+                self.has_unsaved_changes = True
+                return self.render_to_response(self.get_context_data())
 
-        self.add_save_confirmation_message()
+        if not self.expects_json_response:
+            self.add_save_confirmation_message()
 
         if self.has_content_changes and "comments" in self.form.formsets:
             changes = self.get_commenting_changes()
@@ -568,10 +655,28 @@ class EditView(WagtailAdminTemplateMixin, HookResponseMixin, View):
 
         response = self.run_hook("after_edit_page", self.request, self.page)
         if response:
-            return response
+            if self.expects_json_response and not self.response_is_json(response):
+                # Hook response is not suitable for a JSON response, so ignore it and just use
+                # the standard one
+                pass
+            else:
+                return response
 
         # Just saving - remain on edit page for further edits
-        return self.redirect_and_remain()
+        if self.expects_json_response:
+            return JsonResponse(
+                {
+                    "success": True,
+                    "pk": self.page.pk,
+                    "revision_id": revision.pk,
+                    "revision_created_at": revision.created_at.isoformat(),
+                    "field_updates": dict(self.form.get_field_updates_for_resave()),
+                    "comments": self.form.serialize_comments(self.request.user),
+                    "html": self.render_partials(),
+                }
+            )
+        else:
+            return self.redirect_and_remain()
 
     def publish_action(self):
         self.page = self.form.save(commit=not self.page.live)
@@ -851,15 +956,26 @@ class EditView(WagtailAdminTemplateMixin, HookResponseMixin, View):
                 self.request.user
             )
         elif self.locked_for_user:
-            messages.error(
-                self.request, _("The page could not be saved as it is locked.")
-            )
+            if self.expects_json_response:
+                return self.json_error_response(
+                    "locked", _("The page could not be saved as it is locked.")
+                )
+            else:
+                messages.error(
+                    self.request, _("The page could not be saved as it is locked.")
+                )
         else:
-            messages.validation_error(
-                self.request,
-                _("The page could not be saved due to validation errors."),
-                self.form,
-            )
+            if self.expects_json_response:
+                return self.json_error_response(
+                    "validation_error",
+                    _("There are validation errors, click save to highlight them."),
+                )
+            else:
+                messages.validation_error(
+                    self.request,
+                    _("The page could not be saved due to validation errors."),
+                    self.form,
+                )
         self.errors_debug = repr(self.form.errors) + repr(
             [
                 (name, formset.errors)
@@ -869,8 +985,6 @@ class EditView(WagtailAdminTemplateMixin, HookResponseMixin, View):
         )
         self.has_unsaved_changes = True
 
-        self.page_for_status = self.get_page_for_status()
-
         return self.render_to_response(self.get_context_data())
 
     def get_preview_url(self):
@@ -894,14 +1008,20 @@ class EditView(WagtailAdminTemplateMixin, HookResponseMixin, View):
                 parent_page=self.page.get_parent(),
             ),
         ]
-        if self.page.is_previewable():
+        if not self.expects_json_response and self.page.is_previewable():
             side_panels.append(
                 PreviewSidePanel(
                     self.page, self.request, preview_url=self.get_preview_url()
                 )
             )
-            side_panels.append(ChecksSidePanel(self.page, self.request))
-        if self.form.show_comments_toggle:
+            # We don't need to re-render the checks panel when hydrating create view
+            if not self.hydrate_create_view:
+                side_panels.append(ChecksSidePanel(self.page, self.request))
+        if (
+            not self.expects_json_response
+            and not self.hydrate_create_view
+            and self.form.show_comments_toggle
+        ):
             side_panels.append(CommentsSidePanel(self.page, self.request))
         return MediaContainer(side_panels)
 
@@ -926,6 +1046,7 @@ class EditView(WagtailAdminTemplateMixin, HookResponseMixin, View):
             ),
             [],
             self.page.latest_revision_id,
+            self.latest_revision_created_at,
         )
 
     def get_action_menu(self):
@@ -955,8 +1076,9 @@ class EditView(WagtailAdminTemplateMixin, HookResponseMixin, View):
 
         context.update(
             {
+                "object": self.page,
                 "page": self.page,
-                "page_for_status": self.page_for_status,
+                "page_for_status": self.get_page_for_status(),
                 "content_type": self.page_content_type,
                 "edit_handler": bound_panel,
                 "edit_handler_data": edit_handler_data,
@@ -985,7 +1107,13 @@ class EditView(WagtailAdminTemplateMixin, HookResponseMixin, View):
                 and user_perms.can_unlock(),
                 "locale": self.locale,
                 "media": media,
+                "autosave_enabled": self.autosave_enabled,
+                "autosave_interval": self.autosave_interval,
+                "autosave_indicator": AutosaveIndicator(),
                 "editing_sessions": self.get_editing_sessions(),
+                "loaded_revision_created_at": self.latest_revision_created_at,
+                "is_partial": self.expects_json_response or self.hydrate_create_view,
+                "hydrate_create_view": self.hydrate_create_view,
             }
         )
 

wagtail/admin/views/pages/preview.py

@@ -18,8 +18,8 @@ def view_draft(request, page_id):
 
     try:
         preview_mode = request.GET.get("mode", page.default_preview_mode)
-    except IndexError:
-        raise PermissionDenied
+    except IndexError as e:
+        raise PermissionDenied from e
 
     return page.make_preview_request(request, preview_mode)
 
@@ -86,8 +86,8 @@ class PreviewOnCreate(PreviewOnEdit):
             content_type = ContentType.objects.get_by_natural_key(
                 content_type_app_name, content_type_model_name
             )
-        except ContentType.DoesNotExist:
-            raise Http404
+        except ContentType.DoesNotExist as e:
+            raise Http404 from e
 
         page = content_type.model_class()()
         parent_page = get_object_or_404(Page, id=parent_page_id).specific

wagtail/admin/views/pages/revisions.py

@@ -72,6 +72,9 @@ class RevisionsRevertView(EditView):
     def get_context_data(self, **kwargs):
         context = super().get_context_data(**kwargs)
         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
 
 

wagtail/admin/views/pages/search.py

@@ -91,15 +91,15 @@ class SearchView(PageListingMixin, PermissionCheckedMixin, BaseListingView):
         if "content_type" in request.GET:
             try:
                 app_label, model_name = request.GET["content_type"].split(".")
-            except ValueError:
-                raise Http404
+            except ValueError as e:
+                raise Http404 from e
 
             try:
                 self.selected_content_type = ContentType.objects.get_by_natural_key(
                     app_label, model_name
                 )
-            except ContentType.DoesNotExist:
-                raise Http404
+            except ContentType.DoesNotExist as e:
+                raise Http404 from e
 
         else:
             self.selected_content_type = None

wagtail/admin/views/pages/usage.py

@@ -46,8 +46,8 @@ class ContentTypeUseView(PageListingMixin, PermissionCheckedMixin, BaseListingVi
             content_type = ContentType.objects.get_by_natural_key(
                 content_type_app_name, content_type_model_name
             )
-        except ContentType.DoesNotExist:
-            raise Http404
+        except ContentType.DoesNotExist as e:
+            raise Http404 from e
 
         self.page_class = content_type.model_class()
 

wagtail/admin/views/tags.py

@@ -9,8 +9,8 @@ def autocomplete(request, app_name=None, model_name=None):
     if app_name and model_name:
         try:
             content_type = ContentType.objects.get_by_natural_key(app_name, model_name)
-        except ContentType.DoesNotExist:
-            raise Http404
+        except ContentType.DoesNotExist as e:
+            raise Http404 from e
 
         tag_model = content_type.model_class()
         if not issubclass(tag_model, TagBase):

wagtail/admin/views/workflows.py

@@ -184,6 +184,12 @@ class Create(CreateView):
     def get_form_class(self):
         return self.get_edit_handler().get_form_class()
 
+    def get_initial_form_instance(self):
+        # defining this method ensures that self.object is set to a new instance
+        # while constructing the form, making it available to get_pages_formset
+        # and get_content_type_form during is_valid
+        return self.model()
+
     def get_pages_formset(self):
         if self.request.method == "POST":
             return WorkflowPagesFormSet(
@@ -213,36 +219,41 @@ class Create(CreateView):
         context["media"] = form.media + bound_panel.media + pages_formset.media
         return context
 
+    def is_valid(self, form):
+        if not super().is_valid(form):
+            return False
+
+        self.pages_formset = self.get_pages_formset()
+        self.content_type_form = self.get_content_type_form()
+
+        if not self.pages_formset.is_valid() or not self.content_type_form.is_valid():
+            self.produced_error_message = self.get_error_message()
+            return False
+
+        return True
+
     def form_valid(self, form):
         self.form = form
 
         with transaction.atomic():
             self.object = self.save_instance()
 
-            pages_formset = self.get_pages_formset()
-            content_type_form = self.get_content_type_form()
-            if pages_formset.is_valid() and content_type_form.is_valid():
-                pages_formset.save()
-                content_type_form.save()
-
-                success_message = self.get_success_message(self.object)
-                if success_message is not None:
-                    messages.success(
-                        self.request,
-                        success_message,
-                        buttons=[
-                            messages.button(
-                                reverse(self.edit_url_name, args=(self.object.id,)),
-                                _("Edit"),
-                            )
-                        ],
-                    )
-                return redirect(self.get_success_url())
-
-            else:
-                transaction.set_rollback(True)
-
-        return self.form_invalid(form)
+            self.pages_formset.save()
+            self.content_type_form.save()
+
+            success_message = self.get_success_message(self.object)
+            if success_message is not None:
+                messages.success(
+                    self.request,
+                    success_message,
+                    buttons=[
+                        messages.button(
+                            reverse(self.edit_url_name, args=(self.object.id,)),
+                            _("Edit"),
+                        )
+                    ],
+                )
+            return redirect(self.get_success_url())
 
 
 class Edit(EditView):
@@ -326,42 +337,50 @@ class Edit(EditView):
     def get_enable_url(self):
         return reverse(self.enable_url_name, args=(self.object.pk,))
 
+    def is_valid(self, form):
+        if not super().is_valid(form):
+            return False
+
+        if self.object.active:
+            # Note: These are hidden when the workflow is inactive
+            self.pages_formset = self.get_pages_formset()
+            self.content_type_form = self.get_content_type_form()
+
+            if (
+                not self.pages_formset.is_valid()
+                or not self.content_type_form.is_valid()
+            ):
+                self.produced_error_message = self.get_error_message()
+                return False
+
+        return True
+
     @transaction.atomic()
     def form_valid(self, form):
         self.form = form
 
         with transaction.atomic():
             self.object = self.save_instance()
-            successful = True
 
-            # Save pages formset and content type form
-            # Note: These are hidden when the workflow is inactive
             if self.object.active:
-                pages_formset = self.get_pages_formset()
-                content_type_form = self.get_content_type_form()
-                if pages_formset.is_valid() and content_type_form.is_valid():
-                    pages_formset.save()
-                    content_type_form.save()
-                else:
-                    transaction.set_rollback(True)
-                    successful = False
-
-            if successful:
-                success_message = self.get_success_message()
-                if success_message is not None:
-                    messages.success(
-                        self.request,
-                        success_message,
-                        buttons=[
-                            messages.button(
-                                reverse(self.edit_url_name, args=(self.object.id,)),
-                                _("Edit"),
-                            )
-                        ],
-                    )
-                return redirect(self.get_success_url())
-
-        return self.form_invalid(form)
+                # Save pages formset and content type form
+                # Note: These are hidden when the workflow is inactive
+                self.pages_formset.save()
+                self.content_type_form.save()
+
+            success_message = self.get_success_message()
+            if success_message is not None:
+                messages.success(
+                    self.request,
+                    success_message,
+                    buttons=[
+                        messages.button(
+                            reverse(self.edit_url_name, args=(self.object.id,)),
+                            _("Edit"),
+                        )
+                    ],
+                )
+            return redirect(self.get_success_url())
 
 
 class Disable(DeleteView):
@@ -651,8 +670,8 @@ class CreateTask(CreateView):
             content_type = ContentType.objects.get_by_natural_key(
                 self.kwargs["app_label"], self.kwargs["model_name"]
             )
-        except (ContentType.DoesNotExist, AttributeError):
-            raise Http404
+        except (ContentType.DoesNotExist, AttributeError) as e:
+            raise Http404 from e
 
         # Get class
         model = content_type.model_class()

wagtail/admin/viewsets/model.py

@@ -2,8 +2,10 @@ from django.contrib.auth import get_permission_codename
 from django.contrib.auth.models import Permission
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ImproperlyConfigured
+from django.db import models
 from django.forms.models import modelform_factory
 from django.urls import path
+from django.urls.converters import get_converters
 from django.utils.functional import cached_property
 from django.utils.text import capfirst
 
@@ -129,6 +131,24 @@ class ModelViewSet(ViewSet):
     def permission_policy(self):
         return ModelPermissionPolicy(self.model)
 
+    @cached_property
+    def pk_path_converter(self):
+        """
+        :ref:`Path converter <topics/http/urls:path converters>` to use for
+        the model's primary key in URL patterns. Defaults to ``"int"`` for
+        ``IntegerField``, ``"uuid"`` for ``UUIDField``, and ``"str"`` for all
+        other types.
+
+        .. versionadded:: 7.3
+           The ``pk_path_converter`` property was added.
+        """
+        if isinstance(self.model_opts.pk, models.UUIDField):
+            return "uuid"
+        if isinstance(self.model_opts.pk, models.IntegerField):
+            return "int"
+        # Default to string if unknown
+        return "str"
+
     @cached_property
     def name(self):
         """
@@ -649,38 +669,44 @@ class ModelViewSet(ViewSet):
         hooks.register("register_permissions", self.get_permissions_to_register)
 
     def get_urlpatterns(self):
+        conv = self.pk_path_converter
         urlpatterns = [
             path("", self.index_view, name="index"),
             path("results/", self.index_results_view, name="index_results"),
             path("new/", self.add_view, name="add"),
-            path("edit/<str:pk>/", self.edit_view, name="edit"),
-            path("delete/<str:pk>/", self.delete_view, name="delete"),
-            path("history/<str:pk>/", self.history_view, name="history"),
+            path(f"edit/<{conv}:pk>/", self.edit_view, name="edit"),
+            path(f"delete/<{conv}:pk>/", self.delete_view, name="delete"),
+            path(f"history/<{conv}:pk>/", self.history_view, name="history"),
             path(
-                "history-results/<str:pk>/",
+                f"history-results/<{conv}:pk>/",
                 self.history_results_view,
                 name="history_results",
             ),
-            path("usage/<str:pk>/", self.usage_view, name="usage"),
+            path(f"usage/<{conv}:pk>/", self.usage_view, name="usage"),
         ]
 
         if self.reorder_view_enabled:
             urlpatterns.append(
-                path("reorder/<str:pk>/", self.reorder_view, name="reorder")
+                path(f"reorder/<{conv}:pk>/", self.reorder_view, name="reorder")
             )
 
         if self.inspect_view_enabled:
             urlpatterns.append(
-                path("inspect/<str:pk>/", self.inspect_view, name="inspect")
+                path(f"inspect/<{conv}:pk>/", self.inspect_view, name="inspect")
             )
 
         if self.copy_view_enabled:
-            urlpatterns.append(path("copy/<str:pk>/", self.copy_view, name="copy"))
+            urlpatterns.append(path(f"copy/<{conv}:pk>/", self.copy_view, name="copy"))
 
         return urlpatterns
 
     def on_register(self):
         super().on_register()
+        if self.pk_path_converter not in get_converters():
+            raise ImproperlyConfigured(
+                f"{self.__class__.__name__}.pk_path_converter is not a "
+                "registered path converter"
+            )
         self.register_admin_url_finder()
         self.register_reference_index()
         self.register_permissions()