wagtail 7.0.2__py3-none-any.whl → 7.1rc1__py3-none-any.whl

wagtail/models/preview.py

@@ -150,7 +150,12 @@ class PreviewableMixin:
         Return the URL that _get_dummy_headers() should use to set META headers
         for the faked HttpRequest.
         """
-        return self.full_url
+        if url := self.full_url:
+            return url
+        # If no full_url is defined, try to use the original request's URL
+        # to build a dummy request so that we get the correct scheme and host.
+        if original_request:
+            return original_request.build_absolute_uri("/")
 
     def get_full_url(self):
         return None
@@ -263,6 +268,9 @@ class PreviewableMixin:
     def get_preview_context(self, request, mode_name):
         """
         Returns a context dictionary for use in templates for previewing this object.
+
+        By default, this returns a dictionary containing the ``request`` and
+        and the ``object`` itself.
         """
         return {"object": self, "request": request}
 

wagtail/models/reference_index.py

@@ -1,8 +1,12 @@
 import uuid
+from itertools import groupby
 
 from django.contrib.contenttypes.fields import GenericForeignKey, GenericRel
 from django.contrib.contenttypes.models import ContentType
+from django.core.exceptions import FieldDoesNotExist
 from django.db import connection, models
+from django.db.models import CharField, Count, OuterRef, Subquery
+from django.db.models.functions import Cast, Coalesce
 from django.utils.functional import cached_property
 from django.utils.text import capfirst
 from django.utils.translation import gettext_lazy as _
@@ -19,7 +23,7 @@ class ReferenceGroups:
     Groups records in a ReferenceIndex queryset by their source object.
 
     Args:
-        qs: (QuerySet[ReferenceIndex]) A QuerySet on the ReferenceIndex model
+        qs: (QuerySet[ReferenceIndex] | list[ReferenceIndex]) A QuerySet or list of ReferenceIndex instances
 
     Yields:
         A tuple (source_object, references) for each source object that appears
@@ -29,7 +33,10 @@ class ReferenceGroups:
     """
 
     def __init__(self, qs):
-        self.qs = qs.order_by("base_content_type", "object_id")
+        if isinstance(qs, models.QuerySet):
+            self.qs = qs.order_by("base_content_type", "object_id")
+        else:
+            self.qs = sorted(qs, key=lambda x: (x.base_content_type_id, x.object_id))
 
     def __iter__(self):
         reference_fk = None
@@ -56,7 +63,14 @@ class ReferenceGroups:
 
     @cached_property
     def _count(self):
-        return self.qs.values("base_content_type", "object_id").distinct().count()
+        if isinstance(self.qs, models.QuerySet) and not self.qs._result_cache:
+            return self.qs.values("base_content_type", "object_id").distinct().count()
+        return len(
+            {
+                (reference.base_content_type_id, reference.object_id)
+                for reference in self.qs
+            }
+        )
 
     @cached_property
     def is_protected(self):
@@ -84,6 +98,22 @@ class ReferenceIndexQuerySet(models.QuerySet):
         """
         return ReferenceGroups(self)
 
+    def group_by_source_object_in_bulk(self):
+        """
+        Returns a dict that maps (to_content_type_id, to_object_id) to a
+        ReferenceGroups object for this queryset that will yield references
+        grouped by their source instance for each referenced instance.
+        """
+        qs = self.order_by(
+            "to_content_type", "to_object_id", "base_content_type", "object_id"
+        )
+        return {
+            key: ReferenceGroups(list(references))
+            for key, references in groupby(
+                qs, key=lambda x: (x.to_content_type_id, x.to_object_id)
+            )
+        }
+
 
 class ReferenceIndex(models.Model):
     """
@@ -556,6 +586,41 @@ class ReferenceIndex(models.Model):
             to_object_id=object.pk,
         )
 
+    @classmethod
+    def get_references_to_in_bulk(cls, objects):
+        """
+        Returns all inbound references for the given objects.
+
+        Args:
+            objects: An iterable of model instances to fetch ReferenceIndex
+            records for, which may be of different models
+
+        Returns:
+            A QuerySet of ReferenceIndex records
+        """
+        if isinstance(objects, models.QuerySet):
+            return cls.objects.filter(
+                to_content_type_id=cls._get_base_content_type(objects.model).pk,
+                to_object_id__in=objects.values_list(
+                    Cast("pk", output_field=models.CharField()),
+                    flat=True,
+                ),
+            )
+        if not objects:
+            return cls.objects.none()
+
+        objects_by_ct = groupby(
+            sorted(objects, key=lambda obj: cls._get_base_content_type(obj).pk),
+            key=lambda obj: cls._get_base_content_type(obj).pk,
+        )
+        condition = models.Q()
+        for content_type_id, objs in objects_by_ct:
+            condition |= models.Q(
+                to_content_type_id=content_type_id,
+                to_object_id__in=[str(obj.pk) for obj in objs],
+            )
+        return cls.objects.filter(condition)
+
     @classmethod
     def get_grouped_references_to(cls, object):
         """
@@ -570,6 +635,45 @@ class ReferenceIndex(models.Model):
         """
         return cls.get_references_to(object).group_by_source_object()
 
