def to_internal_value(self, data):
"""
Data transformation to python list object.
:param object data: Data for transformation.
:return: Transformed data.
:rtype: list
:raise ValidationError: If data not valid.
"""
# Parse data.
if html.is_html_input(data):
data = html.parse_html_list(data)
# Initial validation that came in an array.
if not isinstance(data, list):
message = self.error_messages['not_a_list'].format(
input_type=type(data).__name__)
raise ValidationError(detail={'non_field_errors': [message]},
code='not_a_list')
# Validation that this is not an empty value and whether it is empty.
if not self.allow_empty and len(data) == 0:
message = self.error_messages['empty']
raise ValidationError(detail={'non_field_errors': [message]},
code='empty')
res, errors = [], [] # Make storage for results.
# Validating each item from the list.
for item in data:
try:
value = self.child.run_validation(item)
except ValidationError as e:
res.append({})
errors.append(e.detail)
else:
res.append(value)
errors.append({})
# If the conversion and validation failed.
if any(errors):
raise ValidationError(detail=errors)
# We return the transformed and validated data.
return res
async def get_valid_json(self, parse_query=False, raise_exception=True):
"""
Make, Validate and return JSON from request BODY.
:param bool parse_query: Parse query or only body?
:param bool raise_exception: Raise exception if body not parse?
:return: Validated data from request BODY.
:rtype: Optional[dict]
"""
# Get request query
data = self.request_object.query.copy() if parse_query else {}
# Get request body
try:
request_json = await self.request_object.json()
data.update(request_json)
except JSONDecodeError:
if raise_exception:
raise ValidationError(detail='Not valid json.')
# Validate body request.
serializer = self.get_request_serializer()
if serializer is None:
return None
serializer = serializer(data=data)
serializer.is_valid(raise_exception=True)
return serializer.validated_data
def validate_empty_values(self, data):
"""
Check if the value is empty.
:param object data: Data for check.
:return: The result of check, and current data.
If there is a default value and nothing is passed, returns the default.
Tuple: (is None, actual data)
:rtype: tuple
:raise ValidationError: If validation on an empty field did not pass.
"""
# Process.
is_empty, data = data is None, data if data is not None else self.default
# Validating.
if is_empty and not self.required:
return is_empty, data
# If empty and not necessary, then there is nothing to validate and transformed.
if is_empty:
raise ValidationError(detail=self.error_messages['required'])
# Return.
return is_empty, data
def is_valid(self, raise_exception=False):
"""
Validates the data that came into the serializer.
:param bool raise_exception: Is there an exception if validation fails?
:return: Validation result.
:rtype: bool
"""
if not hasattr(self, 'initial_data'):
raise AssertionError(
'Cannot call `.is_valid()` as no `data=` keyword argument '
'was passed when instantiating the serializer instance.')
# Preparing storage for results.
self._errors, self._validated_data = [], []
# Validating all fields
try:
self._validated_data = self.to_internal_value(self.initial_data)
except ValidationError as e:
self._errors = e.detail
# If you need to throw an error, we throw.
if self._errors and raise_exception:
self._validated_data = []
raise ValidationError(detail=self._errors)
# Return validation result.
return not bool(self._errors)
def run_validation(self, data):
"""
Runs validation on the current serializer..
:param object data: Data for validation.
:return: Transformed and validated data.
:rtype: dict
"""
# We first check to see if an empty field has arrived?
is_empty, data = self.validate_empty_values(data)
# Transformed to python type.
value = self.to_internal_value(data)
# Validating validators.
try:
self.run_validators(value)
value = self.validate(value)
assert value is not None, '`.validate ()` should return a valid value.'
except ValidationError as e:
raise ValidationError(detail=e.detail)
# We return the validated and transformed value.
return value
def __call__(self, value: object):
"""
Validation.
:param object value: Object for validation.
"""
if value not in self.choices:
raise ValidationError(
self.message.format(**dict(allowed_values=self.choices)))
def __call__(self, value):
"""
Validation.
:param iter value: Object for validation.
:raise ValidationError: If not valid data.
"""
if value is None:
raise ValidationError(self.message)
def fail_validate(self, detail=None, status=400):
"""
We throw a normal error if custom validation error.
:param Union[str, dict] detail: Detail validation error
:param int status: Code for response
:raise AssertionError: If you have not found the key in the `self.error_messages`.
:raise ValidationError: If you find the key in the `self.error_messages`.
"""
raise ValidationError(detail=detail, status=status)
def __call__(self, value):
"""
Validation.
:param iter value: Object for validation.
:raise ValidationError: If not valid data.
"""
if len(value) < self.min_length:
raise ValidationError(
self.message.format(min_length=self.min_length))
def __call__(self, value):
"""
Validate that the input contains a match for the regular expression
if inverse_match is False, otherwise raise ValidationError.
:param object value: Value for validation.
:raise: ValidationError: If not valid data.
"""
if not (self.inverse_match is not bool(self.regex.search(value))):
raise ValidationError(self.message)
def __call__(self, value):
"""
Validation.
:param object value: Value for validation.
:raise ValidationError: If not valid data.
"""
if value > self.max_value:
raise ValidationError(
self.message.format(max_value=self.max_value))
def _field_validation(self, fields_dict, data):
"""
Validation add fields
:param dict fields_dict: Dictionary with initialized fields that we validate.
:param dict data: Data that is validated.
:return: Validated and transformed data.
:raise ValidationError: If errors occurred during validation.
"""
validated_data, errors = OrderedDict(), OrderedDict()
# Running through the fields.
for _, field_obj in six.iteritems(fields_dict):
field_name = field_obj._get_field_name()
try:
# Check by empty for nested serializer fields
is_empty, _field_data = field_obj.validate_empty_values(
data.get(field_name, None))
if is_empty:
if field_name in data:
validated_data[field_name] = _field_data
continue
# Transform to python type and validate each field.
validated_val = field_obj.run_validation(_field_data)
# Now manual validation.
validated_val = self._manual_validate_method(
field_name, validated_val)
# And if there was a field in the incoming data, then we save it in the converted form.
if field_name in data:
validated_data[field_name] = validated_val
elif field_obj.default:
validated_data[field_name] = field_obj.default
except ValidationError as e:
# If not passed validation, save the error.
errors[field_name] = e.detail
except (AttributeError, TypeError, ValueError):
# If data not valid format.
errors[
field_name] = 'Could not parse data for field `{}`.'.format(
field_name)
if any(errors):
raise ValidationError(detail=errors)
return validated_data
def run_validators(self, value):
"""
Validates all field validators.
:param object value: Data for validation.
:raise ValidationError: If validation fails.
"""
errors = []
for validator in self.validators or []:
try:
# Run each validator.
validator(value)
except ValidationError as e:
errors.append(e.detail)
# Check on errors.
if errors:
raise ValidationError(detail=errors)
def is_valid(self, raise_exception=False):
"""
Validates the data that came into the serializer.
:param bool raise_exception: Whether to throw an exception if validation failed?
:return: Validation result.
:rtype: bool
"""
if not hasattr(self, 'initial_data'):
raise AssertionError(
'Cannot call `.is_valid()` as no `data=` keyword argument '
'was passed when instantiating the serializer instance.')
# Preparing storage for results.
self._errors, self._validated_data = OrderedDict(), OrderedDict()
# Validated all fields.
try:
self._validated_data = self._field_validation(
self.fields, self.initial_data)
except ValidationError as e:
self._errors = e.detail
# Now run the full manual validation method.
try:
self._validated_data = self.validate(
self._validated_data
) if not self._errors else self._validated_data
except ValidationError as e:
self._errors['errors'] = e.detail
# If you need to throw an error, we throw.
if self._errors and raise_exception:
self._validated_data = OrderedDict()
raise ValidationError(detail=self._errors)
# Return validation result.
return not bool(self._errors)
def fail_field_validation(self, key, **kwargs):
"""
We throw a normal error if something went wrong during data processing.
:param str key: Error type. Key for dict `self.default_error_messages`.
:param kwargs: Data to format error message.
:raise AssertionError: If you have not found the key in the `self.error_messages`.
:raise ValidationError: If you find the key in the `self.error_messages`.
"""
# Trying to get an error message.
try:
msg = self.error_messages[key]
except KeyError:
# If we could not talk about it, I use a general message.
class_name = self.__class__.__name__
msg = MISSING_ERROR_MESSAGE.format(class_name=class_name, key=key)
raise AssertionError(msg)
# Format the message and throw an error.
message_string = msg.format(**kwargs)
raise ValidationError(detail=message_string, status=key)