nautobot 2.3.16__py3-none-any.whl → 2.4.0__py3-none-any.whl

nautobot/circuits/views.py

@@ -2,9 +2,18 @@ from django.contrib import messages
 from django.db import transaction
 from django.db.models import Q
 from django.shortcuts import get_object_or_404, redirect, render
+from django.utils.html import format_html
 from django_tables2 import RequestConfig
 
 from nautobot.core.forms import ConfirmationForm
+from nautobot.core.templatetags.helpers import bettertitle, humanize_speed, placeholder
+from nautobot.core.ui.choices import SectionChoices
+from nautobot.core.ui.object_detail import (
+    ObjectDetailContent,
+    ObjectFieldsPanel,
+    ObjectsTablePanel,
+)
+from nautobot.core.ui.utils import render_component_template
 from nautobot.core.views import generic, mixins as view_mixins
 from nautobot.core.views.paginator import EnhancedPaginator, get_paginate_count
 from nautobot.core.views.viewsets import NautobotUIViewSet
@@ -94,27 +103,22 @@ class ProviderUIViewSet(NautobotUIViewSet):
     queryset = Provider.objects.all()
     serializer_class = serializers.ProviderSerializer
     table_class = tables.ProviderTable
-
-    def get_extra_context(self, request, instance):
-        context = super().get_extra_context(request, instance)
-        if self.action == "retrieve":
-            circuits = (
-                Circuit.objects.restrict(request.user, "view")
-                .filter(provider=instance)
-                .select_related("circuit_type", "tenant")
-                .prefetch_related("circuit_terminations__location")
-            )
-            circuits_table = tables.CircuitTable(circuits)
-            circuits_table.columns.hide("provider")
-
-            paginate = {
-                "paginator_class": EnhancedPaginator,
-                "per_page": get_paginate_count(request),
-            }
-            RequestConfig(request, paginate).configure(circuits_table)
-
-            context["circuits_table"] = circuits_table
-        return context
+    object_detail_content = ObjectDetailContent(
+        panels=(
+            ObjectFieldsPanel(
+                section=SectionChoices.LEFT_HALF,
+                weight=100,
+                fields="__all__",
+            ),
+            ObjectsTablePanel(
+                weight=200,
+                table_class=tables.CircuitTable,
+                table_filter="provider",
+                section=SectionChoices.FULL_WIDTH,
+                exclude_columns=["provider"],
+            ),
+        ),
+    )
 
 
 class CircuitUIViewSet(NautobotUIViewSet):
@@ -127,8 +131,121 @@ class CircuitUIViewSet(NautobotUIViewSet):
     queryset = Circuit.objects.all()
     serializer_class = serializers.CircuitSerializer
     table_class = tables.CircuitTable
