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 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_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
