def validate(self, attrs): validated_data = super().validate(attrs=attrs) domain_settings = DomainsSettings.for_client( client=self.context['request'].user.clients.first()) # validate domain name if attrs['operation'] == 'register': available, error, adjusted_name = DomainUtils.check_if_domains_is_available_for_registration( domain_name=attrs['name'], domains_settings=domain_settings, skip_whois_check=True, ) if not available: raise ValidationError({'non_field_errors': error}) else: validated_data['name'] = adjusted_name if attrs['operation'] == 'transfer': available, error, adjusted_name = DomainUtils.check_if_domains_is_available_for_transfer( domain_name=attrs['non_field_errors'], domains_settings=domain_settings, skip_whois_check=True, ) if not available: raise ValidationError({'name': error}) else: validated_data['name'] = adjusted_name return validated_data
def transfer_domain(self, request: Request) -> Response: serializer = TransferDomainSerializer(data=request.data['domain']) if serializer.is_valid(raise_exception=True): client = Client.objects.get(id=serializer.validated_data['client']) domains_settings = DomainsSettings.for_client(client=client) domain_name = serializer.validated_data['name'] available, error, adjusted_name = DomainUtils.check_if_domains_is_available_for_transfer( domain_name=domain_name, domains_settings=domains_settings, skip_whois_check=True, ) if not available: Response(data={'detail': error}, status=400) else: domain_name = adjusted_name tld = DomainUtils.get_tld(domain_name=domain_name) with transaction.atomic(): user = client.users.first() if not user: user = request.user order = Order.objects.create(user=user, client=client, currency=client.currency, client_notes='', status=OrderStatus.pending) cycle = tld.register_product.cycles.filter( currency=client.currency, cycle_multiplier=serializer.validated_data['years'] + 1, ).first() plugin_data = dict(serializer.validated_data) plugin_data['operation'] = 'transfer' plugin_data['epp'] = serializer.validated_data['epp'] order_item = order.items.create( item_type=OrderItemTypes.service, product=tld.transfer_product, cycle=cycle, fixed_price=cycle.fixed_price, cycle_display=cycle.display_name, plugin_data=plugin_data, name=domain_name, description=_('Domain transfer'), ) if not validate_services_limit(): raise APIException( _('License service limit reached. Please check your license' ), ) create_service_for_item(item=order_item) return Response(data={ 'order_id': order.id, })
def is_available_for_transfer(self, request: Request) -> Response: client_id = request.query_params.get('client_id', None) client = Client.objects.get(id=client_id) domains_settings = DomainsSettings.for_client(client=client) domain_name = request.query_params.get('domain_name', None) available, error, adjusted_name = DomainUtils.check_if_domains_is_available_for_transfer( domain_name=domain_name, domains_settings=domains_settings, skip_whois_check=True, ) if not available: return Response(data={'error': error, 'available': False}) else: domain_name = adjusted_name tld = DomainUtils.get_tld(domain_name) if not tld: return Response( data={ 'error': _('Domains {} are not available for transfer'.format( DomainUtils.get_tld_name(domain_name))), 'available': False }) if not tld.transfer_product: return Response( data={ 'error': _('No price defined for {} domains'.format( tld.name)), 'available': False }) price_cycles = tld.get_prices_for_type_and_currency( price_type=PriceType.transfer, currency=client.currency) return Response( data={ 'available': True, 'adjusted_name': adjusted_name, 'prices': PriceCyclesSerializer().to_representation( instance=price_cycles), 'config': DomainsSettingsSerializer().to_representation( instance=domains_settings), 'tld': TLDSerializer().to_representation(instance=tld), })
def validate(self, attrs): validated_data = super().validate(attrs=attrs) client = self.context['request'].user.clients.first() domain_settings = DomainsSettings.for_client(client=client) # validate domain name if attrs['operation'] == 'register': available, error, adjusted_name = DomainUtils.check_if_domains_is_available_for_registration( domain_name=attrs['name'], domains_settings=domain_settings, ) if not available: raise ValidationError({'non_field_errors': error}) else: validated_data['name'] = adjusted_name contact_id = attrs.get('contact_id', 0) if contact_id is None: contact_id = 0 if contact_id == 0: missing_fields, missing_fields_labels = CustomFieldsValidator.client_has_missing_fields_for_domain( client_id=client.id, domain_name=attrs['name'], ) else: missing_fields, missing_fields_labels = CustomFieldsValidator.contact_has_missing_fields_for_domain( contact_id=contact_id, domain_name=attrs['name'], ) if missing_fields: raise ValidationError({ 'non_field_errors': _('Missing custom fields: {}. Edit client/contact.').format( ','.join(missing_fields_labels)) }) if attrs['operation'] == 'transfer': available, error, adjusted_name = DomainUtils.check_if_domains_is_available_for_transfer( domain_name=attrs['non_field_errors'], domains_settings=domain_settings, ) if not available: raise ValidationError({'name': error}) else: validated_data['name'] = adjusted_name return validated_data
def select_domain_options(self, request: Request) -> Response: client = request.user.clients.first() domain_settings = DomainsSettings.for_client(client=client) existing_domains = Domain.objects.filter( assigned_to_service__isnull=True, service__client=client, status=DomainStatus.active, ) cart = cart_from_request(request=request, create=False) # type: FleioCart domains_in_cart = [] domains_used = [] if cart: for order_item in cart.items.all(): # type: OrderItem if order_item.product.product_type == ProductType.domain: domains_in_cart.append(order_item.name) else: if order_item.domain_name: domains_used.append(order_item.domain_name) domains_in_cart = [ domain for domain in domains_in_cart if domain not in domains_used ] valid_tlds = [tld.name for tld in TLD.objects.all()] has_existing_domains = existing_domains.count() > 0 return Response({ 'has_existing_domains': has_existing_domains, 'allow_domain_registration': domain_settings.allow_domain_registration, 'allow_domain_transfer': domain_settings.allow_domain_transfer, 'has_domains_in_cart': len(domains_in_cart) > 0, 'existing_domains': DomainSerializer(instance=existing_domains, many=True).data, 'domains_in_cart': [{ 'name': domain } for domain in domains_in_cart], 'default_tld': domain_settings.default_tld, 'valid_tlds': valid_tlds, })
def domains(self, request, pk, *args, **kwargs): del pk, args, kwargs # unused try: from plugins.domains.configuration import DomainsSettings, DomainsSettingsSerializer configuration = self.get_object() conf = DomainsSettings(configuration_id=configuration.pk, raise_if_required_not_set=False) if request.method == 'GET': serializer = DomainsSettingsSerializer(instance=conf) return Response(serializer.data) else: serializer = DomainsSettingsSerializer(instance=conf, data=request.data) serializer.is_valid(raise_exception=True) serializer.save() return Response({ 'detail': _('Settings updated'), 'settings': serializer.data }) except ImportError as e: LOG.exception('Cannot load plugin: {}'.format(e))
def transfer_domain(self, request: Request) -> Response: serializer = TransferDomainSerializer(data=request.data['domain']) if serializer.is_valid(raise_exception=True): user = request.user client = user.clients.first() domains_settings = DomainsSettings.for_client(client=client) domain_name = serializer.validated_data['name'] available, error, adjusted_name = DomainUtils.check_if_domains_is_available_for_transfer( domain_name=domain_name, domains_settings=domains_settings) if not available: Response(data={'detail': error}, status=400) else: domain_name = adjusted_name tld = DomainUtils.get_tld(domain_name=domain_name) cart = cart_from_request(request=self.request, create=True) cycle = tld.register_product.cycles.filter( currency=client.currency, cycle_multiplier=serializer.validated_data['years'] + 1, ).first() plugin_data = dict(serializer.validated_data) plugin_data['operation'] = 'transfer' plugin_data['epp'] = serializer.validated_data['epp'] cart.items.create( item_type=OrderItemTypes.service, product=tld.transfer_product, cycle=cycle, fixed_price=cycle.fixed_price, cycle_display=cycle.display_name, plugin_data=plugin_data, name=domain_name, description=_('Domain transfer'), ) return Response()
def is_available_for_registration(self, request: Request) -> Response: client_id = request.query_params.get('client_id', None) client = Client.objects.get(id=client_id) domains_settings = DomainsSettings.for_client(client=client) domain_name = request.query_params.get('domain_name', None) available, error, adjusted_name = DomainUtils.check_if_domains_is_available_for_registration( domain_name=domain_name, domains_settings=domains_settings, skip_whois_check=True, ) if not available: return Response(data={'error': error, 'available': False}) else: domain_name = adjusted_name tld = DomainUtils.get_tld(domain_name) if not tld: return Response( data={ 'error': _('Domains {} are not available for registration'.format( DomainUtils.get_tld_name(domain_name))), 'available': False }) if not tld.register_product: return Response( data={ 'error': _('No price defined for {} domains'.format( tld.name)), 'available': False }) price_cycles = tld.get_prices_for_type_and_currency( price_type=PriceType.register, currency=client.currency) dns_price_cycles = tld.get_addon_prices_for_type_and_currency( price_type=AddonPriceType.dns, currency=client.currency) email_price_cycles = tld.get_addon_prices_for_type_and_currency( price_type=AddonPriceType.email, currency=client.currency) id_price_cycles = tld.get_addon_prices_for_type_and_currency( price_type=AddonPriceType.id, currency=client.currency) client_details = '{}({})\n{}, {}\n{}, {}'.format( client.name, client.email, client.address1, client.city, client.state, client.country) return Response( data={ 'client_id': client.id, 'client_details': client_details, 'available': True, 'adjusted_name': adjusted_name, 'prices': PriceCyclesSerializer().to_representation( instance=price_cycles), 'dns_prices': AddonPriceCyclesSerializer().to_representation( instance=dns_price_cycles), 'email_prices': AddonPriceCyclesSerializer().to_representation( instance=email_price_cycles), 'id_prices': AddonPriceCyclesSerializer().to_representation( instance=id_price_cycles), 'config': DomainsSettingsSerializer().to_representation( instance=domains_settings), 'tld': TLDSerializer().to_representation(instance=tld), })
def register_domain(self, request: Request) -> Response: serializer = RegisterDomainSerializer( data=request.data['domain'], context={'request': self.request}, ) if serializer.is_valid(raise_exception=True): client = Client.objects.get(id=serializer.validated_data['client']) domains_settings = DomainsSettings.for_client(client=client) domain_name = serializer.validated_data['name'] available, error, adjusted_name = DomainUtils.check_if_domains_is_available_for_registration( domain_name=domain_name, domains_settings=domains_settings, skip_whois_check=True, ) if not available: Response(data={'detail': error}, status=400) else: domain_name = adjusted_name tld = DomainUtils.get_tld(domain_name=domain_name) user = client.users.first() if not user: user = request.user order = Order.objects.create(user=user, client=client, currency=client.currency, client_notes='', status=OrderStatus.pending) cycle = tld.register_product.cycles.filter( currency=client.currency, cycle_multiplier=serializer.validated_data['years'] + 1, ).first() dns_cycle = tld.dns_option.cycles.filter( currency=client.currency, cycle_multiplier=serializer.validated_data['years'] + 1, ).first() if serializer.validated_data.get('dns_management', False) else None email_cycle = tld.email_option.cycles.filter( currency=client.currency, cycle_multiplier=serializer.validated_data['years'] + 1, ).first() if serializer.validated_data.get('email_forwarding', False) else None id_cycle = tld.id_option.cycles.filter( currency=client.currency, cycle_multiplier=serializer.validated_data['years'] + 1, ).first() if serializer.validated_data.get('id_protection', False) else None plugin_data = dict(serializer.validated_data) plugin_data['operation'] = 'register' with transaction.atomic(): order_item = order.items.create( item_type=OrderItemTypes.service, product=tld.register_product, cycle=cycle, fixed_price=cycle.fixed_price, cycle_display=cycle.display_name, plugin_data=plugin_data, name=domain_name, description=_('Domain registration'), ) if dns_cycle: OrderItemConfigurableOption.objects.create( order_item=order_item, option=tld.dns_option, option_value="yes", quantity=1, has_price=True, unit_price=dns_cycle.price, price=dns_cycle.price, setup_fee=0) if email_cycle: OrderItemConfigurableOption.objects.create( order_item=order_item, option=tld.email_option, option_value="yes", quantity=1, has_price=True, unit_price=email_cycle.price, price=email_cycle.price, setup_fee=0) if id_cycle: OrderItemConfigurableOption.objects.create( order_item=order_item, option=tld.id_option, option_value="yes", quantity=1, has_price=True, unit_price=id_cycle.price, price=id_cycle.price, setup_fee=0) if not validate_services_limit(): raise APIException( _('License service limit reached. Please check your license' ), ) create_service_for_item(item=order_item) return Response(data={ 'order_id': order.id, })