-    # NOTE: This is how `NautobotUIViewSet` would define use_new_ui attr
-    # use_new_ui = ["list", "retrieve"]
+
+    class CircuitTerminationPanel(ObjectFieldsPanel):
+        def __init__(self, **kwargs):
+            super().__init__(
+                fields=(
+                    "location",  # TODO: render location hierarchy
+                    "cable",
+                    "provider_network",
+                    "cloud_network",
+                    "port_speed",
+                    "upstream_speed",
+                    "ip_addresses",
+                    "xconnect_id",
+                    "pp_info",
+                    "description",
+                ),
+                value_transforms={
+                    "port_speed": [humanize_speed, placeholder],
+                    "upstream_speed": [humanize_speed],
+                },
+                hide_if_unset=("location", "provider_network", "cloud_network", "upstream_speed"),
+                ignore_nonexistent_fields=True,  # ip_addresses may be undefined
+                header_extra_content_template_path="circuits/inc/circuit_termination_header_extra_content.html",
+                **kwargs,
+            )
+
+        def should_render(self, context):
+            return True
+
+        def get_extra_context(self, context):
+            return {"termination": context[self.context_object_key]}
+
+        def get_data(self, context):
+            """
+            Extend the panel data to include custom relationships on the termination.
+
+            This is done for feature parity with the existing UI, and is not a pattern we *generally* should emulate.
+            """
+            data = super().get_data(context)
+            termination = context["termination"]
+            if termination is not None:
+                for side, relationships in termination.get_relationships_with_related_objects(
+                    include_hidden=False
+                ).items():
+                    for relationship, value in relationships.items():
+                        key = (relationship, side)
+                        data[key] = value
+
+            return data
+
+        def render_key(self, key, value, context):
+            """
+            Extend the panel rendering to render custom relationship information.
+
+            This is done for feature parity with the existing UI, and is not a pattern we *generally* should emulate.
+            """
+            if isinstance(key, tuple):
+                # Copied from _ObjectRelationshipsPanel.render_key()
+                relationship, side = key
+                return format_html(
+                    '<span title="{} ({})">{}</span>',
+                    relationship.label,
+                    relationship.key,
+                    bettertitle(relationship.get_label(side)),
+                )
+            return super().render_key(key, value, context)
+
+        def render_value(self, key, value, context):
+            """
+            Add custom rendering of connected cables.
+
+            TODO: this might make sense to move into the base class to handle Cable objects in general?
+            """
+            if key == "cable":
+                if not context["termination"].location:
+                    return ""
+                return render_component_template("circuits/inc/circuit_termination_cable_fragment.html", context)
+            return super().render_value(key, value, context)
+
+        def queryset_list_url_filter(self, key, value, context):
+            """
+            Extend the panel rendering to render custom relationship information.
+
+            This is done for feature parity with the existing UI, and is not a pattern we *generally* should emulate.
+            """
+            if isinstance(key, tuple):
+                # Copied from _ObjectRelationshipsPanel.queryset_list_url_filter()
+                relationship, side = key
+                termination = context["termination"]
+                return f"cr_{relationship.key}__{side}={termination.pk}"
+            return super().queryset_list_url_filter(key, value, context)
+
+    object_detail_content = ObjectDetailContent(
+        panels=(
+            ObjectFieldsPanel(
+                section=SectionChoices.LEFT_HALF,
+                weight=100,
+                fields="__all__",
+                exclude_fields=["comments", "circuit_termination_a", "circuit_termination_z"],
+                value_transforms={"commit_rate": [humanize_speed, placeholder]},
+            ),
+            CircuitTerminationPanel(
+                label="Termination - A Side",
+                section=SectionChoices.RIGHT_HALF,
+                weight=100,
+                context_object_key="circuit_termination_a",
+            ),
+            CircuitTerminationPanel(
+                label="Termination - Z Side",
+                section=SectionChoices.RIGHT_HALF,
+                weight=200,
+                context_object_key="circuit_termination_z",
+            ),
+        ),
+    )
 
     def get_extra_context(self, request, instance):
         context = super().get_extra_context(request, instance)

nautobot/cloud/api/views.py

@@ -9,40 +9,36 @@ from . import serializers
 
 
 class CloudAccountViewSet(NautobotModelViewSet):
-    queryset = models.CloudAccount.objects.select_related("provider", "secrets_group")
+    queryset = models.CloudAccount.objects.all()
     serializer_class = serializers.CloudAccountSerializer
     filterset_class = filters.CloudAccountFilterSet
 
 
 class CloudResourceTypeViewSet(NautobotModelViewSet):
-    queryset = models.CloudResourceType.objects.select_related("provider")
+    queryset = models.CloudResourceType.objects.all()
     serializer_class = serializers.CloudResourceTypeSerializer
     filterset_class = filters.CloudResourceTypeFilterSet
 
 
 class CloudNetworkViewSet(NautobotModelViewSet):
-    queryset = models.CloudNetwork.objects.select_related(
-        "cloud_resource_type", "cloud_account", "parent"
-    ).prefetch_related("prefixes")
+    queryset = models.CloudNetwork.objects.all()
     serializer_class = serializers.CloudNetworkSerializer
     filterset_class = filters.CloudNetworkFilterSet
 
 
 class CloudNetworkPrefixAssignmentViewSet(NautobotModelViewSet):