+    @classmethod
+    def get_grouped_references_to_in_bulk(cls, objects):
+        """
+        Returns all inbound references for the given objects, grouped by the object
+        they are found on for each given object.
+
+        Args:
+            object: An iterable of model instances to fetch ReferenceIndex records for
+
+        Returns:
+            An dict that maps a model instance to a ReferenceGroups object
+        """
+        references = cls.get_references_to_in_bulk(objects)
+        grouped_references = references.group_by_source_object_in_bulk()
+        return {
+            object: grouped_references.get(
+                (cls._get_base_content_type(object).pk, str(object.pk)),
+                ReferenceGroups([]),
+            )
+            for object in objects
+        }
+
+    @classmethod
+    def usage_count_subquery(cls, model):
+        return Coalesce(
+            Subquery(
+                ReferenceIndex.objects.filter(
+                    to_content_type=ContentType.objects.get_for_model(model),
+                    to_object_id=Cast(OuterRef("pk"), output_field=CharField()),
+                )
+                .values("object_id", "to_object_id")
+                .distinct()
+                .values("to_object_id")
+                .annotate(count=Count("object_id", distinct=True))
+                .values("count")
+            ),
+            0,
+        )
+
     @property
     def _content_type(self):
         # Accessing a ContentType from a ForeignKey does not make use of the
@@ -618,8 +722,24 @@ class ReferenceIndex(models.Model):
         """
         model_path_components = self.model_path.split(".")
         field_name = model_path_components[0]
-        field = self._content_type.model_class()._meta.get_field(field_name)
-        return field
+        model_class = self._content_type.model_class()
+        try:
+            field = model_class._meta.get_field(field_name)
+        except FieldDoesNotExist:
+            # For related fields, get_field() only works with the
+            # related_query_name, but we store the reference information using
+            # get_accessor_name() which uses the related_name. In the case where
+            # the two are different, we use get_fields() to find the field
+            # that matches the related_name.
+            for field in model_class._meta.get_fields():
+                if (
+                    isinstance(field, models.ForeignObjectRel)
+                    and field.related_name == field_name
+                ):
+                    return field
+            raise
+        else:
+            return field
 
     @cached_property
     def related_field(self):

wagtail/models/revisions.py

@@ -1,7 +1,7 @@
 import logging
 
 from django.conf import settings
-from django.contrib.contenttypes.fields import GenericForeignKey
+from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
 from django.contrib.contenttypes.models import ContentType
 from django.core.serializers.json import DjangoJSONEncoder
 from django.db import models
@@ -258,6 +258,28 @@ class RevisionMixin(models.Model):
         editable=False,
     )
 
+    _revisions = GenericRelation(
+        "wagtailcore.Revision",
+        content_type_field="content_type",
+        object_id_field="object_id",
+        for_concrete_model=False,
+    )
+    """
+    A default ``GenericRelation`` for the purpose of automatically deleting
+    revisions when the object is deleted. This is not used to query the object's
+    revisions. Instead, the :meth:`revisions` property is used for that purpose.
+    As such, this default relation is considered private.
+
+    This ``GenericRelation`` does not have a
+    :attr:`~django.contrib.contenttypes.fields.GenericRelation.related_query_name`,
+    so it cannot be used for reverse-related queries from ``Revision`` back to
+    this model. If the feature is desired, subclasses can define their own
+    ``GenericRelation`` to ``Revision`` with a custom ``related_query_name``.
+
+    .. versionadded:: 7.1
+        The default ``GenericRelation`` :attr:`~wagtail.models.RevisionMixin._revisions` was added.
+    """
+
     # An array of additional field names that will not be included when the object is copied.
     default_exclude_fields_in_copy = [
         "latest_revision",
@@ -266,19 +288,15 @@ class RevisionMixin(models.Model):
     @property
     def revisions(self):
         """
