nautobot 2.3.12__py3-none-any.whl → 2.3.13__py3-none-any.whl

nautobot/core/api/serializers.py

@@ -134,6 +134,7 @@ class BaseModelSerializer(OptInFieldsMixin, serializers.HyperlinkedModelSerializ
 
     serializer_related_field = NautobotHyperlinkedRelatedField
 
+    id = serializers.UUIDField(read_only=False, default=serializers.CreateOnlyDefault(uuid.uuid4))
     display = serializers.SerializerMethodField(read_only=True, help_text="Human friendly display value")
     object_type = ObjectTypeField()
     # composite_key = serializers.SerializerMethodField()  # TODO: Revisit if we reintroduce composite keys

nautobot/core/celery/log.py

@@ -11,6 +11,10 @@ class NautobotDatabaseHandler(logging.Handler):
         if current_task is None:
             return
 
+        # Skip recording the log entry if it has been marked as such
+        if getattr(record, "skip_db_logging", False):
+            return
+
         from nautobot.extras.models.jobs import JobResult
 
         try:
@@ -24,10 +28,6 @@ class NautobotDatabaseHandler(logging.Handler):
                 # JobResult.DoesNotExist - because we might not have a JobResult with that ID
                 return
 
-            # Skip recording the log entry if it has been marked as such
-            if getattr(record, "skip_db_logging", False):
-                return
-
             job_result.log(
                 message=record.message,
                 level_choice=record.levelname.lower(),

nautobot/core/models/tree_queries.py

@@ -111,8 +111,11 @@ class TreeModel(TreeNode):
         if display_str:
             return display_str
         try:
-            if self.parent is not None:
-                display_str = self.parent.display + " → "
+            if self.parent_id is not None:
+                parent_display_str = cache.get(cache_key.replace(str(self.id), str(self.parent_id)), "")
+                if not parent_display_str:
+                    parent_display_str = self.parent.display
+                display_str = parent_display_str + " → "
         except self.DoesNotExist:
             # Expected to occur at times during bulk-delete operations
             pass

nautobot/core/settings.py

@@ -225,7 +225,7 @@ if SSO_ENABLE_GROUP_SYNC:
         "social_core.pipeline.social_auth.associate_user",
         "social_core.pipeline.social_auth.load_extra_data",
         "social_core.pipeline.user.user_details",
-        "nautobot.extras.group_sync",
+        "nautobot.extras.group_sync.group_sync",
     )
 # OAuth2/OIDC claim where the list of groups the authenticating user is a part of
 SSO_CLAIMS_GROUP = os.getenv("NAUTOBOT_SSO_CLAIMS_GROUP", "groups")

nautobot/core/tables.py

@@ -14,7 +14,8 @@ from django.utils.http import urlencode
 from django.utils.safestring import mark_safe
 from django.utils.text import Truncator
 import django_tables2
-from django_tables2.data import TableQuerysetData
+from django_tables2.data import TableData, TableQuerysetData
+from django_tables2.rows import BoundRows
 from django_tables2.utils import Accessor, OrderBy, OrderByTuple
 from tree_queries.models import TreeNode
 
@@ -46,8 +47,24 @@ class BaseTable(django_tables2.Table):
         user=None,
         hide_hierarchy_ui=False,
         order_by=None,
+        data_transform_callback=None,
         **kwargs,
     ):
+        """
+        Instantiate a BaseTable.
+
+        Args:
+            *args (list, optional): Passed through to django_tables2.Table
+            table_changes_pending (bool): TODO
+            saved_view (SavedView, optional): TODO
+            user (User, optional): TODO
+            hide_hierarchy_ui (bool): Whether to display or hide hierarchy indentation of nested objects.
+            order_by (list, optional): Field(s) to sort by
+            data_transform_callback (function, optional): A function that takes the given `data` as an input and
+                returns new data. Runs after all of the queryset auto-optimization performed by this class.
+                Used for example in IPAM views to inject "fake" records for "available" Prefixes, IPAddresses, or VLANs.
+            **kwargs (dict, optional): Passed through to django_tables2.Table
+        """
         # Add custom field columns
         model = self._meta.model
 
@@ -89,6 +106,14 @@ class BaseTable(django_tables2.Table):
         # Init table
         super().__init__(*args, order_by=order_by, **kwargs)
 
