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

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

nautobot/extras/models/models.py

@@ -4,6 +4,7 @@ import json
 from db_file_storage.model_utils import delete_file, delete_file_if_needed
 from db_file_storage.storage import DatabaseFileStorage
 from django.conf import settings
+from django.contrib.auth import get_user_model
 from django.contrib.contenttypes.fields import GenericForeignKey
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ValidationError
@@ -31,7 +32,7 @@ from nautobot.extras.choices import (
 )
 from nautobot.extras.constants import HTTP_CONTENT_TYPE_JSON
 from nautobot.extras.models import ChangeLoggedModel
-from nautobot.extras.models.mixins import NotesMixin
+from nautobot.extras.models.mixins import ContactMixin, DynamicGroupsModelMixin, NotesMixin, SavedViewMixin
 from nautobot.extras.models.relationships import RelationshipModel
 from nautobot.extras.querysets import ConfigContextQuerySet, NotesQuerySet
 from nautobot.extras.utils import extras_features, FeatureQuery, image_upload
@@ -39,6 +40,7 @@ from nautobot.extras.utils import extras_features, FeatureQuery, image_upload
 # Avoid breaking backward compatibility on anything that might expect these to still be defined here:
 from .jobs import Job, JOB_LOGS, JobLogEntry, JobResult, ScheduledJob, ScheduledJobs  # noqa: F401  # unused-import
 
+User = get_user_model()
 #
 # Config contexts
 #
@@ -68,7 +70,15 @@ def limit_dynamic_group_choices():
 
 
 @extras_features("graphql")
-class ConfigContext(BaseModel, ChangeLoggedModel, ConfigContextSchemaValidationMixin, NotesMixin):
+class ConfigContext(
+    ChangeLoggedModel,
+    ConfigContextSchemaValidationMixin,
+    ContactMixin,
+    # DynamicGroupsModelMixin,  # TODO: conflicts with "dynamic_groups" M2M field on this model
+    NotesMixin,
+    SavedViewMixin,
+    BaseModel,
+):
     """
     A ConfigContext represents a set of arbitrary data available to any Device or VirtualMachine matching its assigned
     qualifiers (location, tenant, etc.). For example, the data stored in a ConfigContext assigned to location A and tenant B
@@ -297,10 +307,18 @@ class ConfigContextSchema(OrganizationalModel):
 
 
 @extras_features("graphql")
-class CustomLink(BaseModel, ChangeLoggedModel, NotesMixin):
+class CustomLink(
+    ChangeLoggedModel,
+    ContactMixin,
+    DynamicGroupsModelMixin,
+    NotesMixin,
+    SavedViewMixin,
+    BaseModel,
+):
     """
