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

netbox_dns/views/record.py

@@ -1,41 +1,136 @@
 from dns import name as dns_name
 
+from django.utils.translation import gettext_lazy as _
+
 from netbox.views import generic
+from utilities.views import register_model_view
 
-from netbox_dns.filters import RecordFilter
+from netbox_dns.filtersets import RecordFilterSet
 from netbox_dns.forms import (
     RecordImportForm,
     RecordFilterForm,
     RecordForm,
     RecordBulkEditForm,
 )
-from netbox_dns.models import Record
-from netbox_dns.tables import RecordTable, ManagedRecordTable
-from netbox_dns.utilities import value_to_unicode
+from netbox_dns.models import Record, Zone
+from netbox_dns.choices import RecordTypeChoices
+from netbox_dns.tables import RecordTable, ManagedRecordTable, RelatedRecordTable
+from netbox_dns.utilities import (
+    value_to_unicode,
+    get_parent_zone_names,
+    regex_from_list,
+)
+
+
+__all__ = (
+    "RecordView",
+    "RecordListView",
+    "RecordEditView",
+    "RecordDeleteView",
+    "RecordBulkImportView",
+    "RecordBulkEditView",
+    "RecordBulkDeleteView",
+    "ManagedRecordListView",
+)
 
 
+class CNAMEWarning(Exception):
+    pass
+
+
+@register_model_view(Record, "list", path="", detail=False)
 class RecordListView(generic.ObjectListView):
     queryset = Record.objects.filter(managed=False).prefetch_related(
         "zone", "ptr_record"
     )
-    filterset = RecordFilter
+    filterset = RecordFilterSet
     filterset_form = RecordFilterForm
     table = RecordTable
 
 
+@register_model_view(Record, "list_managed", path="managed", detail=False)
 class ManagedRecordListView(generic.ObjectListView):
     queryset = Record.objects.filter(managed=True).prefetch_related(
-        "zone", "address_record"
+        "ipam_ip_address", "address_records"
     )
-    filterset = RecordFilter
+    filterset = RecordFilterSet
     filterset_form = RecordFilterForm
     table = ManagedRecordTable
-    actions = ("export",)
+    actions = {"export": {"view"}}
     template_name = "netbox_dns/record/managed.html"
 
 
+@register_model_view(Record)
 class RecordView(generic.ObjectView):
-    queryset = Record.objects.all().prefetch_related("zone", "ptr_record")
+    queryset = Record.objects.prefetch_related("zone", "ptr_record")
+
+    def get_value_records(self, instance):
+        value_fqdn = dns_name.from_text(instance.value_fqdn)
+
+        cname_targets = Record.objects.filter(
+            zone__view=instance.zone.view,
+            fqdn=value_fqdn,
+            active=True,
+        )
+
+        if cname_targets:
+            return RelatedRecordTable(
+                data=cname_targets,
+            )
+
+        if instance.zone.view.zones.filter(
+            name__iregex=regex_from_list(
+                get_parent_zone_names(instance.value_fqdn, min_labels=1)
+            ),
+            active=True,
+        ).exists():
+            raise (
+                CNAMEWarning(
+                    _(
+                        "There is no matching target record for CNAME value {value}"
+                    ).format(value=instance.value_fqdn)
+                )
+            )
+
+        return None
+
+    def get_cname_records(self, instance):
+        cname_records = set(
+            Record.objects.filter(
+                zone__view=instance.zone.view,
+                value=instance.fqdn,
+                type=RecordTypeChoices.CNAME,
+                active=True,
+            )
+        )
+
+        parent_zones = instance.zone.view.zones.filter(
+            name__iregex=regex_from_list(
+                get_parent_zone_names(instance.fqdn, include_self=True)
+            ),
+        )
+
+        for parent_zone in parent_zones:
+            parent_cname_records = Record.objects.filter(
+                zone__view=instance.zone.view,
+                type=RecordTypeChoices.CNAME,
+                zone=parent_zone,
+                active=True,
+            )
+            cname_records = cname_records.union(
+                {
+                    record
+                    for record in parent_cname_records
+                    if record.value_fqdn == instance.fqdn
+                }
+            )
+
+        if cname_records:
+            return RelatedRecordTable(
+                data=cname_records,
+            )
+
+        return None
 
     def get_extra_context(self, request, instance):
         context = {}
@@ -48,40 +143,86 @@ class RecordView(generic.ObjectView):
         if instance.value != unicode_value:
             context["unicode_value"] = unicode_value
 
