wagtail 7.1.1__py3-none-any.whl → 7.2rc1__py3-none-any.whl

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/userbar.py

@@ -364,10 +364,15 @@ class Userbar(Component):
             # Remove any unrendered items
             rendered_items = [item for item in rendered_items if item]
 
+            if request:
+                origin = f"{request.scheme}://{request.get_host()}"
+            else:
+                origin = get_admin_base_url() or ""
+
             # Render the userbar items
             return {
                 "request": request,
-                "origin": get_admin_base_url(),
+                "origin": origin,
                 "items": rendered_items,
                 "position": self.position,
                 "page": self.object,

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

wagtail/admin/views/generic/mixins.py

@@ -1,5 +1,4 @@
 import json
-from typing import Optional
 
 from django.conf import settings
 from django.contrib.admin.utils import quote
@@ -38,6 +37,7 @@ from wagtail.models import (
     WorkflowMixin,
     WorkflowState,
 )
+from wagtail.models.orderable import set_max_order
 from wagtail.utils.timestamps import render_timestamp
 
 
@@ -123,7 +123,7 @@ class LocaleMixin:
     def translations(self):
         return self.get_translations() if self.locale else []
 
-    def get_locale(self) -> Optional[Locale]:
+    def get_locale(self) -> Locale | None:
         if not getattr(self, "model", None):
             return None
 
@@ -240,6 +240,15 @@ class IndexViewOptionalFeaturesMixin:
             list_display.append(LiveStatusTagColumn())
         return list_display
 
+    def get_reorder_url(self):
+        if (
+            self.model
+            and issubclass(self.model, DraftStateMixin)
+            and not self.user_has_permission("publish")
+        ):
+            return None
+        return super().get_reorder_url()
+
 
 class CreateEditViewOptionalFeaturesMixin:
     """
@@ -524,6 +533,15 @@ class CreateEditViewOptionalFeaturesMixin:
         else:
             instance = self.form.save()
 
+        # Apply max order number if the model uses custom ordering and the
+        # sort_order_field is not set.
+        if (
+            self.view_name == "create"
+            and self.sort_order_field
+            and getattr(instance, self.sort_order_field) is None
+        ):
+            set_max_order(instance, self.sort_order_field)
+
         self.has_content_changes = self.view_name == "create" or self.form.has_changed()
 
         # Save revision if the model inherits from RevisionMixin