netbox-plugin-dns 0.21.4__py3-none-any.whl → 1.4.7__py3-none-any.whl

netbox_dns/api/serializers_/zone_template.py

@@ -0,0 +1,157 @@
+from django.utils.translation import gettext as _
+from rest_framework import serializers
+
+from netbox.api.serializers import NetBoxModelSerializer
+from tenancy.api.serializers_.tenants import TenantSerializer
+
+from netbox_dns.models import ZoneTemplate
+from netbox_dns.api.nested_serializers import NestedRecordTemplateSerializer
+
+from .nameserver import NameServerSerializer
+from .registrar import RegistrarSerializer
+from .registration_contact import RegistrationContactSerializer
+from .dnssec_policy import DNSSECPolicySerializer
+
+
+__all__ = ("ZoneTemplateSerializer",)
+
+
+class ZoneTemplateSerializer(NetBoxModelSerializer):
+    class Meta:
+        model = ZoneTemplate
+
+        fields = (
+            "id",
+            "url",
+            "name",
+            "description",
+            "tags",
+            "display",
+            "display_url",
+            "nameservers",
+            "soa_mname",
+            "soa_rname",
+            "dnssec_policy",
+            "parental_agents",
+            "registrar",
+            "registrant",
+            "tech_c",
+            "admin_c",
+            "billing_c",
+            "active",
+            "created",
+            "last_updated",
+            "custom_fields",
+            "tenant",
+            "record_templates",
+        )
+
+        brief_fields = (
+            "id",
+            "url",
+            "name",
+            "display",
+            "description",
+        )
+
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_dns-api:zonetemplate-detail"
+    )
+    nameservers = NameServerSerializer(
+        nested=True,
+        many=True,
+        read_only=False,
+        required=False,
+        help_text=_("Nameservers for the zone"),
+    )
+    soa_mname = NameServerSerializer(
+        nested=True,
+        many=False,
+        read_only=False,
+        required=False,
+        help_text=_("Primary nameserver for the zone"),
+    )
+    record_templates = NestedRecordTemplateSerializer(
+        many=True,
+        read_only=False,
+        required=False,
+        help_text=_("Record templates assigned to the zone template"),
+    )
+    dnssec_policy = DNSSECPolicySerializer(
+        nested=True,
+        many=False,
+        read_only=False,
+        required=False,
+        help_text=_("DNSSEC policy assigned to the zone template"),
+    )
+    registrar = RegistrarSerializer(
+        nested=True,
+        many=False,
+        read_only=False,
+        required=False,
+        help_text=_("Registrar the domain is registered with"),
+    )
+    registrant = RegistrationContactSerializer(
+        nested=True,
+        many=False,
+        read_only=False,
+        required=False,
+        help_text=_("Registrant of the domain"),
+    )
+    admin_c = RegistrationContactSerializer(
+        nested=True,
+        many=False,
+        read_only=False,
+        required=False,
+        help_text=_("Administrative contact for the domain"),
+    )
+    tech_c = RegistrationContactSerializer(
+        nested=True,
+        many=False,
+        read_only=False,
+        required=False,
+        help_text=_("Technical contact for the domain"),
+    )
+    billing_c = RegistrationContactSerializer(
+        nested=True,
+        many=False,
+        read_only=False,
+        required=False,
+        help_text=_("Billing contact for the domain"),
+    )
+    active = serializers.BooleanField(
+        required=False,
+        read_only=True,
+        allow_null=True,
+    )
+    tenant = TenantSerializer(
+        nested=True,
+        required=False,
+        allow_null=True,
+    )
+
+    def create(self, validated_data):
+        nameservers = validated_data.pop("nameservers", None)
+        record_templates = validated_data.pop("record_templates", None)
+
+        zone_template = super().create(validated_data)
+
+        if nameservers is not None:
+            zone_template.nameservers.set(nameservers)
+        if record_templates is not None:
+            zone_template.record_templates.set(record_templates)
+
+        return zone_template
+
+    def update(self, instance, validated_data):
+        nameservers = validated_data.pop("nameservers", None)
+        record_templates = validated_data.pop("record_templates", None)
+
+        zone_template = super().update(instance, validated_data)
+
+        if nameservers is not None:
+            zone_template.nameservers.set(nameservers)
+        if record_templates is not None:
+            zone_template.record_templates.set(record_templates)
+
+        return zone_template

