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

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:

wagtail/admin/views/pages/create.py

@@ -3,7 +3,7 @@ from urllib.parse import quote, urlencode
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import PermissionDenied
-from django.http import Http404
+from django.http import Http404, JsonResponse
 from django.shortcuts import get_object_or_404, redirect
 from django.template.response import TemplateResponse
 from django.urls import reverse
@@ -16,6 +16,7 @@ from django.views.generic.base import View
 from wagtail.admin import messages
 from wagtail.admin.action_menu import PageActionMenu
 from wagtail.admin.telepath import JSContext
+from wagtail.admin.ui.autosave import AutosaveIndicator
 from wagtail.admin.ui.components import MediaContainer
 from wagtail.admin.ui.side_panels import (
     ChecksSidePanel,
@@ -23,8 +24,8 @@ from wagtail.admin.ui.side_panels import (
     PageStatusSidePanel,
     PreviewSidePanel,
 )
-from wagtail.admin.utils import get_valid_next_url_from_request
-from wagtail.admin.views.generic import HookResponseMixin
+from wagtail.admin.utils import get_valid_next_url_from_request, set_query_params
+from wagtail.admin.views.generic import HookResponseMixin, JsonPostResponseMixin
 from wagtail.admin.views.generic.base import WagtailAdminTemplateMixin
 from wagtail.models import (
     BaseViewRestriction,
@@ -71,9 +72,12 @@ def add_subpage(request, parent_page_id):
     )
 
 
-class CreateView(WagtailAdminTemplateMixin, HookResponseMixin, View):
+class CreateView(
+    WagtailAdminTemplateMixin, HookResponseMixin, JsonPostResponseMixin, View
+):
     template_name = "wagtailadmin/pages/create.html"
     page_title = gettext_lazy("New")
+    edit_url_name = "wagtailadmin_pages:edit"
 
     def dispatch(
         self, request, content_type_app_name, content_type_model_name, parent_page_id
@@ -89,8 +93,8 @@ class CreateView(WagtailAdminTemplateMixin, HookResponseMixin, View):
             self.page_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
 
         # Get class
         self.page_class = self.page_content_type.model_class()
@@ -110,7 +114,15 @@ class CreateView(WagtailAdminTemplateMixin, HookResponseMixin, View):
             "before_create_page", self.request, self.parent_page, self.page_class
         )
         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 create %(model_name)s was blocked by hook.")
+                    % {"model_name": Page._meta.verbose_name},
+                )
+            else:
+                return response
 
         self.locale = self.parent_page.locale
         self.page = self.page_class(owner=self.request.user)
@@ -142,6 +154,9 @@ class CreateView(WagtailAdminTemplateMixin, HookResponseMixin, View):
 
         self.next_url = get_valid_next_url_from_request(self.request)
 
+        self.autosave_interval = getattr(settings, "WAGTAIL_AUTOSAVE_INTERVAL", 500)
+        self.autosave_enabled = self.autosave_interval > 0
+
         return super().dispatch(request)
 
     def post(self, request):
@@ -192,9 +207,10 @@ class CreateView(WagtailAdminTemplateMixin, HookResponseMixin, View):
         return self.page_class.get_verbose_name()
 
     def get_edit_message_button(self):
-        return messages.button(
-            reverse("wagtailadmin_pages:edit", args=(self.page.id,)), _("Edit")
-        )
+        return messages.button(self.get_edit_url(), _("Edit"))
+
+    def get_edit_url(self):
+        return reverse(self.edit_url_name, args=(self.page.id,))
 
     def get_view_draft_message_button(self):
         return messages.button(
@@ -248,25 +264,49 @@ class CreateView(WagtailAdminTemplateMixin, HookResponseMixin, View):
         self.set_default_privacy_setting()
 
         # Save revision
-        self.page.save_revision(user=self.request.user, log_action=True, clean=False)
+        revision = self.page.save_revision(
+            user=self.request.user, log_action=True, clean=False
+        )
 
         # Save subscription settings
         self.subscription.page = self.page
         self.subscription.save()
 
-        # Notification
-        messages.success(
-            self.request,
-            _("Page '%(page_title)s' created.")
-            % {"page_title": self.page.get_admin_display_title()},
-        )
+        if not self.expects_json_response:
+            # Notification
+            messages.success(
+                self.request,
+                _("Page '%(page_title)s' created.")
+                % {"page_title": self.page.get_admin_display_title()},
+            )
 
         response = self.run_hook("after_create_page", self.request, self.page)
         if response:
-            return response
-
-        # remain on edit page for further edits
-        return self.redirect_and_remain()
+            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
+
+        if self.expects_json_response:
+            edit_url = self.get_edit_url()
+            hydrate_url = set_query_params(edit_url, {"_w_hydrate_create_view": "1"})
+            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),
+                    "url": edit_url,
+                    "hydrate_url": hydrate_url,
+                }
+            )
+        else:
+            # remain on edit page for further edits
+            return self.redirect_and_remain()
 
     def publish_action(self):
         self.page = self.form.save(commit=False)
@@ -374,21 +414,27 @@ class CreateView(WagtailAdminTemplateMixin, HookResponseMixin, View):
             return redirect("wagtailadmin_explore", self.page.get_parent().id)
 
     def redirect_and_remain(self):
-        target_url = reverse("wagtailadmin_pages:edit", args=[self.page.id])
+        target_url = self.get_edit_url()
         if self.next_url:
             # Ensure the 'next' url is passed through again if present
             target_url += "?next=%s" % quote(self.next_url)
         return redirect(target_url)
 
     def form_invalid(self, form):
-        messages.validation_error(
-            self.request,
-            _("The page could not be created due to validation errors."),
-            self.form,
-        )
-        self.has_unsaved_changes = True
+        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 created due to validation errors."),
+                self.form,
+            )
+            self.has_unsaved_changes = True
 
-        return self.render_to_response(self.get_context_data())
+            return self.render_to_response(self.get_context_data())
 
     def get(self, request):
         init_new_page.send(sender=CreateView, page=self.page, parent=self.parent_page)
@@ -474,6 +520,9 @@ class CreateView(WagtailAdminTemplateMixin, HookResponseMixin, View):
                 "has_unsaved_changes": self.has_unsaved_changes,
                 "locale": self.locale,
                 "media": media,
+                "autosave_enabled": self.autosave_enabled,
+                "autosave_interval": self.autosave_interval,
+                "autosave_indicator": AutosaveIndicator(),
             }
         )
 

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)
 
@@ -30,9 +30,13 @@ class PreviewOnEdit(GenericPreviewOnEdit):
         return "{}{}".format(self.session_key_prefix, self.kwargs["page_id"])
 
     def get_object(self):
-        return get_object_or_404(
+        page = get_object_or_404(
             Page, id=self.kwargs["page_id"]
         ).get_latest_revision_as_object()
+        page_perms = page.permissions_for_user(self.request.user)
+        if not page_perms.can_edit():
+            raise PermissionDenied
+        return page
 
     def get_form(self, query_dict):
         form_class = self.object.get_edit_handler().get_form_class()
@@ -82,11 +86,16 @@ 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
+
+        parent_page_perms = parent_page.permissions_for_user(self.request.user)
+        if not parent_page_perms.can_add_subpage():
+            raise PermissionDenied
+
         # We need to populate treebeard's path / depth fields in order to
         # pass validation. We can't make these 100% consistent with the rest
         # of the tree without making actual database changes (such as

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):