NeoAnd/netbox
1
0
Fork 0
mirror of https://github.com/netbox-community/netbox.git synced 2025-07-14 09:51:22 -06:00
Code Issues Actions 8 Packages Projects Releases Wiki Activity

Reomove obsolete nested serializers

Browse Source
This commit is contained in:
Jeremy Stretch 2024-10-17 16:19:42 -04:00
parent 6aeb553391
commit a8ec06687a
10 changed files with 0 additions and 1170 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

79
netbox/circuits/api/nested_serializers.py
View File

@ -1,79 +0,0 @@
import warnings
from drf_spectacular.utils import extend_schema_serializer
from circuits.models import *
from netbox.api.fields import RelatedObjectCountField
from netbox.api.serializers import WritableNestedSerializer
from .serializers_.nested import NestedProviderAccountSerializer
__all__ = [
'NestedCircuitSerializer',
'NestedCircuitTerminationSerializer',
'NestedCircuitTypeSerializer',
'NestedProviderNetworkSerializer',
'NestedProviderSerializer',
'NestedProviderAccountSerializer',
]
# TODO: Remove in v4.2
warnings.warn(
"Dedicated nested serializers will be removed in NetBox v4.2. Use Serializer(nested=True) instead.",
DeprecationWarning
)
#
# Provider networks
#
class NestedProviderNetworkSerializer(WritableNestedSerializer):
class Meta:
model = ProviderNetwork
fields = ['id', 'url', 'display_url', 'display', 'name']
#
# Providers
#
@extend_schema_serializer(
exclude_fields=('circuit_count',),
)
class NestedProviderSerializer(WritableNestedSerializer):
circuit_count = RelatedObjectCountField('circuits')
class Meta:
model = Provider
fields = ['id', 'url', 'display_url', 'display', 'name', 'slug', 'circuit_count']
#
# Circuits
#
@extend_schema_serializer(
exclude_fields=('circuit_count',),
)
class NestedCircuitTypeSerializer(WritableNestedSerializer):
circuit_count = RelatedObjectCountField('circuits')
class Meta:
model = CircuitType
fields = ['id', 'url', 'display_url', 'display', 'name', 'slug', 'circuit_count']
class NestedCircuitSerializer(WritableNestedSerializer):
class Meta:
model = Circuit
fields = ['id', 'url', 'display_url', 'display', 'cid']
class NestedCircuitTerminationSerializer(WritableNestedSerializer):
circuit = NestedCircuitSerializer()
class Meta:
model = CircuitTermination
fields = ['id', 'url', 'display_url', 'display', 'circuit', 'term_side', 'cable', '_occupied']

47
netbox/core/api/nested_serializers.py
View File

@ -1,47 +0,0 @@
import warnings
from rest_framework import serializers
from core.choices import JobStatusChoices
from core.models import *
from netbox.api.fields import ChoiceField
from netbox.api.serializers import WritableNestedSerializer
from users.api.serializers import UserSerializer
__all__ = (
'NestedDataFileSerializer',
'NestedDataSourceSerializer',
'NestedJobSerializer',
)
# TODO: Remove in v4.2
warnings.warn(
"Dedicated nested serializers will be removed in NetBox v4.2. Use Serializer(nested=True) instead.",
DeprecationWarning
)
class NestedDataSourceSerializer(WritableNestedSerializer):
class Meta:
model = DataSource
fields = ['id', 'url', 'display_url', 'display', 'name']
class NestedDataFileSerializer(WritableNestedSerializer):
class Meta:
model = DataFile
fields = ['id', 'url', 'display_url', 'display', 'path']
class NestedJobSerializer(serializers.ModelSerializer):
status = ChoiceField(choices=JobStatusChoices)
user = UserSerializer(
nested=True,
read_only=True
)
class Meta:
model = Job
fields = ['url', 'display_url', 'created', 'completed', 'user', 'status']

389
netbox/dcim/api/nested_serializers.py
View File

