def save(self, **kwargs):
domain = self.validated_data['domain']
account_id = self.validated_data['account_id']
registrar = self.validated_data['registrar']
dns = self.validated_data.get('dns', '')
logger.info('Begin registrar session: %s, %s, %s (%s)' % (domain, account_id, registrar, dns))
native_contract = RegistrarContract.find_native_by_domain(domain, registrar)
if native_contract:
contract, order = self.prolong_domain(domain, registrar, native_contract, account_id)
else:
contract, order = self.register_domain(domain, registrar, account_id, dns.split(','))
# request balance
registrar_config = DomainRegistrarConfig(registrar)
reg_connector = registrar_config.get_connector()
registrar_balance = reg_connector.get_balance()
return {
'id': order.fields['order_id'],
'domain': domain,
'balance': registrar_balance,
'contract': contract.number
}
def _handle_domain(self, *args, **options):
"""
Handle operations with domains.
:param args:
:param options:
:return:
"""
registrar_config = DomainRegistrarConfig(self.registrar_name)
reg_connector = registrar_config.get_connector()
if options['prolong']:
assert self.contract, _("Specify profile or existing linked contract.")
assert options['prolong'], _("Specify the prolongation period.")
prolong_years = int(options['prolong'])
contracts = list(reg_connector.find_contracts({'contract-num': self.contract}))
if len(contracts) > 0:
contract = contracts[0]
for domain_name in options['domain']:
order = contract.domain_prolong(prolong_years, domain_name)
logger.info("Order created: %s" % order)
elif options['register']:
assert self.contract, _("Specify profile or existing linked contract.")
contracts = list(reg_connector.find_contracts({'contract-num': self.contract}))
if len(contracts) > 0:
contract = contracts[0]
name_servers = options['nameserver'].split(',')
for domain_name in options['domain']:
order = contract.domain_register(domain_name, nserver='\n'.join(name_servers))
logger.info(
"Order created: %s. Domain %s registration on %s." % (order, domain_name, self.contract))
else:
logger.info("There is no such contract %s in %s" % (self.contract, self.registrar_name))
elif options['update']:
assert self.contract, _("Specify profile or existing linked contract.")
contracts = list(reg_connector.find_contracts({'contract-num': self.contract}))
if len(contracts) > 0:
contract = contracts[0]
name_servers = options['nameserver'].split(',')
for domain_name in options['domain']:
order = contract.domain_update(domain_name, nserver='\n'.join(name_servers))
logger.info("Order created: %s. Domain %s update in %s." % (order, domain_name, self.contract))
else:
logger.info("There is no such contract %s in %s" % (self.contract, self.registrar_name))
def find_native_by_domain(domain_name, registrar):
assert domain_name
assert registrar
registrar_config = DomainRegistrarConfig(registrar)
reg_connector = registrar_config.get_connector()
native_contracts = list(reg_connector.find_contracts({"domain": domain_name}))
if len(native_contracts) > 0:
return native_contracts[0]
return None
def get_native(self):
"""
Returns linked native contract from the registrar.
:return:
"""
registrar_config = DomainRegistrarConfig(self.registrar)
reg_connector = registrar_config.get_connector()
existing_contracts = list(reg_connector.find_contracts({"contract-num": self.number}))
if len(existing_contracts) <= 0:
return None
return existing_contracts[0]
def test_domain_register_linked_yes_exported_yes(self):
"""
Using known contract linked to the personal data.
"""
personal_data_ok_data = dict(
fio="Клиент Имя 3",
birth='1983-09-03',
postal_index=610003, postal_address='Address Postal 3',
phone='+7 495 6680903',
passport='8734 238764234 239874',
email='*****@*****.**' % random.randint(1, 1000),
inn_code=384762786428
)
pd = self.user.add_personal_data(PersonalDataEntrepreneur, **personal_data_ok_data)
self.assertEqual(1, len(PersonalData.objects.all()))
self.assertEqual(0, len(RegistrarContract.objects.all()))
self.assertEqual(0, len(RegistrarOrder.objects.all()))
# export personal data to the registrar
registrar_config = DomainRegistrarConfig(self.registrar_name)
reg_connector = registrar_config.get_connector()
serializer_factory = registrar_config.get_serializer_factory()
personal_data_serializer = serializer_factory.get_serializer_by_data_type(pd.type)
existing_contract = reg_connector.create_contract(personal_data_serializer.serialize(pd))
# link contract
RegistrarContract.objects.update_or_create(
registrar=self.registrar_name,
number=existing_contract.number,
defaults=dict(
personal_data=pd
)
)
# register the domain
payload = {
'domain': 'dfjslkfjsdlkfj-%s.ru' % random.randint(1, 1000),
'registrar': self.registrar_name,
'account_id': self.user.id
}
response = self.client.post('/v1/domain_orders/', payload, format='json')
self.assertEqual(200, response.status_code)
self.assertEqual(1, len(RegistrarContract.objects.all()))
self.assertEqual(1, len(RegistrarOrder.objects.all()))
linked_contract = RegistrarContract.objects.get(personal_data=pd)
self.assertEqual(linked_contract.number, response.data['contract'])
self.assertEqual(existing_contract.number, response.data['contract'])
def _handle_service(self, *args, **options):
"""
Handle operations with orders.
:param args:
:param options:
:return:
"""
registrar_config = DomainRegistrarConfig(self.registrar_name)
reg_connector = registrar_config.get_connector()
if options['list']:
assert self.contract, _("Specify profile or existing linked contract.")
contracts = list(reg_connector.find_contracts({'contract-num': self.contract}))
if len(contracts) > 0:
contract = contracts[0]
for service in contract.find_services({}):
logger.info(service.service_data['service-id'], ' - ', service.service_data['domain'])
def get_or_create_contract(personal_data, registrar):
"""
Get existing or create new contract in the registrar system. If there is no known contracts,
then it will be created from the personal data.
:param personal_data: Personal data.
:param registrar: Name of the registrar.
:return: RegistrarContract object.
"""
assert personal_data
assert registrar
logger.info("Getting contract for user %s from registrar %s." % (personal_data.account.id, registrar))
registrar_config = DomainRegistrarConfig(registrar)
reg_connector = registrar_config.get_connector()
serializer_factory = registrar_config.get_serializer_factory()
created = False
registrar_contracts = RegistrarContract.objects.filter(personal_data=personal_data)
if len(registrar_contracts) <= 0:
logger.info("Linked contracts not found. Trying to find at registrar.")
native_contracts = list(reg_connector.find_contracts({"e-mail": personal_data.email}))
if len(native_contracts) <= 0:
logger.info("Exporting contract...")
personal_data_serializer = serializer_factory.get_serializer_by_data_type(personal_data.type)
native_contract = reg_connector.create_contract(personal_data_serializer.serialize(personal_data))
logger.info("Exported as %s. Trying to link local." % native_contract)
created = True
else:
native_contract = native_contracts[0]
logger.info("Used existing contract %s. Trying to link local." % native_contract)
registrar_contract = RegistrarContract.link_native_contract(native_contract, personal_data)
return registrar_contract, created
return registrar_contracts[0], created
def _handle_order(self, *args, **options):
"""
Handle operations with orders.
:param args:
:param options:
:return:
"""
registrar_config = DomainRegistrarConfig(self.registrar_name)
reg_connector = registrar_config.get_connector()
if options['list']:
assert self.contract, _("Specify profile or existing linked contract.")
contracts = list(reg_connector.find_contracts({'contract-num': self.contract}))
if len(contracts) > 0:
contract = contracts[0]
query = {}
if 'state' in options:
query['state'] = options['state']
for order in contract.find_orders(query):
logger.info(order.order_data['order_id'], ' - ', order.order_data['order_items'])
def _get_test_registrar(self):
registrar_config = DomainRegistrarConfig(RucenterRegistrar.NAME)
return registrar_config.get_connector()
def _handle_contract(self, *args, **options):
"""
Handle operations with contracts.
:param args:
:param options:
:return:
"""
registrar_config = DomainRegistrarConfig(self.registrar_name)
reg_connector = registrar_config.get_connector()
serializer_factory = registrar_config.get_serializer_factory()
if options['search_by_domain']:
domain_name = options['search_by_domain']
logger.info("Searching contract by domain %s" % domain_name)
contracts = list(reg_connector.find_contracts({'domain': domain_name}))
if len(contracts) <= 0:
logger.warning(_("Contract is not found by %s in %s." % (domain_name, self.registrar_name)))
else:
for contract in contracts:
logger.info(" %s" % contract.number)
elif options['search_by_email']:
email = options['search_by_email']
logger.info("Searching contract by email %s" % email)
contracts = list(reg_connector.find_contracts({'e-mail': email}))
if len(contracts) <= 0:
logger.warning(_("Contract is not found by %s in %s." % (email, self.registrar_name)))
else:
for contract in contracts:
logger.info(" %s" % contract.number)
elif options['unlink']:
assert self.contract, _("Specify existing contract.")
linked_contracts = RegistrarContract.objects.filter(registrar=self.registrar_name, number=self.contract)
for linked_contract in linked_contracts:
linked_contract.delete()
logger.info(" unlinked %s" % linked_contract)
elif options['link']:
assert self.contract, _("Specify existing contract.")
linked_contracts = RegistrarContract.objects.filter(registrar=self.registrar_name, number=self.contract)
if len(linked_contracts) > 0:
logger.info("Contract %s already linked to profile %s." % (self.contract, linked_contracts[0].id))
else:
personal_data = PersonalData.objects.get(pk=self.profile_id)
RegistrarContract.objects.update_or_create(
registrar=self.registrar_name,
number=self.contract,
defaults=dict(
personal_data=personal_data
)
)
logger.info("Contract %s linked to profile id %s of account %s" % (self.contract,
personal_data.id,
personal_data.account.id))
elif options['list']:
assert self.user_id, _("Specify user id.")
for personal_data in PersonalData.objects.filter(account=self.user_id):
logger.info("%s - %s - %s - %s" % (
personal_data.id,
personal_data.type,
'default' if personal_data.default else '',
'verified' if personal_data.verified else 'not verified'))
logger.info(unicode(personal_data.extended))
print_none = True
for local_contract in RegistrarContract.objects.filter(personal_data=personal_data):
logger.info(" %s (%s)" % (local_contract.number, local_contract.registrar))
print_none = False
if print_none:
logger.info(_(" there is no linked registrar contracts."))
elif options['export']:
assert self.profile_id, _("Specify profile or contract.")
personal_data = PersonalData.objects.get(pk=self.profile_id)
known_contracts = RegistrarContract.objects.filter(personal_data=personal_data)
if len(known_contracts) <= 0:
personal_data_serializer = serializer_factory.get_serializer_by_data_type(personal_data.type)
contract = reg_connector.create_contract(personal_data_serializer.serialize(personal_data))
# track created contracts
contract, created = RegistrarContract.objects.update_or_create(
registrar=self.registrar_name,
number=contract.number,
defaults=dict(
personal_data=personal_data
)
)
if created:
logger.info("Created contract: %s" % contract.number)
else:
logger.info("Updated contract: %s" % contract.number)
else:
for known_contract in known_contracts:
logger.info("Existing contract: %s" % known_contract.number)
elif options['delete']:
assert self.contract, _("Specify profile or existing linked contract.")
try:
for contract in reg_connector.find_contracts({'contract-num': self.contract}):
logger.info("Remove contract %s from %s" % (self.contract, self.registrar_name))
contract.delete()
local_contracts_count = RegistrarContract.objects.filter(number=self.contract).count()
if local_contracts_count > 0:
RegistrarContract.objects.filter(number=self.contract).delete()
logger.info("Local contracts removed: %s" % local_contracts_count)
except Exception, ex:
raise ex