+        if instance.type == RecordTypeChoices.CNAME:
+            try:
+                cname_target_table = self.get_value_records(instance)
+                if cname_target_table is not None:
+                    cname_target_table.configure(request)
+                context["cname_target_table"] = cname_target_table
+            except CNAMEWarning as exc:
+                context["cname_warning"] = str(exc)
+        else:
+            cname_table = self.get_cname_records(instance)
+            if cname_table is not None:
+                cname_table.configure(request)
+            context["cname_table"] = cname_table
+
+        if instance.ipam_ip_address is not None:
+            context["ipam_ip_address"] = instance.ipam_ip_address
+        elif instance.address_records is not None:
+            address_record = instance.address_records.filter(
+                ipam_ip_address__isnull=False
+            ).first()
+            if address_record is not None:
+                context["ipam_ip_address"] = address_record.ipam_ip_address
+
+        if not instance.managed:
+            name = dns_name.from_text(instance.name, origin=None)
+
+            if not instance.is_delegation_record:
+                fqdn = dns_name.from_text(instance.fqdn)
+
+                if Zone.objects.filter(
+                    active=True,
+                    view=instance.zone.view,
+                    name__iregex=regex_from_list(
+                        get_parent_zone_names(
+                            instance.fqdn,
+                            min_labels=len(fqdn) - len(name),
+                            include_self=True,
+                        )
+                    ),
+                ).exists():
+                    context["mask_warning"] = _(
+                        "Record is masked by a child zone and may not be visible in DNS"
+                    )
+
         return context
 
 
+@register_model_view(Record, "add", detail=False)
+@register_model_view(Record, "edit")
 class RecordEditView(generic.ObjectEditView):
-    """View for editing a Record instance."""
-
     queryset = Record.objects.filter(managed=False).prefetch_related(
         "zone", "ptr_record"
     )
     form = RecordForm
-    default_return_url = "plugins:netbox_dns:record_list"
 
 
+@register_model_view(Record, "delete")
 class RecordDeleteView(generic.ObjectDeleteView):
     queryset = Record.objects.filter(managed=False)
-    default_return_url = "plugins:netbox_dns:record_list"
 
 
+@register_model_view(Record, "bulk_import", detail=False)
 class RecordBulkImportView(generic.BulkImportView):
     queryset = Record.objects.filter(managed=False).prefetch_related(
         "zone", "ptr_record"
     )
     model_form = RecordImportForm
     table = RecordTable
-    default_return_url = "plugins:netbox_dns:record_list"
 
 
+@register_model_view(Record, "bulk_edit", path="edit", detail=False)
 class RecordBulkEditView(generic.BulkEditView):
     queryset = Record.objects.filter(managed=False).prefetch_related("zone")
-    filterset = RecordFilter
+    filterset = RecordFilterSet
     table = RecordTable
     form = RecordBulkEditForm
 
 
+@register_model_view(Record, "bulk_delete", path="delete", detail=False)
 class RecordBulkDeleteView(generic.BulkDeleteView):
     queryset = Record.objects.filter(managed=False)
+    filterset = RecordFilterSet
     table = RecordTable

netbox_dns/views/record_template.py