@ -1,389 +0,0 @@
import warnings
from drf_spectacular.utils import extend_schema_serializer
from rest_framework import serializers
from dcim import models
from netbox.api.fields import RelatedObjectCountField
from netbox.api.serializers import WritableNestedSerializer
from .serializers_.nested import (
NestedDeviceBaySerializer, NestedDeviceSerializer, NestedInterfaceSerializer, NestedInterfaceTemplateSerializer,
NestedLocationSerializer, NestedModuleBaySerializer, NestedRegionSerializer, NestedSiteGroupSerializer,
)
__all__ = [
'NestedCableSerializer',
'NestedConsolePortSerializer',
'NestedConsolePortTemplateSerializer',
'NestedConsoleServerPortSerializer',
'NestedConsoleServerPortTemplateSerializer',
'NestedDeviceBaySerializer',
'NestedDeviceBayTemplateSerializer',
'NestedDeviceRoleSerializer',
'NestedDeviceSerializer',
'NestedDeviceTypeSerializer',
'NestedFrontPortSerializer',
'NestedFrontPortTemplateSerializer',
'NestedInterfaceSerializer',
'NestedInterfaceTemplateSerializer',
'NestedInventoryItemSerializer',
'NestedInventoryItemRoleSerializer',
'NestedInventoryItemTemplateSerializer',
'NestedManufacturerSerializer',
'NestedModuleBaySerializer',
'NestedModuleBayTemplateSerializer',
'NestedModuleSerializer',
'NestedModuleTypeSerializer',
'NestedPlatformSerializer',
'NestedPowerFeedSerializer',
'NestedPowerOutletSerializer',
'NestedPowerOutletTemplateSerializer',
'NestedPowerPanelSerializer',
'NestedPowerPortSerializer',
'NestedPowerPortTemplateSerializer',
'NestedLocationSerializer',
'NestedRackReservationSerializer',
'NestedRackRoleSerializer',
'NestedRackSerializer',
'NestedRearPortSerializer',
'NestedRearPortTemplateSerializer',
'NestedRegionSerializer',
'NestedSiteSerializer',
'NestedSiteGroupSerializer',
'NestedVirtualChassisSerializer',
'NestedVirtualDeviceContextSerializer',
]
# TODO: Remove in v4.2
warnings.warn(
"Dedicated nested serializers will be removed in NetBox v4.2. Use Serializer(nested=True) instead.",
DeprecationWarning
)
#
# Regions/sites
#
class NestedSiteSerializer(WritableNestedSerializer):
class Meta:
model = models.Site
fields = ['id', 'url', 'display_url', 'display', 'name', 'slug']
#
# Racks
#
@extend_schema_serializer(
exclude_fields=('rack_count',),
)
class NestedRackRoleSerializer(WritableNestedSerializer):
rack_count = RelatedObjectCountField('racks')
class Meta:
model = models.RackRole
fields = ['id', 'url', 'display_url', 'display', 'name', 'slug', 'rack_count']
@extend_schema_serializer(
exclude_fields=('device_count',),
)
class NestedRackSerializer(WritableNestedSerializer):
device_count = RelatedObjectCountField('devices')
class Meta:
model = models.Rack
fields = ['id', 'url', 'display_url', 'display', 'name', 'device_count']
class NestedRackReservationSerializer(WritableNestedSerializer):
user = serializers.SerializerMethodField(read_only=True)
class Meta:
model = models.RackReservation
fields = ['id', 'url', 'display_url', 'display', 'user', 'units']
def get_user(self, obj):
return obj.user.username
#
# Device/module types
#
@extend_schema_serializer(
exclude_fields=('devicetype_count',),
)
class NestedManufacturerSerializer(WritableNestedSerializer):
devicetype_count = RelatedObjectCountField('device_types')
class Meta:
model = models.Manufacturer
fields = ['id', 'url', 'display_url', 'display', 'name', 'slug', 'devicetype_count']
@extend_schema_serializer(
exclude_fields=('device_count',),
)
class NestedDeviceTypeSerializer(WritableNestedSerializer):
manufacturer = NestedManufacturerSerializer(read_only=True)
device_count = RelatedObjectCountField('instances')
class Meta:
model = models.DeviceType
fields = ['id', 'url', 'display_url', 'display', 'manufacturer', 'model', 'slug', 'device_count']
class NestedModuleTypeSerializer(WritableNestedSerializer):
manufacturer = NestedManufacturerSerializer(read_only=True)
class Meta:
model = models.ModuleType
fields = ['id', 'url', 'display_url', 'display', 'manufacturer', 'model']
#
# Component templates
#
class NestedConsolePortTemplateSerializer(WritableNestedSerializer):
class Meta:
model = models.ConsolePortTemplate
fields = ['id', 'url', 'display_url', 'display', 'name']
class NestedConsoleServerPortTemplateSerializer(WritableNestedSerializer):
class Meta:
model = models.ConsoleServerPortTemplate
fields = ['id', 'url', 'display_url', 'display', 'name']
class NestedPowerPortTemplateSerializer(WritableNestedSerializer):
class Meta:
model = models.PowerPortTemplate
fields = ['id', 'url', 'display_url', 'display', 'name']
class NestedPowerOutletTemplateSerializer(WritableNestedSerializer):
class Meta:
model = models.PowerOutletTemplate
fields = ['id', 'url', 'display_url', 'display', 'name']
class NestedRearPortTemplateSerializer(WritableNestedSerializer):
class Meta:
model = models.RearPortTemplate
fields = ['id', 'url', 'display_url', 'display', 'name']
class NestedFrontPortTemplateSerializer(WritableNestedSerializer):
class Meta:
model = models.FrontPortTemplate
fields = ['id', 'url', 'display_url', 'display', 'name']
class NestedModuleBayTemplateSerializer(WritableNestedSerializer):
class Meta:
model = models.ModuleBayTemplate
fields = ['id', 'url', 'display_url', 'display', 'name']
class NestedDeviceBayTemplateSerializer(WritableNestedSerializer):
class Meta:
model = models.DeviceBayTemplate
fields = ['id', 'url', 'display_url', 'display', 'name']
class NestedInventoryItemTemplateSerializer(WritableNestedSerializer):
_depth = serializers.IntegerField(source='level', read_only=True)
class Meta:
model = models.InventoryItemTemplate
fields = ['id', 'url', 'display_url', 'display', 'name', '_depth']
#
# Devices
#
@extend_schema_serializer(
exclude_fields=('device_count', 'virtualmachine_count'),
)
class NestedDeviceRoleSerializer(WritableNestedSerializer):
device_count = RelatedObjectCountField('devices')
virtualmachine_count = RelatedObjectCountField('virtual_machines')
class Meta:
model = models.DeviceRole
fields = ['id', 'url', 'display_url', 'display', 'name', 'slug', 'device_count', 'virtualmachine_count']
@extend_schema_serializer(
exclude_fields=('device_count', 'virtualmachine_count'),
)
class NestedPlatformSerializer(WritableNestedSerializer):
device_count = RelatedObjectCountField('devices')
virtualmachine_count = RelatedObjectCountField('virtual_machines')
class Meta:
model = models.Platform
fields = ['id', 'url', 'display_url', 'display', 'name', 'slug', 'device_count', 'virtualmachine_count']
class ModuleNestedModuleBaySerializer(WritableNestedSerializer):
class Meta:
model = models.ModuleBay
fields = ['id', 'url', 'display_url', 'display', 'name']
class NestedModuleSerializer(WritableNestedSerializer):
device = NestedDeviceSerializer(read_only=True)
module_bay = ModuleNestedModuleBaySerializer(read_only=True)
module_type = NestedModuleTypeSerializer(read_only=True)
class Meta:
model = models.Module
fields = ['id', 'url', 'display_url', 'display', 'device', 'module_bay', 'module_type']
class NestedConsoleServerPortSerializer(WritableNestedSerializer):
device = NestedDeviceSerializer(read_only=True)
_occupied = serializers.BooleanField(required=False, read_only=True)
class Meta:
model = models.ConsoleServerPort
fields = ['id', 'url', 'display_url', 'display', 'device', 'name', 'cable', '_occupied']
class NestedConsolePortSerializer(WritableNestedSerializer):
device = NestedDeviceSerializer(read_only=True)
_occupied = serializers.BooleanField(required=False, read_only=True)
class Meta:
model = models.ConsolePort
fields = ['id', 'url', 'display_url', 'display', 'device', 'name', 'cable', '_occupied']
class NestedPowerOutletSerializer(WritableNestedSerializer):
device = NestedDeviceSerializer(read_only=True)
_occupied = serializers.BooleanField(required=False, read_only=True)
class Meta:
model = models.PowerOutlet
fields = ['id', 'url', 'display_url', 'display', 'device', 'name', 'cable', '_occupied']
class NestedPowerPortSerializer(WritableNestedSerializer):
device = NestedDeviceSerializer(read_only=True)
_occupied = serializers.BooleanField(required=False, read_only=True)
class Meta:
model = models.PowerPort
fields = ['id', 'url', 'display_url', 'display', 'device', 'name', 'cable', '_occupied']
class NestedRearPortSerializer(WritableNestedSerializer):
device = NestedDeviceSerializer(read_only=True)
_occupied = serializers.BooleanField(required=False, read_only=True)
class Meta:
model = models.RearPort
fields = ['id', 'url', 'display_url', 'display', 'device', 'name', 'cable', '_occupied']
class NestedFrontPortSerializer(WritableNestedSerializer):
device = NestedDeviceSerializer(read_only=True)
_occupied = serializers.BooleanField(required=False, read_only=True)
class Meta:
model = models.FrontPort
fields = ['id', 'url', 'display_url', 'display', 'device', 'name', 'cable', '_occupied']
class NestedInventoryItemSerializer(WritableNestedSerializer):
device = NestedDeviceSerializer(read_only=True)
_depth = serializers.IntegerField(source='level', read_only=True)
class Meta:
model = models.InventoryItem
fields = ['id', 'url', 'display_url', 'display', 'device', 'name', '_depth']
@extend_schema_serializer(
exclude_fields=('inventoryitem_count',),
)
class NestedInventoryItemRoleSerializer(WritableNestedSerializer):
inventoryitem_count = RelatedObjectCountField('inventory_items')
class Meta:
model = models.InventoryItemRole
fields = ['id', 'url', 'display_url', 'display', 'name', 'slug', 'inventoryitem_count']
#
# Cables
#
class NestedCableSerializer(WritableNestedSerializer):
class Meta:
model = models.Cable
fields = ['id', 'url', 'display_url', 'display', 'label']
#
# Virtual chassis
#
@extend_schema_serializer(
exclude_fields=('member_count',),
)
class NestedVirtualChassisSerializer(WritableNestedSerializer):
master = NestedDeviceSerializer()
member_count = serializers.IntegerField(read_only=True)
class Meta:
model = models.VirtualChassis
fields = ['id', 'url', 'display_url', 'display', 'name', 'master', 'member_count']
#
# Power panels/feeds
#
@extend_schema_serializer(
exclude_fields=('powerfeed_count',),
)
class NestedPowerPanelSerializer(WritableNestedSerializer):
powerfeed_count = RelatedObjectCountField('powerfeeds')
class Meta:
model = models.PowerPanel
fields = ['id', 'url', 'display_url', 'display', 'name', 'powerfeed_count']
class NestedPowerFeedSerializer(WritableNestedSerializer):
_occupied = serializers.BooleanField(required=False, read_only=True)
class Meta:
model = models.PowerFeed
fields = ['id', 'url', 'display_url', 'display', 'name', 'cable', '_occupied']
class NestedVirtualDeviceContextSerializer(WritableNestedSerializer):
device = NestedDeviceSerializer()
class Meta:
model = models.VirtualDeviceContext
fields = ['id', 'url', 'display_url', 'display', 'name', 'identifier', 'device']

