def validate(self, data=None, _id=None):
# prevent 500 error on empty payload
if not data:
data = {}
# ensure that required fields are supplied, if creating
if not _id:
required_fields = [field.name for field in self.fields if field.required]
for f in required_fields:
try:
assert f in data.keys()
except AssertionError:
raise ValidationError('This field is required', field=f)
# ensure that all input fields are valid field names
for key, val in data.items():
if not key in self.fieldnames:
raise ValidationError('Invalid field', field=key)
# perform field-level validation
field = self.get_field_by_name(key)
field.validate(val, _id=_id)
auto_fields = [field for field in self.fields if field.auto]
for f in auto_fields:
data[f.name] = f.set(_id=_id)
return data
def validate(self, data, _id=None):
"""
Checks to see if a document in the related model's collection matches the ID provided as `data`
"""
data = super().validate(data, _id=_id)
try:
self.related.retrieve(data)
except InvalidId:
raise ValidationError('Invalid id', field=self.name)
except NotFound:
raise ValidationError('Cannot find %s with ID %s' %
(self.related.name, data),
field=self.name)
return data
def validate(self, data, _id=None):
"""
When creating or updating an object. This method validates the inputs
:param data: data to validate
:type data: dict
:param _id: ID as a string, or None in case of new objects
:type _id: str or None
:rtype: dict
"""
if self.unique:
query = {self.name: data}
if _id:
"""
If object is being updated, the query is adjusted to exclude the object being updated (otherwise,
it isn't possible to save an object without changing the unique field values every time)
"""
query['_id'] = {'$not': {'$eq': ObjectId(_id)}}
if self.model.collection.find(query).count() > 0:
raise ValidationError('%s with this %s already exists' %
(self.model.name, self.name),
field=self.name)
return data
def validate(self, data=None, _id=None):
if not data:
data = {}
if not _id:
try:
assert self.username_field in data.keys()
assert 'password' in data.keys()
except AssertionError:
raise ValidationError('Username and password must be provided')
if self.user_exists(data[self.username_field]):
raise ValidationError('That user already exists')
return data
def check_invalid_keys(self, keys):
key = None
try:
for key in keys:
assert key in [self.username_field, 'password']
except AssertionError:
raise ValidationError('Invalid field', field=key)
def test_exceptions(
self,
*args,
):
from crudcast.exceptions import handle_invalid_usage, ValidationError
with self.assertRaises(RuntimeError):
handle_invalid_usage(ValidationError('test', status_code=415))
def validate(self, data, _id=None):
"""
Validates the input string by asserting that the time format is valid
"""
data = super().validate(data, _id=_id)
try:
datetime.strptime(data, self.format_string)
except ValueError as err:
raise ValidationError(err, field=self.name)
return data
def validate(self, data, _id=None):
"""
Checks that the input value is a Boolean
"""
data = super().validate(data, _id=_id)
try:
assert data in [True, False]
except AssertionError:
raise ValidationError('Input must be true or false',
field=self.name)
return data
def validate(self, data, _id=None):
"""
Asserts that the input is numeric
"""
data = super().validate(data, _id=_id)
try:
assert isinstance(data, (int, float, complex))
except AssertionError:
raise ValidationError('Input must be numeric', field=self.name)
return data
def validate(self, data, _id=None):
"""
Validates that the input value is a string
"""
data = super().validate(data, _id=_id)
try:
assert isinstance(data, str)
except AssertionError:
raise ValidationError('Input must be a string', field=self.name)
return data
def validate(self, data, _id=None):
"""
Any attempt to set the value of an auto field will raise a validation error
"""
raise ValidationError('Auto fields cannot be set manually',
field=self.name)