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