135
netbox/extras/api/nested_serializers.py
View File

@ -1,135 +0,0 @@
import warnings
from rest_framework import serializers
from extras import models
from netbox.api.serializers import NestedTagSerializer, WritableNestedSerializer
__all__ = [
'NestedBookmarkSerializer',
'NestedConfigContextSerializer',
'NestedConfigTemplateSerializer',
'NestedCustomFieldChoiceSetSerializer',
'NestedCustomFieldSerializer',
'NestedCustomLinkSerializer',
'NestedEventRuleSerializer',
'NestedExportTemplateSerializer',
'NestedImageAttachmentSerializer',
'NestedJournalEntrySerializer',
'NestedSavedFilterSerializer',
'NestedScriptSerializer',
'NestedTagSerializer', # Defined in netbox.api.serializers
'NestedWebhookSerializer',
]
# TODO: Remove in v4.2
warnings.warn(
"Dedicated nested serializers will be removed in NetBox v4.2. Use Serializer(nested=True) instead.",
DeprecationWarning
)
class NestedEventRuleSerializer(WritableNestedSerializer):
class Meta:
model = models.EventRule
fields = ['id', 'url', 'display_url', 'display', 'name']
class NestedWebhookSerializer(WritableNestedSerializer):
class Meta:
model = models.Webhook
fields = ['id', 'url', 'display_url', 'display', 'name']
class NestedCustomFieldSerializer(WritableNestedSerializer):
class Meta:
model = models.CustomField
fields = ['id', 'url', 'display_url', 'display', 'name']
class NestedCustomFieldChoiceSetSerializer(WritableNestedSerializer):
class Meta:
model = models.CustomFieldChoiceSet
fields = ['id', 'url', 'display_url', 'display', 'name', 'choices_count']
class NestedCustomLinkSerializer(WritableNestedSerializer):
class Meta:
model = models.CustomLink
fields = ['id', 'url', 'display_url', 'display', 'name']
class NestedConfigContextSerializer(WritableNestedSerializer):
class Meta:
model = models.ConfigContext
fields = ['id', 'url', 'display_url', 'display', 'name']
class NestedConfigTemplateSerializer(WritableNestedSerializer):
class Meta:
model = models.ConfigTemplate
fields = ['id', 'url', 'display_url', 'display', 'name']
class NestedExportTemplateSerializer(WritableNestedSerializer):
class Meta:
model = models.ExportTemplate
fields = ['id', 'url', 'display_url', 'display', 'name']
class NestedSavedFilterSerializer(WritableNestedSerializer):
class Meta:
model = models.SavedFilter
fields = ['id', 'url', 'display_url', 'display', 'name', 'slug']
class NestedBookmarkSerializer(WritableNestedSerializer):
class Meta:
model = models.Bookmark
fields = ['id', 'url', 'display', 'object_id', 'object_type']
class NestedImageAttachmentSerializer(WritableNestedSerializer):
class Meta:
model = models.ImageAttachment
fields = ['id', 'url', 'display', 'name', 'image']
class NestedJournalEntrySerializer(WritableNestedSerializer):
class Meta:
model = models.JournalEntry
fields = ['id', 'url', 'display_url', 'display', 'created']
class NestedScriptSerializer(WritableNestedSerializer):
url = serializers.HyperlinkedIdentityField(
view_name='extras-api:script-detail',
lookup_field='full_name',
lookup_url_kwarg='pk'
)
display_url = serializers.HyperlinkedIdentityField(
view_name='extras:script',
lookup_field='full_name',
lookup_url_kwarg='pk'
)
name = serializers.CharField(read_only=True)
display = serializers.SerializerMethodField(read_only=True)
class Meta:
model = models.Script
fields = ['id', 'url', 'display_url', 'display', 'name']
def get_display(self, obj):
return f'{obj.name} ({obj.module})'