@@ -0,0 +1,93 @@
+from dns import name as dns_name
+
+from netbox.views import generic
+from utilities.views import register_model_view
+
+from netbox_dns.filtersets import RecordTemplateFilterSet
+from netbox_dns.forms import (
+    RecordTemplateImportForm,
+    RecordTemplateFilterForm,
+    RecordTemplateForm,
+    RecordTemplateBulkEditForm,
+)
+from netbox_dns.models import RecordTemplate
+from netbox_dns.tables import RecordTemplateTable, ZoneTemplateDisplayTable
+from netbox_dns.utilities import value_to_unicode
+
+
+__all__ = (
+    "RecordTemplateView",
+    "RecordTemplateListView",
+    "RecordTemplateEditView",
+    "RecordTemplateDeleteView",
+    "RecordTemplateBulkImportView",
+    "RecordTemplateBulkEditView",
+    "RecordTemplateBulkDeleteView",
+)
+
+
+@register_model_view(RecordTemplate, "list", path="", detail=False)
+class RecordTemplateListView(generic.ObjectListView):
+    queryset = RecordTemplate.objects.all()
+    filterset = RecordTemplateFilterSet
+    filterset_form = RecordTemplateFilterForm
+    table = RecordTemplateTable
+
+
+@register_model_view(RecordTemplate)
+class RecordTemplateView(generic.ObjectView):
+    queryset = RecordTemplate.objects.all()
+
+    def get_extra_context(self, request, instance):
+        context = {}
+
+        name = dns_name.from_text(instance.record_name, origin=None)
+        if name.to_text() != name.to_unicode():
+            context["unicode_name"] = name.to_unicode()
+
+        unicode_value = value_to_unicode(instance.value)
+        if instance.value != unicode_value:
+            context["unicode_value"] = unicode_value
+
+        if instance.zone_templates.exists():
+            zone_template_table = ZoneTemplateDisplayTable(
+                data=instance.zone_templates.all()
+            )
+            zone_template_table.configure(request)
+            context["zone_template_table"] = zone_template_table
+
+        return context
+
+
+@register_model_view(RecordTemplate, "add", detail=False)
+@register_model_view(RecordTemplate, "edit")
+class RecordTemplateEditView(generic.ObjectEditView):
+    queryset = RecordTemplate.objects.all()
+    form = RecordTemplateForm
+
+
+@register_model_view(RecordTemplate, "delete")
+class RecordTemplateDeleteView(generic.ObjectDeleteView):
+    queryset = RecordTemplate.objects.all()
+
+
+@register_model_view(RecordTemplate, "bulk_import", detail=False)
+class RecordTemplateBulkImportView(generic.BulkImportView):
+    queryset = RecordTemplate.objects.all()
+    model_form = RecordTemplateImportForm
+    table = RecordTemplateTable
+
+
+@register_model_view(RecordTemplate, "bulk_edit", path="edit", detail=False)
+class RecordTemplateBulkEditView(generic.BulkEditView):
+    queryset = RecordTemplate.objects.all()
+    filterset = RecordTemplateFilterSet
+    table = RecordTemplateTable
+    form = RecordTemplateBulkEditForm
+
+
+@register_model_view(RecordTemplate, "bulk_delete", path="delete", detail=False)
+class RecordTemplateBulkDeleteView(generic.BulkDeleteView):
+    queryset = RecordTemplate.objects.all()
+    filterset = RecordTemplateFilterSet
+    table = RecordTemplateTable

netbox_dns/views/registrar.py

@@ -1,9 +1,11 @@
+from django.utils.translation import gettext as _
+
 from netbox.views import generic
 
 from utilities.views import ViewTab, register_model_view
 
 from netbox_dns.models import Registrar, Zone
