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

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)
 

nautobot/extras/querysets.py

@@ -1,12 +1,10 @@
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
-from django.core.cache import cache
 from django.db.models import F, Model, OuterRef, Q, Subquery
 from django.db.models.functions import JSONObject
 
 from nautobot.core.models.query_functions import EmptyGroupByJSONBAgg
 from nautobot.core.models.querysets import RestrictedQuerySet
-from nautobot.core.utils.config import get_settings_or_config
 from nautobot.extras.models.tags import TaggedItem
 
 
@@ -85,10 +83,10 @@ class ConfigContextModelQuerySet(RestrictedQuerySet):
         """
         Attach the subquery annotation to the base queryset.
 
-        Order By clause in Subquery is not guaranteed to be respected within the aggregated JSON array, which is why
-        we include "weight" and "name" into the result so that we can sort it within Python to ensure correctness.
+        Note that the underlying function of our JSONBAgg in MySQL, `JSONARRAY_AGG`, does not support an `ordering`,
+        unlike PostgreSQL's implementation. This is why we include "weight" and "name" into the result so that we can
+        sort it within Python to ensure correctness.
 
-        TODO This method does not accurately reflect location inheritance because of the reasons stated in _get_config_context_filters()
         Do not use this method by itself, use get_config_context() method directly on ConfigContextModel instead.
         """
         from nautobot.extras.models import ConfigContext
@@ -96,7 +94,6 @@ class ConfigContextModelQuerySet(RestrictedQuerySet):
         return self.annotate(
             config_context_data=Subquery(
                 ConfigContext.objects.filter(self._get_config_context_filters())
-                .order_by("weight", "name")
                 .annotate(
                     _data=EmptyGroupByJSONBAgg(
                         JSONObject(
@@ -107,15 +104,13 @@ class ConfigContextModelQuerySet(RestrictedQuerySet):
                     )
                 )
                 .values("_data")
+                .order_by()
             )
         ).distinct()
 
     def _get_config_context_filters(self):
         """
         This method is constructing the set of Q objects for the specific object types.
-        Note that locations filters are not included in the method because the filter needs the
-        ability to query the ancestors for a particular tree node for subquery and we lost it since
-        moving from mptt to django-tree-queries https://github.com/matthiask/django-tree-queries/issues/54.
         """
         tag_query_filters = {
             "object_id": OuterRef(OuterRef("pk")),
@@ -163,81 +158,50 @@ class ConfigContextModelQuerySet(RestrictedQuerySet):
 
 
 class DynamicGroupQuerySet(RestrictedQuerySet):
-    """Queryset for `DynamicGroup` objects that provides a `get_for_object` method."""
+    """Queryset for `DynamicGroup` objects that provides `get_for_object` and `get_for_model` methods."""
+
+    def get_for_model(self, model):
+        """
+        Return all DynamicGroups assignable to the given model class.
+        """
+        concrete_model = model._meta.concrete_model
+        content_type = ContentType.objects.get_for_model(concrete_model)
+        return self.filter(content_type=content_type)
 
     def get_list_for_object(self, obj, use_cache=False):
         """
-        Return a list of `DynamicGroup` assigned to the given object. As opposed to `get_for_object`
-        which will return a queryset but that is an additional query to the DB when you may just
-        want a list.
+        Return a (cached) list of `DynamicGroup` objects assigned to the given object.
 
         Args:
             obj: The object to seek dynamic groups membership by.
-            use_cache: If True, use the cache and query the database directly.
+            use_cache: Obsolete; cache is always used. If truly necessary to get up-to-the-minute accuracy, you should
+                call `[dg.update_cached_members() for dg in DynamicGroup.objects.filter(content_type=...)]` beforehand,
+                but be aware that that's potentially quite expensive computationally.
         """
-        if not isinstance(obj, Model):
-            raise TypeError(f"{obj} is not an instance of Django Model class")
-
-        # Get dynamic groups for this content_type using the discrete content_type fields to
-        # optimize the query.
-        eligible_groups = self._get_eligible_dynamic_groups(obj, use_cache=use_cache)
-
-        # Filter down to matching groups.
-        my_groups = []
-        for dynamic_group in list(eligible_groups):
-            if dynamic_group.has_member(obj, use_cache=use_cache):
-                my_groups.append(dynamic_group)
-
-        return my_groups
+        return list(self.get_for_object(obj))
 
     def get_for_object(self, obj, use_cache=False):
         """
-        Return a queryset of `DynamicGroup` objects that are assigned to the given object.
+        Return a (cached) queryset of `DynamicGroup` objects that are assigned to the given object.
 
         Args:
             obj: The object to seek dynamic groups membership by.
-            use_cache: If True, use the cache and query the database directly.
+            use_cache: Obsolete; cache is always used. If truly necessary to get up-to-the-minute accuracy, you should
+                call `[dg.update_cached_members() for dg in DynamicGroup.objects.filter(content_type=...)]` beforehand,
+                but be aware that's potentially quite expensive computationally.
         """
-        return self.filter(pk__in=[dg.pk for dg in self.get_list_for_object(obj, use_cache=use_cache)])
+        if not isinstance(obj, Model):
+            raise TypeError(f"{obj} is not an instance of Django Model class")
+
+        return self.filter(
+            content_type__app_label=obj._meta.app_label,
+            content_type__model=obj._meta.model_name,
+            static_group_associations__associated_object_id=obj.id,
+        )
 
     def get_by_natural_key(self, slug):
         return self.get(slug=slug)
 
-    @classmethod
-    def _get_eligible_dynamic_groups_cache_key(cls, obj):
-        """
-        Return the cache key for the queryset of `DynamicGroup` objects that are eligible to potentially contain the
-        given object.
-        """
-        return f"nautobot.{obj._meta.label_lower}._get_eligible_dynamic_groups"
-
-    def _get_eligible_dynamic_groups(self, obj, use_cache=False):
-        """
-        Return a queryset of `DynamicGroup` objects that are eligible to potentially contain the given object.
-        """
-        cache_key = self.__class__._get_eligible_dynamic_groups_cache_key(obj)
-
-        def _query_eligible_dynamic_groups():
-            """
-            A callable to be used as the default value for the cache of which dynamic groups are
-            eligible for a given object.
-            """
-            # Save a DB query if we can by using the _content_type field on the model which is a cached instance of the ContentType
-            if use_cache and hasattr(type(obj), "_content_type"):
-                return self.filter(content_type_id=type(obj)._content_type.id)
-            return self.filter(
-                content_type__app_label=obj._meta.app_label, content_type__model=obj._meta.model_name
-            ).select_related("content_type")
-
-        if not use_cache:
-            eligible_dynamic_groups = _query_eligible_dynamic_groups()
-            cache.set(cache_key, eligible_dynamic_groups, get_settings_or_config("DYNAMIC_GROUPS_MEMBER_CACHE_TIMEOUT"))
-            return eligible_dynamic_groups
-
-        return cache.get_or_set(
-            cache_key, _query_eligible_dynamic_groups, get_settings_or_config("DYNAMIC_GROUPS_MEMBER_CACHE_TIMEOUT")
-        )
-
 
 class DynamicGroupMembershipQuerySet(RestrictedQuerySet):
     """Queryset for `DynamicGroupMembership` objects."""