204
netbox/ipam/api/nested_serializers.py
View File

@ -1,204 +0,0 @@
import warnings
from drf_spectacular.utils import extend_schema_serializer
from rest_framework import serializers
from ipam import models
from netbox.api.fields import RelatedObjectCountField
from netbox.api.serializers import WritableNestedSerializer
from .field_serializers import IPAddressField
from .serializers_.nested import NestedIPAddressSerializer
__all__ = [
'NestedAggregateSerializer',
'NestedASNSerializer',
'NestedASNRangeSerializer',
'NestedFHRPGroupSerializer',
'NestedFHRPGroupAssignmentSerializer',
'NestedIPAddressSerializer',
'NestedIPRangeSerializer',
'NestedPrefixSerializer',
'NestedRIRSerializer',
'NestedRoleSerializer',
'NestedRouteTargetSerializer',
'NestedServiceSerializer',
'NestedServiceTemplateSerializer',
'NestedVLANGroupSerializer',
'NestedVLANSerializer',
'NestedVRFSerializer',
]
# TODO: Remove in v4.2
warnings.warn(
"Dedicated nested serializers will be removed in NetBox v4.2. Use Serializer(nested=True) instead.",
DeprecationWarning
)
#
# ASN ranges
#
class NestedASNRangeSerializer(WritableNestedSerializer):
class Meta:
model = models.ASNRange
fields = ['id', 'url', 'display_url', 'display', 'name']
#
# ASNs
#
class NestedASNSerializer(WritableNestedSerializer):
class Meta:
model = models.ASN
fields = ['id', 'url', 'display_url', 'display', 'asn']
#
# VRFs
#
@extend_schema_serializer(
exclude_fields=('prefix_count',),
)
class NestedVRFSerializer(WritableNestedSerializer):
prefix_count = RelatedObjectCountField('prefixes')
class Meta:
model = models.VRF
fields = ['id', 'url', 'display_url', 'display', 'name', 'rd', 'prefix_count']
#
# Route targets
#
class NestedRouteTargetSerializer(WritableNestedSerializer):
class Meta:
model = models.RouteTarget
fields = ['id', 'url', 'display_url', 'display', 'name']
#
# RIRs/aggregates
#
@extend_schema_serializer(
exclude_fields=('aggregate_count',),
)
class NestedRIRSerializer(WritableNestedSerializer):
aggregate_count = RelatedObjectCountField('aggregates')
class Meta:
model = models.RIR
fields = ['id', 'url', 'display_url', 'display', 'name', 'slug', 'aggregate_count']
class NestedAggregateSerializer(WritableNestedSerializer):
family = serializers.IntegerField(read_only=True)
class Meta:
model = models.Aggregate
fields = ['id', 'url', 'display_url', 'display', 'family', 'prefix']
#
# FHRP groups
#
class NestedFHRPGroupSerializer(WritableNestedSerializer):
class Meta:
model = models.FHRPGroup
fields = ['id', 'url', 'display_url', 'display', 'protocol', 'group_id']
class NestedFHRPGroupAssignmentSerializer(WritableNestedSerializer):
group = NestedFHRPGroupSerializer()
class Meta:
model = models.FHRPGroupAssignment
fields = ['id', 'url', 'display_url', 'display', 'group', 'interface_type', 'interface_id', 'priority']
#
# VLANs
#
@extend_schema_serializer(
exclude_fields=('prefix_count', 'vlan_count'),
)
class NestedRoleSerializer(WritableNestedSerializer):
prefix_count = RelatedObjectCountField('prefixes')
vlan_count = RelatedObjectCountField('vlans')
class Meta:
model = models.Role
fields = ['id', 'url', 'display_url', 'display', 'name', 'slug', 'prefix_count', 'vlan_count']
@extend_schema_serializer(
exclude_fields=('vlan_count',),
)
class NestedVLANGroupSerializer(WritableNestedSerializer):
vlan_count = RelatedObjectCountField('vlans')
class Meta:
model = models.VLANGroup
fields = ['id', 'url', 'display_url', 'display', 'name', 'slug', 'vlan_count']
class NestedVLANSerializer(WritableNestedSerializer):
class Meta:
model = models.VLAN
fields = ['id', 'url', 'display_url', 'display', 'vid', 'name']
#
# Prefixes
#
class NestedPrefixSerializer(WritableNestedSerializer):
family = serializers.IntegerField(read_only=True)
_depth = serializers.IntegerField(read_only=True)
class Meta:
model = models.Prefix
fields = ['id', 'url', 'display_url', 'display', 'family', 'prefix', '_depth']
#
# IP ranges
#
class NestedIPRangeSerializer(WritableNestedSerializer):
family = serializers.IntegerField(read_only=True)
start_address = IPAddressField()
end_address = IPAddressField()
class Meta:
model = models.IPRange
fields = ['id', 'url', 'display_url', 'display', 'family', 'start_address', 'end_address']
#
# Services
#
class NestedServiceTemplateSerializer(WritableNestedSerializer):
class Meta:
model = models.ServiceTemplate
fields = ['id', 'url', 'display_url', 'display', 'name', 'protocol', 'ports']
class NestedServiceSerializer(WritableNestedSerializer):
class Meta:
model = models.Service
fields = ['id', 'url', 'display_url', 'display', 'name', 'protocol', 'ports']

