wagtail 6.4.1__py3-none-any.whl → 7.0rc1__py3-none-any.whl

wagtail/models/pages.py

@@ -0,0 +1,2754 @@
+from __future__ import annotations
+
+import functools
+import logging
+import posixpath
+import uuid
+
+from django.conf import settings
+from django.contrib.auth.models import Group, Permission
+from django.contrib.contenttypes.fields import GenericRelation
+from django.contrib.contenttypes.models import ContentType
+from django.core import checks
+from django.core.exceptions import (
+    FieldDoesNotExist,
+    ValidationError,
+)
+from django.db import models, transaction
+from django.db.models import Q, Value
+from django.db.models.expressions import Subquery
+from django.db.models.functions import Concat, Substr
+from django.dispatch import receiver
+from django.http import Http404, HttpRequest, HttpResponse, HttpResponseNotAllowed
+from django.template.response import TemplateResponse
+from django.urls import NoReverseMatch, reverse
+from django.utils import translation as translation
+from django.utils.encoding import force_bytes, force_str
+from django.utils.functional import Promise, cached_property
+from django.utils.text import capfirst, slugify
+from django.utils.translation import gettext_lazy as _
+from modelcluster.fields import ParentalKey
+from modelcluster.models import (
+    ClusterableModel,
+)
+from treebeard.mp_tree import MP_Node
+
+from wagtail.actions.copy_for_translation import CopyPageForTranslationAction
+from wagtail.actions.copy_page import CopyPageAction
+from wagtail.actions.create_alias import CreatePageAliasAction
+from wagtail.actions.delete_page import DeletePageAction
+from wagtail.actions.move_page import MovePageAction
+from wagtail.actions.publish_page_revision import PublishPageRevisionAction
+from wagtail.actions.unpublish_page import UnpublishPageAction
+from wagtail.compat import HTTPMethod
+from wagtail.coreutils import (
+    WAGTAIL_APPEND_SLASH,
+    camelcase_to_underscore,
+    get_supported_content_language_variant,
+    resolve_model_string,
+    safe_md5,
+)
+from wagtail.fields import StreamField
+from wagtail.log_actions import log
+from wagtail.query import PageQuerySet
+from wagtail.search import index
+from wagtail.signals import (
+    page_published,
+    page_slug_changed,
+    pre_validate_delete,
+)
+from wagtail.url_routing import RouteResult
+from wagtail.utils.timestamps import ensure_utc
+
+from .audit_log import BaseLogEntry, BaseLogEntryManager, LogEntryQuerySet
+from .content_types import get_default_page_content_type
+from .copying import _copy_m2m_relations
+from .draft_state import DraftStateMixin
+from .i18n import Locale, TranslatableMixin
+from .locking import LockableMixin
+from .panels import CommentPanelPlaceholder, PanelPlaceholder
+from .preview import PreviewableMixin
+from .revisions import Revision, RevisionMixin
+from .sites import Site
+from .specific import SpecificMixin
+from .view_restrictions import BaseViewRestriction
+from .workflows import WorkflowMixin
+
+logger = logging.getLogger("wagtail")
+
+PAGE_TEMPLATE_VAR = "page"
+COMMENTS_RELATION_NAME = getattr(
+    settings, "WAGTAIL_COMMENTS_RELATION_NAME", "wagtail_admin_comments"
+)
+
+
+@receiver(pre_validate_delete, sender=Locale)
+def reassign_root_page_locale_on_delete(sender, instance, **kwargs):
+    # if we're deleting the locale used on the root page node, reassign that to a new locale first
+    root_page_with_this_locale = Page.objects.filter(depth=1, locale=instance)
+    if root_page_with_this_locale.exists():
+        # Select the default locale, if one exists and isn't the one being deleted
+        try:
+            new_locale = Locale.get_default()
+            default_locale_is_ok = new_locale != instance
+        except (Locale.DoesNotExist, LookupError):
+            default_locale_is_ok = False
+
+        if not default_locale_is_ok:
+            # fall back on any remaining locale
+            new_locale = Locale.all_objects.exclude(pk=instance.pk).first()
+
+        root_page_with_this_locale.update(locale=new_locale)
+
+
+PAGE_MODEL_CLASSES = []
+
+
+def get_page_models():
+    """
+    Returns a list of all non-abstract Page model classes defined in this project.
+    """
+    return PAGE_MODEL_CLASSES.copy()
+
+
+def get_page_content_types(include_base_page_type=True):
+    """
+    Returns a queryset of all ContentType objects corresponding to Page model classes.
+    """
+    models = get_page_models()
+    if not include_base_page_type:
+        models.remove(Page)
+
+    content_type_ids = [
+        ct.pk for ct in ContentType.objects.get_for_models(*models).values()
+    ]
+    return ContentType.objects.filter(pk__in=content_type_ids).order_by("model")
+
+
+@functools.cache
+def get_streamfield_names(model_class):
+    return tuple(
+        field.name
+        for field in model_class._meta.concrete_fields
+        if isinstance(field, StreamField)
+    )
+
+
+class BasePageManager(models.Manager):
+    def get_queryset(self):
+        return self._queryset_class(self.model).order_by("path")
+
+    def first_common_ancestor_of(self, pages, include_self=False, strict=False):
+        """
+        This is similar to ``PageQuerySet.first_common_ancestor`` but works
+        for a list of pages instead of a queryset.
+        """
+        if not pages:
+            if strict:
+                raise self.model.DoesNotExist("Can not find ancestor of empty list")
+            return self.model.get_first_root_node()
+
+        if include_self:
+            paths = list({page.path for page in pages})
+        else:
+            paths = list({page.path[: -self.model.steplen] for page in pages})
+
+        # This method works on anything, not just file system paths.
+        common_parent_path = posixpath.commonprefix(paths)
+        extra_chars = len(common_parent_path) % self.model.steplen
+        if extra_chars != 0:
+            common_parent_path = common_parent_path[:-extra_chars]
+
+        if common_parent_path == "":
+            if strict:
+                raise self.model.DoesNotExist("No common ancestor found!")
+
+            return self.model.get_first_root_node()
+
+        return self.get(path=common_parent_path)
+
+    def annotate_parent_page(self, pages):
+        """
+        Annotates each page with its parent page. This is implemented as a
+        manager-only method instead of a QuerySet method so it can be used with
+        search results.
+
+        If given a QuerySet, this method will evaluate it. Only use this method
+        when you are ready to consume the queryset, e.g. after pagination has
+        been applied. This is typically done in the view's ``get_context_data``
+        using ``context["object_list"]``.
+
+        This method does not return a new queryset, but modifies the existing one,
+        to ensure any references to the queryset in the view's context are updated
+        (e.g. when using ``context_object_name``).
+        """
+        parent_page_paths = {
+            Page._get_parent_path_from_path(page.path) for page in pages
+        }
+        parent_pages_by_path = {
+            page.path: page
+            for page in Page.objects.filter(path__in=parent_page_paths).specific(
+                defer=True
+            )
+        }
+        for page in pages:
+            parent_page = parent_pages_by_path.get(
+                Page._get_parent_path_from_path(page.path)
+            )
+            page._parent_page = parent_page
+
+
+PageManager = BasePageManager.from_queryset(PageQuerySet)
+
+
+class PageBase(models.base.ModelBase):
+    """Metaclass for Page"""
+
+    def __init__(cls, name, bases, dct):
+        super().__init__(name, bases, dct)
+
+        if "template" not in dct:
+            # Define a default template path derived from the app name and model name
+            cls.template = "{}/{}.html".format(
+                cls._meta.app_label,
+                camelcase_to_underscore(name),
+            )
+
+        if "ajax_template" not in dct:
+            cls.ajax_template = None
+
+        cls._clean_subpage_models = (
+            None  # to be filled in on first call to cls.clean_subpage_models
+        )
+        cls._clean_parent_page_models = (
+            None  # to be filled in on first call to cls.clean_parent_page_models
+        )
+
+        # All pages should be creatable unless explicitly set otherwise.
+        # This attribute is not inheritable.
+        if "is_creatable" not in dct:
+            cls.is_creatable = not cls._meta.abstract
+
+        if not cls._meta.abstract:
+            # register this type in the list of page content types
+            PAGE_MODEL_CLASSES.append(cls)
+
+
+class AbstractPage(
+    WorkflowMixin,
+    PreviewableMixin,
+    DraftStateMixin,
+    LockableMixin,
+    RevisionMixin,
+    TranslatableMixin,
+    SpecificMixin,
+    MP_Node,
+):
+    """
+    Abstract superclass for Page. According to Django's inheritance rules, managers set on
+    abstract models are inherited by subclasses, but managers set on concrete models that are extended
+    via multi-table inheritance are not. We therefore need to attach PageManager to an abstract
+    superclass to ensure that it is retained by subclasses of Page.
+    """
+
+    objects = PageManager()
+
+    class Meta:
+        abstract = True
+
+
+# Make sure that this list is sorted by the codename (first item in the tuple)
+# so that we can follow the same order when querying the Permission objects.
+PAGE_PERMISSION_TYPES = [
+    ("add_page", _("Add"), _("Add/edit pages you own")),
+    ("bulk_delete_page", _("Bulk delete"), _("Delete pages with children")),
+    ("change_page", _("Edit"), _("Edit any page")),
+    ("lock_page", _("Lock"), _("Lock/unlock pages you've locked")),
+    ("publish_page", _("Publish"), _("Publish any page")),
+    ("unlock_page", _("Unlock"), _("Unlock any page")),
+]
+
+PAGE_PERMISSION_TYPE_CHOICES = [
+    (identifier[:-5], long_label) for identifier, _, long_label in PAGE_PERMISSION_TYPES
+]
+
+PAGE_PERMISSION_CODENAMES = [identifier for identifier, *_ in PAGE_PERMISSION_TYPES]
+
+
+class Page(AbstractPage, index.Indexed, ClusterableModel, metaclass=PageBase):
+    title = models.CharField(
+        verbose_name=_("title"),
+        max_length=255,
+        help_text=_("The page title as you'd like it to be seen by the public"),
+    )
+    title.required_on_save = True
+    # to reflect title of a current draft in the admin UI
+    draft_title = models.CharField(max_length=255, editable=False)
+    slug = models.SlugField(
+        verbose_name=_("slug"),
+        allow_unicode=True,
+        max_length=255,
+        help_text=_(
+            "The name of the page as it will appear in URLs e.g http://domain.com/blog/[my-slug]/"
+        ),
+    )
+    content_type = models.ForeignKey(
+        ContentType,
+        verbose_name=_("content type"),
+        related_name="pages",
+        on_delete=models.SET(get_default_page_content_type),
+    )
+    content_type.wagtail_reference_index_ignore = True
+    url_path = models.TextField(verbose_name=_("URL path"), blank=True, editable=False)
+    owner = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        verbose_name=_("owner"),
+        null=True,
+        blank=True,
+        editable=True,
+        on_delete=models.SET_NULL,
+        related_name="owned_pages",
+    )
+    owner.wagtail_reference_index_ignore = True
+
+    seo_title = models.CharField(
+        verbose_name=_("title tag"),
+        max_length=255,
+        blank=True,
+        help_text=_(
+            "The name of the page displayed on search engine results as the clickable headline."
+        ),
+    )
+
+    show_in_menus_default = False
+    show_in_menus = models.BooleanField(
+        verbose_name=_("show in menus"),
+        default=False,
+        help_text=_(
+            "Whether a link to this page will appear in automatically generated menus"
+        ),
+    )
+    search_description = models.TextField(
+        verbose_name=_("meta description"),
+        blank=True,
+        help_text=_(
+            "The descriptive text displayed underneath a headline in search engine results."
+        ),
+    )
+
+    latest_revision_created_at = models.DateTimeField(
+        verbose_name=_("latest revision created at"), null=True, editable=False
+    )
+
+    _revisions = GenericRelation("wagtailcore.Revision", related_query_name="page")
+
+    # Add GenericRelation to allow WorkflowState.objects.filter(page=...) queries.
+    # There is no need to override the workflow_states property, as the default
+    # implementation in WorkflowMixin already ensures that the queryset uses the
+    # base Page content type.
+    _workflow_states = GenericRelation(
+        "wagtailcore.WorkflowState",
+        content_type_field="base_content_type",
+        object_id_field="object_id",
+        related_query_name="page",
+        for_concrete_model=False,
+    )
+
+    # When using a specific queryset, accessing the _workflow_states GenericRelation
+    # will yield no results. This is because the _workflow_states GenericRelation
+    # uses the base_content_type as the content_type_field, which is not the same
+    # as the content type of the specific queryset. To work around this, we define
+    # a second GenericRelation that uses the specific content_type to be used
+    # when working with specific querysets.
+    _specific_workflow_states = GenericRelation(
+        "wagtailcore.WorkflowState",
+        content_type_field="content_type",
+        object_id_field="object_id",
+        related_query_name="page",
+        for_concrete_model=False,
+    )
+
+    # If non-null, this page is an alias of the linked page
+    # This means the page is kept in sync with the live version
+    # of the linked pages and is not editable by users.
+    alias_of = models.ForeignKey(
+        "self",
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        editable=False,
+        related_name="aliases",
+    )
+    alias_of.wagtail_reference_index_ignore = True
+
+    search_fields = [
+        index.SearchField("title", boost=2),
+        index.AutocompleteField("title"),
+        index.FilterField("title"),
+        index.FilterField("id"),
+        index.FilterField("live"),
+        index.FilterField("owner"),
+        index.FilterField("content_type"),
+        index.FilterField("path"),
+        index.FilterField("depth"),
+        index.FilterField("locked"),
+        index.FilterField("show_in_menus"),
+        index.FilterField("first_published_at"),
+        index.FilterField("last_published_at"),
+        index.FilterField("latest_revision_created_at"),
+        index.FilterField("locale"),
+        index.FilterField("translation_key"),
+    ]
+
+    # Do not allow plain Page instances to be created through the Wagtail admin
+    is_creatable = False
+
+    # Define the maximum number of instances this page type can have. Default to unlimited.
+    max_count = None
+
+    # Define the maximum number of instances this page can have under a specific parent. Default to unlimited.
+    max_count_per_parent = None
+
+    # Set the default order for child pages to be shown in the Page index listing
+    admin_default_ordering = "-latest_revision_created_at"
+
+    # An array of additional field names that will not be included when a Page is copied.
+    exclude_fields_in_copy = []
+    default_exclude_fields_in_copy = [
+        "id",
+        "depth",
+        "numchild",
+        "url_path",
+        "path",
+        "postgres_index_entries",
+        "index_entries",
+        "latest_revision",
+        COMMENTS_RELATION_NAME,
+    ]
+
+    # Real panel classes are defined in wagtail.admin.panels, which we can't import here
+    # because it would create a circular import. Instead, define them with placeholders
+    # to be replaced with the real classes by `wagtail.admin.panels.model_utils.expand_panel_list`.
+    content_panels = [
+        PanelPlaceholder("wagtail.admin.panels.TitleFieldPanel", ["title"], {}),
+    ]
+    promote_panels = [
+        PanelPlaceholder(
+            "wagtail.admin.panels.MultiFieldPanel",
+            [
+                [
+                    "slug",
+                    "seo_title",
+                    "search_description",
+                ],
+                _("For search engines"),
+            ],
+            {},
+        ),
+        PanelPlaceholder(
+            "wagtail.admin.panels.MultiFieldPanel",
+            [
+                [
+                    "show_in_menus",
+                ],
+                _("For site menus"),
+            ],
+            {},
+        ),
+    ]
+    settings_panels = [
+        PanelPlaceholder("wagtail.admin.panels.PublishingPanel", [], {}),
+        CommentPanelPlaceholder(),
+    ]
+
+    # Privacy options for page
+    private_page_options = ["password", "groups", "login"]
+
+    # Allows page types to specify a list of HTTP method names that page instances will
+    # respond to. When the request type doesn't match, Wagtail should return a response
+    # with a status code of 405.
+    allowed_http_methods = [
+        HTTPMethod.DELETE,
+        HTTPMethod.GET,
+        HTTPMethod.HEAD,
+        HTTPMethod.OPTIONS,
+        HTTPMethod.PATCH,
+        HTTPMethod.POST,
+        HTTPMethod.PUT,
+    ]
+
+    @staticmethod
+    def route_for_request(request: HttpRequest, path: str) -> RouteResult | None:
+        """
+        Find the page route for the given HTTP request object, and URL path. The route
+        result (`page`, `args`, and `kwargs`) will be cached via
+        ``request._wagtail_route_for_request``.
+        """
+        if not hasattr(request, "_wagtail_route_for_request"):
+            try:
+                # we need a valid Site object for this request in order to proceed
+                if site := Site.find_for_request(request):
+                    path_components = [
+                        component for component in path.split("/") if component
+                    ]
+                    request._wagtail_route_for_request = (
+                        site.root_page.localized.specific.route(
+                            request, path_components
+                        )
+                    )
+                else:
+                    request._wagtail_route_for_request = None
+            except Http404:
+                # .route() can raise Http404
+                request._wagtail_route_for_request = None
+
+        return request._wagtail_route_for_request
+
+    @staticmethod
+    def find_for_request(request: HttpRequest, path: str) -> Page | None:
+        """
+        Find the page for the given HTTP request object, and URL path. The full
+        page route will be cached via ``request._wagtail_route_for_request``.
+        """
+        result = Page.route_for_request(request, path)
+        if result is not None:
+            return result[0]
+
+    @classmethod
+    def allowed_http_method_names(cls):
+        return [
+            method.value if hasattr(method, "value") else method
+            for method in cls.allowed_http_methods
+        ]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if not self.id:
+            # this model is being newly created
+            # rather than retrieved from the db;
+            if not self.content_type_id:
+                # set content type to correctly represent the model class
+                # that this was created as
+                self.content_type = ContentType.objects.get_for_model(self)
+            if "show_in_menus" not in kwargs:
+                # if the value is not set on submit refer to the model setting
+                self.show_in_menus = self.show_in_menus_default
+
+    def __str__(self):
+        return self.title
+
+    @property
+    def revisions(self):
+        # Always use the specific page instance when querying for revisions as
+        # they are always saved with the specific content_type.
+        return self.specific_deferred._revisions
+
+    def get_base_content_type(self):
+        # We want to always use the default Page model's ContentType as the
+        # base_content_type so that we can query for page revisions without
+        # having to know the specific Page type.
+        return get_default_page_content_type()
+
+    def get_content_type(self):
+        return self.content_type
+
+    @classmethod
+    def get_streamfield_names(cls):
+        return get_streamfield_names(cls)
+
+    def set_url_path(self, parent):
+        """
+        Populate the url_path field based on this page's slug and the specified parent page.
+        (We pass a parent in here, rather than retrieving it via get_parent, so that we can give
+        new unsaved pages a meaningful URL when previewing them; at that point the page has not
+        been assigned a position in the tree, as far as treebeard is concerned.
+        """
+        if parent:
+            self.url_path = parent.url_path + self.slug + "/"
+        else:
+            # a page without a parent is the tree root, which always has a url_path of '/'
+            self.url_path = "/"
+
+        return self.url_path
+
+    @staticmethod
+    def _slug_is_available(slug, parent_page, page=None):
+        """
+        Determine whether the given slug is available for use on a child page of
+        parent_page. If 'page' is passed, the slug is intended for use on that page
+        (and so it will be excluded from the duplicate check).
+        """
+        if parent_page is None:
+            # the root page's slug can be whatever it likes...
+            return True
+
+        siblings = parent_page.get_children()
+        if page:
+            siblings = siblings.not_page(page)
+
+        return not siblings.filter(slug=slug).exists()
+
+    def _get_autogenerated_slug(self, base_slug):
+        candidate_slug = base_slug
+        suffix = 1
+        parent_page = self.get_parent()
+
+        while not Page._slug_is_available(candidate_slug, parent_page, self):
+            # try with incrementing suffix until we find a slug which is available
+            suffix += 1
+            candidate_slug = "%s-%d" % (base_slug, suffix)
+
+        return candidate_slug
+
+    def get_default_locale(self):
+        """
+        Finds the default locale to use for this page.
+
+        This will be called just before the initial save.
+        """
+        parent = self.get_parent()
+        if parent is not None:
+            return (
+                parent.specific_class.objects.defer()
+                .select_related("locale")
+                .get(id=parent.id)
+                .locale
+            )
+
+        return super().get_default_locale()
+
+    def get_admin_default_ordering(self):
+        """
+        Determine the default ordering for child pages in the admin index listing.
+        Returns a string (e.g. 'latest_revision_created_at, title, ord' or 'live').
+        """
+        return self.admin_default_ordering
+
+    def _set_core_field_defaults(self):
+        """
+        Set default values for core fields (slug, draft_title, locale) that need to be
+        in place before validating or saving
+        """
+        if not self.slug:
+            # Try to auto-populate slug from title
+            allow_unicode = getattr(settings, "WAGTAIL_ALLOW_UNICODE_SLUGS", True)
+            base_slug = slugify(self.title, allow_unicode=allow_unicode)
+
+            # only proceed if we get a non-empty base slug back from slugify
+            if base_slug:
+                self.slug = self._get_autogenerated_slug(base_slug)
+
+        if not self.draft_title:
+            self.draft_title = self.title
+
+        # Set the locale
+        if self.locale_id is None:
+            self.locale = self.get_default_locale()
+
+    def full_clean(self, *args, **kwargs):
+        self._set_core_field_defaults()
+        super().full_clean(*args, **kwargs)
+
+    def _check_slug_is_unique(self):
+        parent_page = self.get_parent()
+        if not Page._slug_is_available(self.slug, parent_page, self):
+            raise ValidationError(
+                {
+                    "slug": _(
+                        "The slug '%(page_slug)s' is already in use within the parent page at '%(parent_url_path)s'"
+                    )
+                    % {"page_slug": self.slug, "parent_url_path": parent_page.url}
+                }
+            )
+
+    def clean(self):
+        super().clean()
+        self._check_slug_is_unique()
+
+    def minimal_clean(self):
+        self._set_core_field_defaults()
+        self.title = self._meta.get_field("title").clean(self.title, self)
+        self._check_slug_is_unique()
+
+    def is_site_root(self):
+        """
+        Returns True if this page is the root of any site.
+
+        This includes translations of site root pages as well.
+        """
+        # `_is_site_root` may be populated by `annotate_site_root_state` on `PageQuerySet` as a
+        # performance optimisation
+        if hasattr(self, "_is_site_root"):
+            return self._is_site_root
+
+        return Site.objects.filter(
+            root_page__translation_key=self.translation_key
+        ).exists()
+
+    @transaction.atomic
+    # ensure that changes are only committed when we have updated all descendant URL paths, to preserve consistency
+    def save(self, clean=True, user=None, log_action=False, **kwargs):
+        """
+        Writes the page to the database, performing additional housekeeping tasks to ensure data
+        integrity:
+
+        * ``locale``, ``draft_title`` and ``slug`` are set to default values if not provided, with ``slug``
+          being generated from the title with a suffix to ensure uniqueness within the parent page
+          where necessary
+        * The ``url_path`` field is set based on the ``slug`` and the parent page
+        * If the ``slug`` has changed, the ``url_path`` of this page and all descendants is updated and
+          a :ref:`page_slug_changed` signal is sent
+
+        New pages should be saved by passing the unsaved page instance to the
+        :meth:`~treebeard.mp_tree.MP_Node.add_child`
+        or :meth:`~treebeard.mp_tree.MP_Node.add_sibling` method of an existing page, which will correctly update
+        the fields responsible for tracking the page's location in the tree.
+
+        If ``clean=False`` is passed, the page is saved without validation. This is appropriate for updates that only
+        change metadata such as `latest_revision` while keeping content and page location unchanged.
+
+        If ``clean=True`` is passed (the default), and the page has ``live=True`` set, the page is validated using
+        :meth:`~django.db.models.Model.full_clean` before saving.
+
+        If ``clean=True`` is passed, and the page has ``live=False`` set, only the title and slug fields are validated.
+
+        .. versionchanged:: 7.0
+           ``clean=True`` now only performs full validation when the page is live. When the page is not live, only
+           the title and slug fields are validated. Previously, full validation was always performed.
+        """
+        if clean:
+            if self.live:
+                self.full_clean()
+            else:
+                # Saving as draft; only perform the minimal validation to satisfy data integrity
+                self.minimal_clean()
+
+        slug_changed = False
+        is_new = self.id is None
+
+        if is_new:
+            # we are creating a record. If we're doing things properly, this should happen
+            # through a treebeard method like add_child, in which case the 'path' field
+            # has been set and so we can safely call get_parent
+            self.set_url_path(self.get_parent())
+        else:
+            # Check that we are committing the slug to the database
+            # Basically: If update_fields has been specified, and slug is not included, skip this step
+            if not (
+                "update_fields" in kwargs and "slug" not in kwargs["update_fields"]
+            ):
+                # see if the slug has changed from the record in the db, in which case we need to
+                # update url_path of self and all descendants. Even though we might not need it,
+                # the specific page is fetched here for sending to the 'page_slug_changed' signal.
+                old_record = Page.objects.get(id=self.id).specific
+                if old_record.slug != self.slug:
+                    self.set_url_path(self.get_parent())
+                    slug_changed = True
+                    old_url_path = old_record.url_path
+                    new_url_path = self.url_path
+
+        result = super().save(**kwargs)
+
+        if slug_changed:
+            self._update_descendant_url_paths(old_url_path, new_url_path)
+            # Emit page_slug_changed signal on successful db commit
+            transaction.on_commit(
+                lambda: page_slug_changed.send(
+                    sender=self.specific_class or self.__class__,
+                    instance=self.specific,
+                    instance_before=old_record,
+                )
+            )
+
+        # Check if this is a root page of any sites and clear the 'wagtail_site_root_paths' key if so
+        # Note: New translations of existing site roots are considered site roots as well, so we must
+        # always check if this page is a site root, even if it's new.
+        if self.is_site_root():
+            Site.clear_site_root_paths_cache()
+
+        # Log
+        if is_new:
+            cls = type(self)
+            logger.info(
+                'Page created: "%s" id=%d content_type=%s.%s path=%s',
+                self.title,
+                self.id,
+                cls._meta.app_label,
+                cls.__name__,
+                self.url_path,
+            )
+
+        if log_action is not None:
+            # The default for log_action is False. i.e. don't log unless specifically instructed
+            # Page creation is a special case that we want logged by default, but allow skipping it
+            # explicitly by passing log_action=None
+            if is_new:
+                log(
+                    instance=self,
+                    action="wagtail.create",
+                    user=user or self.owner,
+                    content_changed=True,
+                )
+            elif log_action:
+                log(instance=self, action=log_action, user=user)
+
+        return result
+
+    def delete(self, *args, **kwargs):
+        user = kwargs.pop("user", None)
+        return DeletePageAction(self, user=user).execute(*args, **kwargs)
+
+    @classmethod
+    def check(cls, **kwargs):
+        errors = super().check(**kwargs)
+
+        # Check that foreign keys from pages are not configured to cascade
+        # This is the default Django behaviour which must be explicitly overridden
+        # to prevent pages disappearing unexpectedly and the tree being corrupted
+
+        # get names of foreign keys pointing to parent classes (such as page_ptr)
+        field_exceptions = [
+            field.name
+            for model in [cls] + list(cls._meta.get_parent_list())
+            for field in model._meta.parents.values()
+            if field
+        ]
+
+        for field in cls._meta.fields:
+            if (
+                isinstance(field, models.ForeignKey)
+                and field.name not in field_exceptions
+            ):
+                if field.remote_field.on_delete == models.CASCADE:
+                    errors.append(
+                        checks.Warning(
+                            "Field hasn't specified on_delete action",
+                            hint="Set on_delete=models.SET_NULL and make sure the field is nullable or set on_delete=models.PROTECT. Wagtail does not allow simple database CASCADE because it will corrupt its tree storage.",
+                            obj=field,
+                            id="wagtailcore.W001",
+                        )
+                    )
+
+        if not isinstance(cls.objects, PageManager):
+            errors.append(
+                checks.Error(
+                    "Manager does not inherit from PageManager",
+                    hint="Ensure that custom Page managers inherit from wagtail.models.PageManager",
+                    obj=cls,
+                    id="wagtailcore.E002",
+                )
+            )
+
+        try:
+            cls.clean_subpage_models()
+        except (ValueError, LookupError) as e:
+            errors.append(
+                checks.Error(
+                    "Invalid subpage_types setting for %s" % cls,
+                    hint=str(e),
+                    id="wagtailcore.E002",
+                )
+            )
+
+        try:
+            cls.clean_parent_page_models()
+        except (ValueError, LookupError) as e:
+            errors.append(
+                checks.Error(
+                    "Invalid parent_page_types setting for %s" % cls,
+                    hint=str(e),
+                    id="wagtailcore.E002",
+                )
+            )
+
+        return errors
+
+    def _update_descendant_url_paths(self, old_url_path, new_url_path):
+        (
+            Page.objects.filter(path__startswith=self.path)
+            .exclude(pk=self.pk)
+            .update(
+                url_path=Concat(
+                    Value(new_url_path), Substr("url_path", len(old_url_path) + 1)
+                )
+            )
+        )
+
+    @property
+    def page_type_display_name(self):
+        """
+        A human-readable version of this page's type.
+        """
+        if not self.specific_class or self.is_root():
+            return ""
+        else:
+            return self.specific_class.get_verbose_name()
+
+    def route(self, request, path_components):
+        if path_components:
+            # request is for a child of this page
+            child_slug = path_components[0]
+            remaining_components = path_components[1:]
+
+            try:
+                subpage = self.get_children().get(slug=child_slug)
+                # Cache the parent page on the subpage to avoid another db query
+                # Treebeard's get_parent will use the `_cached_parent_obj` attribute if it exists
+                # And update = False
+                setattr(subpage, "_cached_parent_obj", self)
+
+            except Page.DoesNotExist:
+                raise Http404
+
+            return subpage.specific.route(request, remaining_components)
+
+        else:
+            # request is for this very page
+            if self.live:
+                return RouteResult(self)
+            else:
+                raise Http404
+
+    def get_admin_display_title(self):
+        """
+        Return the title for this page as it should appear in the admin backend;
+        override this if you wish to display extra contextual information about the page,
+        such as language. By default, returns ``draft_title``.
+        """
+        # Fall back on title if draft_title is blank (which may happen if the page was created
+        # in a fixture or migration that didn't explicitly handle draft_title)
+        return self.draft_title or self.title
+
+    def save_revision(
+        self,
+        user=None,
+        approved_go_live_at=None,
+        changed=True,
+        log_action=False,
+        previous_revision=None,
+        clean=True,
+    ):
+        # Raise error if this is not the specific version of the page
+        if not isinstance(self, self.specific_class):
+            raise RuntimeError(
+                "page.save_revision() must be called on the specific version of the page. "
+                "Call page.specific.save_revision() instead."
+            )
+
+        # Raise an error if this page is an alias.
+        if self.alias_of_id:
+            raise RuntimeError(
+                "page.save_revision() was called on an alias page. "
+                "Revisions are not required for alias pages as they are an exact copy of another page."
+            )
+
+        if clean:
+            self.full_clean()
+
+        new_comments = getattr(self, COMMENTS_RELATION_NAME).filter(pk__isnull=True)
+        for comment in new_comments:
+            # We need to ensure comments have an id in the revision, so positions can be identified correctly
+            comment.save()
+
+        revision = Revision.objects.create(
+            content_object=self,
+            base_content_type=self.get_base_content_type(),
+            user=user,
+            approved_go_live_at=approved_go_live_at,
+            content=self.serializable_data(),
+            object_str=str(self),
+        )
+
+        for comment in new_comments:
+            comment.revision_created = revision
+
+        self.latest_revision_created_at = revision.created_at
+        self.draft_title = self.title
+        self.latest_revision = revision
+
+        update_fields = [
+            COMMENTS_RELATION_NAME,
+            "latest_revision_created_at",
+            "draft_title",
+            "latest_revision",
+        ]
+
+        if changed:
+            self.has_unpublished_changes = True
+            update_fields.append("has_unpublished_changes")
+
+        if update_fields:
+            # clean=False because the fields we're updating don't need validation
+            self.save(update_fields=update_fields, clean=False)
+
+        # Log
+        logger.info(
+            'Page edited: "%s" id=%d revision_id=%d', self.title, self.id, revision.id
+        )
+        if log_action:
+            if not previous_revision:
+                log(
+                    instance=self,
+                    action=log_action
+                    if isinstance(log_action, str)
+                    else "wagtail.edit",
+                    user=user,
+                    revision=revision,
+                    content_changed=changed,
+                )
+            else:
+                log(
+                    instance=self,
+                    action=log_action
+                    if isinstance(log_action, str)
+                    else "wagtail.revert",
+                    user=user,
+                    data={
+                        "revision": {
+                            "id": previous_revision.id,
+                            "created": ensure_utc(previous_revision.created_at),
+                        }
+                    },
+                    revision=revision,
+                    content_changed=changed,
+                )
+
+        return revision
+
+    def get_latest_revision_as_object(self):
+        if not self.has_unpublished_changes:
+            # Use the live database copy in preference to the revision record, as:
+            # 1) this will pick up any changes that have been made directly to the model,
+            #    such as automated data imports;
+            # 2) it ensures that inline child objects pick up real database IDs even if
+            #    those are absent from the revision data. (If this wasn't the case, the child
+            #    objects would be recreated with new IDs on next publish - see #1853)
+            return self.specific
+
+        latest_revision = self.get_latest_revision()
+
+        if latest_revision:
+            return latest_revision.as_object()
+        else:
+            return self.specific
+
+    def update_aliases(self, *, revision=None, _content=None, _updated_ids=None):
+        """
+        Publishes all aliases that follow this page with the latest content from this page.
+
+        This is called by Wagtail whenever a page with aliases is published.
+
+        :param revision: The revision of the original page that we are updating to (used for logging purposes)
+        :type revision: Revision, Optional
+        """
+        specific_self = self.specific
+
+        # Only compute this if necessary since it's quite a heavy operation
+        if _content is None:
+            _content = self.serializable_data()
+
+        # A list of IDs that have already been updated. This is just in case someone has
+        # created an alias loop (which is impossible to do with the UI Wagtail provides)
+        _updated_ids = _updated_ids or []
+
+        for alias in self.specific_class.objects.filter(alias_of=self).exclude(
+            id__in=_updated_ids
+        ):
+            # FIXME: Switch to the same fields that are excluded from copy
+            # We can't do this right now because we can't exclude fields from with_content_json
+            exclude_fields = [
+                "id",
+                "path",
+                "depth",
+                "numchild",
+                "url_path",
+                "path",
+                "index_entries",
+                "postgres_index_entries",
+            ]
+
+            # Copy field content
+            alias_updated = alias.with_content_json(_content)
+
+            # Publish the alias if it's currently in draft
+            alias_updated.live = True
+            alias_updated.has_unpublished_changes = False
+
+            # Copy child relations
+            child_object_map = specific_self.copy_all_child_relations(
+                target=alias_updated, exclude=exclude_fields
+            )
+
+            # Process child objects
+            # This has two jobs:
+            #  - If the alias is in a different locale, this updates the
+            #    locale of any translatable child objects to match
+            #  - If the alias is not a translation of the original, this
+            #    changes the translation_key field of all child objects
+            #    so they do not clash
+            if child_object_map:
+                alias_is_translation = alias.translation_key == self.translation_key
+
+                def process_child_object(child_object):
+                    if isinstance(child_object, TranslatableMixin):
+                        # Child object's locale must always match the page
+                        child_object.locale = alias_updated.locale
+
+                        # If the alias isn't a translation of the original page,
+                        # change the child object's translation_keys so they are
+                        # not either
+                        if not alias_is_translation:
+                            child_object.translation_key = uuid.uuid4()
+
+                for (rel, previous_id), child_objects in child_object_map.items():
+                    if previous_id is None:
+                        for child_object in child_objects:
+                            process_child_object(child_object)
+                    else:
+                        process_child_object(child_objects)
+
+            # Copy M2M relations
+            _copy_m2m_relations(
+                specific_self, alias_updated, exclude_fields=exclude_fields
+            )
+
+            # Don't change the aliases slug
+            # Aliases can have their own slugs so they can be siblings of the original
+            alias_updated.slug = alias.slug
+            alias_updated.set_url_path(alias_updated.get_parent())
+
+            # Aliases don't have revisions, so update fields that would normally be updated by save_revision
+            alias_updated.draft_title = alias_updated.title
+            alias_updated.latest_revision_created_at = self.latest_revision_created_at
+
+            alias_updated.save(clean=False)
+
+            page_published.send(
+                sender=alias_updated.specific_class,
+                instance=alias_updated,
+                revision=revision,
+                alias=True,
+            )
+
+            # Update any aliases of that alias
+
+            # Design note:
+            # It could be argued that this will be faster if we just changed these alias-of-alias
+            # pages to all point to the original page and avoid having to update them recursively.
+            #
+            # But, it's useful to have a record of how aliases have been chained.
+            # For example, In Wagtail Localize, we use aliases to create mirrored trees, but those
+            # trees themselves could have aliases within them. If an alias within a tree is
+            # converted to a regular page, we want the alias in the mirrored tree to follow that
+            # new page and stop receiving updates from the original page.
+            #
+            # Doing it this way requires an extra lookup query per alias but this is small in
+            # comparison to the work required to update the alias.
+
+            alias.update_aliases(
+                revision=revision,
+                _content=_content,
+                _updated_ids=_updated_ids,
+            )
+
+    update_aliases.alters_data = True
+
+    def publish(
+        self,
+        revision,
+        user=None,
+        changed=True,
+        log_action=True,
+        previous_revision=None,
+        skip_permission_checks=False,
+    ):
+        return PublishPageRevisionAction(
+            revision,
+            user=user,
+            changed=changed,
+            log_action=log_action,
+            previous_revision=previous_revision,
+        ).execute(skip_permission_checks=skip_permission_checks)
+
+    def unpublish(self, set_expired=False, commit=True, user=None, log_action=True):
+        return UnpublishPageAction(
+            self,
+            set_expired=set_expired,
+            commit=commit,
+            user=user,
+            log_action=log_action,
+        ).execute()
+
+    context_object_name = None
+
+    def get_context(self, request, *args, **kwargs):
+        context = {
+            PAGE_TEMPLATE_VAR: self,
+            "self": self,
+            "request": request,
+        }
+
+        if self.context_object_name:
+            context[self.context_object_name] = self
+
+        return context
+
+    def get_preview_context(self, request, mode_name):
+        return self.get_context(request)
+
+    def get_template(self, request, *args, **kwargs):
+        if request.headers.get("x-requested-with") == "XMLHttpRequest":
+            return self.ajax_template or self.template
+        else:
+            return self.template
+
+    def get_preview_template(self, request, mode_name):
+        return self.get_template(request)
+
+    def serve(self, request, *args, **kwargs):
+        request.is_preview = False
+
+        return TemplateResponse(
+            request,
+            self.get_template(request, *args, **kwargs),
+            self.get_context(request, *args, **kwargs),
+        )
+
+    def check_request_method(self, request, *args, **kwargs):
+        """
+        Checks the ``method`` attribute of the request against those supported
+        by the page (as defined by :attr:`allowed_http_methods`) and responds
+        accordingly.
+
+        If supported, ``None`` is returned, and the request is processed
+        normally. If not, a warning is logged and an ``HttpResponseNotAllowed``
+        is returned, and any further request handling is terminated.
+        """
+        allowed_methods = self.allowed_http_method_names()
+        if request.method not in allowed_methods:
+            logger.warning(
+                "Method Not Allowed (%s): %s",
+                request.method,
+                request.path,
+                extra={"status_code": 405, "request": request},
+            )
+            return HttpResponseNotAllowed(allowed_methods)
+
+    def handle_options_request(self, request, *args, **kwargs):
+        """
+        Returns an ``HttpResponse`` with an ``"Allow"`` header containing the list of
+        supported HTTP methods for this page. This method is used instead of
+        :meth:`serve` to handle requests when the ``OPTIONS`` HTTP verb is
+        detected (and :class:`HTTPMethod.OPTIONS <python:http.HTTPMethod>` is
+        present in :attr:`allowed_http_methods` for this type of page).
+        """
+        return HttpResponse(
+            headers={"Allow": ", ".join(self.allowed_http_method_names())}
+        )
+
+    def is_navigable(self):
+        """
+        Return true if it's meaningful to browse subpages of this page -
+        i.e. it currently has subpages,
+        or it's at the top level (this rule necessary for empty out-of-the-box sites to have working navigation)
+        """
+        return (not self.is_leaf()) or self.depth == 2
+
+    def _get_site_root_paths(self, request=None):
+        """
+        Return ``Site.get_site_root_paths()``, using the cached copy on the
+        request object if available.
+        """
+        # if we have a request, use that to cache site_root_paths; otherwise, use self
+        cache_object = request if request else self
+        try:
+            return cache_object._wagtail_cached_site_root_paths
+        except AttributeError:
+            cache_object._wagtail_cached_site_root_paths = Site.get_site_root_paths()
+            return cache_object._wagtail_cached_site_root_paths
+
+    def _get_relevant_site_root_paths(self, cache_object=None):
+        """
+        Returns a tuple of root paths for all sites this page belongs to.
+        """
+        return tuple(
+            srp
+            for srp in self._get_site_root_paths(cache_object)
+            if self.url_path.startswith(srp.root_path)
+        )
+
+    def get_url_parts(self, request=None):
+        """
+        Determine the URL for this page and return it as a tuple of
+        ``(site_id, site_root_url, page_url_relative_to_site_root)``.
+        Return ``None`` if the page is not routable.
+
+        This is used internally by the ``full_url``, ``url``, ``relative_url``
+        and ``get_site`` properties and methods; pages with custom URL routing
+        should override this method in order to have those operations return
+        the custom URLs.
+
+        Accepts an optional keyword argument ``request``, which may be used
+        to avoid repeated database / cache lookups. Typically, a page model
+        that overrides ``get_url_parts`` should not need to deal with
+        ``request`` directly, and should just pass it to the original method
+        when calling ``super``.
+        """
+
+        possible_sites = self._get_relevant_site_root_paths(request)
+
+        if not possible_sites:
+            return None
+
+        # Thanks to the ordering applied by Site.get_site_root_paths(),
+        # the first item is ideal in the vast majority of setups.
+        site_id, root_path, root_url, language_code = possible_sites[0]
+
+        unique_site_ids = {values[0] for values in possible_sites}
+        if len(unique_site_ids) > 1 and isinstance(request, HttpRequest):
+            # The page somehow belongs to more than one site (rare, but possible).
+            # If 'request' is indeed a HttpRequest, use it to identify the 'current'
+            # site and prefer an option matching that (where present).
+            site = Site.find_for_request(request)
+            if site:
+                for values in possible_sites:
+                    if values[0] == site.pk:
+                        site_id, root_path, root_url, language_code = values
+                        break
+
+        use_wagtail_i18n = getattr(settings, "WAGTAIL_I18N_ENABLED", False)
+
+        if use_wagtail_i18n:
+            # If the active language code is a variant of the page's language, then
+            # use that instead
+            # This is used when LANGUAGES contain more languages than WAGTAIL_CONTENT_LANGUAGES
+            try:
+                if (
+                    get_supported_content_language_variant(translation.get_language())
+                    == language_code
+                ):
+                    language_code = translation.get_language()
+            except LookupError:
+                # active language code is not a recognised content language, so leave
+                # page's language code unchanged
+                pass
+
+        # The page may not be routable because wagtail_serve is not registered
+        # This may be the case if Wagtail is used headless
+        try:
+            if use_wagtail_i18n:
+                with translation.override(language_code):
+                    page_path = reverse(
+                        "wagtail_serve", args=(self.url_path[len(root_path) :],)
+                    )
+            else:
+                page_path = reverse(
+                    "wagtail_serve", args=(self.url_path[len(root_path) :],)
+                )
+        except NoReverseMatch:
+            return (site_id, None, None)
+
+        # Remove the trailing slash from the URL reverse generates if
+        # WAGTAIL_APPEND_SLASH is False and we're not trying to serve
+        # the root path
+        if not WAGTAIL_APPEND_SLASH and page_path != "/":
+            page_path = page_path.rstrip("/")
+
+        return (site_id, root_url, page_path)
+
+    def get_full_url(self, request=None):
+        """
+        Return the full URL (including protocol / domain) to this page, or ``None`` if it is not routable.
+        """
+        url_parts = self.get_url_parts(request=request)
+
+        if url_parts is None or url_parts[1] is None and url_parts[2] is None:
+            # page is not routable
+            return
+
+        site_id, root_url, page_path = url_parts
+
+        return root_url + page_path
+
+    full_url = property(get_full_url)
+
+    def get_url(self, request=None, current_site=None):
+        """
+        Return the 'most appropriate' URL for referring to this page from the pages we serve,
+        within the Wagtail backend and actual website templates;
+        this is the local URL (starting with '/') if we're only running a single site
+        (i.e. we know that whatever the current page is being served from, this link will be on the
+        same domain), and the full URL (with domain) if not.
+        Return ``None`` if the page is not routable.
+
+        Accepts an optional but recommended ``request`` keyword argument that, if provided, will
+        be used to cache site-level URL information (thereby avoiding repeated database / cache
+        lookups) and, via the ``Site.find_for_request()`` function, determine whether a relative
+        or full URL is most appropriate.
+        """
+        # ``current_site`` is purposefully undocumented, as one can simply pass the request and get
+        # a relative URL based on ``Site.find_for_request()``. Nonetheless, support it here to avoid
+        # copy/pasting the code to the ``relative_url`` method below.
+        if current_site is None and request is not None:
+            site = Site.find_for_request(request)
+            current_site = site
+        url_parts = self.get_url_parts(request=request)
+
+        if url_parts is None or url_parts[1] is None and url_parts[2] is None:
+            # page is not routable
+            return
+
+        site_id, root_url, page_path = url_parts
+
+        # Get number of unique sites in root paths
+        # Note: there may be more root paths to sites if there are multiple languages
+        num_sites = len(
+            {root_path[0] for root_path in self._get_site_root_paths(request)}
+        )
+
+        if (current_site is not None and site_id == current_site.id) or num_sites == 1:
+            # the site matches OR we're only running a single site, so a local URL is sufficient
+            return page_path
+        else:
+            return root_url + page_path
+
+    url = property(get_url)
+
+    def relative_url(self, current_site, request=None):
+        """
+        Return the 'most appropriate' URL for this page taking into account the site we're currently on;
+        a local URL if the site matches, or a fully qualified one otherwise.
+        Return ``None`` if the page is not routable.
+
+        Accepts an optional but recommended ``request`` keyword argument that, if provided, will
+        be used to cache site-level URL information (thereby avoiding repeated database / cache
+        lookups).
+        """
+        return self.get_url(request=request, current_site=current_site)
+
+    def get_site(self):
+        """
+        Return the Site object that this page belongs to.
+        """
+
+        url_parts = self.get_url_parts()
+
+        if url_parts is None:
+            # page is not routable
+            return
+
+        site_id, root_url, page_path = url_parts
+
+        return Site.objects.get(id=site_id)
+
+    @classmethod
+    def get_indexed_objects(cls):
+        content_type = ContentType.objects.get_for_model(cls)
+        return super().get_indexed_objects().filter(content_type=content_type)
+
+    def get_indexed_instance(self):
+        # This is accessed on save by the wagtailsearch signal handler, and in edge
+        # cases (e.g. loading test fixtures), may be called before the specific instance's
+        # entry has been created. In those cases, we aren't ready to be indexed yet, so
+        # return None.
+        try:
+            return self.specific
+        except self.specific_class.DoesNotExist:
+            return None
+
+    def get_default_privacy_setting(self, request: HttpRequest):
+        """Set the default privacy setting for a page."""
+        return {"type": BaseViewRestriction.NONE}
+
+    @classmethod
+    def clean_subpage_models(cls):
+        """
+        Returns the list of subpage types, normalized as model classes.
+        Throws ValueError if any entry in subpage_types cannot be recognized as a model name,
+        or LookupError if a model does not exist (or is not a Page subclass).
+        """
+        if cls._clean_subpage_models is None:
+            subpage_types = getattr(cls, "subpage_types", None)
+            if subpage_types is None:
+                # if subpage_types is not specified on the Page class, allow all page types as subpages
+                cls._clean_subpage_models = get_page_models()
+            else:
+                cls._clean_subpage_models = [
+                    resolve_model_string(model_string, cls._meta.app_label)
+                    for model_string in subpage_types
+                ]
+
+                for model in cls._clean_subpage_models:
+                    if not issubclass(model, Page):
+                        raise LookupError("%s is not a Page subclass" % model)
+
+        return cls._clean_subpage_models
+
+    @classmethod
+    def clean_parent_page_models(cls):
+        """
+        Returns the list of parent page types, normalized as model classes.
+        Throws ValueError if any entry in parent_page_types cannot be recognized as a model name,
+        or LookupError if a model does not exist (or is not a Page subclass).
+        """
+
+        if cls._clean_parent_page_models is None:
+            parent_page_types = getattr(cls, "parent_page_types", None)
+            if parent_page_types is None:
+                # if parent_page_types is not specified on the Page class, allow all page types as subpages
+                cls._clean_parent_page_models = get_page_models()
+            else:
+                cls._clean_parent_page_models = [
+                    resolve_model_string(model_string, cls._meta.app_label)
+                    for model_string in parent_page_types
+                ]
+
+                for model in cls._clean_parent_page_models:
+                    if not issubclass(model, Page):
+                        raise LookupError("%s is not a Page subclass" % model)
+
+        return cls._clean_parent_page_models
+
+    @classmethod
+    def allowed_parent_page_models(cls):
+        """
+        Returns the list of page types that this page type can be a subpage of,
+        as a list of model classes.
+        """
+        return [
+            parent_model
+            for parent_model in cls.clean_parent_page_models()
+            if cls in parent_model.clean_subpage_models()
+        ]
+
+    @classmethod
+    def allowed_subpage_models(cls):
+        """
+        Returns the list of page types that this page type can have as subpages,
+        as a list of model classes.
+        """
+        return [
+            subpage_model
+            for subpage_model in cls.clean_subpage_models()
+            if cls in subpage_model.clean_parent_page_models()
+        ]
+
+    @classmethod
+    def creatable_subpage_models(cls):
+        """
+        Returns the list of page types that may be created under this page type,
+        as a list of model classes.
+        """
+        return [
+            page_model
+            for page_model in cls.allowed_subpage_models()
+            if page_model.is_creatable
+        ]
+
+    @classmethod
+    def can_exist_under(cls, parent):
+        """
+        Checks if this page type can exist as a subpage under a parent page
+        instance.
+
+        See also: :func:`Page.can_create_at` and :func:`Page.can_move_to`
+        """
+        return cls in parent.specific_class.allowed_subpage_models()
+
+    @classmethod
+    def can_create_at(cls, parent):
+        """
+        Checks if this page type can be created as a subpage under a parent
+        page instance.
+        """
+        can_create = cls.is_creatable and cls.can_exist_under(parent)
+
+        if cls.max_count is not None:
+            can_create = can_create and cls.objects.count() < cls.max_count
+
+        if cls.max_count_per_parent is not None:
+            can_create = (
+                can_create
+                and parent.get_children().type(cls).count() < cls.max_count_per_parent
+            )
+
+        return can_create
+
+    def can_move_to(self, parent):
+        """
+        Checks if this page instance can be moved to be a subpage of a parent
+        page instance.
+        """
+        # Prevent pages from being moved to different language sections
+        # The only page that can have multi-lingual children is the root page
+        parent_is_root = parent.depth == 1
+        if not parent_is_root and parent.locale_id != self.locale_id:
+            return False
+
+        return self.can_exist_under(parent)
+
+    @classmethod
+    def get_verbose_name(cls):
+        """
+        Returns the human-readable "verbose name" of this page model e.g "Blog page".
+        """
+        # This is similar to doing cls._meta.verbose_name.title()
+        # except this doesn't convert any characters to lowercase
+        return capfirst(cls._meta.verbose_name)
+
+    @classmethod
+    def get_page_description(cls):
+        """
+        Returns a page description if it's set. For example "A multi-purpose web page".
+        """
+        description = getattr(cls, "page_description", None)
+
+        # make sure that page_description is actually a string rather than a model field
+        if isinstance(description, str):
+            return description
+        elif isinstance(description, Promise):
+            # description is a lazy object (e.g. the result of gettext_lazy())
+            return str(description)
+        else:
+            return ""
+
+    @property
+    def approved_schedule(self):
+        """
+        ``_approved_schedule`` may be populated by ``annotate_approved_schedule`` on ``PageQuerySet`` as a
+        performance optimization.
+        """
+        if hasattr(self, "_approved_schedule"):
+            return self._approved_schedule
+
+        return self.scheduled_revision is not None
+
+    def has_unpublished_subtree(self):
+        """
+        An awkwardly-defined flag used in determining whether unprivileged editors have
+        permission to delete this article. Returns true if and only if this page is non-live,
+        and it has no live children.
+        """
+        return (not self.live) and (
+            not self.get_descendants().filter(live=True).exists()
+        )
+
+    def move(self, target, pos=None, user=None):
+        """
+        Extension to the treebeard 'move' method to ensure that url_path is updated,
+        and to emit a 'pre_page_move' and 'post_page_move' signals.
+        """
+        return MovePageAction(self, target, pos=pos, user=user).execute()
+
+    def copy(
+        self,
+        recursive=False,
+        to=None,
+        update_attrs=None,
+        copy_revisions=True,
+        keep_live=True,
+        user=None,
+        process_child_object=None,
+        exclude_fields=None,
+        log_action="wagtail.copy",
+        reset_translation_key=True,
+    ):
+        """
+        Copies a given page
+
+        :param log_action: flag for logging the action. Pass None to skip logging. Can be passed an action string. Defaults to ``'wagtail.copy'``.
+        """
+        return CopyPageAction(
+            self,
+            to=to,
+            update_attrs=update_attrs,
+            exclude_fields=exclude_fields,
+            recursive=recursive,
+            copy_revisions=copy_revisions,
+            keep_live=keep_live,
+            user=user,
+            process_child_object=process_child_object,
+            log_action=log_action,
+            reset_translation_key=reset_translation_key,
+        ).execute(skip_permission_checks=True)
+
+    copy.alters_data = True
+
+    def create_alias(
+        self,
+        *,
+        recursive=False,
+        parent=None,
+        update_slug=None,
+        update_locale=None,
+        user=None,
+        log_action="wagtail.create_alias",
+        reset_translation_key=True,
+        _mpnode_attrs=None,
+    ):
+        return CreatePageAliasAction(
+            self,
+            recursive=recursive,
+            parent=parent,
+            update_slug=update_slug,
+            update_locale=update_locale,
+            user=user,
+            log_action=log_action,
+            reset_translation_key=reset_translation_key,
+            _mpnode_attrs=_mpnode_attrs,
+        ).execute()
+
+    create_alias.alters_data = True
+
+    def copy_for_translation(
+        self, locale, copy_parents=False, alias=False, exclude_fields=None
+    ):
+        """Creates a copy of this page in the specified locale."""
+
+        return CopyPageForTranslationAction(
+            self,
+            locale,
+            copy_parents=copy_parents,
+            alias=alias,
+            exclude_fields=exclude_fields,
+        ).execute()
+
+    copy_for_translation.alters_data = True
+
+    def permissions_for_user(self, user):
+        """
+        Return a PagePermissionsTester object defining what actions the user can perform on this page.
+        """
+        # Allow specific classes to override this method, but only cast to the
+        # specific instance if it's not already specific and if the method has
+        # been overridden. This helps improve performance when working with
+        # base Page querysets.
+        is_overridden = (
+            self.specific_class
+            and self.specific_class.permissions_for_user
+            != type(self).permissions_for_user
+        )
+        if is_overridden and not isinstance(self, self.specific_class):
+            return self.specific_deferred.permissions_for_user(user)
+        return PagePermissionTester(user, self)
+
+    def is_previewable(self):
+        """Returns True if at least one preview mode is specified"""
+        # It's possible that this will be called from a listing page using a plain Page queryset -
+        # if so, checking self.preview_modes would incorrectly give us the default set from
+        # Page.preview_modes. However, accessing self.specific.preview_modes would result in an N+1
+        # query problem. To avoid this (at least in the general case), we'll call .specific only if
+        # a check of the property at the class level indicates that preview_modes has been
+        # overridden from whatever type we're currently in.
+        page = self
+        if page.specific_class.preview_modes != type(page).preview_modes:
+            page = page.specific
+
+        return bool(page.preview_modes)
+
+    def get_route_paths(self):
+        """
+        Returns a list of paths that this page can be viewed at.
+
+        These values are combined with the dynamic portion of the page URL to
+        automatically create redirects when the page's URL changes.
+
+        .. note::
+
+            If using ``RoutablePageMixin``, you may want to override this method
+            to include the paths of popular routes.
+
+        .. note::
+
+            Redirect paths are 'normalized' to apply consistent ordering to GET parameters,
+            so you don't need to include every variation. Fragment identifiers are discarded
+            too, so should be avoided.
+        """
+        return ["/"]
+
+    def get_cached_paths(self):
+        """
+        This returns a list of paths to invalidate in a frontend cache
+        """
+        return ["/"]
+
+    def get_cache_key_components(self):
+        """
+        The components of a :class:`Page` which make up the :attr:`cache_key`. Any change to a
+        page should be reflected in a change to at least one of these components.
+        """
+
+        return [
+            self.id,
+            self.url_path,
+            self.last_published_at.isoformat() if self.last_published_at else None,
+        ]
+
+    @property
+    def cache_key(self):
+        """
+        A generic cache key to identify a page in its current state.
+        Should the page change, so will the key.
+
+        Customizations to the cache key should be made in :attr:`get_cache_key_components`.
+        """
+
+        hasher = safe_md5()
+
+        for component in self.get_cache_key_components():
+            hasher.update(force_bytes(component))
+
+        return hasher.hexdigest()
+
+    def get_sitemap_urls(self, request=None):
+        return [
+            {
+                "location": self.get_full_url(request),
+                # fall back on latest_revision_created_at if last_published_at is null
+                # (for backwards compatibility from before last_published_at was added)
+                "lastmod": (self.last_published_at or self.latest_revision_created_at),
+            }
+        ]
+
+    def get_ancestors(self, inclusive=False):
+        """
+        Returns a queryset of the current page's ancestors, starting at the root page
+        and descending to the parent, or to the current page itself if ``inclusive`` is true.
+        """
+        return Page.objects.ancestor_of(self, inclusive)
+
+    def get_descendants(self, inclusive=False):
+        """
+        Returns a queryset of all pages underneath the current page, any number of levels deep.
+        If ``inclusive`` is true, the current page itself is included in the queryset.
+        """
+        return Page.objects.descendant_of(self, inclusive)
+
+    def get_siblings(self, inclusive=True):
+        """
+        Returns a queryset of all other pages with the same parent as the current page.
+        If ``inclusive`` is true, the current page itself is included in the queryset.
+        """
+        return Page.objects.sibling_of(self, inclusive)
+
+    def get_next_siblings(self, inclusive=False):
+        return self.get_siblings(inclusive).filter(path__gte=self.path).order_by("path")
+
+    def get_prev_siblings(self, inclusive=False):
+        return (
+            self.get_siblings(inclusive).filter(path__lte=self.path).order_by("-path")
+        )
+
+    def get_view_restrictions(self):
+        """
+        Return a query set of all page view restrictions that apply to this page.
+
+        This checks the current page and all ancestor pages for page view restrictions.
+
+        If any of those pages are aliases, it will resolve them to their source pages
+        before querying PageViewRestrictions so alias pages use the same view restrictions
+        as their source page and they cannot have their own.
+        """
+        page_ids_to_check = set()
+
+        def add_page_to_check_list(page):
+            # If the page is an alias, add the source page to the check list instead
+            if page.alias_of:
+                add_page_to_check_list(page.alias_of)
+            else:
+                page_ids_to_check.add(page.id)
+
+        # Check current page for view restrictions
+        add_page_to_check_list(self)
+
+        # Check each ancestor for view restrictions as well
+        for page in self.get_ancestors().only("alias_of"):
+            add_page_to_check_list(page)
+
+        return PageViewRestriction.objects.filter(page_id__in=page_ids_to_check)
+
+    password_required_template = None
+
+    def serve_password_required_response(self, request, form, action_url):
+        """
+        Serve a response indicating that the user has been denied access to view this page,
+        and must supply a password.
+        ``form`` = a Django form object containing the password input
+            (and zero or more hidden fields that also need to be output on the template)
+        ``action_url`` = URL that this form should be POSTed to
+        """
+
+        password_required_template = self.password_required_template or getattr(
+            settings,
+            "WAGTAIL_PASSWORD_REQUIRED_TEMPLATE",
+            "wagtailcore/password_required.html",
+        )
+
+        context = self.get_context(request)
+        context["form"] = form
+        context["action_url"] = action_url
+        return TemplateResponse(request, password_required_template, context)
+
+    def with_content_json(self, content):
+        """
+        Returns a new version of the page with field values updated to reflect changes
+        in the provided ``content`` (which usually comes from a previously-saved
+        page revision).
+
+        Certain field values are preserved in order to prevent errors if the returned
+        page is saved, such as ``id``, ``content_type`` and some tree-related values.
+        The following field values are also preserved, as they are considered to be
+        meaningful to the page as a whole, rather than to a specific revision:
+
+        * ``draft_title``
+        * ``live``
+        * ``has_unpublished_changes``
+        * ``owner``
+        * ``locked``
+        * ``locked_by``
+        * ``locked_at``
+        * ``latest_revision``
+        * ``latest_revision_created_at``
+        * ``first_published_at``
+        * ``alias_of``
+        * ``wagtail_admin_comments`` (COMMENTS_RELATION_NAME)
+        """
+
+        # Old revisions (pre Wagtail 2.15) may have saved comment data under the name 'comments'
+        # rather than the current relation name as set by COMMENTS_RELATION_NAME;
+        # if a 'comments' field exists and looks like our comments model, alter the data to use
+        # COMMENTS_RELATION_NAME before restoring
+        if (
+            COMMENTS_RELATION_NAME not in content
+            and "comments" in content
+            and isinstance(content["comments"], list)
+            and len(content["comments"])
+            and isinstance(content["comments"][0], dict)
+            and "contentpath" in content["comments"][0]
+        ):
+            content[COMMENTS_RELATION_NAME] = content["comments"]
+            del content["comments"]
+
+        obj = self.specific_class.from_serializable_data(content)
+
+        # These should definitely never change between revisions
+        obj.id = self.id
+        obj.pk = self.pk
+        obj.content_type_id = self.content_type_id
+
+        # Override possibly-outdated tree parameter fields
+        obj.path = self.path
+        obj.depth = self.depth
+        obj.numchild = self.numchild
+
+        # Update url_path to reflect potential slug changes, but maintaining the page's
+        # existing tree position
+        obj.set_url_path(self.get_parent())
+
+        # Ensure other values that are meaningful for the page as a whole (rather than
+        # to a specific revision) are preserved
+        obj.draft_title = self.draft_title
+        obj.live = self.live
+        obj.has_unpublished_changes = self.has_unpublished_changes
+        obj.owner_id = self.owner_id
+        obj.locked = self.locked
+        obj.locked_by_id = self.locked_by_id
+        obj.locked_at = self.locked_at
+        obj.latest_revision_id = self.latest_revision_id
+        obj.latest_revision_created_at = self.latest_revision_created_at
+        obj.first_published_at = self.first_published_at
+        obj.translation_key = self.translation_key
+        obj.locale_id = self.locale_id
+        obj.alias_of_id = self.alias_of_id
+        revision_comment_positions = dict(
+            getattr(obj, COMMENTS_RELATION_NAME).values_list("id", "position")
+        )
+        page_comments = (
+            getattr(self, COMMENTS_RELATION_NAME)
+            .filter(resolved_at__isnull=True)
+            .defer("position")
+        )
+        for comment in page_comments:
+            # attempt to retrieve the comment position from the revision's stored version
+            # of the comment
+            try:
+                comment.position = revision_comment_positions[comment.id]
+            except KeyError:
+                pass
+        setattr(obj, COMMENTS_RELATION_NAME, page_comments)
+
+        return obj
+
+    @property
+    def has_workflow(self):
+        """
+        Returns ``True`` if the page or an ancestor has an active workflow assigned, otherwise ``False``.
+        """
+        if not getattr(settings, "WAGTAIL_WORKFLOW_ENABLED", True):
+            return False
+        return (
+            self.get_ancestors(inclusive=True)
+            .filter(workflowpage__isnull=False)
+            .filter(workflowpage__workflow__active=True)
+            .exists()
+        )
+
+    def get_workflow(self):
+        """
+        Returns the active workflow assigned to the page or its nearest ancestor.
+        """
+        if not getattr(settings, "WAGTAIL_WORKFLOW_ENABLED", True):
+            return None
+
+        if hasattr(self, "workflowpage") and self.workflowpage.workflow.active:
+            return self.workflowpage.workflow
+        else:
+            try:
+                workflow = (
+                    self.get_ancestors()
+                    .filter(workflowpage__isnull=False)
+                    .filter(workflowpage__workflow__active=True)
+                    .order_by("-depth")
+                    .first()
+                    .workflowpage.workflow
+                )
+            except AttributeError:
+                workflow = None
+            return workflow
+
+    class Meta:
+        verbose_name = _("page")
+        verbose_name_plural = _("pages")
+        unique_together = [("translation_key", "locale")]
+        # Make sure that we auto-create Permission objects that are defined in
+        # PAGE_PERMISSION_TYPES, skipping the default_permissions from Django.
+        permissions = [
+            (codename, name)
+            for codename, _, name in PAGE_PERMISSION_TYPES
+            if codename not in {"add_page", "change_page", "delete_page", "view_page"}
+        ]
+
+
+# set module path of Page so that when Sphinx autodoc sees Page in type annotations
+# it won't complain that there's no target for wagtail.models.pages.Page
+Page.__module__ = "wagtail.models"
+
+
+class GroupPagePermissionManager(models.Manager):
+    def create(self, **kwargs):
+        # Simplify creation of GroupPagePermission objects by allowing one
+        # of permission or permission_type to be passed in.
+        permission = kwargs.get("permission")
+        permission_type = kwargs.pop("permission_type", None)
+        if not permission and permission_type:
+            kwargs["permission"] = Permission.objects.get(
+                content_type=get_default_page_content_type(),
+                codename=f"{permission_type}_page",
+            )
+        return super().create(**kwargs)
+
+
+class GroupPagePermission(models.Model):
+    group = models.ForeignKey(
+        Group,
+        verbose_name=_("group"),
+        related_name="page_permissions",
+        on_delete=models.CASCADE,
+    )
+    page = models.ForeignKey(
+        "Page",
+        verbose_name=_("page"),
+        related_name="group_permissions",
+        on_delete=models.CASCADE,
+    )
+    permission = models.ForeignKey(
+        Permission,
+        verbose_name=_("permission"),
+        on_delete=models.CASCADE,
+    )
+
+    objects = GroupPagePermissionManager()
+
+    class Meta:
+        constraints = [
+            models.UniqueConstraint(
+                fields=("group", "page", "permission"),
+                name="unique_permission",
+            ),
+        ]
+        verbose_name = _("group page permission")
+        verbose_name_plural = _("group page permissions")
+
+    def __str__(self):
+        return "Group %d ('%s') has permission '%s' on page %d ('%s')" % (
+            self.group.id,
+            self.group,
+            self.permission.codename,
+            self.page.id,
+            self.page,
+        )
+
+
+class PagePermissionTester:
+    def __init__(self, user, page):
+        from wagtail.permissions import page_permission_policy
+
+        self.user = user
+        self.permission_policy = page_permission_policy
+        self.page = page
+        self.page_is_root = page.depth == 1  # Equivalent to page.is_root()
+
+        if self.user.is_active and not self.user.is_superuser:
+            self.permissions = {
+                # Get the 'action' part of the permission codename, e.g.
+                # 'add' instead of 'add_page'
+                perm.permission.codename.rsplit("_", maxsplit=1)[0]
+                for perm in self.permission_policy.get_cached_permissions_for_user(user)
+                if self.page.path.startswith(perm.page.path)
+            }
+
+    def user_has_lock(self):
+        return self.page.locked_by_id == self.user.pk
+
+    def page_locked(self):
+        lock = self.page.get_lock()
+        return lock and lock.for_user(self.user)
+
+    def can_add_subpage(self):
+        if not self.user.is_active:
+            return False
+        specific_class = self.page.specific_class
+        if specific_class is None or not specific_class.creatable_subpage_models():
+            return False
+        return self.user.is_superuser or ("add" in self.permissions)
+
+    def can_edit(self):
+        if not self.user.is_active:
+            return False
+
+        if (
+            self.page_is_root
+        ):  # root node is not a page and can never be edited, even by superusers
+            return False
+
+        if self.user.is_superuser:
+            return True
+
+        if "change" in self.permissions:
+            return True
+
+        if "add" in self.permissions and self.page.owner_id == self.user.pk:
+            return True
+
+        current_workflow_task = self.page.current_workflow_task
+        if current_workflow_task:
+            if current_workflow_task.user_can_access_editor(self.page, self.user):
+                return True
+
+        return False
+
+    def can_delete(self, ignore_bulk=False):
+        if not self.user.is_active:
+            return False
+
+        if (
+            self.page_is_root
+        ):  # root node is not a page and can never be deleted, even by superusers
+            return False
+
+        if self.user.is_superuser:
+            # superusers require no further checks
+            return True
+
+        # if the user does not have bulk_delete permission, they may only delete leaf pages
+        if (
+            "bulk_delete" not in self.permissions
+            and not self.page.is_leaf()
+            and not ignore_bulk
+        ):
+            return False
+
+        if "change" in self.permissions:
+            # if the user does not have publish permission, we also need to confirm that there
+            # are no published pages here
+            if "publish" not in self.permissions:
+                pages_to_delete = self.page.get_descendants(inclusive=True)
+                if pages_to_delete.live().exists():
+                    return False
+
+            return True
+
+        elif "add" in self.permissions:
+            pages_to_delete = self.page.get_descendants(inclusive=True)
+            if "publish" in self.permissions:
+                # we don't care about live state, but all pages must be owned by this user
+                # (i.e. eliminating pages owned by this user must give us the empty set)
+                return not pages_to_delete.exclude(owner=self.user).exists()
+            else:
+                # all pages must be owned by this user and non-live
+                # (i.e. eliminating non-live pages owned by this user must give us the empty set)
+                return not pages_to_delete.exclude(live=False, owner=self.user).exists()
+
+        else:
+            return False
+
+    def can_unpublish(self):
+        if not self.user.is_active:
+            return False
+        if (not self.page.live) or self.page_is_root:
+            return False
+        if self.page_locked():
+            return False
+
+        return self.user.is_superuser or ("publish" in self.permissions)
+
+    def can_publish(self):
+        if not self.user.is_active:
+            return False
+        if self.page_is_root:
+            return False
+
+        return self.user.is_superuser or ("publish" in self.permissions)
+
+    def can_submit_for_moderation(self):
+        return (
+            not self.page_locked()
+            and self.page.has_workflow
+            and not self.page.workflow_in_progress
+        )
+
+    def can_set_view_restrictions(self):
+        return self.can_publish()
+
+    def can_unschedule(self):
+        return self.can_publish()
+
+    def can_lock(self):
+        if self.user.is_superuser:
+            return True
+        current_workflow_task = self.page.current_workflow_task
+        if current_workflow_task:
+            return current_workflow_task.user_can_lock(self.page, self.user)
+
+        if "lock" in self.permissions:
+            return True
+
+        return False
+
+    def can_unlock(self):
+        if self.user.is_superuser:
+            return True
+
+        if self.user_has_lock():
+            return True
+
+        current_workflow_task = self.page.current_workflow_task
+        if current_workflow_task:
+            return current_workflow_task.user_can_unlock(self.page, self.user)
+
+        if "unlock" in self.permissions:
+            return True
+
+        return False
+
+    def can_publish_subpage(self):
+        """
+        Niggly special case for creating and publishing a page in one go.
+        Differs from can_publish in that we want to be able to publish subpages of root, but not
+        to be able to publish root itself. (Also, can_publish_subpage returns false if the page
+        does not allow subpages at all.)
+        """
+        if not self.user.is_active:
+            return False
+        specific_class = self.page.specific_class
+        if specific_class is None or not specific_class.creatable_subpage_models():
+            return False
+
+        return self.user.is_superuser or ("publish" in self.permissions)
+
+    def can_reorder_children(self):
+        """
+        Reorder permission checking is similar to publishing a subpage, since it immediately
+        affects published pages. However, it shouldn't care about the 'creatability' of
+        page types, because the action only ever updates existing pages.
+        """
+        if not self.user.is_active:
+            return False
+        return self.user.is_superuser or ("publish" in self.permissions)
+
+    def can_move(self):
+        """
+        Moving a page should be logically equivalent to deleting and re-adding it (and all its children).
+        As such, the permission test for 'can this be moved at all?' should be the same as for deletion.
+        (Further constraints will then apply on where it can be moved *to*.)
+        """
+        return self.can_delete(ignore_bulk=True)
+
+    def can_copy(self):
+        return not self.page_is_root
+
+    def can_move_to(self, destination):
+        # reject the logically impossible cases first
+        if self.page == destination or destination.is_descendant_of(self.page):
+            return False
+
+        # reject moves that are forbidden by subpage_types / parent_page_types rules
+        # (these rules apply to superusers too)
+        # – but only check this if the page is not already under the target parent.
+        # If it already is, then the user is just reordering the page, and we want
+        # to allow it even if the page currently violates the subpage_type /
+        # parent_page_type rules. This can happen if it was either created before
+        # the rules were specified, or it was done programmatically (e.g. to
+        # predefine a set of pages and disallow the creation of new subpages by
+        # setting subpage_types = []).
+
+        if (not self.page.is_child_of(destination)) and (
+            not self.page.specific.can_move_to(destination)
+        ):
+            return False
+
+        # shortcut the trivial 'everything' / 'nothing' permissions
+        if not self.user.is_active:
+            return False
+        if self.user.is_superuser:
+            return True
+
+        # check that the page can be moved at all
+        if not self.can_move():
+            return False
+
+        # Inspect permissions on the destination
+        destination_perms = destination.permissions_for_user(self.user)
+
+        # we always need at least add permission in the target
+        if "add" not in destination_perms.permissions:
+            return False
+
+        if self.page.live or self.page.get_descendants().filter(live=True).exists():
+            # moving this page will entail publishing within the destination section
+            return "publish" in destination_perms.permissions
+        else:
+            # no publishing required, so the already-tested 'add' permission is sufficient
+            return True
+
+    def can_copy_to(self, destination, recursive=False):
+        # reject the logically impossible cases first
+        # recursive can't copy to the same tree otherwise it will be on infinite loop
+        if recursive and (
+            self.page == destination or destination.is_descendant_of(self.page)
+        ):
+            return False
+
+        # reject inactive users early
+        if not self.user.is_active:
+            return False
+
+        # reject early if pages of this type cannot be created at the destination
+        if not self.page.specific_class.can_create_at(destination):
+            return False
+
+        # skip permission checking for super users
+        if self.user.is_superuser:
+            return True
+
+        # Inspect permissions on the destination
+        destination_perms = destination.permissions_for_user(self.user)
+
+        if not destination.specific_class.creatable_subpage_models():
+            return False
+
+        # we always need at least add permission in the target
+        if "add" not in destination_perms.permissions:
+            return False
+
+        return True
+
+    def can_view_revisions(self):
+        return not self.page_is_root
+
+
+class PageViewRestriction(BaseViewRestriction):
+    page = models.ForeignKey(
+        "Page",
+        verbose_name=_("page"),
+        related_name="view_restrictions",
+        on_delete=models.CASCADE,
+    )
+
+    passed_view_restrictions_session_key = "passed_page_view_restrictions"
+
+    class Meta:
+        verbose_name = _("page view restriction")
+        verbose_name_plural = _("page view restrictions")
+
+    def save(self, user=None, **kwargs):
+        """
+        Custom save handler to include logging.
+        :param user: the user add/updating the view restriction
+        :param specific_instance: the specific model instance the restriction applies to
+        """
+        specific_instance = self.page.specific
+        is_new = self.id is None
+        super().save(**kwargs)
+
+        if specific_instance:
+            log(
+                instance=specific_instance,
+                action="wagtail.view_restriction.create"
+                if is_new
+                else "wagtail.view_restriction.edit",
+                user=user,
+                data={
+                    "restriction": {
+                        "type": self.restriction_type,
+                        "title": force_str(
+                            dict(self.RESTRICTION_CHOICES).get(self.restriction_type)
+                        ),
+                    }
+                },
+            )
+
+    def delete(self, user=None, **kwargs):
+        """
+        Custom delete handler to aid in logging.
+        :param user: the user removing the view restriction
+        """
+        specific_instance = self.page.specific
+        if specific_instance:
+            removed_restriction_type = PageViewRestriction.objects.filter(
+                id=self.id
+            ).values_list("restriction_type", flat=True)[0]
+            log(
+                instance=specific_instance,
+                action="wagtail.view_restriction.delete",
+                user=user,
+                data={
+                    "restriction": {
+                        "type": self.restriction_type,
+                        "title": force_str(
+                            dict(self.RESTRICTION_CHOICES).get(removed_restriction_type)
+                        ),
+                    }
+                },
+            )
+        return super().delete(**kwargs)
+
+
+class WorkflowPage(models.Model):
+    page = models.OneToOneField(
+        "Page",
+        verbose_name=_("page"),
+        on_delete=models.CASCADE,
+        primary_key=True,
+        unique=True,
+    )
+    workflow = models.ForeignKey(
+        "Workflow",
+        related_name="workflow_pages",
+        verbose_name=_("workflow"),
+        on_delete=models.CASCADE,
+    )
+
+    def get_pages(self):
+        """
+        Returns a queryset of pages that are affected by this ``WorkflowPage`` link.
+
+        This includes all descendants of the page excluding any that have other ``WorkflowPage``(s).
+        """
+        descendant_pages = Page.objects.descendant_of(self.page, inclusive=True)
+        descendant_workflow_pages = WorkflowPage.objects.filter(
+            page_id__in=descendant_pages.values_list("id", flat=True)
+        ).exclude(pk=self.pk)
+
+        for path, depth in descendant_workflow_pages.values_list(
+            "page__path", "page__depth"
+        ):
+            descendant_pages = descendant_pages.exclude(
+                path__startswith=path, depth__gte=depth
+            )
+
+        return descendant_pages
+
+    class Meta:
+        verbose_name = _("workflow page")
+        verbose_name_plural = _("workflow pages")
+
+
+class PageLogEntryQuerySet(LogEntryQuerySet):
+    def get_content_type_ids(self):
+        # for reporting purposes, pages of all types are combined under a single "Page"
+        # object type
+        if self.exists():
+            return {ContentType.objects.get_for_model(Page).pk}
+        else:
+            return set()
+
+    def filter_on_content_type(self, content_type):
+        if content_type == ContentType.objects.get_for_model(Page):
+            return self
+        else:
+            return self.none()
+
+
+class PageLogEntryManager(BaseLogEntryManager):
+    def get_queryset(self):
+        return PageLogEntryQuerySet(self.model, using=self._db)
+
+    def get_instance_title(self, instance):
+        return instance.specific_deferred.get_admin_display_title()
+
+    def log_action(self, instance, action, **kwargs):
+        kwargs.update(page=instance)
+        return super().log_action(instance, action, **kwargs)
+
+    def viewable_by_user(self, user):
+        from wagtail.permissions import page_permission_policy
+
+        explorable_instances = page_permission_policy.explorable_instances(user)
+        q = Q(page__in=explorable_instances.values_list("pk", flat=True))
+
+        root_page_permissions = Page.get_first_root_node().permissions_for_user(user)
+        if (
+            user.is_superuser
+            or root_page_permissions.can_add_subpage()
+            or root_page_permissions.can_edit()
+        ):
+            # Include deleted entries
+            q = q | Q(
+                page_id__in=Subquery(
+                    PageLogEntry.objects.filter(deleted=True).values("page_id")
+                )
+            )
+
+        return PageLogEntry.objects.filter(q)
+
+    def for_instance(self, instance):
+        return self.filter(page=instance)
+
+
+class PageLogEntry(BaseLogEntry):
+    page = models.ForeignKey(
+        "wagtailcore.Page",
+        on_delete=models.DO_NOTHING,
+        db_constraint=False,
+        related_name="+",
+    )
+
+    objects = PageLogEntryManager()
+
+    class Meta:
+        ordering = ["-timestamp", "-id"]
+        verbose_name = _("page log entry")
+        verbose_name_plural = _("page log entries")
+
+    def __str__(self):
+        return "PageLogEntry %d: '%s' on '%s' with id %s" % (
+            self.pk,
+            self.action,
+            self.object_verbose_name(),
+            self.page_id,
+        )
+
+    @cached_property
+    def object_id(self):
+        return self.page_id
+
+    @cached_property
+    def message(self):
+        # for page log entries, the 'edit' action should show as 'Draft saved'
+        if self.action == "wagtail.edit":
+            return _("Draft saved")
+        else:
+            return super().message
+
+
+class Comment(ClusterableModel):
+    """
+    A comment on a field, or a field within a streamfield block
+    """
+
+    page = ParentalKey(
+        Page, on_delete=models.CASCADE, related_name=COMMENTS_RELATION_NAME
+    )
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        related_name=COMMENTS_RELATION_NAME,
+    )
+    text = models.TextField()
+
+    contentpath = models.TextField()
+    # This stores the field or field within a streamfield block that the comment is applied on, in the form: 'field', or 'field.block_id.field'
+    # This must be unchanging across all revisions, so we will not support (current-format) ListBlock or the contents of InlinePanels initially.
+
+    position = models.TextField(blank=True)
+    # This stores the position within a field, to be interpreted by the field's frontend widget. It may change between revisions
+
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    revision_created = models.ForeignKey(
+        Revision,
+        on_delete=models.CASCADE,
+        related_name="created_comments",
+        null=True,
+        blank=True,
+    )
+
+    resolved_at = models.DateTimeField(null=True, blank=True)
+    resolved_by = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.SET_NULL,
+        related_name="comments_resolved",
+        null=True,
+        blank=True,
+    )
+
+    class Meta:
+        verbose_name = _("comment")
+        verbose_name_plural = _("comments")
+
+    def __str__(self):
+        return "Comment on Page '{}', left by {}: '{}'".format(
+            self.page, self.user, self.text
+        )
+
+    def save(self, update_position=False, **kwargs):
+        # Don't save the position unless specifically instructed to, as the position will normally be retrieved from the revision
+        update_fields = kwargs.pop("update_fields", None)
+        if not update_position and (
+            not update_fields or "position" not in update_fields
+        ):
+            if self.id:
+                # The instance is already saved; we can use `update_fields`
+                update_fields = (
+                    update_fields if update_fields else self._meta.get_fields()
+                )
+                update_fields = [
+                    field.name
+                    for field in update_fields
+                    if field.name not in {"position", "id"}
+                ]
+            else:
+                # This is a new instance, we have to preserve and then restore the position via a variable
+                position = self.position
+                result = super().save(**kwargs)
+                self.position = position
+                return result
+        return super().save(update_fields=update_fields, **kwargs)
+
+    def _log(self, action, page_revision=None, user=None):
+        log(
+            instance=self.page,
+            action=action,
+            user=user,
+            revision=page_revision,
+            data={
+                "comment": {
+                    "id": self.pk,
+                    "contentpath": self.contentpath,
+                    "text": self.text,
+                }
+            },
+        )
+
+    def log_create(self, **kwargs):
+        self._log("wagtail.comments.create", **kwargs)
+
+    def log_edit(self, **kwargs):
+        self._log("wagtail.comments.edit", **kwargs)
+
+    def log_resolve(self, **kwargs):
+        self._log("wagtail.comments.resolve", **kwargs)
+
+    def log_delete(self, **kwargs):
+        self._log("wagtail.comments.delete", **kwargs)
+
+    def has_valid_contentpath(self, page):
+        """
+        Return True if this comment's contentpath corresponds to a valid field or
+        StreamField block on the given page object.
+        """
+        field_name, *remainder = self.contentpath.split(".")
+        try:
+            field = page._meta.get_field(field_name)
+        except FieldDoesNotExist:
+            return False
+
+        if not remainder:
+            # comment applies to the field as a whole
+            return True
+
+        if not isinstance(field, StreamField):
+            # only StreamField supports content paths that are deeper than one level
+            return False
+
+        stream_value = getattr(page, field_name)
+        block = field.get_block_by_content_path(stream_value, remainder)
+        # content path is valid if this returns a BoundBlock rather than None
+        return bool(block)
+
+
+class CommentReply(models.Model):
+    comment = ParentalKey(Comment, on_delete=models.CASCADE, related_name="replies")
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        related_name="comment_replies",
+    )
+    text = models.TextField()
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        verbose_name = _("comment reply")
+        verbose_name_plural = _("comment replies")
+
+    def __str__(self):
+        return f"CommentReply left by '{self.user}': '{self.text}'"
+
+    def _log(self, action, page_revision=None, user=None):
+        log(
+            instance=self.comment.page,
+            action=action,
+            user=user,
+            revision=page_revision,
+            data={
+                "comment": {
+                    "id": self.comment.pk,
+                    "contentpath": self.comment.contentpath,
+                    "text": self.comment.text,
+                },
+                "reply": {
+                    "id": self.pk,
+                    "text": self.text,
+                },
+            },
+        )
+
+    def log_create(self, **kwargs):
+        self._log("wagtail.comments.create_reply", **kwargs)
+
+    def log_edit(self, **kwargs):
+        self._log("wagtail.comments.edit_reply", **kwargs)
+
+    def log_delete(self, **kwargs):
+        self._log("wagtail.comments.delete_reply", **kwargs)
+
+
+class PageSubscription(models.Model):
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        related_name="page_subscriptions",
+    )
+    page = models.ForeignKey(Page, on_delete=models.CASCADE, related_name="subscribers")
+
+    comment_notifications = models.BooleanField()
+
+    wagtail_reference_index_ignore = True
+
+    class Meta:
+        unique_together = [
+            ("page", "user"),
+        ]