-        Returns revisions that belong to the object.
-
-        Subclasses should define a
-        :class:`~django.contrib.contenttypes.fields.GenericRelation` to
-        :class:`~wagtail.models.Revision` and override this property to return
-        that ``GenericRelation``. This allows subclasses to customize the
-        ``related_query_name`` of the ``GenericRelation`` and add custom logic
-        (e.g. to always use the specific instance in ``Page``).
+        Returns revisions that belong to the object. For non-page models, this
+        is done by querying the :class:`~wagtail.models.Revision` model directly
+        rather than using a
+        :class:`~django.contrib.contenttypes.fields.GenericRelation`, to avoid
+        `a known limitation <https://code.djangoproject.com/ticket/31269>`_ in
+        Django for models with multi-table inheritance where the relation's
+        content type may not match the instance's type.
         """
-        return Revision.objects.filter(
-            content_type=self.get_content_type(),
-            object_id=self.pk,
-        )
+        return Revision.objects.for_instance(self)
 
     def get_base_content_type(self):
         parents = self._meta.get_parent_list()

wagtail/models/sites.py

@@ -2,6 +2,7 @@ from collections import namedtuple
 
 from django.apps import apps
 from django.conf import settings
+from django.contrib.auth.models import Group, Permission
 from django.core.cache import cache
 from django.core.exceptions import ValidationError
 from django.db import models
@@ -268,3 +269,50 @@ class Site(models.Model):
     @staticmethod
     def clear_site_root_paths_cache():
         cache.delete(SITE_ROOT_PATHS_CACHE_KEY, version=SITE_ROOT_PATHS_CACHE_VERSION)
+
+
+class GroupSitePermissionManager(models.Manager):
+    def get_by_natural_key(self, group, site, permission):
+        return self.get(group=group, site=site, permission=permission)
+
+
+class GroupSitePermission(models.Model):
+    """
+    A rule indicating that a group has permission for some action (e.g. "edit social media settings")
+    within a specified site.
+    """
+
+    group = models.ForeignKey(
+        Group,
+        verbose_name=_("group"),
+        related_name="site_permissions",
+        on_delete=models.CASCADE,
+    )
+    site = models.ForeignKey(
+        Site,
+        verbose_name=_("site"),
+        related_name="group_permissions",
+        on_delete=models.CASCADE,
+    )
+    permission = models.ForeignKey(
+        Permission, verbose_name=_("permission"), on_delete=models.CASCADE
+    )
+
+    def __str__(self):
+        return "Group %d ('%s') has permission '%s' on site %d ('%s')" % (
+            self.group.id,
+            self.group,
+            self.permission,
+            self.site.id,
+            self.site,
+        )
+
+    def natural_key(self):
+        return (self.group, self.site, self.permission)
+
+    objects = GroupSitePermissionManager()
+
+    class Meta:
+        unique_together = ("group", "site", "permission")
+        verbose_name = _("group site permission")
+        verbose_name_plural = _("group site permissions")

wagtail/models/workflows.py

@@ -1,7 +1,7 @@
 from django import forms
 from django.conf import settings
 from django.contrib.auth.models import Group
-from django.contrib.contenttypes.fields import GenericForeignKey
+from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
 from django.contrib.contenttypes.models import ContentType
 from django.core import checks
 from django.core.exceptions import PermissionDenied, ValidationError
@@ -1158,9 +1158,35 @@ class TaskState(SpecificMixin, models.Model):
         verbose_name_plural = _("Task states")
 
 
-class WorkflowMixin:
+class WorkflowMixin(models.Model):
     """A mixin that allows a model to have workflows."""
 
+    _workflow_states = GenericRelation(
+        "wagtailcore.WorkflowState",
+        content_type_field="base_content_type",
+        object_id_field="object_id",
+        for_concrete_model=False,
+    )
+    """
+    A default ``GenericRelation`` for the purpose of automatically deleting
+    workflow states when the object is deleted. This is not used to query the
+    object's workflow states. Instead, the :meth:`workflow_states` property is
+    used for that purpose. As such, this default relation is considered private.
+
+    This ``GenericRelation`` does not have a
+    :attr:`~django.contrib.contenttypes.fields.GenericRelation.related_query_name`,
+    so it cannot be used for reverse-related queries from ``WorkflowState`` back
+    to this model. If the feature is desired, subclasses can define their own
+    ``GenericRelation`` to ``WorkflowState`` with a custom
+    ``related_query_name``.
+
+    .. versionadded:: 7.1
+        The default ``GenericRelation`` :attr:`~wagtail.models.WorkflowMixin._workflow_states` was added.
+    """
+
+    class Meta:
+        abstract = True
+
     @classmethod
     def check(cls, **kwargs):
         return [
@@ -1239,15 +1265,13 @@ class WorkflowMixin:
     @property
     def workflow_states(self):
         """
