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

nautobot/dcim/tests/test_views.py

@@ -40,8 +40,8 @@ from nautobot.dcim.choices import (
 )
 from nautobot.dcim.filters import (
     ConsoleConnectionFilterSet,
-    ControllerDeviceGroupFilterSet,
     ControllerFilterSet,
+    ControllerManagedDeviceGroupFilterSet,
     InterfaceConnectionFilterSet,
     PowerConnectionFilterSet,
     SoftwareImageFileFilterSet,
@@ -55,7 +55,7 @@ from nautobot.dcim.models import (
     ConsoleServerPort,
     ConsoleServerPortTemplate,
     Controller,
-    ControllerDeviceGroup,
+    ControllerManagedDeviceGroup,
     Device,
     DeviceBay,
     DeviceBayTemplate,
@@ -136,6 +136,7 @@ def create_test_device(name):
 
 class LocationTypeTestCase(ViewTestCases.OrganizationalObjectViewTestCase):
     model = LocationType
+    sort_on_field = "nestable"
 
     @classmethod
     def setUpTestData(cls):
@@ -254,15 +255,20 @@ class LocationTestCase(ViewTestCases.PrimaryObjectViewTestCase):
 
 class RackGroupTestCase(ViewTestCases.OrganizationalObjectViewTestCase):
     model = RackGroup
+    sort_on_field = "name"
 
     @classmethod
     def setUpTestData(cls):
         location = Location.objects.filter(location_type=LocationType.objects.get(name="Campus")).first()
 
-        RackGroup.objects.create(name="Rack Group 1", location=location)
-        RackGroup.objects.create(name="Rack Group 2", location=location)
-        RackGroup.objects.create(name="Rack Group 3", location=location)
-        RackGroup.objects.create(name="Rack Group 8", location=location)
+        rack_groups = (
+            RackGroup.objects.create(name="Rack Group 1", location=location),
+            RackGroup.objects.create(name="Rack Group 2", location=location),
+            RackGroup.objects.create(name="Rack Group 3", location=location),
+            RackGroup.objects.create(name="Rack Group 8", location=location),
+        )
+        RackGroup.objects.create(name="Rack Group Child 1", location=location, parent=rack_groups[0])
+        RackGroup.objects.create(name="Rack Group Child 2", location=location, parent=rack_groups[0])
 
         cls.form_data = {
             "name": "Rack Group X",
@@ -567,6 +573,7 @@ class ManufacturerTestCase(ViewTestCases.OrganizationalObjectViewTestCase):
         # FIXME(jathan): This has to be replaced with# `get_deletable_object` and
         # `get_deletable_object_pks` but this is a workaround just so all of these objects are
         # deletable for now.
+        Controller.objects.filter(controller_device__isnull=False).delete()
         Device.objects.all().delete()
         DeviceType.objects.all().delete()
         Platform.objects.all().delete()
@@ -593,6 +600,7 @@ class DeviceTypeTestCase(
 
     @classmethod
     def setUpTestData(cls):
+        Controller.objects.filter(controller_device__isnull=False).delete()
         Device.objects.all().delete()
         manufacturers = Manufacturer.objects.all()[:2]
 
@@ -1278,6 +1286,7 @@ class DeviceTestCase(ViewTestCases.PrimaryObjectViewTestCase):
 
     @classmethod
     def setUpTestData(cls):
+        Controller.objects.filter(controller_device__isnull=False).delete()
         Device.objects.all().delete()
         locations = Location.objects.filter(location_type=LocationType.objects.get(name="Campus"))[:2]
 
@@ -1445,7 +1454,7 @@ class DeviceTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "face": DeviceFaceChoices.FACE_FRONT,
             "secrets_group": secrets_groups[1].pk,
             "software_version": software_versions[1].pk,
-            "controller_device_group": ControllerDeviceGroup.objects.first().pk,
+            "controller_managed_device_group": ControllerManagedDeviceGroup.objects.first().pk,
         }
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
@@ -2227,6 +2236,9 @@ class InventoryItemTestCase(ViewTestCases.DeviceComponentViewTestCase):
             "software_version": software_versions[2].pk,
         }
 
+    def test_table_with_indentation_is_removed_on_filter_or_sort(self):
+        self.skipTest("InventoryItem table has no implementation of indentation.")
+
 
 # TODO: Change base class to PrimaryObjectViewTestCase
 # Blocked by lack of common creation view for cables (termination A must be initialized)
@@ -3119,7 +3131,7 @@ class ControllerTestCase(ViewTestCases.PrimaryObjectViewTestCase):
         tenant = Tenant.objects.first()
 
         cls.form_data = {
-            "deployed_controller_device": device.pk,
+            "controller_device": device.pk,
             "description": "Controller 1 description",
             "external_integration": external_integration.pk,
             "location": location.pk,
@@ -3140,16 +3152,16 @@ class ControllerTestCase(ViewTestCases.PrimaryObjectViewTestCase):
         }
 
 
-class ControllerDeviceGroupTestCase(ViewTestCases.PrimaryObjectViewTestCase):
-    model = ControllerDeviceGroup
-    filterset = ControllerDeviceGroupFilterSet
+class ControllerManagedDeviceGroupTestCase(ViewTestCases.PrimaryObjectViewTestCase):
+    model = ControllerManagedDeviceGroup
+    filterset = ControllerManagedDeviceGroupFilterSet
 
     @classmethod
     def setUpTestData(cls):
         controllers = Controller.objects.all()
 
         cls.form_data = {
-            "name": "Controller Device Group 10",
+            "name": "Managed Device Group 10",
             "controller": controllers[0].pk,
             "weight": 100,
             "devices": [item.pk for item in Device.objects.all()[:2]],

nautobot/dcim/urls.py

@@ -40,7 +40,7 @@ router.register("interface-redundancy-groups-associations", views.InterfaceRedun
 router.register("software-image-files", views.SoftwareImageFileUIViewSet)
 router.register("software-versions", views.SoftwareVersionUIViewSet)
 router.register("controllers", views.ControllerUIViewSet)
-router.register("controller-device-groups", views.ControllerDeviceGroupUIViewSet)
+router.register("controller-managed-device-groups", views.ControllerManagedDeviceGroupUIViewSet)
 
 urlpatterns = [
     # Location types

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

@@ -3,11 +3,13 @@ import uuid
 
 from django.contrib.auth import get_user_model
 from django.contrib.auth.models import AnonymousUser
+from django.db import transaction
 from django.test.client import RequestFactory
 
 from nautobot.extras.choices import ObjectChangeEventContextChoices
+from nautobot.extras.constants import CHANGELOG_MAX_CHANGE_CONTEXT_DETAIL
 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
 
 
@@ -25,9 +27,12 @@ class ChangeContext:
     :param change_id: Optional uuid object to uniquely identify the transaction. One will be generated if not supplied
     """
 
+    defer_object_changes = False  # advanced usage, for creating object changes in bulk
+
     def __init__(self, user=None, request=None, context=None, context_detail="", change_id=None):
         self.request = request
         self.user = user
+        self.reset_deferred_object_changes()
 
         if self.request is None and self.user is None:
             raise TypeError("Either user or request must be provided")
@@ -46,11 +51,52 @@ 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
+
+    def _object_change_batch(self, n):
+        # Return first n keys from the self.deferred_object_changes dict
+        keys = []
+        for i, k in enumerate(self.deferred_object_changes.keys()):
+            if i >= n:
+                return keys
+            keys.append(k)
+        return keys
+
+    def reset_deferred_object_changes(self):
+        self.deferred_object_changes = {}
+
+    def flush_deferred_object_changes(self, batch_size=1000):
+        if self.defer_object_changes:
+            self.create_object_changes(batch_size=batch_size)
+
+    def create_object_changes(self, batch_size=1000):
+        while self.deferred_object_changes:
+            create_object_changes = []
+            for key in self._object_change_batch(batch_size):
+                for entry in self.deferred_object_changes[key]:
+                    objectchange = entry["instance"].to_objectchange(entry["action"])
+                    objectchange.user = entry["user"]
+                    objectchange.request_id = self.change_id
+                    objectchange.change_context = self.context
+                    objectchange.change_context_detail = self.context_detail[:CHANGELOG_MAX_CHANGE_CONTEXT_DETAIL]
+                    create_object_changes.append(objectchange)
+                self.deferred_object_changes.pop(key, None)
+            ObjectChange.objects.bulk_create(create_object_changes, batch_size=batch_size)
 
 
 class JobChangeContext(ChangeContext):
@@ -152,3 +198,24 @@ def web_request_context(
         for object_change in ObjectChange.objects.filter(request_id=change_context.change_id).iterator():
             enqueue_job_hooks(object_change)
             enqueue_webhooks(object_change)
+
+
+@contextmanager
+def deferred_change_logging_for_bulk_operation():
+    """
+    Defers change logging until the end of the context manager to improve performance. For use with bulk edit views. This
+    context manager is wrapped in an atomic transaction.
+    """
+
+    change_context = change_context_state.get()
+    if change_context is None:
+        raise ValueError("Change logging must be enabled before using deferred_change_logging_for_bulk_operation")
+
+    with transaction.atomic():
+        try:
+            change_context.defer_object_changes = True
+            yield
+            change_context.flush_deferred_object_changes()
+        finally:
+            change_context.defer_object_changes = False
+            change_context.reset_deferred_object_changes()

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