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)