netbox_dns/api/urls.py

@@ -7,7 +7,12 @@ from netbox_dns.api.views import (
     NameServerViewSet,
     RecordViewSet,
     RegistrarViewSet,
-    ContactViewSet,
+    RegistrationContactViewSet,
+    ZoneTemplateViewSet,
+    RecordTemplateViewSet,
+    DNSSECKeyTemplateViewSet,
+    DNSSECPolicyViewSet,
+    PrefixViewSet,
 )
 
 router = NetBoxRouter()
@@ -18,6 +23,12 @@ router.register("zones", ZoneViewSet)
 router.register("nameservers", NameServerViewSet)
 router.register("records", RecordViewSet)
 router.register("registrars", RegistrarViewSet)
-router.register("contacts", ContactViewSet)
+router.register("contacts", RegistrationContactViewSet)
+router.register("zonetemplates", ZoneTemplateViewSet)
+router.register("recordtemplates", RecordTemplateViewSet)
+router.register("dnsseckeytemplates", DNSSECKeyTemplateViewSet)
+router.register("dnssecpolicies", DNSSECPolicyViewSet)
+
+router.register("prefixes", PrefixViewSet)
 
 urlpatterns = router.urls

netbox_dns/api/views.py

@@ -1,8 +1,10 @@
+from django.utils.translation import gettext as _
 from rest_framework import serializers
-from rest_framework.decorators import action
-from rest_framework.response import Response
 from rest_framework.routers import APIRootView
 
