feat: adds domain endpoints (#16)

* feat: adds domain endpoints

* docs: contact api indication

* tests: add test cases for new endpoints

* chore: remove print

Author: becelot

.gitignore

@@ -137,6 +137,9 @@ docs/_build
 .venv/
 venv
 
+test-results/
+main.py
+
 # Include tracked hidden files and directories in search and diff tools
 !.commitlintrc.json
 !.dockerignore

README.md

@@ -151,9 +151,18 @@ Currently, we support the following endpoints for the following services:
     * [x] delete_zone 100%
     * [ ] jobs_find 50% - missing official documentation, functionality cannot be guaranteed
     * [x] update_zone 100%
+    * [x] get_default_nameserver 100%
+* Domain
+    * [x] list_domains 100%
+    * [x] register_domain 100%
+    * [x] jobs_find 100%
+    * [x] list_contacts 100%
+    * [ ] create_contact 0%
+    * [ ] update_contact 0%
 * Account
     * [ ] list_accounts 50% - missing official documentation, functionality cannot be guaranteed
-    
+    * [ ] get_own_account 50% - missing official documentation, functionality only implemented as far as required
+
 We plan to add more endpoints in the future, for example for SSL and Domain services.
 
 The implemented endpoints do not contain any logic to catch asynchronous behaviour yet. We plan to add a `sync: bool`

hostingde/account/account.py

@@ -45,3 +45,12 @@ def list_subaccounts_names(
         uri = self._build_uri('account', 'subaccountsFind')
 
         return self._iter(uri, Account, filter, limit, sort)
+
+    def get_own_account(self, **kwargs):
+        uri = self._build_uri('account', 'getOwnAccount')
+
+        response = self._request(uri)
+
+        data = response.json().get('response', {})
+
+        return self._instance(Account, data)

hostingde/client.py

@@ -1,5 +1,6 @@
 from hostingde.account.account import AccountClient
 from hostingde.dns.dns import DnsClient
+from hostingde.domain.domain import DomainClient
 from hostingde.hostingde import HostingDeCore
 
 
@@ -13,4 +14,5 @@ class HostingDeClient(HostingDeCore):
     def __init__(self):
         super().__init__()
         self.dns: DnsClient = DnsClient(self)
+        self.domain: DomainClient = DomainClient(self)
         self.account: AccountClient = AccountClient(self)

hostingde/dns/dns.py

@@ -33,6 +33,15 @@ def build_uri(self, method: str) -> str:
         """
         return self._build_uri('dns', method)
 
+    def get_default_nameserver(self) -> List[str]:
+        uri = self.build_uri('nameserverSetGetDefault')
+
+        response = self._request(uri)
+
+        data = response.json().get('response', {})
+
+        return data.get('nameservers', [])
+
     def list_zones(
         self,
         limit: Optional[int] = None,

hostingde/domain/__init__.py

@@ -0,0 +1,132 @@
+from typing import Optional, List
+
+from hostingde.domain.requests.register_domain import RegisterDomainRequest
+from hostingde.paginator import HostingDePaginator
+from hostingde.hostingde import HostingDeCore
+from hostingde.job_waiter import AsynchronousClient, JobWaiter
+from hostingde.model.domain import Domain, Nameserver, DomainContactRef
+from hostingde.model.filter import FilterElement
+from hostingde.model.job import Job
+from hostingde.model.sort import SortConfiguration
+
+
+class DomainClient(HostingDeCore, AsynchronousClient):
+
+    def __init__(self, parent: HostingDeCore):
+        """
+        Construct a new client
+
+        :param parent: The parent to retrieve the session from
+        """
+        super().__init__(parent)
+
+    def build_uri(self, method: str) -> str:
+        """
+        Utility method to easily construct URLs for this service.
+
+        :param method: The method within this service
+        :return: The URL string
+        """
+        return self._build_uri('domain', method)
+
+    def jobs_find(
+        self,
+        limit: Optional[int] = None,
+        filter: Optional[FilterElement] = None,
+        sort: Optional[SortConfiguration] = None,
+        *args: list,
+        **kwargs: dict
+    ) -> HostingDePaginator[Job]:
+        """
+        Retrieves a list of Job objects from the generic filtering and sorting API.
+
+        :param limit: The limit of objects to retrieve per call. If not set, defaults to 25.
+        :param filter: A filter that is applied to the query
+        :param sort: Configuration how results are sorted.
+        :return: An iterator that yields ZoneConfig objects.
+        """
+        uri = self._build_uri('domain', 'jobsFind')
+
+        return self._iter(uri, Job, filter, limit, sort)
+
+    def list_domains(
+        self,
+        limit: Optional[int] = None,
+        filter: Optional[FilterElement] = None,
+        sort: Optional[SortConfiguration] = None,
+        *args: list,
+        **kwargs: dict
+    ) -> HostingDePaginator[Domain]:
+        """
+        Retrieves a list of Domain objects from the generic filtering and sorting API.
+
+        :param limit: The limit of objects to retrieve per call. If not set, defaults to 25.
+        :param filter: A filter that is applied to the query
+        :param sort: Configuration how results are sorted.
+        :return: An iterator that yields Zone objects.
+        """
+
+        uri = self._build_uri('domain', 'domainsFind')
+
+        return self._iter(uri, Domain, filter, limit, sort)
+
+    def list_contacts(
+        self,
+        limit: Optional[int] = None,
+        filter: Optional[FilterElement] = None,
+        sort: Optional[SortConfiguration] = None,
+        *args: list,
+        **kwargs: dict
+    ) -> HostingDePaginator[Domain]:
+        """
+        Retrieves a list of Domain objects from the generic filtering and sorting API.
+
+        :param limit: The limit of objects to retrieve per call. If not set, defaults to 25.
+        :param filter: A filter that is applied to the query
+        :param sort: Configuration how results are sorted.
+        :return: An iterator that yields Zone objects.
+        """
+
+        uri = self._build_uri('domain', 'contactsFind')
+
+        return self._iter(uri, Domain, filter, limit, sort)
+
+    def register_domain(
+        self,
+        name: str,
+        contacts: List[DomainContactRef],
+        nameservers: List[Nameserver],
+        transfer_lock_enabled=True,
+        asynchronous: Optional[bool] = None,
+    ) -> Domain:
+        """
+        In order to create a domain, you need to send a domainCreate request. This request takes one parameter domain
+        which contains all required information of a domain object.
+
+        :param name:
+        :param contacts:
+        :param nameservers:
+        :param transfer_lock_enabled:
+        :param asynchronous:
+        :return:
+        """
+        url = self.build_uri('domainCreate')
+
+        response = self._request(
+            url,
+            RegisterDomainRequest(
+                domain=Domain(
+                    name=name,
+                    contacts=contacts,
+                    nameservers=nameservers,
+                    transfer_lock_enabled=transfer_lock_enabled
+                )
+            ),
+        )
+
+        domain: Domain = self._instance(Domain, response.json().get('response', {}))
+
+        if not asynchronous and domain.id is not None:
+            JobWaiter(self, domain.id, 'domainCreate').wait()
+
+        return domain

hostingde/domain/domain.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+
+from hostingde.model import Model
+from hostingde.model.domain import Domain
+
+
+@dataclass
+class RegisterDomainRequest(Model):
+    domain: Domain

hostingde/domain/requests/__init__.py

@@ -13,3 +13,7 @@ def __str__(self) -> str:
 
 class ClientException(Exception):
     pass
+
+
+class ContextConditionException(Exception):
+    pass