netbox-plugin-dns 0.22.8__py3-none-any.whl → 1.0.0__py3-none-any.whl

netbox_dns/api/serializers_/zone.py

@@ -0,0 +1,159 @@
+from rest_framework import serializers
+
+from netbox.api.serializers import NetBoxModelSerializer
+from tenancy.api.serializers_.tenants 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 netbox_dns.models import Zone
+
+
+class ZoneSerializer(NetBoxModelSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_dns-api:zone-detail"
+    )
+    view = ViewSerializer(
+        nested=True,
+        many=False,
+        read_only=False,
+        required=False,
+        default=None,
+        help_text="View the zone belongs to",
+    )
+    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",
+    )
+    rfc2317_parent_zone = NestedZoneSerializer(
+        many=False,
+        read_only=True,
+        required=False,
+        help_text="RFC2317 arent zone for the zone",
+    )
+    rfc2317_child_zones = NestedZoneSerializer(
+        many=True,
+        read_only=True,
+        required=False,
+        help_text="RFC2317 child zones of the zone",
+    )
+    registrar = RegistrarSerializer(
+        nested=True,
+        many=False,
+        read_only=False,
+        required=False,
+        help_text="The registrar the domain is registered with",
+    )
+    registrant = ContactSerializer(
+        many=False,
+        read_only=False,
+        required=False,
+        help_text="The owner of the domain",
+    )
+    admin_c = ContactSerializer(
+        many=False,
+        read_only=False,
+        required=False,
+        help_text="The administrative contact for the domain",
+    )
+    tech_c = ContactSerializer(
+        many=False,
+        read_only=False,
+        required=False,
+        help_text="The technical contact for the domain",
+    )
+    billing_c = ContactSerializer(
+        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)
+
+        zone = super().create(validated_data)
+
+        if nameservers is not None:
+            zone.nameservers.set(nameservers)
+
+        return zone
+
+    def update(self, instance, validated_data):
+        nameservers = validated_data.pop("nameservers", None)
+
+        zone = super().update(instance, validated_data)
+
+        if nameservers is not None:
+            zone.nameservers.set(nameservers)
+
+        return zone
+
+    class Meta:
+        model = Zone
+        fields = (
+            "id",
+            "url",
+            "name",
+            "view",
+            "display",
+            "nameservers",
+            "status",
+            "description",
+            "tags",
+            "created",
+            "last_updated",
+            "default_ttl",
+            "soa_ttl",
+            "soa_mname",
+            "soa_rname",
+            "soa_serial",
+            "soa_serial_auto",
+            "soa_refresh",
+            "soa_retry",
+            "soa_expire",
+            "soa_minimum",
+            "rfc2317_prefix",
+            "rfc2317_parent_managed",
+            "rfc2317_parent_zone",
+            "rfc2317_child_zones",
+            "registrar",
+            "registry_domain_id",
+            "registrant",
+            "tech_c",
+            "admin_c",
+            "billing_c",
+            "active",
+            "custom_fields",
+            "tenant",
+        )
+        brief_fields = (
+            "id",
+            "url",
+            "name",
+            "view",
+            "display",
+            "status",
+            "description",
+            "rfc2317_prefix",
+            "active",
+        )

netbox_dns/api/views.py

@@ -13,13 +13,13 @@ from netbox_dns.api.serializers import (
     RegistrarSerializer,
     ContactSerializer,
 )