-    queryset = models.CloudNetworkPrefixAssignment.objects.select_related("cloud_network", "prefix")
+    queryset = models.CloudNetworkPrefixAssignment.objects.all()
     serializer_class = serializers.CloudNetworkPrefixAssignmentSerializer
     filterset_class = filters.CloudNetworkPrefixAssignmentFilterSet
 
 
 class CloudServiceViewSet(NautobotModelViewSet):
-    queryset = models.CloudService.objects.select_related("cloud_account", "cloud_resource_type").prefetch_related(
-        "cloud_networks"
-    )
+    queryset = models.CloudService.objects.all()
     serializer_class = serializers.CloudServiceSerializer
     filterset_class = filters.CloudServiceFilterSet
 
 
 class CloudServiceNetworkAssignmentViewSet(NautobotModelViewSet):
-    queryset = models.CloudServiceNetworkAssignment.objects.select_related("cloud_network", "cloud_service")
+    queryset = models.CloudServiceNetworkAssignment.objects.all()
     serializer_class = serializers.CloudServiceNetworkAssignmentSerializer
     filterset_class = filters.CloudServiceNetworkAssignmentFilterSet

nautobot/cloud/factory.py

@@ -86,7 +86,10 @@ class CloudNetworkFactory(PrimaryModelFactory):
             if extracted:
                 self.prefixes.set(extracted)
             else:
-                self.prefixes.set(get_random_instances(Prefix))
+                # TODO Investigate https://github.com/nautobot/nautobot/actions/runs/11019738391/job/30603271529
+                # to uncomment the line below.
+                # self.prefixes.set(get_random_instances(Prefix))
+                self.prefixes.set(get_random_instances(model_or_queryset_or_lambda=Prefix, maximum=1))
 
 
 class CloudServiceFactory(PrimaryModelFactory):

nautobot/cloud/tests/test_filters.py

@@ -5,12 +5,13 @@ from nautobot.core.testing import FilterTestCases
 from nautobot.extras.models import SecretsGroup
 
 
