def __call__(self, value):
queryset = self.queryset
slug = re.sub(r'[^\w]', '', value.replace(' ', '_').lower())
queryset = self.filter_queryset(value, slug, queryset)
queryset = self.exclude_current_instance(queryset)
if qs_exists(queryset):
#q1 = queryset.filter(Q(title__exact=value))
#q2 = queryset.filter(Q(slug__exact=slug))
if qs_exists(queryset.filter(Q(title__exact=value))):
raise ValidationError(self.message, code='unique')
elif qs_exists(queryset.filter(Q(slug__exact=slug))):
raise ValidationError('Non Unique Slug Generated: ' + slug,
code='unique')
def __call__(self, value):
room = None
start = None
end = None
# Default to current values, if instance exists
if self.instance is not None:
room = self.instance.room
start = self.instance.start_date
end = self.instance.end_date
room = value.get('room', room)
start = value.get('start_date', start)
end = value.get('end_date', end)
overlap_q = (Q(start_date__lte=start, end_date__gte=start)
| Q(start_date__lte=end, end_date__gte=end)
| Q(start_date__lte=start, end_date__gte=end)
| Q(start_date__gte=start, end_date__lte=end))
queryset = Reservation.objects.filter(overlap_q, room=room)
# Exclude current instance if updating an existing range
if self.instance is not None:
queryset = queryset.exclude(id=self.instance.id)
if qs_exists(queryset):
raise serializers.ValidationError(
'Conflicting reservation exists for this room and date range.')
def __call__(self, value):
queryset = self.queryset
queryset = self.filter_queryset(value, queryset)
queryset = self.exclude_current_instance(queryset)
if validators.qs_exists(queryset):
raise ValidationError(
self.message,
code=generate_code(fields=[self.prefix, self.field_name]))
def __call__(self, value, serializer_field):
# Determine the underlying model field name. This may not be the
# same as the serializer field name if `source=<>` is set.
field_name = serializer_field.source_attrs[-1]
# Determine the existing instance, if this is an update operation.
instance = getattr(serializer_field.parent, 'instance', None)
queryset = self.queryset
queryset = self.filter_queryset(value, queryset, field_name)
if validators.qs_exists(queryset) and not self.include_current_instance(instance, serializer_field, value):
raise validators.ValidationError(self.message, code='unique')
def __call__(self, value, serializer_field):
# Determine the underlying model field name. This may not be the
# same as the serializer field name if `source=<>` is set.
field_name = serializer_field.source_attrs[-1]
# Determine the existing instance, if this is an update operation.
instance = getattr(serializer_field.parent, 'instance', None)
queryset = self.queryset
queryset = self.filter_queryset(value, queryset, field_name)
queryset = self.exclude_current_instance(queryset, instance)
if qs_exists(queryset):
raise APIException(message=self.message)
def like(self, request, pk=None):
# validate the post pk in url by calling get_object which inside will call
# get_object_or_404
post = self.get_object()
if qs_exists(PostLike.objects.filter(post=post, liker=request.user)):
raise serializers.ValidationError('You already liked this post',
code='unique')
post_like = PostLike(post=post, liker=request.user)
post_like.save()
serializer = self.get_serializer(post_like)
return Response(serializer.data, status=status.HTTP_201_CREATED)
def __call__(self, attrs):
self.enforce_required_fields(attrs)
queryset = self.queryset
queryset = self.filter_queryset(attrs, queryset)
queryset = self.exclude_current_instance(attrs, queryset)
# Ignore validation if any field is None
checked_values = [
value for field, value in attrs.items() if field in self.fields
]
if None not in checked_values and validators.qs_exists(queryset):
raise ValidationError({self.key_field_name: self.message},
code=self.code
or generate_code(fields=self.fields))
def __call__(self, attrs):
self.enforce_required_fields(attrs)
queryset = self.queryset
queryset = self.filter_queryset(attrs, queryset)
queryset = self.exclude_current_instance(attrs, queryset)
# Ignore validation if any field is None
checked_values = [
value for field, value in attrs.items() if field in self.fields
]
if None not in checked_values and qs_exists(queryset):
# field_names = ', '.join(self.fields)
# message = self.message.format(field_names=field_names)
# raise ValidationError(message, code='unique')
raise ValidationError(self.message, code='unique')
def cancel_like(self, request, pk=None):
# validate the post pk in url by calling get_object which inside will call
# get_object_or_404
post = self.get_object()
if not qs_exists(PostLike.objects.filter(post=post,
liker=request.user)):
raise serializers.ValidationError(
'You can not cancel your like because you did not like this post before.'
)
instance = PostLike.objects.get(post=post, liker=request.user)
instance.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def __call__(self, attrs, serializer):
self.enforce_required_fields(attrs, serializer)
queryset = self.queryset
queryset = self.filter_queryset(attrs, queryset, serializer)
queryset = self.exclude_current_instance(attrs, queryset,
serializer.instance)
# Ignore validation if any field is None
checked_values = [
value for field, value in attrs.items() if field in self.fields
]
if None not in checked_values and qs_exists(queryset):
duplicated_record = queryset.values_list(self.duplicate_field,
flat=True).first()
message = self.message.format(duplicate_field=duplicated_record)
raise ValidationError(message, code="unique")
def validate_id(self, value):
message = _('This field must be unique.')
if value is None:
return value
ModelClass = self.Meta.model
queryset = ModelClass.objects.filter(pk=check_uuid(value))
existing_instance = getattr(self.fields['id'].parent, 'instance', None)
if existing_instance is not None:
queryset = queryset.exclude(pk=self.instance.pk)
if qs_exists(queryset):
raise ValidationError(message, code='unique')
return value
def __call__(self, attrs, serializer):
self.enforce_required_fields(attrs, serializer)
queryset = self.queryset
queryset = self.filter_queryset(attrs, queryset, serializer)
queryset = self.exclude_current_instance(attrs, queryset,
serializer.instance)
# Ignore validation if any field is None
checked_values = [
value for field, value in attrs.items() if field in self.fields
]
if None not in checked_values and qs_exists(queryset):
field_names = ', '.join(self.fields)
message = self.message.format(field_names=field_names)
field = ''.join(self.fields[0].split('_'))
raise ValidationError({field: message},
code=constants.ERR_UNIQUE_FIELD)
def __call__(self, attrs, serializer, *args, **kwargs):
# Ignore validation if the many flag is set
if getattr(serializer.root, 'many', False):
return
self.enforce_required_fields(attrs, serializer)
queryset = self.queryset
queryset = self.filter_queryset(attrs, queryset, serializer)
queryset = self.exclude_current_instance(attrs, queryset,
serializer.instance)
# Ignore validation if any field is None
checked_values = [
value for field, value in attrs.items() if field in self.fields
]
if None not in checked_values and qs_exists(queryset):
types = queryset.values_list('type', flat=True)
types = ', '.join(types)
message = self.message.format(types=types)
raise ValidationError(message, code='exclusive')
def __call__(self, value):
queryset = self.queryset
queryset = self.filter_queryset(value, queryset)
queryset = self.exclude_current_instance(queryset)
if qs_exists(queryset):
raise InvalidParameterException(self.message, code='unique')
def test_qs_exists_handles_data_error(self):
class DataErrorQueryset(object):
def exists(self):
raise DataError
assert qs_exists(DataErrorQueryset()) is False
def test_qs_exists_handles_value_error(self):
class ValueErrorQueryset(object):
def exists(self):
raise ValueError
assert qs_exists(ValueErrorQueryset()) is False
def test_qs_exists_handles_type_error(self):
class TypeErrorQueryset(object):
def exists(self):
raise TypeError
assert qs_exists(TypeErrorQueryset()) is False
def test_qs_exists_handles_type_error(self):
class TypeErrorQueryset:
def exists(self):
raise TypeError
assert qs_exists(TypeErrorQueryset()) is False
def test_qs_exists_handles_value_error(self):
class ValueErrorQueryset:
def exists(self):
raise ValueError
assert qs_exists(ValueErrorQueryset()) is False
def test_qs_exists_handles_data_error(self):
class DataErrorQueryset:
def exists(self):
raise DataError
assert qs_exists(DataErrorQueryset()) is False