-    A custom link to an external representation of a Nautobot object. The link text and URL fields accept Jinja2 template
-    code to be rendered with an object as context.
+    A custom link to an external representation of a Nautobot object.
+
+    The link text and URL fields accept Jinja2 template code to be rendered with an object as context.
     """
 
     content_type = models.ForeignKey(
@@ -351,7 +369,15 @@ class CustomLink(BaseModel, ChangeLoggedModel, NotesMixin):
 @extras_features(
     "graphql",
 )
-class ExportTemplate(BaseModel, ChangeLoggedModel, RelationshipModel, NotesMixin):
+class ExportTemplate(
+    ChangeLoggedModel,
+    ContactMixin,
+    DynamicGroupsModelMixin,
+    RelationshipModel,
+    NotesMixin,
+    SavedViewMixin,
+    BaseModel,
+):
     # An ExportTemplate *may* be owned by another model, such as a GitRepository, or it may be un-owned
     owner_content_type = models.ForeignKey(
         to=ContentType,
@@ -644,7 +670,14 @@ class FileProxy(BaseModel):
 
 
 @extras_features("graphql")
-class GraphQLQuery(BaseModel, ChangeLoggedModel, NotesMixin):
+class GraphQLQuery(
+    ChangeLoggedModel,
+    ContactMixin,
+    DynamicGroupsModelMixin,
+    NotesMixin,
+    SavedViewMixin,
+    BaseModel,
+):
     name = models.CharField(max_length=CHARFIELD_MAX_LENGTH, unique=True)
     query = models.TextField()
     variables = models.JSONField(encoder=DjangoJSONEncoder, default=dict, blank=True)
@@ -697,6 +730,7 @@ class GraphQLQuery(BaseModel, ChangeLoggedModel, NotesMixin):
 
 class HealthCheckTestModel(BaseModel):
     title = models.CharField(max_length=CHARFIELD_MAX_LENGTH)
+    is_metadata_associable_model = False
 
 
 #
@@ -768,7 +802,7 @@ class ImageAttachment(BaseModel):
 
 
 @extras_features("graphql", "webhooks")
-class Note(BaseModel, ChangeLoggedModel):
+class Note(ChangeLoggedModel, BaseModel):
     """
     Notes allow anyone with proper permissions to add a note to an object.
     """
@@ -788,6 +822,8 @@ class Note(BaseModel, ChangeLoggedModel):
     note = models.TextField()
     objects = BaseManager.from_queryset(NotesQuerySet)()
 
+    is_metadata_associable_model = False
+
     class Meta:
         ordering = ["created"]
         unique_together = [["assigned_object_type", "assigned_object_id", "user_name", "created"]]
@@ -801,13 +837,86 @@ class Note(BaseModel, ChangeLoggedModel):
         return super().save(*args, **kwargs)
 
 
+#
+# SavedView
+#
+
+
+@extras_features(
+    "custom_validators",
+)
+class SavedView(BaseModel, ChangeLoggedModel):
+    owner = models.ForeignKey(
+        to=User, blank=False, null=False, on_delete=models.CASCADE, help_text="The user that created this view"
+    )
+    name = models.CharField(max_length=CHARFIELD_MAX_LENGTH, blank=False, null=False, help_text="The name of this view")
+    view = models.CharField(
+        max_length=CHARFIELD_MAX_LENGTH,
+        blank=False,
+        null=False,
+        help_text="The name of the list view that the saved view is derived from, e.g. dcim:device_list",
+    )
+    config = models.JSONField(
+        encoder=DjangoJSONEncoder, blank=True, default=dict, help_text="Saved Configuration on this view"
+    )
+    is_global_default = models.BooleanField(default=False)
+    is_shared = models.BooleanField(default=True)
+
+    documentation_static_path = "docs/user-guide/platform-functionality/savedview.html"
+
+    class Meta:
+        ordering = ["owner", "view", "name"]
+        unique_together = [["owner", "name", "view"]]
+        verbose_name = "saved view"
+        verbose_name_plural = "saved views"
+
+    def __str__(self):
+        return f"{self.owner.username} - {self.view} - {self.name}"
+
+    def save(self, *args, **kwargs):
+        # If this SavedView is set to a global default, all other saved views related to this view name should not be the global default.
+        if self.is_global_default:
+            SavedView.objects.filter(view=self.view, is_global_default=True).exclude(pk=self.pk).update(
+                is_global_default=False
+            )
+            # If the view is set to Global default, is_shared should be true regardless
+            self.is_shared = True
+
+        super().save(*args, **kwargs)
+
+
+@extras_features("graphql")
+class UserSavedViewAssociation(BaseModel):
+    saved_view = models.ForeignKey("extras.SavedView", on_delete=models.CASCADE, related_name="user_assignments")
+    user = models.ForeignKey("users.User", on_delete=models.CASCADE, related_name="saved_view_assignments")
+    view_name = models.CharField(max_length=CHARFIELD_MAX_LENGTH)
+    is_metadata_associable_model = False
+
+    class Meta:
+        unique_together = [["user", "view_name"]]
+
+    def __str__(self):
+        return f"{self.user}: {self.saved_view} - {self.view_name}"
+
+    def clean(self):
+        super().clean()
+        self.view_name = self.saved_view.view
+
+
 #
 # Webhooks
 #
 
 
 @extras_features("graphql")
-class Webhook(BaseModel, ChangeLoggedModel, NotesMixin):
+class Webhook(
+    ChangeLoggedModel,
+    ContactMixin,
+    DynamicGroupsModelMixin,
+    NotesMixin,
+    SavedViewMixin,
+    BaseModel,
+):
     """
     A Webhook defines a request that will be sent to a remote application when an object is created, updated, and/or
     delete in Nautobot. The request will contain a representation of the object, which the remote application can act on.

nautobot/extras/models/relationships.py

@@ -25,7 +25,7 @@ from nautobot.core.templatetags.helpers import bettertitle
 from nautobot.core.utils.lookup import get_filterset_for_model, get_route_for_model
 from nautobot.extras.choices import RelationshipRequiredSideChoices, RelationshipSideChoices, RelationshipTypeChoices
 from nautobot.extras.models import ChangeLoggedModel
-from nautobot.extras.models.mixins import NotesMixin
+from nautobot.extras.models.mixins import ContactMixin, DynamicGroupsModelMixin, NotesMixin, SavedViewMixin
 from nautobot.extras.utils import check_if_key_is_graphql_safe, extras_features, FeatureQuery
 
 logger = logging.getLogger(__name__)
@@ -416,7 +416,14 @@ class RelationshipManager(BaseManager.from_queryset(RestrictedQuerySet)):
         )
 
 
