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

netbox_dns/models/record_template.py

@@ -0,0 +1,198 @@
+import dns
+from dns import name as dns_name
+
+from django.core.exceptions import ValidationError
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+from django.core.validators import MaxValueValidator
+
+from netbox.models import NetBoxModel
+from netbox.search import SearchIndex, register_search
+from netbox.plugins.utils import get_plugin_config
+
+from netbox_dns.choices import RecordTypeChoices, RecordStatusChoices
+from netbox_dns.validators import validate_generic_name, validate_record_value
+
+from .record import Record
+
+
+__all__ = (
+    "RecordTemplate",
+    "RecordTemplateIndex",
+)
+
+
+class RecordTemplate(NetBoxModel):
+    class Meta:
+        verbose_name = _("Record Template")
+        verbose_name_plural = _("Record Templates")
+
+        ordering = ("name",)
+
+    clone_fields = (
+        "record_name",
+        "description",
+        "type",
+        "value",
+        "status",
+        "ttl",
+        "disable_ptr",
+        "tenant",
+    )
+
+    template_fields = (
+        "type",
+        "value",
+        "status",
+        "ttl",
+        "disable_ptr",
+        "tenant",
+    )
+
+    def __str__(self):
+        return str(self.name)
+
+    name = models.CharField(
+        verbose_name=_("Template Name"),
+        unique=True,
+        max_length=200,
+        db_collation="natural_sort",
+    )
+    record_name = models.CharField(
+        verbose_name=_("Name"),
+        max_length=255,
+        db_collation="natural_sort",
+    )
+    description = models.CharField(
+        verbose_name=_("Description"),
+        max_length=200,
+        blank=True,
+    )
+    type = models.CharField(
+        verbose_name=_("Type"),
+        choices=RecordTypeChoices,
+    )
+    value = models.CharField(
+        verbose_name=_("Value"),
+        max_length=65535,
+    )
+    status = models.CharField(
+        verbose_name=_("Status"),
+        choices=RecordStatusChoices,
+        default=RecordStatusChoices.STATUS_ACTIVE,
+        blank=False,
+    )
+    ttl = models.PositiveIntegerField(
+        verbose_name=_("TTL"),
+        null=True,
+        blank=True,
+        validators=[MaxValueValidator(2147483647)],
+    )
+    disable_ptr = models.BooleanField(
+        verbose_name=_("Disable PTR"),
+        help_text=_("Disable PTR record creation"),
+        default=False,
+    )
+    tenant = models.ForeignKey(
+        verbose_name=_("Tenant"),
+        to="tenancy.Tenant",
+        on_delete=models.PROTECT,
+        related_name="+",
+        blank=True,
+        null=True,
+    )
+
+    def get_status_color(self):
+        return RecordStatusChoices.colors.get(self.status)
+
+    def validate_name(self):
+        try:
+            name = dns_name.from_text(self.record_name, origin=None)
+            name.to_unicode()
+
+        except dns.exception.DNSException as exc:
+            raise ValidationError({"record_name": str(exc)})
+
+        if self.type not in get_plugin_config(
+            "netbox_dns", "tolerate_non_rfc1035_types", default=[]
+        ):
+            try:
+                validate_generic_name(
+                    self.record_name,
+                    (
+                        self.type
+                        in get_plugin_config(
+                            "netbox_dns",
+                            "tolerate_leading_underscore_types",
+                            default=[],
+                        )
+                    ),
+                )
+            except ValidationError as exc:
+                raise ValidationError(
+                    {
+                        "record_name": exc,
+                    }
+                )
+
+    def validate_value(self):
+        try:
+            validate_record_value(self)
+        except ValidationError as exc:
+            raise ValidationError({"value": exc})
+
+    def matching_records(self, zone):
+        return zone.records.filter(
+            name=self.record_name, type=self.type, value=self.value
+        )
+
+    def create_record(self, zone):
+        if self.matching_records(zone).exists():
+            return
+
+        record_data = {
+            "zone": zone,
+            "name": self.record_name,
+        }
+        for field in self.template_fields:
+            record_data[field] = getattr(self, field)
+
+        try:
+            record = Record.objects.create(**record_data)
+        except ValidationError as exc:
+            raise ValidationError(
+                {
+                    None: _(
+                        "Error while processing record template {template}: {error}"
+                    ).format(template=self, error=exc.messages[0])
+                }
+            )
+
+        if tags := self.tags.all():
+            record.tags.set(tags)
+
+    def clean_fields(self, exclude=None):
+        self.type = self.type.upper()
+        if get_plugin_config("netbox_dns", "convert_names_to_lowercase", False):
+            self.record_name = self.record_name.lower()
+
+        super().clean_fields(exclude=exclude)
+
+    def clean(self, *args, **kwargs):
+        self.validate_name()
+        self.validate_value()
+
+        super().clean(*args, **kwargs)
+
+
+@register_search
+class RecordTemplateIndex(SearchIndex):
+    model = RecordTemplate
+
+    fields = (
+        ("name", 100),
+        ("record_name", 120),
+        ("value", 150),
+        ("type", 200),
+        ("description", 500),
+    )

