wagtail 6.0.1__py3-none-any.whl → 6.1rc1__py3-none-any.whl

wagtail/admin/tests/ui/test_tables.py

@@ -2,7 +2,13 @@ from django.template import Context, Template
 from django.test import RequestFactory, TestCase
 from django.utils.html import format_html
 
-from wagtail.admin.ui.tables import BaseColumn, Column, Table, TitleColumn
+from wagtail.admin.ui.tables import (
+    BaseColumn,
+    Column,
+    RelatedObjectsColumn,
+    Table,
+    TitleColumn,
+)
 from wagtail.models import Page, Site
 
 
@@ -322,3 +328,44 @@ class TestTable(TestCase):
             </table>
         """,
         )
+
+
+class TestRelatedObjectsColumn(TestCase):
+    def setUp(self):
+        self.rf = RequestFactory()
+
+    def render_component(self, obj):
+        request = self.rf.get("/")
+        template = Template("{% load wagtailadmin_tags %}{% component obj %}")
+        return template.render(Context({"request": request, "obj": obj}))
+
+    def test_table_render(self):
+        table = Table(
+            [
+                Column("title"),
+                RelatedObjectsColumn("sites_rooted_here"),
+            ],
+            Page.objects.all(),
+        )
+
+        html = self.render_component(table)
+        self.assertHTMLEqual(
+            html,
+            """
+            <table class="listing">
+                <thead>
+                    <tr><th>Title</th><th>Sites rooted here</th></tr>
+                </thead>
+                <tbody>
+                    <tr>
+                        <td>Root</td>
+                        <td></td>
+                    </tr>
+                    <tr>
+                        <td>Welcome to your new Wagtail site!</td>
+                        <td><ul><li>localhost [default]</li></ul></td>
+                    </tr>
+                </tbody>
+            </table>
+        """,
+        )

wagtail/admin/tests/viewsets/test_model_viewset.py

@@ -6,7 +6,7 @@ from django.contrib.admin.utils import quote
 from django.contrib.auth import get_permission_codename
 from django.contrib.auth.models import Permission
 from django.contrib.contenttypes.models import ContentType
-from django.test import RequestFactory, TestCase
+from django.test import TestCase
 from django.urls import NoReverseMatch, reverse
 from django.utils.formats import date_format, localize
 from django.utils.html import escape
@@ -22,7 +22,6 @@ from wagtail.test.testapp.models import (
     SearchTestModel,
     VariousOnDeleteModel,
 )
-from wagtail.test.testapp.views import FCToyAlt1ViewSet
 from wagtail.test.utils.template_tests import AdminTemplateTestUtils
 from wagtail.test.utils.wagtail_tests import WagtailTestUtils
 from wagtail.utils.deprecation import RemovedInWagtail70Warning
@@ -994,7 +993,7 @@ class TestHistoryView(WagtailTestUtils, TestCase):
         )
         response = self.client.get(self.url)
         soup = self.get_soup(response.content)
-        rows = soup.select("tbody tr")
+        rows = soup.select("#listing-results tbody tr")
         self.assertEqual(response.status_code, 200)
         self.assertEqual(len(rows), 2)
 
@@ -1011,28 +1010,109 @@ class TestHistoryView(WagtailTestUtils, TestCase):
         for rendered_row, expected_row in zip(rendered_rows, expected):
             self.assertSequenceEqual(rendered_row, expected_row)
 
-    def test_filters(self):
-        response = self.client.get(self.url, {"action": "wagtail.edit"})
+    def test_action_filter(self):
+        response = self.client.get(self.url)
+        self.assertEqual(response.status_code, 200)
+
+        # Should only show the created and edited options for the filter
         soup = self.get_soup(response.content)
-        rows = soup.select("tbody tr")
+        options = soup.select('input[name="action"][type="checkbox"]')
+        self.assertEqual(len(options), 2)
+        self.assertEqual(
+            {option.attrs.get("value") for option in options},
+            {"wagtail.create", "wagtail.edit"},
+        )
+        # Should not show the heading when not searching
+        heading = soup.select_one('h2[role="alert"]')
+        self.assertIsNone(heading)
+
+        # Should only show the edited log
+        response = self.client.get(self.url, {"action": "wagtail.edit"})
         self.assertEqual(response.status_code, 200)
+        soup = self.get_soup(response.content)
+        rows = soup.select("#listing-results tbody tr")
         self.assertEqual(len(rows), 1)
         self.assertEqual(rows[0].select_one("td").text.strip(), "Edited")
 
+        # Should only show the created log
         response = self.client.get(self.url, {"action": "wagtail.create"})
+        self.assertEqual(response.status_code, 200)
         soup = self.get_soup(response.content)
-        rows = soup.select("tbody tr")
+        rows = soup.select("#listing-results tbody tr")
         heading = soup.select_one('h2[role="alert"]')
-        self.assertEqual(response.status_code, 200)
         self.assertEqual(heading.string.strip(), "There is 1 match")
         self.assertEqual(len(rows), 1)
         self.assertEqual(rows[0].select_one("td").text.strip(), "Created")
 
+        # Should display the heading when there are results
+        heading = soup.select_one('h2[role="alert"]')
+        self.assertEqual(heading.string.strip(), "There is 1 match")
+
+        response = self.client.get(
+            self.url,
+            {"action": ["wagtail.create", "wagtail.edit"]},
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(len(response.context["object_list"]), 2)
+
+    def test_user_filter(self):
+        # A user who absolutely has no permissions to the model
+        self.create_user("no_power")
+
+        # A user who has permissions to the model,
+        # but only has logs for a different object
+        has_power = self.create_superuser("has_power")
+        other_obj = FeatureCompleteToy.objects.create(name="Woody")
+        log(
+            instance=other_obj,
+            action="wagtail.create",
+            content_changed=True,
+            user=has_power,
+        )
+
+        # A user who does not have permissions to the model,
+        # but has logs for the object (e.g. maybe they used to have permissions)
+        previously_has_power = self.create_user("previously_has_power")
+        log(
+            instance=self.object,
+            action="wagtail.edit",
+            content_changed=True,
+            user=previously_has_power,
+        )
+
+        response = self.client.get(self.url)
+        self.assertEqual(response.status_code, 200)
+        soup = self.get_soup(response.content)
+
+        # Should only show the current user and the previously_has_power user
+        options = soup.select('input[name="user"][type="checkbox"]')
+        self.assertEqual(len(options), 2)
+        self.assertEqual(
+            {option.attrs.get("value") for option in options},
+            {str(self.user.pk), str(previously_has_power.pk)},
+        )
+
+        response = self.client.get(self.url, {"user": str(self.user.pk)})
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(len(response.context["object_list"]), 2)
+
+        response = self.client.get(self.url, {"user": str(previously_has_power.pk)})
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(len(response.context["object_list"]), 1)
+
+        # Should allow filtering by multiple users
+        response = self.client.get(
+            self.url,
+            {"user": [str(self.user.pk), str(previously_has_power.pk)]},
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(len(response.context["object_list"]), 3)
+
     def test_filtered_no_results(self):
-        response = self.client.get(self.url, {"timestamp_before": "2020-01-01"})
+        response = self.client.get(self.url, {"timestamp_to": "2020-01-01"})
         soup = self.get_soup(response.content)
         results = soup.select_one("#listing-results")
-        table = soup.select_one("table")
+        table = soup.select_one("#listing-results table")
         p = results.select_one("p")
         self.assertEqual(response.status_code, 200)
         self.assertIsNotNone(results)
@@ -1045,12 +1125,25 @@ class TestHistoryView(WagtailTestUtils, TestCase):
         response = self.client.get(self.url)
         soup = self.get_soup(response.content)
         results = soup.select_one("#listing-results")
-        table = soup.select_one("table")
+        table = soup.select_one("#listing-results table")
         self.assertEqual(response.status_code, 200)
         self.assertIsNotNone(results)
         self.assertEqual(results.text.strip(), "There are no log entries to display.")
         self.assertIsNone(table)
 
+        # Should hide the action and user filters as there are no choices for
+        # these filters (since the choices are based on the current queryset)
+        action_inputs = soup.select('input[name="action"]')
+        self.assertEqual(len(action_inputs), 0)
+        user_inputs = soup.select('input[name="user"]')
+        self.assertEqual(len(user_inputs), 0)
+
+        # Should still render the timestamp filter as it is always available
+        timestamp_before_input = soup.select_one('input[name="timestamp_to"]')
+        self.assertIsNotNone(timestamp_before_input)
+        timestamp_after_input = soup.select_one('input[name="timestamp_from"]')
+        self.assertIsNotNone(timestamp_after_input)
+
     def test_edit_view_links_to_history_view(self):
         edit_url = reverse("feature_complete_toy:edit", args=(quote(self.object.pk),))
         response = self.client.get(edit_url)
@@ -1059,6 +1152,19 @@ class TestHistoryView(WagtailTestUtils, TestCase):
         history_link = header.find("a", attrs={"href": self.url})
         self.assertIsNotNone(history_link)
 
+    def test_deleted_user(self):
+        to_be_deleted = self.create_user("to_be_deleted")
+        user_id = to_be_deleted.pk
+        log(
+            instance=self.object,
+            action="wagtail.edit",
+            content_changed=True,
+            user=to_be_deleted,
+        )
+        to_be_deleted.delete()
+        response = self.client.get(self.url)
+        self.assertContains(response, f"user {user_id} (deleted)")
+
 
 class TestUsageView(WagtailTestUtils, TestCase):
     @classmethod
@@ -1084,7 +1190,7 @@ class TestUsageView(WagtailTestUtils, TestCase):
         h1 = soup.select_one("h1")
         self.assertEqual(h1.text.strip(), f"Usage: {self.object}")
 
-        tds = soup.select("tbody tr td")
+        tds = soup.select("#listing-results tbody tr td")
         self.assertEqual(len(tds), 3)
         self.assertEqual(tds[0].text.strip(), str(self.tbx))
         self.assertEqual(tds[1].text.strip(), "Various on delete model")
@@ -1132,7 +1238,7 @@ class TestUsageView(WagtailTestUtils, TestCase):
         h1 = soup.select_one("h1")
         self.assertEqual(h1.text.strip(), f"Usage: {self.object}")
 
-        tds = soup.select("tbody tr td")
+        tds = soup.select("#listing-results tbody tr td")
         self.assertEqual(len(tds), 3)
         self.assertEqual(tds[0].text.strip(), "(Private various on delete model)")
         self.assertEqual(tds[1].text.strip(), "Various on delete model")
@@ -1154,7 +1260,7 @@ class TestUsageView(WagtailTestUtils, TestCase):
         h1 = soup.select_one("h1")
         self.assertEqual(h1.text.strip(), f"Usage: {self.object}")
 
-        tds = soup.select("tbody tr td")
+        tds = soup.select("#listing-results tbody tr td")
         self.assertEqual(len(tds), 3)
         self.assertEqual(tds[0].text.strip(), str(self.tbx))
         self.assertEqual(tds[1].text.strip(), "Various on delete model")
@@ -1180,7 +1286,7 @@ class TestUsageView(WagtailTestUtils, TestCase):
         response = self.client.get(self.url)
         soup = self.get_soup(response.content)
         results = soup.select_one("#listing-results")
-        table = soup.select_one("table")
+        table = soup.select_one("#listing-results table")
         self.assertEqual(response.status_code, 200)
         self.assertIsNotNone(results)
         self.assertEqual(results.text.strip(), "There are no results.")
@@ -1425,14 +1531,11 @@ class TestCopyView(WagtailTestUtils, TestCase):
         self.assertRedirects(response, reverse("wagtailadmin_home"))
 
     def test_form_is_prefilled(self):
-        request = RequestFactory().get(self.url)
-        request.user = self.user
-        view = FCToyAlt1ViewSet().copy_view_class()
-        view.setup(request)
-        view.model = self.object.__class__
-        view.kwargs = {"pk": self.object.pk}
-
-        self.assertEqual(view.get_form_kwargs()["instance"], self.object)
+        response = self.client.get(self.url)
+        self.assertEqual(response.status_code, 200)
+        soup = self.get_soup(response.content)
+        name_input = soup.select_one('input[name="name"]')
+        self.assertEqual(name_input.attrs.get("value"), "Test Toy")
 
 
 class TestEditHandler(WagtailTestUtils, TestCase):
@@ -1448,6 +1551,10 @@ class TestEditHandler(WagtailTestUtils, TestCase):
         response = self.client.get(self.url)
         self.assertEqual(response.status_code, 200)
         self.assertTemplateUsed(response, "wagtailadmin/shared/panel.html")
+        # Many features from the Panels API are powered by client-side JS in
+        # _editor_js.html. We need to make sure that this template is included
+        # in the response for now.
+        self.assertTemplateUsed(response, "wagtailadmin/pages/_editor_js.html", count=1)
 
         soup = self.get_soup(response.content)
 

wagtail/admin/ui/side_panels.py

@@ -15,6 +15,7 @@ class BaseSidePanel(Component):
         icon_name = ""
         has_counter = True
         counter_classname = ""
+        keyboard_shortcut = None
 
         def __init__(self, panel):
             self.panel = panel
@@ -229,7 +230,7 @@ class StatusSidePanel(BaseSidePanel):
         context["last_updated_info"] = self.last_updated_info
         context.update(self.get_scheduled_publishing_context(parent_context))
         context.update(self.get_lock_context(parent_context))
-        if self.object.pk:
+        if self.object.pk and self.usage_url:
             context.update(self.get_usage_context())
         return context
 
@@ -338,6 +339,7 @@ class PreviewSidePanel(BaseSidePanel):
         aria_label = gettext_lazy("Toggle preview")
         icon_name = "mobile-alt"
         has_counter = False
+        keyboard_shortcut = "mod+p"
 
     name = "preview"
     title = gettext_lazy("Preview")

wagtail/admin/ui/tables/__init__.py

@@ -149,7 +149,10 @@ class Column(BaseColumn):
         if callable(self.accessor):
             return self.accessor(instance)
         else:
-            return multigetattr(instance, self.accessor)
+            try:
+                return multigetattr(instance, self.accessor)
+            except AttributeError:
+                return None
 
     def get_cell_context_data(self, instance, parent_context):
         context = super().get_cell_context_data(instance, parent_context)
@@ -393,6 +396,15 @@ class DownloadColumn(Column):
         return context
 
 
+class RelatedObjectsColumn(Column):
+    """Outputs a list of objects related to the object through a one-to-many relationship"""
+
+    cell_template_name = "wagtailadmin/tables/related_objects_cell.html"
+
+    def get_value(self, instance):
+        return getattr(instance, self.accessor).all()
+
+
 class Table(Component):
     template_name = "wagtailadmin/tables/table.html"
     classname = "listing"

wagtail/admin/ui/tables/pages.py

@@ -11,14 +11,24 @@ class PageTitleColumn(BaseColumn):
 
     def get_header_context_data(self, parent_context):
         context = super().get_header_context_data(parent_context)
+        parent_page = parent_context.get("parent_page")
+
         context["items_count"] = parent_context.get("items_count")
         context["page_obj"] = parent_context.get("page_obj")
-        context["parent_page"] = parent_context.get("parent_page")
-        context["is_searching"] = parent_context.get("is_searching")
-        context["is_filtering"] = parent_context.get("is_filtering")
-        context["is_searching_whole_tree"] = parent_context.get(
-            "is_searching_whole_tree"
-        )
+        context["parent_page"] = parent_page
+
+        if parent_page and (
+            parent_context.get("is_searching") or parent_context.get("is_filtering")
+        ):
+            # Results are switchable between searching the whole tree and searching just this parent.
+            # Add extra signposting to show which scope we're in, and provide a link to switch scope.
+            if parent_context.get("is_searching_whole_tree"):
+                context["result_scope"] = "whole_tree"
+            else:
+                context["result_scope"] = "parent"
+        else:
+            # No signposting needed
+            context["result_scope"] = None
 
         # If results are not paginated e.g. when using the OrderingColumn,
         # all items are displayed on the page
@@ -27,6 +37,7 @@ class PageTitleColumn(BaseColumn):
         if context["page_obj"]:
             context["start_index"] = context["page_obj"].start_index()
             context["end_index"] = context["page_obj"].end_index()
+
         return context
 
     def get_cell_context_data(self, instance, parent_context):

wagtail/admin/urls/__init__.py

@@ -28,15 +28,19 @@ urlpatterns = [
     path("api/", include(api_urls)),
     path("failwhale/", home.error_test, name="wagtailadmin_error_test"),
     # TODO: Move into wagtailadmin_pages namespace
-    path("pages/", listing.IndexView.as_view(), name="wagtailadmin_explore_root"),
+    path(
+        "pages/",
+        listing.ExplorableIndexView.as_view(),
+        name="wagtailadmin_explore_root",
+    ),
     path(
         "pages/<int:parent_page_id>/",
-        listing.IndexView.as_view(),
+        listing.ExplorableIndexView.as_view(),
         name="wagtailadmin_explore",
     ),
     path(
         "pages/<int:parent_page_id>/results/",
-        listing.IndexView.as_view(results_only=True),
+        listing.ExplorableIndexView.as_view(results_only=True),
         name="wagtailadmin_explore_results",
     ),
     # bulk actions
@@ -127,6 +131,7 @@ def get_sprite_hash():
     global sprite_hash
     if not sprite_hash:
         content = str(home.sprite(None).content, "utf-8")
+        # SECRET_KEY is used to prevent exposing the Wagtail version
         sprite_hash = hashlib.sha1(
             (content + settings.SECRET_KEY).encode("utf-8")
         ).hexdigest()[:8]

wagtail/admin/urls/pages.py

@@ -121,4 +121,9 @@ urlpatterns = [
         name="workflow_history_detail",
     ),
     path("<int:page_id>/history/", history.PageHistoryView.as_view(), name="history"),
+    path(
+        "<int:page_id>/history/results/",
+        history.PageHistoryView.as_view(results_only=True),
+        name="history_results",
+    ),
 ]

wagtail/admin/urls/workflows.py

@@ -5,6 +5,11 @@ from wagtail.admin.views import workflows
 app_name = "wagtailadmin_workflows"
 urlpatterns = [
     path("list/", workflows.Index.as_view(), name="index"),
+    path(
+        "list/results/",
+        workflows.Index.as_view(results_only=True),
+        name="index_results",
+    ),
     path("add/", workflows.Create.as_view(), name="add"),
     path("enable/<int:pk>/", workflows.enable_workflow, name="enable"),
     path("disable/<int:pk>/", workflows.Disable.as_view(), name="disable"),
@@ -23,6 +28,11 @@ urlpatterns = [
     ),
     path("tasks/select_type/", workflows.select_task_type, name="select_task_type"),
     path("tasks/index/", workflows.TaskIndex.as_view(), name="task_index"),
+    path(
+        "tasks/index/results/",
+        workflows.TaskIndex.as_view(results_only=True),
+        name="task_index_results",
+    ),
     path("tasks/edit/<int:pk>/", workflows.EditTask.as_view(), name="edit_task"),
     path(
         "tasks/disable/<int:pk>/", workflows.DisableTask.as_view(), name="disable_task"

wagtail/admin/views/chooser.py

@@ -7,7 +7,6 @@ from django.http import Http404
 from django.shortcuts import get_object_or_404
 from django.template.response import TemplateResponse
 from django.urls.base import reverse
-from django.utils.http import urlencode
 from django.utils.translation import gettext_lazy as _
 from django.views.generic.base import View
 
@@ -93,7 +92,7 @@ def can_choose_page(
 
             if user_perm == "move_to":
                 return page_to_move.permissions_for_user(user).can_move_to(page)
-    if user_perm == "copy_to":
+    if user_perm in {"add_subpage", "copy_to"}:
         return page.permissions_for_user(user).can_add_subpage()
 
     return True
@@ -286,6 +285,11 @@ class BrowseView(View):
         selected_locale = None
         locale_options = []
         if self.i18n_enabled:
+            # Ensure query parameters (e.g. `page_type`, `user_perms`, etc.) are
+            # preserved when switching locales, but reset the pagination as the
+            # number of pages might be different.
+            new_params = request.GET.copy()
+            new_params.pop("p", None)
             if self.parent_page.is_root():
                 # 'locale' is the current value of the "Locale" selector in the UI
                 if request.GET.get("locale"):
@@ -298,25 +302,20 @@ class BrowseView(View):
 
                 # we are at the Root level, so get the locales from the current pages
                 choose_url = reverse("wagtailadmin_choose_page")
-                locale_options = [
-                    {
-                        "locale": locale,
-                        "url": choose_url
-                        + "?"
-                        + urlencode(
-                            {
-                                "page_type": page_type_string,
-                                "locale": locale.language_code,
-                            }
-                        ),
-                    }
-                    for locale in Locale.objects.filter(
-                        pk__in=pages.values_list("locale_id")
-                    ).exclude(pk=active_locale_id)
-                ]
+                for locale in Locale.objects.filter(
+                    pk__in=pages.values_list("locale_id")
+                ).exclude(pk=active_locale_id):
+                    new_params["locale"] = locale.language_code
+                    locale_options.append(
+                        {
+                            "locale": locale,
+                            "url": choose_url + "?" + new_params.urlencode(),
+                        }
+                    )
             else:
                 # We have a parent page (that is not the root page). Use its locale as the selected localer
                 selected_locale = self.parent_page.locale
+                new_params.pop("locale", None)
                 # and get the locales based on its available translations
                 locales_and_parent_pages = {
                     item["locale"]: item["pk"]
@@ -332,17 +331,14 @@ class BrowseView(View):
                         "wagtailadmin_choose_page_child",
                         args=[locales_and_parent_pages[locale.pk]],
                     )
-
                     locale_options.append(
                         {
                             "locale": locale,
-                            "url": choose_child_url
-                            + "?"
-                            + urlencode({"page_type": page_type_string}),
+                            "url": choose_child_url + "?" + new_params.urlencode(),
                         }
                     )
 
-            # finally, filter the browseable pages on the selected locale
+            # finally, filter the browsable pages on the selected locale
             if selected_locale:
                 pages = pages.filter(locale=selected_locale)
 
@@ -355,7 +351,7 @@ class BrowseView(View):
         except InvalidPage:
             raise Http404
 
-        # Annotate each page with can_choose/can_decend flags
+        # Annotate each page with can_choose/can_descend flags
         for page in pages:
             page.can_choose = can_choose_page(
                 page,

wagtail/admin/views/collections.py

@@ -5,6 +5,7 @@ from django.utils.translation import gettext_lazy
 from wagtail import hooks
 from wagtail.admin import messages
 from wagtail.admin.forms.collections import CollectionForm
+from wagtail.admin.ui.tables import TitleColumn
 from wagtail.admin.views.generic import CreateView, DeleteView, EditView, IndexView
 from wagtail.models import Collection
 from wagtail.permissions import collection_permission_policy
@@ -14,18 +15,31 @@ class Index(IndexView):
     permission_policy = collection_permission_policy
     model = Collection
     context_object_name = "collections"
-    template_name = "wagtailadmin/collections/index.html"
+    results_template_name = "wagtailadmin/collections/index_results.html"
     add_url_name = "wagtailadmin_collections:add"
     index_url_name = "wagtailadmin_collections:index"
     page_title = gettext_lazy("Collections")
     add_item_label = gettext_lazy("Add a collection")
     header_icon = "folder-open-1"
+    columns = [
+        TitleColumn(
+            "name",
+            label=gettext_lazy("Name"),
+            url_name="wagtailadmin_collections:edit",
+            id_accessor="0",
+            accessor="1",
+        )
+    ]
+    _show_breadcrumbs = True
 
     def get_queryset(self):
         return self.permission_policy.instances_user_has_any_permission_for(
             self.request.user, ["add", "change", "delete"]
         ).exclude(depth=1)
 
+    def get_table(self, object_list):
+        return super().get_table(object_list.get_indented_choices())
+
 
 class Create(CreateView):
     permission_policy = collection_permission_policy
@@ -37,6 +51,7 @@ class Create(CreateView):
     edit_url_name = "wagtailadmin_collections:edit"
     index_url_name = "wagtailadmin_collections:index"
     header_icon = "folder-open-1"
+    _show_breadcrumbs = True
 
     def get_form(self, form_class=None):
         form = super().get_form(form_class)
@@ -67,6 +82,7 @@ class Edit(EditView):
     delete_url_name = "wagtailadmin_collections:delete"
     context_object_name = "collection"
     header_icon = "folder-open-1"
+    _show_breadcrumbs = True
 
     def _user_may_move_collection(self, user, instance):
         """