-from netbox_dns.filters import (
-    ViewFilter,
-    ZoneFilter,
-    NameServerFilter,
-    RecordFilter,
-    RegistrarFilter,
-    ContactFilter,
+from netbox_dns.filtersets import (
+    ViewFilterSet,
+    ZoneFilterSet,
+    NameServerFilterSet,
+    RecordFilterSet,
+    RegistrarFilterSet,
+    ContactFilterSet,
 )
 from netbox_dns.models import View, Zone, NameServer, Record, Registrar, Contact
 
@@ -32,7 +32,7 @@ class NetBoxDNSRootView(APIRootView):
 class ViewViewSet(NetBoxModelViewSet):
     queryset = View.objects.all()
     serializer_class = ViewSerializer
-    filterset_class = ViewFilter
+    filterset_class = ViewFilterSet
 
     @action(detail=True, methods=["get"])
     def views(self, request, pk=None):
@@ -51,7 +51,7 @@ class ZoneViewSet(NetBoxModelViewSet):
         "tenant",
     )
     serializer_class = ZoneSerializer
-    filterset_class = ZoneFilter
+    filterset_class = ZoneFilterSet
 
     @action(detail=True, methods=["get"])
     def records(self, request, pk=None):
@@ -71,7 +71,7 @@ class ZoneViewSet(NetBoxModelViewSet):
 class NameServerViewSet(NetBoxModelViewSet):
     queryset = NameServer.objects.prefetch_related("zones", "tenant")
     serializer_class = NameServerSerializer
-    filterset_class = NameServerFilter
+    filterset_class = NameServerFilterSet
 
     @action(detail=True, methods=["get"])
     def zones(self, request, pk=None):
@@ -83,7 +83,7 @@ class NameServerViewSet(NetBoxModelViewSet):
 class RecordViewSet(NetBoxModelViewSet):
     queryset = Record.objects.all().prefetch_related("zone", "zone__view", "tenant")
     serializer_class = RecordSerializer
-    filterset_class = RecordFilter
+    filterset_class = RecordFilterSet
 
     def destroy(self, request, *args, **kwargs):
         v_object = self.get_object()
@@ -105,10 +105,10 @@ class RecordViewSet(NetBoxModelViewSet):
 class RegistrarViewSet(NetBoxModelViewSet):
     queryset = Registrar.objects.all()
     serializer_class = RegistrarSerializer
-    filterset_class = RegistrarFilter
+    filterset_class = RegistrarFilterSet
 
 
 class ContactViewSet(NetBoxModelViewSet):
     queryset = Contact.objects.all()
     serializer_class = ContactSerializer
-    filterset_class = ContactFilter
+    filterset_class = ContactFilterSet

netbox_dns/fields/network.py

@@ -1,6 +1,6 @@
 from django import forms
 from django.db import models
-from django.db.models import Lookup, Transform
+from django.db.models import Lookup, Transform, IntegerField
 from django.core.exceptions import ValidationError
 
 from netaddr import AddrFormatError, IPNetwork
@@ -9,51 +9,51 @@ from netaddr import AddrFormatError, IPNetwork
 class NetContains(Lookup):
     lookup_name = "net_contains"
 
-    def as_sql(self, qn, connection):
-        lhs, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
+    def as_sql(self, compiler, connection):
+        lhs, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
         params = lhs_params + rhs_params
-        return "%s >> %s" % (lhs, rhs), params
+        return f"{lhs} >> {rhs}", params
 
 
 class NetContainsOrEquals(Lookup):
     lookup_name = "net_contains_or_equals"
 
-    def as_sql(self, qn, connection):
-        lhs, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
+    def as_sql(self, compiler, connection):
+        lhs, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
         params = lhs_params + rhs_params
-        return "%s >>= %s" % (lhs, rhs), params
+        return f"{lhs} >>= {rhs}", params
 
 
 class NetContained(Lookup):
     lookup_name = "net_contained"
 
-    def as_sql(self, qn, connection):
-        lhs, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
+    def as_sql(self, compiler, connection):
+        lhs, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
         params = lhs_params + rhs_params
-        return "%s << %s" % (lhs, rhs), params
+        return f"{lhs} << {rhs}", params
 
 
 class NetContainedOrEqual(Lookup):
     lookup_name = "net_contained_or_equal"
 