netbox_dns/models/registrar.py

@@ -1,61 +1,80 @@
 from django.db import models
-from django.urls import reverse
+from django.utils.translation import gettext_lazy as _
 
 from netbox.models import NetBoxModel
 from netbox.search import SearchIndex, register_search
 
 
+__all__ = (
+    "Registrar",
+    "RegistrarIndex",
+)
+
+
 class Registrar(NetBoxModel):
+    class Meta:
+        verbose_name = _("Registrar")
+        verbose_name_plural = _("Registrars")
+
+        ordering = (
+            "name",
+            "iana_id",
+        )
+
+    def __str__(self):
+        return str(self.name)
+
     # +
     # Data fields according to https://www.icann.org/resources/pages/rdds-labeling-policy-2017-02-01-en
     # -
     name = models.CharField(
+        verbose_name=_("Name"),
         unique=True,
         max_length=255,
+        db_collation="natural_sort",
+    )
+    description = models.CharField(
+        verbose_name=_("Description"),
+        blank=True,
+        max_length=200,
     )
     iana_id = models.IntegerField(
-        verbose_name="IANA ID",
+        verbose_name=_("IANA ID"),
         null=True,
         blank=True,
     )
     referral_url = models.URLField(
-        verbose_name="Referral URL",
+        verbose_name=_("Referral URL"),
         max_length=255,
         blank=True,
     )
     whois_server = models.CharField(
-        verbose_name="WHOIS Server",
+        verbose_name=_("WHOIS Server"),
         max_length=255,
         blank=True,
     )
     address = models.CharField(
+        verbose_name=_("Address"),
         max_length=200,
         blank=True,
     )
     abuse_email = models.EmailField(
-        verbose_name="Abuse Email",
+        verbose_name=_("Abuse Email"),
         blank=True,
     )
     abuse_phone = models.CharField(
-        verbose_name="Abuse Phone",
+        verbose_name=_("Abuse Phone"),
         max_length=50,
         blank=True,
     )
 
-    def get_absolute_url(self):
-        return reverse("plugins:netbox_dns:registrar", kwargs={"pk": self.id})
-
-    def __str__(self):
-        return str(self.name)
-
-    class Meta:
-        ordering = ("name", "iana_id")
-
 
 @register_search
 class RegistrarIndex(SearchIndex):
     model = Registrar
+
     fields = (
         ("name", 100),
         ("iana_id", 100),
+        ("description", 500),
     )

netbox_dns/models/{contact.py → registration_contact.py}

@@ -1,5 +1,5 @@
 from django.db import models
-from django.urls import reverse
+from django.utils.translation import gettext_lazy as _
 
 from netbox.models import NetBoxModel
 from netbox.search import SearchIndex, register_search
@@ -7,108 +7,135 @@ from netbox.search import SearchIndex, register_search
 from taggit.managers import TaggableManager
 
 
