nautobot 2.0.0a3__py3-none-any.whl → 2.0.0b1__py3-none-any.whl

nautobot/extras/api/serializers.py

@@ -3,32 +3,33 @@ import logging
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ObjectDoesNotExist
-from django.urls import NoReverseMatch
 from drf_spectacular.utils import extend_schema_field
 from rest_framework import serializers
-from rest_framework.reverse import reverse
 
 from nautobot.core.api import (
+    BaseModelSerializer,
     ChoiceField,
     ContentTypeField,
-    SerializedPKRelatedField,
+    CustomFieldModelSerializerMixin,
+    NautobotModelSerializer,
+    NotesSerializerMixin,
+    RelationshipModelSerializerMixin,
     ValidatedModelSerializer,
 )
 from nautobot.core.api.exceptions import SerializerNotFound
-from nautobot.core.api.mixins import LimitQuerysetChoicesSerializerMixin
-from nautobot.core.api.serializers import BaseModelSerializer, PolymorphicProxySerializer
-from nautobot.core.api.utils import get_serializer_for_model, get_serializers_for_models
+from nautobot.core.api.serializers import PolymorphicProxySerializer
+from nautobot.core.api.utils import (
+    get_nested_serializer_depth,
+    get_serializers_for_models,
+    return_nested_serializer_data_based_on_depth,
+)
 from nautobot.core.models.utils import get_all_concrete_models