-class Relationship(BaseModel, ChangeLoggedModel, NotesMixin):
+class Relationship(
+    ChangeLoggedModel,
+    ContactMixin,
+    DynamicGroupsModelMixin,
+    NotesMixin,
+    SavedViewMixin,
+    BaseModel,
+):
     label = models.CharField(
         max_length=CHARFIELD_MAX_LENGTH, unique=True, help_text="Label of the relationship as displayed to users"
     )

nautobot/extras/models/tags.py

@@ -7,12 +7,13 @@ from nautobot.core.constants import CHARFIELD_MAX_LENGTH
 from nautobot.core.models import BaseManager, BaseModel
 from nautobot.core.models.fields import ColorField
 from nautobot.core.models.querysets import RestrictedQuerySet
+from nautobot.extras.models.mixins import SavedViewMixin
 from nautobot.extras.utils import extras_features, TaggableClassesQuery
 
 # These imports are in this particular order because of circular import problems
 from .change_logging import ChangeLoggedModel
 from .customfields import CustomFieldModel
-from .mixins import NotesMixin
+from .mixins import ContactMixin, DynamicGroupsModelMixin, NotesMixin
 from .relationships import RelationshipModel
 
 #
@@ -34,7 +35,16 @@ class TagQuerySet(RestrictedQuerySet):
 @extras_features(
     "custom_validators",
 )
-class Tag(BaseModel, ChangeLoggedModel, CustomFieldModel, RelationshipModel, NotesMixin):
+class Tag(
+    ChangeLoggedModel,
+    ContactMixin,
+    CustomFieldModel,
+    DynamicGroupsModelMixin,
+    NotesMixin,
+    RelationshipModel,
+    SavedViewMixin,
+    BaseModel,
+):
     name = models.CharField(max_length=CHARFIELD_MAX_LENGTH, unique=True)
     content_types = models.ManyToManyField(
         to=ContentType,
@@ -76,6 +86,7 @@ class TaggedItem(BaseModel, GenericUUIDTaggedItemBase):
     tag = models.ForeignKey(to=Tag, related_name="%(app_label)s_%(class)s_items", on_delete=models.CASCADE)
 
     documentation_static_path = "docs/user-guide/platform-functionality/tag.html"
+    is_metadata_associable_model = False
 
     natural_key_field_names = ["pk"]
 

nautobot/extras/navigation.py

@@ -240,6 +240,20 @@ menu_items = (
                     ),
                 ),
             ),
+            NavMenuGroup(
+                name="Users",
+                weight=150,
+                items=(
+                    NavMenuItem(
+                        link="extras:savedview_list",
+                        name="Saved Views",
+                        weight=100,
+                        permissions=[
+                            "extras.view_savedview",
+                        ],
+                    ),
+                ),
+            ),
             NavMenuGroup(
                 name="Data Sources",
                 weight=200,
@@ -448,6 +462,37 @@ menu_items = (
                     ),
                 ),
             ),
+            NavMenuGroup(
+                name="Metadata",
+                weight=700,
+                items=(
+                    NavMenuItem(
+                        link="extras:metadatatype_list",
+                        name="Metadata Types",
+                        weight=100,
+                        permissions=[
+                            "extras.view_metadatatype",
+                        ],
+                        buttons=(
+                            NavMenuAddButton(
+                                link="extras:metadatatype_add",
+                                permissions=[
+                                    "extras.add_metadatatype",
+                                ],
+                            ),
+                        ),
+                    ),
+                    NavMenuItem(
+                        link="extras:objectmetadata_list",
+                        name="Object Metadata",
+                        weight=200,
+                        permissions=[
+                            "extras.view_objectmetadata",
+                        ],
+                        buttons=(),
+                    ),
+                ),
+            ),
         ),
     ),
     NavMenuTab(
@@ -713,6 +758,18 @@ navigation = (
                     ),
                 ),
             ),
+            NavGrouping(
+                name="Users",
+                weight=500,
+                items=(
+                    NavItem(
+                        link="extras:savedview_list",
+                        name="Saved Views",
+                        weight=100,
+                        permissions=["extras.view_savedviews"],
+                    ),
+                ),
+            ),
         ),
     ),
 )

nautobot/extras/plugins/__init__.py

@@ -45,6 +45,8 @@ class NautobotAppConfig(NautobotConfig):
     Subclass of Django's built-in AppConfig class, to be used for Nautobot plugins.
     """
 
+    default = True
+
     # Plugin metadata
     author = ""
     author_email = ""
@@ -205,7 +207,7 @@ class NautobotAppConfig(NautobotConfig):
         if override_views is not None:
             for qualified_view_name, view in override_views.items():
                 self.features.setdefault("overridden_views", []).append(
-                    (qualified_view_name, f"{view.__module__}.{view.__name__}")
+                    (qualified_view_name, f"{view.__module__}.{view.view_class.__name__}")
                 )
             register_override_views(override_views, self.name)