def add_collaborator(self, account_id, domain, email): """ Adds a collaborator for the domain in the account At the time of the add, a collaborator may or may not have a DNSimple account. In case the collaborator doesn't have a DNSimple account, the system will invite her/him to register to DNSimple first and then to accept the collaboration invitation. In the other case, she/he is automatically added to the domain as collaborator. She/he can decide to reject the invitation later. See https://developer.dnsimple.com/v2/domains/collaborators/#addDomainCollaborator :param account_id: int The account ID :param domain: int/str The domain name or id :param email: str The email of the collaborator to be added :return: dnsimple.Response The collaborator added to the domain in the account """ response = self.client.post( f'/{account_id}/domains/{domain}/collaborators', data=json.dumps({'email': email})) return Response(response, Collaborator)
def list_template_records(self, account_id, template, sort=None, page=None, per_page=None): """ Lists the records in the template See https://developer.dnsimple.com/v2/templates/records/#listTemplateRecords :param account_id: int The account id :param template: int/str The template id or sid :param sort: str Comma separated key-value pairs: the name of a field and the order criteria (asc for ascending and desc for descending). Possible sort criteria: - id: Sort template records by ID (i.e. 'id:asc') - name: Sort template records by name (i.e. 'name:desc') - content: Sort template records by content (i.e. 'content:asc') - type: Sort template records by type (i.e. 'type:desc') :param page: int The page to return (default: 1) :param per_page: int The number of entries to return per page (default: 30, maximum: 100) :return: dnsimple.Response The list of template records """ response = self.client.get(f'/{account_id}/templates/{template}/records', sort=sort, page=page, per_page=per_page) return Response(response, TemplateRecord)
def list_services(self, sort=None, page=None, per_page=None): """ List the available one-click services. See https://developer.dnsimple.com/v2/services/#listServices :param sort: str Comma separated key-value pairs: the name of a field and the order criteria (asc for ascending and desc for descending). Possible sort criteria: - id: Sort services by ID (i.e. 'id:asc') - sid: Sort services by sid (i.e. 'sid:desc') :param page: int The page to return (default: 1) :param per_page: int The number of entries to return per page (default: 30, maximum: 100) :return: dnsimple.Response The list of services in DNSimple """ response = self.client.get('/services', sort=sort, page=page, per_page=per_page) return Response(response, Service)
def list_templates(self, account_id, sort=None, page=None, per_page=None): """ Lists the templates in the account See https://developer.dnsimple.com/v2/templates/#listTemplates :param account_id: int The account id :param sort: str Comma separated key-value pairs: the name of a field and the order criteria (asc for ascending and desc for descending). Possible sort criteria: - id: Sort templates by ID (i.e. 'id:asc') - name: Sort templates by name (alphabetical order) (i.e. 'name:desc') - sid: Sort templates by sid (i.e. 'sid:asc') :param page: int The page to return (default: 1) :param per_page: int The number of entries to return per page (default: 30, maximum: 100) :return: dnsimple.Response The templates in the account """ response = self.client.get(f'/{account_id}/templates', sort=sort, page=page, per_page=per_page) return Response(response, Template)
def create_domain_delegation_signer_record(self, account_id, domain, ds_input): """ Create a delegation signer record You only need to create a delegation signer record manually if your domain is registered with DNSimple but hosted with another DNS provider that is signing your zone. To enable DNSSEC on a domain that is hosted with DNSimple, use the DNSSEC enable endpoint. See https://developer.dnsimple.com/v2/domains/dnssec/#createDomainDelegationSignerRecord :param account_id: int The account ID :param domain: int/str The domain name or id :param ds_input: DelegationsSignerRecordInput The delegation signer record input to create the delegation signer record :return: dnsimple.Response The newly created domain delegation signer record """ response = self.client.post( f'/{account_id}/domains/{domain}/ds_records', data=ds_input.to_json()) return Response(response, DelegationSignerRecord)
def exchange_authorization_for_token(self, code, client_id, client_secret, state, redirect_uri): """ Exchange the short-lived authorization code for an access token you can use to authenticate your API calls. See https://developer.dnsimple.com/v2/oauth/ :param code: str The authorization code, which can be used in the next step to retrieve a bearer token. :param client_id: str Client Id you received when the application was registered with DNSimple. :param client_secret: str Client Secret you received when the application was registered with DNSimple. :param state: str An unguessable random string. It is used to protect against cross-site request forgery attacks and it will be passed back to your redirect URI. :param redirect_uri: str Where to redirect the user after authorization has completed. This must be the exact URI registered or a subdirectory. :return: OAuthToken The OAuthToken object containing the access token to be used in subsequent calls to the API """ response = self.client.post('/oauth/access_token', data={ 'code': code, 'client_id': client_id, 'client_secret': client_secret, 'state': state, 'redirect_uri': redirect_uri, 'grant_type': 'authorization_code' }) return Response(response, AccessToken)
def list_accounts(self): """ Lists the accounts the current authenticated entity has access to. :return: dnsimple.Response The response containing the list of accounts. """ response = self.client.get('/accounts') return Response(response, Account)
def whoami(self): """ Retrieves the details about the current authenticated entity used to access the DNSimple API. :return: dnsimple.Response A response containing the details of the authenticated entity """ response = self.client.get('/whoami') return Response(response, Whoami)
def setUp(self) -> None: responses.add( DNSimpleMockResponse( method=responses.GET, url='https://api.sandbox.dnsimple.com/v2/whoami', fixture_name='whoami/success-user')) self.http_response = requests.get( 'https://api.sandbox.dnsimple.com/v2/whoami') self.dnsimple_response = Response(self.http_response, Whoami)
def get_tld_extended_attributes(self, tld): """ Gets the extended attributes for a TLD See https://developer.dnsimple.com/v2/tlds/#getTldExtendedAttributes :param tld: str The TLD name :return: dnsimple.Response The TLDs extended attributes """ response = self.client.get(f'/tlds/{tld}/extended_attributes') return Response(response, TldExtendedAttribute)
def get_service(self, service_id): """ Gets the service with specified ID See https://developer.dnsimple.com/v2/services/#getService :param service_id: int The service id :return: dnsimple.Response The service requested """ response = self.client.get(f'/services/{service_id}') return Response(response, Service)
def get_tld(self, tld): """ Gets the details of a TLD See https://developer.dnsimple.com/v2/tlds/#getTld :param tld: str The TLD name :return: dnsimple.Response The TLD details """ response = self.client.get(f'/tlds/{tld}') return Response(response, Tld)
def get_domain(self, account_id, domain): """ Retrieves the details of an existing domain. See https://developer.dnsimple.com/v2/domains/#getDomain :param account_id: int The account ID :param domain: int/str The domain name or ID :return: dnsimple.Response The domain requested """ response = self.client.get(f'/{account_id}/domains/{domain}') return Response(response, Domain)
def create_template(self, account_id, template_attributes): """ Creates a template in the account See https://developer.dnsimple.com/v2/templates/#createTemplate :param account_id: int The account id :param template_attributes: dnsimple.struct.Template The template attributes :return: dnsimple.Response The newly created template """ response = self.client.post(f'/{account_id}/templates', data=template_attributes.to_json()) return Response(response, Template)
def enable_vanity_name_servers(self, account_id, domain): """ Enables Vanity Name Servers for the domain See https://developer.dnsimple.com/v2/vanity/#enableVanityNameServers :param account_id: int The account id :param domain: int/str The domain name or id :return: dnsimple.Response The vanity name server list """ response = self.client.put(f'/{account_id}/vanity/{domain}') return Response(response, VanityNameServer)
def disable_dnssec(self, account_id, domain): """ Disable DNSSEC for the domain in the account. See https://developer.dnsimple.com/v2/domains/dnssec/#disableDomainDnssec :param account_id: int The account ID :param domain: int/str The domain name or id :return: dnsimple.Response An empty response """ response = self.client.delete(f'/{account_id}/domains/{domain}/dnssec') return Response(response)
def list_collaborators(self, account_id, domain): """ List collaborators for the domain in the account. See https://developer.dnsimple.com/v2/domains/collaborators/#listDomainCollaborators :param account_id: int The account ID :param domain: int/str The domain name or id :return: dnsimple.Response A list of collaborators for the domain in the account """ response = self.client.get( f'/{account_id}/domains/{domain}/collaborators') return Response(response, Collaborator)
def get_zone_file(self, account_id, zone): """ Gets a zone file from the account See https://developer.dnsimple.com/v2/zones/#getZoneFile :param account_id: int The account ID :param zone: str The zone name :return: dnsimple.Response The zone file requested """ response = self.client.get(f'/{account_id}/zones/{zone}/file') return Response(response, ZoneFile)
def create_domain(self, account_id, domain_name): """ Creates a domain in the account. See https://developer.dnsimple.com/v2/domains/#create :param account_id: int The account ID :param domain_name: str The name of the domain :return: dnsimple.Response The newly created domain """ response = self.client.post(f'/{account_id}/domains', data=json.dumps({'name': domain_name})) return Response(response, Domain)
def create_contact(self, account_id, contact): """ Creates a new contact in the account See https://developer.dnsimple.com/v2/contacts/#createContact :param account_id: int The account id :param contact: dnsimple.struct.Contact The contact to be created :return: dnsimple.Response The newly created contact """ response = self.client.post(f'/{account_id}/contacts', data=contact.to_json()) return Response(response, Contact)
def reject_push(self, account_id, push_id): """ Reject a push for the target account See: https://developer.dnsimple.com/v2/domains/pushes/#rejectPush :param account_id: int The account ID :param push_id: int Then push ID :return: dnsimple.Response An empty response """ response = self.client.delete(f'/{account_id}/pushes/{push_id}') return Response(response)
def get_contact(self, account_id, contact_id): """ Gets a contact from the account See https://developer.dnsimple.com/v2/contacts/#getContact :param account_id: int Then account id :param contact_id: int The contact id :return: dnsimple.Response The contact """ response = self.client.get(f'/{account_id}/contacts/{contact_id}') return Response(response, Contact)
def get_template(self, account_id, template): """ Gets the template with the specified id or sid See https://developer.dnsimple.com/v2/templates/#getTemplate :param account_id: int The account id :param template: int/str The template sid or id :return: dnsimple.Response The template requested """ response = self.client.get(f'/{account_id}/templates/{template}') return Response(response, Template)
def delete_webhook(self, account_id, webhook): """ Deletes a webhook from the account See https://developer.dnsimple.com/v2/webhooks/#deleteWebhook :param account_id: int The account id :param webhook: int/str The webhook id :return: dnsimple.Response An empty response """ response = self.client.delete(f'/{account_id}/webhooks/{webhook}') return Response(response)
def delete_contact(self, account_id, contact_id): """ Deletes a contact from the account See https://developer.dnsimple.com/v2/contacts/#deleteContact :param account_id: int The account id :param contact_id: int The contact id :return: dnsimple.Response An empty response """ response = self.client.delete(f'/{account_id}/contacts/{contact_id}') return Response(response)
def get_webhook(self, account_id, webhook): """ Gets a webhook from the account See https://developer.dnsimple.com/v2/webhooks/#getWebhook :param account_id: int The account id :param webhook: int/str The webhook id :return: dnsimple.Response The webhook """ response = self.client.get(f'/{account_id}/webhooks/{webhook}') return Response(response, Webhook)
def get_dnssec(self, account_id, domain): """ Get the status of DNSSEC, indicating whether it is currently enabled or disabled. See https://developer.dnsimple.com/v2/domains/dnssec/#getDomainDnssec :param account_id: int The account ID :param domain: int/str The domain name or id :return: dnsimple.Response The DNSSEC status requested """ response = self.client.get(f'/{account_id}/domains/{domain}/dnssec') return Response(response, Dnssec)
def disable_vanity_name_servers(self, account_id, domain): """ Disables Vanity Name Servers for the domain See https://developer.dnsimple.com/v2/vanity/#disableVanityNameServers :param account_id: int The account id :param domain: int/str The domain name or id :return: dnsimple.Response An empty response """ response = self.client.delete(f'/{account_id}/vanity/{domain}') return Response(response)
def renew_whois_privacy(self, account_id, domain): """ Renew WHOIS privacy See https://developer.dnsimple.com/v2/registrar/whois-privacy/#renewWhoisPrivacy :param account_id: int The account ID :param domain: int/str The domain name or id :return: dnsimple.Response The whois privacy renewal """ response = self.client.post( f'/{account_id}/registrar/domains/{domain}/whois_privacy') return Response(response, WhoisPrivacyRenewal)
def list_records(self, account_id, zone, filter=None, sort=None, page=None, per_page=None): """ Lists the zone records in the account See https://developer.dnsimple.com/v2/zones/records/#listZoneRecords :param account_id: int The account ID :param zone: str The zone name :param sort: str Comma separated key-value pairs: the name of a field and the order criteria (asc for ascending and desc for descending). Possible sort criteria: - id: Sort records by ID (i.e. 'id:asc') - name: Sort records by name (i.e. 'name:desc') - content: Sort records by content (i.e. 'content:asc') - type: Sort records by type (i.e. 'type:asc') :param filter: dict Makes it possible to ask only for the exact subset of data that you you’re looking for. Possible filters: - name_like: Only include records where the name contains the given string (i.e.{'name_like':'example'}) - name: Only include records with name equal to the given string (i.e. {'name': 'example.com'}) - type: Only include records with the record type equal to the given string (i.e. {'type': 'SOA'}) :param page: int The page to return (default: 1) :param per_page: int The number of entries to return per page (default: 30, maximum: 100) :return: dnsimple.Response The list of zone records in the account """ response = self.client.get(f'/{account_id}/zones/{zone}/records', filter=filter, sort=sort, page=page, per_page=per_page) return Response(response, ZoneRecord)