refactor(api): simplify interface to retrieve parent domain

api/desecapi/models.py

@@ -10,7 +10,6 @@ import uuid
 from base64 import b64encode
 from datetime import datetime, timedelta
 from os import urandom
-from typing import Union
 
 import psl_dns
 import rest_framework.authtoken.models
@@ -265,15 +264,17 @@ class Domain(models.Model):
     def keys(self):
         return pdns.get_keys(self)
 
+    @property
     def is_locally_registrable(self):
-        return self.partition_name()[1] in settings.LOCAL_PUBLIC_SUFFIXES
+        return self.parent_domain_name in settings.LOCAL_PUBLIC_SUFFIXES
 
+    @property
     def parent_domain_name(self):
-        return self.partition_name()[1]
+        return self._partitioned_name[1]
 
-    def partition_name(self: Union[Domain, str]):
-        name = self.name if isinstance(self, Domain) else self
-        subname, _, parent_name = name.partition('.')
+    @property
+    def _partitioned_name(self):
+        subname, _, parent_name = self.name.partition('.')
         return subname, parent_name or None
 
     def save(self, *args, **kwargs):
@@ -281,7 +282,7 @@ class Domain(models.Model):
         super().save(*args, **kwargs)
 
     def update_delegation(self, child_domain: Domain):
-        child_subname, child_domain_name = child_domain.partition_name()
+        child_subname, child_domain_name = child_domain._partitioned_name
         if self.name != child_domain_name:
             raise ValueError('Cannot update delegation of %s as it is not an immediate child domain of %s.' %
                              (child_domain.name, self.name))

api/desecapi/tests/base.py

@@ -890,8 +890,7 @@ class DomainOwnerTestCase(DesecTestCase, PublicSuffixMockMixin):
 
         if cls.DYN:
             for domain in cls.my_domains + cls.other_domains:
-                parent_domain_name = domain.partition_name()[1]
-                parent_domain = Domain.objects.get(name=parent_domain_name)
+                parent_domain = Domain.objects.get(name=domain.parent_domain_name)
                 parent_domain.update_delegation(domain)
 
         cls.my_domain = cls.my_domains[0]

api/desecapi/views.py

@@ -72,10 +72,8 @@ class DomainList(generics.ListCreateAPIView):
         return models.Domain.objects.filter(owner=self.request.user.pk)
 
     def perform_create(self, serializer):
-        _, parent_domain_name = models.Domain.partition_name(serializer.validated_data['name'])
-        domain_is_local = parent_domain_name in settings.LOCAL_PUBLIC_SUFFIXES
         domain_kwargs = {'owner': self.request.user}
-        if domain_is_local:
+        if models.Domain(name=serializer.validated_data['name']).is_locally_registrable:
             domain_kwargs['minimum_ttl'] = 60
         with PDNSChangeTracker():
             domain = serializer.save(**domain_kwargs)
@@ -84,13 +82,13 @@ class DomainList(generics.ListCreateAPIView):
         PDNSChangeTracker.track(lambda: self.auto_delegate(domain))
 
         # Send dyn email
-        if domain_is_local:
+        if domain.is_locally_registrable:
             content_tmpl = get_template('emails/domain-dyndns/content.txt')
             subject_tmpl = get_template('emails/domain-dyndns/subject.txt')
             from_tmpl = get_template('emails/from.txt')
             context = {
                 'domain': domain.name,
-                'url': f'https://update.{parent_domain_name}/',
+                'url': f'https://update.{domain.parent_domain_name}/',
                 'username': domain.name,
                 'password': self.request.auth.key
             }
@@ -102,9 +100,8 @@ class DomainList(generics.ListCreateAPIView):
 
     @staticmethod
     def auto_delegate(domain: models.Domain):
-        parent_domain_name = domain.partition_name()[1]
-        if parent_domain_name in settings.LOCAL_PUBLIC_SUFFIXES:
-            parent_domain = models.Domain.objects.get(name=parent_domain_name)
+        if domain.is_locally_registrable:
+            parent_domain = models.Domain.objects.get(name=domain.parent_domain_name)
             parent_domain.update_delegation(domain)
 
 
@@ -116,8 +113,8 @@ class DomainDetail(IdempotentDestroy, generics.RetrieveUpdateDestroyAPIView):
     def perform_destroy(self, instance: models.Domain):
         with PDNSChangeTracker():
             instance.delete()
-        if instance.is_locally_registrable():
-            parent_domain = models.Domain.objects.get(name=instance.parent_domain_name())
+        if instance.is_locally_registrable:
+            parent_domain = models.Domain.objects.get(name=instance.parent_domain_name)
             with PDNSChangeTracker():
                 parent_domain.update_delegation(instance)
 
@@ -599,7 +596,7 @@ class AuthenticatedActivateUserActionView(AuthenticatedActionView):
             )
         domain = PDNSChangeTracker.track(lambda: serializer.save(owner=action.user))
 
-        if domain.parent_domain_name() in settings.LOCAL_PUBLIC_SUFFIXES:
+        if domain.is_locally_registrable:
             # TODO the following line raises Domain.DoesNotExist under unknown conditions
             PDNSChangeTracker.track(lambda: DomainList.auto_delegate(domain))
             token = models.Token.objects.create(user=action.user, name='dyndns')