def _validate(self, doc, **kwargs):
lookup = {'act': doc['act'], 'type': doc[ITEM_TYPE]}
use_headline = kwargs and 'headline' in kwargs
validators = superdesk.get_resource_service('validators').get(req=None, lookup=lookup)
for validator in validators:
v = Validator()
v.allow_unknown = True
v.validate(doc['validate'], validator['schema'])
error_list = v.errors
response = []
for e in error_list:
if error_list[e] == 'required field' or type(error_list[e]) is dict:
message = '{} is a required field'.format(e.upper())
elif 'min length is' in error_list[e]:
message = '{} is too short'.format(e.upper())
elif 'max length is' in error_list[e]:
message = '{} is too long'.format(e.upper())
else:
message = '{} {}'.format(e.upper(), error_list[e])
if use_headline:
response.append('{}: {}'.format(doc['validate'].get('headline',
doc['validate'].get('_id')), message))
else:
response.append(message)
return response
else:
return ['validator was not found for {}'.format(doc['act'])]
def test_coerce_not_destructive():
schema = {
'amount': {'coerce': int}
}
v = Validator(schema)
doc = {'amount': '1'}
v.validate(doc)
assert v.document is not doc
def test_readonly_field_first_rule():
# test that readonly rule is checked before any other rule, and blocks.
# See #63.
schema = {"a_readonly_number": {"type": "integer", "readonly": True, "max": 1}}
v = Validator(schema)
v.validate({"a_readonly_number": 2})
# it would be a list if there's more than one error; we get a dict
# instead.
assert "read-only" in v.errors["a_readonly_number"][0]
def test_callable_validator():
"""
Validator instance is callable, functions as a shorthand
passthrough to validate()
"""
schema = {"test_field": {"type": "string"}}
v = Validator(schema)
assert v.validate({"test_field": "foo"})
assert v({"test_field": "foo"})
assert not v.validate({"test_field": 1})
assert not v({"test_field": 1})
def max_min_length_example():
"""对于字符串项, 可以限制字符串的长度。
"""
schema = {"password": {"type": "string", "minlength": 8, "maxlength": 20}}
v = Validator(schema)
print(v.validate({"password": "******"}))
print(v.errors)
print(v.validate({"password": "******"}))
print(v.errors)
def regex_example():
"""对字符串进行正则匹配验证。
"""
email_regex ="([a-z0-9!#$%&'*+\/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+\/=?^_`{|}~-]+)*(@|\sat\s)(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(\.|\sdot\s))+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)"
schema = {"email": {"type": "string", "regex": email_regex}}
v = Validator(schema)
print(v.validate({"email": "*****@*****.**"}))
print(v.validate({"email": "123456"}))
print(v.errors)
def allow_unknown_example():
"""默认需要data中所有的key都要在schema中被预定义。而设置allow_unknown = True可以允许出现
没有被预定义的key
"""
schema = {"name": {"type": "string", "maxlength": 10}}
v = Validator(schema)
print(v.validate({"name": "john", "sex": "M"}))
print(v.errors)
v.allow_unknown = True
print(v.validate({"name": "john", "sex": "M"}))
def test_callable_validator():
"""
Validator instance is callable, functions as a shorthand
passthrough to validate()
"""
schema = {'test_field': {'type': 'string'}}
v = Validator(schema)
assert v.validate({'test_field': 'foo'})
assert v({'test_field': 'foo'})
assert not v.validate({'test_field': 1})
assert not v({'test_field': 1})
def max_min_example():
"""对于数值项, 可以限制其最大值和最小值。
"""
schema = {"value": {"type": "number", "min": 0, "max": 1}}
v = Validator(schema)
print(v.validate({"value": 1.5}))
print(v.validate({"value": -0.5}))
print(v.errors)
print(v.validate({"value": 1.5}))
print(v.errors)
def function_based_custom_validators():
"""以函数的方式自定义你的validator
"""
def validate_oddity(field, value, error):
if not bool(value & 1):
error(field, "Must be an odd number")
schema = {"oddity": {"validator": validate_oddity}}
v = Validator(schema)
print(v.validate({"oddity": 10}))
print(v.errors)
print(v.validate({"oddity": 9}))
def allowed_example():
"""对list中的值的取值进行限制。
我们可以通过设定::
"allowed": [item1, item2, ...]
使得list中的值必须是allowed中的元素
"""
schema = {"role": {"type": "list", "allowed": ["agent", "client", "supplier"]}}
v = Validator(schema)
print(v.validate({"role": ["agent", "supplier"]}))
print(v.validate({"role": ["agent", "boss"]}))
print(v.errors)
def test_readonly_field_first_rule():
# test that readonly rule is checked before any other rule, and blocks.
# See #63.
schema = {
'a_readonly_number': {
'type': 'integer',
'readonly': True,
'max': 1
}
}
v = Validator(schema)
v.validate({'a_readonly_number': 2})
# it would be a list if there's more than one error; we get a dict
# instead.
assert 'read-only' in v.errors['a_readonly_number'][0]
def validate(self):
"""
Validates the action_block based on the cerberus schema
example:
action_block :: sample ::
- name: manipulate_inventory
type: shell
path: /tmp/shellscripts
actions:
- thisisshell.sh
"""
schema = {
'name': {'type': 'string', 'required': True},
'type': {
'type': 'string',
'allowed': ['shell', 'subprocess']
},
'path': {'type': 'string', 'required': False},
'context': {'type': 'boolean', 'required': False},
'actions': {
'type': 'list',
'schema': {'type': 'string'},
'required': True
}
}
v = Validator(schema)
status = v.validate(self.action_data)
if not status:
raise HookError("Invalid Syntax: {0}".format(str(v.errors)))
else:
return status
class EsquemaGrupo():
def __init__(self, *claves_requeridas):
self.cadena = {'type': 'string'}
self.correo = {'type': 'string', 'regex': "(?i)^[A-Z0-9._%!#$%&'*+-/=?^_`{|}~()]+@[A-Z0-9]+([.-][A-Z0-9]+)*\.[A-Z]{2,22}$"}
self.cadena_enteros = {'type': 'string', 'regex': "[0-9]+"}
esquema = {}
esquema["cn"] = self.cadena.copy()
esquema["type"] = self.cadena_enteros.copy()
esquema["description"] = self.cadena.copy()
esquema["mail"] = self.correo.copy()
esquema["notes"] = self.cadena.copy()
esquema = self._requeridor(esquema, claves_requeridas)
self.validador = Validator(esquema)
def _requeridor(self, esquema, claves_requeridas):
for clave in claves_requeridas:
esquema[clave]['required'] = True
return esquema
def validacion(self, contenido):
if self.validador.validate(contenido):
return contenido
else:
raise DatosException(self.validador.errors)
def __init__(self, environment_name, nova_descriptor_file=None):
self._nova_descriptor_file = nova_descriptor_file or 'nova.yml'
self._environment_name = environment_name
self._environment = None
self._codedeploy_app = None
self.templates_used = dict()
yaml.add_constructor("!include", yaml_include)
with open(os.path.join(spec.__path__[0], 'nova_service_schema.yml'), 'r') as schemaYaml:
schema = yaml.load(schemaYaml)
v = Validator(schema)
try:
with open(self._nova_descriptor_file, 'r') as novaYaml:
self.service_spec = yaml.safe_load(novaYaml)
# Validate loaded dictionary
valid = v.validate(self.service_spec)
if not valid:
raise NovaError("Invalid nova service descriptor file '%s': %s" % (self._nova_descriptor_file, v.errors))
else:
self.service = Service.load(self.service_spec)
self.service_name = self.service.name
self.service_port = self.service.port
self.service_healthcheck_url = self.service.healthcheck_url
except IOError:
raise NovaError("No nova service descriptor found at '%s'" % self._nova_descriptor_file)
async def registration(request: web.Request) -> Dict:
payload = await base.get_payload(request)
validator = Validator(schema=users.schema)
if not validator.validate(payload):
raise ValidationError(validator.errors)
async with request.app['engine'].acquire() as conn:
count = await conn.scalar(
sqlalchemy.select([sqlalchemy.func.count()])
.select_from(users.table)
.where(users.table.c.login == payload['login'])
)
if count:
raise ValidationError({'login': '******'})
user = {
'login': payload['login'],
'password': users.encrypt_password(payload['password']),
'created_on': datetime.now()
}
user = await create_instance(user, users.table, conn)
return base.json_response({
'id': user['id'],
'login': user['login']
}, status=201)
def validate(self):
"""
Validates the action_block based on the cerberus schema
"""
schema = {
'name': {'type': 'string', 'required': True},
'type': {'type': 'string', 'allowed': ['ruby']},
'path': {'type': 'string', 'required': False},
'context': {'type': 'boolean', 'required': False},
'actions': {
'type': 'list',
'schema': {'type': 'string'},
'required': True
}
}
v = Validator(schema)
status = v.validate(self.action_data)
if not status:
raise HookError("Invalid syntax: {0}".format(str((v.errors))))
else:
return status
def allowed_for_single_value():
"""对于值进行限制, 只能使预定义的几个值中的一个。
"""
schema = {"label": {"type": "integer", "allowed": [1, 2, 3]}}
v = Validator(schema)
print(v.validate({"label": 1}))
def validate(self):
# pdb.set_trace()
v = Validator(self.schema)
status = v.validate(self.result)
if not status:
return v.errors
return None
def add_friend_to_group(id):
user = current_user._get_current_object()
form = request.get_json()
schema = {
'id':{'type':'integer','empty':False},
}
v = Validator(schema)
if v.validate(form) is False:
return api_validation_error(v.errors)
#first see if this is a valid group
group = FriendsGroup.query.filter(and_(FriendsGroup.user_id == user.id,FriendsGroup.id == id)).first()
if group:
#lets see if this is a confirmed friend of yours
friend = Friends.query.filter(and_(Friends.user_id == user.id,Friends.friend_id == form['id'])).first()
if friend:
#lets see if this friend is not in this group
if friend.group_id == group.id:
return api_error("This friend is already in this group")
else:
friend.group_id = group.id
meeple.db.session.commit()
return api_package()
else:
return api_error("Friend does not exist")
else:
return api_error("This group does not exist.")
def validate_cred(cred, f):
v = Validator()
valid = v.validate(cred, schema)
for e in v.errors:
logger.error("[validate_cred] Validation Error: %s, %s - %s" % (f, e, v.errors[e]))
return valid
def check_bx_users(fn):
"""Check the consistentcy of the BX-Users.csv file.
"""
tab = etl.fromcsv(fn, delimiter=DELIMITER,
quoting=QUOTE_ALL, encoding=ENCODING)
v = Validator({
"User-ID" : {
"type" : "string",
"regex" : USER_ID_PAT,
"required" : True
},
"Location" : {
"type" : "string",
"required" : True
},
"Age" : {
"type" : "string",
"validator" : validate_age,
"required" : True
}
})
for row_num, r in enumerate(tab.dicts(), 1):
is_valid = v.validate(r)
if not is_valid:
print "row %d -> %r, %r" % (row_num, v.errors, r)
return
def _validate_page(self, page):
schema = {'page': {'type': 'integer', 'min': 1}}
v = Validator(schema)
try:
return v.validate({'page': int(page)})
except Exception:
return False
def check_bx_book_ratings(fn):
"""Check the consistency of the BX-Book-Ratings.csv file.
"""
tab = etl.fromcsv(fn, delimiter=DELIMITER,
quoting=QUOTE_ALL, encoding=ENCODING)
v = Validator({
"User-ID" : {
"type" : "string",
"required" : True
},
"ISBN" : {
"type" : "string",
"required" : True
},
"Book-Rating" : {
"type" : "string",
"validator" : validate_rating,
"required" : True
}
})
for row_num, r in enumerate(tab.dicts(), 1):
is_valid = v.validate(r)
if not is_valid:
print "row %d -> %r, %r" % (row_num, v.errors, r)
return
def confirm_friend():
user = current_user._get_current_object()
form = request.get_json()
schema = {
'id':{'type':'integer','empty':False}
}
v = Validator(schema)
if v.validate(form) is False:
return api_validation_error(v.errors)
friend_request = FriendRequests.query.filter(FriendRequests.id == form['id']).first()
if friend_request:
#we are confirming this, so create friendships that last both ways.
my_friend = Friends(user_id = user.id,friend_id = friend_request.friend_id)
their_friend = Friends(user_id = friend_request.friend_id,friend_id = user.id)
meeple.db.session.add(my_friend)
meeple.db.session.add(their_friend)
meeple.db.session.delete(friend_request) #remove this friend request
meeple.db.session.commit()
#now return who this friend is back to them.
return api_package(data=my_friend.as_dict())
else:
return api_error("This request does not exist")
def validate_filter(filter):
for key, value in filter.items():
if '*' not in allowed and key not in allowed:
return "filter on '%s' not allowed" % key
if key in ('$or', '$and', '$nor'):
if not isinstance(value, list):
return "operator '%s' expects a list of sub-queries" % key
for v in value:
if not isinstance(v, dict):
return "operator '%s' expects a list of sub-queries" \
% key
r = validate_filter(v)
if r:
return r
else:
if config.VALIDATE_FILTERS:
res_schema = config.DOMAIN[resource]['schema']
if key not in res_schema:
return "filter on '%s' is invalid"
else:
field_schema = res_schema.get(key)
v = Validator({key: field_schema})
if not v.validate({key: value}):
return "filter on '%s' is invalid"
else:
return None
def anyof_example():
"""定义: 值需要满足以下几个条件中的任意一个
除了anyof, 类似的还有: allof, noneof, oneof
"""
schema = {"value": {"type": "number", "anyof": [{"min": 0, "max": 10}, {"min": 100, "max": 1000}]}}
v = Validator(schema)
document = {"value": 1}
print(v.validate(document, schema))
document = {"value": 111}
print(v.validate(document, schema))
document = {"value": 11}
print(v.validate(document, schema))
print(v.errors)
def validate_info():
v = Validator()
schema = {
'title': {'required': True, 'type': 'string'},
'version': {'required': True, 'type': 'string'},
'description': {'type': 'string'},
'termsOfService': {'type': 'string'},
'contact': {
'type': 'dict',
'schema': {
'name': {'type': 'string'},
'url': {'type': 'string', 'validator': _validate_url},
'email': {
'type': 'string',
'regex':
'^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$'
}
}
},
'license': {
'type': 'dict',
'schema': {
'name': {'type': 'string', 'required': True},
'url': {'type': 'string', 'validator': _validate_url}
}
},
}
if eve_swagger.INFO not in app.config:
raise ConfigException('%s setting is required in Eve configuration.' %
eve_swagger.INFO)
if not v.validate(app.config[eve_swagger.INFO], schema):
raise ConfigException('%s is misconfigured: %s' % (
eve_swagger.INFO, v.errors))
def put(self, request, *args, **kwargs):
team_info = json.loads(request.body.decode('utf-8'))
validator = Validator(team_schema)
if not validator.validate(team_info):
return JsonResponse({'error': validator.errors})
try:
team = Team.objects.get(id=int(self.kwargs['team_id']))
except ObjectDoesNotExist:
return JsonResponse({'error': [{"Team ID": "Team not found for ID in request"}]})
check_scope(request, team)
report = team.report_set.first()
if 'send_time' in team_info:
report.survey_send_time = parser.parse(team_info['send_time']).replace(second=0, microsecond=0)
if 'summary_time' in team_info:
report.summary_send_time = parser.parse(team_info['summary_time']).replace(second=0, microsecond=0)
if 'days_of_week' in team_info:
rule = recurrence.Rule(recurrence.WEEKLY, byday=team_info['days_of_week'])
rec = recurrence.Recurrence(rrules=[rule])
report.recurrences = rec
if 'name' in team_info:
team.name = team_info['name']
report.save()
try:
team.save()
except IntegrityError:
return JsonResponse({'error': {"name": _("team with this name already exists")}})
team_dict = model_to_dict(team, exclude=['users'])
team_dict['report'] = self.report_dict(team)
return JsonResponse({'team': team_dict})
def new_place():
if flask.request.method == 'POST':
v = Validator({
'name': {'type': 'string', 'minlength': 3},
'description': {'type': 'string', 'required': True},
'location': {'type': 'string', 'required': True},
})
form = dict(flask.request.form.items())
try:
del form['g-recaptcha-response']
except KeyError:
pass
if check_recaptcha() and v.validate(form):
author = make_author()
place = Place(v.document['name'], v.document['description'],
v.document['location'], author)
place.scale = PlaceScale()
flask.g.sql_session.add(place)
flask.g.sql_session.commit()
return flask.redirect(flask.url_for('.place', slug=place.slug))
else:
return flask.render_template('place/new.html', errors=v.errors)
return flask.render_template('place/new.html')
def validate_add(self, report_id, data):
"""
Validate add type
:report_id: the report id we are modifying
:data: the data we want to add to the report
"""
validator = Validator(Schemas().add, allow_unknown=True)
validation = validator.validate(data)
if not validation:
raise ValidationError(validator.errors)
if data["type"] == "test":
data = self.validate_step_add(report_id, data)
elif data["type"] == "scenario":
data = self.validate_scenario_add(report_id, data)
return data
def wrapped_view(**kwargs):
if "application/json" not in request.headers["Content-Type"]:
return jsonify({
"message":
"Content-Type must be `application/json`."
}), Status.BAD_REQUEST
v = Validator(schema)
g.data = {key: request.json[key] for key in schema.keys()}
if not v.validate(g.data):
return jsonify({
"message": f"Errors in request data: {v.errors}"
}), Status.BAD_REQUEST
return view(**kwargs)
def validate_document(validation_schema, document):
"""
Validate the format of a document, depending on the schema supplied in the class constructor.
Args:
validation_schema (dict): The schema the document has to follow.
document (dict): The format specification.
"""
validator = Validator(validation_schema)
# Check if the document is valid.
if not validator.validate(document):
raise ApiUnprocessableEntity(
u"The submitted document doesn't have the right format.",
api_error_code=u"WRONG_DOCUMENT_FORMAT",
payload=validator.errors)
return None
def validate_yml_file(yml_file, yml_file_dir):
v = Validator(schema)
if not v.validate(yml_file):
print(v.errors)
exit(
'Please follow schema definition as declared in schema.py. Exiting.'
)
hasErrors = False
for path in yml_file['paths']:
if not _maps_to_folder(os.path.join(yml_file_dir, path)):
hasErrors = True
print("Provided path: " +
os.path.abspath(os.path.join(yml_file_dir, path)))
if hasErrors:
exit('No directory found for previous paths. Exiting.')
class LoginValidator:
def __init__(self):
self.__schema = {
'email': {
'type': 'string',
'required': True
},
'password': {
'type': 'string',
'required': True
},
}
self.__validator = Validator()
def validate_login(self, login: dict):
return self.__validator.validate(login, self.__schema)
def put(self):
data = request.get_json()
validator = Validator(self.login_schema)
is_valid = validator.validate(data)
if not is_valid:
return self.json_response(validator.errors, HTTPStatus.BAD_REQUEST)
clean_data = validator.normalized(data)
user = self.logged_user
if 'fullname' in clean_data:
user.fullname = clean_data['fullname']
user.set_password(clean_data['password'])
db.session.add(user)
db.session.commit()
return self.json_response({'id': user.id}, HTTPStatus.ACCEPTED)
def validateData(cls, data, _request):
schema = {
'category_name': {
'required': True,
'empty': False,
'type': 'string'
},
'logo': {
'required': True,
'empty': False,
'type': 'string'
}
}
v = Validator(schema)
v.allow_unknown = True
return True if (v.validate(data)) else v.errors
def validate(self, schema, payload):
try:
check_data = Validator(schema)
validate = check_data.validate(payload)
status = None
message = None
if (validate == True):
status = "success"
message = payload
else:
status = "error"
error_data = {i for i in check_data.errors}
message = f"""Invalid Paramerters found for: '{error_data}'."""
return {"status": status, "message": message}
except BaseException as error:
return {"status": "error", "message": error}
def test_list_all_links_not_empty_body(purge_all_links, create_shortcut_link):
response = requests.get(url='http://localhost:8888/admin/all_links')
v = Validator({
'links': {
'type': 'dict',
'schema': {
str(create_shortcut_link.json()['id']): {
'type': 'string',
'allowed':
['https://github.com/Yurasb/url_shortener_testing']
}
}
}
})
assert v.validate(response.json()), v.errors
def delete(self):
schema = {'name': {'type': 'string', 'empty': False, 'required': True}}
v = Validator(schema, allow_unknown=True)
if not v.validate(self.__dict__):
raise NonRecoverableError("Object schema not valid")
response = self.fm_client.delete_path(name=self.name)
ctx.logger.debug("Path {} {} response: {} {}".format(
'DELETE', self.name, response['status_code'], response['content']))
if response['status_code'] != 200:
raise NonRecoverableError(
"Delete Path {0} failed with response {1} {2}".format(
self.name, response['status_code'], response['content']))
else:
ctx.logger.info("Delete Path {} response successful: {} {}".format(
self.name, response['status_code'], response['content']))
def create(cls, postId=None):
request_data = return_request_data()
coll = db[cls.collection]
v = Validator(cls.schema)
if not v.validate(request_data):
return make_error(status=400, description=v.errors)
else:
if cls.__name__ == "User":
if users.find_one({"username": request_data.get('username')}) is not None:
return make_error(400, description="Username is exist, please choose another.")
request_data["birthday"] = datetime.strptime(
request_data.get("birthday"), format_str)
result = coll.insert_one(request_data)
post = coll.find_one({'_id': result.inserted_id})
logger.warn('Update %r', post)
return Utils.return_jsonify(post)
def validate_initialisation_request(parameters):
"""Validate parameters for initialisation request
Args:
parameters (dict): The request parameters in the initialisation request
Returns:
boolean: Returns True if the validation is a success
"""
logger.info("Validating initialisation parameters")
initialisation_validator = Validator(initialisation_parameters)
result = initialisation_validator.validate(parameters)
if result:
return True
logger.error("Validation Failed: {0}".format(initialisation_validator.errors))
raise BadRequest
def validate_file(filename, dump=False):
"""
Auxiliary function, validate file
:return dict representing the YAML document. NOTE that the
returned dict hasn't removed any 'additional' key from the original
file.
"""
validated = False # reflect whether the overall process suceeded
cyan("Validating " + str(filename) + "...")
doc = None
try:
with open(click.format_filename(filename), 'r') as stream:
try:
doc = yaml.load(stream, Loader=yaml.FullLoader)
except yaml.YAMLError as exception:
raise exception
except FileNotFoundError:
red("File " + str(filename) + " not found")
v = Validator(SCHEMA, allow_unknown=True) # allow unknown values
if doc:
# print(MyNormalizer().normalized(doc, SCHEMA))
if not v.validate(doc, SCHEMA):
# print(v.errors)
for key in v.errors.keys():
print("\t" + str(key) + ": ", end='')
red("not valid", end='')
print(': ' + str(v.errors[key]))
else:
# print(v.validated(doc))
# valid_documents = [x for x in v.validated(doc)]
# for document in valid_documents:
# print("\t" + str(document) + ": ", end='')
# green("valid")
green("Validated successfully!")
validated = True
# else:
# red("file to validate not processed correctly!")
if dump:
print(json.dumps(v.document, indent=4, default=default))
# flaw = Flaw(v.document)
# print the final document after validations and normalizations
# print(flaw)
# print(flaw.yml())
return validated, v.document
def validate(raw):
schema = {
"version": {
"type": "string",
"allowed": ["1.0"]
},
"athletes": {
"type": "list",
"minlength": 1,
"schema": {
"type": "dict",
"schema": {
"born": {
"type": "integer",
"min": 1900,
"max": 2100
},
"club": {
"type": "string",
"minlength": 4,
"maxlength": 4,
"required": False
},
"id": {
"type": "integer",
"required": False
},
"name": {
"type": "string"
},
"sex": {
"type": "string",
"allowed": ["f", "m"]
},
"surname": {
"type": "string"
}
}
}
}
}
v = Validator(schema, require_all=True)
if not v.validate(raw):
print(v.errors)
raise Exception("Athletes file does not validate")
return v.document
def patch_site_settings_values(**kwargs):
body = kwargs.get('body')
email = kwargs.get('email')
settings = {
'site_visibility': body.get('site_visibility', ''),
'title': body.get('title', ''),
'fontsize': body.get('fontsize', ''),
'coloraccent': body.get('coloraccent', ''),
'isdarkmode': body.get('isdarkmode', ''),
'description': body.get('description', ''),
'copyright': body.get('copyright', ''),
'websiteurl': body.get('websiteurl', ''),
'brandmail': body.get('brandmail', ''),
'brandlogourl': body.get('brandlogourl', ''),
'faviconurl': body.get('faviconurl', ''),
'appiconurl': body.get('appiconurl', '')
}
schema_validation = Validator(PATCH_ADMIN_SETTINGS_SCHEMA)
remove_empty_values_of_dict(settings)
resp = None
if schema_validation.validate(settings):
query = dynamic_update_query(
settings, 'settings.site_settings', '', email)
print(query)
msg = {
'body': {
'action': 'run',
'queries': [query]
}
}
method, result = db_handler(msg)
print(result)
if method == 'ok':
resp = settings
else:
return bad_request(schema_validation.errors)
return ok(resp)
async def _handle_open_stream(self, message):
log.info("Handling %s", message)
route = message['route']
data = message['message']
stream = message['stream']
session_key = message.get('session')
log.info("Opening stream %s", stream)
# Make sure requested route exists
if route not in self.routes:
await self.send_error(stream, 404, 'Route not found')
return
# Make sure user doesn't have too many streams open
if len(self.generators) >= self.MAX_STREAMS:
await self.send_error(stream, 400, 'Too many open streams')
return
# Check message schema
if self.routes[route].schema:
validator = Validator(schema=self.routes[route].schema)
if not validator.validate({"message": data}):
log.error("Invalid message received: %s", validator.errors, extra={'body': message})
await self.send_error(stream, 400, "Bad request", error_fields=validator.errors)
return
# Get a DB connection and a new session.
async with self.db.acquire() as db_connection, self.sessions.acquire(session_key) as session:
req = Request(
db=db_connection,
session=session,
message=data,
stream=stream,
route=route)
response = Response(
protocol=self,
stream=stream)
try:
fn = self.routes[route].handler
async with db_connection.transaction():
await fn(req, response)
await response.close()
except Exception as e:
log.exception("Handler failed: %s", str(e), extra={'body': message})
await self.send_error(stream, 500, 'Internal server error')
def recursive_validate_filter(key, value, schema):
if key not in schema:
base_key, _, sub_keys = key.partition('.')
if sub_keys and base_key in schema:
# key is the composition of base field and
# sub-fields
sub_schemas = get_sub_schemas(schema[base_key])
for sub_schema in sub_schemas:
if recursive_validate_filter(
sub_keys, value, sub_schema):
return True
return False
else:
field_schema = schema.get(key)
v = Validator({key: field_schema})
return v.validate({key: value})
def cli():
"""Validate input data and call the appropriate subcommand with necessary arguments"""
args = parse_args(sys.argv[1:])
logger.setLevel(args.pop('log') * 10)
cmd = args.pop('command')
# read in configuration file and destination folder
config = json.load(open(args.get('config')))
dest_folder = args.get('dest')
# create destination folder if necessary
if not op.isdir(dest_folder):
makedirs(dest_folder)
# validate configuration file
v = Validator(schema)
valid = v.validate(config)
if not valid:
raise Exception(v.errors)
# custom validation for top level keys
# require either: country & bounding_box or geojson
if 'geojson' not in config.keys() and not (
'country' in config.keys() and 'bounding_box' in config.keys()):
raise Exception(
'either "geojson" or "country" and "bounding_box" must be present in the configuration JSON'
)
# for geojson, overwrite other config keys to correct labeling
if 'geojson' in config.keys():
config['country'] = op.splitext(op.basename(config.get('geojson')))[0]
config['bounding_box'] = get_bounds(
json.load(open(config.get('geojson'), 'r')))
if cmd == 'download':
download_mbtiles(dest_folder=dest_folder, **config)
elif cmd == 'labels':
sparse = args.get('sparse', False)
make_labels(dest_folder=dest_folder, sparse=sparse, **config)
elif cmd == 'preview':
number = args.get('number')
preview(dest_folder=dest_folder, number=number, **config)
elif cmd == 'images':
download_images(dest_folder=dest_folder, **config)
elif cmd == 'package':
package_directory(dest_folder=dest_folder, **config)
def run(schema_filename: str, config_filename: str) -> None:
schema = yaml.load(read_yaml(schema_filename), Loader=yaml.FullLoader)
config_data = yaml.load(read_yaml(config_filename), Loader=yaml.FullLoader)
v = Validator(schema)
result = v.validate(config_data)
if not result:
print(v.errors)
sys.exit(1)
config = ConfigClassDict(config_data)
print(config)
print(config.version)
print(config.jobs.build.docker)
print(config.jobs.build.docker.image)
print(config.workflows.build_and_test.jobs)
def get_config(self):
"""
Reads the configuration from the config.yaml file and verifies that is compilant with the validation schema
:return:
Dictionary with the configuration or None if the config file is invalid
"""
data = Config.read_yaml(self.config_file)
schema = Config.read_yaml(self.validation_schema)
try:
validator = Validator(schema)
if validator.validate(data):
return data
else:
return None
except Exception as e:
print("ERROR: Exception trying to validate configuration file:" +
str(e))
def update_transaction(code):
validator = Validator(Transaction.schema)
payload = request.get_json()
if not validator.validate(payload):
return make_response(jsonify(validator.errors), 400)
transaction = Transaction.get(code)
transaction = Transaction.from_json(payload, transaction)
session.add(transaction)
session.commit()
session.flush()
return make_response(jsonify(transaction.to_json()), 200)
def validate_api_get_user_info(data_input):
"""
:param data_input:
:return:
"""
schema = {
'email': {
'required': True,
'type': 'string',
'regex': '^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$'
},
}
v = Validator(schema)
if v.validate(data_input):
return True, data_input
else:
return False, v.errors
def edit_book_validation(self, dict_data):
'''edit book data validation function using CERBERUS'''
schema = {
'title': {
'type': 'string',
'required': False,
'empty': True,
'regex': '^[a-zA-Z0-9 ]+$',
'maxlength': 25,
'minlength': 4},
'author': {
'type': 'string',
'required': False,
'regex': '^[a-zA-Z0-9 ]+$',
'empty': True,
'maxlength': 25,
'minlength': 4},
'genre': {
'type': 'string',
'required': False,
'regex': '^[a-zA-Z0-9 ]+$',
'empty': True,
'maxlength': 20,
'minlength': 4},
'copies': {
'type': 'string',
'required': False,
'regex': '^[0-9]+$',
'empty': False,
'maxlength': 1,
'minlength': 3},
'isbn': {
'type': 'string',
'required': False,
'regex': '^[0-9]+$',
'empty': False,
'maxlength': 13,
'minlength': 13},
'description': {
'type': 'string',
'required': False,
'maxlength': 200,
'minlength': 4}}
v = Validator(schema)
v.allow_unknown = True
return v.validate(dict_data)
def validate_verification(_in):
schema = {
"verification": {
"type": "list",
"maxlength": 1,
"minlength": 1,
"nullable": False,
"required": True,
"items": [{
"type": "string"
}],
},
}
v = Validator(schema)
is_valid = v.validate(_in)
return is_valid, v.errors
def validator(request, schema, target):
"""
Run validation using Cerberus and a given schema and target dictionary;
raises an http exception with details when validation fails.
"""
validator = Validator(schema)
if not validator.validate(target):
raise BadRequest(
response={
"notification": {
"body":
"Some of the provided information is invalid. Please correct the errors and try again.",
"type": "popup_notifications",
"delay": 5,
},
})
return request
def _validate_and_sanitize(self, method, params):
"""
This internal method is used to validate and sanitize the parameters
expected by the given method. These parameters are validated and
sanitized according to a schema provided by a method following the
naming convention: '_validator_{method_name}'.
:param method:
:param params:
:return:
"""
method_name = method.__name__
schema = self._get_schema_for_method(method_name)
v = Validator(schema, purge_unknown=True)
if v.validate(params):
return v.document
_logger.error("BadRequest %s", v.errors)
raise UserError(_('Invalid Form'))
def test_stats_redirected_body(purge_all_links, create_shortcut_link,
redirect_by_id):
response = requests.post(url='http://localhost:8888/stats',
data=json.dumps(
{'id': create_shortcut_link.json()['id']}))
v = Validator({
'last_redirected': {
'nullable': False,
'type': 'float'
},
'redirects_count': {
'type': 'integer',
'allowed': [1]
}
})
assert v.validate(response.json()), v.errors
def create():
# Assume comment belongs to the temporary test user
user = get_temp_test_user()
if user:
# Validate comment attributes
v = Validator(comment_schema)
if v.validate(request.get_json()):
attrs = v.document
# Insert valid comment in DB
if comments_collection.insert_one(attrs).inserted_id:
return jsonify({}), HTTP_201_CREATED
else:
return jsonify({}), HTTP_500_INTERNAL_SERVER_ERROR
else:
return jsonify(v.errors), HTTP_422_UNPROCESSABLE_ENTITY
else:
return jsonify({'error': 'Test user doesn\'t exist'}), HTTP_422_UNPROCESSABLE_ENTITY
def completed():
out = request.json
schema = {
"timer_id": {"type": "integer", "required": True},
"current_time": {"type": "integer", "required": True},
}
validator = Validator(schema)
if not validator.validate(out):
return {"MSG": "INVALID REQUEST"}
timestamp = datetime.datetime.fromtimestamp(out["current_time"])
timestamp = timestamp.strftime("%Y-%m-%d %H:%M:%S")
query = f"UPDATE pomodoro SET stop_time = TIMESTAMP '{timestamp}' WHERE pomodoro_id = {out['timer_id']} RETURNING *;"
print(query)
db.execute(query)
query = f"UPDATE pomodoro SET status = 'completed' WHERE pomodoro_id = {out['timer_id']} RETURNING *;"
out = next(db.execute(query))
return {i: j for i, j in out.items()}
def validate_document(document, schema, **kwargs):
"""
Validate `document` against provided `schema`
:param document: document for validation
:type document: dict
:param schema: validation schema
:type schema: dict
:param kwargs: additional arguments for `Validator`
:return: normalized and validated document
:rtype: dict
:raise: `BadRequest` if `document` is not valid
"""
validator = Validator(schema, **kwargs)
if not validator.validate(document):
raise BadRequest(validator.errors)
return validator.document