-    def as_sql(self, qn, connection):
-        lhs, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
+    def as_sql(self, compiler, connection):
+        lhs, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
         params = lhs_params + rhs_params
-        return "%s <<= %s" % (lhs, rhs), params
+        return f"{lhs} <<= {rhs}", params
 
 
 class NetOverlap(Lookup):
     lookup_name = "net_overlap"
 
-    def as_sql(self, qn, connection):
-        lhs, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
+    def as_sql(self, compiler, connection):
+        lhs, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
         params = lhs_params + rhs_params
-        return "%s && %s" % (lhs, rhs), params
+        return f"{lhs} && {rhs}", params
 
 
 class NetworkFormField(forms.Field):
@@ -118,7 +118,6 @@ class NetMaskLength(Transform):
     function = "MASKLEN"
     lookup_name = "net_mask_length"
 
-    @property
     def output_field(self):
         return IntegerField()
 

netbox_dns/fields/rfc2317.py

@@ -18,8 +18,8 @@ class RFC2317NetworkFormField(forms.Field):
         if isinstance(value, IPNetwork):
             if value.version == 4 and value.prefixlen > 24:
                 return value
-            else:
-                raise ValidationError(INVALID_RFC2317)
+
+            raise ValidationError(INVALID_RFC2317)
 
         if len(value.split("/")) != 2:
             raise ValidationError("Please specify the prefix length")
@@ -51,7 +51,7 @@ class RFC2317NetworkField(models.Field):
 
         try:
             ip_network = IPNetwork(value)
-        except (AddressFormatError, TypeError, ValueError) as exc:
+        except (AddrFormatError, TypeError, ValueError) as exc:
             raise ValidationError(exc)
 
         if ip_network.version != 4:

netbox_dns/{filters → filtersets}/contact.py

@@ -5,12 +5,13 @@ from netbox.filtersets import NetBoxModelFilterSet
 from netbox_dns.models import Contact
 
 