-class CloudAccountTestCase(FilterTestCases.NameOnlyFilterTestCase):
+class CloudAccountTestCase(FilterTestCases.FilterTestCase):
     queryset = models.CloudAccount.objects.all()
     filterset = filters.CloudAccountFilterSet
     generic_filter_tests = [
         ("account_number",),
         ("description",),
+        ("name",),
         ("provider", "provider__id"),
         ("provider", "provider__name"),
         ("secrets_group", "secrets_group__id"),
@@ -31,7 +32,7 @@ class CloudAccountTestCase(FilterTestCases.NameOnlyFilterTestCase):
             cls.cloud_accounts[i].validated_save()
 
 
-class CloudResourceTypeTestCase(FilterTestCases.NameOnlyFilterTestCase):
+class CloudResourceTypeTestCase(FilterTestCases.FilterTestCase):
     queryset = models.CloudResourceType.objects.all()
     filterset = filters.CloudResourceTypeFilterSet
     generic_filter_tests = [
@@ -50,7 +51,7 @@ class CloudResourceTypeTestCase(FilterTestCases.NameOnlyFilterTestCase):
         )
 
 
-class CloudNetworkTestCase(FilterTestCases.NameOnlyFilterTestCase):
+class CloudNetworkTestCase(FilterTestCases.FilterTestCase):
     queryset = models.CloudNetwork.objects.all()
     filterset = filters.CloudNetworkFilterSet
     generic_filter_tests = [
@@ -110,7 +111,7 @@ class CloudServiceNetworkAssignmentTestCase(FilterTestCases.FilterTestCase):
     ]
 
 
-class CloudServiceTestCase(FilterTestCases.NameOnlyFilterTestCase):
+class CloudServiceTestCase(FilterTestCases.FilterTestCase):
     queryset = models.CloudService.objects.all()
     filterset = filters.CloudServiceFilterSet
     generic_filter_tests = [

nautobot/cloud/views.py

@@ -100,16 +100,6 @@ class CloudNetworkUIViewSet(NautobotUIViewSet):
 
         return context
 
-    def extra_post_save_action(self, obj, form):
-        if form.cleaned_data.get("add_prefixes", None):
-            obj.prefixes.add(*form.cleaned_data["add_prefixes"])
-        if form.cleaned_data.get("remove_prefixes", None):
-            obj.prefixes.remove(*form.cleaned_data["remove_prefixes"])
-        if form.cleaned_data.get("add_cloud_services", None):
-            obj.cloud_services.add(*form.cleaned_data["add_cloud_services"])
-        if form.cleaned_data.get("remove_cloud_services", None):
-            obj.cloud_services.remove(*form.cleaned_data["remove_cloud_services"])
-
 
 class CloudResourceTypeUIViewSet(NautobotUIViewSet):
     queryset = CloudResourceType.objects.all()
@@ -173,9 +163,3 @@ class CloudServiceUIViewSet(NautobotUIViewSet):
             )
 
         return context
-
-    def extra_post_save_action(self, obj, form):
-        if form.cleaned_data.get("add_cloud_networks", None):
-            obj.cloud_networks.add(*form.cleaned_data["add_cloud_networks"])
-        if form.cleaned_data.get("remove_cloud_networks", None):
-            obj.cloud_networks.remove(*form.cleaned_data["remove_cloud_networks"])

nautobot/core/api/constants.py

@@ -0,0 +1,11 @@
+# Query parameters that are *not* filterset filters
+NON_FILTER_QUERY_PARAMS = (
+    "api_version",  # used to select the Nautobot API version
+    "depth",  # nested levels of the serializers default to depth=0
+    "exclude_m2m",  # used to exclude many-to-many fields from the REST API
+    "format",  # "json" or "api", used in the interactive HTML REST API views
+    "include",  # used to include computed fields, relationships, config-contexts, etc. (excluded by default)
+    "limit",  # pagination
+    "offset",  # pagination
+    "sort",  # sorting of results
+)

nautobot/core/api/filter_backends.py

@@ -2,6 +2,8 @@ from django_filters.rest_framework.backends import DjangoFilterBackend
 from rest_framework.filters import OrderingFilter
 from tree_queries.models import TreeNode
 
+from nautobot.core.api.constants import NON_FILTER_QUERY_PARAMS
+
 
 class NautobotFilterBackend(DjangoFilterBackend):
     """Custom filtering backend for use with django-rest-framework and django-filters."""
@@ -17,15 +19,7 @@ class NautobotFilterBackend(DjangoFilterBackend):
         # The default 'data' is a reference to request.GET, which is immutable; copies of this data are mutable
         data = kwargs["data"].copy()
 
-        for non_filter_param in (
-            "api_version",  # used to select the Nautobot API version
-            "depth",  # nested levels of the serializers default to depth=0
-            "format",  # "json" or "api", used in the interactive HTML REST API views
-            "include",  # used to include computed fields, relationships, config-contexts, etc. (excluded by default)
-            "limit",  # pagination
-            "offset",  # pagination
-            "sort",  # sorting of results
-        ):
+        for non_filter_param in NON_FILTER_QUERY_PARAMS:
             data.pop(non_filter_param, None)
 
         kwargs["data"] = data

nautobot/core/api/metadata.py

@@ -1,202 +1,25 @@
-import contextlib
-from typing import Any, Dict, List
-
 from django.core.exceptions import PermissionDenied
 from django.http import Http404
-from django.urls import reverse
-from django.urls.exceptions import NoReverseMatch
-import django_filters
-import drf_react_template.schema_form_encoder as schema
-from rest_framework import exceptions, fields as drf_fields, serializers as drf_serializers
+from django.utils.encoding import force_str
+from rest_framework import exceptions
 from rest_framework.metadata import SimpleMetadata
 from rest_framework.request import clone_request
 
-from nautobot.core.utils.filtering import build_lookup_label, get_filter_field_label
-from nautobot.core.utils.lookup import get_route_for_model
-
-# FIXME(jathan): I hate this pattern that these fields are hard-coded here. But for the moment, this
-# works reliably.
-BOTTOM_FIELDS = ["computed_fields", "custom_fields", "relationships"]
-
-
-class NautobotProcessingMixin(schema.ProcessingMixin):
-    """Processing mixin to account for custom field types and behaviors for Nautobot."""
-
-    def _get_type_map_value(self, field: schema.SerializerType):
-        """Overload default to add "required" as a default mapping."""
-        # This adds "required" as a default type mapping compared to drf_react_template core.
-        result = {
-            "type": field.style.get("schema:type"),
-            "enum": field.style.get("schema:enum"),
-            "format": field.style.get("schema:format"),
-            "widget": field.style.get("ui:widget"),
-            "required": field.style.get("schema:required"),
-            "readOnly": field.style.get("schema:readOnly"),
-        }
-        result_default = self.TYPE_MAP.get(type(field).__name__, {})
-        for k in result_default:
-            if result[k] is None:
-                result[k] = result_default[k]
-        return result
-
-    def order_fields(self, fields):
-        """Explicitly order the "big ugly" fields to the bottom."""
-        # FIXME(jathan): Correct the behavior introduced in #3500 by switching to `__all__` to
-        # assert these get added at the end.
-        for field_name in BOTTOM_FIELDS:
-            if field_name in fields:
-                fields.remove(field_name)
-                fields.append(field_name)
-        return fields
-
-
-class NautobotSchemaProcessor(NautobotProcessingMixin, schema.SchemaProcessor):
-    """SchemaProcessor to account for custom field types and behaviors for Nautobot."""
-
-    def _get_field_properties(self, field: schema.SerializerType, name: str) -> Dict[str, Any]:
-        """
-        This method is used to generate the proper schema based on serializer field mappings or
-        per-field attribute markup.
-
-        This has been overloaded with an `elif` to account for `ManyRelatedField`.
-        """
-        type_map_obj = self._get_type_map_value(field)
-        result = {
-            "type": type_map_obj["type"] or "string",
-            "title": self._get_title(field, name),
-        }
-
-        if isinstance(field, drf_serializers.ListField):
-            if field.allow_empty:
-                result["required"] = not getattr(field, "allow_empty", True)
-            result["items"] = self._get_field_properties(field.child, "")
-            result["uniqueItems"] = True
-        elif isinstance(field, drf_serializers.ManyRelatedField):
-            if field.allow_empty:
-                result["required"] = type_map_obj.get("required", [])
-            result["items"] = self._get_field_properties(field.child_relation, "")
-            result["uniqueItems"] = True
-        else:
-            if isinstance(field, drf_serializers.RelatedField):
-                result["uniqueItems"] = True
-                if hasattr(field, "queryset") and hasattr(field.queryset, "model"):
-                    # We construct the correct list view url here so we can just append the object id to the end of the url in our frontend.
-                    # e.g. /dcim/locations/
-                    try:
-                        model_url = reverse(get_route_for_model(model=field.queryset.model, action="list"))
-                    except NoReverseMatch:
-                        model_url = None
-                    model_options = field.queryset.model._meta
-                    result["required"] = field.required
-                    # Custom Keyword: modelName, modelNamePlural and appLabel
-                    # modelName represents the model name of the uuid model
-                    # modelUrl represents the UI URL to list instances of this model
-                    # and appLabel represents the app_name of the model
-                    result["modelName"] = model_options.model_name
-                    result["appLabel"] = model_options.app_label
-                    result["modelUrl"] = model_url
-            if field.allow_null:
-                result["type"] = [result["type"], "null"]
-            if enum := type_map_obj.get("enum"):
-                if enum == "choices":
-                    choices = field.choices
-                    result["enum"] = list(choices.keys())
-                    result["enumNames"] = list(choices.values())
-                if isinstance(enum, (list, tuple)):
-                    result["enum"] = [item[0] for item in enum]
-                    result["enumNames"] = [item[1] for item in enum]
-            if format_ := type_map_obj["format"]:
-                result["format"] = format_
-
-            if read_only := field.read_only:
-                result["readOnly"] = read_only
-
-            with contextlib.suppress(drf_fields.SkipField):
-                result["default"] = field.get_default()
-
-        result = self._set_validation_properties(field, result)
-
-        return result
-
-    @staticmethod
-    def _filter_fields(all_fields):
-        """
-        Override super._filter_fields to return all fields, including read-only fields,
-        as read-only fields have to be displayed in Detail View.
-        """
-        return tuple((name, field) for name, field in all_fields)
-
-
-class NautobotUiSchemaProcessor(NautobotProcessingMixin, schema.UiSchemaProcessor):
-    """UiSchemaProcessor to account for custom field types and behaviors for Nautobot."""
-
-    def _field_order(self) -> List[str]:
-        """
-        Overload the base which just returns `Meta.fields` and doesn't play nicely with "__all__".
-
-        This instead calls `get_fields()` and returns the keys.
-        """
-        if self._is_list_serializer(self.serializer):
-            fields = self.serializer.child.get_fields()
-        else:
-            fields = self.serializer.get_fields()
-
-        field_names = self.order_fields(list(fields))
-
-        return field_names
-
-    def _get_ui_field_properties(self, field: schema.SerializerType, name: str) -> Dict[str, Any]:
-        """
-        We had to overload this here to make it so that array types with children validate properly
-        and to also use `NautobotUiSchemaProcessor` over the default.
-        """
-        data_index = self._generate_data_index(name)
-        result = {}
-        is_int = False
-        is_list = False
-        if self._is_field_serializer(field):
-            return NautobotUiSchemaProcessor(field, self.renderer_context, prefix=data_index).get_ui_schema()
-        elif isinstance(field, drf_serializers.ListField):
-            is_list = True
-            child = field.child
-            is_int = isinstance(child, drf_serializers.IntegerField)
-            widget = self._get_type_map_value(field=child).get("widget")
-            if not widget and isinstance(child, drf_serializers.ChoiceField):
-                widget = "checkbox"
-        else:
-            widget = self._get_type_map_value(field=field).get("widget")
-        help_text = field.help_text
-        if widget:
-            if is_list and is_int:
-                if "items" not in result:
-                    result["items"] = {}
-                result["items"]["ui:widget"] = widget
-            else:
-                result["ui:widget"] = widget
-        if help_text:
-            result["ui:help"] = help_text
-        result.update(self._get_style_dict(field))
-        result = self._set_validation_properties(field, result)
-        return result
-
-
-class NautobotColumnProcessor(NautobotProcessingMixin, schema.ColumnProcessor):
-    """ColumnProcessor to account for custom field types and behaviors for Nautobot."""
+from nautobot.core.api import ContentTypeField
 
 
 class NautobotMetadata(SimpleMetadata):
     """
-    Metadata class that emits JSON schema. It contains `schema` and `uiSchema` keys where:
-
-    - schema: The object JSON schema
-    - uiSchema: The object UI schema which describes the form layout in the UI
+    Metadata class that emits JSON schema.
     """
 
     def determine_actions(self, request, view):
         """Generate the actions and return the names of the allowed methods."""
-        actions = []
+        actions = {}
         for method in {"PUT", "POST"} & set(view.allowed_methods):
             view.request = clone_request(request, method)
+            view.request.major_version = request.major_version
+            view.request.minor_version = request.minor_version
             try:
                 # Test global permissions
                 if hasattr(view, "check_permissions"):
@@ -207,82 +30,31 @@ class NautobotMetadata(SimpleMetadata):
             except (exceptions.APIException, PermissionDenied, Http404):
                 pass
             else:
-                actions.append(method)
+                # If user has appropriate permissions for the view, include
+                # appropriate metadata about the fields that should be supplied.
+                serializer = view.get_serializer()
+                actions[method] = self.get_serializer_info(serializer)
             finally:
                 view.request = request
         return actions
 
-    def get_list_display_fields(self, serializer):
-        """Try to get the list display fields or default to an empty list."""
-        serializer_meta = getattr(serializer, "Meta", None)
-        return list(getattr(serializer_meta, "list_display_fields", []))
-
-    def determine_metadata(self, request, view):
-        """This is the metadata that gets returned on an `OPTIONS` request."""
-        metadata = super().determine_metadata(request, view)
-
-        # Include the object type label for this model.
-        object_type = view.queryset.model._meta.label_lower if getattr(view, "queryset", None) else "unknown"
-        metadata["object_type"] = object_type
+    def get_field_info(self, field):
+        """
+        Fixup field information:
 
-        # If there's a serializer, do the needful to bind the schema/uiSchema.
-        if hasattr(view, "get_serializer"):
-            serializer = view.get_serializer()
-            # TODO(jathan): Bit of a WIP here. Will likely refactor. There might be cases where we
-            # want to explicitly override the UI field ordering, but that's not yet accounted for
-            # here. For now the assertion is always put the `list_display_fields` first, and then
-            # include the rest in whatever order.
-            # See: https://rjsf-team.github.io/react-jsonschema-form/docs/usage/objects#specifying-property-order
-            ui_schema = NautobotUiSchemaProcessor(serializer, request.parser_context).get_ui_schema()
-            ui_schema["ui:order"] = [*self.get_list_display_fields(serializer), "*"]
-            metadata.update(
+        - Set choices for ContentTypeField
+        - Replace DRF choices `display_name` to `display` to match new pattern.
+        """
+        field_info = super().get_field_info(field)
+        for choice in field_info.get("choices", []):
+            choice["display"] = choice.pop("display_name")
+        if hasattr(field, "queryset") and not field_info.get("read_only") and isinstance(field, ContentTypeField):
+            field_info["choices"] = [
                 {
-                    "schema": NautobotSchemaProcessor(serializer, request.parser_context).get_schema(),
-                    "uiSchema": ui_schema,
+                    "value": choice_value,
+                    "display": force_str(choice_name, strings_only=True),
                 }
-            )
-
-            metadata["filters"] = self.get_filter_info(view)
-
-            if hasattr(serializer, "determine_view_options"):
-                metadata["view_options"] = serializer.determine_view_options(request)
-
-        return metadata
-
-    def get_filter_info(self, view):
-        """Enumerate filterset information for the view. Returns a dictionary with the following format:
-
-        {
-            "filter_name": {
-                "label": "Filter Label",
-                "lookup_types": [
-                    {"value": "filter_name__n", "label": "not exact (n)"},
-                    {"value": "filter_name__re", "label": "matches regex (re)"},
-                    ...
-                ]
-            }
-        }
-
-        """
-
-        if not getattr(view, "filterset_class", None):
-            return {}
-        filterset = view.filterset_class
-        filters = {}
-        for filter_name, filter_instance in sorted(
-            filterset.base_filters.items(),
-            key=lambda x: get_filter_field_label(x[1]),
-        ):
-            filter_key = filter_name.rsplit("__", 1)[0]
-            label = get_filter_field_label(filter_instance)
-            lookup_label = self._filter_lookup_label(filter_name, filter_instance)
-            filters.setdefault(filter_key, {"label": label})
-            filters[filter_key].setdefault("lookup_types", []).append({"value": filter_name, "label": lookup_label})
-        return filters
-
-    # TODO: move this into `build_lookup_label` when the legacy UI is removed
-    def _filter_lookup_label(self, filter_name, filter_instance):
-        """Fix confusing lookup labels for boolean filters."""
-        if isinstance(filter_instance, django_filters.BooleanFilter):
-            return "exact"
-        return build_lookup_label(filter_name, filter_instance.lookup_expr)
+                for choice_value, choice_name in field.choices.items()
+            ]
+            field_info["choices"].sort(key=lambda item: item["display"])
+        return field_info