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

wagtail/admin/templates/wagtailadmin/shared/side_panels/includes/status/usage.html

@@ -7,15 +7,22 @@
                     {% trans "Usage" %}
                 </h3>
             </div>
-            <a class="w-text-14 w-text-text-link-default hover:w-text-text-link-hover w-no-underline w-transition"
-               href="{{ usage_url }}"
-            >
+            {% fragment as usage_label %}
                 {% if usage_url_text %}
                     {{ usage_url_text }}
                 {% else %}
                     {% blocktrans trimmed with counter=usage_count usage_count=usage_count|intcomma count counter=counter %}Used {{ usage_count }} time{% plural %}Used {{ usage_count }} times{% endblocktrans %}
                 {% endif %}
-            </a>
+            {% endfragment %}
+            {% if usage_url %}
+                <a class="w-text-14 w-text-text-link-default hover:w-text-text-link-hover w-no-underline w-transition"
+                   href="{{ usage_url }}"
+                >
+                    {{ usage_label }}
+                </a>
+            {% else %}
+                <span>{{ usage_label }}</span>
+            {% endif %}
         </div>
     </section>
 </div>

wagtail/admin/templates/wagtailadmin/shared/side_panels/includes/status/workflow.html

@@ -80,6 +80,19 @@
                 {% endif %}
             {% endwith %}
         </div>
+    {% else %}
+        {% if draftstate_enabled %}
+            {% trans "Draft" as title %}
+            {% fragment as icon_name %}draft{% endfragment %}
+        {% else %}
+            {% trans "Live" as title %}
+            {% fragment as icon_name %}doc-full-inverse{% endfragment %}
+        {% endif %}
+        {% blocktranslate trimmed asvar help_text with user=request.user|user_display_name %}
+            To be created by {{ user }}
+        {% endblocktranslate %}
+
+        {{ block.super }}
     {% endif %}
 {% endblock %}
 
