def respond_with_schema(self, schema: Schema, value, status: int = 200) -> Response:
try:
schema.validate(value)
except ValidationError:
return self.error("invalid schema supplied")
result = schema.dump(value)
return self.respond(result, status)
def validate_schema(schema: Schema, data: dict, remove_blank=False):
"""schema验证,验证成功返回数据，验证失败返回错误信息
Parameters
----------
schema:Schema: 验证规则
data: 验证数据
remove_blank : 是否去除空白字段
Returns (data,errors)
-------
"""
if not data:
return {}, []
if not isinstance(data, dict):
return Msg.PARAMS_ERROR, 400
if remove_blank:
for k, v in data.items():
if v != "":
data[k] = v
try:
validate_data = schema.validate(data)
return validate_data, []
except SchemaError as e:
return {}, str(e.autos)
else:
return validate_data, []
def validate_file(name: str, schema: Schema):
with console.status(f"Validating {name}...", spinner="dots"):
errors = schema.validate(get_data_json(f"mtgjson/{name}.json"))
if errors:
pprint(errors["data"], max_length=10, console=console)
console.print(f"❌ [bold red]{name} had {len(errors['data'])} errors")
else:
console.print(f"✅ [bold green]{name} validated")
def validate(schema: Schema, data):
error_msgs = schema.validate(data)
if not error_msgs:
return
if '_schema' in error_msgs and error_msgs['_schema']:
msg = ', '.join(error_msgs['_schema'])
raise CommonException(error_code=error_codes.SERVER_PARAM_INVALID,
msg=msg)
raise CommonException(error_code=error_codes.SERVER_PARAM_INVALID,
data=error_msgs)
def data_dump_and_validation(schema: Schema, data: Any) -> Dict:
"""
Use a marshmallow schema to dump and validate input data
:param schema: the schema to use to dump an object and validate it
:param data: the data to dump and validate
:return: the resulting dumped data from marshmallow
"""
val = schema.dump(data)
errors = schema.validate(val)
if errors:
raise ValidationError(errors)
return val
def build_response(self, schema: Schema, response):
"""
Validate the given response against a given Schema.
Return the response data as a serialized object according to the given Schema's fields.
:param schema:
:param response:
:return:
"""
# Validate that schema.
# This is not normally done with responses, but I want to be strict about ensuring the schema is up-to-date
validation_errors = schema.validate(response)
if validation_errors:
# Throw an exception here with all the errors.
# This will be caught and handled by the 500 internal error
raise exceptions.ValidationError(validation_errors)
# Build schema object from response
data = schema.dump(response)
return data
def read_json_request(self, schema: Schema):
"""
:param schema:
:type schema: Schema descendant
:return:
"""
# Ensure body can be JSON decoded
try:
json_data = json.loads(self.request.body)
except JSONDecodeError as e:
self.set_status(self.STATUS_ERROR_EXTERNAL, reason=str(e))
self.write_error()
raise BaseApiError("Expected request body to be JSON. Received '{}'".format(self.request.body))
request_validation_errors = schema.validate(json_data)
if request_validation_errors:
self.error_messages = request_validation_errors
self.set_status(self.STATUS_ERROR_EXTERNAL, reason="Failed request schema validation")
self.write_error()
raise BaseApiError("Failed schema validation: {}".format(str(request_validation_errors)))
return schema.dump(schema.load(json_data))
def validate_data(serializer: Schema, data: Dict):
validation_errors = serializer.validate(data)
if validation_errors:
raise HTTPError(403, validation_errors)
return True
