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

wagtail/models/audit_log.py

@@ -97,7 +97,7 @@ class BaseLogEntryManager(models.Manager):
         return LogEntryQuerySet(self.model, using=self._db)
 
     def get_instance_title(self, instance):
-        return str(instance)
+        return str(instance) or f"{instance.__class__.__name__} object ({instance.pk})"
 
     def log_action(self, instance, action, **kwargs):
         """

wagtail/models/content_types.py

@@ -0,0 +1,11 @@
+from django.contrib.contenttypes.models import ContentType
+
+
+def get_default_page_content_type():
+    """
+    Returns the content type to use as a default for pages whose content type
+    has been deleted.
+    """
+    from wagtail.models import Page
+
+    return ContentType.objects.get_for_model(Page)

wagtail/models/draft_state.py

@@ -0,0 +1,197 @@
+from django.core import checks
+from django.db import models
+from django.utils.functional import cached_property
+from django.utils.translation import gettext_lazy as _
+
+from wagtail.actions.publish_revision import PublishRevisionAction
+from wagtail.actions.unpublish import UnpublishAction
+from wagtail.locks import ScheduledForPublishLock
+
+from .revisions import RevisionMixin
+
+
+class DraftStateMixin(models.Model):
+    live = models.BooleanField(verbose_name=_("live"), default=True, editable=False)
+    has_unpublished_changes = models.BooleanField(
+        verbose_name=_("has unpublished changes"), default=False, editable=False
+    )
+
+    first_published_at = models.DateTimeField(
+        verbose_name=_("first published at"), blank=True, null=True, db_index=True
+    )
+    last_published_at = models.DateTimeField(
+        verbose_name=_("last published at"), null=True, editable=False
+    )
+    live_revision = models.ForeignKey(
+        "wagtailcore.Revision",
+        related_name="+",
+        verbose_name=_("live revision"),
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        editable=False,
+    )
+
+    go_live_at = models.DateTimeField(
+        verbose_name=_("go live date/time"), blank=True, null=True
+    )
+    expire_at = models.DateTimeField(
+        verbose_name=_("expiry date/time"), blank=True, null=True
+    )
+    expired = models.BooleanField(
+        verbose_name=_("expired"), default=False, editable=False
+    )
+
+    class Meta:
+        abstract = True
+
+    @classmethod
+    def check(cls, **kwargs):
+        return [
+            *super().check(**kwargs),
+            *cls._check_revision_mixin(),
+        ]
+
+    @classmethod
+    def _check_revision_mixin(cls):
+        mro = cls.mro()
+        error = checks.Error(
+            "DraftStateMixin requires RevisionMixin to be applied after DraftStateMixin.",
+            hint="Add RevisionMixin to the model's base classes after DraftStateMixin.",
+            obj=cls,
+            id="wagtailcore.E004",
+        )
+
+        try:
+            if mro.index(RevisionMixin) < mro.index(DraftStateMixin):
+                return [error]
+        except ValueError:
+            return [error]
+
+        return []
+
+    @property
+    def approved_schedule(self):
+        return self.scheduled_revision is not None
+
+    @property
+    def status_string(self):
+        if not self.live:
+            if self.expired:
+                return _("expired")
+            elif self.approved_schedule:
+                return _("scheduled")
+            else:
+                return _("draft")
+        else:
+            if self.approved_schedule:
+                return _("live + scheduled")
+            elif self.has_unpublished_changes:
+                return _("live + draft")
+            else:
+                return _("live")
+
+    def publish(
+        self,
+        revision,
+        user=None,
+        changed=True,
+        log_action=True,
+        previous_revision=None,
+        skip_permission_checks=False,
+    ):
+        """
+        Publish a revision of the object by applying the changes in the revision to the live object.
+
+        :param revision: Revision to publish.
+        :type revision: Revision
+        :param user: The publishing user.
+        :param changed: Indicated whether content has changed.
+        :param log_action: Flag for the logging action, pass ``False`` to skip logging.
+        :param previous_revision: Indicates a revision reversal. Should be set to the previous revision instance.
+        :type previous_revision: Revision
+        """
+        return PublishRevisionAction(
+            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):
+        """
+        Unpublish the live object.
+
+        :param set_expired: Mark the object as expired.
+        :param commit: Commit the changes to the database.
+        :param user: The unpublishing user.
+        :param log_action: Flag for the logging action, pass ``False`` to skip logging.
+        """
+        return UnpublishAction(
+            self,
+            set_expired=set_expired,
+            commit=commit,
+            user=user,
+            log_action=log_action,
+        ).execute()
+
+    def with_content_json(self, content):
+        """
+        Similar to :meth:`RevisionMixin.with_content_json`,
+        but with the following fields also preserved:
+
+        * ``live``
+        * ``has_unpublished_changes``
+        * ``first_published_at``
+        """
+        obj = super().with_content_json(content)
+
+        # Ensure other values that are meaningful for the object as a whole (rather than
+        # to a specific revision) are preserved
+        obj.live = self.live
+        obj.has_unpublished_changes = self.has_unpublished_changes
+        obj.first_published_at = self.first_published_at
+
+        return obj
+
+    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
+
+        latest_revision = self.get_latest_revision()
+
+        if latest_revision:
+            return latest_revision.as_object()
+        else:
+            return self
+
+    @cached_property
+    def scheduled_revision(self):
+        return self.revisions.filter(approved_go_live_at__isnull=False).first()
+
+    def get_scheduled_revision_as_object(self):
+        scheduled_revision = self.scheduled_revision
+        return scheduled_revision and scheduled_revision.as_object()
+
+    def _update_from_revision(self, revision, changed=True):
+        update_fields = ["latest_revision"]
+        self.latest_revision = revision
+
+        if changed:
+            self.has_unpublished_changes = True
+            update_fields.append("has_unpublished_changes")
+
+        self.save(update_fields=update_fields)
+
+    def get_lock(self):
+        # Scheduled publishing lock should take precedence over other locks
+        if self.approved_schedule:
+            return ScheduledForPublishLock(self)
+        return super().get_lock()

wagtail/models/locking.py

@@ -0,0 +1,82 @@
+from django.conf import settings
+from django.core import checks
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+
+from wagtail.locks import BasicLock
+
+from .revisions import RevisionMixin
+
+
+class LockableMixin(models.Model):
+    locked = models.BooleanField(
+        verbose_name=_("locked"), default=False, editable=False
+    )
+    locked_at = models.DateTimeField(
+        verbose_name=_("locked at"), null=True, editable=False
+    )
+    locked_by = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        verbose_name=_("locked by"),
+        null=True,
+        blank=True,
+        editable=False,
+        on_delete=models.SET_NULL,
+        related_name="locked_%(class)ss",
+    )
+    locked_by.wagtail_reference_index_ignore = True
+
+    class Meta:
+        abstract = True
+
+    @classmethod
+    def check(cls, **kwargs):
+        return [
+            *super().check(**kwargs),
+            *cls._check_revision_mixin(),
+        ]
+
+    @classmethod
+    def _check_revision_mixin(cls):
+        mro = cls.mro()
+        error = checks.Error(
+            "LockableMixin must be applied before RevisionMixin.",
+            hint="Move LockableMixin in the model's base classes before RevisionMixin.",
+            obj=cls,
+            id="wagtailcore.E005",
+        )
+
+        try:
+            if mro.index(RevisionMixin) < mro.index(LockableMixin):
+                return [error]
+        except ValueError:
+            # LockableMixin can be used without RevisionMixin.
+            return []
+
+        return []
+
+    def with_content_json(self, content):
+        """
+        Similar to :meth:`RevisionMixin.with_content_json`,
+        but with the following fields also preserved:
+
+        * ``locked``
+        * ``locked_at``
+        * ``locked_by``
+        """
+        obj = super().with_content_json(content)
+
+        # Ensure other values that are meaningful for the object as a whole (rather than
+        # to a specific revision) are preserved
+        obj.locked = self.locked
+        obj.locked_at = self.locked_at
+        obj.locked_by = self.locked_by
+
+        return obj
+
+    def get_lock(self):
+        """
+        Returns a sub-class of ``BaseLock`` if the instance is locked, otherwise ``None``.
+        """
+        if self.locked:
+            return BasicLock(self)

wagtail/models/orderable.py

@@ -0,0 +1,10 @@
+from django.db import models
+
+
+class Orderable(models.Model):
+    sort_order = models.IntegerField(null=True, blank=True, editable=False)
+    sort_order_field = "sort_order"
+
+    class Meta:
+        abstract = True
+        ordering = ["sort_order"]