def validate(data, schema=None):
if schema is None:
schema = generate()
JsonSchemaValidator.check_schema(schema)
validator = JsonSchemaValidator(schema)
errors = list(validator.iter_errors(data))
if not errors:
return check_unique(data) or []
try:
resp = policy_error_scope(specific_error(errors[0]), data)
name = isinstance(
errors[0].instance,
dict) and errors[0].instance.get(
'name',
'unknown') or 'unknown'
return [resp, name]
except Exception:
logging.exception(
"specific_error failed, traceback, followed by fallback")
return list(filter(None, [
errors[0],
best_match(validator.iter_errors(data)),
]))
def validate(data, schema=None):
if schema is None:
schema = generate()
Validator.check_schema(schema)
validator = Validator(schema)
errors = list(validator.iter_errors(data))
if not errors:
counter = Counter([p['name'] for p in data.get('policies')])
dupes = []
for k, v in counter.items():
if v > 1:
dupes.append(k)
if dupes:
return [
ValueError(
"Only one policy with a given name allowed, duplicates: %s"
% (", ".join(dupes)))
]
return []
try:
resp = specific_error(errors[0])
name = isinstance(errors[0].instance, dict) and errors[0].instance.get(
'name', 'unknown') or 'unknown'
return [resp, name]
except Exception:
logging.exception(
"specific_error failed, traceback, followed by fallback")
return list(
filter(None, [
errors[0],
best_match(validator.iter_errors(data)),
]))
def validate(data, schema=None):
if schema is None:
schema = generate()
Validator.check_schema(schema)
validator = Validator(schema)
errors = list(validator.iter_errors(data))
if not errors:
counter = Counter([p['name'] for p in data.get('policies')])
dupes = []
for k, v in counter.items():
if v > 1:
dupes.append(k)
if dupes:
return [ValueError(
"Only one policy with a given name allowed, duplicates: %s" % (
", ".join(dupes)))]
return []
try:
resp = specific_error(errors[0])
name = isinstance(errors[0].instance, dict) and errors[0].instance.get('name', 'unknown') or 'unknown'
return [resp, name]
except Exception:
logging.exception(
"specific_error failed, traceback, followed by fallback")
return filter(None, [
errors[0],
best_match(validator.iter_errors(data)),
])
def validate(data):
schema = generate()
Validator.check_schema(schema)
validator = Validator(schema)
errors = list(validator.iter_errors(data))
if not errors:
counter = Counter([p['name'] for p in data.get('policies')])
dupes = []
for k, v in counter.items():
if v > 1:
dupes.append(k)
if dupes:
return [
ValueError(
"Only one policy with a given name allowed, duplicates: %s"
% (", ".join(dupes)))
]
return []
try:
return [specific_error(errors[0])]
except Exception:
logging.exception(
"specific_error failed, traceback, followed by fallback")
return filter(None, [
errors[0],
best_match(validator.iter_errors(data)),
])
def validate(data, schema=None):
if schema is None:
schema = generate()
Validator.check_schema(schema)
validator = Validator(schema)
errors = list(validator.iter_errors(data))
if not errors:
return check_unique(data) or []
try:
resp = policy_error_scope(specific_error(errors[0]), data)
name = isinstance(
errors[0].instance,
dict) and errors[0].instance.get(
'name',
'unknown') or 'unknown'
return [resp, name]
except Exception:
logging.exception(
"specific_error failed, traceback, followed by fallback")
return list(filter(None, [
errors[0],
best_match(validator.iter_errors(data)),
]))
def validate(data):
schema = generate()
Validator.check_schema(schema)
validator = Validator(schema)
errors = list(validator.iter_errors(data))
if not errors:
return []
try:
return [specific_error(errors[0])]
except Exception:
logging.exception(
"specific_error failed, traceback, followed by fallback")
return filter(None, [
errors[0],
best_match(validator.iter_errors(data)),
])
def validate(schema_filename, data):
with open(schema_filename) as f:
schema = json.load(f) # cteme JSON Schema primo ze souboru
Validator.check_schema(schema) # zkontroluje schema nebo vyhodi vyjimku
base_uri = 'file://' + os.path.dirname(schema_filename) + '/'
resolver = RefResolver(base_uri, schema)
validator = Validator(schema, resolver=resolver)
return validator.iter_errors(data) # vraci chyby jednu po druhe
def _validate_data(self, data: dict, validator: jsonschema.Draft4Validator):
"""
Validates data against provider schema. Raises :class:`BadArguments` if relevant
:param data: Data to validate
:param validator: :class:`jsonschema.Draft4Validator`
"""
log.debug('validating provided data')
e = best_match(validator.iter_errors(data))
if e:
raise BadArguments(validation_error=e.message, provider=self.provider_name, data=data)
def use_validator(validator: jsonschema.Draft4Validator,
payload: Dict) -> List:
errors = sorted(validator.iter_errors(payload), key=lambda e: e.path)
if len(errors) > 0:
error_list = [(list(e.absolute_schema_path), e.message)
for e in errors]
else:
error_list = []
return error_list