+from ipam.models import Prefix
+from ipam.filtersets import PrefixFilterSet
+
 from netbox.api.viewsets import NetBoxModelViewSet
 
 from netbox_dns.api.serializers import (
@@ -11,17 +13,37 @@ from netbox_dns.api.serializers import (
     NameServerSerializer,
     RecordSerializer,
     RegistrarSerializer,
-    ContactSerializer,
+    RegistrationContactSerializer,
+    ZoneTemplateSerializer,
+    RecordTemplateSerializer,
+    DNSSECKeyTemplateSerializer,
+    DNSSECPolicySerializer,
+    PrefixSerializer,
+)
+from netbox_dns.filtersets import (
+    ViewFilterSet,
+    ZoneFilterSet,
+    NameServerFilterSet,
+    RecordFilterSet,
+    RegistrarFilterSet,
+    RegistrationContactFilterSet,
+    ZoneTemplateFilterSet,
+    RecordTemplateFilterSet,
+    DNSSECKeyTemplateFilterSet,
+    DNSSECPolicyFilterSet,
 )
-from netbox_dns.filters import (
-    ViewFilter,
-    ZoneFilter,
-    NameServerFilter,
-    RecordFilter,
-    RegistrarFilter,
-    ContactFilter,
+from netbox_dns.models import (
+    View,
+    Zone,
+    NameServer,
+    Record,
+    Registrar,
+    RegistrationContact,
+    ZoneTemplate,
+    RecordTemplate,
+    DNSSECKeyTemplate,
+    DNSSECPolicy,
 )
-from netbox_dns.models import View, Zone, NameServer, Record, Registrar, Contact
 
 
 class NetBoxDNSRootView(APIRootView):
@@ -32,64 +54,41 @@ class NetBoxDNSRootView(APIRootView):
 class ViewViewSet(NetBoxModelViewSet):
     queryset = View.objects.all()
     serializer_class = ViewSerializer
-    filterset_class = ViewFilter
-
-    @action(detail=True, methods=["get"])
-    def views(self, request, pk=None):
-        views = View.objects.filter(zone=pk)
-        serializer = ViewSerializer(views, many=True, context={"request": request})
-        return Response(serializer.data)
+    filterset_class = ViewFilterSet
 
 
 class ZoneViewSet(NetBoxModelViewSet):
-    queryset = Zone.objects.prefetch_related(
-        "view",
-        "nameservers",
-        "tags",
-        "soa_mname",
-        "record_set",
-        "tenant",
-    )
+    queryset = Zone.objects.prefetch_related("view", "nameservers", "soa_mname")
     serializer_class = ZoneSerializer
-    filterset_class = ZoneFilter
-
-    @action(detail=True, methods=["get"])
-    def records(self, request, pk=None):
-        records = Record.objects.filter(zone=pk)
-        serializer = RecordSerializer(records, many=True, context={"request": request})
-        return Response(serializer.data)
-
-    @action(detail=True, methods=["get"])
-    def nameservers(self, request, pk=None):
-        nameservers = NameServer.objects.filter(zones__id=pk)
-        serializer = NameServerSerializer(
-            nameservers, many=True, context={"request": request}
-        )
-        return Response(serializer.data)
+    filterset_class = ZoneFilterSet
 
 
 class NameServerViewSet(NetBoxModelViewSet):
-    queryset = NameServer.objects.prefetch_related("zones", "tenant")
+    queryset = NameServer.objects.prefetch_related("zones")
     serializer_class = NameServerSerializer
-    filterset_class = NameServerFilter
-
-    @action(detail=True, methods=["get"])
-    def zones(self, request, pk=None):
-        zones = Zone.objects.filter(nameservers__id=pk)
-        serializer = ZoneSerializer(zones, many=True, context={"request": request})
-        return Response(serializer.data)
+    filterset_class = NameServerFilterSet
 
 
 class RecordViewSet(NetBoxModelViewSet):
-    queryset = Record.objects.all().prefetch_related("zone", "zone__view", "tenant")
+    queryset = Record.objects.prefetch_related("zone", "zone__view")
     serializer_class = RecordSerializer
-    filterset_class = RecordFilter
+    filterset_class = RecordFilterSet
+
+    def create(self, request, *args, **kwargs):
+        data = request.data
+        if not isinstance(data, list):
+            data = [data]
+
+        if any(record.get("managed") for record in data):
+            raise serializers.ValidationError(_("'managed' is True, refusing create"))
+
+        return super().create(request, *args, **kwargs)
 
     def destroy(self, request, *args, **kwargs):
         v_object = self.get_object()
         if v_object.managed:
             raise serializers.ValidationError(
-                f"{v_object} is managed, refusing deletion"
+                _("{object} is managed, refusing deletion").format(object=v_object)
             )
 
         return super().destroy(request, *args, **kwargs)
@@ -97,7 +96,16 @@ class RecordViewSet(NetBoxModelViewSet):
     def update(self, request, *args, **kwargs):
         v_object = self.get_object()
         if v_object.managed:
-            raise serializers.ValidationError(f"{v_object} is managed, refusing update")
+            raise serializers.ValidationError(
+                _("{object} is managed, refusing update").format(object=v_object)
+            )
+
+        if request.data.get("managed"):
+            raise serializers.ValidationError(
+                _("{object} is unmanaged, refusing update to managed").format(
+                    object=v_object
+                )
+            )
 
         return super().update(request, *args, **kwargs)
 
@@ -105,10 +113,40 @@ class RecordViewSet(NetBoxModelViewSet):
 class RegistrarViewSet(NetBoxModelViewSet):
     queryset = Registrar.objects.all()
     serializer_class = RegistrarSerializer
-    filterset_class = RegistrarFilter
+    filterset_class = RegistrarFilterSet
+
+
+class RegistrationContactViewSet(NetBoxModelViewSet):
+    queryset = RegistrationContact.objects.all()
+    serializer_class = RegistrationContactSerializer
+    filterset_class = RegistrationContactFilterSet
+
+
+class ZoneTemplateViewSet(NetBoxModelViewSet):
+    queryset = ZoneTemplate.objects.all()
+    serializer_class = ZoneTemplateSerializer
+    filterset_class = ZoneTemplateFilterSet
+
+
+class RecordTemplateViewSet(NetBoxModelViewSet):
+    queryset = RecordTemplate.objects.all()
+    serializer_class = RecordTemplateSerializer
+    filterset_class = RecordTemplateFilterSet
+
+
+class DNSSECKeyTemplateViewSet(NetBoxModelViewSet):
+    queryset = DNSSECKeyTemplate.objects.all()
+    serializer_class = DNSSECKeyTemplateSerializer
+    filterset_class = DNSSECKeyTemplateFilterSet
+
+
+class DNSSECPolicyViewSet(NetBoxModelViewSet):
+    queryset = DNSSECPolicy.objects.all()
+    serializer_class = DNSSECPolicySerializer
+    filterset_class = DNSSECPolicyFilterSet
 
 
-class ContactViewSet(NetBoxModelViewSet):
-    queryset = Contact.objects.all()
-    serializer_class = ContactSerializer
-    filterset_class = ContactFilter
+class PrefixViewSet(NetBoxModelViewSet):
+    queryset = Prefix.objects.all()
+    serializer_class = PrefixSerializer
+    filterset_class = PrefixFilterSet

netbox_dns/choices/__init__.py

@@ -0,0 +1,4 @@
+from .record import *
+from .zone import *
+from .dnssec_key_template import *
+from .dnssec_policy import *

netbox_dns/choices/dnssec_key_template.py

@@ -0,0 +1,67 @@
+from dns.dnssectypes import Algorithm
+
+from django.utils.translation import gettext_lazy as _
+
+from utilities.choices import ChoiceSet
+
+from .utilities import initialize_choice_names
+
+DEPRECATED_ALGORITHMS = (
+    Algorithm.RSAMD5,
+    Algorithm.DH,
+    Algorithm.DSA,
+    Algorithm.ECC,
+    Algorithm.RSASHA1,
+    Algorithm.DSANSEC3SHA1,
+    Algorithm.RSASHA1NSEC3SHA1,
+    Algorithm.RSASHA512,
+    Algorithm.ECCGOST,
+)
+
+
+__all__ = (
+    "DNSSECKeyTemplateTypeChoices",
+    "DNSSECKeyTemplateAlgorithmChoices",
+    "DNSSECKeyTemplateKeySizeChoices",
+)
+
+
+class DNSSECKeyTemplateTypeChoices(ChoiceSet):
+    TYPE_CSK = "CSK"
+    TYPE_KSK = "KSK"
+    TYPE_ZSK = "ZSK"
+
+    CHOICES = [
+        (TYPE_CSK, _("CSK"), "purple"),
+        (TYPE_KSK, _("KSK"), "blue"),
+        (TYPE_ZSK, _("ZSK"), "green"),
+    ]
+
+
+class DNSSECKeyTemplateKeySizeChoices(ChoiceSet):
+    SIZE_512 = 512
+    SIZE_1024 = 1024
+    SIZE_2048 = 2048
+    SIZE_3072 = 3072
+    SIZE_4096 = 4096
+
+    CHOICES = [
+        (SIZE_512, 512),
+        (SIZE_1024, 1024),
+        (SIZE_2048, 2048),
+        (SIZE_3072, 3072),
+        (SIZE_4096, 4096),
+    ]
+
+    @classmethod
+    def as_enum(cls):
+        return super().as_enum(prefix="SIZE")
+
+
+@initialize_choice_names
+class DNSSECKeyTemplateAlgorithmChoices(ChoiceSet):
+    CHOICES = [
+        (algorithm.name, f"{algorithm.name} ({algorithm.value})")
+        for algorithm in sorted(Algorithm, key=lambda a: a.value)
+        if algorithm.value < 252 and algorithm not in DEPRECATED_ALGORITHMS
+    ]

netbox_dns/choices/dnssec_policy.py

@@ -0,0 +1,40 @@
+from dns.dnssectypes import DSDigest
+
+from django.utils.translation import gettext_lazy as _
+
+from utilities.choices import ChoiceSet
+
+from .utilities import initialize_choice_names
+
+DEPRECATED_DIGESTS = (
+    DSDigest.NULL,
+    DSDigest.SHA1,
+    DSDigest.GOST,
+)
+
+
+__all__ = (
+    "DNSSECPolicyDigestChoices",
+    "DNSSECPolicyStatusChoices",
+)
+
+
+@initialize_choice_names
+class DNSSECPolicyDigestChoices(ChoiceSet):
+    CHOICES = [
+        (digest.name, digest.name)
+        for digest in sorted(DSDigest, key=lambda a: a.name)
+        if digest not in DEPRECATED_DIGESTS
+    ]
+
+
+class DNSSECPolicyStatusChoices(ChoiceSet):
+    key = "DNSSECPolicy.status"
+
+    STATUS_ACTIVE = "active"
+    STATUS_INACTIVE = "inactive"
+
+    CHOICES = [
+        (STATUS_ACTIVE, _("Active"), "blue"),
+        (STATUS_INACTIVE, _("Inactive"), "red"),
+    ]

netbox_dns/choices/record.py

@@ -0,0 +1,104 @@
+from dns import rdatatype, rdataclass
+
+from django.utils.translation import gettext_lazy as _
+
+from utilities.choices import ChoiceSet
+from netbox.plugins.utils import get_plugin_config
+
+from .utilities import initialize_choice_names
+
+
+__all__ = (
+    "RecordTypeChoices",
+    "RecordSelectableTypeChoices",
+    "RecordClassChoices",
+    "RecordStatusChoices",
+)
+
+
+def _get_config_option(option_name):
+    return list(
+        set(get_plugin_config("netbox_dns", option_name, []))
+        | set(get_plugin_config("netbox_dns", f"{option_name}+", []))
+        - set(get_plugin_config("netbox_dns", f"{option_name}-", []))
+    )
+
+
+class RecordTypeNames:
+    def __init__(self):
+        self.record_type_names = sorted(
+            [
+                rdtype.name
+                for rdtype in rdatatype.RdataType
+                if not rdatatype.is_metatype(rdtype)
+            ]
+            + _get_config_option("custom_record_types")
+        )
+
+    def __iter__(self):
+        for rdtype_name in self.record_type_names:
+            yield rdtype_name
+
+
+class RecordSelectableTypeNames:
+    def __init__(self, exclude_types=[]):
+        self.record_type_names = sorted(
+            [
+                rdtype.name
+                for rdtype in rdatatype.RdataType
+                if not rdatatype.is_metatype(rdtype)
+                and rdtype.name not in _get_config_option("filter_record_types")
+            ]
+            + _get_config_option("custom_record_types")
+        )
+
+    def __iter__(self):
+        for rdtype_name in self.record_type_names:
+            yield rdtype_name
+
+
+class RecordClassNames:
+    def __iter__(self):
+        for rdclass in rdataclass.RdataClass:
+            yield rdclass.name
+
+
+@initialize_choice_names
+class RecordTypeChoices(ChoiceSet):
+    def choices():
+        return RecordTypeNames()
+
+    CHOICES = [(name, name) for name in choices()]
+
+    SINGLETONS = [
+        rdtype.name for rdtype in rdatatype.RdataType if rdatatype.is_singleton(rdtype)
+    ]
+    CUSTOM_TYPES = _get_config_option("custom_record_types")
+
+
+@initialize_choice_names
+class RecordSelectableTypeChoices(ChoiceSet):
+    def choices():
+        return RecordSelectableTypeNames()
+
+    CHOICES = [(name, name) for name in choices()]
+
+
+@initialize_choice_names
+class RecordClassChoices(ChoiceSet):
+    def choices():
+        return RecordClassNames()
+
+    CHOICES = [(name, name) for name in choices()]
+
+
+class RecordStatusChoices(ChoiceSet):
+    key = "Record.status"
+
+    STATUS_ACTIVE = "active"
+    STATUS_INACTIVE = "inactive"
+
+    CHOICES = [
+        (STATUS_ACTIVE, _("Active"), "blue"),
+        (STATUS_INACTIVE, _("Inactive"), "red"),
+    ]

netbox_dns/choices/utilities.py

@@ -0,0 +1,4 @@
+def initialize_choice_names(cls):
+    for choice in cls.CHOICES:
+        setattr(cls, choice[0], choice[0])
+    return cls