nautobot 2.2.0b1__py3-none-any.whl → 2.2.1__py3-none-any.whl

nautobot/dcim/views.py

@@ -11,7 +11,7 @@ from django.forms import (
     ModelMultipleChoiceField,
     MultipleHiddenInput,
 )
-from django.shortcuts import get_object_or_404, redirect, render
+from django.shortcuts import get_object_or_404, HttpResponse, redirect, render
 from django.utils.functional import cached_property
 from django.utils.html import format_html
 from django.views.generic import View
@@ -48,7 +48,7 @@ from .models import (
     ConsoleServerPort,
     ConsoleServerPortTemplate,
     Controller,
-    ControllerDeviceGroup,
+    ControllerManagedDeviceGroup,
     Device,
     DeviceBay,
     DeviceBayTemplate,
@@ -1459,7 +1459,7 @@ class DeviceBulkEditView(generic.BulkEditView):
         "device_type__manufacturer",
         "secrets_group",
         "device_redundancy_group",
-        "controller_device_group",
+        "controller_managed_device_group",
     )
     filterset = filters.DeviceFilterSet
     table = tables.DeviceTable
@@ -2359,7 +2359,7 @@ class CableCreateView(generic.ObjectEditView):
             "rear-port": forms.ConnectCableToRearPortForm,
             "power-feed": forms.ConnectCableToPowerFeedForm,
             "circuit-termination": forms.ConnectCableToCircuitTerminationForm,
-        }[kwargs.get("termination_b_type")]
+        }.get(kwargs.get("termination_b_type"), None)
 
         return super().dispatch(request, *args, **kwargs)
 
@@ -2376,6 +2376,9 @@ class CableCreateView(generic.ObjectEditView):
         return obj
 
     def get(self, request, *args, **kwargs):
+        if self.model_form is None:
+            return HttpResponse(status_code=400)
+
         obj = self.alter_obj(self.get_object(kwargs), request, args, kwargs)
 
         # Parse initial data manually to avoid setting field values as lists
@@ -2975,6 +2978,12 @@ class DeviceFamilyUIViewSet(NautobotUIViewSet):
             RequestConfig(request, paginate).configure(device_type_table)
 
             context["device_type_table"] = device_type_table
+
+            total_devices = 0
+            for device_type in device_types:
+                total_devices += device_type.device_count
+            context["total_devices"] = total_devices
+
         return context
 
 
@@ -3021,12 +3030,13 @@ class ControllerUIViewSet(NautobotUIViewSet):
     queryset = Controller.objects.all()
     serializer_class = serializers.ControllerSerializer
     table_class = tables.ControllerTable
+    template_name = "dcim/controller_create.html"
 
     def get_extra_context(self, request, instance):
         context = super().get_extra_context(request, instance)
 
         if self.action == "retrieve" and instance:
-            devices = Device.objects.restrict(request.user).filter(controller_device_group__controller=instance)
+            devices = Device.objects.restrict(request.user).filter(controller_managed_device_group__controller=instance)
             devices_table = tables.DeviceTable(devices)
 
             paginate = {
@@ -3040,19 +3050,19 @@ class ControllerUIViewSet(NautobotUIViewSet):
         return context
 
 
-class ControllerDeviceGroupUIViewSet(NautobotUIViewSet):
-    filterset_class = filters.ControllerDeviceGroupFilterSet
-    filterset_form_class = forms.ControllerDeviceGroupFilterForm
-    form_class = forms.ControllerDeviceGroupForm
-    bulk_update_form_class = forms.ControllerDeviceGroupBulkEditForm
+class ControllerManagedDeviceGroupUIViewSet(NautobotUIViewSet):
+    filterset_class = filters.ControllerManagedDeviceGroupFilterSet
+    filterset_form_class = forms.ControllerManagedDeviceGroupFilterForm
+    form_class = forms.ControllerManagedDeviceGroupForm
+    bulk_update_form_class = forms.ControllerManagedDeviceGroupBulkEditForm
     queryset = (
-        ControllerDeviceGroup.objects.all()
+        ControllerManagedDeviceGroup.objects.all()
         .prefetch_related("devices")
-        .annotate(device_count=count_related(Device, "controller_device_group"))
+        .annotate(device_count=count_related(Device, "controller_managed_device_group"))
     )
-    serializer_class = serializers.ControllerDeviceGroupSerializer
-    table_class = tables.ControllerDeviceGroupTable
-    template_name = "dcim/controllerdevicegroup_create.html"
+    serializer_class = serializers.ControllerManagedDeviceGroupSerializer
+    table_class = tables.ControllerManagedDeviceGroupTable
+    template_name = "dcim/controllermanageddevicegroup_create.html"
 
     def get_extra_context(self, request, instance):
         context = super().get_extra_context(request, instance)

nautobot/extras/api/serializers.py

@@ -193,10 +193,18 @@ class ContactSerializer(NautobotModelSerializer):
     class Meta:
         model = Contact
         fields = "__all__"
+        # https://www.django-rest-framework.org/api-guide/validators/#optional-fields
+        validators = []
+        extra_kwargs = {
+            "email": {"default": ""},
+            "phone": {"default": ""},
+        }
 
     def validate(self, data):
         attrs = data.copy()
         attrs.pop("teams", None)
+        validator = UniqueTogetherValidator(queryset=Contact.objects.all(), fields=("name", "phone", "email"))
+        validator(attrs, self)
         super().validate(attrs)
         return data
 
@@ -946,7 +954,18 @@ class TeamSerializer(NautobotModelSerializer):
     class Meta:
         model = Team
         fields = "__all__"
-        extra_kwargs = {"contacts": {"required": False}}
+        extra_kwargs = {
+            "contacts": {"required": False},
+            "email": {"default": ""},
+            "phone": {"default": ""},
+        }
+        # https://www.django-rest-framework.org/api-guide/validators/#optional-fields
+        validators = []
+
+    def validate(self, data):
+        validator = UniqueTogetherValidator(queryset=Team.objects.all(), fields=("name", "phone", "email"))
+        validator(data, self)
+        return super().validate(data)
 
 
 #

nautobot/extras/api/urls.py

@@ -2,8 +2,7 @@ from nautobot.core.api.routers import OrderedDefaultRouter
 
 from . import views
 
-router = OrderedDefaultRouter()
-router.APIRootView = views.ExtrasRootView
+router = OrderedDefaultRouter(view_name="Extras")
 
 # Computed Fields
 router.register("computed-fields", views.ComputedFieldViewSet)

nautobot/extras/api/views.py

@@ -16,7 +16,6 @@ from rest_framework.exceptions import MethodNotAllowed, PermissionDenied, Valida
 from rest_framework.parsers import JSONParser, MultiPartParser
 from rest_framework.permissions import IsAuthenticated
 from rest_framework.response import Response
-from rest_framework.routers import APIRootView
 
 from nautobot.core.api.authentication import TokenPermissions
 from nautobot.core.api.utils import get_serializer_for_model
@@ -77,15 +76,6 @@ from nautobot.extras.utils import get_worker_count
 from . import serializers
 
 
-class ExtrasRootView(APIRootView):
-    """
-    Extras API root view
-    """
-
-    def get_view_name(self):
-        return "Extras"
-
-
 class NotesViewSetMixin:
     def restrict_queryset(self, request, *args, **kwargs):
         """

nautobot/extras/apps.py

@@ -12,6 +12,13 @@ logger = logging.getLogger(__name__)
 
 class ExtrasConfig(NautobotConfig):
     name = "nautobot.extras"
+    searchable_models = [
+        "contact",
+        "dynamicgroup",
+        "externalintegration",
+        "gitrepository",
+        "team",
+    ]
 
     def ready(self):
         super().ready()

nautobot/extras/context_managers.py

@@ -7,7 +7,7 @@ from django.test.client import RequestFactory
 
 from nautobot.extras.choices import ObjectChangeEventContextChoices
 from nautobot.extras.models import ObjectChange
-from nautobot.extras.signals import change_context_state
+from nautobot.extras.signals import change_context_state, get_user_if_authenticated
 from nautobot.extras.webhooks import enqueue_webhooks
 
 
@@ -46,11 +46,22 @@ class ChangeContext:
         if self.change_id is None:
             self.change_id = uuid.uuid4()
 
-    def get_user(self):
+    def get_user(self, instance=None):
         """Return self.user if set, otherwise return self.request.user"""
         if self.user is not None:
-            return self.user
-        return self.request.user
+            return get_user_if_authenticated(self.user, instance)
+        return get_user_if_authenticated(self.request.user, instance)
+
+    def as_dict(self, instance=None):
+        """
+        Return ChangeContext attributes in dictionary format
+        """
+        context = {
+            "user": self.get_user(instance),
+            "change_id": self.change_id,
+            "context": self.context,
+        }
+        return context
 
 
 class JobChangeContext(ChangeContext):

nautobot/extras/filters/__init__.py

@@ -1,7 +1,11 @@
+from difflib import get_close_matches
+
 from django.conf import settings
 from django.contrib.auth import get_user_model
 from django.contrib.contenttypes.models import ContentType
+from django.db.models import Q
 import django_filters
+from drf_spectacular.utils import extend_schema_field
 
 from nautobot.core.api.exceptions import SerializerNotFound
 from nautobot.core.api.utils import get_serializer_for_model
@@ -447,7 +451,54 @@ class NautobotFilterSet(
 #
 
 
-class ContactFilterSet(NameSearchFilterSet, NautobotFilterSet):
+class ContactTeamFilterSet(NameSearchFilterSet, NautobotFilterSet):
+    """Base filter set for Contacts and Teams."""
+
+    similar_to_location_data = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=Location.objects.all(),
+        label="Similar to location contact data",
+        method="_similar_to_location_data",
+    )
+
+    def generate_query__similar_to_location_data(self, queryset, locations):
+        """Helper method used by _similar_to_location_data() method."""
+        query_params = Q()
+        for location in locations:
+            contact_name = location.contact_name
+            contact_phone = location.contact_phone
+            contact_email = location.contact_email
+            if contact_name:
+                contact_names = list(queryset.order_by().values_list("name", flat=True).distinct())
+                name_matches = get_close_matches(contact_name, contact_names, cutoff=0.8)
+                if name_matches:
+                    query_params |= Q(name__in=name_matches)
+            if contact_phone:
+                contact_phones = list(queryset.order_by().values_list("phone", flat=True).distinct())
+                phone_matches = get_close_matches(contact_phone, contact_phones, cutoff=0.8)
+                if phone_matches:
+                    query_params |= Q(phone__in=phone_matches)
+            if contact_email:
+                contact_emails = list(queryset.order_by().values_list("email", flat=True).distinct())
+                # fuzzy matching for emails doesn't make sense, use case insensitive match here
+                email_matches = [e for e in contact_emails if e.casefold() == contact_email.casefold()]
+                if email_matches:
+                    query_params |= Q(email__in=email_matches)
+
+        return query_params
+
+    @extend_schema_field({"type": "string"})
+    def _similar_to_location_data(self, queryset, name, value):
+        """FilterSet method for getting Contacts or Teams that are similar to the explicit contact fields of a location"""
+        if value:
+            params = self.generate_query__similar_to_location_data(queryset, value)
+            if len(params) > 0:
+                return queryset.filter(params)
+            else:
+                return queryset.none()
+        return queryset
+
+
+class ContactFilterSet(ContactTeamFilterSet):
     class Meta:
         model = Contact
         fields = "__all__"
@@ -1109,7 +1160,7 @@ class TagFilterSet(NautobotFilterSet):
 #
 
 
-class TeamFilterSet(NameSearchFilterSet, NautobotFilterSet):
+class TeamFilterSet(ContactTeamFilterSet):
     class Meta:
         model = Team
         fields = "__all__"

nautobot/extras/filters/customfields.py

@@ -8,8 +8,9 @@ from nautobot.core.filters import (
     MultiValueNumberFilter,
 )
 from nautobot.core.forms import NullableDateField
-from nautobot.core.forms.widgets import StaticSelect2Multiple
+from nautobot.core.utils.data import is_uuid
 from nautobot.extras.choices import CustomFieldFilterLogicChoices, CustomFieldTypeChoices
+from nautobot.extras.models import CustomFieldChoice
 
 EXACT_FILTER_TYPES = (
     CustomFieldTypeChoices.TYPE_BOOLEAN,
@@ -71,19 +72,23 @@ class CustomFieldJSONFilter(CustomFieldFilterMixin, django_filters.Filter):
     """Custom field single value filter for backwards compatibility"""
 
 
-class CustomFieldMultiSelectFilter(CustomFieldFilterMixin, MultiValueCharFilter):
-    """This provides functionality for filtering custom fields with multiple  select type"""
+class CustomFieldSelectFilter(CustomFieldFilterMixin, MultiValueCharFilter):
+    """Filter for custom fields of type TYPE_SELECT."""
 
-    def __init__(self, *args, **kwargs):
-        kwargs.setdefault("lookup_expr", "contains")
-        super().__init__(*args, **kwargs)
+    def get_filter_predicate(self, v):
+        if is_uuid(v):
+            try:
+                v = self.custom_field.custom_field_choices.get(pk=v).value
+            except CustomFieldChoice.DoesNotExist:
+                v = ""
+        return super().get_filter_predicate(v)
 
 
-class CustomFieldMultiValueSelectFilter(CustomFieldFilterMixin, django_filters.MultipleChoiceFilter):
-    """This provides functionality for filtering custom fields with select type"""
+class CustomFieldMultiSelectFilter(CustomFieldSelectFilter):
+    """Filter for custom fields of type TYPE_MULTISELECT."""
 
     def __init__(self, *args, **kwargs):
-        self.field_class.widget = StaticSelect2Multiple
+        kwargs.setdefault("lookup_expr", "contains")
         super().__init__(*args, **kwargs)
 
 

nautobot/extras/filters/mixins.py

@@ -27,6 +27,7 @@ from nautobot.extras.filters.customfields import (
     CustomFieldMultiValueDateFilter,
     CustomFieldMultiValueNumberFilter,
     CustomFieldNumberFilter,
+    CustomFieldSelectFilter,
 )
 from nautobot.extras.models import (
     ConfigContextSchema,
@@ -61,12 +62,16 @@ class CustomFieldModelFilterSetMixin(django_filters.FilterSet):
         super().__init__(*args, **kwargs)
 
         custom_field_filter_classes = {
+            # Here, for the "base" filters for each custom field, for backwards compatibility, use single-value filters.
+            # For the "extended" filters, see below, we use multi-value filters.
+            # 3.0 TODO: switch the "base" filters to multi-value filters as well.
             CustomFieldTypeChoices.TYPE_DATE: CustomFieldDateFilter,
             CustomFieldTypeChoices.TYPE_BOOLEAN: CustomFieldBooleanFilter,
             CustomFieldTypeChoices.TYPE_INTEGER: CustomFieldNumberFilter,
             CustomFieldTypeChoices.TYPE_JSON: CustomFieldJSONFilter,
+            # The below are multi-value filters already:
             CustomFieldTypeChoices.TYPE_MULTISELECT: CustomFieldMultiSelectFilter,
-            CustomFieldTypeChoices.TYPE_SELECT: CustomFieldMultiSelectFilter,
+            CustomFieldTypeChoices.TYPE_SELECT: CustomFieldSelectFilter,
         }
 
         custom_fields = CustomField.objects.get_for_model(self._meta.model, exclude_filter_disabled=True)

nautobot/extras/forms/contacts.py

@@ -28,6 +28,13 @@ class ContactForm(NautobotModelForm):
             "tags",
         ]
 
+    def __init__(self, instance=None, initial=None, **kwargs):
+        if instance is not None:
+            if initial is None:
+                initial = {}
+            initial.setdefault("teams", instance.teams.all())
+        super().__init__(instance=instance, initial=initial, **kwargs)
+
     def save(self, *args, **kwargs):
         """
         Since `teams` field on Contact Model is the reverse side of an M2M,

nautobot/extras/health_checks.py

@@ -1,4 +1,5 @@
 """Nautobot custom health checks."""
+
 from typing import Optional
 from urllib.parse import urlparse
 

nautobot/extras/jobs.py

@@ -1,4 +1,5 @@
 """Jobs functionality - consolidates and replaces legacy "custom scripts" and "reports" features."""
+
 from collections import OrderedDict
 import functools
 import inspect

nautobot/extras/managers.py

@@ -1,6 +1,5 @@
 from celery import states
 from django.utils import timezone
-from django_celery_beat.managers import ExtendedManager
 from django_celery_results.managers import TaskResultManager, transaction_retry
 
 from nautobot.core.models import BaseManager
@@ -8,6 +7,20 @@ from nautobot.core.models.querysets import RestrictedQuerySet
 
 
 class JobResultManager(BaseManager.from_queryset(RestrictedQuerySet), TaskResultManager):
+    def get_task(self, task_id):
+        """Get result for task by ``task_id``.
+
+        This overloads `TaskResultManager.get_task` provided by `django-celery-results` to manage custom
+        behaviors for integration with Nautobot.
+        """
+        try:
+            return self.get(id=task_id)
+        except self.model.DoesNotExist:
+            if self._last_id == task_id:
+                self.warn_if_repeatable_read()
+            self._last_id = task_id
+            return self.model(id=task_id)
+
     @transaction_retry(max_retries=2)
     def store_result(
         self,
@@ -122,5 +135,5 @@ class JobResultManager(BaseManager.from_queryset(RestrictedQuerySet), TaskResult
         return obj
 
 
-class ScheduledJobsManager(BaseManager.from_queryset(RestrictedQuerySet), ExtendedManager):
+class ScheduledJobsManager(BaseManager.from_queryset(RestrictedQuerySet)):
     pass

nautobot/extras/models/contacts.py

@@ -19,6 +19,7 @@ class ContactTeamSharedBase(PrimaryModel):
     address = models.TextField(blank=True)
 
     comments = models.TextField(blank=True)
+    is_contact_associable_model = False
 
     class Meta:
         abstract = True

nautobot/extras/models/customfields.py

@@ -724,7 +724,16 @@ class CustomField(BaseModel, ChangeLoggedModel, NotesMixin):
 
         super().delete(*args, **kwargs)
 
-        delete_custom_field_data.delay(self.key, content_types)
+        # Circular Import
+        from nautobot.extras.signals import change_context_state
+
+        change_context = change_context_state.get()
+        if change_context is None:
+            context = None
+        else:
+            context = change_context.as_dict(instance=self)
+            context["context_detail"] = "delete custom field data"
+        delete_custom_field_data.delay(self.key, content_types, context)
 
     def add_prefix_to_cf_key(self):
         return "cf_" + str(self.key)
@@ -783,8 +792,22 @@ class CustomFieldChoice(BaseModel, ChangeLoggedModel):
         super().save(*args, **kwargs)
 
         if self.value != database_object.value:
+            # Circular Import
+            from nautobot.extras.signals import change_context_state
+
+            change_context = change_context_state.get()
+            if change_context is None:
+                context = None
+            else:
+                context = change_context.as_dict(instance=self)
+                context["context_detail"] = "update custom field choice data"
             transaction.on_commit(
-                lambda: update_custom_field_choice_data.delay(self.custom_field.pk, database_object.value, self.value)
+                lambda: update_custom_field_choice_data.delay(
+                    self.custom_field.pk,
+                    database_object.value,
+                    self.value,
+                    context,
+                )
             )
 
     def delete(self, *args, **kwargs):

nautobot/extras/models/datasources.py

@@ -1,4 +1,5 @@
 """Models for representing external data sources."""
+
 from importlib.util import find_spec
 import os
 

nautobot/extras/models/mixins.py

@@ -1,6 +1,7 @@
 """
 Class-modifying mixins that need to be standalone to avoid circular imports.
 """
+
 from django.urls import NoReverseMatch, reverse
 
 from nautobot.core.utils.lookup import get_route_for_model