class CableSerializer(ValidatedModelSerializer):
termination_a_type = ContentTypeField()
termination_b_type = ContentTypeField()
termination_a = serializers.SerializerMethodField(read_only=True)
termination_b = serializers.SerializerMethodField(read_only=True)
status = ChoiceField(choices=CONNECTION_STATUS_CHOICES, required=False)
length_unit = ChoiceField(choices=CABLE_LENGTH_UNIT_CHOICES, required=False)
class Meta:
model = Cable
fields = [
'id', 'termination_a_type', 'termination_a_id', 'termination_a', 'termination_b_type', 'termination_b_id',
'termination_b', 'type', 'status', 'label', 'color', 'length', 'length_unit',
]
def _get_termination(self, obj, side):
"""
Serialize a nested representation of a termination.
"""
if side.lower() not in ['a', 'b']:
raise ValueError("Termination side must be either A or B.")
termination = getattr(obj, 'termination_{}'.format(side.lower()))
if termination is None:
return None
serializer = get_serializer_for_model(termination, prefix='Nested')
context = {'request': self.context['request']}
data = serializer(termination, context=context).data
return data
def get_termination_a(self, obj):
return self._get_termination(obj, 'a')
def get_termination_b(self, obj):
return self._get_termination(obj, 'b')
class InterfaceSerializer(TaggitSerializer, ValidatedModelSerializer):
virtual_machine = NestedVirtualMachineSerializer()
form_factor = ChoiceField(choices=IFACE_FF_CHOICES,
default=IFACE_FF_VIRTUAL,
required=False)
mode = ChoiceField(choices=IFACE_MODE_CHOICES,
required=False,
allow_null=True)
untagged_vlan = InterfaceVLANSerializer(required=False, allow_null=True)
tagged_vlans = SerializedPKRelatedField(queryset=VLAN.objects.all(),
serializer=InterfaceVLANSerializer,
required=False,
many=True)
tags = TagListSerializerField(required=False)
class Meta:
model = Interface
fields = [
'id',
'virtual_machine',
'name',
'form_factor',
'enabled',
'mtu',
'mac_address',
'description',
'mode',
'untagged_vlan',
'tagged_vlans',
'tags',
]
class InterfaceSerializer(TaggitSerializer, ValidatedModelSerializer):
virtual_machine = NestedVirtualMachineSerializer()
type = ChoiceField(choices=VMInterfaceTypeChoices,
default=VMInterfaceTypeChoices.TYPE_VIRTUAL,
required=False)
mode = ChoiceField(choices=InterfaceModeChoices,
allow_blank=True,
required=False)
untagged_vlan = NestedVLANSerializer(required=False, allow_null=True)
tagged_vlans = SerializedPKRelatedField(queryset=VLAN.objects.all(),
serializer=NestedVLANSerializer,
required=False,
many=True)
tags = TagListSerializerField(required=False)
class Meta:
model = Interface
fields = [
'id',
'virtual_machine',
'name',
'type',
'enabled',
'mtu',
'mac_address',
'description',
'mode',
'untagged_vlan',
'tagged_vlans',
'tags',
]
class RackSerializer(TaggitSerializer, CustomFieldModelSerializer):
site = NestedSiteSerializer()
group = NestedRackGroupSerializer(required=False, allow_null=True)
tenant = NestedTenantSerializer(required=False, allow_null=True)
role = NestedRackRoleSerializer(required=False, allow_null=True)
type = ChoiceField(choices=RACK_TYPE_CHOICES, required=False)
width = ChoiceField(choices=RACK_WIDTH_CHOICES, required=False)
tags = TagListSerializerField(required=False)
class Meta:
model = Rack
fields = [
'id', 'name', 'facility_id', 'display_name', 'site', 'group', 'tenant', 'role', 'serial', 'type', 'width',
'u_height', 'desc_units', 'comments', 'tags', 'custom_fields', 'created', 'last_updated',
]
# Omit the UniqueTogetherValidator that would be automatically added to validate (group, facility_id). This
# prevents facility_id from being interpreted as a required field.
validators = [
UniqueTogetherValidator(queryset=Rack.objects.all(), fields=('group', 'name'))
]
def validate(self, data):
# Validate uniqueness of (group, facility_id) since we omitted the automatically-created validator from Meta.
if data.get('facility_id', None):
validator = UniqueTogetherValidator(queryset=Rack.objects.all(), fields=('group', 'facility_id'))
validator.set_context(self)
validator(data)
# Enforce model validation
super(RackSerializer, self).validate(data)
return data
class PrefixSerializer(TaggedObjectSerializer, CustomFieldModelSerializer):
url = serializers.HyperlinkedIdentityField(
view_name='ipam-api:prefix-detail')
family = ChoiceField(choices=IPAddressFamilyChoices, read_only=True)
site = NestedSiteSerializer(required=False, allow_null=True)
vrf = NestedVRFSerializer(required=False, allow_null=True)
tenant = NestedTenantSerializer(required=False, allow_null=True)
vlan = NestedVLANSerializer(required=False, allow_null=True)
status = ChoiceField(choices=PrefixStatusChoices, required=False)
role = NestedRoleSerializer(required=False, allow_null=True)
class Meta:
model = Prefix
fields = [
'id',
'url',
'family',
'prefix',
'site',
'vrf',
'tenant',
'vlan',
'status',
'role',
'is_pool',
'description',
'tags',
'custom_fields',
'created',
'last_updated',
]
read_only_fields = ['family']
class InterfaceSerializer(TaggitSerializer, ConnectedEndpointSerializer):
device = NestedDeviceSerializer()
form_factor = ChoiceField(choices=IFACE_FF_CHOICES, required=False)
lag = NestedInterfaceSerializer(required=False, allow_null=True)
mode = ChoiceField(choices=IFACE_MODE_CHOICES,
required=False,
allow_null=True)
untagged_vlan = NestedVLANSerializer(required=False, allow_null=True)
tagged_vlans = SerializedPKRelatedField(queryset=VLAN.objects.all(),
serializer=NestedVLANSerializer,
required=False,
many=True)
cable = NestedCableSerializer(read_only=True)
tags = TagListSerializerField(required=False)
class Meta:
model = Interface
fields = [
'id',
'device',
'name',
'form_factor',
'enabled',
'lag',
'mtu',
'mac_address',
'mgmt_only',
'description',
'connected_endpoint_type',
'connected_endpoint',
'connection_status',
'cable',
'mode',
'untagged_vlan',
'tagged_vlans',
'tags',
'count_ipaddresses',
]
# TODO: This validation should be handled by Interface.clean()
def validate(self, data):
# All associated VLANs be global or assigned to the parent device's site.
device = self.instance.device if self.instance else data.get('device')
untagged_vlan = data.get('untagged_vlan')
if untagged_vlan and untagged_vlan.site not in [device.site, None]:
raise serializers.ValidationError({
'untagged_vlan':
"VLAN {} must belong to the same site as the interface's parent device, or it must be "
"global.".format(untagged_vlan)
})
for vlan in data.get('tagged_vlans', []):
if vlan.site not in [device.site, None]:
raise serializers.ValidationError({
'tagged_vlans':
"VLAN {} must belong to the same site as the interface's parent device, or it must "
"be global.".format(vlan)
})
return super().validate(data)
class PowerFeedSerializer(TaggitSerializer, CustomFieldModelSerializer):
power_panel = NestedPowerPanelSerializer()
rack = NestedRackSerializer(
required=False,
allow_null=True,
default=None
)
type = ChoiceField(
choices=POWERFEED_TYPE_CHOICES,
default=POWERFEED_TYPE_PRIMARY
)
status = ChoiceField(
choices=POWERFEED_STATUS_CHOICES,
default=POWERFEED_STATUS_ACTIVE
)
supply = ChoiceField(
choices=POWERFEED_SUPPLY_CHOICES,
default=POWERFEED_SUPPLY_AC
)
phase = ChoiceField(
choices=POWERFEED_PHASE_CHOICES,
default=POWERFEED_PHASE_SINGLE
)
tags = TagListSerializerField(
required=False
)
class Meta:
model = PowerFeed
fields = [
'id', 'power_panel', 'rack', 'name', 'status', 'type', 'supply', 'phase', 'voltage', 'amperage',
'max_utilization', 'comments', 'tags', 'custom_fields', 'created', 'last_updated',
]
class PrefixSerializer(TaggitSerializer, CustomFieldModelSerializer):
family = ChoiceField(choices=IPAddressFamilyChoices, read_only=True)
site = NestedSiteSerializer(required=False, allow_null=True)
vrf = NestedVRFSerializer(required=False, allow_null=True)
tenant = NestedTenantSerializer(required=False, allow_null=True)
vlan = NestedVLANSerializer(required=False, allow_null=True)
status = ChoiceField(choices=PrefixStatusChoices, required=False)
role = NestedRoleSerializer(required=False, allow_null=True)
tags = TagListSerializerField(required=False)
class Meta:
model = Prefix
fields = [
'id',
'family',
'prefix',
'site',
'vrf',
'tenant',
'vlan',
'status',
'role',
'is_pool',
'description',
'tags',
'custom_fields',
'created',
'last_updated',
]
read_only_fields = ['family']
class DeviceTypeSerializer(TaggitSerializer, CustomFieldModelSerializer):
manufacturer = NestedManufacturerSerializer()
interface_ordering = ChoiceField(choices=IFACE_ORDERING_CHOICES,
required=False)
subdevice_role = ChoiceField(choices=SUBDEVICE_ROLE_CHOICES,
required=False)
instance_count = serializers.IntegerField(source='instances.count',
read_only=True)
tags = TagListSerializerField(required=False)
class Meta:
model = DeviceType
fields = [
'id',
'manufacturer',
'model',
'slug',
'part_number',
'u_height',
'is_full_depth',
'interface_ordering',
'is_console_server',
'is_pdu',
'is_network_device',
'subdevice_role',
'comments',
'tags',
'custom_fields',
'created',
'last_updated',
'instance_count',
]
class IPAddressSerializer(TaggitSerializer, CustomFieldModelSerializer):
family = ChoiceField(choices=IPAddressFamilyChoices, read_only=True)
vrf = NestedVRFSerializer(required=False, allow_null=True)
tenant = NestedTenantSerializer(required=False, allow_null=True)
status = ChoiceField(choices=IPAddressStatusChoices, required=False)
role = ChoiceField(choices=IPAddressRoleChoices,
required=False,
allow_null=True)
interface = IPAddressInterfaceSerializer(required=False, allow_null=True)
nat_inside = NestedIPAddressSerializer(required=False, allow_null=True)
nat_outside = NestedIPAddressSerializer(read_only=True)
tags = TagListSerializerField(required=False)
class Meta:
model = IPAddress
fields = [
'id',
'family',
'address',
'vrf',
'tenant',
'status',
'role',
'interface',
'nat_inside',
'nat_outside',
'dns_name',
'description',
'tags',
'custom_fields',
'created',
'last_updated',
]
read_only_fields = ['family']
class PowerOutletSerializer(TaggitSerializer, ConnectedEndpointSerializer):
device = NestedDeviceSerializer()
type = ChoiceField(choices=PowerOutletTypeChoices,
allow_blank=True,
required=False)
power_port = NestedPowerPortSerializer(required=False)
feed_leg = ChoiceField(choices=PowerOutletFeedLegChoices,
allow_blank=True,
required=False)
cable = NestedCableSerializer(read_only=True)
tags = TagListSerializerField(required=False)
class Meta:
model = PowerOutlet
fields = [
'id',
'device',
'name',
'type',
'power_port',
'feed_leg',
'description',
'connected_endpoint_type',
'connected_endpoint',
'connection_status',
'cable',
'tags',
]
class PowerOutletSerializer(TaggedObjectSerializer,
ConnectedEndpointSerializer):
url = serializers.HyperlinkedIdentityField(
view_name='dcim-api:poweroutlet-detail')
device = NestedDeviceSerializer()
type = ChoiceField(choices=PowerOutletTypeChoices,
allow_blank=True,
required=False)
power_port = NestedPowerPortSerializer(required=False)
feed_leg = ChoiceField(choices=PowerOutletFeedLegChoices,
allow_blank=True,
required=False)
cable = NestedCableSerializer(read_only=True)
class Meta:
model = PowerOutlet
fields = [
'id',
'url',
'device',
'name',
'label',
'type',
'power_port',
'feed_leg',
'description',
'connected_endpoint_type',
'connected_endpoint',
'connection_status',
'cable',
'tags',
]
class InterfaceTemplateSerializer(ValidatedModelSerializer):
device_type = NestedDeviceTypeSerializer()
type = ChoiceField(choices=IFACE_TYPE_CHOICES, required=False)
# TODO: Remove in v2.7 (backward-compatibility for form_factor)
form_factor = ChoiceField(choices=IFACE_TYPE_CHOICES, required=False)
class Meta:
model = InterfaceTemplate
fields = ['id', 'device_type', 'name', 'type', 'form_factor', 'mgmt_only']
class CableSerializer(TaggedObjectSerializer, ValidatedModelSerializer):
url = serializers.HyperlinkedIdentityField(
view_name='dcim-api:cable-detail')
termination_a_type = ContentTypeField(
queryset=ContentType.objects.filter(CABLE_TERMINATION_MODELS))
termination_b_type = ContentTypeField(
queryset=ContentType.objects.filter(CABLE_TERMINATION_MODELS))
termination_a = serializers.SerializerMethodField(read_only=True)
termination_b = serializers.SerializerMethodField(read_only=True)
status = ChoiceField(choices=CableStatusChoices, required=False)
length_unit = ChoiceField(choices=CableLengthUnitChoices,
allow_blank=True,
required=False)
class Meta:
model = Cable
fields = [
'id',
'url',
'termination_a_type',
'termination_a_id',
'termination_a',
'termination_b_type',
'termination_b_id',
'termination_b',
'type',
'status',
'label',
'color',
'length',
'length_unit',
'tags',
]
def _get_termination(self, obj, side):
"""
Serialize a nested representation of a termination.
"""
if side.lower() not in ['a', 'b']:
raise ValueError("Termination side must be either A or B.")
termination = getattr(obj, 'termination_{}'.format(side.lower()))
if termination is None:
return None
serializer = get_serializer_for_model(termination, prefix='Nested')
context = {'request': self.context['request']}
data = serializer(termination, context=context).data
return data
@swagger_serializer_method(serializer_or_field=serializers.DictField)
def get_termination_a(self, obj):
return self._get_termination(obj, 'a')
@swagger_serializer_method(serializer_or_field=serializers.DictField)
def get_termination_b(self, obj):
return self._get_termination(obj, 'b')
class IPAddressSerializer(TaggedObjectSerializer, CustomFieldModelSerializer):
url = serializers.HyperlinkedIdentityField(
view_name='ipam-api:ipaddress-detail')
family = ChoiceField(choices=IPAddressFamilyChoices, read_only=True)
vrf = NestedVRFSerializer(required=False, allow_null=True)
tenant = NestedTenantSerializer(required=False, allow_null=True)
status = ChoiceField(choices=IPAddressStatusChoices, required=False)
role = ChoiceField(choices=IPAddressRoleChoices,
allow_blank=True,
required=False)
assigned_object_type = ContentTypeField(
queryset=ContentType.objects.filter(IPADDRESS_ASSIGNMENT_MODELS),
required=False,
allow_null=True)
assigned_object = serializers.SerializerMethodField(read_only=True)
nat_inside = NestedIPAddressSerializer(required=False, allow_null=True)
nat_outside = NestedIPAddressSerializer(read_only=True)
class Meta:
model = IPAddress
fields = [
'id',
'url',
'family',
'address',
'vrf',
'tenant',
'status',
'role',
'assigned_object_type',
'assigned_object_id',
'assigned_object',
'nat_inside',
'nat_outside',
'dns_name',
'description',
'tags',
'custom_fields',
'created',
'last_updated',
]
read_only_fields = ['family']
@swagger_serializer_method(serializer_or_field=serializers.DictField)
def get_assigned_object(self, obj):
if obj.assigned_object is None:
return None
serializer = get_serializer_for_model(obj.assigned_object,
prefix='Nested')
context = {'request': self.context['request']}
return serializer(obj.assigned_object, context=context).data
class DeviceSerializer(TaggitSerializer, CustomFieldModelSerializer):
device_type = NestedDeviceTypeSerializer()
device_role = NestedDeviceRoleSerializer()
tenant = NestedTenantSerializer(required=False, allow_null=True)
platform = NestedPlatformSerializer(required=False, allow_null=True)
site = NestedSiteSerializer()
rack = NestedRackSerializer(required=False, allow_null=True)
face = ChoiceField(choices=RACK_FACE_CHOICES, required=False, allow_null=True)
status = ChoiceField(choices=DEVICE_STATUS_CHOICES, required=False)
primary_ip = NestedIPAddressSerializer(read_only=True)
primary_ip4 = NestedIPAddressSerializer(required=False, allow_null=True)
primary_ip6 = NestedIPAddressSerializer(required=False, allow_null=True)
parent_device = serializers.SerializerMethodField()
cluster = NestedClusterSerializer(required=False, allow_null=True)
virtual_chassis = NestedVirtualChassisSerializer(required=False, allow_null=True)
tags = TagListSerializerField(required=False)
class Meta:
model = Device
fields = [
'id', 'name', 'display_name', 'device_type', 'device_role', 'tenant', 'platform', 'serial', 'asset_tag',
'site', 'rack', 'position', 'face', 'parent_device', 'status', 'primary_ip', 'primary_ip4', 'primary_ip6',
'cluster', 'virtual_chassis', 'vc_position', 'vc_priority', 'comments', 'local_context_data', 'tags',
'custom_fields', 'created', 'last_updated',
]
validators = []
def validate(self, data):
# Validate uniqueness of (rack, position, face) since we omitted the automatically-created validator from Meta.
if data.get('rack') and data.get('position') and data.get('face'):
validator = UniqueTogetherValidator(queryset=Device.objects.all(), fields=('rack', 'position', 'face'))
validator.set_context(self)
validator(data)
# Enforce model validation
super().validate(data)
return data
@swagger_serializer_method(serializer_or_field=NestedDeviceSerializer)
def get_parent_device(self, obj):
try:
device_bay = obj.parent_bay
except DeviceBay.DoesNotExist:
return None
context = {'request': self.context['request']}
data = NestedDeviceSerializer(instance=device_bay.device, context=context).data
data['device_bay'] = NestedDeviceBaySerializer(instance=device_bay, context=context).data
return data
class PowerOutletTemplateSerializer(ValidatedModelSerializer):
device_type = NestedDeviceTypeSerializer()
type = ChoiceField(choices=PowerOutletTypeChoices,
allow_blank=True,
required=False)
power_port = NestedPowerPortTemplateSerializer(required=False)
feed_leg = ChoiceField(choices=PowerOutletFeedLegChoices,
allow_blank=True,
required=False)
class Meta:
model = PowerOutletTemplate
fields = [
'id', 'device_type', 'name', 'type', 'power_port', 'feed_leg'
]
class VLANSerializer(TaggitSerializer, CustomFieldModelSerializer):
site = NestedSiteSerializer(required=False, allow_null=True)
group = NestedVLANGroupSerializer(required=False, allow_null=True)
tenant = NestedTenantSerializer(required=False, allow_null=True)
status = ChoiceField(choices=VLAN_STATUS_CHOICES, required=False)
role = NestedRoleSerializer(required=False, allow_null=True)
tags = TagListSerializerField(required=False)
class Meta:
model = VLAN
fields = [
'id', 'site', 'group', 'vid', 'name', 'tenant', 'status', 'role', 'description', 'tags', 'display_name',
'custom_fields', 'created', 'last_updated',
]
validators = []
def validate(self, data):
# Validate uniqueness of vid and name if a group has been assigned.
if data.get('group', None):
for field in ['vid', 'name']:
validator = UniqueTogetherValidator(queryset=VLAN.objects.all(), fields=('group', field))
validator.set_context(self)
validator(data)
# Enforce model validation
super(VLANSerializer, self).validate(data)
return data
class ServiceSerializer(CustomFieldModelSerializer):
device = NestedDeviceSerializer(required=False, allow_null=True)
virtual_machine = NestedVirtualMachineSerializer(required=False,
allow_null=True)
protocol = ChoiceField(choices=ServiceProtocolChoices)
ipaddresses = SerializedPKRelatedField(
queryset=IPAddress.objects.all(),
serializer=NestedIPAddressSerializer,
required=False,
many=True)
class Meta:
model = Service
fields = [
'id',
'device',
'virtual_machine',
'name',
'port',
'protocol',
'ipaddresses',
'description',
'custom_fields',
'created',
'last_updated',
]
class VirtualMachineSerializer(TaggitSerializer, CustomFieldModelSerializer):
status = ChoiceField(choices=VM_STATUS_CHOICES, required=False)
cluster = NestedClusterSerializer(required=False, allow_null=True)
role = NestedDeviceRoleSerializer(required=False, allow_null=True)
tenant = NestedTenantSerializer(required=False, allow_null=True)
platform = NestedPlatformSerializer(required=False, allow_null=True)
primary_ip = VirtualMachineIPAddressSerializer(read_only=True)
primary_ip4 = VirtualMachineIPAddressSerializer(required=False,
allow_null=True)
primary_ip6 = VirtualMachineIPAddressSerializer(required=False,
allow_null=True)
tags = TagListSerializerField(required=False)
class Meta:
model = VirtualMachine
fields = [
'id',
'name',
'status',
'cluster',
'role',
'tenant',
'platform',
'primary_ip',
'primary_ip4',
'primary_ip6',
'vcpus',
'memory',
'disk',
'comments',
'tags',
'custom_fields',
'created',
'last_updated',
]
class CircuitSerializer(TaggitSerializer, CustomFieldModelSerializer):
provider = NestedProviderSerializer()
status = ChoiceField(choices=CIRCUIT_STATUS_CHOICES, required=False)
type = NestedCircuitTypeSerializer()
tenant = NestedTenantSerializer(required=False, allow_null=True)
tags = TagListSerializerField(required=False)
class Meta:
model = Circuit
fields = [
'id',
'cid',
'provider',
'type',
'status',
'tenant',
'install_date',
'commit_rate',
'description',
'comments',
'tags',
'custom_fields',
'created',
'last_updated',
]
class ConnectedEndpointSerializer(ValidatedModelSerializer):
connected_endpoint_type = serializers.SerializerMethodField(read_only=True)
connected_endpoint = serializers.SerializerMethodField(read_only=True)
connection_status = ChoiceField(choices=CONNECTION_STATUS_CHOICES, read_only=True)
def get_connected_endpoint_type(self, obj):
if hasattr(obj, 'connected_endpoint') and obj.connected_endpoint is not None:
return '{}.{}'.format(
obj.connected_endpoint._meta.app_label,
obj.connected_endpoint._meta.model_name
)
return None
@swagger_serializer_method(serializer_or_field=serializers.DictField)
def get_connected_endpoint(self, obj):
"""
Return the appropriate serializer for the type of connected object.
"""
if getattr(obj, 'connected_endpoint', None) is None:
return None
serializer = get_serializer_for_model(obj.connected_endpoint, prefix='Nested')
context = {'request': self.context['request']}
data = serializer(obj.connected_endpoint, context=context).data
return data
class RearPortTemplateSerializer(ValidatedModelSerializer):
device_type = NestedDeviceTypeSerializer()
type = ChoiceField(choices=PORT_TYPE_CHOICES)
class Meta:
model = RearPortTemplate
fields = ['id', 'device_type', 'name', 'type', 'positions']
class ServiceSerializer(TaggedObjectSerializer, CustomFieldModelSerializer):
url = serializers.HyperlinkedIdentityField(
view_name='ipam-api:service-detail')
device = NestedDeviceSerializer(required=False, allow_null=True)
virtual_machine = NestedVirtualMachineSerializer(required=False,
allow_null=True)
protocol = ChoiceField(choices=ServiceProtocolChoices, required=False)
ipaddresses = SerializedPKRelatedField(
queryset=IPAddress.objects.all(),
serializer=NestedIPAddressSerializer,
required=False,
many=True)
class Meta:
model = Service
fields = [
'id',
'url',
'device',
'virtual_machine',
'name',
'port',
'protocol',
'ipaddresses',
'description',
'tags',
'custom_fields',
'created',
'last_updated',
]
class DeviceTypeSerializer(TaggitSerializer, CustomFieldModelSerializer):
manufacturer = NestedManufacturerSerializer()
subdevice_role = ChoiceField(choices=SubdeviceRoleChoices,
allow_blank=True,
required=False)
tags = TagListSerializerField(required=False)
device_count = serializers.IntegerField(read_only=True)
class Meta:
model = DeviceType
fields = [
'id',
'manufacturer',
'model',
'slug',
'display_name',
'part_number',
'u_height',
'is_full_depth',
'subdevice_role',
'front_image',
'rear_image',
'comments',
'tags',
'custom_fields',
'created',
'last_updated',
'device_count',
]
class DeviceTypeSerializer(TaggitSerializer, CustomFieldModelSerializer):
manufacturer = NestedManufacturerSerializer()
subdevice_role = ChoiceField(choices=SUBDEVICE_ROLE_CHOICES,
required=False,
allow_null=True)
instance_count = serializers.IntegerField(source='instances.count',
read_only=True)
tags = TagListSerializerField(required=False)
class Meta:
model = DeviceType
fields = [
'id',
'manufacturer',
'model',
'slug',
'display_name',
'part_number',
'u_height',
'is_full_depth',
'subdevice_role',
'comments',
'tags',
'custom_fields',
'created',
'last_updated',
'instance_count',
]
class VMInterfaceSerializer(TaggedObjectSerializer, ValidatedModelSerializer):
url = serializers.HyperlinkedIdentityField(
view_name='virtualization-api:vminterface-detail')
virtual_machine = NestedVirtualMachineSerializer()
mode = ChoiceField(choices=InterfaceModeChoices,
allow_blank=True,
required=False)
untagged_vlan = NestedVLANSerializer(required=False, allow_null=True)
tagged_vlans = SerializedPKRelatedField(queryset=VLAN.objects.all(),
serializer=NestedVLANSerializer,
required=False,
many=True)
class Meta:
model = VMInterface
fields = [
'id',
'url',
'virtual_machine',
'name',
'enabled',
'mtu',
'mac_address',
'description',
'mode',
'untagged_vlan',
'tagged_vlans',
'tags',
]
class InterfaceTemplateSerializer(ValidatedModelSerializer):
device_type = NestedDeviceTypeSerializer()
type = ChoiceField(choices=InterfaceTypeChoices)
class Meta:
model = InterfaceTemplate
fields = ['id', 'device_type', 'name', 'type', 'mgmt_only']
class InterfaceTemplateSerializer(ValidatedModelSerializer):
device_type = NestedDeviceTypeSerializer()
form_factor = ChoiceField(choices=IFACE_FF_CHOICES, required=False)
class Meta:
model = InterfaceTemplate
fields = ['id', 'device_type', 'name', 'form_factor', 'mgmt_only']
class ConsolePortSerializer(TaggedObjectSerializer,
ConnectedEndpointSerializer):
url = serializers.HyperlinkedIdentityField(
view_name='dcim-api:consoleport-detail')
device = NestedDeviceSerializer()
type = ChoiceField(choices=ConsolePortTypeChoices,
allow_blank=True,
required=False)
cable = NestedCableSerializer(read_only=True)
class Meta:
model = ConsolePort
fields = [
'id',
'url',
'device',
'name',
'label',
'type',
'description',
'connected_endpoint_type',
'connected_endpoint',
'connection_status',
'cable',
'tags',
]