58
netbox/tenancy/api/nested_serializers.py
View File

@ -1,58 +0,0 @@
import warnings
from netbox.api.serializers import WritableNestedSerializer
from serializers_.nested import NestedContactGroupSerializer, NestedTenantGroupSerializer
from tenancy.models import *
__all__ = [
'NestedContactSerializer',
'NestedContactAssignmentSerializer',
'NestedContactGroupSerializer',
'NestedContactRoleSerializer',
'NestedTenantGroupSerializer',
'NestedTenantSerializer',
]
# TODO: Remove in v4.2
warnings.warn(
"Dedicated nested serializers will be removed in NetBox v4.2. Use Serializer(nested=True) instead.",
DeprecationWarning
)
#
# Tenants
#
class NestedTenantSerializer(WritableNestedSerializer):
class Meta:
model = Tenant
fields = ['id', 'url', 'display_url', 'display', 'name', 'slug']
#
# Contacts
#
class NestedContactRoleSerializer(WritableNestedSerializer):
class Meta:
model = ContactRole
fields = ['id', 'url', 'display_url', 'display', 'name', 'slug']
class NestedContactSerializer(WritableNestedSerializer):
class Meta:
model = Contact
fields = ['id', 'url', 'display_url', 'display', 'name']
class NestedContactAssignmentSerializer(WritableNestedSerializer):
contact = NestedContactSerializer()
role = NestedContactRoleSerializer
class Meta:
model = ContactAssignment
fields = ['id', 'url', 'display', 'contact', 'role', 'priority']

