wagtail 7.1.2__py3-none-any.whl → 7.2__py3-none-any.whl

wagtail/admin/tests/test_templatetags.py

@@ -4,6 +4,7 @@ from datetime import datetime, timedelta
 from datetime import timezone as dt_timezone
 from unittest import mock
 
+from django import forms
 from django.conf import settings
 from django.template import Context, Template, TemplateSyntaxError
 from django.test import SimpleTestCase, TestCase
@@ -1084,3 +1085,139 @@ class ThemeColorSchemeTest(AdminTemplateTestUtils, WagtailTestUtils, TestCase):
         meta_tag = soup.find("meta", {"name": "color-scheme"})
         self.assertIsNotNone(meta_tag)
         self.assertEqual(meta_tag["content"], "light")
+
+
+class FormattedfieldTagTestCase(WagtailTestUtils, SimpleTestCase):
+    def render_template(self, template, field_name="title", **context):
+        class BasicForm(forms.Form):
+            title = forms.CharField()
+
+        form = BasicForm(data={})
+
+        html = Template("{% load wagtailadmin_tags %}" + template).render(
+            Context(
+                {
+                    "field": form[field_name],
+                    **context,
+                }
+            )
+        )
+
+        # Parse the rendered HTML for the first DOM element in the output
+        return self.get_soup(html).find()
+
+    def test_basic_usage_with_full_html(self):
+        soup = self.render_template("{% formattedfield field=field %}")
+
+        # check the outer wrapper attributes
+        self.assertEqual(
+            {"class": ["w-field__wrapper"], "data-field-wrapper": ""},
+            soup.attrs,
+        )
+
+        # check the label is correct
+        label = soup.find("label")
+        self.assertIsNotNone(label)
+        self.assertEqual(label["for"], "id_title")
+        self.assertEqual(label["id"], "id_title-label")
+        self.assertEqual(label.get_text().strip(), "Title*")
+
+        # check there is an error container
+        errors = soup.find("div", {"data-field-errors": ""})
+        self.assertIsNotNone(errors)
+        self.assertEqual(errors["class"], ["w-field__errors"])
+        self.assertEqual(errors.get_text().strip(), "This field is required.")
+
+        # check there is a help container that is empty
+        help_text = soup.find("div", {"data-field-help": ""})
+        self.assertIsNotNone(help_text)
+        self.assertEqual(help_text["class"], ["w-field__help"])
+        self.assertEqual(help_text.get_text().strip(), "")
+
+        # check there is an input
+        input = soup.find("input")
+        self.assertIsNotNone(input)
+        self.assertEqual(input["id"], "id_title")
+        self.assertEqual(input["name"], "title")
+        self.assertEqual(input["type"], "text")
+        self.assertEqual(input["required"], "")
+
+        # check the input container & input siblings
+        input_container = input.parent
+        self.assertIsNone(input.find("svg"))  # there should be no icon
+        self.assertEqual(
+            input_container.attrs, {"class": ["w-field__input"], "data-field-input": ""}
+        )  # validate input container
+
+    def test_complex_usage_with_full_html(self):
+        soup = self.render_template(
+            """{% formattedfield field=field wrapper_id="__CUSTOM_ID__" classname="extra-custom-class" sr_only_label=True icon='search' help_text='This is a help text.' show_add_comment_button=True %}"""
+        )
+
+        # check the outer wrapper attributes
+        self.assertEqual(
+            {
+                "class": ["w-field__wrapper", "extra-custom-class"],
+                "id": "__CUSTOM_ID__",
+                "data-field-wrapper": "",
+            },
+            soup.attrs,
+        )
+
+        # check the label is correct
+        label = soup.find("label")
+        self.assertIsNotNone(label)
+        self.assertEqual(label["for"], "id_title")
+        self.assertEqual(label["id"], "id_title-label")
+        self.assertEqual(label.get_text().strip(), "Title*")
+
+        # check there is an error container
+        errors = soup.find("div", {"data-field-errors": ""})
+        self.assertIsNotNone(errors)
+        self.assertEqual(errors["class"], ["w-field__errors"])
+        self.assertEqual(errors.get_text().strip(), "This field is required.")
+
+        # check there is a help container that is empty
+        help_text = soup.find("div", {"data-field-help": ""})
+        self.assertIsNotNone(help_text)
+        self.assertEqual(help_text["class"], ["w-field__help"])
+        self.assertEqual(help_text.get_text().strip(), "This is a help text.")
+
+        # check there is an input
+        input = soup.find("input")
+        self.assertIsNotNone(input)
+        self.assertEqual(input["id"], "id_title")
+        self.assertEqual(input["name"], "title")
+        self.assertEqual(input["type"], "text")
+        self.assertEqual(input["required"], "")
+
+        # check the input container & input siblings
+        input_container = input.parent
+        self.assertEqual(
+            input_container.find("svg").find("use")["href"], "#icon-search"
+        )  # there should be an icon
+        self.assertEqual(
+            input_container.attrs, {"class": ["w-field__input"], "data-field-input": ""}
+        )  # validate input container
+
+    def test_attrs_rendering(self):
+        soup = self.render_template(
+            """{% formattedfield field=field wrapper_id="__CUSTOM_ID__" classname="extra-custom-class" attrs=attrs %}""",
+            attrs={
+                "data-custom-attr": "custom-value",
+                "data-controller": "w-example w-other",
+                "data-field-wrapper": "__CANNOT_OVERRIDE_DEFAULT__",
+            },
+        )
+
+        self.assertEqual(
+            {
+                "class": ["w-field__wrapper", "extra-custom-class"],
+                "id": "__CUSTOM_ID__",
+                "data-custom-attr": "custom-value",
+                "data-controller": "w-example w-other",
+                # wrapper attribute should be preserved
+                "data-field-wrapper": "",
+            },
+            soup.attrs,
+        )