-class Contact(NetBoxModel):
+__all__ = (
+    "RegistrationContact",
+    "RegistrationContactIndex",
+)
+
+
+class RegistrationContact(NetBoxModel):
+    class Meta:
+        verbose_name = _("Registration Contact")
+        verbose_name_plural = _("Registration Contacts")
+
+        ordering = (
+            "name",
+            "contact_id",
+        )
+
+    clone_fields = (
+        "name",
+        "description",
+        "organization",
+        "street",
+        "city",
+        "state_province",
+        "postal_code",
+        "country",
+        "phone",
+        "phone_ext",
+        "fax",
+        "fax_ext",
+        "email",
+        "tags",
+    )
+
+    def __str__(self):
+        if self.name is not None:
+            return f"{self.contact_id} ({self.name})"
+
+        return self.contact_id
+
     # +
     # Data fields according to https://www.icann.org/resources/pages/rdds-labeling-policy-2017-02-01-en
     # -
     contact_id = models.CharField(
-        verbose_name="Contact ID",
+        verbose_name=_("Contact ID"),
         max_length=50,
         unique=True,
+        db_collation="natural_sort",
     )
     name = models.CharField(
+        verbose_name=_("Name"),
         blank=True,
         max_length=100,
+        db_collation="natural_sort",
+    )
+    description = models.CharField(
+        verbose_name=_("Description"),
+        blank=True,
+        max_length=200,
     )
     organization = models.CharField(
+        verbose_name=_("Organization"),
         blank=True,
         max_length=200,
     )
     street = models.CharField(
+        verbose_name=_("Street"),
         blank=True,
-        max_length=50,
+        max_length=255,
     )
     city = models.CharField(
+        verbose_name=_("City"),
         blank=True,
         max_length=50,
     )
     state_province = models.CharField(
-        verbose_name="State/Province",
+        verbose_name=_("State/Province"),
         blank=True,
         max_length=255,
     )
     postal_code = models.CharField(
-        verbose_name="Postal Code",
+        verbose_name=_("Postal Code"),
         blank=True,
         max_length=20,
     )
     country = models.CharField(
-        verbose_name="Country (ISO 3166)",
+        verbose_name=_("Country (ISO 3166)"),
         blank=True,
         max_length=2,
     )
     phone = models.CharField(
-        verbose_name="Phone",
+        verbose_name=_("Phone"),
         blank=True,
         max_length=50,
     )
     phone_ext = models.CharField(
-        verbose_name="Phone Extension",
+        verbose_name=_("Phone Extension"),
         blank=True,
         max_length=50,
     )
     fax = models.CharField(
-        verbose_name="Fax",
+        verbose_name=_("Fax"),
         blank=True,
         max_length=50,
     )
     fax_ext = models.CharField(
-        verbose_name="Fax Extension",
+        verbose_name=_("Fax Extension"),
         blank=True,
         max_length=50,
     )
     email = models.EmailField(
-        verbose_name="Email",
+        verbose_name=_("Email"),
         blank=True,
     )
 
+    # +
+    # TODO: Retained for backwards compatibility with older versions where
+    # 'RegistrationContact' was still ambiguously named 'Contact'.
+    #
+    # Removing it requires a data migration.
+    # -
     tags = TaggableManager(
         through="extras.TaggedItem",
         related_name="netbox_dns_contact_set",
     )
 