53
netbox/users/api/nested_serializers.py
View File

@ -1,53 +0,0 @@
import warnings
from drf_spectacular.utils import extend_schema_field
from rest_framework import serializers
from core.models import ObjectType
from netbox.api.fields import ContentTypeField
from netbox.api.serializers import WritableNestedSerializer
from serializers_.nested import NestedGroupSerializer, NestedUserSerializer
from users.models import ObjectPermission, Token
__all__ = [
'NestedGroupSerializer',
'NestedObjectPermissionSerializer',
'NestedTokenSerializer',
'NestedUserSerializer',
]
# TODO: Remove in v4.2
warnings.warn(
"Dedicated nested serializers will be removed in NetBox v4.2. Use Serializer(nested=True) instead.",
DeprecationWarning
)
class NestedTokenSerializer(WritableNestedSerializer):
class Meta:
model = Token
fields = ['id', 'url', 'display_url', 'display', 'key', 'write_enabled']
class NestedObjectPermissionSerializer(WritableNestedSerializer):
object_types = ContentTypeField(
queryset=ObjectType.objects.all(),
many=True
)
groups = serializers.SerializerMethodField(read_only=True)
users = serializers.SerializerMethodField(read_only=True)
class Meta:
model = ObjectPermission
fields = [
'id', 'url', 'display_url', 'display', 'name', 'enabled', 'object_types', 'groups', 'users', 'actions'
]
@extend_schema_field(serializers.ListField)
def get_groups(self, obj):
return [g.name for g in obj.groups.all()]
@extend_schema_field(serializers.ListField)
def get_users(self, obj):
return [u.username for u in obj.users.all()]