wagtail/admin/tests/test_workflows.py

@@ -26,6 +26,7 @@ from wagtail.admin.utils import (
     get_latest_str,
     get_user_display_name,
 )
+from wagtail.locks import BasicLock
 from wagtail.models import (
     GroupApprovalTask,
     GroupPagePermission,
@@ -41,6 +42,8 @@ from wagtail.models import (
 )
 from wagtail.signals import page_published, published
 from wagtail.test.testapp.models import (
+    CustomLockTask,
+    CustomWorkflowLock,
     FullFeaturedSnippet,
     ModeratedModel,
     MultiPreviewModesPage,
@@ -4851,3 +4854,34 @@ class TestWorkflowStateEmailNotifier(BasePageWorkflowTests):
             with self.subTest(f"Testing with {notification}_notifications"):
                 notifier.notification = notification
                 self.assertSetEqual(notifier.get_valid_recipients(self.object), set())
+
+
+class TestCustomWorkflowLockOnTask(BasePageWorkflowTests):
+    def setup_workflow_and_tasks(self):
+        self.workflow = Workflow.objects.create(name="test_workflow")
+        self.task_1 = CustomLockTask.objects.create(name="test_task_1")
+        WorkflowTask.objects.create(
+            workflow=self.workflow, task=self.task_1, sort_order=1
+        )
+
+    def test_custom_lock_class(self):
+        self.post("submit")
+        response = self.client.get(self.get_url("edit"))
+        self.assertContains(response, "If there is a door, there must be a key")
+        self.assertIsInstance(self.object.get_lock(), CustomWorkflowLock)
+
+    @mock.patch.object(CustomLockTask, "lock_class", new_callable=mock.PropertyMock)
+    def test_typeerror_if_custom_lock_class_inherits_basic_locks(self, mock_property):
+        mock_property.return_value = BasicLock
+
+        self.post("submit")
+
+        with self.assertRaises(TypeError):
+            self.client.get(self.get_url("edit"))
+
+
+class TestCustomWorkflowLockOnTaskWithSnippets(
+    TestCustomWorkflowLockOnTask,
+    BaseSnippetWorkflowTests,
+):
+    pass

wagtail/admin/tests/viewsets/test_model_viewset.py

@@ -1828,3 +1828,325 @@ class TestHeaderButtons(WagtailTestUtils, TestCase):
             [(a.text.strip(), a.get("href")) for a in header_buttons],
             expected_buttons,
         )
+
+
+class TestIndexViewReordering(WagtailTestUtils, TestCase):
+    def setUp(self):
+        self.user = self.login()
+        self.obj1 = FeatureCompleteToy.objects.create(name="Toy 1", sort_order=0)
+        self.obj2 = FeatureCompleteToy.objects.create(name="Toy 2", sort_order=1)
+        self.obj3 = FeatureCompleteToy.objects.create(name="Toy 3", sort_order=2)
+
+    def test_header_button_rendered(self):
+        index_url = reverse("feature_complete_toy:index")
+        custom_ordering_url = index_url + "?ordering=sort_order"
+        response = self.client.get(index_url)
+        self.assertEqual(response.status_code, 200)
+        soup = self.get_soup(response.content)
+        button = soup.select_one(
+            f".w-slim-header .w-dropdown a[href='{custom_ordering_url}']"
+        )
+        self.assertIsNotNone(button)
+        self.assertEqual(button.text.strip(), "Sort item order")
+
+        # Reordering feature disabled when not sorting by sort_order
+        table = soup.select_one("main table")
+        self.assertIsNotNone(table)
+        self.assertFalse(table.get("data-controller"))
+        first_th = soup.select_one("main thead th:first-child")
+        self.assertIsNotNone(first_th)
+        self.assertEqual(first_th.text.strip(), "Name")
+
+    def test_show_ordering_column(self):
+        index_url = reverse("feature_complete_toy:index")
+        custom_ordering_url = index_url + "?ordering=sort_order"
+        response = self.client.get(custom_ordering_url)
+        self.assertEqual(response.status_code, 200)
+        soup = self.get_soup(response.content)
+
+        # The table should have the w-orderable controller
+        table = soup.select_one("main table")
+        self.assertIsNotNone(table)
+        self.assertEqual(table.get("data-controller"), "w-orderable")
+        self.assertEqual(
+            table.get("data-w-orderable-message-value"),
+            "'__LABEL__' has been moved successfully.",
+        )
+        self.assertEqual(
+            table.get("data-w-orderable-url-value"),
+            reverse("feature_complete_toy:reorder", args=[999999]),
+        )
+
+        # The ordering column added as the first column
+        first_th = table.select_one("thead th:first-child")
+        self.assertIsNotNone(first_th)
+        self.assertEqual(first_th.text.strip(), "Sort")
+
+        # All rows have the corresponding attributes for reordering
+        rows = table.select("tbody tr")
+        self.assertEqual(len(rows), 3)
+        expected = [
+            {
+                "id": f"item_{quote(toy.pk)}",
+                "data-w-orderable-item-id": quote(toy.pk),
+                "data-w-orderable-item-label": str(toy),
+                "data-w-orderable-target": "item",
+            }
+            for toy in [self.obj1, self.obj2, self.obj3]
+        ]
+        for row, expected_attrs in zip(rows, expected):
+            for attr, value in expected_attrs.items():
+                self.assertEqual(row.get(attr), value)
+            handle = row.select_one("td button[data-w-orderable-target='handle']")
+            self.assertIsNotNone(handle)
+
+    def test_reordering_disabled_with_explicit_sort_order_field_none(self):
+        # The model has a sort_order_field, but the viewset explicitly sets
+        # sort_order_field = None
+        index_url = reverse("fctoy-alt2:index")
+        custom_ordering_url = index_url + "?ordering=sort_order"
+        response = self.client.get(custom_ordering_url)
+        self.assertEqual(response.status_code, 200)
+        soup = self.get_soup(response.content)
+
+        # Header button for enabling reordering should not be rendered
+        button = soup.select_one(
+            f".w-slim-header .w-dropdown a[href='{custom_ordering_url}']"
+        )
+        self.assertIsNone(button)
+
+        # Reordering feature not enabled
+        table = soup.select_one("main table")
+        self.assertIsNotNone(table)
+        self.assertFalse(table.get("data-controller"))
+        first_th = soup.select_one("main thead th:first-child")
+        self.assertIsNotNone(first_th)
+        self.assertEqual(first_th.text.strip(), "Feature complete toy")
+
+    def test_reordering_disabled_with_no_sort_order_field(self):
+        # This model has no sort_order_field defined on the model nor the viewset
+        JSONStreamModel.objects.create()
+        index_url = reverse("streammodel:index")
+        custom_ordering_url = index_url + "?ordering="
+        response = self.client.get(custom_ordering_url)
+        self.assertEqual(response.status_code, 200)
+        soup = self.get_soup(response.content)
+
+        # Header button for enabling reordering should not be rendered
+        button = soup.select_one(
+            f".w-slim-header .w-dropdown a[href^='{custom_ordering_url}']"
+        )
+        self.assertIsNone(button)
+
+        # Reordering feature not enabled
+        table = soup.select_one("main table")
+        self.assertIsNotNone(table)
+        self.assertFalse(table.get("data-controller"))
+        first_th = soup.select_one("main thead th:first-child")
+        self.assertIsNotNone(first_th)
+        self.assertEqual(first_th.text.strip(), "JSON stream model")
+
+    def test_reordering_disabled_with_insufficient_permission(self):
+        self.user.is_superuser = False
+        self.user.save()
+        admin_permission = Permission.objects.get(
+            content_type__app_label="wagtailadmin", codename="access_admin"
+        )
+        view_permission = Permission.objects.get(
+            content_type__app_label=self.obj1._meta.app_label,
+            codename=get_permission_codename("view", self.obj1._meta),
+        )
+        self.user.user_permissions.add(admin_permission, view_permission)
+
+        index_url = reverse("feature_complete_toy:index")
+        custom_ordering_url = index_url + "?ordering=sort_order"
+        response = self.client.get(custom_ordering_url)
+        self.assertEqual(response.status_code, 200)
+        soup = self.get_soup(response.content)
+
+        # Header button for enabling reordering should not be rendered
+        button = soup.select_one(
+            f".w-slim-header .w-dropdown a[href='{custom_ordering_url}']"
+        )
+        self.assertIsNone(button)
+
+        # Reordering feature not enabled
+        table = soup.select_one("main table")
+        self.assertIsNotNone(table)
+        self.assertFalse(table.get("data-controller"))
+        first_th = soup.select_one("main thead th:first-child")
+        self.assertIsNotNone(first_th)
+        self.assertEqual(first_th.text.strip(), "Name")
+
+    def test_minimal_permission(self):
+        self.user.is_superuser = False
+        self.user.save()
+        admin_permission = Permission.objects.get(
+            content_type__app_label="wagtailadmin", codename="access_admin"
+        )
+        change_permission = Permission.objects.get(
+            content_type__app_label=self.obj1._meta.app_label,
+            codename=get_permission_codename("change", self.obj1._meta),
+        )
+        self.user.user_permissions.add(admin_permission, change_permission)
+
+        self.test_header_button_rendered()
+        self.test_show_ordering_column()
+
+
+class TestCreateViewReordering(WagtailTestUtils, TestCase):
+    def setUp(self):
+        self.user = self.login()
+        FeatureCompleteToy.objects.bulk_create(
+            [
+                FeatureCompleteToy(name="Toy 1", sort_order=0),
+                FeatureCompleteToy(name="Toy 2", sort_order=1),
+                FeatureCompleteToy(name="Toy 3", sort_order=2),
+            ]
+        )
+
+    def test_create_sets_max_sort_order(self):
+        response = self.client.post(
+            reverse("feature_complete_toy:add"),
+            data={"name": "New Toy", "release_date": "2025-08-17"},
+        )
+        self.assertRedirects(response, reverse("feature_complete_toy:index"))
+        new_toy = FeatureCompleteToy.objects.get(name="New Toy")
+        self.assertEqual(new_toy.sort_order, 3)
+
+    def test_create_does_not_set_max_sort_order_without_sort_order_field(self):
+        response = self.client.post(
+            reverse("fctoy-alt2:add"),
+            data={"name": "New Toy", "release_date": "2025-08-17", "strid": "foo"},
+        )
+        self.assertRedirects(response, reverse("fctoy-alt2:index"))
+        new_toy = FeatureCompleteToy.objects.get(name="New Toy")
+        self.assertIsNone(new_toy.sort_order)
+
+
+class TestReorderView(WagtailTestUtils, TestCase):
+    def setUp(self):
+        self.user = self.login()
+        # We don't do any normalization, so the sort_order values may not be
+        # consecutive integers (e.g. after an item is deleted), and the update
+        # logic may cause the sort_order values to be negative or larger than
+        # the number of items in the queryset.
+        self.obj1 = FeatureCompleteToy.objects.create(name="Toy 1", sort_order=-3)
+        self.obj2 = FeatureCompleteToy.objects.create(name="Toy 2", sort_order=4)
+        self.obj3 = FeatureCompleteToy.objects.create(name="Toy 3", sort_order=9)
+
+    def get_url(self, obj):
+        return reverse("feature_complete_toy:reorder", args=(quote(obj.pk),))
+
+    def assertOrder(self, objs):
+        self.assertSequenceEqual(
+            [
+                (obj, obj.sort_order)
+                for obj in FeatureCompleteToy.objects.order_by("sort_order")
+            ],
+            objs,
+        )
+
+    def test_reorder_view_disabled_without_sort_order_field(self):
+        # The alt2 viewset explicitly sets sort_order_field to `None`,
+        # so the reorder view should not be available
+        with self.assertRaises(NoReverseMatch):
+            reverse("fctoy-alt2:reorder", args=(quote(self.obj1.pk),))
+
+        # This model has no sort_order_field on the model nor the viewset
+        obj = JSONStreamModel.objects.create()
+        with self.assertRaises(NoReverseMatch):
+            reverse("streammodel:reorder", args=(quote(obj.pk),))
+
+    def test_get_request_does_not_alter_order(self):
+        response = self.client.get(self.get_url(self.obj1))
+        self.assertEqual(response.status_code, 405)
+
+        # Ensure item order does not change
+        self.assertOrder([(self.obj1, -3), (self.obj2, 4), (self.obj3, 9)])
+
+    def test_post_request_without_position_argument_moves_to_the_end(self):
+        response = self.client.post(self.get_url(self.obj1))
+        self.assertEqual(response.status_code, 200)
+
+        # The item will be moved to the last position by taking the sort_order
+        # of the last item, and the sort_order of the other items updated by -1
+        self.assertOrder([(self.obj2, 3), (self.obj3, 8), (self.obj1, 9)])
+
+    def test_post_request_with_non_integer_position_moves_to_the_end(self):
+        response = self.client.post(self.get_url(self.obj1) + "?position=good")
+        self.assertEqual(response.status_code, 200)
+
+        # The item will be moved to the last position by taking the sort_order
+        # of the last item, and the sort_order of the other items updated by -1
+        self.assertOrder([(self.obj2, 3), (self.obj3, 8), (self.obj1, 9)])
+
+    def test_move_position_up(self):
+        # Move obj3 to the first position
+        response = self.client.post(self.get_url(self.obj3) + "?position=0")
+        self.assertEqual(response.status_code, 200)
+
+        # Check if obj3 is now the first item by taking obj1's sort_order and
+        # incrementing sort_order of the other items after it by 1
+        self.assertOrder([(self.obj3, -3), (self.obj1, -2), (self.obj2, 5)])
+
+    def test_move_position_down(self):
+        # Move obj1 to the second position
+        response = self.client.post(self.get_url(self.obj1) + "?position=1")
+        self.assertEqual(response.status_code, 200)
+
+        # Check if obj1 is now the second item by taking obj2's sort_order
+        # and decrementing sort_order of the other items before it by 1
+        self.assertOrder([(self.obj2, 3), (self.obj1, 4), (self.obj3, 9)])
+
+    def test_move_position_to_same_position(self):
+        # Move obj1 to position 0 (where it already is)
+        response = self.client.post(self.get_url(self.obj1) + "?position=0")
+        self.assertEqual(response.status_code, 200)
+
+        # Ensure item order does not change
+        self.assertOrder([(self.obj1, -3), (self.obj2, 4), (self.obj3, 9)])
+
+    def test_move_position_with_invalid_target_position(self):
+        response = self.client.post(self.get_url(self.obj1) + "?position=99")
+        self.assertEqual(response.status_code, 200)
+
+        # The item will be moved to the last position by taking the sort_order
+        # of the last item, and the sort_order of the other items updated by -1
+        self.assertOrder([(self.obj2, 3), (self.obj3, 8), (self.obj1, 9)])
+
+    def test_insufficient_permission(self):
+        self.user.is_superuser = False
+        self.user.save()
+        admin_permission = Permission.objects.get(
+            content_type__app_label="wagtailadmin", codename="access_admin"
+        )
+        view_permission = Permission.objects.get(
+            content_type__app_label=self.obj1._meta.app_label,
+            codename=get_permission_codename("view", self.obj1._meta),
+        )
+        self.user.user_permissions.add(admin_permission, view_permission)
+
+        response = self.client.post(self.get_url(self.obj1) + "?position=1")
+        self.assertEqual(response.status_code, 302)
+        self.assertRedirects(response, reverse("wagtailadmin_home"))
+        self.assertOrder([(self.obj1, -3), (self.obj2, 4), (self.obj3, 9)])
+
+    def test_minimal_permission(self):
+        self.user.is_superuser = False
+        self.user.save()
+        admin_permission = Permission.objects.get(
+            content_type__app_label="wagtailadmin", codename="access_admin"
+        )
+        change_permission = Permission.objects.get(
+            content_type__app_label=self.obj1._meta.app_label,
+            codename=get_permission_codename("change", self.obj1._meta),
+        )
+        self.user.user_permissions.add(admin_permission, change_permission)
+
+        response = self.client.post(self.get_url(self.obj1) + "?position=1")
+        self.assertEqual(response.status_code, 200)
+
+        # Check if obj1 is now the second item by taking obj2's sort_order
+        # and decrementing sort_order of the other items before it by 1
+        self.assertOrder([(self.obj2, 3), (self.obj1, 4), (self.obj3, 9)])

wagtail/admin/ui/tables/orderable.py

@@ -0,0 +1,73 @@
+from collections import OrderedDict
+
+from django.contrib.admin.utils import quote
+from django.utils.functional import cached_property
+from django.utils.translation import gettext, gettext_lazy
+
+from wagtail.admin.ui.tables import BaseColumn, BulkActionsCheckboxColumn
+
+
+class OrderingColumn(BaseColumn):
+    header_template_name = "wagtailadmin/tables/ordering_header.html"
+    cell_template_name = "wagtailadmin/tables/ordering_cell.html"
+
+
+class OrderableTableMixin:
+    success_message = gettext_lazy("'%(page_title)s' has been moved successfully.")
+
+    def __init__(self, *args, sort_order_field=None, reorder_url=None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.sort_order_field = sort_order_field
+        self.reorder_url = reorder_url
+        if self.reorder_url:
+            self._add_ordering_column()
+
+    @cached_property
+    def ordering_column(self):
+        return OrderingColumn("ordering", width="80px", sort_key=self.sort_order_field)
+
+    def _add_ordering_column(self):
+        self.columns = OrderedDict(
+            [(self.ordering_column.name, self.ordering_column)]
+            + [
+                (column_name, column)
+                for column_name, column in self.columns.items()
+                # Replace bulk actions column with the ordering column if it exists
+                if not isinstance(column, BulkActionsCheckboxColumn)
+            ]
+        )
+
+    @property
+    def attrs(self):
+        attrs = super().attrs
+        if self.reorder_url:
+            attrs = {
+                **attrs,
+                "data-controller": "w-orderable",
+                "data-w-orderable-active-class": "w-orderable--active",
+                "data-w-orderable-chosen-class": "w-orderable__item--active",
+                "data-w-orderable-container-value": "tbody",
+                "data-w-orderable-message-value": self.get_success_message(),
+                "data-w-orderable-url-value": self.reorder_url,
+            }
+        return attrs
+
+    def get_success_message(self):
+        return self.success_message % {"page_title": "__LABEL__"}
+
+    def get_row_attrs(self, instance):
+        attrs = super().get_row_attrs(instance)
+        if self.reorder_url:
+            attrs["id"] = "item_%s" % quote(instance.pk)
+            attrs["data-w-orderable-item-id"] = quote(instance.pk)
+            attrs["data-w-orderable-item-label"] = str(instance)
+            attrs["data-w-orderable-target"] = "item"
+        return attrs
+
+    def get_caption(self):
+        caption = super().get_caption()
+        if not caption and self.reorder_url:
+            return gettext(
+                "Focus on the drag button and press up or down arrows to move the item, then press enter to submit the change."
+            )
+        return caption

wagtail/admin/ui/tables/pages.py

@@ -2,6 +2,7 @@ from django.utils.safestring import mark_safe
 from django.utils.translation import gettext
 
 from wagtail.admin.ui.tables import BaseColumn, BulkActionsCheckboxColumn, Column, Table
+from wagtail.admin.ui.tables.orderable import OrderableTableMixin
 
 
 class PageTitleColumn(BaseColumn):
@@ -77,11 +78,6 @@ class BulkActionsColumn(BulkActionsCheckboxColumn):
         return context
 
 
-class OrderingColumn(BaseColumn):
-    header_template_name = "wagtailadmin/pages/listing/_ordering_header.html"
-    cell_template_name = "wagtailadmin/pages/listing/_ordering_cell.html"
-
-
 class PageTypeColumn(Column):
     def get_header_context_data(self, parent_context):
         context = super().get_header_context_data(parent_context)
@@ -109,11 +105,10 @@ class NavigateToChildrenColumn(BaseColumn):
         return mark_safe("<td></td>")
 
 
-class PageTable(Table):
+class PageTable(OrderableTableMixin, Table):
     def __init__(
         self,
         *args,
-        use_row_ordering_attributes=False,
         parent_page=None,
         show_locale_labels=False,
         actions_next_url=None,
@@ -121,9 +116,6 @@ class PageTable(Table):
     ):
         super().__init__(*args, **kwargs)
 
-        # If true, attributes will be added on the <tr> element to support reordering
-        self.use_row_ordering_attributes = use_row_ordering_attributes
-
         # The parent page of the pages being listed - used to add extra context to the title text
         # of the reordering links. Leave this undefined if the pages being listed do not share a
         # common parent.
@@ -163,11 +155,9 @@ class PageTable(Table):
 
     def get_row_attrs(self, instance):
         attrs = super().get_row_attrs(instance)
-        if self.use_row_ordering_attributes:
+        if self.reorder_url:
             attrs["id"] = "page_%d" % instance.id
-            attrs["data-w-orderable-item-id"] = instance.id
             attrs["data-w-orderable-item-label"] = instance.get_admin_display_title()
-            attrs["data-w-orderable-target"] = "item"
         return attrs
 
     def get_context_data(self, parent_context):

wagtail/admin/views/collection_privacy.py

@@ -1,5 +1,6 @@
 from django.core.exceptions import PermissionDenied
 from django.shortcuts import get_object_or_404
+from django.urls import reverse
 
 from wagtail.admin.forms.collections import CollectionViewRestrictionForm
 from wagtail.admin.modal_workflow import render_modal_workflow
@@ -69,10 +70,13 @@ def set_privacy(request, collection_id):
         # no restriction set at ancestor level - can set restrictions here
         return render_modal_workflow(
             request,
-            "wagtailadmin/collection_privacy/set_privacy.html",
+            "wagtailadmin/shared/set_privacy.html",
             None,
             {
-                "collection": collection,
+                "action_url": reverse(
+                    "wagtailadmin_collections:set_privacy", args=(collection.pk,)
+                ),
+                "object": collection,
                 "form": form,
             },
             json_data={"step": "set_privacy"},

wagtail/admin/views/generic/__init__.py

@@ -26,5 +26,6 @@ from .models import (  # noqa: F401
     RevisionsUnscheduleView,
     UnpublishView,
 )
+from .ordering import ReorderView  # noqa: F401
 from .permissions import PermissionCheckedMixin  # noqa: F401
 from .usage import UsageView  # noqa: F401