nautobot 2.2.9__py3-none-any.whl → 2.3.0__py3-none-any.whl

nautobot/extras/models/jobs.py

@@ -43,7 +43,7 @@ from nautobot.extras.constants import (
 )
 from nautobot.extras.managers import JobResultManager, ScheduledJobsManager
 from nautobot.extras.models import ChangeLoggedModel, GitRepository
-from nautobot.extras.models.mixins import NotesMixin
+from nautobot.extras.models.mixins import ContactMixin, DynamicGroupsModelMixin, NotesMixin
 from nautobot.extras.querysets import JobQuerySet, ScheduledJobExtendedQuerySet
 from nautobot.extras.utils import (
     ChangeLoggedModelsQuery,
@@ -456,6 +456,8 @@ class JobLogEntry(BaseModel):
     log_object = models.CharField(max_length=JOB_LOG_MAX_LOG_OBJECT_LENGTH, blank=True, default="")
     absolute_url = models.CharField(max_length=JOB_LOG_MAX_ABSOLUTE_URL_LENGTH, blank=True, default="")
 
+    is_metadata_associable_model = False
+
     documentation_static_path = "docs/user-guide/platform-functionality/jobs/models.html"
 
     def __str__(self):
@@ -793,9 +795,10 @@ class JobResult(BaseModel, CustomFieldModel):
 
 
 @extras_features("graphql")
-class JobButton(BaseModel, ChangeLoggedModel, NotesMixin):
+class JobButton(ContactMixin, ChangeLoggedModel, DynamicGroupsModelMixin, NotesMixin, BaseModel):
     """
-    A predefined button that includes all necessary information to run a Nautobot Job based on a single object as a source.
+    A predefined button that includes all information to run a Nautobot Job based on a single object as a source.
+
     The button text field accepts Jinja2 template code to be rendered with an object as context.
     """
 

nautobot/extras/models/metadata.py

@@ -0,0 +1,441 @@
+from datetime import date, datetime, timezone
+
+from django.contrib.contenttypes.fields import GenericForeignKey
+from django.contrib.contenttypes.models import ContentType
+from django.core.cache import cache
+from django.core.exceptions import ValidationError
+from django.db import models
+
+from nautobot.core.constants import CHARFIELD_MAX_LENGTH
+from nautobot.core.models import BaseManager, BaseModel
+from nautobot.core.models.fields import JSONArrayField
+from nautobot.core.models.generics import PrimaryModel
+from nautobot.core.models.querysets import RestrictedQuerySet
+from nautobot.core.settings_funcs import is_truthy
+from nautobot.extras.choices import MetadataTypeDataTypeChoices
+from nautobot.extras.models.change_logging import ChangeLoggedModel
+from nautobot.extras.models.contacts import Contact, Team
+from nautobot.extras.utils import extras_features, FeatureQuery
+
+
+class MetadataTypeManager(BaseManager.from_queryset(RestrictedQuerySet)):
+    use_in_migrations = True
+
+    def get_for_model(self, model):
+        """Return all MetadataTypes assigned to the given model."""
+        concrete_model = model._meta.concrete_model
+        cache_key = f"{self.get_for_model.cache_key_prefix}.{concrete_model._meta.label_lower}"
+        queryset = cache.get(cache_key)
+        if queryset is None:
+            content_type = ContentType.objects.get_for_model(concrete_model)
+            queryset = self.get_queryset().filter(content_types=content_type)
+            cache.set(cache_key, queryset)
+        return queryset
+
+    get_for_model.cache_key_prefix = "nautobot.extras.metadatatype.get_for_model"
+
+
+@extras_features(
+    "custom_links",
+    "custom_validators",
+    "export_templates",
+    "graphql",
+    "webhooks",
+)
+class MetadataType(PrimaryModel):
+    content_types = models.ManyToManyField(
+        to=ContentType,
+        related_name="metadata_types",
+        limit_choices_to=FeatureQuery("metadata"),
+        help_text="The object type(s) to which Metadata of this type can be applied.",
+    )
+    name = models.CharField(max_length=CHARFIELD_MAX_LENGTH, unique=True)
+    description = models.CharField(max_length=CHARFIELD_MAX_LENGTH, blank=True)
+    data_type = models.CharField(
+        max_length=50,
+        choices=MetadataTypeDataTypeChoices,
+        help_text="The type of data allowed for any Metadata of this type.",
+    )
+    # TODO: validation_minimum, validation_maximum, validation_regex?
+    # TODO: weight, grouping, advanced_ui?
+
+    objects = MetadataTypeManager()
+    clone_fields = ["data_type"]
+    documentation_static_path = "docs/user-guide/platform-functionality/objectmetadata.html"
+
+    class Meta:
+        ordering = ["name"]
+
+    def __str__(self):
+        return self.name
+
+    def clean(self):
+        super().clean()
+
+        if self.present_in_database:
+            # Check immutable fields
+            database_object = self.__class__.objects.get(pk=self.pk)
+            if self.data_type != database_object.data_type:
+                raise ValidationError({"data_type": "Type cannot be changed once created"})
+
+        # Choices can be set only on selection fields
+        if self.choices.exists() and self.data_type not in (
+            MetadataTypeDataTypeChoices.TYPE_SELECT,
+            MetadataTypeDataTypeChoices.TYPE_MULTISELECT,
+        ):
+            raise ValidationError("Choices may be set only for select/multi-select data_type.")
+
+
+@extras_features(
+    "custom_validators",
+    "graphql",
+    "webhooks",
+)
+class MetadataChoice(ChangeLoggedModel, BaseModel):
+    """Store the possible set of values for a select/multi-select metadata type."""
+
+    metadata_type = models.ForeignKey(
+        to=MetadataType,
+        on_delete=models.CASCADE,
+        related_name="choices",
+        limit_choices_to=models.Q(
+            data_type__in=[MetadataTypeDataTypeChoices.TYPE_SELECT, MetadataTypeDataTypeChoices.TYPE_MULTISELECT]
+        ),
+    )
+    value = models.CharField(max_length=CHARFIELD_MAX_LENGTH)
+    weight = models.PositiveSmallIntegerField(default=100, help_text="Higher weights appear later in the list")
+    is_metadata_associable_model = False
+
+    documentation_static_path = "docs/user-guide/platform-functionality/objectmetadata.html"
+
+    class Meta:
+        ordering = ["metadata_type", "weight", "value"]
+        unique_together = ["metadata_type", "value"]
+
+    def __str__(self):
+        return self.value
+
+    def clean(self):
+        super().clean()
+
+        if self.present_in_database:
+            # Check immutable fields
+            database_object = self.__class__.objects.get(pk=self.pk)
+            if self.metadata_type != database_object.metadata_type:
+                raise ValidationError({"metadata_type": "Cannot be changed once created"})
+
+        if self.metadata_type.data_type not in (
+            MetadataTypeDataTypeChoices.TYPE_SELECT,
+            MetadataTypeDataTypeChoices.TYPE_MULTISELECT,
+        ):
+            raise ValidationError(
+                {"metadata_type": "Metadata choices can only be assigned to select/multiselect data_type."}
+            )
+        # TODO: enforce validation_minimum, validation_maximum, validation_regex like CustomFieldChoice does?
+
+    def save(self, *args, **kwargs):
+        super().save(*args, **kwargs)
+        # TODO: on change of value, enqueue background task to go through all existing metadata and update them,
+        #       like CustomFieldChoice does?
+        # TODO: Alternately, should we let Metadata just have a FK directly to its corresponding MetadataTypeChoice?
+
+    def delete(self, *args, **kwargs):
+        # TODO: should we behave like CustomFieldChoice and raise a ProtectedError if this choice is in use anywhere?
+        super().delete(*args, **kwargs)
+
+
+class ObjectMetadataManager(BaseManager.from_queryset(RestrictedQuerySet)):
+    use_in_migrations = True
+
+    def get_for_object(self, instance):
+        """Return all ObjectMetadatas assigned to the given instance."""
+        assigned_object_type = ContentType.objects.get_for_model(instance)
+        assigned_object_id = instance.pk
+        queryset = self.get_queryset().filter(
+            assigned_object_type=assigned_object_type, assigned_object_id=assigned_object_id
+        )
+        return queryset
+
+
+@extras_features(
+    "custom_validators",
+    "graphql",
+    "webhooks",
+)
+class ObjectMetadata(ChangeLoggedModel, BaseModel):
+    metadata_type = models.ForeignKey(
+        to=MetadataType,
+        on_delete=models.PROTECT,
+        related_name="object_metadata",
+    )
+    contact = models.ForeignKey(
+        to=Contact,
+        on_delete=models.PROTECT,
+        related_name="object_metadata",
+        blank=True,
+        null=True,
+    )
+    team = models.ForeignKey(
+        to=Team,
+        on_delete=models.PROTECT,
+        related_name="object_metadata",
+        blank=True,
+        null=True,
+    )
+    scoped_fields = JSONArrayField(
+        base_field=models.CharField(
+            max_length=CHARFIELD_MAX_LENGTH,
+        ),
+        blank=True,
+        help_text="List of scoped fields, only direct fields on the model",
+    )
+    _value = models.JSONField(
+        blank=True,
+        null=True,
+        help_text="Relevant data value to an object field or a set of object fields",
+    )
+    assigned_object_type = models.ForeignKey(to=ContentType, on_delete=models.SET_NULL, null=True, related_name="+")
+    assigned_object_id = models.UUIDField(db_index=True)
+    assigned_object = GenericForeignKey(ct_field="assigned_object_type", fk_field="assigned_object_id")
+
+    objects = ObjectMetadataManager()
+    natural_key_field_names = ["pk"]
+    documentation_static_path = "docs/user-guide/platform-functionality/objectmetadata.html"
+
+    class Meta:
+        ordering = ["metadata_type"]
+        verbose_name_plural = "object metadata"
+
+        indexes = [
+            models.Index(
+                name="assigned_object",
+                fields=["assigned_object_type", "assigned_object_id"],
+            ),
+            models.Index(
+                name="assigned_object_contact",
+                fields=["assigned_object_type", "assigned_object_id", "contact"],
+            ),
+            models.Index(
+                name="assigned_object_team",
+                fields=["assigned_object_type", "assigned_object_id", "team"],
+            ),
+        ]
+
+    @property
+    def value(self):
+        if self.metadata_type.data_type == MetadataTypeDataTypeChoices.TYPE_CONTACT_TEAM:
+            return None
+        else:
+            return self._value
+
+    @value.setter
+    def value(self, v):
+        if self.metadata_type.data_type == MetadataTypeDataTypeChoices.TYPE_CONTACT_TEAM:
+            if v is not None:
+                raise ValidationError(
+                    f"{v} is an invalid value for metadata type data type {self.metadata_type.data_type}"
+                )
+        else:
+            self._value = v
+        self.clean()
+
+    def __str__(self):
+        if self.metadata_type.data_type == MetadataTypeDataTypeChoices.TYPE_CONTACT_TEAM:
+            return f"{self.metadata_type} - {self.assigned_object} - {self.contact or self.team}"
+        return f"{self.metadata_type} - {self.assigned_object} - {self.value}"
+
+    def validated_save(self, *args, **kwargs):
+        # call clean() first so that the data type-conversion is done first
+        # so that clean_fields() would not raise any errors
+        self.clean()
+        return super().validated_save(*args, **kwargs)
+
+    def clean(self):
+        """
+        Validate a value according to the field's type validation rules.
+
+        Returns the value, possibly cleaned up
+        """
+        super().clean()
+        value = self.value
+        metadata_type_data_type = self.metadata_type.data_type
+        if self.present_in_database:
+            # Check immutable fields
+            database_object = self.__class__.objects.get(pk=self.pk)
+            if self.metadata_type != database_object.metadata_type:
+                raise ValidationError({"metadata_type": "Cannot be changed once created"})
+        # Validate the assigned_object_type is allowed in metadata_type's content_types
+        if not self.metadata_type.content_types.filter(pk=self.assigned_object_type.id).exists():
+            raise ValidationError(
+                f"Assigned Object Type {self.assigned_object_type} is not allowed by Metadata Type {self.metadata_type}"
+            )
+        # Check for MetadataTypeDataTypeChoices.TYPE_CONTACT_TEAM first
+        if metadata_type_data_type == MetadataTypeDataTypeChoices.TYPE_CONTACT_TEAM:
+            if value is not None:
+                raise ValidationError(f"A value cannot be specified for type {metadata_type_data_type}")
+            if self.contact is None and self.team is None:
+                raise ValidationError("Either a contact or a team must be specified")
+            if self.contact is not None and self.team is not None:
+                raise ValidationError("A contact and a team cannot be both specified at once")
+        elif value is None:
+            raise ValidationError(
+                f"value is a required field that cannot be empty for metadata type {metadata_type_data_type}."
+            )
+        else:
+            # Validate text field
+            if metadata_type_data_type in (
+                MetadataTypeDataTypeChoices.TYPE_TEXT,
+                MetadataTypeDataTypeChoices.TYPE_URL,
+                MetadataTypeDataTypeChoices.TYPE_MARKDOWN,
+            ):
+                if not isinstance(value, str):
+                    raise ValidationError("Value must be a string")
+                # TODO uncomment this when MetaDataType validation_minimum, validation_maximum and validation_regex fields are implemented
+                # if self.metadata_type.validation_minimum is not None and len(value) < self.metadata_type.validation_minimum:
+                #     raise ValidationError(f"Value must be at least {self.metadata_type.validation_minimum} characters in length")
+                # if self.metadata_type.validation_maximum is not None and len(value) > self.metadata_type.validation_maximum:
+                #     raise ValidationError(f"Value must not exceed {self.metadata_type.validation_maximum} characters in length")
+                # if self.metadata_type.validation_regex and not re.search(self.metadata_type.validation_regex, value):
+                #     raise ValidationError(f"Value must match regex '{self.metadata_type.validation_regex}'")
+
+            # Validate JSON
+            elif metadata_type_data_type == MetadataTypeDataTypeChoices.TYPE_JSON:
+                pass
+                # TODO uncomment this when MetaDataType validation_minimum, validation_maximum and validation_regex fields are implemented
+                # if (
+                #     self.metadata_type.validation_regex
+                #     or self.metadata_type.validation_minimum is not None
+                #     or self.metadata_type.validation_maximum is not None
+                # ):
+                #     json_value = json.dumps(value)
+                #     if (
+                #         self.metadata_type.validation_minimum is not None
+                #         and len(json_value) < self.metadata_type.validation_minimum
+                #     ):
+                #         raise ValidationError(
+                #             f"Value must be at least {self.metadata_type.validation_minimum} characters in length"
+                #         )
+                #     if (
+                #         self.metadata_type.validation_maximum is not None
+                #         and len(json_value) > self.metadata_type.validation_maximum
+                #     ):
+                #         raise ValidationError(
+                #             f"Value must not exceed {self.metadata_type.validation_maximum} characters in length"
+                #         )
+                #     if self.metadata_type.validation_regex and not re.search(
+                #         self.metadata_type.validation_regex, json_value
+                #     ):
+                #         raise ValidationError(f"Value must match regex '{self.metadata_type.validation_regex}'")
+
+            # Validate integer
+            elif metadata_type_data_type == MetadataTypeDataTypeChoices.TYPE_INTEGER:
+                try:
+                    value = int(value)
+                except ValueError:
+                    raise ValidationError("Value must be an integer.")
+                # TODO uncomment this when MetaDataType validation_minimum, validation_maximum and validation_regex fields are implemented
+                # if self.metadata_type.validation_minimum is not None and value < self.metadata_type.validation_minimum:
+                #     raise ValidationError(f"Value must be at least {self.metadata_type.validation_minimum}")
+                # if self.metadata_type.validation_maximum is not None and value > self.metadata_type.validation_maximum:
+                #     raise ValidationError(f"Value must not exceed {self.metadata_type.validation_maximum}")
+            # Validate integer
+            elif metadata_type_data_type == MetadataTypeDataTypeChoices.TYPE_FLOAT:
+                try:
+                    value = float(value)
+                except ValueError:
+                    raise ValidationError("Value must be a float.")
+            # Validate boolean
+            elif metadata_type_data_type == MetadataTypeDataTypeChoices.TYPE_BOOLEAN:
+                try:
+                    value = is_truthy(value)
+                except ValueError as exc:
+                    raise ValidationError("Value must be true or false.") from exc
+
+            # Validate date
+            elif metadata_type_data_type == MetadataTypeDataTypeChoices.TYPE_DATE:
+                if not isinstance(value, date):
+                    try:
+                        datetime.strptime(value, "%Y-%m-%d")
+                    except TypeError:
+                        raise ValidationError("Value must be a date or str object.")
+                    except ValueError:
+                        raise ValidationError("Date values must be in the format YYYY-MM-DD.")
+            # Validate datetime
+            elif metadata_type_data_type == MetadataTypeDataTypeChoices.TYPE_DATETIME:
+                if isinstance(value, datetime):
+                    # check if datetime object has tzinfo
+                    if value.tzinfo is None:
+                        value = value.replace(tzinfo=timezone.utc)  # pylint: disable=unexpected-keyword-arg,no-value-for-parameter
+                    value = value.replace(microsecond=0).isoformat()  # pylint: disable=unexpected-keyword-arg,no-value-for-parameter
+                else:
+                    acceptable_datetime_formats = [
+                        "YYYY-MM-DDTHH:MM:SS",
+                        "YYYY-MM-DDTHH:MM:SS(+,-)zzzz",
+                        "YYYY-MM-DDTHH:MM:SS(+,-)zz:zz",
+                    ]
+                    try:
+                        datetime.strptime(value, "%Y-%m-%dT%H:%M:%S%z")
+                    except ValueError:
+                        try:
+                            # No time zone info entered so assume UTC timezone
+                            datetime.strptime(value, "%Y-%m-%dT%H:%M:%S")
+                            value += "+0000"
+                        except ValueError:
+                            raise ValidationError(
+                                f"Datetime values must be in the following formats {acceptable_datetime_formats}"
+                            )
+                    except TypeError:
+                        raise ValidationError("Value must be a datetime or str object.")
+            # Validate selected choice
+            elif metadata_type_data_type == MetadataTypeDataTypeChoices.TYPE_SELECT:
+                if value not in self.metadata_type.choices.values_list("value", flat=True):
+                    raise ValidationError(
+                        f"Invalid choice ({value}). Available choices are: {', '.join(self.metadata_type.choices.values_list('value', flat=True))}"
+                    )
+
+            elif metadata_type_data_type == MetadataTypeDataTypeChoices.TYPE_MULTISELECT:
+                if isinstance(value, str):
+                    value = value.split(",")
+                if not set(value).issubset(self.metadata_type.choices.values_list("value", flat=True)):
+                    raise ValidationError(
+                        f"Invalid choice(s) ({value}). Available choices are: {', '.join(self.metadata_type.choices.values_list('value', flat=True))}"
+                    )
+        self._value = value
+
+        # Check if there is any intersections of scoped_fields of ObjectMetadata instances in the database.
+        object_metadata_scoped_fields = (
+            ObjectMetadata.objects.filter(
+                metadata_type=self.metadata_type,
+                assigned_object_type=self.assigned_object_type,
+                assigned_object_id=self.assigned_object_id,
+            )
+            .exclude(pk=self.pk)
+            .values_list("scoped_fields", flat=True)
+        )
+        duplicate_scoped_fields_list = set([])
+
+        # TODO Make sure that scoped fields are all direct fields on the assigned_object_type model
+
+        for scoped_fields in object_metadata_scoped_fields:
+            duplicate_scoped_fields_list |= set(self.scoped_fields).intersection(scoped_fields)
+            # if self.scoped_fields or scoped_fields are [] which means all fields are scoped
+            # That means any fields in self.scoped_fields or scoped_fields are considered overlapped
+            if not self.scoped_fields:
+                raise ValidationError(
+                    {
+                        "scoped_fields": f"This Object Metadata {self} scoping all the fields for {self.assigned_object} has overlapped with the scoped fields of other Object Metadata instances."
+                    }
+                )
+            if not scoped_fields:
+                raise ValidationError(
+                    {
+                        "scoped_fields": f"There are other Object Metadata instances of metadata type {self.metadata_type} scoping all the fields for {self.assigned_object}"
+                    }
+                )
+
+        if duplicate_scoped_fields_list:
+            raise ValidationError(
+                {
+                    "scoped_fields": f"There are other Object Metadata instances of metadata type {self.metadata_type} scoping the same fields {duplicate_scoped_fields_list} for {self.assigned_object}"
+                }
+            )

nautobot/extras/models/mixins.py

@@ -2,95 +2,79 @@
 Class-modifying mixins that need to be standalone to avoid circular imports.
 """
 
+from django.contrib.contenttypes.fields import GenericRelation
+from django.db import models
 from django.urls import NoReverseMatch, reverse
 
+from nautobot.core.utils.deprecation import method_deprecated_in_favor_of
 from nautobot.core.utils.lookup import get_route_for_model
 
 
-class DynamicGroupMixin:
-    """
-    Adds properties to a model to facilitate reversing DynamicGroup membership:
+class ContactMixin(models.Model):
+    """Abstract mixin for enabling Contact/Team association to a given model class."""
 
-    - `dynamic_groups` - A QuerySet of `DynamicGroup` objects this instance is a member of, performs the most database queries.
-    - `dynamic_groups_cached` - A QuerySet of `DynamicGroup` objects this instance is a member of, uses cached member list if available. Ideal for most use cases.
-    - `dynamic_groups_list` - A list of `DynamicGroup` objects this instance is a member of, performs one less database query than `dynamic_groups`.
-    - `dynamic_groups_list_cached` - A list of `DynamicGroup` objects this instance is a member of, uses cached member list if available. Performs no database queries in optimal conditions.
+    class Meta:
+        abstract = True
 
-    All properties are cached on the instance after the first call. To clear the instance cache without re-instantiating the object, call `delattr(instance, "_[the_property_name]")`.
-        EX: `delattr(instance, "_dynamic_groups")`
-    """
+    is_contact_associable_model = True
 
-    @property
-    def dynamic_groups(self):
-        """
-        Return a queryset of `DynamicGroup` objects this instance is a member of.
+    # Reverse relation so that deleting a ContactMixin automatically deletes any ContactAssociations related to it.
+    associated_contacts = GenericRelation(
+        "extras.ContactAssociation",
+        content_type_field="associated_object_type",
+        object_id_field="associated_object_id",
+        related_query_name="associated_contacts_%(app_label)s_%(class)s",  # e.g. 'associated_contacts_dcim_device'
+    )
 
-        This will NOT use the cached member lists of the dynamic groups and will always query the database for each DynamicGroup.
 
-        Additionally, this performs a final database query to turn the internal list into a queryset.
-        """
-        from nautobot.extras.models.groups import DynamicGroup
+class DynamicGroupMixin:
+    """
+    DEPRECATED - use DynamicGroupsModelMixin instead if you need to mark a model as supporting Dynamic Groups.
 
-        if not hasattr(self, "_dynamic_groups"):
-            queryset = DynamicGroup.objects.get_for_object(self)
-            self._dynamic_groups = queryset
+    This is necessary because DynamicGroupMixin was incorrectly not implemented as a subclass of models.Model,
+    and so it cannot properly implement Model behaviors like the `static_group_association_set` ReverseRelation.
+    However, adding this inheritance to DynamicGroupMixin itself would negatively impact existing migrations.
+    So unfortunately our best option is to deprecate this class and gradually convert core and app models alike
+    to the new DynamicGroupsModelMixin in its place.
 
-        return self._dynamic_groups
+    Adds `dynamic_groups` property to a model to facilitate reversing (cached) DynamicGroup membership.
 
-    @property
-    def dynamic_groups_cached(self):
-        """
-        Return a queryset of `DynamicGroup` objects this instance is a member of.
+    If up-to-the-minute accuracy is necessary for your use case, it's up to you to call the
+    `DynamicGroup.update_cached_members()` API on any relevant DynamicGroups before accessing this property.
 
-        This will use the cached member lists of the dynamic groups if available.
+    Other related properties added by this mixin should be considered obsolete.
+    """
 
-        In optimal conditions this will incur a single database query to convert internal list into a queryset which is reasonably performant.
+    is_dynamic_group_associable_model = True
 
-        This is the ideal property to use for most use cases.
+    @property
+    def dynamic_groups(self):
+        """
+        Return a queryset of (cached) `DynamicGroup` objects this instance is a member of.
         """
         from nautobot.extras.models.groups import DynamicGroup
 
-        if not hasattr(self, "_dynamic_groups_cached"):
-            queryset = DynamicGroup.objects.get_for_object(self, use_cache=True)
-            self._dynamic_groups_cached = queryset
+        return DynamicGroup.objects.get_for_object(self)
 
-        return self._dynamic_groups_cached
+    @property
+    @method_deprecated_in_favor_of(dynamic_groups.fget)
+    def dynamic_groups_cached(self):
+        """Deprecated - use `self.dynamic_groups` instead."""
+        return self.dynamic_groups
 
     @property
+    @method_deprecated_in_favor_of(dynamic_groups.fget)
     def dynamic_groups_list(self):
-        """
-        Return a list of `DynamicGroup` objects this instance is a member of.
-
-        This will NOT use the cached member lists of the dynamic groups and will always query the database for each DynamicGroup.
-
-        This saves a final query to turn the list into a queryset.
-        """
-        from nautobot.extras.models.groups import DynamicGroup
-
-        if not hasattr(self, "_dynamic_groups_list"):
-            dg_list = DynamicGroup.objects.get_list_for_object(self)
-            self._dynamic_groups_list = dg_list
-
-        return self._dynamic_groups_list
+        """Deprecated - use `list(self.dynamic_groups)` instead."""
+        return list(self.dynamic_groups)
 
     @property
+    @method_deprecated_in_favor_of(dynamic_groups.fget)
     def dynamic_groups_list_cached(self):
-        """
-        Return a list of `DynamicGroup` objects this instance is a member of.
-
-        This will use the cached member lists of the dynamic groups if available.
-
-        In optimal conditions this will incur no database queries.
-        """
-
-        from nautobot.extras.models.groups import DynamicGroup
-
-        if not hasattr(self, "_dynamic_groups_list_cached"):
-            dg_list = DynamicGroup.objects.get_list_for_object(self, use_cache=True)
-            self._dynamic_groups_list_cached = dg_list
-
-        return self._dynamic_groups_list_cached
+        """Deprecated - use `list(self.dynamic_groups)` instead."""
+        return self.dynamic_groups_list
 
+    # TODO may be able to remove this entirely???
     def get_dynamic_groups_url(self):
         """Return the dynamic groups URL for a given instance."""
         route = get_route_for_model(self, "dynamicgroups")
@@ -109,6 +93,23 @@ class DynamicGroupMixin:
         return None
 
 
+class DynamicGroupsModelMixin(DynamicGroupMixin, models.Model):
+    """
+    Add this to models to make them fully support Dynamic Groups.
+    """
+
+    class Meta:
+        abstract = True
+
+    # Reverse relation so that deleting a DynamicGroupMixin automatically deletes any related StaticGroupAssociations
+    static_group_association_set = GenericRelation(  # not "static_group_associations" as that'd collide on DynamicGroup
+        "extras.StaticGroupAssociation",
+        content_type_field="associated_object_type",
+        object_id_field="associated_object_id",
+        related_query_name="static_group_association_set_%(app_label)s_%(class)s",
+    )
+
+
 class NotesMixin:
     """
     Adds a `notes` property that returns a queryset of `Notes` membership.
@@ -141,3 +142,12 @@ class NotesMixin:
                 continue
 
         return None
+
+
+class SavedViewMixin(models.Model):
+    """Abstract mixin for enabling Saved View functionality to a given model class."""
+
+    class Meta:
+        abstract = True
+
+    is_saved_view_model = True