Example #1
0
    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
        }
Example #2
0
    def register_domain(self, domain, registrar, account_id, dns_list):
        """
        Register the new domain to account.
        :param dns_list:
        :param domain: Domain to register.
        :param registrar: Name of the registrar.
        :param account_id: ID of the domain owner.
        :return: Registration order.
        """
        assert domain
        assert registrar
        assert account_id > 0

        personal_data = RegistrarContract.get_linked_personal_data(account_id, registrar)
        registrar_contract, created = RegistrarContract.get_or_create_contract(personal_data, registrar)

        order = registrar_contract.get_native().domain_register(domain, nserver='\n'.join(dns_list))
        logger.info("Order created: %s. Domain %s registration for %s." % (order, domain, registrar_contract.number))

        RegistrarOrder.objects.create(id=order.fields['order_id'],
                                      contract=registrar_contract,
                                      domain=domain,
                                      is_prolong=False)

        return registrar_contract, order
Example #3
0
    def prolong_domain(self, domain, registrar, native_contract, account_id):
        """
        Prolongate domain using known registrar contract.
        :param domain: Domain to prolong.
        :param registrar: Name of the registrar.
        :param native_contract: Used native registrar contract.
        :return: Prolong order.
        """
        assert domain
        assert registrar
        assert native_contract
        assert account_id > 0

        prolong_years = 1

        personal_data = RegistrarContract.get_matched_personal_data(native_contract, account_id)
        registrar_contract = RegistrarContract.link_native_contract(native_contract, personal_data)

        order = native_contract.domain_prolong(prolong_years, domain)
        logger.info("Order created: %s. Domain %s prolongation for %s." % (order, domain, native_contract.number))

        RegistrarOrder.objects.create(id=order.fields['order_id'],
                                      contract=registrar_contract,
                                      domain=domain,
                                      is_prolong=True,
                                      prolong_years=prolong_years)

        return native_contract, order
Example #4
0
    def handle_rf(self, order_item):
        assert order_item

        original_domain = order_item['domain']
        order_item['domain'] = idna.encode(order_item['domain'])

        logger.info("IDNA convert: %s -> %s" % (original_domain, order_item['domain']))

        return order_item
Example #5
0
    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))
Example #6
0
    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'])
Example #7
0
    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
Example #8
0
    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'])
Example #9
0
    def link_native_contract(native_contract, personal_data):
        """
        Link remote registrar contract to the local personal data.
        :param native_contract: Contract at the registrar
        :param personal_data: User personal data.
        :return: RegistrarContract object.
        """
        assert native_contract
        assert personal_data
        assert isinstance(native_contract, Contract)

        if not RegistrarContract.objects.filter(
            number=native_contract.number, registrar=native_contract.registrar.NAME
        ).exists():
            logger.info("Linking contract %s to personal data %s." % (native_contract, personal_data.id))
            RegistrarContract.objects.update_or_create(
                registrar=native_contract.registrar.NAME,
                number=native_contract.number,
                defaults=dict(personal_data=personal_data),
            )

        return RegistrarContract.objects.filter(
            number=native_contract.number, registrar=native_contract.registrar.NAME
        )[0]
Example #10
0
    def _parse_globals(self, **options):
        self.registrar_name = options['registrar']
        self.user_id = int(options['user_id']) if options['user_id'] else None
        self.contract = options['contract']
        self.profile_id = int(options['profile_id']) if options['profile_id'] else None

        if self.profile_id and not self.contract:
            logger.info("Searching for the profile %s" % self.profile_id)
            local_contracts = RegistrarContract.objects.filter(personal_data=self.profile_id)
            if len(local_contracts) > 0:
                self.contract = local_contracts[0].number
            else:
                logger.error(_("There is no linked contracts to profile %s" % self.profile_id))
        elif not self.profile_id and self.contract:
            local_contracts = RegistrarContract.objects.filter(registrar=self.registrar_name, number=self.contract)
            if len(local_contracts) > 0:
                self.profile_id = local_contracts[0].personal_data.id

        logger.info("Registered globals:")
        logger.info("registrar_name = %s" % self.registrar_name)
        logger.info("user_id = %s" % self.user_id)
        logger.info("contract = %s" % self.contract)
        logger.info("profile_id = %s" % self.profile_id)
Example #11
0
    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