def parse_invitation_token(token): signer = TimestampSigner() try: payload = signer.unsign(token, max_age=settings.WALDUR_CORE['INVITATION_MAX_AGE']) except BadSignature: raise serializers.ValidationError('Invalid signature.') parts = payload.split('.') if len(parts) != 2: raise serializers.ValidationError('Invalid payload.') user_uuid = parts[0] invitation_uuid = parts[1] if not core_utils.is_uuid_like(user_uuid): raise serializers.ValidationError('Invalid user UUID.') try: user = core_models.User.objects.filter(uuid=parts[0], is_active=True, is_staff=True).get() except core_models.User.DoesNotExist: raise serializers.ValidationError('Invalid user UUID.') if not core_utils.is_uuid_like(invitation_uuid): raise serializers.ValidationError('Invalid invitation UUID.') try: invitation = models.Invitation.objects.get(uuid=parts[1], state=models.Invitation.State.REQUESTED) except models.Invitation.DoesNotExist: raise serializers.ValidationError('Invalid invitation UUID.') return user, invitation
def handle(self, *args, **options): offering_uuid = options['offering'] path = options['path'] if not is_uuid_like(offering_uuid): self.stdout.write(self.style.ERROR('Offering UUID is not valid.')) return if not os.path.exists(path): self.stdout.write( self.style.ERROR('The file path does not exist.')) return try: offering = models.Offering.objects.get(uuid=offering_uuid) except models.Offering.DoesNotExist: self.stdout.write( self.style.ERROR('Offering with UUID: %s is not found.' % offering_uuid)) return json_path, pic_path = export_offering(offering, path) self.stdout.write( self.style.SUCCESS('Offering data has been exported to %s.' % json_path)) if pic_path: self.stdout.write( self.style.SUCCESS( 'Offering thumbnail has been exported to %s.' % pic_path))
def get(self, request): cluster_uuid = request.query_params.get('cluster_uuid') if not cluster_uuid or not is_uuid_like(cluster_uuid): raise ValidationError('Cluster UUID is required.') cluster = self.get_object(request, models.Cluster, cluster_uuid) backend = cluster.settings.get_backend() applications = backend.list_cluster_applications(cluster) applications = self.paginate_queryset(applications) return self.get_paginated_response(applications)
def filter_queryset(self, request, queryset, view): customer_uuid = request.query_params.get('service_provider_uuid') if customer_uuid and is_uuid_like(customer_uuid): customers = models.Resource.objects.filter( offering__customer__uuid=customer_uuid).values_list( 'project__customer_id', flat=True) queryset = queryset.filter(pk__in=customers) return queryset
def filter_query(self, queryset, name, value): if is_uuid_like(value): if queryset.filter(uuid=value).exists(): return queryset.filter(uuid=value) else: return self.filter_scope_uuid(queryset, name, value) else: return queryset.filter( Q(name__icontains=value) | Q(backend_metadata__external_ips__icontains=value) | Q(backend_metadata__internal_ips__icontains=value))
def get_plan(): plan_uuid = settings.WALDUR_HPC['PLAN_UUID'] if not plan_uuid: logger.debug('Plan is not specified.') return if not is_uuid_like(plan_uuid): logger.warning('Plan UUID is invalid.') return try: return Plan.objects.get(uuid=plan_uuid) except Plan.DoesNotExist: logger.warning('Plan UUID %s is not found', plan_uuid) return
def get_external_customer(): customer_uuid = settings.WALDUR_HPC['EXTERNAL_CUSTOMER_UUID'] if not customer_uuid: logger.debug('External customer is not specified.') return if not is_uuid_like(customer_uuid): logger.warning('External customer UUID is invalid.') return try: return Customer.objects.get(uuid=customer_uuid) except Customer.DoesNotExist: logger.warning('Customer with UUID %s is not found', customer_uuid) return
def get_object(uuid, model, model_name): if uuid: if not is_uuid_like(uuid): self.stdout.write( self.style.ERROR('%s UUID is not valid.' % model_name)) return try: return model.objects.get(uuid=uuid) except model.DoesNotExist: self.stdout.write( self.style.ERROR('%s with UUID: %s is not found.' % (model_name, uuid)))
def delete(self, request): project_uuid = request.data.get('project_uuid') if not project_uuid or not is_uuid_like(project_uuid): raise ValidationError('Project UUID is required.') project = self.get_object(request, models.Project, project_uuid) app_id = request.data.get('app_id') if not app_id: raise ValidationError('App ID is required.') backend = project.settings.get_backend() try: backend.client.destroy_application(project.backend_id, app_id) except RancherException as e: return response.Response({'detail': str(e)}, status=status.HTTP_400_BAD_REQUEST) return response.Response(status=status.HTTP_204_NO_CONTENT)
def get_private_settings(self): service_settings_uuid = self.request.query_params.get('service_settings_uuid') if not service_settings_uuid or not core_utils.is_uuid_like(service_settings_uuid): return structure_models.ServiceSettings.objects.none() queryset = structure_models.ServiceSettings.objects.filter(type=OpenStackConfig.service_name) try: shared_settings = queryset.get(uuid=service_settings_uuid) except structure_models.ServiceSettings.DoesNotExist: return structure_models.ServiceSettings.objects.none() tenants = openstack_models.Tenant.objects.filter(service_project_link__service__settings=shared_settings) if tenants: return structure_models.ServiceSettings.objects.filter(scope__in=tenants) else: return structure_models.ServiceSettings.objects.none()
def get_items(self, invoice): resource_uuid = self.context['request'].GET.get('resource_uuid') qs = invoice.items.all() if resource_uuid: if core_utils.is_uuid_like(resource_uuid): qs = qs.filter(resource__uuid=resource_uuid) else: raise rf_exceptions.ValidationError( 'Passed resource_uuid is not UUID.') qs = qs.order_by('project_name', 'name') items = utils.filter_invoice_items(qs) serializer = InvoiceItemSerializer(items, many=True, context=self.context) return serializer.data
def get(self, request): project_uuid = request.query_params.get('project_uuid') if not project_uuid or not is_uuid_like(project_uuid): raise ValidationError('Project UUID is required.') project = self.get_object(request, models.Project, project_uuid) client = project.settings.get_backend().client applications = client.get_project_applications(project.backend_id) return response.Response( [ { 'name': app['name'], 'state': app['state'], 'created': app['created'], 'id': app['id'], 'answers': app['answers'], } for app in applications ] )
def get_offering(): offering_uuid = settings.WALDUR_HPC['OFFERING_UUID'] if not offering_uuid: logger.debug('Offering is not specified.') return if not is_uuid_like(offering_uuid): logger.warning('Offering UUID is invalid.') return try: offering = Offering.objects.get(uuid=offering_uuid) except Offering.DoesNotExist: logger.warning('Offering UUID %s is not found', offering_uuid) return if not offering.shared: logger.warning('Offering is not shared.') return return offering
def confirm_email(self, request): code = request.data.get('code') if not code or not is_uuid_like(code): raise ValidationError(_('The confirmation code is required.')) change_request = get_object_or_404(core_models.ChangeEmailRequest, uuid=code) if (change_request.created + django_settings.WALDUR_CORE['EMAIL_CHANGE_MAX_AGE'] < timezone.now()): raise ValidationError(_('Request has expired.')) with transaction.atomic(): change_request.user.email = change_request.email change_request.user.save(update_fields=['email']) core_models.ChangeEmailRequest.objects.filter( email=change_request.email).delete() return Response( {'detail': _('Email has been successfully updated.')}, status=status.HTTP_200_OK, )
def create(self, request, *args, **kwargs): serializer = self.get_serializer(data=request.data, many=True) serializer.is_valid(raise_exception=True) checklist = get_object_or_404(models.Checklist, uuid=self.kwargs['checklist_uuid']) # we allow staff users to answer on behalf of users on_behalf_user_uuid = request.query_params.get('on_behalf_user_uuid', '') if request.user.is_staff and on_behalf_user_uuid: if not is_uuid_like(on_behalf_user_uuid): raise ValidationError({ 'on_behalf_user_uuid': "Format of user UUID is not correct" }) try: user = User.objects.get(uuid=on_behalf_user_uuid) except User.DoesNotExist: raise ValidationError( {'on_behalf_user_uuid': "User was not found."}) else: user = request.user for answer in serializer.validated_data: question = get_object_or_404(models.Question, uuid=answer['question_uuid'], checklist=checklist) models.Answer.objects.update_or_create( question=question, user=user, defaults={'value': answer['value']}, ) headers = self.get_success_headers(serializer.data) return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
def validate(self, attrs): token = attrs.pop('token') signer = signing.TimestampSigner() try: issue_uuid = signer.unsign( token, max_age=timedelta(days=settings.ISSUE_FEEDBACK_TOKEN_PERIOD)) if not is_uuid_like(issue_uuid): raise serializers.ValidationError( {'token': _('UUID:%s is not valid.') % issue_uuid}) issue = models.Issue.objects.get(uuid=issue_uuid) if models.Feedback.objects.filter(issue=issue).exists(): raise serializers.ValidationError( _('Feedback for this issue already exists.')) except signing.BadSignature: raise serializers.ValidationError({'token': _('Token is wrong.')}) except models.Issue.DoesNotExist: raise serializers.ValidationError(_('An issue is not found.')) attrs['issue'] = issue return attrs
def filter_query(self, queryset, name, value): if is_uuid_like(value): return queryset.filter(uuid=value) else: return queryset.filter(name__icontains=value)
def get_project(self): project_uuid = self.kwargs['project_uuid'] if not is_uuid_like(project_uuid): return Response(status=status.HTTP_400_BAD_REQUEST, data='Project UUID is invalid.') return get_object_or_404(structure_models.Project, uuid=project_uuid)
def get_category(self): category_uuid = self.kwargs['category_uuid'] if not is_uuid_like(category_uuid): return Response(status=status.HTTP_400_BAD_REQUEST, data='Category UUID is invalid.') return get_object_or_404(models.Category, uuid=category_uuid)