+        if not isinstance(self.data, TableQuerysetData):
+            # LinkedCountColumns don't work properly if the data is a list of dicts instead of a queryset,
+            # as they rely on a `queryset.annotate()` call to gather the data.
+            self.exclude = [
+                *self.exclude,
+                *[column.name for column in self.columns if isinstance(column.column, LinkedCountColumn)],
+            ]
+
         # Don't show hierarchy if we're sorted
         if order_by is not None and hide_hierarchy_ui is None:
             hide_hierarchy_ui = True
@@ -122,7 +147,7 @@ class BaseTable(django_tables2.Table):
                 columns = user.get_config(f"tables.{self.__class__.__name__}.columns")
         if columns:
             for name, column in self.base_columns.items():
-                if name in columns:
+                if name in columns and name not in self.exclude:
                     self.columns.show(name)
                 else:
                     self.columns.hide(name)
@@ -161,7 +186,8 @@ class BaseTable(django_tables2.Table):
                         logger.error("Couldn't find model for %s", column.column.viewname)
                         continue
                     reverse_lookup = column.column.reverse_lookup or next(iter(column.column.url_params.keys()))
-                    count_fields.append((column.name, column_model, reverse_lookup))
+                    distinct = column.column.distinct
+                    count_fields.append((column.name, column_model, reverse_lookup, distinct))
                     try:
                         lookup = column.column.lookup or get_related_field_for_models(model, column_model).name
                         # For some reason get_related_field_for_models(Tag, DynamicGroup) gives a M2M with the name
@@ -173,7 +199,8 @@ class BaseTable(django_tables2.Table):
                     if lookup is not None:
                         # Also attempt to prefetch the first matching record for display - see LinkedCountColumn
                         prefetch_fields.append(
-                            Prefetch(lookup, column_model.objects.all()[:1], to_attr=f"{lookup}_list")
+                            # Use order_by() because we don't care about ordering here and it's potentially expensive
+                            Prefetch(lookup, column_model.objects.order_by()[:1], to_attr=f"{lookup}_list")
                         )
                     continue
 
@@ -256,24 +283,34 @@ class BaseTable(django_tables2.Table):
                         )
 
             if count_fields:
-                for column_name, column_model, lookup_name in count_fields:
+                for column_name, column_model, lookup_name, distinct in count_fields:
                     if hasattr(queryset.first(), column_name):
                         continue
                     try:
                         logger.debug(
-                            "Applying .annotate(%s=count_related(%s, %r) to %s QuerySet",
+                            "Applying .annotate(%s=count_related(%s, %r, distinct=%s) to %s QuerySet",
                             column_name,
                             column_model.__name__,
                             lookup_name,
+                            distinct,
                             model.__name__,
                         )
-                        queryset = queryset.annotate(**{column_name: count_related(column_model, lookup_name)})
+                        queryset = queryset.annotate(
+                            **{column_name: count_related(column_model, lookup_name, distinct=distinct)}
+                        )
                     except FieldError:
                         # No error message logged here as the above is *very much* best-effort
                         pass
 
             self.data.data = queryset
 
