re2o/topologie/api/serializers.py

# -*- mode: python; coding: utf-8 -*-
# Re2o est un logiciel d'administration développé initiallement au rezometz. Il
# se veut agnostique au réseau considéré, de manière à être installable en
# quelques clics.
#
# Copyright © 2019 Arthur Grisel-Davy
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

"""Defines the serializers of the API
"""

from rest_framework import serializers

import topologie.models as topologie

from re2o.serializers import NamespacedHRField, NamespacedHIField, NamespacedHMSerializer

from machines.api.serializer import VlanSerializer

class StackSerializer(NamespacedHMSerializer):
    """Serialize `topologie.models.Stack` objects
    """

    class Meta:
        model = topologie.Stack
        fields = ('name', 'stack_id', 'details', 'member_id_min',
                  'member_id_max', 'api_url')


class AccessPointSerializer(NamespacedHMSerializer):
    """Serialize `topologie.models.AccessPoint` objects
    """

    class Meta:
        model = topologie.AccessPoint
        fields = ('user', 'name', 'active', 'location', 'api_url')


class SwitchSerializer(NamespacedHMSerializer):
    """Serialize `topologie.models.Switch` objects
    """
    port_amount = serializers.IntegerField(source='number')

    class Meta:
        model = topologie.Switch
        fields = ('user', 'name', 'active', 'port_amount', 'stack',
                  'stack_member_id', 'model', 'switchbay', 'api_url')


class ServerSerializer(NamespacedHMSerializer):
    """Serialize `topologie.models.Server` objects
    """

    class Meta:
        model = topologie.Server
        fields = ('user', 'name', 'active', 'api_url')


class ModelSwitchSerializer(NamespacedHMSerializer):
    """Serialize `topologie.models.ModelSwitch` objects
    """

    class Meta:
        model = topologie.ModelSwitch
        fields = ('reference', 'constructor', 'api_url')


class ConstructorSwitchSerializer(NamespacedHMSerializer):
    """Serialize `topologie.models.ConstructorSwitch` objects
    """

    class Meta:
        model = topologie.ConstructorSwitch
        fields = ('name', 'api_url')


class SwitchBaySerializer(NamespacedHMSerializer):
    """Serialize `topologie.models.SwitchBay` objects
    """

    class Meta:
        model = topologie.SwitchBay
        fields = ('name', 'building', 'info', 'api_url')


class BuildingSerializer(NamespacedHMSerializer):
    """Serialize `topologie.models.Building` objects
    """

    class Meta:
        model = topologie.Building
        fields = ('name', 'api_url')


class SwitchPortSerializer(NamespacedHMSerializer):
    """Serialize `topologie.models.Port` objects
    """

    get_port_profile = NamespacedHIField(view_name='portprofile-detail', read_only=True)

    class Meta:
        model = topologie.Port
        fields = ('switch', 'port', 'room', 'machine_interface', 'related',
                  'custom_profile', 'state', 'get_port_profile', 'details', 'api_url')
        extra_kwargs = {
            'related': {'view_name': 'switchport-detail'},
            'api_url': {'view_name': 'switchport-detail'},
        }


class PortProfileSerializer(NamespacedHMSerializer):
    """Serialize `topologie.models.Room` objects
    """
    class Meta:
        model = topologie.PortProfile
        fields = ('name', 'profil_default', 'vlan_untagged', 'vlan_tagged',
                  'radius_type', 'radius_mode', 'speed', 'mac_limit', 'flow_control',
                  'dhcp_snooping', 'dhcpv6_snooping', 'dhcpv6_snooping', 'arp_protect',
                  'ra_guard', 'loop_protect', 'api_url')


class RoomSerializer(NamespacedHMSerializer):
    """Serialize `topologie.models.Room` objects
    """

    class Meta:
        model = topologie.Room
        fields = ('name', 'details', 'api_url')


class PortProfileSerializer(NamespacedHMSerializer):
    vlan_untagged = VlanSerializer(read_only=True)

    class Meta:
        model = topologie.PortProfile
        fields = ('name', 'profil_default', 'vlan_untagged', 'vlan_tagged',
                  'radius_type', 'radius_mode', 'speed', 'mac_limit',
                  'flow_control', 'dhcp_snooping', 'dhcpv6_snooping',
                  'arp_protect', 'ra_guard', 'loop_protect', 'vlan_untagged',
                  'vlan_tagged')

class InterfaceVlanSerializer(NamespacedHMSerializer):
    domain = serializers.CharField(read_only=True)
    ipv4 = serializers.CharField(read_only=True)
    ipv6 = Ipv6ListSerializer(read_only=True, many=True)
    vlan_id = serializers.IntegerField(source='type.ip_type.vlan.vlan_id', read_only=True)

    class Meta:
        model = machines.Interface
        fields = ('ipv4', 'ipv6', 'domain', 'vlan_id')

class InterfaceRoleSerializer(NamespacedHMSerializer):
    interface = InterfaceVlanSerializer(source='machine.interface_set', read_only=True, many=True)

    class Meta:
        model = machines.Interface
        fields = ('interface',)


class RoleSerializer(NamespacedHMSerializer):
    """Serialize `machines.models.OuverturePort` objects.
    """
    servers = InterfaceRoleSerializer(read_only=True, many=True)

    class Meta:
        model = machines.Role
        fields = ('role_type', 'servers', 'specific_role')


class VlanPortSerializer(NamespacedHMSerializer):
    class Meta:
        model = machines.Vlan
        fields = ('vlan_id', 'name')


class ProfilSerializer(NamespacedHMSerializer):
    vlan_untagged = VlanSerializer(read_only=True)
    vlan_tagged = VlanPortSerializer(read_only=True, many=True)

    class Meta:
        model = topologie.PortProfile
        fields = ('name', 'profil_default', 'vlan_untagged', 'vlan_tagged', 'radius_type', 'radius_mode', 'speed', 'mac_limit', 'flow_control', 'dhcp_snooping', 'dhcpv6_snooping', 'arp_protect', 'ra_guard', 'loop_protect', 'vlan_untagged', 'vlan_tagged')


class ModelSwitchSerializer(NamespacedHMSerializer):
    constructor = serializers.CharField(read_only=True)

    class Meta:
        model = topologie.ModelSwitch
        fields = ('reference', 'firmware', 'constructor')


class SwitchBaySerializer(NamespacedHMSerializer):
    class Meta:
        model = topologie.SwitchBay
        fields = ('name',)


class PortsSerializer(NamespacedHMSerializer):
    """Serialize `machines.models.Ipv6List` objects.
    """
    get_port_profile = ProfilSerializer(read_only=True)


    class Meta:
        model = topologie.Port
        fields = ('state', 'port', 'pretty_name', 'get_port_profile')



class SwitchPortSerializer(serializers.ModelSerializer):
    """Serialize the data about the switches"""
    ports = PortsSerializer(many=True, read_only=True)
    model = ModelSwitchSerializer(read_only=True)
    switchbay = SwitchBaySerializer(read_only=True)


    class Meta:
        model = topologie.Switch
        fields = ('short_name', 'model', 'switchbay', 'ports', 'ipv4', 'ipv6',
                  'interfaces_subnet', 'interfaces6_subnet', 'automatic_provision', 'rest_enabled',
                  'web_management_enabled', 'get_radius_key_value', 'get_management_cred_value',
                  'list_modules')