libcloud/dns/drivers/godaddy.py - libcloud - Git at Google

 # Licensed to the Apache Software Foundation (ASF) under one or more
 # contributor license agreements.  See the NOTICE file distributed with
 # this work for additional information regarding copyright ownership.
 # The ASF licenses this file to You under the Apache License, Version 2.0
 # (the "License"); you may not use this file except in compliance with
 # the License.You may obtain a copy of the License at
 # http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.

 __all__ = [
     'GoDaddyDNSDriver'
 ]

 try:
     import simplejson as json
 except Exception:
     import json

 from libcloud.common.base import ConnectionKey, JsonResponse
 from libcloud.common.types import LibcloudError
 from libcloud.utils.py3 import httplib
 from libcloud.dns.types import Provider, RecordType, RecordDoesNotExistError
 from libcloud.dns.base import DNSDriver, Zone, Record

 API_HOST = 'api.godaddy.com'
 VALID_RECORD_EXTRA_PARAMS = ['prio', 'ttl']


 class GoDaddyDNSException(LibcloudError):
     def __init__(self, code, message):
         self.code = code
         self.message = message
         self.args = (code, message)

     def __str__(self):
         return self.__repr__()

     def __repr__(self):
         return ('<GoDaddyDNSException in %s: %s>' % (self.code, self.message))


 class GoDaddyDNSResponse(JsonResponse):
     valid_response_codes = [httplib.OK, httplib.ACCEPTED, httplib.CREATED,
                             httplib.NO_CONTENT]

     def parse_body(self):
         if not self.body:
             return None
         # json.loads doesn't like the regex expressions used in godaddy schema
         self.body = self.body.replace('\\.', '\\\\.')

         data = json.loads(self.body)
         return data

     def parse_error(self):
         data = self.parse_body()
         raise GoDaddyDNSException(code=data['code'], message=data['message'])

     def success(self):
         return self.status in self.valid_response_codes


 class GoDaddyDNSConnection(ConnectionKey):
     responseCls = GoDaddyDNSResponse
     host = API_HOST

     allow_insecure = False

     def __init__(self, key, secret, secure=True, shopper_id=None, host=None,
                  port=None, url=None, timeout=None,
                  proxy_url=None, backoff=None, retry_delay=None):
         super(GoDaddyDNSConnection, self).__init__(
             key,
             secure=secure, host=host,
             port=port, url=url,
             timeout=timeout,
             proxy_url=proxy_url,
             backoff=backoff,
             retry_delay=retry_delay)
         self.key = key
         self.secret = secret
         self.shopper_id = shopper_id

     def add_default_headers(self, headers):
         if self.shopper_id is not None:
             headers['X-Shopper-Id'] = self.shopper_id
         headers['Content-type'] = 'application/json'
         headers['Authorization'] = "sso-key %s:%s" % \
             (self.key, self.secret)
         return headers


 class GoDaddyDNSDriver(DNSDriver):
     """
     A driver for GoDaddy DNS.

     This is for customers of GoDaddy
     who wish to purchase, update existing domains
     and manage records for DNS zones owned by GoDaddy NS servers.
     """
     type = Provider.GODADDY
     name = 'GoDaddy DNS'
     website = 'https://www.godaddy.com/'
     connectionCls = GoDaddyDNSConnection

     RECORD_TYPE_MAP = {
         RecordType.A: 'A',
         RecordType.AAAA: 'AAAA',
         RecordType.CNAME: 'CNAME',
         RecordType.MX: 'MX',
         RecordType.NS: 'SPF',
         RecordType.SRV: 'SRV',
         RecordType.TXT: 'TXT',
     }

     def __init__(self, shopper_id, key, secret,
                  secure=True, host=None, port=None):
         """
         Instantiate a new `GoDaddyDNSDriver`

         :param  shopper_id: Your customer ID or shopper ID with GoDaddy
         :type   shopper_id: ``str``

         :param  key: Your access key from developer.godaddy.com
         :type   key: ``str``

         :param  secret: Your access key secret
         :type   secret: ``str``
         """
         self.shopper_id = shopper_id
         super(GoDaddyDNSDriver, self).__init__(key=key, secret=secret,
                                                secure=secure,
                                                host=host, port=port,
                                                shopper_id=str(shopper_id))

     def list_zones(self):
         """
         Return a list of zones (purchased domains)

         :return: ``list`` of :class:`Zone`
         """
         result = self.connection.request(
             '/v1/domains/').object
         zones = self._to_zones(result)
         return zones

     def list_records(self, zone):
         """
         Return a list of records for the provided zone.

         :param zone: Zone to list records for.
         :type zone: :class:`Zone`

         :return: ``list`` of :class:`Record`
         """
         result = self.connection.request(
             '/v1/domains/%s/records' % (zone.domain)).object
         records = self._to_records(items=result, zone=zone)
         return records

     def create_record(self, name, zone, type, data, extra=None):
         """
         Create a new record.

         :param name: Record name without the domain name (e.g. www).
                      Note: If you want to create a record for a base domain
                      name, you should specify empty string ('') for this
                      argument.
         :type  name: ``str``

         :param zone: Zone where the requested record is created.
         :type  zone: :class:`Zone`

         :param type: DNS record type (A, AAAA, ...).
         :type  type: :class:`RecordType`

         :param data: Data for the record (depends on the record type).
         :type  data: ``str``

         :param extra: Extra attributes (driver specific). (optional)
         :type extra: ``dict``

         :rtype: :class:`Record`
         """
         new_record = self._format_record(name, type, data, extra)
         self.connection.request(
             '/v1/domains/%s/records' % (zone.domain), method='PATCH',
             data=json.dumps([new_record]))
         id = self._get_id_of_record(name, type)
         return Record(
             id=id, name=name,
             type=type, data=data,
             zone=zone, driver=self,
             ttl=new_record['ttl'],
             extra=extra)

     def update_record(self, record, name, type, data, extra=None):
         """
         Update an existing record.

         :param record: Record to update.
         :type  record: :class:`Record`

         :param name: Record name without the domain name (e.g. www).
                      Note: If you want to create a record for a base domain
                      name, you should specify empty string ('') for this
                      argument.
         :type  name: ``str``

         :param type: DNS record type (A, AAAA, ...).
         :type  type: :class:`RecordType`

         :param data: Data for the record (depends on the record type).
         :type  data: ``str``

         :param extra: (optional) Extra attributes (driver specific).
         :type  extra: ``dict``

         :rtype: :class:`Record`
         """
         new_record = self._format_record(name, type, data, extra)
         self.connection.request(
             '/v1/domains/%s/records/%s/%s' % (record.zone.domain,
                                               record.type,
                                               record.name),
             method='PUT',
             data=json.dumps([new_record]))
         id = self._get_id_of_record(name, type)
         return Record(
             id=id, name=name,
             type=type, data=data,
             zone=record.zone, driver=self,
             ttl=new_record['ttl'],
             extra=extra)

     def get_record(self, zone_id, record_id):
         """
         Return a Record instance.

         :param zone_id: ID of the required zone
         :type  zone_id: ``str``

         :param record_id: ID of the required record
         :type  record_id: ``str``

         :rtype: :class:`Record`
         """
         parts = record_id.split(':')
         result = self.connection.request(
             '/v1/domains/%s/records/%s/%s' % (
                 zone_id,
                 parts[1],
                 parts[0])).object
         if len(result) == 0:
             raise RecordDoesNotExistError(record_id,
                                           driver=self,
                                           record_id=record_id)
         return self._to_record(result[0],
                                self.get_zone(zone_id))

     def get_zone(self, zone_id):
         """
         Get a zone (by domain)

         :param  zone_id: The domain, not the ID
         :type   zone_id: ``str``

         :rtype:  :class:`Zone`
         """
         result = self.connection.request(
             '/v1/domains/%s/' % zone_id).object
         zone = self._to_zone(result)
         return zone

     def delete_zone(self, zone):
         """
         Delete a zone.

         Note: This will CANCEL a purchased domain

         :param zone: Zone to delete.
         :type  zone: :class:`Zone`

         :rtype: ``bool``
         """
         self.connection.request(
             '/v1/domains/%s' % (zone.domain),
             method='DELETE')
         # no error means ok
         return True

     def ex_check_availability(self, domain, for_transfer=False):
         """
         Check the availability of the domain

         :param   domain: the domain name e.g. wazzlewobbleflooble.com
         :type    domain: ``str``

         :param   for_transfer: Check if domain is available for transfer
         :type    for_transfer: ``bool``

         :rtype: `list` of :class:`GoDaddyAvailability`
         """
         result = self.connection.request(
             '/v1/domains/available',
             method='GET',
             params={
                 'domain': domain,
                 'forTransfer': str(for_transfer)
             }
         ).object
         return GoDaddyAvailability(
             domain=result['domain'],
             available=result['available'],
             price=result['price'],
             currency=result['currency'],
             period=result['period']
         )

     def ex_list_tlds(self):
         """
         List available TLDs for sale

         :rtype: ``list`` of :class:`GoDaddyTLD`
         """
         result = self.connection.request(
             '/v1/domains/tlds',
             method='GET'
         ).object
         return self._to_tlds(result)

     def ex_get_purchase_schema(self, tld):
         """
         Get the schema that needs completing to purchase a new domain
         Use this in conjunction with ex_purchase_domain

         :param   tld: The top level domain e.g com, eu, uk
         :type    tld: ``str``

         :rtype: `dict` the JSON Schema
         """
         result = self.connection.request(
             '/v1/domains/purchase/schema/%s' % tld,
             method='GET'
         ).object
         return result

     def ex_get_agreements(self, tld, privacy=True):
         """
         Get the legal agreements for a tld
         Use this in conjunction with ex_purchase_domain

         :param   tld: The top level domain e.g com, eu, uk
         :type    tld: ``str``

         :rtype: `dict` the JSON Schema
         """
         result = self.connection.request(
             '/v1/domains/agreements',
             params={
                 'tlds': tld,
                 'privacy': str(privacy)
             },
             method='GET'
         ).object
         agreements = []
         for item in result:
             agreements.append(
                 GoDaddyLegalAgreement(
                     agreement_key=item['agreementKey'],
                     title=item['title'],
                     url=item['url'],
                     content=item['content']))
         return agreements

     def ex_purchase_domain(self, purchase_request):
         """
         Purchase a domain with GoDaddy

         :param  purchase_request: The completed document
             from ex_get_purchase_schema
         :type   purchase_request: ``dict``

         :rtype: :class:`GoDaddyDomainPurchaseResponse` Your order
         """
         result = self.connection.request(
             '/v1/domains/purchase',
             data=purchase_request,
             method='POST'
         ).object
         return GoDaddyDomainPurchaseResponse(
             order_id=result['orderId'],
             item_count=result['itemCount'],
             total=result['total'],
             currency=result['currency']
         )

     def _format_record(self, name, type, data, extra):
         if extra is None:
             extra = {}
         new_record = {}
         if type == RecordType.SRV:
             new_record = {
                 'type': type,
                 'name': name,
                 'data': data,
                 'priority': 1,
                 'ttl': extra.get('ttl', 5),
                 'service': extra.get('service', ''),
                 'protocol': extra.get('protocol', ''),
                 'port': extra.get('port', ''),
                 'weight': extra.get('weight', '1')
             }
         else:
             new_record = {
                 'type': type,
                 'name': name,
                 'data': data,
                 'ttl': extra.get('ttl', 5)
             }
         if type == RecordType.MX:
             new_record['priority'] = 1
         return new_record

     def _to_zones(self, items):
         zones = []
         for item in items:
             zones.append(self._to_zone(item))
         return zones

     def _to_zone(self, item):
         extra = {"expires": item['expires']}
         zone = Zone(id=item['domainId'], domain=item['domain'],
                     type='master', ttl=None,
                     driver=self, extra=extra)
         return zone

     def _to_records(self, items, zone=None):
         records = []

         for item in items:
             records.append(self._to_record(item=item, zone=zone))
         return records

     def _to_record(self, item, zone=None):
         ttl = item['ttl']
         type = self._string_to_record_type(item['type'])
         name = item['name']
         id = self._get_id_of_record(name, type)
         record = Record(id=id, name=name,
                         type=type, data=item['data'],
                         zone=zone, driver=self,
                         ttl=ttl)
         return record

     def _to_tlds(self, items):
         tlds = []
         for item in items:
             tlds.append(self._to_tld(item))
         return tlds

     def _to_tld(self, item):
         return GoDaddyTLD(
             name=item['name'],
             tld_type=item['type']
         )

     def _get_id_of_record(self, name, type):
         return '%s:%s' % (name, type)

     def _ex_connection_class_kwargs(self):
         return {'shopper_id': self.shopper_id}


 class GoDaddyAvailability(object):
     def __init__(self, domain, available, price, currency, period):
         self.domain = domain
         self.available = bool(available)
         # currency comes in micro-units, convert to dollars.
         self.price = float(price) / 1000000
         self.currency = currency
         self.period = int(period)


 class GoDaddyTLD(object):
     def __init__(self, name, tld_type):
         self.name = name
         self.type = tld_type


 class GoDaddyDomainPurchaseResponse(object):
     def __init__(self, order_id, item_count, total, currency):
         self.order_id = order_id
         self.item_count = item_count
         self.total = total
         self.current = currency


 class GoDaddyLegalAgreement(object):
     def __init__(self, agreement_key, title, url, content):
         self.agreement_key = agreement_key
         self.title = title
         self.url = url
         self.content = content
	# Licensed to the Apache Software Foundation (ASF) under one or more
	# contributor license agreements. See the NOTICE file distributed with
	# this work for additional information regarding copyright ownership.
	# The ASF licenses this file to You under the Apache License, Version 2.0
	# (the "License"); you may not use this file except in compliance with
	# the License.You may obtain a copy of the License at
	# http://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing, software
	# distributed under the License is distributed on an "AS IS" BASIS,
	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	# See the License for the specific language governing permissions and
	# limitations under the License.

	__all__ = [
	'GoDaddyDNSDriver'
	]

	try:
	import simplejson as json
	except Exception:
	import json

	from libcloud.common.base import ConnectionKey, JsonResponse
	from libcloud.common.types import LibcloudError
	from libcloud.utils.py3 import httplib
	from libcloud.dns.types import Provider, RecordType, RecordDoesNotExistError
	from libcloud.dns.base import DNSDriver, Zone, Record

	API_HOST = 'api.godaddy.com'
	VALID_RECORD_EXTRA_PARAMS = ['prio', 'ttl']


	class GoDaddyDNSException(LibcloudError):
	def __init__(self, code, message):
	self.code = code
	self.message = message
	self.args = (code, message)

	def __str__(self):
	return self.__repr__()

	def __repr__(self):
	return ('<GoDaddyDNSException in %s: %s>' % (self.code, self.message))


	class GoDaddyDNSResponse(JsonResponse):
	valid_response_codes = [httplib.OK, httplib.ACCEPTED, httplib.CREATED,
	httplib.NO_CONTENT]

	def parse_body(self):
	if not self.body:
	return None
	# json.loads doesn't like the regex expressions used in godaddy schema
	self.body = self.body.replace('\\.', '\\\\.')

	data = json.loads(self.body)
	return data

	def parse_error(self):
	data = self.parse_body()
	raise GoDaddyDNSException(code=data['code'], message=data['message'])

	def success(self):
	return self.status in self.valid_response_codes


	class GoDaddyDNSConnection(ConnectionKey):
	responseCls = GoDaddyDNSResponse
	host = API_HOST

	allow_insecure = False

	def __init__(self, key, secret, secure=True, shopper_id=None, host=None,
	port=None, url=None, timeout=None,
	proxy_url=None, backoff=None, retry_delay=None):
	super(GoDaddyDNSConnection, self).__init__(
	key,
	secure=secure, host=host,
	port=port, url=url,
	timeout=timeout,
	proxy_url=proxy_url,
	backoff=backoff,
	retry_delay=retry_delay)
	self.key = key
	self.secret = secret
	self.shopper_id = shopper_id

	def add_default_headers(self, headers):
	if self.shopper_id is not None:
	headers['X-Shopper-Id'] = self.shopper_id
	headers['Content-type'] = 'application/json'
	headers['Authorization'] = "sso-key %s:%s" % \
	(self.key, self.secret)
	return headers


	class GoDaddyDNSDriver(DNSDriver):
	"""
	A driver for GoDaddy DNS.

	This is for customers of GoDaddy
	who wish to purchase, update existing domains
	and manage records for DNS zones owned by GoDaddy NS servers.
	"""
	type = Provider.GODADDY
	name = 'GoDaddy DNS'
	website = 'https://www.godaddy.com/'
	connectionCls = GoDaddyDNSConnection

	RECORD_TYPE_MAP = {
	RecordType.A: 'A',
	RecordType.AAAA: 'AAAA',
	RecordType.CNAME: 'CNAME',
	RecordType.MX: 'MX',
	RecordType.NS: 'SPF',
	RecordType.SRV: 'SRV',
	RecordType.TXT: 'TXT',
	}

	def __init__(self, shopper_id, key, secret,
	secure=True, host=None, port=None):
	"""
	Instantiate a new `GoDaddyDNSDriver`

	:param shopper_id: Your customer ID or shopper ID with GoDaddy
	:type shopper_id: ``str``

	:param key: Your access key from developer.godaddy.com
	:type key: ``str``

	:param secret: Your access key secret
	:type secret: ``str``
	"""
	self.shopper_id = shopper_id
	super(GoDaddyDNSDriver, self).__init__(key=key, secret=secret,
	secure=secure,
	host=host, port=port,
	shopper_id=str(shopper_id))

	def list_zones(self):
	"""
	Return a list of zones (purchased domains)

	:return: ``list`` of :class:`Zone`
	"""
	result = self.connection.request(
	'/v1/domains/').object
	zones = self._to_zones(result)
	return zones

	def list_records(self, zone):
	"""
	Return a list of records for the provided zone.

	:param zone: Zone to list records for.
	:type zone: :class:`Zone`

	:return: ``list`` of :class:`Record`
	"""
	result = self.connection.request(
	'/v1/domains/%s/records' % (zone.domain)).object
	records = self._to_records(items=result, zone=zone)
	return records

	def create_record(self, name, zone, type, data, extra=None):
	"""
	Create a new record.

	:param name: Record name without the domain name (e.g. www).
	Note: If you want to create a record for a base domain
	name, you should specify empty string ('') for this
	argument.
	:type name: ``str``

	:param zone: Zone where the requested record is created.
	:type zone: :class:`Zone`

	:param type: DNS record type (A, AAAA, ...).
	:type type: :class:`RecordType`

	:param data: Data for the record (depends on the record type).
	:type data: ``str``

	:param extra: Extra attributes (driver specific). (optional)
	:type extra: ``dict``

	:rtype: :class:`Record`
	"""
	new_record = self._format_record(name, type, data, extra)
	self.connection.request(
	'/v1/domains/%s/records' % (zone.domain), method='PATCH',
	data=json.dumps([new_record]))
	id = self._get_id_of_record(name, type)
	return Record(
	id=id, name=name,
	type=type, data=data,
	zone=zone, driver=self,
	ttl=new_record['ttl'],
	extra=extra)

	def update_record(self, record, name, type, data, extra=None):
	"""
	Update an existing record.

	:param record: Record to update.
	:type record: :class:`Record`

	:param name: Record name without the domain name (e.g. www).
	Note: If you want to create a record for a base domain
	name, you should specify empty string ('') for this
	argument.
	:type name: ``str``

	:param type: DNS record type (A, AAAA, ...).
	:type type: :class:`RecordType`

	:param data: Data for the record (depends on the record type).
	:type data: ``str``

	:param extra: (optional) Extra attributes (driver specific).
	:type extra: ``dict``

	:rtype: :class:`Record`
	"""
	new_record = self._format_record(name, type, data, extra)
	self.connection.request(
	'/v1/domains/%s/records/%s/%s' % (record.zone.domain,
	record.type,
	record.name),
	method='PUT',
	data=json.dumps([new_record]))
	id = self._get_id_of_record(name, type)
	return Record(
	id=id, name=name,
	type=type, data=data,
	zone=record.zone, driver=self,
	ttl=new_record['ttl'],
	extra=extra)

	def get_record(self, zone_id, record_id):
	"""
	Return a Record instance.

	:param zone_id: ID of the required zone
	:type zone_id: ``str``

	:param record_id: ID of the required record
	:type record_id: ``str``

	:rtype: :class:`Record`
	"""
	parts = record_id.split(':')
	result = self.connection.request(
	'/v1/domains/%s/records/%s/%s' % (
	zone_id,
	parts[1],
	parts[0])).object
	if len(result) == 0:
	raise RecordDoesNotExistError(record_id,
	driver=self,
	record_id=record_id)
	return self._to_record(result[0],
	self.get_zone(zone_id))

	def get_zone(self, zone_id):
	"""
	Get a zone (by domain)

	:param zone_id: The domain, not the ID
	:type zone_id: ``str``

	:rtype: :class:`Zone`
	"""
	result = self.connection.request(
	'/v1/domains/%s/' % zone_id).object
	zone = self._to_zone(result)
	return zone

	def delete_zone(self, zone):
	"""
	Delete a zone.

	Note: This will CANCEL a purchased domain

	:param zone: Zone to delete.
	:type zone: :class:`Zone`

	:rtype: ``bool``
	"""
	self.connection.request(
	'/v1/domains/%s' % (zone.domain),
	method='DELETE')
	# no error means ok
	return True

	def ex_check_availability(self, domain, for_transfer=False):
	"""
	Check the availability of the domain

	:param domain: the domain name e.g. wazzlewobbleflooble.com
	:type domain: ``str``

	:param for_transfer: Check if domain is available for transfer
	:type for_transfer: ``bool``

	:rtype: `list` of :class:`GoDaddyAvailability`
	"""
	result = self.connection.request(
	'/v1/domains/available',
	method='GET',
	params={
	'domain': domain,
	'forTransfer': str(for_transfer)
	}
	).object
	return GoDaddyAvailability(
	domain=result['domain'],
	available=result['available'],
	price=result['price'],
	currency=result['currency'],
	period=result['period']
	)

	def ex_list_tlds(self):
	"""
	List available TLDs for sale

	:rtype: ``list`` of :class:`GoDaddyTLD`
	"""
	result = self.connection.request(
	'/v1/domains/tlds',
	method='GET'
	).object
	return self._to_tlds(result)

	def ex_get_purchase_schema(self, tld):
	"""
	Get the schema that needs completing to purchase a new domain
	Use this in conjunction with ex_purchase_domain

	:param tld: The top level domain e.g com, eu, uk
	:type tld: ``str``

	:rtype: `dict` the JSON Schema
	"""
	result = self.connection.request(
	'/v1/domains/purchase/schema/%s' % tld,
	method='GET'
	).object
	return result

	def ex_get_agreements(self, tld, privacy=True):
	"""
	Get the legal agreements for a tld
	Use this in conjunction with ex_purchase_domain

	:param tld: The top level domain e.g com, eu, uk
	:type tld: ``str``

	:rtype: `dict` the JSON Schema
	"""
	result = self.connection.request(
	'/v1/domains/agreements',
	params={
	'tlds': tld,
	'privacy': str(privacy)
	},
	method='GET'
	).object
	agreements = []
	for item in result:
	agreements.append(
	GoDaddyLegalAgreement(
	agreement_key=item['agreementKey'],
	title=item['title'],
	url=item['url'],
	content=item['content']))
	return agreements

	def ex_purchase_domain(self, purchase_request):
	"""
	Purchase a domain with GoDaddy

	:param purchase_request: The completed document
	from ex_get_purchase_schema
	:type purchase_request: ``dict``

	:rtype: :class:`GoDaddyDomainPurchaseResponse` Your order
	"""
	result = self.connection.request(
	'/v1/domains/purchase',
	data=purchase_request,
	method='POST'
	).object
	return GoDaddyDomainPurchaseResponse(
	order_id=result['orderId'],
	item_count=result['itemCount'],
	total=result['total'],
	currency=result['currency']
	)

	def _format_record(self, name, type, data, extra):
	if extra is None:
	extra = {}
	new_record = {}
	if type == RecordType.SRV:
	new_record = {
	'type': type,
	'name': name,
	'data': data,
	'priority': 1,
	'ttl': extra.get('ttl', 5),
	'service': extra.get('service', ''),
	'protocol': extra.get('protocol', ''),
	'port': extra.get('port', ''),
	'weight': extra.get('weight', '1')
	}
	else:
	new_record = {
	'type': type,
	'name': name,
	'data': data,
	'ttl': extra.get('ttl', 5)
	}
	if type == RecordType.MX:
	new_record['priority'] = 1
	return new_record

	def _to_zones(self, items):
	zones = []
	for item in items:
	zones.append(self._to_zone(item))
	return zones

	def _to_zone(self, item):
	extra = {"expires": item['expires']}
	zone = Zone(id=item['domainId'], domain=item['domain'],
	type='master', ttl=None,
	driver=self, extra=extra)
	return zone

	def _to_records(self, items, zone=None):
	records = []

	for item in items:
	records.append(self._to_record(item=item, zone=zone))
	return records

	def _to_record(self, item, zone=None):
	ttl = item['ttl']
	type = self._string_to_record_type(item['type'])
	name = item['name']
	id = self._get_id_of_record(name, type)
	record = Record(id=id, name=name,
	type=type, data=item['data'],
	zone=zone, driver=self,
	ttl=ttl)
	return record

	def _to_tlds(self, items):
	tlds = []
	for item in items:
	tlds.append(self._to_tld(item))
	return tlds

	def _to_tld(self, item):
	return GoDaddyTLD(
	name=item['name'],
	tld_type=item['type']
	)

	def _get_id_of_record(self, name, type):
	return '%s:%s' % (name, type)

	def _ex_connection_class_kwargs(self):
	return {'shopper_id': self.shopper_id}


	class GoDaddyAvailability(object):
	def __init__(self, domain, available, price, currency, period):
	self.domain = domain
	self.available = bool(available)
	# currency comes in micro-units, convert to dollars.
	self.price = float(price) / 1000000
	self.currency = currency
	self.period = int(period)


	class GoDaddyTLD(object):
	def __init__(self, name, tld_type):
	self.name = name
	self.type = tld_type


	class GoDaddyDomainPurchaseResponse(object):
	def __init__(self, order_id, item_count, total, currency):
	self.order_id = order_id
	self.item_count = item_count
	self.total = total
	self.current = currency


	class GoDaddyLegalAgreement(object):
	def __init__(self, agreement_key, title, url, content):
	self.agreement_key = agreement_key
	self.title = title
	self.url = url
	self.content = content