72
netbox/virtualization/api/nested_serializers.py
View File

@ -1,72 +0,0 @@
import warnings
from drf_spectacular.utils import extend_schema_serializer
from netbox.api.fields import RelatedObjectCountField
from netbox.api.serializers import WritableNestedSerializer
from virtualization.models import *
from .serializers_.nested import NestedVirtualMachineSerializer, NestedVMInterfaceSerializer
__all__ = [
'NestedClusterGroupSerializer',
'NestedClusterSerializer',
'NestedClusterTypeSerializer',
'NestedVirtualDiskSerializer',
'NestedVMInterfaceSerializer',
'NestedVirtualMachineSerializer',
]
# TODO: Remove in v4.2
warnings.warn(
"Dedicated nested serializers will be removed in NetBox v4.2. Use Serializer(nested=True) instead.",
DeprecationWarning
)
#
# Clusters
#
@extend_schema_serializer(
exclude_fields=('cluster_count',),
)
class NestedClusterTypeSerializer(WritableNestedSerializer):
cluster_count = RelatedObjectCountField('clusters')
class Meta:
model = ClusterType
fields = ['id', 'url', 'display_url', 'display', 'name', 'slug', 'cluster_count']
@extend_schema_serializer(
exclude_fields=('cluster_count',),
)
class NestedClusterGroupSerializer(WritableNestedSerializer):
cluster_count = RelatedObjectCountField('clusters')
class Meta:
model = ClusterGroup
fields = ['id', 'url', 'display_url', 'display', 'name', 'slug', 'cluster_count']
@extend_schema_serializer(
exclude_fields=('virtualmachine_count',),
)
class NestedClusterSerializer(WritableNestedSerializer):
virtualmachine_count = RelatedObjectCountField('virtual_machines')
class Meta:
model = Cluster
fields = ['id', 'url', 'display_url', 'display', 'name', 'virtualmachine_count']
#
# Virtual machines
#
class NestedVirtualDiskSerializer(WritableNestedSerializer):
virtual_machine = NestedVirtualMachineSerializer(read_only=True)
class Meta:
model = VirtualDisk
fields = ['id', 'url', 'display_url', 'display', 'virtual_machine', 'name', 'size']