-from nautobot.core.utils.deprecation import class_deprecated_in_favor_of
-from nautobot.core.utils.lookup import get_route_for_model
-from nautobot.dcim.api.nested_serializers import (
-    NestedDeviceSerializer,
-    NestedDeviceTypeSerializer,
-    NestedLocationSerializer,
-    NestedPlatformSerializer,
-    NestedRackSerializer,
+from nautobot.dcim.api.serializers import (
+    DeviceSerializer,
+    LocationSerializer,
+    RackSerializer,
 )
-from nautobot.dcim.models import DeviceType, Location, Platform
+from nautobot.extras import choices, models
 from nautobot.extras.choices import (
     CustomFieldFilterLogicChoices,
     CustomFieldTypeChoices,
@@ -36,6 +37,9 @@ from nautobot.extras.choices import (
     JobResultStatusChoices,
     ObjectChangeActionChoices,
 )
+from nautobot.extras.api.mixins import (
+    TaggedModelSerializerMixin,
+)
 from nautobot.extras.datasources import get_datasource_content_choices
 from nautobot.extras.models import (
     ComputedField,
@@ -70,54 +74,8 @@ from nautobot.extras.models import (
 )
 from nautobot.extras.models.mixins import NotesMixin
 from nautobot.extras.utils import ChangeLoggedModelsQuery, FeatureQuery, RoleModelsQuery, TaggableClassesQuery
-from nautobot.tenancy.api.nested_serializers import (
-    NestedTenantSerializer,
-    NestedTenantGroupSerializer,
-)
-from nautobot.tenancy.models import Tenant, TenantGroup
-from nautobot.users.api.nested_serializers import NestedUserSerializer
-from nautobot.virtualization.api.nested_serializers import (
-    NestedClusterGroupSerializer,
-    NestedClusterSerializer,
-)
-from nautobot.virtualization.models import Cluster, ClusterGroup
-
-from .customfields import CustomFieldModelSerializerMixin
-from .fields import MultipleChoiceJSONField, RoleSerializerField, StatusSerializerField
-from .relationships import RelationshipModelSerializerMixin
-
-# Not all of these variable(s) are not actually used anywhere in this file, but required for the
-# automagically replacing a Serializer with its corresponding NestedSerializer.
-from .nested_serializers import (  # noqa: F401
-    NestedComputedFieldSerializer,
-    NestedConfigContextSchemaSerializer,
-    NestedConfigContextSerializer,
-    NestedCustomFieldChoiceSerializer,
-    NestedCustomFieldSerializer,
-    NestedCustomLinkSerializer,
-    NestedDynamicGroupSerializer,
-    NestedDynamicGroupMembershipSerializer,
-    NestedExportTemplateSerializer,
-    NestedGitRepositorySerializer,
-    NestedGraphQLQuerySerializer,
-    NestedImageAttachmentSerializer,
-    NestedJobButtonSerializer,
-    NestedJobHookSerializer,
-    NestedJobSerializer,
-    NestedJobResultSerializer,
-    NestedNoteSerializer,
-    NestedRelationshipAssociationSerializer,
-    NestedRelationshipSerializer,
-    NestedRoleSerializer,
-    NestedScheduledJobSerializer,
-    NestedScheduledJobCreationSerializer,
-    NestedSecretSerializer,
-    NestedSecretsGroupSerializer,
-    NestedSecretsGroupAssociationSerializer,
-    NestedStatusSerializer,
-    NestedTagSerializer,
-    NestedWebhookSerializer,
-)
+
+from .fields import MultipleChoiceJSONField
 
 #
 # Mixins and Base Classes
@@ -126,130 +84,19 @@ from .nested_serializers import (  # noqa: F401
 logger = logging.getLogger(__name__)
 
 
-class NotesSerializerMixin(BaseModelSerializer):
-    """Extend Serializer with a `notes` field."""
-
-    notes_url = serializers.SerializerMethodField()
-
-    def get_field_names(self, declared_fields, info):
-        """Ensure that fields includes "notes_url" field if applicable."""
-        fields = list(super().get_field_names(declared_fields, info))
-        if hasattr(self.Meta.model, "notes"):
-            self.extend_field_names(fields, "notes_url")
-        return fields
-
-    @extend_schema_field(serializers.URLField())
-    def get_notes_url(self, instance):
-        try:
-            notes_url = get_route_for_model(instance, "notes", api=True)
-            return reverse(notes_url, args=[instance.id], request=self.context["request"])
-        except NoReverseMatch:
-            model_name = type(instance).__name__
-            logger.warning(
-                (
-                    f"Notes feature is not available for model {model_name}. "
-                    "Please make sure to: "
-                    f"1. Include NotesMixin from nautobot.extras.model.mixins in the {model_name} class definition "
-                    f"2. Include NotesViewSetMixin from nautobot.extras.api.mixins in the {model_name}ViewSet "
-                    "before including NotesSerializerMixin in the model serializer"
-                )
-            )
-
-            return None
-
-
-class NautobotModelSerializer(
-    RelationshipModelSerializerMixin, CustomFieldModelSerializerMixin, NotesSerializerMixin, ValidatedModelSerializer
-):
-    """Base class to use for serializers based on OrganizationalModel or PrimaryModel.
-
-    Can also be used for models derived from BaseModel, so long as they support custom fields and relationships.
-    """
-
-
-class StatusModelSerializerMixin(BaseModelSerializer):
-    """Mixin to add `status` choice field to model serializers."""
-
-    status = StatusSerializerField(required=True)
-
-    def get_field_names(self, declared_fields, info):
-        """Ensure that "status" field is always present."""
-        fields = list(super().get_field_names(declared_fields, info))
-        self.extend_field_names(fields, "status")
-        return fields
-
-
-class TagSerializerField(LimitQuerysetChoicesSerializerMixin, NestedTagSerializer):
-    """NestedSerializer field for `Tag` object fields."""
-
-
-class TaggedModelSerializerMixin(BaseModelSerializer):
-    tags = TagSerializerField(many=True, required=False)
-
-    def get_field_names(self, declared_fields, info):
-        """Ensure that 'tags' field is always present."""
-        fields = list(super().get_field_names(declared_fields, info))
-        self.extend_field_names(fields, "tags")
-        return fields
-
-    def create(self, validated_data):
-        tags = validated_data.pop("tags", None)
-        instance = super().create(validated_data)
-
-        if tags is not None:
-            return self._save_tags(instance, tags)
-        return instance
-
-    def update(self, instance, validated_data):
-        tags = validated_data.pop("tags", None)
-
-        # Cache tags on instance for change logging
-        instance._tags = tags or []
-
-        instance = super().update(instance, validated_data)
-
-        if tags is not None:
-            return self._save_tags(instance, tags)
-        return instance
-
-    def _save_tags(self, instance, tags):
-        if tags:
-            instance.tags.set([t.name for t in tags])
-        else:
-            instance.tags.clear()
-
-        return instance
-
-
-# TODO: remove in 2.2
-@class_deprecated_in_favor_of(TaggedModelSerializerMixin)
-class TaggedObjectSerializer(TaggedModelSerializerMixin):
-    pass
-
-
 #
 # Computed Fields
 #
 
 
 class ComputedFieldSerializer(ValidatedModelSerializer, NotesSerializerMixin):
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:computedfield-detail")
     content_type = ContentTypeField(
         queryset=ContentType.objects.filter(FeatureQuery("custom_fields").get_query()).order_by("app_label", "model"),
     )
 
     class Meta:
         model = ComputedField
-        fields = (
-            "url",
-            "slug",
-            "label",
-            "description",
-            "content_type",
-            "template",
-            "fallback_value",
-            "weight",
-        )
+        fields = "__all__"
 
 
 #
@@ -257,8 +104,7 @@ class ComputedFieldSerializer(ValidatedModelSerializer, NotesSerializerMixin):
 #
 
 
-class ConfigContextSerializer(ValidatedModelSerializer, NotesSerializerMixin):
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:configcontext-detail")
+class ConfigContextSerializer(ValidatedModelSerializer, TaggedModelSerializerMixin, NotesSerializerMixin):
     owner_content_type = ContentTypeField(
         queryset=ContentType.objects.filter(FeatureQuery("config_context_owners").get_query()),
         required=False,
@@ -266,63 +112,6 @@ class ConfigContextSerializer(ValidatedModelSerializer, NotesSerializerMixin):
         default=None,
     )
     owner = serializers.SerializerMethodField(read_only=True)
-    config_context_schema = NestedConfigContextSchemaSerializer(required=False, allow_null=True)
-    locations = SerializedPKRelatedField(
-        queryset=Location.objects.all(),
-        serializer=NestedLocationSerializer,
-        required=False,
-        many=True,
-    )
-    roles = SerializedPKRelatedField(
-        queryset=Role.objects.all(),
-        serializer=NestedRoleSerializer,
-        required=False,
-        many=True,
-    )
-    device_types = SerializedPKRelatedField(
-        queryset=DeviceType.objects.all(),
-        serializer=NestedDeviceTypeSerializer,
-        required=False,
-        many=True,
-    )
-    platforms = SerializedPKRelatedField(
-        queryset=Platform.objects.all(),
-        serializer=NestedPlatformSerializer,
-        required=False,
-        many=True,
-    )
-    cluster_groups = SerializedPKRelatedField(
-        queryset=ClusterGroup.objects.all(),
-        serializer=NestedClusterGroupSerializer,
-        required=False,
-        many=True,
-    )
-    clusters = SerializedPKRelatedField(
-        queryset=Cluster.objects.all(),
-        serializer=NestedClusterSerializer,
-        required=False,
-        many=True,
-    )
-    tenant_groups = SerializedPKRelatedField(
-        queryset=TenantGroup.objects.all(),
-        serializer=NestedTenantGroupSerializer,
-        required=False,
-        many=True,
-    )
-    tenants = SerializedPKRelatedField(
-        queryset=Tenant.objects.all(),
-        serializer=NestedTenantSerializer,
-        required=False,
-        many=True,
-    )
-    tags = serializers.SlugRelatedField(queryset=Tag.objects.all(), slug_field="slug", required=False, many=True)
-
-    dynamic_groups = SerializedPKRelatedField(
-        queryset=DynamicGroup.objects.all(),
-        serializer=NestedDynamicGroupSerializer,
-        required=False,
-        many=True,
-    )
 
     # Conditional enablement of dynamic groups filtering
     def __init__(self, *args, **kwargs):
@@ -333,45 +122,21 @@ class ConfigContextSerializer(ValidatedModelSerializer, NotesSerializerMixin):
 
     class Meta:
         model = ConfigContext
-        fields = [
-            "url",
-            "name",
-            "owner_content_type",
-            "owner_object_id",
-            "owner",
-            "weight",
-            "description",
-            "config_context_schema",
-            "is_active",
-            "locations",
-            "roles",
-            "device_types",
-            "platforms",
-            "cluster_groups",
-            "clusters",
-            "tenant_groups",
-            "tenants",
-            "tags",
-            "dynamic_groups",
-            "data",
-        ]
+        fields = "__all__"
 
     @extend_schema_field(
         PolymorphicProxySerializer(
             component_name="ConfigContextOwner",
             resource_type_field_name="object_type",
-            serializers=lambda: get_serializers_for_models(
-                FeatureQuery("config_context_owners").list_subclasses(), prefix="Nested"
-            ),
+            serializers=lambda: get_serializers_for_models(FeatureQuery("config_context_owners").list_subclasses()),
             allow_null=True,
         )
     )
     def get_owner(self, obj):
         if obj.owner is None:
             return None
-        serializer = get_serializer_for_model(obj.owner, prefix="Nested")
-        context = {"request": self.context["request"]}
-        return serializer(obj.owner, context=context).data
+        depth = get_nested_serializer_depth(self)
+        return return_nested_serializer_data_based_on_depth(self, depth, obj, obj.owner, "owner")
 
 
 #
@@ -380,7 +145,6 @@ class ConfigContextSerializer(ValidatedModelSerializer, NotesSerializerMixin):
 
 
 class ConfigContextSchemaSerializer(NautobotModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:configcontextschema-detail")
     owner_content_type = ContentTypeField(
         queryset=ContentType.objects.filter(FeatureQuery("config_context_owners").get_query()),
         required=False,
@@ -391,33 +155,21 @@ class ConfigContextSchemaSerializer(NautobotModelSerializer):
 
     class Meta:
         model = ConfigContextSchema
-        fields = [
-            "url",
-            "name",
-            "slug",
-            "owner_content_type",
-            "owner_object_id",
-            "owner",
-            "description",
-            "data_schema",
-        ]
+        fields = "__all__"
 
     @extend_schema_field(
         PolymorphicProxySerializer(
             component_name="ConfigContextSchemaOwner",
             resource_type_field_name="object_type",
-            serializers=lambda: get_serializers_for_models(
-                FeatureQuery("config_context_owners").list_subclasses(), prefix="Nested"
-            ),
+            serializers=lambda: get_serializers_for_models(FeatureQuery("config_context_owners").list_subclasses()),
             allow_null=True,
         )
     )
     def get_owner(self, obj):
         if obj.owner is None:
             return None
-        serializer = get_serializer_for_model(obj.owner, prefix="Nested")
-        context = {"request": self.context["request"]}
-        return serializer(obj.owner, context=context).data
+        depth = get_nested_serializer_depth(self)
+        return return_nested_serializer_data_based_on_depth(self, depth, obj, obj.owner, "owner")
 
 
 #
@@ -431,7 +183,7 @@ class ContentTypeSerializer(BaseModelSerializer):
 
     class Meta:
         model = ContentType
-        fields = ["url", "app_label", "model"]
+        fields = "__all__"
 
     @extend_schema_field(serializers.CharField)
     def get_display(self, obj):
@@ -444,7 +196,6 @@ class ContentTypeSerializer(BaseModelSerializer):
 
 
 class CustomFieldSerializer(ValidatedModelSerializer, NotesSerializerMixin):
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:customfield-detail")
     content_types = ContentTypeField(
         queryset=ContentType.objects.filter(FeatureQuery("custom_fields").get_query()),
         many=True,
@@ -455,30 +206,13 @@ class CustomFieldSerializer(ValidatedModelSerializer, NotesSerializerMixin):
 
     class Meta:
         model = CustomField
-        fields = [
-            "url",
-            "content_types",
-            "type",
-            "label",
-            "key",
-            "description",
-            "required",
-            "filter_logic",
-            "default",
-            "weight",
-            "validation_minimum",
-            "validation_maximum",
-            "validation_regex",
-        ]
+        fields = "__all__"
 
 
 class CustomFieldChoiceSerializer(ValidatedModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:customfieldchoice-detail")
-    custom_field = NestedCustomFieldSerializer()
-
     class Meta:
         model = CustomFieldChoice
-        fields = ["url", "custom_field", "value", "weight"]
+        fields = "__all__"
 
 
 #
@@ -487,24 +221,13 @@ class CustomFieldChoiceSerializer(ValidatedModelSerializer):
 
 
 class CustomLinkSerializer(ValidatedModelSerializer, NotesSerializerMixin):
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:customlink-detail")
     content_type = ContentTypeField(
         queryset=ContentType.objects.filter(FeatureQuery("custom_links").get_query()).order_by("app_label", "model"),
     )
 
     class Meta:
         model = CustomLink
-        fields = (
-            "url",
-            "target_url",
-            "name",
-            "content_type",
-            "text",
-            "weight",
-            "group_name",
-            "button_class",
-            "new_window",
-        )
+        fields = "__all__"
 
 
 #
@@ -512,36 +235,24 @@ class CustomLinkSerializer(ValidatedModelSerializer, NotesSerializerMixin):
 #
 
 
+class DynamicGroupMembershipSerializer(ValidatedModelSerializer):
+    class Meta:
+        model = DynamicGroupMembership
+        fields = "__all__"
+
+
 class DynamicGroupSerializer(NautobotModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:dynamicgroup-detail")
     content_type = ContentTypeField(
         queryset=ContentType.objects.filter(FeatureQuery("dynamic_groups").get_query()).order_by("app_label", "model"),
     )
-    # Read-only because m2m is hard. Easier to just create # `DynamicGroupMemberships` explicitly
-    # using their own endpoint at /api/extras/dynamic-group-memberships/.
-    children = NestedDynamicGroupMembershipSerializer(source="dynamic_group_memberships", read_only=True, many=True)
 
     class Meta:
         model = DynamicGroup
-        fields = [
-            "url",
-            "name",
-            "description",
-            "content_type",
-            "filter",
-            "children",
-        ]
-        extra_kwargs = {"filter": {"read_only": False}}
-
-
-class DynamicGroupMembershipSerializer(ValidatedModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:dynamicgroupmembership-detail")
-    group = NestedDynamicGroupSerializer()
-    parent_group = NestedDynamicGroupSerializer()
-
-    class Meta:
-        model = DynamicGroupMembership
-        fields = ["url", "group", "parent_group", "operator", "weight"]
+        fields = "__all__"
+        extra_kwargs = {
+            "children": {"source": "dynamic_group_memberships", "read_only": True},
+            "filter": {"read_only": False},
+        }
 
 
 #
@@ -551,7 +262,6 @@ class DynamicGroupMembershipSerializer(ValidatedModelSerializer):
 
 # TODO: export-templates don't support custom-fields, is this omission intentional?
 class ExportTemplateSerializer(RelationshipModelSerializerMixin, ValidatedModelSerializer, NotesSerializerMixin):
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:exporttemplate-detail")
     content_type = ContentTypeField(
         queryset=ContentType.objects.filter(FeatureQuery("export_templates").get_query()),
     )
@@ -565,35 +275,21 @@ class ExportTemplateSerializer(RelationshipModelSerializerMixin, ValidatedModelS
 
     class Meta:
         model = ExportTemplate
-        fields = [
-            "url",
-            "content_type",
-            "owner_content_type",
-            "owner_object_id",
-            "owner",
-            "name",
-            "description",
-            "template_code",
-            "mime_type",
-            "file_extension",
-        ]
+        fields = "__all__"
 
     @extend_schema_field(
         PolymorphicProxySerializer(
             component_name="ExportTemplateOwner",
             resource_type_field_name="object_type",
-            serializers=lambda: get_serializers_for_models(
-                FeatureQuery("export_template_owners").list_subclasses(), prefix="Nested"
-            ),
+            serializers=lambda: get_serializers_for_models(FeatureQuery("export_template_owners").list_subclasses()),
             allow_null=True,
         )
     )
     def get_owner(self, obj):
         if obj.owner is None:
             return None
-        serializer = get_serializer_for_model(obj.owner, prefix="Nested")
-        context = {"request": self.context["request"]}
-        return serializer(obj.owner, context=context).data
+        depth = get_nested_serializer_depth(self)
+        return return_nested_serializer_data_based_on_depth(self, depth, obj, obj.owner, "owner")
 
 
 #
@@ -604,10 +300,6 @@ class ExportTemplateSerializer(RelationshipModelSerializerMixin, ValidatedModelS
 class GitRepositorySerializer(NautobotModelSerializer):
     """Git repositories defined as a data source."""
 
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:gitrepository-detail")
-
-    secrets_group = NestedSecretsGroupSerializer(required=False, allow_null=True)
-
     provided_contents = MultipleChoiceJSONField(
         choices=lambda: get_datasource_content_choices("extras.gitrepository"),
         allow_blank=True,
@@ -616,23 +308,7 @@ class GitRepositorySerializer(NautobotModelSerializer):
 
     class Meta:
         model = GitRepository
-        fields = [
-            "url",
-            "name",
-            "slug",
-            "remote_url",
-            "branch",
-            "secrets_group",
-            "current_head",
-            "provided_contents",
-        ]
-
-    def validate(self, data):
-        """
-        Add the originating Request as a parameter to be passed when creating/updating a GitRepository.
-        """
-        data["request"] = self.context["request"]
-        return super().validate(data)
+        fields = "__all__"
 
 
 #
@@ -641,17 +317,11 @@ class GitRepositorySerializer(NautobotModelSerializer):
 
 
 class GraphQLQuerySerializer(ValidatedModelSerializer, NotesSerializerMixin):
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:graphqlquery-detail")
     variables = serializers.DictField(required=False, allow_null=True, default={})
 
     class Meta:
         model = GraphQLQuery
-        fields = (
-            "url",
-            "name",
-            "query",
-            "variables",
-        )
+        fields = "__all__"
 
 
 class GraphQLQueryInputSerializer(serializers.Serializer):
@@ -668,23 +338,11 @@ class GraphQLQueryOutputSerializer(serializers.Serializer):
 
 
 class ImageAttachmentSerializer(ValidatedModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:imageattachment-detail")
     content_type = ContentTypeField(queryset=ContentType.objects.all())
-    parent = serializers.SerializerMethodField(read_only=True)
 
     class Meta:
         model = ImageAttachment
-        fields = [
-            "url",
-            "content_type",
-            "object_id",
-            "parent",
-            "name",
-            "image",
-            "image_height",
-            "image_width",
-            "created",
-        ]
+        fields = "__all__"
 
     def validate(self, data):
         # Validate that the parent object exists
@@ -703,15 +361,15 @@ class ImageAttachmentSerializer(ValidatedModelSerializer):
             component_name="ImageAttachmentParent",
             resource_type_field_name="object_type",
             serializers=[
-                NestedDeviceSerializer,
-                NestedLocationSerializer,
-                NestedRackSerializer,
+                DeviceSerializer,
+                LocationSerializer,
+                RackSerializer,
             ],
         )
     )
     def get_parent(self, obj):
-        serializer = get_serializer_for_model(obj.parent, prefix="Nested")
-        return serializer(obj.parent, context={"request": self.context["request"]}).data
+        depth = get_nested_serializer_depth(self)
+        return return_nested_serializer_data_based_on_depth(self, depth, obj, obj.parent, "parent")
 
 
 #
@@ -720,44 +378,9 @@ class ImageAttachmentSerializer(ValidatedModelSerializer):
 
 
 class JobSerializer(NautobotModelSerializer, TaggedModelSerializerMixin):
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:job-detail")
-
     class Meta:
         model = Job
-        fields = [
-            "url",
-            "source",
-            "module_name",
-            "job_class_name",
-            "grouping",
-            "grouping_override",
-            "name",
-            "name_override",
-            "slug",
-            "description",
-            "description_override",
-            "installed",
-            "enabled",
-            "is_job_hook_receiver",
-            "is_job_button_receiver",
-            "has_sensitive_variables",
-            "has_sensitive_variables_override",
-            "approval_required",
-            "approval_required_override",
-            "commit_default",
-            "commit_default_override",
-            "hidden",
-            "hidden_override",
-            "read_only",
-            "read_only_override",
-            "soft_time_limit",
-            "soft_time_limit_override",
-            "time_limit",
-            "time_limit_override",
-            "task_queues",
-            "task_queues_override",
-            "tags",
-        ]
+        fields = "__all__"
 
     def validate(self, data):
         # note no validation for on creation of jobs because we do not support user creation of Job records via API
@@ -788,7 +411,6 @@ class JobVariableSerializer(serializers.Serializer):
     help_text = serializers.CharField(read_only=True, required=False)
     default = serializers.JSONField(read_only=True, required=False)
     required = serializers.BooleanField(read_only=True, required=False)
-
     min_length = serializers.IntegerField(read_only=True, required=False)
     max_length = serializers.IntegerField(read_only=True, required=False)
     min_value = serializers.IntegerField(read_only=True, required=False)
@@ -797,11 +419,17 @@ class JobVariableSerializer(serializers.Serializer):
     model = serializers.CharField(read_only=True, required=False)
 
 
-class JobRunResponseSerializer(serializers.Serializer):
-    """Serializer representing responses from the JobModelViewSet.run() POST endpoint."""
+#
+# Scheduled Jobs
+#
+
 
-    schedule = NestedScheduledJobSerializer(read_only=True, required=False)
-    job_result = NestedJobResultSerializer(read_only=True, required=False)
+class ScheduledJobSerializer(BaseModelSerializer):
+    # start_time = serializers.DateTimeField(format=None, required=False)
+
+    class Meta:
+        model = ScheduledJob
+        fields = "__all__"
 
 
 #
@@ -810,63 +438,18 @@ class JobRunResponseSerializer(serializers.Serializer):
 
 
 class JobResultSerializer(CustomFieldModelSerializerMixin, BaseModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:jobresult-detail")
-    user = NestedUserSerializer(read_only=True)
     status = ChoiceField(choices=JobResultStatusChoices, read_only=True)
-    job_model = NestedJobSerializer(read_only=True)
-    obj_type = ContentTypeField(read_only=True)
-    scheduled_job = NestedScheduledJobSerializer(read_only=True)
 
     class Meta:
         model = JobResult
-        fields = [
-            "url",
-            "date_created",
-            "date_done",
-            "name",
-            "job_model",
-            "obj_type",
-            "status",
-            "user",
-            "data",
-            "task_id",
-            "task_kwargs",
-            "scheduled_job",
-        ]
+        fields = "__all__"
 
 
-#
-# Scheduled Jobs
-#
-
-
-class ScheduledJobSerializer(BaseModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:scheduledjob-detail")
-    user = NestedUserSerializer(read_only=True)
-    job_model = NestedJobSerializer(read_only=True)
-    approved_by_user = NestedUserSerializer(read_only=True)
+class JobRunResponseSerializer(serializers.Serializer):
+    """Serializer representing responses from the JobModelViewSet.run() POST endpoint."""
 
-    class Meta:
-        model = ScheduledJob
-        fields = [
-            "url",
-            "name",
-            "user",
-            "job_model",
-            "task",
-            "interval",
-            "queue",
-            "job_class",
-            "last_run_at",
-            "total_run_count",
-            "date_changed",
-            "description",
-            "user",
-            "approved_by_user",
-            "approval_required",
-            "approved_at",
-            "crontab",
-        ]
+    schedule = ScheduledJobSerializer(read_only=True, required=False)
+    job_result = JobResultSerializer(read_only=True, required=False)
 
 
 #
@@ -887,7 +470,6 @@ class JobClassSerializer(serializers.Serializer):
     description = serializers.CharField(max_length=255, required=False, read_only=True)
     test_methods = serializers.ListField(child=serializers.CharField(max_length=255))
     vars = serializers.SerializerMethodField(read_only=True)
-    result = NestedJobResultSerializer(required=False)
 
     @extend_schema_field(serializers.DictField)
     def get_vars(self, instance):
@@ -910,7 +492,6 @@ class JobClassDetailSerializer(JobClassSerializer):
 
 
 class JobHookSerializer(NautobotModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:jobhook-detail")
     content_types = ContentTypeField(
         queryset=ChangeLoggedModelsQuery().as_queryset(),
         many=True,
@@ -918,17 +499,7 @@ class JobHookSerializer(NautobotModelSerializer):
 
     class Meta:
         model = JobHook
-        fields = [
-            "id",
-            "url",
-            "name",
-            "content_types",
-            "job",
-            "enabled",
-            "type_create",
-            "type_update",
-            "type_delete",
-        ]
+        fields = "__all__"
 
     def validate(self, data):
         validated_data = super().validate(data)
@@ -948,17 +519,58 @@ class JobHookSerializer(NautobotModelSerializer):
         return validated_data
 
 
+class JobCreationSerializer(BaseModelSerializer):
+    """
+    Nested serializer specifically for use with `JobInputSerializer.schedule`.
+
+    We don't use `WritableNestedSerializer` here because this is not used to look up
+    an existing `ScheduledJob`, but instead used to specify parameters for creating one.
+    """
+
+    url = serializers.HyperlinkedIdentityField(view_name="extras-api:scheduledjob-detail")
+    name = serializers.CharField(max_length=255, required=False)
+    start_time = serializers.DateTimeField(format=None, required=False)
+
+    class Meta:
+        model = ScheduledJob
+        fields = ["url", "name", "start_time", "interval", "crontab"]
+
+    def validate(self, data):
+        data = super().validate(data)
+
+        if data["interval"] in choices.JobExecutionType.SCHEDULE_CHOICES:
+            if "name" not in data:
+                raise serializers.ValidationError({"name": "Please provide a name for the job schedule."})
+
+            if ("start_time" not in data and data["interval"] != choices.JobExecutionType.TYPE_CUSTOM) or (
+                "start_time" in data and data["start_time"] < models.ScheduledJob.earliest_possible_time()
+            ):
+                raise serializers.ValidationError(
+                    {
+                        "start_time": "Please enter a valid date and time greater than or equal to the current date and time."
+                    }
+                )
+
+            if data["interval"] == choices.JobExecutionType.TYPE_CUSTOM:
+                if data.get("crontab") is None:
+                    raise serializers.ValidationError({"crontab": "Please enter a valid crontab."})
+                try:
+                    models.ScheduledJob.get_crontab(data["crontab"])
+                except Exception as e:
+                    raise serializers.ValidationError({"crontab": e})
+
+        return data
+
+
 class JobInputSerializer(serializers.Serializer):
     data = serializers.JSONField(required=False, default=dict)
-    commit = serializers.BooleanField(required=False, default=None)
-    schedule = NestedScheduledJobCreationSerializer(required=False)
+    schedule = JobCreationSerializer(required=False)
     task_queue = serializers.CharField(required=False, allow_blank=True)
 
 
 class JobMultiPartInputSerializer(serializers.Serializer):
     """JobMultiPartInputSerializer is a "flattened" version of JobInputSerializer for use with multipart/form-data submissions which only accept key-value pairs"""
 
-    _commit = serializers.BooleanField(required=False, default=None)
     _schedule_name = serializers.CharField(max_length=255, required=False)
     _schedule_start_time = serializers.DateTimeField(format=None, required=False)
     _schedule_interval = ChoiceField(choices=JobExecutionType, required=False)
@@ -993,25 +605,9 @@ class JobMultiPartInputSerializer(serializers.Serializer):
 
 
 class JobLogEntrySerializer(BaseModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:joblogentry-detail")
-    display = serializers.SerializerMethodField()
-
     class Meta:
         model = JobLogEntry
-        fields = [
-            "url",
-            "absolute_url",
-            "created",
-            "grouping",
-            "job_result",
-            "log_level",
-            "log_object",
-            "message",
-        ]
-
-    @extend_schema_field(serializers.CharField)
-    def get_display(self, obj):
-        return obj.created.isoformat()
+        fields = "__all__"
 
 
 #
@@ -1020,22 +616,11 @@ class JobLogEntrySerializer(BaseModelSerializer):
 
 
 class JobButtonSerializer(ValidatedModelSerializer, NotesSerializerMixin):
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:jobbutton-detail")
     content_types = ContentTypeField(queryset=ContentType.objects.all(), many=True)
 
     class Meta:
         model = JobButton
-        fields = (
-            "url",
-            "job",
-            "name",
-            "content_types",
-            "text",
-            "weight",
-            "group_name",
-            "button_class",
-            "confirmation",
-        )
+        fields = "__all__"
 
 
 #
@@ -1044,29 +629,19 @@ class JobButtonSerializer(ValidatedModelSerializer, NotesSerializerMixin):
 
 
 class NoteSerializer(BaseModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:note-detail")
-    user = NestedUserSerializer(read_only=True)
     assigned_object_type = ContentTypeField(queryset=ContentType.objects.all())
     assigned_object = serializers.SerializerMethodField()
 
     class Meta:
         model = Note
-        fields = [
-            "url",
-            "user",
-            "user_name",
-            "assigned_object_type",
-            "assigned_object_id",
-            "assigned_object",
-            "note",
-            "slug",
-        ]
+        fields = "__all__"
+        list_display_fields = ["note", "assigned_object_type", "assigned_object_id", "user"]
 
     @extend_schema_field(
         PolymorphicProxySerializer(
             component_name="NoteAssignedObject",
             resource_type_field_name="object_type",
-            serializers=lambda: get_serializers_for_models(get_all_concrete_models(NotesMixin), prefix="Nested"),
+            serializers=lambda: get_serializers_for_models(get_all_concrete_models(NotesMixin)),
             allow_null=True,
         )
     )
@@ -1074,9 +649,10 @@ class NoteSerializer(BaseModelSerializer):
         if obj.assigned_object is None:
             return None
         try:
-            serializer = get_serializer_for_model(obj.assigned_object, prefix="Nested")
-            context = {"request": self.context["request"]}
-            return serializer(obj.assigned_object, context=context).data
+            depth = get_nested_serializer_depth(self)
+            return return_nested_serializer_data_based_on_depth(
+                self, depth, obj, obj.assigned_object, "assigned_object"
+            )
         except SerializerNotFound:
             return None
 
@@ -1091,34 +667,20 @@ class NoteInputSerializer(serializers.Serializer):
 
 
 class ObjectChangeSerializer(BaseModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:objectchange-detail")
-    user = NestedUserSerializer(read_only=True)
     action = ChoiceField(choices=ObjectChangeActionChoices, read_only=True)
     changed_object_type = ContentTypeField(read_only=True)
     changed_object = serializers.SerializerMethodField(read_only=True)
 
     class Meta:
         model = ObjectChange
-        fields = [
-            "url",
-            "time",
-            "user",
-            "user_name",
-            "request_id",
-            "action",
-            "changed_object_type",
-            "changed_object_id",
-            "changed_object",
-            "object_data",
-        ]
+        fields = "__all__"
+        list_display_fields = ["changed_object_id", "related_object_id", "related_object_type", "user"]
 
     @extend_schema_field(
         PolymorphicProxySerializer(
             component_name="ObjectChangeChangedObject",
             resource_type_field_name="object_type",
-            serializers=lambda: get_serializers_for_models(
-                ChangeLoggedModelsQuery().list_subclasses(), prefix="Nested"
-            ),
+            serializers=lambda: get_serializers_for_models(ChangeLoggedModelsQuery().list_subclasses()),
             allow_null=True,
         )
     )
@@ -1128,15 +690,11 @@ class ObjectChangeSerializer(BaseModelSerializer):
         """
         if obj.changed_object is None:
             return None
-
         try:
-            serializer = get_serializer_for_model(obj.changed_object, prefix="Nested")
+            depth = get_nested_serializer_depth(self)
+            return return_nested_serializer_data_based_on_depth(self, depth, obj, obj.changed_object, "changed_object")
         except SerializerNotFound:
             return obj.object_repr
-        context = {"request": self.context["request"]}
-        data = serializer(obj.changed_object, context=context).data
-
-        return data
 
 
 #
@@ -1145,8 +703,6 @@ class ObjectChangeSerializer(BaseModelSerializer):
 
 
 class RelationshipSerializer(ValidatedModelSerializer, NotesSerializerMixin):
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:relationship-detail")
-
     source_type = ContentTypeField(
         queryset=ContentType.objects.filter(FeatureQuery("relationships").get_query()),
     )
@@ -1157,27 +713,10 @@ class RelationshipSerializer(ValidatedModelSerializer, NotesSerializerMixin):
 
     class Meta:
         model = Relationship
-        fields = [
-            "url",
-            "name",
-            "slug",
-            "description",
-            "type",
-            "required_on",
-            "source_type",
-            "source_label",
-            "source_hidden",
-            "source_filter",
-            "destination_type",
-            "destination_label",
-            "destination_hidden",
-            "destination_filter",
-        ]
+        fields = "__all__"
 
 
 class RelationshipAssociationSerializer(ValidatedModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:relationshipassociation-detail")
-
     source_type = ContentTypeField(
         queryset=ContentType.objects.filter(FeatureQuery("relationships").get_query()),
     )
@@ -1186,18 +725,9 @@ class RelationshipAssociationSerializer(ValidatedModelSerializer):
         queryset=ContentType.objects.filter(FeatureQuery("relationships").get_query()),
     )
 
-    relationship = NestedRelationshipSerializer()
-
     class Meta:
         model = RelationshipAssociation
-        fields = [
-            "url",
-            "relationship",
-            "source_type",
-            "source_id",
-            "destination_type",
-            "destination_id",
-        ]
+        fields = "__all__"
 
 
 #
@@ -1205,22 +735,9 @@ class RelationshipAssociationSerializer(ValidatedModelSerializer):
 #
 
 
-class RoleModelSerializerMixin(BaseModelSerializer):
-    """Mixin to add `role` choice field to model serializers."""
-
-    role = RoleSerializerField(required=False)
-
-
-class RoleRequiredRoleModelSerializerMixin(BaseModelSerializer):
-    """Mixin to add `role` choice field to model serializers."""
-
-    role = RoleSerializerField()
-
-
 class RoleSerializer(NautobotModelSerializer):
     """Serializer for `Role` objects."""
 
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:role-detail")
     content_types = ContentTypeField(
         queryset=RoleModelsQuery().as_queryset(),
         many=True,
@@ -1228,13 +745,10 @@ class RoleSerializer(NautobotModelSerializer):
 
     class Meta:
         model = Role
-        fields = [
-            "url",
-            "content_types",
-            "name",
-            "color",
-            "weight",
-        ]
+        fields = "__all__"
+        extra_kwargs = {
+            "color": {"help_text": "RGB color in hexadecimal (e.g. 00ff00)"},
+        }
 
 
 #
@@ -1245,57 +759,33 @@ class RoleSerializer(NautobotModelSerializer):
 class SecretSerializer(NautobotModelSerializer, TaggedModelSerializerMixin):
     """Serializer for `Secret` objects."""
 
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:secret-detail")
-
     class Meta:
         model = Secret
-        fields = [
-            "url",
-            "name",
-            "description",
-            "provider",
-            "parameters",
-        ]
+        fields = "__all__"
 
 
-class SecretsGroupSerializer(NautobotModelSerializer):
-    """Serializer for `SecretsGroup` objects."""
-
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:secretsgroup-detail")
-
-    # TODO: it would be **awesome** if we could create/update SecretsGroupAssociations
-    # alongside creating/updating the base SecretsGroup, but since this is a ManyToManyField with
-    # a `through` table, that appears very non-trivial to implement. For now we have this as a
-    # read-only field; to create/update SecretsGroupAssociations you must make separate calls to the
-    # api/extras/secrets-group-associations/ REST endpoint as appropriate.
-    secrets = NestedSecretsGroupAssociationSerializer(source="secrets_group_associations", many=True, read_only=True)
+class SecretsGroupAssociationSerializer(ValidatedModelSerializer):
+    """Serializer for `SecretsGroupAssociation` objects."""
 
     class Meta:
-        model = SecretsGroup
-        fields = [
-            "url",
-            "name",
-            "description",
-            "secrets",
-        ]
-
+        model = SecretsGroupAssociation
+        fields = "__all__"
 
-class SecretsGroupAssociationSerializer(ValidatedModelSerializer):
-    """Serializer for `SecretsGroupAssociation` objects."""
 
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:secretsgroupassociation-detail")
-    secrets_group = NestedSecretsGroupSerializer()
-    secret = NestedSecretSerializer()
+class SecretsGroupSerializer(NautobotModelSerializer):
+    """Serializer for `SecretsGroup` objects."""
 
     class Meta:
-        model = SecretsGroupAssociation
-        fields = [
-            "url",
-            "secrets_group",
-            "access_type",
-            "secret_type",
-            "secret",
-        ]
+        model = SecretsGroup
+        fields = "__all__"
+        # TODO: it would be **awesome** if we could create/update SecretsGroupAssociations
+        # alongside creating/updating the base SecretsGroup, but since this is a ManyToManyField with
+        # a `through` table, that appears very non-trivial to implement. For now we have this as a
+        # read-only field; to create/update SecretsGroupAssociations you must make separate calls to the
+        # api/extras/secrets-group-associations/ REST endpoint as appropriate.
+        extra_kwargs = {
+            "secrets": {"source": "secrets_group_associations", "read_only": True},
+        }
 
 
 #
@@ -1306,7 +796,6 @@ class SecretsGroupAssociationSerializer(ValidatedModelSerializer):
 class StatusSerializer(NautobotModelSerializer):
     """Serializer for `Status` objects."""
 
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:status-detail")
     content_types = ContentTypeField(
         queryset=ContentType.objects.filter(FeatureQuery("statuses").get_query()),
         many=True,
@@ -1314,12 +803,10 @@ class StatusSerializer(NautobotModelSerializer):
 
     class Meta:
         model = Status
-        fields = [
-            "url",
-            "content_types",
-            "name",
-            "color",
-        ]
+        fields = "__all__"
+        extra_kwargs = {
+            "color": {"help_text": "RGB color in hexadecimal (e.g. 00ff00)"},
+        }
 
 
 #
@@ -1328,7 +815,6 @@ class StatusSerializer(NautobotModelSerializer):
 
 
 class TagSerializer(NautobotModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:tag-detail")
     tagged_items = serializers.IntegerField(read_only=True)
     content_types = ContentTypeField(
         queryset=TaggableClassesQuery().as_queryset(),
@@ -1338,15 +824,10 @@ class TagSerializer(NautobotModelSerializer):
 
     class Meta:
         model = Tag
-        fields = [
-            "url",
-            "name",
-            "slug",
-            "color",
-            "description",
-            "tagged_items",
-            "content_types",
-        ]
+        fields = "__all__"
+        extra_kwargs = {
+            "color": {"help_text": "RGB color in hexadecimal (e.g. 00ff00)"},
+        }
 
     def validate(self, data):
         data = super().validate(data)
@@ -1368,7 +849,6 @@ class TagSerializer(NautobotModelSerializer):
 
 
 class WebhookSerializer(ValidatedModelSerializer, NotesSerializerMixin):
-    url = serializers.HyperlinkedIdentityField(view_name="extras-api:webhook-detail")
     content_types = ContentTypeField(
         queryset=ContentType.objects.filter(FeatureQuery("webhooks").get_query()).order_by("app_label", "model"),
         many=True,
@@ -1376,22 +856,7 @@ class WebhookSerializer(ValidatedModelSerializer, NotesSerializerMixin):
 
     class Meta:
         model = Webhook
-        fields = [
-            "url",
-            "content_types",
-            "name",
-            "type_create",
-            "type_update",
-            "type_delete",
-            "payload_url",
-            "http_method",
-            "http_content_type",
-            "additional_headers",
-            "body_template",
-            "secret",
-            "ssl_verification",
-            "ca_file_path",
-        ]
+        fields = "__all__"
 
     def validate(self, data):
         validated_data = super().validate(data)