-class ContactFilter(NetBoxModelFilterSet):
+class ContactFilterSet(NetBoxModelFilterSet):
     class Meta:
         model = Contact
         fields = (
             "id",
             "name",
+            "description",
             "contact_id",
             "organization",
             "street",

netbox_dns/filtersets/nameserver.py

@@ -0,0 +1,37 @@
+import django_filters
+from django.db.models import Q
+
+from netbox.filtersets import NetBoxModelFilterSet
+from tenancy.filtersets import TenancyFilterSet
+
+from netbox_dns.models import NameServer, Zone
+
+
+class NameServerFilterSet(TenancyFilterSet, NetBoxModelFilterSet):
+    zone_id = django_filters.ModelMultipleChoiceFilter(
+        field_name="zones",
+        queryset=Zone.objects.all(),
+        to_field_name="id",
+        label="Zones",
+    )
+    soa_zone_id = django_filters.ModelMultipleChoiceFilter(
+        method="filter_soa_zones",
+        queryset=Zone.objects.all(),
+        label="SOA Zones",
+    )
+
+    class Meta:
+        model = NameServer
+        fields = ("id", "name", "description")
+
+    def search(self, queryset, name, value):
+        if not value.strip():
+            return queryset
+        qs_filter = Q(name__icontains=value)
+        return queryset.filter(qs_filter)
+
+    def filter_soa_zones(self, queryset, name, value):
+        if not value:
+            return queryset
+        soa_mnames = {zone.soa_mname.pk for zone in value}
+        return queryset.filter(pk__in=soa_mnames)

netbox_dns/{filters → filtersets}/record.py

@@ -1,3 +1,5 @@
+import netaddr
+
 import django_filters
 from django.db.models import Q
 
@@ -5,16 +7,17 @@ from netbox.filtersets import NetBoxModelFilterSet
 from tenancy.filtersets import TenancyFilterSet
 from utilities.filters import MultiValueCharFilter
 
+from ipam.models import IPAddress
+
 from netbox_dns.models import View, Zone, Record, RecordTypeChoices, RecordStatusChoices
 
 
-class RecordFilter(TenancyFilterSet, NetBoxModelFilterSet):
+class RecordFilterSet(TenancyFilterSet, NetBoxModelFilterSet):
     fqdn = MultiValueCharFilter(
         method="filter_fqdn",
     )
     type = django_filters.MultipleChoiceFilter(
         choices=RecordTypeChoices,
-        null_value=None,
     )
     status = django_filters.MultipleChoiceFilter(
         choices=RecordStatusChoices,
@@ -40,20 +43,48 @@ class RecordFilter(TenancyFilterSet, NetBoxModelFilterSet):
         to_field_name="name",
         label="View the Parent Zone belongs to",
     )
+    address_record_id = django_filters.ModelMultipleChoiceFilter(
+        field_name="address_record",
+        queryset=Record.objects.all(),
+        to_field_name="id",
+        label="Address Record",
+    )
+    ptr_record_id = django_filters.ModelMultipleChoiceFilter(
+        field_name="ptr_record",
+        queryset=Record.objects.all(),
+        to_field_name="id",
+        label="Pointer Record",
+    )
+    rfc2317_cname_record_id = django_filters.ModelMultipleChoiceFilter(
+        field_name="rfc2317_cname_record",
+        queryset=Record.objects.all(),
+        to_field_name="id",
+        label="Pointer Record",
+    )
+    ipam_ip_address_id = django_filters.ModelMultipleChoiceFilter(
+        field_name="ipam_ip_address",
+        queryset=IPAddress.objects.all(),
+        to_field_name="id",
+        label="IPAM IP Address",
+    )
+    ip_address = MultiValueCharFilter(
+        method="filter_ip_address",
+        label="IP Address",
+    )
+
     managed = django_filters.BooleanFilter()
 
     class Meta:
         model = Record
         fields = (
             "id",
-            "type",
             "name",
             "fqdn",
+            "description",
+            "ttl",
             "value",
-            "status",
-            "zone",
+            "disable_ptr",
             "managed",
-            "tenant",
         )
 
     def filter_fqdn(self, queryset, name, value):
@@ -68,6 +99,20 @@ class RecordFilter(TenancyFilterSet, NetBoxModelFilterSet):
 
         return queryset.filter(fqdn__in=fqdns)
 
+    def filter_ip_address(self, queryset, name, value):
+        if not value:
+            return queryset
+        try:
+            ip_addresses = [
+                str(netaddr.IPAddress(item)) for item in value if item.strip()
+            ]
+            if not ip_addresses:
+                return queryset
+
+            return queryset.filter(ip_address__in=ip_addresses)
+        except (netaddr.AddrFormatError, ValueError):
+            return queryset.none()
+
     def search(self, queryset, name, value):
         if not value.strip():
             return queryset

netbox_dns/{filters → filtersets}/registrar.py

@@ -5,12 +5,13 @@ from netbox.filtersets import NetBoxModelFilterSet
 from netbox_dns.models import Registrar
 
 
-class RegistrarFilter(NetBoxModelFilterSet):
+class RegistrarFilterSet(NetBoxModelFilterSet):
     class Meta:
         model = Registrar
         fields = (
             "id",
             "name",
+            "description",
             "iana_id",
             "address",
             "referral_url",

netbox_dns/{filters → filtersets}/view.py

@@ -6,10 +6,10 @@ from tenancy.filtersets import TenancyFilterSet
 from netbox_dns.models import View
 
 
-class ViewFilter(NetBoxModelFilterSet, TenancyFilterSet):
+class ViewFilterSet(NetBoxModelFilterSet, TenancyFilterSet):
     class Meta:
         model = View
-        fields = ("id", "name", "tenant")
+        fields = ("id", "name", "default_view", "description")
 
     def search(self, queryset, name, value):
         if not value.strip():