-from netbox_dns.filters import RegistrarFilter, ZoneFilter
+from netbox_dns.filtersets import RegistrarFilterSet, ZoneFilterSet
 from netbox_dns.forms import (
     RegistrarForm,
     RegistrarFilterForm,
@@ -13,62 +15,79 @@ from netbox_dns.forms import (
 from netbox_dns.tables import RegistrarTable, ZoneTable
 
 
-class RegistrarView(generic.ObjectView):
-    queryset = Registrar.objects.all()
+__all__ = (
+    "RegistrarView",
+    "RegistrarListView",
+    "RegistrarEditView",
+    "RegistrarDeleteView",
+    "RegistrarBulkImportView",
+    "RegistrarBulkEditView",
+    "RegistrarBulkDeleteView",
+)
 
 
+@register_model_view(Registrar, "list", path="", detail=False)
 class RegistrarListView(generic.ObjectListView):
     queryset = Registrar.objects.all()
     table = RegistrarTable
-    filterset = RegistrarFilter
+    filterset = RegistrarFilterSet
     filterset_form = RegistrarFilterForm
 
 
+@register_model_view(Registrar)
+class RegistrarView(generic.ObjectView):
+    queryset = Registrar.objects.all()
+
+
+@register_model_view(Registrar, "add", detail=False)
+@register_model_view(Registrar, "edit")
 class RegistrarEditView(generic.ObjectEditView):
     queryset = Registrar.objects.all()
     form = RegistrarForm
-    default_return_url = "plugins:netbox_dns:registrar_list"
 
 
+@register_model_view(Registrar, "delete")
 class RegistrarDeleteView(generic.ObjectDeleteView):
     queryset = Registrar.objects.all()
-    default_return_url = "plugins:netbox_dns:registrar_list"
 
 
+@register_model_view(Registrar, "bulk_import", detail=False)
 class RegistrarBulkImportView(generic.BulkImportView):
     queryset = Registrar.objects.all()
     model_form = RegistrarImportForm
     table = RegistrarTable
-    default_return_url = "plugins:netbox_dns:registrar_list"
 
 
+@register_model_view(Registrar, "bulk_edit", path="edit", detail=False)
 class RegistrarBulkEditView(generic.BulkEditView):
     queryset = Registrar.objects.all()
-    filterset = RegistrarFilter
+    filterset = RegistrarFilterSet
     table = RegistrarTable
     form = RegistrarBulkEditForm
 
 
+@register_model_view(Registrar, "bulk_delete", path="delete", detail=False)
 class RegistrarBulkDeleteView(generic.BulkDeleteView):
     queryset = Registrar.objects.all()
+    filterset = RegistrarFilterSet
     table = RegistrarTable
 
 
 @register_model_view(Registrar, "zones")
 class RegistrarZoneListView(generic.ObjectChildrenView):
-    queryset = Registrar.objects.all().prefetch_related("zone_set")
+    queryset = Registrar.objects.prefetch_related("zones")
     child_model = Zone
     table = ZoneTable
-    filterset = ZoneFilter
+    filterset = ZoneFilterSet
     template_name = "netbox_dns/zone/child.html"
     hide_if_empty = True
 
     tab = ViewTab(
-        label="Zones",
+        label=_("Zones"),
         permission="netbox_dns.view_zone",
-        badge=lambda obj: obj.zone_set.count(),
+        badge=lambda obj: obj.zones.count(),
         hide_if_empty=True,
     )
 
     def get_children(self, request, parent):
-        return parent.zone_set
+        return parent.zones

netbox_dns/views/registration_contact.py

@@ -0,0 +1,101 @@
+from django.db.models import Q
+from django.utils.translation import gettext_lazy as _
+
+from netbox.views import generic
+
+from utilities.views import ViewTab, register_model_view
+
+from netbox_dns.models import RegistrationContact, Zone
+from netbox_dns.filtersets import RegistrationContactFilterSet, ZoneFilterSet
+from netbox_dns.forms import (
+    RegistrationContactForm,
+    RegistrationContactFilterForm,
+    RegistrationContactImportForm,
+    RegistrationContactBulkEditForm,
+)
+from netbox_dns.tables import RegistrationContactTable, ZoneTable
+
+
+__all__ = (
+    "RegistrationContactView",
+    "RegistrationContactEditView",
+    "RegistrationContactListView",
+    "RegistrationContactDeleteView",
+    "RegistrationContactBulkImportView",
+    "RegistrationContactBulkEditView",
+    "RegistrationContactBulkDeleteView",
+)
+
+
+@register_model_view(RegistrationContact, "list", path="", detail=False)
+class RegistrationContactListView(generic.ObjectListView):
+    queryset = RegistrationContact.objects.all()
+    table = RegistrationContactTable
+    filterset = RegistrationContactFilterSet
+    filterset_form = RegistrationContactFilterForm
+
+
+@register_model_view(RegistrationContact)
+class RegistrationContactView(generic.ObjectView):
+    queryset = RegistrationContact.objects.all()
+
+
+@register_model_view(RegistrationContact, "add", detail=False)
+@register_model_view(RegistrationContact, "edit")
+class RegistrationContactEditView(generic.ObjectEditView):
+    queryset = RegistrationContact.objects.all()
+    form = RegistrationContactForm
+
+
+@register_model_view(RegistrationContact, "delete")
+class RegistrationContactDeleteView(generic.ObjectDeleteView):
+    queryset = RegistrationContact.objects.all()
+
+
+@register_model_view(RegistrationContact, "bulk_import", detail=False)
+class RegistrationContactBulkImportView(generic.BulkImportView):
+    queryset = RegistrationContact.objects.all()
+    model_form = RegistrationContactImportForm
+    table = RegistrationContactTable
+
+
+@register_model_view(RegistrationContact, "bulk_edit", path="edit", detail=False)
+class RegistrationContactBulkEditView(generic.BulkEditView):
+    queryset = RegistrationContact.objects.all()
+    filterset = RegistrationContactFilterSet
+    table = RegistrationContactTable
+    form = RegistrationContactBulkEditForm
+
+
+@register_model_view(RegistrationContact, "bulk_delete", path="delete", detail=False)
+class RegistrationContactBulkDeleteView(generic.BulkDeleteView):
+    queryset = RegistrationContact.objects.all()
+    filterset = RegistrationContactFilterSet
+    table = RegistrationContactTable
+
+
+@register_model_view(RegistrationContact, "zones")
+class RegistrationContactZoneListView(generic.ObjectChildrenView):
+    queryset = RegistrationContact.objects.prefetch_related(
+        "registrant_zones", "admin_c_zones", "tech_c_zones", "billing_c_zones"
+    )
+    child_model = Zone
+    table = ZoneTable
+    filterset = ZoneFilterSet
+    template_name = "netbox_dns/zone/child.html"
+    hide_if_empty = True
+
+    tab = ViewTab(
+        label=_("Zones"),
+        permission="netbox_dns.view_zone",
+        badge=lambda obj: len(obj.zones),
+        hide_if_empty=True,
+    )
+
+    def get_children(self, request, parent):
+        return Zone.objects.filter(
+            Q(registrant=parent)
+            | Q(admin_c=parent)
+            | Q(tech_c=parent)
+            | Q(billing_c=parent)
+        )

netbox_dns/views/view.py

@@ -1,69 +1,113 @@
 from utilities.views import ViewTab, register_model_view
+from django.utils.translation import gettext_lazy as _
 
 from netbox.views import generic
+from ipam.models import Prefix
 
 from netbox_dns.models import View, Zone
-from netbox_dns.filters import ViewFilter, ZoneFilter
-from netbox_dns.forms import ViewForm, ViewFilterForm, ViewImportForm, ViewBulkEditForm
+from netbox_dns.filtersets import ViewFilterSet, ZoneFilterSet
+from netbox_dns.forms import (
+    ViewForm,
+    ViewFilterForm,
+    ViewImportForm,
+    ViewBulkEditForm,
+    ViewPrefixEditForm,
+)
 from netbox_dns.tables import ViewTable, ZoneTable
+from netbox_dns.utilities import get_views_by_prefix
 
 
-class ViewView(generic.ObjectView):
-    queryset = View.objects.all().prefetch_related("zone_set")
+__all__ = (
+    "ViewView",
+    "ViewListView",
+    "ViewEditView",
+    "ViewDeleteView",
+    "ViewBulkImportView",
+    "ViewBulkEditView",
+    "ViewBulkDeleteView",
+    "ViewPrefixEditView",
+)
 
 
+@register_model_view(View, "list", path="", detail=False)
 class ViewListView(generic.ObjectListView):
     queryset = View.objects.all()
     table = ViewTable
-    filterset = ViewFilter
+    filterset = ViewFilterSet
     filterset_form = ViewFilterForm
 
 
+@register_model_view(View)
+class ViewView(generic.ObjectView):
+    queryset = View.objects.prefetch_related("zones")
+
+
+@register_model_view(View, "add", detail=False)
+@register_model_view(View, "edit")
 class ViewEditView(generic.ObjectEditView):
     queryset = View.objects.all()
     form = ViewForm
-    default_return_url = "plugins:netbox_dns:view_list"
 
 
+@register_model_view(View, "delete")
 class ViewDeleteView(generic.ObjectDeleteView):
     queryset = View.objects.all()
-    default_return_url = "plugins:netbox_dns:view_list"
 
 
+@register_model_view(View, "bulk_import", detail=False)
 class ViewBulkImportView(generic.BulkImportView):
     queryset = View.objects.all()
     model_form = ViewImportForm
     table = ViewTable
-    default_return_url = "plugins:netbox_dns:view_list"
 
 
+@register_model_view(View, "bulk_edit", path="edit", detail=False)
 class ViewBulkEditView(generic.BulkEditView):
     queryset = View.objects.all()
-    filterset = ViewFilter
+    filterset = ViewFilterSet
     table = ViewTable
     form = ViewBulkEditForm
 
 
+@register_model_view(View, "bulk_delete", path="delete", detail=False)
 class ViewBulkDeleteView(generic.BulkDeleteView):
     queryset = View.objects.all()
+    filterset = ViewFilterSet
     table = ViewTable
 
 
+@register_model_view(Prefix, "views", path="assign-views")
+class ViewPrefixEditView(generic.ObjectEditView):
+    queryset = Prefix.objects.all()
+    form = ViewPrefixEditForm
+    template_name = "netbox_dns/view/prefix.html"
+
+    def get_extra_context(self, request, instance):
+        parents = instance.get_parents()
+        if parents:
+            return {
+                "inherited_views": get_views_by_prefix(parents.last()),
+                "inherited_from": parents.filter(netbox_dns_views__isnull=False).last(),
+            }
+
+        return {}
+
+
 @register_model_view(View, "zones")
 class ViewZoneListView(generic.ObjectChildrenView):
-    queryset = View.objects.all().prefetch_related("zone_set")
+    queryset = View.objects.prefetch_related("zones")
     child_model = Zone
     table = ZoneTable
-    filterset = ZoneFilter
+    filterset = ZoneFilterSet
     template_name = "netbox_dns/zone/child.html"
     hide_if_empty = True
 
     tab = ViewTab(
-        label="Zones",
+        label=_("Zones"),
         permission="netbox_dns.view_zone",
-        badge=lambda obj: obj.zone_set.count(),
+        badge=lambda obj: obj.zones.count(),
         hide_if_empty=True,
     )
 
     def get_children(self, request, parent):
-        return parent.zone_set
+        return parent.zones