109
netbox/vpn/api/nested_serializers.py
View File

@ -1,109 +0,0 @@
import warnings
from drf_spectacular.utils import extend_schema_serializer
from netbox.api.fields import RelatedObjectCountField
from netbox.api.serializers import WritableNestedSerializer
from vpn import models
__all__ = (
'NestedIKEPolicySerializer',
'NestedIKEProposalSerializer',
'NestedIPSecPolicySerializer',
'NestedIPSecProfileSerializer',
'NestedIPSecProposalSerializer',
'NestedL2VPNSerializer',
'NestedL2VPNTerminationSerializer',
'NestedTunnelGroupSerializer',
'NestedTunnelSerializer',
'NestedTunnelTerminationSerializer',
)
# TODO: Remove in v4.2
warnings.warn(
"Dedicated nested serializers will be removed in NetBox v4.2. Use Serializer(nested=True) instead.",
DeprecationWarning
)
@extend_schema_serializer(
exclude_fields=('tunnel_count',),
)
class NestedTunnelGroupSerializer(WritableNestedSerializer):
tunnel_count = RelatedObjectCountField('tunnels')
class Meta:
model = models.TunnelGroup
fields = ['id', 'url', 'display_url', 'display', 'name', 'slug', 'tunnel_count']
class NestedTunnelSerializer(WritableNestedSerializer):
class Meta:
model = models.Tunnel
fields = ('id', 'url', 'display_url', 'display', 'name')
class NestedTunnelTerminationSerializer(WritableNestedSerializer):
class Meta:
model = models.TunnelTermination
fields = ('id', 'url', 'display_url', 'display')
class NestedIKEProposalSerializer(WritableNestedSerializer):
class Meta:
model = models.IKEProposal
fields = ('id', 'url', 'display_url', 'display', 'name')
class NestedIKEPolicySerializer(WritableNestedSerializer):
class Meta:
model = models.IKEPolicy
fields = ('id', 'url', 'display_url', 'display', 'name')
class NestedIPSecProposalSerializer(WritableNestedSerializer):
class Meta:
model = models.IPSecProposal
fields = ('id', 'url', 'display_url', 'display', 'name')
class NestedIPSecPolicySerializer(WritableNestedSerializer):
class Meta:
model = models.IPSecPolicy
fields = ('id', 'url', 'display_url', 'display', 'name')
class NestedIPSecProfileSerializer(WritableNestedSerializer):
class Meta:
model = models.IPSecProfile
fields = ('id', 'url', 'display_url', 'display', 'name')
#
# L2VPN
#
class NestedL2VPNSerializer(WritableNestedSerializer):
class Meta:
model = models.L2VPN
fields = [
'id', 'url', 'display', 'display_url', 'identifier', 'name', 'slug', 'type'
]
class NestedL2VPNTerminationSerializer(WritableNestedSerializer):
l2vpn = NestedL2VPNSerializer()
class Meta:
model = models.L2VPNTermination
fields = [
'id', 'url', 'display_url', 'display', 'l2vpn'
]

24
netbox/wireless/api/nested_serializers.py
View File

@ -1,24 +0,0 @@
import warnings
from netbox.api.serializers import WritableNestedSerializer
from wireless.models import *
from .serializers_.nested import NestedWirelessLANGroupSerializer, NestedWirelessLinkSerializer
__all__ = (
'NestedWirelessLANSerializer',
'NestedWirelessLANGroupSerializer',
'NestedWirelessLinkSerializer',
)
# TODO: Remove in v4.2
warnings.warn(
"Dedicated nested serializers will be removed in NetBox v4.2. Use Serializer(nested=True) instead.",
DeprecationWarning
)
class NestedWirelessLANSerializer(WritableNestedSerializer):
class Meta:
model = WirelessLAN
fields = ['id', 'url', 'display_url', 'display', 'ssid']