@@ -88,7 +101,15 @@
         {% dialog_toggle classname='w-bg-transparent w-text-14 w-p-0 w-text-text-link-default hover:w-text-text-link-hover w-inline-flex w-justify-center w-transition' dialog_id="workflow-status-dialog" text=action_text %}
 
         {# info subtitle #}
-        {% if object.get_latest_revision %}
+        {% if is_partial %}
+            {% comment %}
+                The dialog will be teleported to the body. Do not re-render the dialog
+                when rendering partials, as we would end up with multiple instances.
+                We also don't render it when hydrating the create view, as it's unlikely
+                that the object immediately enters a workflow on creation without a
+                full-page reload.
+            {% endcomment %}
+        {% elif object.get_latest_revision %}
             {% workflow_status_with_date workflow_state as message_heading %}
             {% if workflow_state.requested_by %}
                 {% blocktrans trimmed with user=workflow_state.requested_by|user_display_name asvar modified_by %}by {{ user }}{% endblocktrans %}

wagtail/admin/templates/wagtailadmin/shared/side_panels/preview.html

@@ -3,6 +3,7 @@
 <div
     class="w-preview"
     data-controller="w-preview"
+    data-action="w-unsaved:add@document->w-preview#setStale"
     data-w-preview-has-errors-class="w-preview--has-errors"
     data-w-preview-proxy-class="w-preview__proxy"
     data-w-preview-selected-size-class="w-preview__size-button--selected"

wagtail/admin/templates/wagtailadmin/shared/side_panels.html

@@ -27,8 +27,7 @@
 
     {% for panel in side_panels %}
         <div class="form-side__panel" data-side-panel="{{ panel.name }}" hidden>
-            <h2 id="side-panel-{{ panel.name }}-title" class="w-sr-only">{{ panel.title }}</h2>
-            {% component panel %}
+            {% include "wagtailadmin/shared/side_panels/includes/side_panel.html" with panel=panel %}
         </div>
     {% endfor %}
 </aside>

wagtail/admin/templates/wagtailadmin/shared/unsaved_changes_warning.html

@@ -3,31 +3,31 @@
     class="footer__container footer__container--hidden"
     aria-live="polite"
     data-controller="w-messages"
-    data-action="w-unsaved:add@document->w-messages#add w-unsaved:clear@document->w-messages#clear"
+    data-action="w-unsaved:add@document->w-messages#add w-unsaved:clear@document->w-messages#clear w-autosave:error@document->w-messages#add"
     data-w-messages-clear-delay-value="1024"
     data-w-messages-clear-param="true"
     data-w-messages-hide-class="footer__container--hidden"
 >
     <div class="footer__save-warning footer__emphasise-span-tags" data-w-messages-target="container"></div>
     {% block message_templates %}
-        {% trans 'Save your changes before leaving' as generic_save_message %}
-        <template data-w-messages-target="template" data-type="edits">
-            <div>
-                <b>{% blocktrans trimmed %}You have <span>unsaved edits</span>{% endblocktrans %}</b>
-                <p>{{ generic_save_message }}</p>
-            </div>
-        </template>
-        <template data-w-messages-target="template" data-type="comments">
-            <div>
-                <b>{% blocktrans trimmed %}You have <span>unsaved comments</span>{% endblocktrans %}</b>
-                <p>{{ generic_save_message }}</p>
-            </div>
-        </template>
-        <template data-w-messages-target="template" data-type="all">
-            <div>
-                <b>{% blocktrans trimmed %}You have <span>unsaved edits</span> and <span>comments</span>{% endblocktrans %}</b>
-                <p>{{ generic_save_message }}</p>
-            </div>
-        </template>
+        {% if autosave_enabled %}
+            {% blocktranslate trimmed asvar generic_save_message %}
+                Autosave is <span>paused</span>
+            {% endblocktranslate %}
+            <template data-w-messages-target="template" data-selector="p">
+                <div>
+                    <b>{{ generic_save_message }}</b>
+                    <p></p>
+                </div>
+            </template>
+        {% else %}
+            {% trans 'Save your changes before leaving' as generic_save_message %}
+            <template data-w-messages-target="template" data-type="edits">
+                <div>
+                    <b>{% blocktrans trimmed %}You have <span>unsaved edits</span>{% endblocktrans %}</b>
+                    <p>{{ generic_save_message }}</p>
+                </div>
+            </template>
+        {% endif %}
     {% endblock %}
 </div>

wagtail/admin/templates/wagtailadmin/userbar/base.html

@@ -9,6 +9,7 @@
                 <link rel="stylesheet" href="{% build_absolute_url core_css_url %}">
                 {# For headless userbar: the contents of the hook also need absolute URLs #}
                 {% hook_output 'insert_global_admin_css' %}
+                {{ media.css }}
             {% endblock %}
             <div class="w-userbar-nav">
 
@@ -49,5 +50,6 @@
     {% versioned_static 'wagtailadmin/js/userbar.js' as userbar_js_url %}
     <script src="{% build_absolute_url vendor_js_url %}"></script>
     <script src="{% build_absolute_url userbar_js_url %}"></script>
+    {{ media.js }}
 {% endblock %}
 <!-- end Wagtail user bar embed code -->

wagtail/admin/templates/wagtailadmin/userbar/item_accessibility.html

@@ -4,7 +4,7 @@
 {% block item_content %}
     <button type="button" id="accessibility-trigger" role="menuitem">
         <span class="w-sr-only">{% trans 'Issues found' %}</span><span class="w-a11y-result__count" data-a11y-result-count></span>
-        {% trans 'Accessibility' %}
+        {% trans 'Checks' %}
     </button>
     {{ axe_configuration|json_script:"accessibility-axe-configuration" }}
     {% trans 'Warnings' as dialog_title %}

wagtail/admin/templatetags/wagtailadmin_tags.py

@@ -19,7 +19,6 @@ from django.utils import timezone
 from django.utils.encoding import force_str
 from django.utils.formats import get_format
 from django.utils.html import avoid_wrapping, json_script
-from django.utils.http import urlencode
 from django.utils.safestring import mark_safe
 from django.utils.timesince import timesince
 from django.utils.translation import gettext_lazy as _
@@ -40,7 +39,6 @@ from wagtail.admin.utils import (
     get_keyboard_key_labels_from_request,
     get_latest_str,
     get_user_display_name,
-    get_valid_next_url_from_request,
 )
 from wagtail.admin.views.bulk_action.registry import bulk_action_registry
 from wagtail.admin.views.pages.utils import get_breadcrumbs_items_for_page
@@ -509,18 +507,14 @@ def bulk_action_choices(context, app_label, model_name):
     bulk_action_more_list = bulk_actions_list[4:]
     bulk_actions_list = bulk_actions_list[:4]
 
-    next_url = get_valid_next_url_from_request(context["request"])
-    if not next_url:
-        next_url = context["request"].path
-
+    # These buttons are not re-rendered after AJAX search and filters are applied,
+    # so don't include a 'next' parameter and let the JS construct it later.
     bulk_action_buttons = [
         ListingButton(
             action.display_name,
             reverse(
                 "wagtail_bulk_action", args=[app_label, model_name, action.action_type]
-            )
-            + "?"
-            + urlencode({"next": next_url}),
+            ),
             attrs={"aria-label": action.aria_label, "data-bulk-action-button": ""},
             priority=action.action_priority,
             classname=" ".join(action.classes | {"bulk-action-btn"}),
@@ -539,9 +533,7 @@ def bulk_action_choices(context, app_label, model_name):
                     url=reverse(
                         "wagtail_bulk_action",
                         args=[app_label, model_name, action.action_type],
-                    )
-                    + "?"
-                    + urlencode({"next": next_url}),
+                    ),
                     attrs={
                         "aria-label": action.aria_label,
                         "data-bulk-action-button": "",
@@ -1037,9 +1029,9 @@ def fragment(parser, token):
         tag_name, *options, target_var = token.split_contents()
         nodelist = parser.parse(("endfragment",))
         parser.delete_first_token()
-    except ValueError:
+    except ValueError as e:
         if settings.DEBUG:
-            raise template.TemplateSyntaxError(error_message)
+            raise template.TemplateSyntaxError(error_message) from e
         return ""
 
     stripped = "stripped" in options

wagtail/admin/tests/pages/test_create_page.py

@@ -2,7 +2,7 @@ import datetime
 from unittest import mock
 
 from django.contrib.auth.models import Group, Permission
-from django.http import HttpRequest, HttpResponse
+from django.http import HttpRequest, HttpResponse, JsonResponse
 from django.test import TestCase
 from django.test.utils import override_settings
 from django.urls import reverse
@@ -572,6 +572,32 @@ class TestPageCreation(WagtailTestUtils, TestCase):
         # form should be marked as having unsaved changes for the purposes of the dirty-forms warning
         self.assertContains(response, 'data-w-unsaved-force-value="true"')
 
+    def test_create_simplepage_post_invalid_with_json_response(self):
+        post_data = {
+            "title": "",
+            "content": "Some content",
+            "slug": "hello-world",
+        }
+        response = self.client.post(
+            reverse(
+                "wagtailadmin_pages:add",
+                args=("tests", "simplepage", self.root_page.id),
+            ),
+            post_data,
+            headers={"Accept": "application/json"},
+        )
+
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(response["Content-Type"], "application/json")
+        self.assertEqual(
+            response.json(),
+            {
+                "success": False,
+                "error_code": "validation_error",
+                "error_message": "There are validation errors, click save to highlight them.",
+            },
+        )
+
     def test_create_simplepage_post_with_blank_content(self):
         """
         Saving a page as draft with blank content should be allowed, as this skips
@@ -610,6 +636,63 @@ class TestPageCreation(WagtailTestUtils, TestCase):
             any(Page.find_problems()), msg="treebeard found consistency problems"
         )
 
+    def test_create_simplepage_post_with_json_response(self):
+        post_data = {
+            "title": "New page",
+            "content": "hello world",
+            "slug": "hello-world",
+        }
+        response = self.client.post(
+            reverse(
+                "wagtailadmin_pages:add",
+                args=("tests", "simplepage", self.root_page.id),
+            ),
+            post_data,
+            headers={"Accept": "application/json"},
+        )
+        # Find the page and check it
+        page = Page.objects.get(
+            path__startswith=self.root_page.path, slug="hello-world"
+        ).specific
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response["Content-Type"], "application/json")
+        revision = page.get_latest_revision()
+        response_json = response.json()
+        edit_url = reverse("wagtailadmin_pages:edit", args=(page.pk,))
+        self.assertEqual(response_json["success"], True)
+        self.assertEqual(response_json["pk"], page.pk)
+        self.assertEqual(response_json["revision_id"], revision.pk)
+        self.assertEqual(
+            response_json["revision_created_at"],
+            revision.created_at.isoformat(),
+        )
+        self.assertEqual(response_json["field_updates"], {})
+        self.assertEqual(
+            response_json["comments"],
+            {
+                "comments": [],
+                "user": str(self.user.pk),
+                "authors": {},
+            },
+        )
+        self.assertEqual(response_json["url"], edit_url)
+        self.assertEqual(
+            response_json["hydrate_url"],
+            f"{edit_url}?_w_hydrate_create_view=1",
+        )
+
+        self.assertEqual(page.title, post_data["title"])
+        self.assertEqual(page.draft_title, post_data["title"])
+        self.assertIsInstance(page, SimplePage)
+        self.assertFalse(page.live)
+        self.assertFalse(page.first_published_at)
+
+        # treebeard should report no consistency problems with the tree
+        self.assertFalse(
+            any(Page.find_problems()), msg="treebeard found consistency problems"
+        )
+
     def test_publish_simplepage_post_with_blank_content(self):
         post_data = {
             "title": "New page",
@@ -1799,6 +1882,52 @@ class TestPageCreation(WagtailTestUtils, TestCase):
         self.assertEqual(response.status_code, 200)
         self.assertEqual(response.content, b"Overridden!")
 
+    def test_before_create_page_hook_with_json_response(self):
+        def non_json_hook_func(request, parent_page, page_class):
+            self.assertIsInstance(request, HttpRequest)
+            self.assertEqual(parent_page.id, self.root_page.id)
+            self.assertEqual(page_class, SimplePage)
+
+            return HttpResponse("Overridden!")
+
+        def json_hook_func(request, parent_page, page_class):
+            self.assertIsInstance(request, HttpRequest)
+            self.assertEqual(parent_page.id, self.root_page.id)
+            self.assertEqual(page_class, SimplePage)
+
+            return JsonResponse({"status": "purple"})
+
+        with self.register_hook("before_create_page", non_json_hook_func):
+            response = self.client.get(
+                reverse(
+                    "wagtailadmin_pages:add",
+                    args=("tests", "simplepage", self.root_page.id),
+                ),
+                headers={"Accept": "application/json"},
+            )
+
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(
+            response.json(),
+            {
+                "success": False,
+                "error_code": "blocked_by_hook",
+                "error_message": "Request to create page was blocked by hook.",
+            },
+        )
+
+        with self.register_hook("before_create_page", json_hook_func):
+            response = self.client.get(
+                reverse(
+                    "wagtailadmin_pages:add",
+                    args=("tests", "simplepage", self.root_page.id),
+                ),
+                headers={"Accept": "application/json"},
+            )
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.json(), {"status": "purple"})
+
     def test_before_create_page_hook_post(self):
         def hook_func(request, parent_page, page_class):
             self.assertIsInstance(request, HttpRequest)
@@ -1827,6 +1956,70 @@ class TestPageCreation(WagtailTestUtils, TestCase):
         # page should not be created
         self.assertFalse(Page.objects.filter(title="New page!").exists())
 
+    def test_before_create_page_hook_post_with_json_response(self):
+        def non_json_hook_func(request, parent_page, page_class):
+            self.assertIsInstance(request, HttpRequest)
+            self.assertEqual(parent_page.id, self.root_page.id)
+            self.assertEqual(page_class, SimplePage)
+
+            return HttpResponse("Overridden!")
+
+        def json_hook_func(request, parent_page, page_class):
+            self.assertIsInstance(request, HttpRequest)
+            self.assertEqual(parent_page.id, self.root_page.id)
+            self.assertEqual(page_class, SimplePage)
+
+            return JsonResponse({"status": "purple"})
+
+        with self.register_hook("before_create_page", non_json_hook_func):
+            post_data = {
+                "title": "New page!",
+                "content": "Some content",
+                "slug": "hello-world",
+            }
+            response = self.client.post(
+                reverse(
+                    "wagtailadmin_pages:add",
+                    args=("tests", "simplepage", self.root_page.id),
+                ),
+                post_data,
+                headers={"Accept": "application/json"},
+            )
+
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(
+            response.json(),
+            {
+                "success": False,
+                "error_code": "blocked_by_hook",
+                "error_message": "Request to create page was blocked by hook.",
+            },
+        )
+
+        # page should not be created
+        self.assertFalse(Page.objects.filter(title="New page!").exists())
+
+        with self.register_hook("before_create_page", json_hook_func):
+            post_data = {
+                "title": "New page!",
+                "content": "Some content",
+                "slug": "hello-world",
+            }
+            response = self.client.post(
+                reverse(
+                    "wagtailadmin_pages:add",
+                    args=("tests", "simplepage", self.root_page.id),
+                ),
+                post_data,
+                headers={"Accept": "application/json"},
+            )
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.json(), {"status": "purple"})
+
+        # page should not be created
+        self.assertFalse(Page.objects.filter(title="New page!").exists())
+
     def test_after_create_page_hook(self):
         def hook_func(request, page):
             self.assertIsInstance(request, HttpRequest)
@@ -1858,6 +2051,70 @@ class TestPageCreation(WagtailTestUtils, TestCase):
         # page should be created
         self.assertTrue(Page.objects.filter(title="New page!").exists())
 
+    def test_after_create_page_hook_with_json_response(self):
+        def non_json_hook_func(request, page):
+            self.assertIsInstance(request, HttpRequest)
+            self.assertIsInstance(page, SimplePage)
+
+            # Both are None as this is only a draft
+            self.assertIsNone(page.first_published_at)
+            self.assertIsNone(page.last_published_at)
+
+            return HttpResponse("Overridden!")
+
+        def json_hook_func(request, page):
+            self.assertIsInstance(request, HttpRequest)
+            self.assertIsInstance(page, SimplePage)
+
+            # Both are None as this is only a draft
+            self.assertIsNone(page.first_published_at)
+            self.assertIsNone(page.last_published_at)
+
+            return JsonResponse({"status": "purple"})
+
+        with self.register_hook("after_create_page", non_json_hook_func):
+            post_data = {
+                "title": "New page!",
+                "content": "Some content",
+                "slug": "hello-world",
+            }
+            response = self.client.post(
+                reverse(
+                    "wagtailadmin_pages:add",
+                    args=("tests", "simplepage", self.root_page.id),
+                ),
+                post_data,
+                headers={"Accept": "application/json"},
+            )
+
+        self.assertEqual(response.status_code, 200)
+        # hook response is ignored, since it's not a JSON response
+        self.assertEqual(response.json()["success"], True)
+
+        # page should be created
+        self.assertTrue(Page.objects.filter(title="New page!").exists())
+
+        with self.register_hook("after_create_page", json_hook_func):
+            post_data = {
+                "title": "Another new page!",
+                "content": "Some content",
+                "slug": "hello-another-world",
+            }
+            response = self.client.post(
+                reverse(
+                    "wagtailadmin_pages:add",
+                    args=("tests", "simplepage", self.root_page.id),
+                ),
+                post_data,
+                headers={"Accept": "application/json"},
+            )
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.json(), {"status": "purple"})
+
+        # page should be created
+        self.assertTrue(Page.objects.filter(title="Another new page!").exists())
+
     def test_after_create_page_hook_with_page_publish(self):
         def hook_func(request, page):
             self.assertIsInstance(request, HttpRequest)
@@ -2004,6 +2261,56 @@ class TestPageCreation(WagtailTestUtils, TestCase):
 
         self.assertEqual(response.context["page"].locale, fr_locale)
 
+    def test_create_shows_status_side_panel_skeleton(self):
+        self.user.first_name = "Chrismansyah"
+        self.user.last_name = "Rahadi"
+        self.user.save()
+        response = self.client.get(
+            reverse(
+                "wagtailadmin_pages:add",
+                args=("tests", "simplepage", self.root_page.id),
+            )
+        )
+        soup = self.get_soup(response.content)
+        panel = soup.select_one('[data-side-panel="status"]')
+        self.assertIsNotNone(panel)
+
+        def assert_panel_section(label_id, label_text, description):
+            section = panel.select_one(f'[aria-labelledby="{label_id}"]')
+            self.assertIsNotNone(section)
+            label = section.select_one(f"#{label_id}")
+            self.assertIsNotNone(label)
+            self.assertEqual(label.get_text(separator="\n", strip=True), label_text)
+            self.assertEqual(
+                section.get_text(separator="\n", strip=True),
+                f"{label_text}\n{description}",
+            )
+
+        assert_panel_section(
+            "status-sidebar-draft",
+            "Draft",
+            "To be created by Chrismansyah Rahadi",
+        )
+
+        assert_panel_section(
+            "status-sidebar-unlocked",
+            "Locking:\nUnlocked",
+            "Anyone can edit this page",
+        )
+
+        assert_panel_section(
+            "status-sidebar-visible-to-all",
+            "Page visibility:\nVisible to all",
+            "Once live anyone can view",
+        )
+
+        usage_section = panel.select("section")[-1]
+        self.assertIsNotNone(usage_section)
+        self.assertEqual(
+            usage_section.get_text(separator="\n", strip=True),
+            "Usage\nReferenced 0 times",
+        )
+
 
 class TestPermissionedFieldPanels(WagtailTestUtils, TestCase):
     fixtures = ["test.json"]
@@ -2715,6 +3022,57 @@ class TestCommenting(WagtailTestUtils, TestCase):
         self.assertIn("w-init", form["data-controller"])
         self.assertEqual("", form["data-w-init-event-value"])
 
+    def test_new_comment_json(self):
+        post_data = {
+            "title": "New page",
+            "content": "hello world",
+            "slug": "hello-world",
+            "comments-TOTAL_FORMS": "1",
+            "comments-INITIAL_FORMS": "0",
+            "comments-MIN_NUM_FORMS": "0",
+            "comments-MAX_NUM_FORMS": "",
+            "comments-0-DELETE": "",
+            "comments-0-resolved": "",
+            "comments-0-id": "",
+            "comments-0-contentpath": "title",
+            "comments-0-text": "A test comment",
+            "comments-0-position": "",
+            "comments-0-replies-TOTAL_FORMS": "0",
+            "comments-0-replies-INITIAL_FORMS": "0",
+            "comments-0-replies-MIN_NUM_FORMS": "0",
+            "comments-0-replies-MAX_NUM_FORMS": "0",
+        }
+        response = self.client.post(
+            reverse(
+                "wagtailadmin_pages:add",
+                args=("tests", "simplepage", self.root_page.id),
+            ),
+            post_data,
+            headers={"Accept": "application/json"},
+        )
+
+        self.assertEqual(response.status_code, 200)
+        response_json = response.json()
+        self.assertEqual(response_json["success"], True)
+        pk = response_json["pk"]
+        new_page = SimplePage.objects.get(pk=pk)
+
+        # Check the comment was added
+        comment = new_page.wagtail_admin_comments.get()
+        self.assertEqual(comment.text, "A test comment")
+
+        # Should include serialized comments data in the response
+        comments_json = response_json["comments"]
+        self.assertEqual(len(comments_json["comments"]), 1)
+        comment_json = comments_json["comments"][0]
+        self.assertEqual(comment_json["pk"], comment.pk)
+        self.assertEqual(comment_json["page"], new_page.pk)
+        self.assertEqual(comment_json["user"], str(self.user.pk))
+        self.assertEqual(comment_json["text"], "A test comment")
+        self.assertEqual(comment_json["contentpath"], "title")
+        self.assertEqual(comments_json["user"], str(self.user.pk))
+        self.assertIn(str(self.user.pk), comments_json["authors"])
+
 
 class TestCreateViewChildPagePrivacy(WagtailTestUtils, TestCase):
     def setUp(self):