netbox-plugin-dns 1.0.3__py3-none-any.whl → 1.0.5__py3-none-any.whl

netbox_dns/__init__.py

@@ -1,6 +1,6 @@
 from netbox.plugins import PluginConfig
 
-__version__ = "1.0.3"
+__version__ = "1.0.5"
 
 
 class DNSConfig(PluginConfig):

netbox_dns/api/nested_serializers.py

@@ -2,10 +2,18 @@ from rest_framework import serializers
 
 from netbox.api.serializers import WritableNestedSerializer
 
-from netbox_dns.models import Zone, Record
+from netbox_dns.models import Zone, Record, ZoneTemplate, RecordTemplate
 from netbox_dns.api.serializers_.view import ViewSerializer
 
 
+__ALL__ = (
+    "NestedZoneSerializer",
+    "NestedRecordSerializer",
+    "NestedZoneTemplateSerializer",
+    "NestedRecordTemplateSerializer",
+)
+
+
 class NestedZoneSerializer(WritableNestedSerializer):
     def to_representation(self, instance):
         # +
@@ -80,3 +88,40 @@ class NestedRecordSerializer(WritableNestedSerializer):
             "zone",
             "active",
         ]
+
+
+class NestedRecordTemplateSerializer(WritableNestedSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_dns-api:recordtemplate-detail"
+    )
+
+    class Meta:
+        model = RecordTemplate
+        fields = (
+            "id",
+            "url",
+            "display",
+            "type",
+            "name",
+            "record_name",
+            "value",
+            "status",
+            "ttl",
+            "description",
+        )
+
+
+class NestedZoneTemplateSerializer(WritableNestedSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_dns-api:zonetemplate-detail"
+    )
+
+    class Meta:
+        model = ZoneTemplate
+        fields = (
+            "id",
+            "url",
+            "name",
+            "display",
+            "description",
+        )

netbox_dns/api/serializers.py

@@ -4,5 +4,7 @@ from .serializers_.record import *
 from .serializers_.registrar import *
 from .serializers_.view import *
 from .serializers_.zone import *
+from .serializers_.zone_template import *
+from .serializers_.record_template import *
 
 from .nested_serializers import *

netbox_dns/api/serializers_/contact.py

@@ -5,6 +5,9 @@ from netbox.api.serializers import NetBoxModelSerializer
 from netbox_dns.models import Contact
 
 