+        # TODO: it would be better if we could apply this transformation and the above queryset optimizations
+        #       **before** calling super().__init__(), but the current implementation works for now, though inelegant.
+        if data_transform_callback is not None:
+            self.data = TableData.from_data(data_transform_callback(self.data.data))
+            self.data.set_table(self)
+            self.rows = BoundRows(data=self.data, table=self, pinned_data=self.pinned_data)
+
     @property
     def configurable_columns(self):
         selected_columns = [
@@ -288,7 +325,7 @@ class BaseTable(django_tables2.Table):
 
     @property
     def visible_columns(self):
-        return [name for name in self.sequence if self.columns[name].visible]
+        return [name for name in self.sequence if self.columns[name].visible and name not in self.exclude]
 
     @property
     def order_by(self):
@@ -490,6 +527,7 @@ class LinkedCountColumn(django_tables2.Column):
             TODO: this currently does *not* support nested lookups via `__`. That may be solvable in the future.
         reverse_lookup (str, optional): The reverse lookup parameter to use to derive the count.
             If not specified, the first key in `url_params` will be implicitly used as the `reverse_lookup` value.
+        distinct (bool, optional): Parameter passed through to `count_related()`.
         **kwargs (dict, optional): As the parent Column class.
 
     Examples:
@@ -514,21 +552,33 @@ class LinkedCountColumn(django_tables2.Column):
                 # We'd like to do the below but this module isn't currently smart enough to build the right Prefetch()
                 # for a nested lookup:
                 # lookup="circuit_terminations__circuit",
-                # For the count, .annotate(circuit_count=count_related(Circuit, "circuit_terminations__cloud_network"))
+                # For the count,
+                # .annotate(circuit_count=count_related(Circuit, "circuit_terminations__cloud_network", distinct=True))
                 reverse_lookup="circuit_terminations__cloud_network",
+                distinct=True,
                 verbose_name="Circuits",
             )
         ```
     """
 
     def __init__(
-        self, viewname, *args, view_kwargs=None, url_params=None, lookup=None, reverse_lookup=None, default=0, **kwargs
+        self,
+        viewname,
+        *args,
+        view_kwargs=None,
+        url_params=None,
+        lookup=None,
+        reverse_lookup=None,
+        distinct=False,
+        default=None,
+        **kwargs,
     ):
         self.viewname = viewname
         self.lookup = lookup
         self.view_kwargs = view_kwargs or {}
         self.url_params = url_params
         self.reverse_lookup = reverse_lookup or next(iter(url_params.keys()))
+        self.distinct = distinct
         self.model = get_model_for_view_name(self.viewname)
         super().__init__(*args, default=default, **kwargs)
 

nautobot/core/templatetags/helpers.py

@@ -795,7 +795,13 @@ def saved_view_modal(
         "clear_view",
     ]
 
-    table_name = lookup.get_table_for_model(model).__name__
+    view_class = lookup.get_view_for_model(model, "List")
+    table_name = None
+    if hasattr(view_class, "table"):
+        table_name = view_class.table.__name__
+    if hasattr(view_class, "table_class"):
+        table_name = view_class.table_class.__name__
+
     for param in non_filter_params:
         if param == "saved_view":
             current_saved_view_pk = filters_applied.pop(param, None)

nautobot/core/testing/api.py

@@ -707,7 +707,11 @@ class APIViewTestCases:
             self.assertHttpStatus(response, status.HTTP_201_CREATED, csv_data)
             # Note that create via CSV is always treated as a bulk-create, and so the response is always a list of dicts
             new_instance = self._get_queryset().get(pk=response.data[0]["id"])
-            self.assertNotEqual(new_instance.pk, orig_pk)
+            if isinstance(orig_pk, int):
+                self.assertNotEqual(new_instance.pk, orig_pk)
+            else:
+                # for our non-integer PKs, we're expecting the creation to respect the requested PK
+                self.assertEqual(new_instance.pk, orig_pk)
 
             new_serializer = serializer_class(new_instance, context={"request": None})
             new_data = new_serializer.data

nautobot/core/tests/test_api.py

@@ -3,6 +3,7 @@ from io import BytesIO, StringIO
 import json
 import os
 from unittest import skip
+import uuid
 
 from constance import config
 from constance.test import override_config
@@ -754,6 +755,25 @@ class WritableNestedSerializerTest(testing.APITestCase):
         self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
         self.assertEqual(ipam_models.VLAN.objects.filter(name="Test VLAN 100").count(), 0)
 
+    def test_create_with_specified_id(self):
+        data = {
+            "id": str(uuid.uuid4()),
+            "vid": 400,
+            "name": "Test VLAN 400",
+            "status": self.statuses.first().pk,
+            "vlan_group": self.vlan_group1.pk,
+        }
+        url = reverse("ipam-api:vlan-list")
+        self.add_permissions("ipam.add_vlan")
+
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(str(response.data["vlan_group"]["url"]), self.absolute_api_url(self.vlan_group1))
+        self.assertEqual(str(response.data["id"]), data["id"])
+        vlan = ipam_models.VLAN.objects.get(pk=response.data["id"])
+        self.assertEqual(vlan.status, self.statuses.first())
+        self.assertEqual(vlan.vlan_group, self.vlan_group1)
+
 
 class APIOrderingTestCase(testing.APITestCase):
     """

nautobot/core/tests/test_csv.py

@@ -1,3 +1,6 @@
+import csv
+import io
+
 from django.contrib.contenttypes.models import ContentType
 from django.test import override_settings, RequestFactory, TestCase
 from django.urls import reverse
@@ -261,9 +264,28 @@ class CSVParsingRelatedTestCase(TestCase):
         self.assertEqual(response.status_code, 200)
         response_data = response.content.decode(response.charset)
 
-        # Replace Device Name
-        import_data = response_data.replace("TestDevice1", "TestDevice3").replace("TestDevice2", "")
-        data = {"csv_data": import_data}
+        # parse the csv data
+        csv_reader = csv.DictReader(response_data.splitlines())
+        # remove the 'id' column so that all the items are imported new
+        fieldnames = [field for field in csv_reader.fieldnames if field != "id"]
+        # read all entries into a list
+        response_csv = list(csv_reader)
+
+        # mutate our data for testing purposes
+        for row in response_csv:
+            if row["name"] == "TestDevice1":
+                row["name"] = "TestDevice3"
+            elif row["name"] == "TestDevice2":
+                row["name"] = ""
+
+        # prep our data to write out
+        with io.StringIO() as import_csv:
+            writer = csv.DictWriter(import_csv, fieldnames=fieldnames)
+            writer.writeheader()
+            for row in response_csv:
+                filtered_row = {key: row[key] for key in fieldnames}
+                writer.writerow(filtered_row)
+            data = {"csv_data": import_csv.getvalue()}
         url = reverse("dcim:device_import")
         response = self.client.post(url, data)
         self.assertEqual(response.status_code, 200)

nautobot/core/tests/test_utils.py

@@ -268,6 +268,14 @@ class GetFooForModelTest(TestCase):
                 lookup.get_model_for_view_name("unknown:plugins:example_app:examplemodel_list")
             self.assertEqual(str(err.exception), "Unexpected View Name: unknown:plugins:example_app:examplemodel_list")
 
+    def test_get_table_class_string_from_view_name(self):
+        # Testing UIViewSet
+        self.assertEqual(lookup.get_table_class_string_from_view_name("circuits:circuit_list"), "CircuitTable")
+        # Testing Legacy View
+        self.assertEqual(lookup.get_table_class_string_from_view_name("dcim:location_list"), "LocationTable")
+        # Testing unconventional table name
+        self.assertEqual(lookup.get_table_class_string_from_view_name("ipam:prefix_list"), "PrefixDetailTable")
+
 
 class IsTaggableTest(TestCase):
     def test_is_taggable_true(self):

nautobot/core/utils/lookup.py

@@ -8,7 +8,7 @@ from django.conf import settings
 from django.contrib.auth.models import Group
 from django.contrib.contenttypes.models import ContentType
 from django.db.models import Model
-from django.urls import get_resolver, URLPattern, URLResolver
+from django.urls import get_resolver, resolve, reverse, URLPattern, URLResolver
 from django.utils.module_loading import import_string
 
 
@@ -212,7 +212,7 @@ def get_related_field_for_models(from_model, to_model):
     return matching_field
 
 
-def get_table_for_model(model):
+def get_table_for_model(model, suffix=None):
     """Return the `Table` class associated with a given `model`.
 
     The `Table` class is expected to be in the `tables` module within the application
@@ -222,11 +222,12 @@ def get_table_for_model(model):
 
     Args:
         model (BaseModel): A model class
+        suffix (str): A replacement suffix for the table name (e.g. `DetailTable`, such as to retrieve `FooDetailTable`)
 
     Returns:
         (Union[Table, None]): Either the `Table` class or `None`
     """
-    return get_related_class_for_model(model, module_name="tables", object_suffix="Table")
+    return get_related_class_for_model(model, module_name="tables", object_suffix=suffix or "Table")
 
 
 def get_view_for_model(model, view_type=""):
@@ -275,11 +276,13 @@ def get_table_class_string_from_view_name(view_name):
     Returns:
         table_class_name (String): The name of the model table class or None e.g. LocationTable, CircuitTable
     """
-    model = get_model_for_view_name(view_name)
-    if model:
-        table_class = get_table_for_model(model)
-        if table_class:
-            return table_class.__name__
+
+    view_func = resolve(reverse(view_name)).func
+    view_class = getattr(view_func, "cls", getattr(view_func, "view_class", None))
+    if hasattr(view_class, "table_class"):
+        return view_class.table_class.__name__
+    if hasattr(view_class, "table"):
+        return view_class.table.__name__
     return None
 
 

nautobot/dcim/api/views.py

@@ -11,6 +11,7 @@ from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import extend_schema, OpenApiParameter
 from rest_framework.decorators import action
 from rest_framework.mixins import ListModelMixin
+from rest_framework.parsers import JSONParser, MultiPartParser
 from rest_framework.permissions import IsAuthenticated
 from rest_framework.response import Response
 from rest_framework.viewsets import GenericViewSet, ViewSet
@@ -18,6 +19,7 @@ from rest_framework.viewsets import GenericViewSet, ViewSet
 from nautobot.circuits.models import Circuit
 from nautobot.cloud.models import CloudAccount
 from nautobot.core.api.exceptions import ServiceUnavailable
+from nautobot.core.api.parsers import NautobotCSVParser
 from nautobot.core.api.utils import get_serializer_for_model
 from nautobot.core.api.views import ModelViewSet
 from nautobot.core.models.querysets import count_related
@@ -300,6 +302,7 @@ class DeviceTypeViewSet(NautobotModelViewSet):
     )
     serializer_class = serializers.DeviceTypeSerializer
     filterset_class = filters.DeviceTypeFilterSet
+    parser_classes = [JSONParser, NautobotCSVParser, MultiPartParser]
 
 
 #

nautobot/dcim/filters/__init__.py

@@ -903,6 +903,19 @@ class DeviceFilterSet(
         to_field_name="version",
         label="Software version (version or ID)",
     )
+    ip_addresses = MultiValueCharFilter(
+        method="filter_ip_addresses",
+        label="IP addresses (address or ID)",
+        distinct=True,
+    )
+    has_ip_addresses = RelatedMembershipBooleanFilter(field_name="interfaces__ip_addresses", label="Has IP addresses")
+
+    def filter_ip_addresses(self, queryset, name, value):
+        pk_values = set(item for item in value if is_uuid(item))
+        addresses = set(item for item in value if item not in pk_values)
+
+        ip_queryset = IPAddress.objects.filter_address_or_pk_in(addresses, pk_values)
+        return queryset.filter(interfaces__ip_addresses__in=ip_queryset).distinct()
 
     class Meta:
         model = Device
@@ -1130,6 +1143,19 @@ class InterfaceFilterSet(
         queryset=InterfaceRedundancyGroup.objects.all(),
         to_field_name="name",
     )
+    ip_addresses = MultiValueCharFilter(
+        method="filter_ip_addresses",
+        label="IP addresses (address or ID)",
+        distinct=True,
+    )
+    has_ip_addresses = RelatedMembershipBooleanFilter(field_name="ip_addresses", label="Has IP addresses")
+
+    def filter_ip_addresses(self, queryset, name, value):
+        pk_values = set(item for item in value if is_uuid(item))
+        addresses = set(item for item in value if item not in pk_values)
+
+        ip_queryset = IPAddress.objects.filter_address_or_pk_in(addresses, pk_values)
+        return queryset.filter(ip_addresses__in=ip_queryset).distinct()
 
     class Meta:
         model = Interface
@@ -1144,7 +1170,6 @@ class InterfaceFilterSet(
             "description",
             "label",
             "tags",
-            "interface_redundancy_groups",
         ]
 
     def generate_query_filter_device(self, value):

nautobot/dcim/forms.py

@@ -2123,6 +2123,8 @@ class DeviceBulkEditForm(
     rack_group = DynamicModelChoiceField(
         queryset=RackGroup.objects.all(), required=False, query_params={"location": "$location"}
     )
+    cluster = DynamicModelChoiceField(queryset=Cluster.objects.all(), required=False)
+    comments = CommentField(widget=SmallTextarea, label="Comments")
     tenant = DynamicModelChoiceField(queryset=Tenant.objects.all(), required=False)
     platform = DynamicModelChoiceField(queryset=Platform.objects.all(), required=False)
     serial = forms.CharField(max_length=CHARFIELD_MAX_LENGTH, required=False, label="Serial Number")
@@ -2146,6 +2148,8 @@ class DeviceBulkEditForm(
             "position",
             "face",
             "rack_group",
+            "cluster",
+            "comments",
             "secrets_group",
             "device_redundancy_group",
             "device_redundancy_group_priority",

nautobot/dcim/tests/test_filters.py

@@ -1701,6 +1701,7 @@ class DeviceTestCase(
         ("front_ports", "front_ports__id"),
         ("interfaces", "interfaces__id"),
         ("interfaces", "interfaces__name"),
+        ("ip_addresses", "interfaces__ip_addresses__id"),
         ("mac_address", "interfaces__mac_address"),
         ("manufacturer", "device_type__manufacturer__id"),
         ("manufacturer", "device_type__manufacturer__name"),
@@ -1874,6 +1875,14 @@ class DeviceTestCase(
                 Device.objects.filter(primary_ip4__isnull=True, primary_ip6__isnull=True),
             )
 
+    def test_ip_addresses(self):
+        addresses = list(IPAddress.objects.filter(interfaces__isnull=False)[:2])
+        params = {"ip_addresses": [addresses[0].address, addresses[1].id]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs,
+            self.queryset.filter(interfaces__ip_addresses__in=addresses).distinct(),
+        )
+
     def test_virtual_chassis_member(self):
         # TODO: Not a generic_filter_test because this is a boolean filter but not a RelatedMembershipBooleanFilter
         with self.subTest():
@@ -2168,6 +2177,7 @@ class InterfaceTestCase(PathEndpointModelTestMixin, ModularDeviceComponentTestMi
         ("child_interfaces", "child_interfaces__name"),
         ("description",),
         # ("device", "device__id"),  # TODO - InterfaceFilterSet overrides device as a MultiValueCharFilter on name only
+        ("ip_addresses", "ip_addresses__id"),
         ("label",),
         ("lag", "lag__id"),
         ("lag", "lag__name"),
@@ -2413,6 +2423,21 @@ class InterfaceTestCase(PathEndpointModelTestMixin, ModularDeviceComponentTestMi
             status=interface_statuses[3],
         )
 
+        ipaddr_status = Status.objects.get_for_model(IPAddress).first()
+        prefix_status = Status.objects.get_for_model(Prefix).first()
+        namespace = Namespace.objects.first()
+        Prefix.objects.create(prefix="192.0.2.0/24", namespace=namespace, status=prefix_status)
+        Prefix.objects.create(prefix="2600::/64", namespace=namespace, status=prefix_status)
+        ipaddresses = (
+            IPAddress.objects.create(address="192.0.2.1/24", namespace=namespace, status=ipaddr_status),
+            IPAddress.objects.create(address="192.0.2.2/24", namespace=namespace, status=ipaddr_status),
+            IPAddress.objects.create(address="2600::1/120", namespace=namespace, status=ipaddr_status),
+            IPAddress.objects.create(address="2600::0100/120", namespace=namespace, status=ipaddr_status),
+        )
+
+        cabled_interfaces[0].add_ip_addresses([ipaddresses[0], ipaddresses[2]])
+        cabled_interfaces[1].add_ip_addresses([ipaddresses[1], ipaddresses[3]])
+
     def test_enabled(self):
         # TODO: Not a generic_filter_test because this is a boolean filter but not a RelatedMembershipBooleanFilter
         with self.subTest():
@@ -2646,6 +2671,14 @@ class InterfaceTestCase(PathEndpointModelTestMixin, ModularDeviceComponentTestMi
         with self.subTest("device (pk) filter with an invalid uuid"):
             self.assertFalse(self.filterset({"device": [uuid.uuid4()]}, self.queryset).is_valid())
 
+    def test_ip_addresses(self):
+        addresses = list(IPAddress.objects.filter(interfaces__isnull=False)[:2])
+        params = {"ip_addresses": [addresses[0].address, addresses[1].id]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs,
+            self.queryset.filter(ip_addresses__in=addresses).distinct(),
+        )
+
     def test_kind(self):
         # TODO: Not a generic_filter_test because this is a single-value filter
         # 2.0 TODO: Support filtering for multiple values

nautobot/dcim/tests/test_views.py

@@ -130,6 +130,7 @@ from nautobot.ipam.choices import IPAddressTypeChoices
 from nautobot.ipam.models import IPAddress, Namespace, Prefix, VLAN, VLANGroup, VRF
 from nautobot.tenancy.models import Tenant
 from nautobot.users.models import ObjectPermission
+from nautobot.virtualization.models import Cluster, ClusterType
 
 # Use the proper swappable User model
 User = get_user_model()
@@ -2047,6 +2048,9 @@ class DeviceTestCase(ViewTestCases.PrimaryObjectViewTestCase):
 
         rack_group = RackGroup.objects.create(location=locations[0], name="Rack Group 1")
 
+        cluster_type = ClusterType.objects.create(name="Cluster Type 1")
+        cluster = Cluster.objects.create(name="Cluster 1", cluster_type=cluster_type)
+
         rack_status = Status.objects.get_for_model(Rack).first()
         racks = (
             Rack.objects.create(
@@ -2218,6 +2222,8 @@ class DeviceTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "status": statuses[2].pk,
             "location": locations[1].pk,
             "rack": racks[1].pk,
+            "cluster": cluster.pk,
+            "comments": "An older device",
             "position": None,
             "face": DeviceFaceChoices.FACE_FRONT,
             "secrets_group": secrets_groups[1].pk,

nautobot/extras/api/serializers.py

@@ -270,6 +270,7 @@ class ContactAssociationSerializer(NautobotModelSerializer):
 
 
 class ContentTypeSerializer(BaseModelSerializer):
+    id = serializers.IntegerField(read_only=True)
     url = serializers.HyperlinkedIdentityField(view_name="extras-api:contenttype-detail")
     display = serializers.SerializerMethodField()
 

nautobot/extras/api/views.py

@@ -17,6 +17,7 @@ from rest_framework.permissions import IsAuthenticated
 from rest_framework.response import Response
 
 from nautobot.core.api.authentication import TokenPermissions
+from nautobot.core.api.parsers import NautobotCSVParser
 from nautobot.core.api.utils import get_serializer_for_model
 from nautobot.core.api.views import (
     BulkDestroyModelMixin,
@@ -484,6 +485,7 @@ class ImageAttachmentViewSet(ModelViewSet):
     queryset = ImageAttachment.objects.all()
     serializer_class = serializers.ImageAttachmentSerializer
     filterset_class = filters.ImageAttachmentFilterSet
+    parser_classes = [JSONParser, NautobotCSVParser, MultiPartParser]
 
 
 #

nautobot/extras/forms/forms.py

@@ -1682,6 +1682,8 @@ class RoleBulkEditForm(NautobotBulkEditForm):
 
     pk = forms.ModelMultipleChoiceField(queryset=Role.objects.all(), widget=forms.MultipleHiddenInput)
     color = forms.CharField(max_length=6, required=False, widget=ColorSelect())
+    description = forms.CharField(max_length=CHARFIELD_MAX_LENGTH, required=False)
+    weight = forms.IntegerField(required=False)
     content_types = MultipleContentTypeField(
         queryset=RoleModelsQuery().as_queryset(), required=False, label="Content Type(s)"
     )

nautobot/extras/group_sync.py

@@ -8,15 +8,15 @@ from django.contrib.auth.models import Group
 logger = logging.getLogger(__name__)
 
 
-CLAIMS_GROUP_NAME = getattr(settings, "NAUTOBOT_SSO_CLAIMS_GROUP", "groups")
+CLAIMS_GROUP_NAME = getattr(settings, "SSO_CLAIMS_GROUP", "groups")
 """ Which claim to look at in the OAuth2/OIDC response
 
     For Okta you can look at `Okta -> Authorization Servers -> Claims`. And a reasonable
     default is "groups". For Azure a reasonable default is "roles".
 """
 
-SUPERUSER_GROUPS = getattr(settings, "NAUTOBOT_SSO_SUPERUSER_GROUPS", [])
-STAFF_GROUPS = getattr(settings, "NAUTOBOT_SSO_STAFF_GROUPS", [])
+SUPERUSER_GROUPS = getattr(settings, "SSO_SUPERUSER_GROUPS", [])
+STAFF_GROUPS = getattr(settings, "SSO_STAFF_GROUPS", [])
 
 
 def group_sync(uid, user=None, response=None, *args, **kwargs):