-        Returns workflow states that belong to the object.
-
-        To allow filtering ``WorkflowState`` queries by the object,
-        subclasses should define a
-        :class:`~django.contrib.contenttypes.fields.GenericRelation` to
-        :class:`~wagtail.models.WorkflowState` with the desired
-        ``related_query_name``. This property can be replaced with the
-        ``GenericRelation`` or overridden to allow custom logic, which can be
-        useful if the model has inheritance.
+        Returns workflow states that belong to the object. For non-page models,
+        this is done by querying the :class:`~wagtail.models.WorkflowState`
+        model directly rather than using a
+        :class:`~django.contrib.contenttypes.fields.GenericRelation`, to avoid
+        `a known limitation <https://code.djangoproject.com/ticket/31269>`_ in
+        Django for models with multi-table inheritance where the relation's
+        content type may not match the instance's type.
         """
         return WorkflowState.objects.for_instance(self)
 

wagtail/permission_policies/base.py

@@ -135,9 +135,9 @@ class BasePermissionPolicy:
         permission to perform any of the given actions
         """
         if self.user_has_any_permission(user, actions):
-            return self.model.objects.all()
+            return self.model._default_manager.all()
         else:
-            return self.model.objects.none()
+            return self.model._default_manager.none()
 
     def instances_user_has_permission_for(self, user, action):
         """
@@ -387,22 +387,24 @@ class OwnershipPermissionPolicy(BaseDjangoAuthPermissionPolicy):
         if user.is_active and user.is_superuser:
             # active superusers can perform any action (including unrecognised ones)
             # on any instance
-            return self.model.objects.all()
+            return self.model._default_manager.all()
         elif "change" in actions or "delete" in actions:
             if user.has_perm(self._get_permission_name("change")):
                 # user can edit all instances
-                return self.model.objects.all()
+                return self.model._default_manager.all()
             elif user.has_perm(self._get_permission_name("add")):
                 # user can edit their own instances
-                return self.model.objects.filter(**{self.owner_field_name: user})
+                return self.model._default_manager.filter(
+                    **{self.owner_field_name: user}
+                )
             else:
                 # user has no permissions at all on this model
-                return self.model.objects.none()
+                return self.model._default_manager.none()
         else:
             # action is either not recognised, or is the 'add' action which is
             # not meaningful for existing instances. As such, non-superusers
             # cannot perform it on any existing instances.
-            return self.model.objects.none()
+            return self.model._default_manager.none()
 
     def users_with_any_permission_for_instance(self, actions, instance):
         if "change" in actions or "delete" in actions:

wagtail/permission_policies/collections.py

@@ -187,12 +187,12 @@ class CollectionPermissionPolicy(
         permission to perform any of the given actions
         """
         if not (user.is_active and user.is_authenticated):
-            return self.model.objects.none()
+            return self.model._default_manager.none()
         elif user.is_superuser:
-            return self.model.objects.all()
+            return self.model._default_manager.all()
         else:
             # filter to just the collections with this permission
-            return self.model.objects.filter(
+            return self.model._default_manager.filter(
                 collection__in=list(self._collections_with_perm(user, actions))
             )
 
@@ -299,9 +299,9 @@ class CollectionOwnershipPermissionPolicy(
         if user.is_active and user.is_superuser:
             # active superusers can perform any action (including unrecognised ones)
             # on any instance
-            return self.model.objects.all()
+            return self.model._default_manager.all()
         elif not user.is_authenticated:
-            return self.model.objects.none()
+            return self.model._default_manager.none()
         elif known_actions:
             # if "change" or "delete" in actions, return instances which are:
             #   - in (a descendant of) a collection for which they have "change" permission
@@ -322,12 +322,12 @@ class CollectionOwnershipPermissionPolicy(
                     collection__in=self._collections_with_perm(user, ["add"])
                 ) & Q(**{self.owner_field_name: user})
 
-            return self.model.objects.filter(perm_filter)
+            return self.model._default_manager.filter(perm_filter)
         else:
             # action is either not recognised, or is the 'add' action which is
             # not meaningful for existing instances. As such, non-superusers
             # cannot perform it on any existing instances.
-            return self.model.objects.none()
+            return self.model._default_manager.none()
 
     def users_with_any_permission_for_instance(self, actions, instance):
         known_actions = set(actions) & {"choose", "change"}