+__ALL__ = ("ContactSerializer",)
+
+
 class ContactSerializer(NetBoxModelSerializer):
     url = serializers.HyperlinkedIdentityField(
         view_name="plugins-api:netbox_dns-api:contact-detail"

netbox_dns/api/serializers_/nameserver.py

@@ -5,7 +5,10 @@ from tenancy.api.serializers_.tenants import TenantSerializer
 
 from netbox_dns.models import NameServer
 
-from netbox_dns.api.nested_serializers import NestedZoneSerializer
+from ..nested_serializers import NestedZoneSerializer
+
+
+__ALL__ = ("NameServerSerializer",)
 
 
 class NameServerSerializer(NetBoxModelSerializer):

netbox_dns/api/serializers_/record.py

@@ -5,10 +5,11 @@ from ipam.api.serializers import IPAddressSerializer
 from tenancy.api.serializers import TenantSerializer
 
 from netbox_dns.models import Record
-from netbox_dns.api.nested_serializers import (
-    NestedZoneSerializer,
-    NestedRecordSerializer,
-)
+
+from ..nested_serializers import NestedZoneSerializer, NestedRecordSerializer
+
+
+__ALL__ = ("RecordSerializer",)
 
 
 class RecordSerializer(NetBoxModelSerializer):

netbox_dns/api/serializers_/record_template.py

@@ -0,0 +1,57 @@
+from rest_framework import serializers
+
+from netbox.api.serializers import NetBoxModelSerializer
+from tenancy.api.serializers import TenantSerializer
+
+from netbox_dns.models import RecordTemplate
+
+from ..nested_serializers import NestedZoneTemplateSerializer
+
+__ALL__ = ("RecordTemplateSerializer",)
+
+
+class RecordTemplateSerializer(NetBoxModelSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_dns-api:recordtemplate-detail"
+    )
+    tenant = TenantSerializer(nested=True, required=False, allow_null=True)
+    zone_templates = NestedZoneTemplateSerializer(
+        many=True,
+        read_only=True,
+        required=False,
+        help_text="Zone templates using the record template",
+    )
+
+    class Meta:
+        model = RecordTemplate
+        fields = (
+            "id",
+            "url",
+            "display",
+            "type",
+            "name",
+            "record_name",
+            "value",
+            "status",
+            "ttl",
+            "description",
+            "tags",
+            "created",
+            "last_updated",
+            "disable_ptr",
+            "custom_fields",
+            "tenant",
+            "zone_templates",
+        )
+        brief_fields = (
+            "id",
+            "url",
+            "display",
+            "type",
+            "name",
+            "record_name",
+            "value",
+            "status",
+            "ttl",
+            "description",
+        )

netbox_dns/api/serializers_/registrar.py

@@ -5,6 +5,9 @@ from netbox.api.serializers import NetBoxModelSerializer
 from netbox_dns.models import Registrar
 
 
+__ALL__ = ("RegistrarSerializer",)
+
+
 class RegistrarSerializer(NetBoxModelSerializer):
     url = serializers.HyperlinkedIdentityField(
         view_name="plugins-api:netbox_dns-api:registrar-detail"

netbox_dns/api/serializers_/view.py

@@ -6,6 +6,9 @@ from tenancy.api.serializers_.tenants import TenantSerializer
 from netbox_dns.models import View
 
 
+__ALL__ = ("ViewSerializer",)
+
+
 class ViewSerializer(NetBoxModelSerializer):
     url = serializers.HyperlinkedIdentityField(
         view_name="plugins-api:netbox_dns-api:view-detail"

netbox_dns/api/serializers_/zone.py

@@ -1,16 +1,20 @@
 from rest_framework import serializers
 
 from netbox.api.serializers import NetBoxModelSerializer
-from tenancy.api.serializers_.tenants import TenantSerializer
+from tenancy.api.serializers import TenantSerializer
 
-from netbox_dns.api.serializers_.view import ViewSerializer
-from netbox_dns.api.serializers_.nameserver import NameServerSerializer
-from netbox_dns.api.serializers_.registrar import RegistrarSerializer
-from netbox_dns.api.serializers_.contact import ContactSerializer
-from netbox_dns.api.nested_serializers import NestedZoneSerializer
+from .view import ViewSerializer
+from .nameserver import NameServerSerializer
+from .registrar import RegistrarSerializer
+from .contact import ContactSerializer
+from .zone_template import ZoneTemplateSerializer
+
+from ..nested_serializers import NestedZoneSerializer
 
 from netbox_dns.models import Zone
 
+__ALL__ = ("NameServerSerializer",)
+
 
 class ZoneSerializer(NetBoxModelSerializer):
     url = serializers.HyperlinkedIdentityField(
@@ -58,29 +62,40 @@ class ZoneSerializer(NetBoxModelSerializer):
         help_text="The registrar the domain is registered with",
     )
     registrant = ContactSerializer(
+        nested=True,
         many=False,
         read_only=False,
         required=False,
         help_text="The owner of the domain",
     )
     admin_c = ContactSerializer(
+        nested=True,
         many=False,
         read_only=False,
         required=False,
         help_text="The administrative contact for the domain",
     )
     tech_c = ContactSerializer(
+        nested=True,
         many=False,
         read_only=False,
         required=False,
         help_text="The technical contact for the domain",
     )
     billing_c = ContactSerializer(
+        nested=True,
         many=False,
         read_only=False,
         required=False,
         help_text="The billing contact for the domain",
     )
+    template = ZoneTemplateSerializer(
+        nested=True,
+        write_only=True,
+        required=False,
+        default=None,
+        help_text="Template to apply to the zone",
+    )
     active = serializers.BooleanField(
         required=False,
         read_only=True,
@@ -89,6 +104,7 @@ class ZoneSerializer(NetBoxModelSerializer):
     tenant = TenantSerializer(nested=True, required=False, allow_null=True)
 
     def create(self, validated_data):
+        template = validated_data.pop("template", None)
         nameservers = validated_data.pop("nameservers", None)
 
         zone = super().create(validated_data)
@@ -96,9 +112,13 @@ class ZoneSerializer(NetBoxModelSerializer):
         if nameservers is not None:
             zone.nameservers.set(nameservers)
 
+        if template is not None:
+            template.apply_to_zone(zone)
+
         return zone
 
     def update(self, instance, validated_data):
+        template = validated_data.pop("template", None)
         nameservers = validated_data.pop("nameservers", None)
 
         zone = super().update(instance, validated_data)
@@ -106,6 +126,9 @@ class ZoneSerializer(NetBoxModelSerializer):
         if nameservers is not None:
             zone.nameservers.set(nameservers)
 
+        if template is not None:
+            template.apply_to_zone(zone)
+
         return zone
 
     class Meta:
@@ -145,6 +168,7 @@ class ZoneSerializer(NetBoxModelSerializer):
             "active",
             "custom_fields",
             "tenant",
+            "template",
         )
         brief_fields = (
             "id",

netbox_dns/api/serializers_/zone_template.py

@@ -0,0 +1,129 @@
+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 .contact import ContactSerializer
+
+__ALL__ = ("ZoneTemplateSerializer",)
+
+
+class ZoneTemplateSerializer(NetBoxModelSerializer):
+    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",
+    )
+    record_templates = NestedRecordTemplateSerializer(
+        many=True,
+        read_only=False,
+        required=False,
+        help_text="Record templates assigned to the zone",
+    )
+    registrar = RegistrarSerializer(
+        nested=True,
+        many=False,
+        read_only=False,
+        required=False,
+        help_text="The registrar the domain is registered with",
+    )
+    registrant = ContactSerializer(
+        nested=True,
+        many=False,
+        read_only=False,
+        required=False,
+        help_text="The owner of the domain",
+    )
+    admin_c = ContactSerializer(
+        nested=True,
+        many=False,
+        read_only=False,
+        required=False,
+        help_text="The administrative contact for the domain",
+    )
+    tech_c = ContactSerializer(
+        nested=True,
+        many=False,
+        read_only=False,
+        required=False,
+        help_text="The technical contact for the domain",
+    )
+    billing_c = ContactSerializer(
+        nested=True,
+        many=False,
+        read_only=False,
+        required=False,
+        help_text="The 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
+
+    class Meta:
+        model = ZoneTemplate
+        fields = (
+            "id",
+            "url",
+            "name",
+            "display",
+            "nameservers",
+            "description",
+            "tags",
+            "created",
+            "last_updated",
+            "registrar",
+            "registrant",
+            "tech_c",
+            "admin_c",
+            "billing_c",
+            "active",
+            "custom_fields",
+            "tenant",
+            "record_templates",
+        )
+        brief_fields = (
+            "id",
+            "url",
+            "name",
+            "display",
+            "description",
+        )

netbox_dns/api/urls.py

@@ -8,6 +8,8 @@ from netbox_dns.api.views import (
     RecordViewSet,
     RegistrarViewSet,
     ContactViewSet,
+    ZoneTemplateViewSet,
+    RecordTemplateViewSet,
 )
 
 router = NetBoxRouter()
@@ -19,5 +21,7 @@ router.register("nameservers", NameServerViewSet)
 router.register("records", RecordViewSet)
 router.register("registrars", RegistrarViewSet)
 router.register("contacts", ContactViewSet)
+router.register("zonetemplates", ZoneTemplateViewSet)
+router.register("recordtemplates", RecordTemplateViewSet)
 
 urlpatterns = router.urls

netbox_dns/api/views.py

@@ -12,6 +12,8 @@ from netbox_dns.api.serializers import (
     RecordSerializer,
     RegistrarSerializer,
     ContactSerializer,
+    ZoneTemplateSerializer,
+    RecordTemplateSerializer,
 )
 from netbox_dns.filtersets import (
     ViewFilterSet,
@@ -20,8 +22,19 @@ from netbox_dns.filtersets import (
     RecordFilterSet,
     RegistrarFilterSet,
     ContactFilterSet,
+    ZoneTemplateFilterSet,
+    RecordTemplateFilterSet,
+)
+from netbox_dns.models import (
+    View,
+    Zone,
+    NameServer,
+    Record,
+    Registrar,
+    Contact,
+    ZoneTemplate,
+    RecordTemplate,
 )
-from netbox_dns.models import View, Zone, NameServer, Record, Registrar, Contact
 
 
 class NetBoxDNSRootView(APIRootView):
@@ -85,6 +98,16 @@ class RecordViewSet(NetBoxModelViewSet):
     serializer_class = RecordSerializer
     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:
@@ -99,6 +122,11 @@ class RecordViewSet(NetBoxModelViewSet):
         if v_object.managed:
             raise serializers.ValidationError(f"{v_object} is managed, refusing update")
 
+        if request.data.get("managed"):
+            raise serializers.ValidationError(
+                f"{v_object} is unmanaged, refusing update to managed"
+            )
+
         return super().update(request, *args, **kwargs)
 
 
@@ -112,3 +140,15 @@ class ContactViewSet(NetBoxModelViewSet):
     queryset = Contact.objects.all()
     serializer_class = ContactSerializer
     filterset_class = ContactFilterSet
+
+
+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

netbox_dns/choices/__init__.py

@@ -0,0 +1,2 @@
+from .record import *
+from .zone import *

netbox_dns/choices/record.py

@@ -0,0 +1,49 @@
+from dns import rdatatype, rdataclass
+
+from utilities.choices import ChoiceSet
+
+
+def initialize_choice_names(cls):
+    for choice in cls.CHOICES:
+        setattr(cls, choice[0], choice[0])
+    return cls
+
+
+__ALL__ = (
+    "RecordTypeChoices",
+    "RecordClassChoices",
+    "RecordStatusChoices",
+)
+
+
+@initialize_choice_names
+class RecordTypeChoices(ChoiceSet):
+    CHOICES = [
+        (rdtype.name, rdtype.name)
+        for rdtype in sorted(rdatatype.RdataType, key=lambda a: a.name)
+        if not rdatatype.is_metatype(rdtype)
+    ]
+    SINGLETONS = [
+        rdtype.name for rdtype in rdatatype.RdataType if rdatatype.is_singleton(rdtype)
+    ]
+
+
+@initialize_choice_names
+class RecordClassChoices(ChoiceSet):
+    CHOICES = [
+        (rdclass.name, rdclass.name)
+        for rdclass in sorted(rdataclass.RdataClass)
+        if not rdataclass.is_metaclass(rdclass)
+    ]
+
+
+class RecordStatusChoices(ChoiceSet):
+    key = "Record.status"
+
+    STATUS_ACTIVE = "active"
+    STATUS_INACTIVE = "inactive"
+
+    CHOICES = [
+        (STATUS_ACTIVE, "Active", "blue"),
+        (STATUS_INACTIVE, "Inactive", "red"),
+    ]

netbox_dns/choices/zone.py

@@ -0,0 +1,20 @@
+from utilities.choices import ChoiceSet
+
+
+__ALL__ = ("ZoneStatusChoices",)
+
+
+class ZoneStatusChoices(ChoiceSet):
+    key = "Zone.status"
+
+    STATUS_ACTIVE = "active"
+    STATUS_RESERVED = "reserved"
+    STATUS_DEPRECATED = "deprecated"
+    STATUS_PARKED = "parked"
+
+    CHOICES = [
+        (STATUS_ACTIVE, "Active", "blue"),
+        (STATUS_RESERVED, "Reserved", "cyan"),
+        (STATUS_DEPRECATED, "Deprecated", "red"),
+        (STATUS_PARKED, "Parked", "gray"),
+    ]

netbox_dns/fields/address.py

@@ -5,6 +5,12 @@ from django.core.exceptions import ValidationError
 from netaddr import AddrFormatError, IPAddress
 
 
+__ALL__ = (
+    "AddressFormField",
+    "AddressField",
+)
+
+
 class AddressFormField(forms.Field):
     def to_python(self, value):
         if not value:

netbox_dns/fields/network.py

@@ -6,6 +6,9 @@ from django.core.exceptions import ValidationError
 from netaddr import AddrFormatError, IPNetwork
 
 
+__ALL__ = ()
+
+
 class NetContains(Lookup):
     lookup_name = "net_contains"
 

netbox_dns/fields/rfc2317.py

@@ -10,6 +10,9 @@ from .network import NetContains, NetContained, NetOverlap, NetMaskLength
 INVALID_RFC2317 = "RFC2317 requires an IPv4 prefix with a length of at least 25 bits."
 
 
+__ALL__ = ()
+
+
 class RFC2317NetworkFormField(forms.Field):
     def to_python(self, value):
         if not value:

netbox_dns/filtersets/__init__.py

@@ -4,3 +4,6 @@ from .nameserver import *
 from .record import *
 from .contact import *
 from .registrar import *
+
+from .zone_template import *
+from .record_template import *

netbox_dns/filtersets/contact.py

@@ -5,6 +5,9 @@ from netbox.filtersets import NetBoxModelFilterSet
 from netbox_dns.models import Contact
 
 
+__ALL__ = ("ContactFilterSet",)
+
+
 class ContactFilterSet(NetBoxModelFilterSet):
     class Meta:
         model = Contact

netbox_dns/filtersets/nameserver.py

@@ -7,6 +7,9 @@ from tenancy.filtersets import TenancyFilterSet
 from netbox_dns.models import NameServer, Zone
 
 
+__ALL__ = ("NameServerFilterSet",)
+
+
 class NameServerFilterSet(TenancyFilterSet, NetBoxModelFilterSet):
     zone_id = django_filters.ModelMultipleChoiceFilter(
         field_name="zones",

netbox_dns/filtersets/record.py

@@ -9,7 +9,11 @@ from utilities.filters import MultiValueCharFilter
 
 from ipam.models import IPAddress
 
-from netbox_dns.models import View, Zone, Record, RecordTypeChoices, RecordStatusChoices
+from netbox_dns.models import View, Zone, Record
+from netbox_dns.choices import RecordTypeChoices, RecordStatusChoices
+
+
+__ALL__ = ("RecordFilterSet",)
 
 
 class RecordFilterSet(TenancyFilterSet, NetBoxModelFilterSet):