-    clone_fields = [
-        "name",
-        "organization",
-        "street",
-        "city",
-        "state_province",
-        "postal_code",
-        "country",
-        "phone",
-        "phone_ext",
-        "fax",
-        "fax_ext",
-        "email",
-        "tags",
-    ]
-
-    def get_absolute_url(self):
-        return reverse("plugins:netbox_dns:contact", kwargs={"pk": self.id})
-
-    def __str__(self):
-        if self.name is not None:
-            return f"{self.contact_id} ({self.name})"
-
-        return self.contact_id
-
-    class Meta:
-        ordering = ("name", "contact_id")
-
     @property
     def zones(self):
         return (
-            set(self.zone_set.all())
+            set(self.registrant_zones.all())
             | set(self.admin_c_zones.all())
             | set(self.tech_c_zones.all())
             | set(self.billing_c_zones.all())
@@ -116,11 +143,13 @@ class Contact(NetBoxModel):
 
 
 @register_search
-class ContactIndex(SearchIndex):
-    model = Contact
+class RegistrationContactIndex(SearchIndex):
+    model = RegistrationContact
+
     fields = (
         ("name", 100),
         ("contact_id", 100),
         ("email", 200),
         ("organization", 500),
+        ("description", 500),
     )

netbox_dns/models/view.py

@@ -1,20 +1,73 @@
 from django.db import models
-from django.urls import reverse
+from django.core.exceptions import ValidationError
+from django.utils.translation import gettext_lazy as _
 
 from netbox.models import NetBoxModel
+from netbox.models.features import ContactsMixin
 from netbox.search import SearchIndex, register_search
+from netbox.context import current_request
+from utilities.exceptions import AbortRequest
 
+from netbox_dns.mixins import ObjectModificationMixin
+from netbox_dns.utilities import (
+    get_ip_addresses_by_view,
+    check_dns_records,
+    update_dns_records,
+    delete_dns_records,
+    get_query_from_filter,
+)
+
+
+__all__ = (
+    "View",
+    "ViewIndex",
+)
+
+
+class View(ObjectModificationMixin, ContactsMixin, NetBoxModel):
+    class Meta:
+        verbose_name = _("View")
+        verbose_name_plural = _("Views")
+
+        ordering = ("name",)
+
+    clone_fields = (
+        "name",
+        "description",
+        "tenant",
+    )
+
+    def __str__(self):
+        return str(self.name)
 
-class View(NetBoxModel):
     name = models.CharField(
+        verbose_name=_("Name"),
         unique=True,
         max_length=255,
+        db_collation="natural_sort",
     )
     description = models.CharField(
+        verbose_name=_("Description"),
         max_length=200,
         blank=True,
     )
+    default_view = models.BooleanField(
+        verbose_name=_("Default View"),
+        default=False,
+    )
+    prefixes = models.ManyToManyField(
+        verbose_name=_("IPAM Prefixes"),
+        to="ipam.Prefix",
+        related_name="netbox_dns_views",
+        blank=True,
+    )
+    ip_address_filter = models.JSONField(
+        verbose_name=_("IP Address Filter"),
+        blank=True,
+        null=True,
+    )
     tenant = models.ForeignKey(
+        verbose_name=_("Tenant"),
         to="tenancy.Tenant",
         on_delete=models.PROTECT,
         related_name="netbox_dns_views",
@@ -22,21 +75,88 @@ class View(NetBoxModel):
         null=True,
     )
 
-    clone_fields = ["name", "description"]
+    @classmethod
+    def get_default_view(cls):
+        return cls.objects.get(default_view=True)
 
-    def get_absolute_url(self):
-        return reverse("plugins:netbox_dns:view", kwargs={"pk": self.id})
+    def delete(self, *args, **kwargs):
+        if self.default_view:
+            if current_request.get() is not None:
+                raise AbortRequest(_("The default view cannot be deleted"))
 
-    def __str__(self):
-        return str(self.name)
+            raise ValidationError(_("The default view cannot be deleted"))
 
-    class Meta:
-        ordering = ("name",)
+        super().delete(*args, **kwargs)
+
+    def clean(self, *args, **kwargs):
+        if (changed_fields := self.changed_fields) is None:
+            return
+
+        if (
+            "default_view" in changed_fields
+            and not self.default_view
+            and not View.objects.filter(default_view=True).exclude(pk=self.pk).exists()
+        ):
+            raise ValidationError(
+                {
+                    "default_view": _(
+                        "Please select a different view as default view to change this setting!"
+                    )
+                }
+            )
+
+        if "ip_address_filter" in changed_fields and self.get_saved_value(
+            "ip_address_filter"
+        ):
+            try:
+                for ip_address in get_ip_addresses_by_view(self).filter(
+                    get_query_from_filter(self.ip_address_filter)
+                ):
+                    check_dns_records(ip_address, view=self)
+            except ValidationError as exc:
+                raise ValidationError(
+                    {
+                        "ip_address_filter": exc.messages,
+                    }
+                )
+
+        super().clean(*args, **kwargs)
+
+    def save(self, *args, **kwargs):
+        self.clean()
+
+        changed_fields = self.changed_fields
+
+        super().save(*args, **kwargs)
+
+        if (changed_fields is None and self.default_view) or (
+            changed_fields is not None
+            and self.default_view
+            and "default_view" in changed_fields
+        ):
+            other_views = View.objects.filter(default_view=True).exclude(pk=self.pk)
+            for view in other_views:
+                view.default_view = False
+                view.save()
+
+        if changed_fields is not None and "ip_address_filter" in changed_fields:
+            ip_addresses = get_ip_addresses_by_view(self)
+
+            for ip_address in ip_addresses.exclude(
+                get_query_from_filter(self.ip_address_filter)
+            ):
+                delete_dns_records(ip_address, view=self)
+
+            for ip_address in ip_addresses.filter(
+                get_query_from_filter(self.ip_address_filter)
+            ):
+                update_dns_records(ip_address, view=self)
 
 
 @register_search
 class ViewIndex(SearchIndex):
     model = View
+
     fields = (
         ("name", 100),
         ("description", 500),