def post(self, request, customer_uuid, format=None):
customer = get_object_or_404(Customer, uuid=customer_uuid)
is_owner(request, self, customer)
serializer = serializers.CustomerChecklistUpdateSerializer(
data=request.data, context={'request': request})
serializer.is_valid(raise_exception=True)
target_ids = set(
[checklist.id for checklist in serializer.validated_data])
ChecklistCustomers = models.Checklist.customers.through
current_checklists = ChecklistCustomers.objects.filter(
customer=customer)
current_ids = set([checklist.id for checklist in current_checklists])
stale_ids = current_ids - target_ids
new_ids = target_ids - current_ids
current_checklists.filter(id__in=stale_ids).delete()
for checklist_id in new_ids:
ChecklistCustomers.objects.create(customer=customer,
checklist_id=checklist_id)
return Response({'detail': _('Customer checklist have been updated.')})
def get(self, request, customer_uuid, checklist_uuid, format=None):
customer = get_object_or_404(Customer, uuid=customer_uuid)
is_owner(request, self, customer)
checklist = get_object_or_404(models.Checklist, uuid=checklist_uuid)
total_questions = checklist.questions.count()
points = []
for project in Project.objects.filter(
customer=customer).order_by('name'):
project_users = project.get_users()
customer_users = customer.get_owners()
users_count = project_users.count() + customer_users.count()
correct_count = (models.Answer.objects.filter(
Q(user__in=project_users) | Q(user__in=customer_users)).filter(
question__checklist=checklist,
value=F('question__correct_answer'),
).count())
points.append(
dict(
name=project.name,
uuid=project.uuid.hex,
score=get_score(correct_count,
total_questions * users_count),
))
return Response(points)
def can_register_service_provider(request, customer):
if request.user.is_staff:
return
if not django_settings.WALDUR_MARKETPLACE[
'OWNER_CAN_REGISTER_SERVICE_PROVIDER']:
raise exceptions.PermissionDenied()
structure_permissions.is_owner(request, None, customer)
def validate(self, attrs):
if not self.instance:
structure_permissions.is_owner(self.context['request'], None,
attrs['offering'].customer)
self._validate_components(attrs)
return attrs
def get(self, request, customer_uuid, checklist_uuid, format=None):
try:
customer = Customer.objects.get(uuid=customer_uuid)
except Customer.DoesNotExist:
raise ValidationError(_('Customer does not exist.'))
is_owner(request, self, customer)
checklist = get_object_or_404(models.Checklist, uuid=checklist_uuid)
total_questions = max(1, checklist.questions.count())
points = []
for project in Project.objects.filter(
customer=customer).order_by('name'):
correct_count = models.Answer.objects.filter(
project=project,
question__checklist=checklist,
value=F('question__correct_answer'),
).count()
points.append(
dict(
name=project.name,
uuid=project.uuid.hex,
score=round(
100 * correct_count / total_questions,
2,
),
))
return Response(points)
def validate_project(self, project):
request = self.context['request']
structure_permissions.is_owner(request, None, project.customer)
if models.ExpertRequest.objects.filter(
state=models.ExpertRequest.States.ACTIVE,
project=project).exists():
raise serializers.ValidationError(
_('Active expert request for current project already exists.'))
return project
def can_update_offering(request, view, obj=None):
offering = obj
if not offering:
return
if offering.state == models.Offering.States.DRAFT:
structure_permissions.is_owner(request, view, offering)
else:
structure_permissions.is_staff(request, view)
def delete_permission_check(request, view, obj=None):
if not obj:
return
if obj.service_project_link.service.settings.shared:
if settings.WALDUR_OPENSTACK['MANAGER_CAN_MANAGE_TENANTS']:
structure_permissions.is_manager(request, view, obj)
else:
structure_permissions.is_owner(request, view, obj)
else:
structure_permissions.is_administrator(request, view, obj)
def validate(self, attrs):
customer = (
attrs.get('customer') if not self.instance else self.instance.customer
)
end_date = attrs.get('end_date')
if end_date:
structure_permissions.is_owner(self.context['request'], None, customer)
return attrs
def get(self, request, customer_uuid, format=None):
customer = get_object_or_404(Customer, uuid=customer_uuid)
is_owner(request, self, customer)
ChecklistCustomers = models.Checklist.customers.through
current_checklists = ChecklistCustomers.objects.filter(
customer=customer)
serializer = serializers.CustomerChecklistUpdateSerializer(
[cc.checklist for cc in current_checklists],
context={'request': request})
return Response(serializer.data)
def validate(self, attrs):
# We do not need to check ToS acceptance if provider is already created.
if self.instance:
structure_permissions.is_owner(self.context['request'], None, self.instance.customer)
return attrs
agree_with_policy = attrs.pop('agree_with_policy', False)
if not agree_with_policy:
raise serializers.ValidationError(
{'agree_with_policy': _('User must agree with policies to register organization.')})
structure_permissions.is_owner(self.context['request'], None, attrs['customer'])
return attrs
def validate(self, attrs):
if not self.instance:
structure_permissions.is_owner(self.context['request'], None,
attrs['customer'])
offering_attributes = attrs.get('attributes')
if offering_attributes is not None:
if not isinstance(offering_attributes, dict):
raise rf_exceptions.ValidationError(
{'attributes': 'Dictionary is expected.'})
category = attrs.get('category',
getattr(self.instance, 'category', None))
self._validate_attributes(offering_attributes, category)
return attrs
def can_user_update_settings(request, view, obj=None):
""" Only staff can update shared settings, otherwise user has to be an owner of the settings."""
if obj is None:
return
# TODO [TM:3/21/17] clean it up after WAL-634. Clean up service settings update tests as well.
if obj.customer and not obj.shared:
return permissions.is_owner(request, view, obj)
else:
return permissions.is_staff(request, view, obj)
def validate(self, attrs):
if not self.instance:
structure_permissions.is_owner(self.context['request'], None,
attrs['customer'])
return attrs
