def decorator(func):
from functools import wraps
@wraps(func)
def inner(*args, **kwargs):
from flask import request
user = None
if authorization:
bearer_token = request.headers.get('Authorization')
if bearer_token and len(bearer_token.split(' ')) == 2:
token = bearer_token.split(' ')[1]
user = AuthorizationUtils.get_user_info(token)
request.user_extra = user
else:
raise ErrorTokenException
if permissions is not None and isinstance(permissions, List):
if user and user.role and user.role.has_all_permissions:
return func(*args, **kwargs)
user_permissions = []
if user and user.permissions:
user_permissions = user.permissions
accept = all([(item in user_permissions)
for item in permissions])
if not accept:
raise NotPermissionException
if schema:
if has_request_params:
try:
obj = schema.load(request.args)
request.parse_args = obj
except ValidationError:
raise PhysicalValidationException(
message='The query param is not valid')
else:
try:
obj = schema.load(request.get_json())
request.parse_obj = obj
except ValidationError as err:
raise PhysicalValidationException(extra=err.messages)
return func(*args, **kwargs)
if api and use_swagger:
if schema:
inner = api.doc(
params={qp["name"]: qp
for qp in query_params},
body=for_swagger(
schema=schema,
model_name=get_default_model_name(schema),
api=api,
operation="load",
),
)(inner)
elif _parser:
inner = api.expect(_parser)(inner)
return inner
def decorator(func):
# Check if we are decorating a class method
_IS_METHOD = _is_method(func)
@wraps(func)
def inner(*args, **kwargs):
rv = func(*args, **kwargs)
# If a Flask response has been made already, it is passed through unchanged
if isinstance(rv, Response):
return rv
if schema:
serialized = schema.dump(rv)
# Validate data if asked to (throws)
if validate:
errs = schema.validate(serialized)
if errs:
raise InternalServerError(
description=
"Server attempted to return invalid data")
# Apply the flask-restx mask after validation
serialized = _apply_restx_mask(serialized)
else:
from flask_restx import marshal
serialized = marshal(rv, model_from_parser)
if not _is_method(func):
# Regular route, need to manually create Response
return jsonify(serialized), status_code
return serialized, status_code
# Add Swagger
if api and use_swagger and _IS_METHOD:
if schema:
api_model = for_swagger(schema=schema,
model_name=model_name,
api=api,
operation="dump")
if schema.many is True:
api_model = [api_model]
inner = _document_like_marshal_with(
api_model,
status_code=status_code,
description=description,
)(inner)
elif _parser:
api.add_model(model_name, model_from_parser)
inner = _document_like_marshal_with(
model_from_parser, status_code=status_code)(inner)
return inner
def decorator(func):
from functools import wraps
# Check if we are decorating a class method
_IS_METHOD = _is_method(func)
@wraps(func)
def inner(*args, **kwargs):
from flask import request
error = schema_error = None
# Handle arguments
try:
request.parsed_args = _parser.parse_args()
except Exception as e:
error = e
# Handle Marshmallow schema
if schema:
try:
obj = schema.load(request.get_json())
request.parsed_obj = obj
except ValidationError as ex:
schema_error = ex.messages
if schema_error:
error = error or BadRequest(
f"Invalid parsing error: {schema_error}")
if hasattr(error, "data"):
error.data["errors"].update(
{"schema_errors": schema_error})
else:
error.data = {"schema_errors": schema_error}
# If any parsing produced an error, combine them and re-raise
if error:
raise error
return func(*args, **kwargs)
# Add Swagger
if api and use_swagger and _IS_METHOD:
if schema:
inner = api.doc(
params={qp["name"]: qp
for qp in query_params},
body=for_swagger(
schema=schema,
model_name=model_name
or get_default_model_name(schema),
api=api,
operation="load",
),
)(inner)
elif _parser:
inner = api.expect(_parser)(inner)
return inner
def decorator(func):
from functools import wraps
# Check if we are decorating a class method
_IS_METHOD = _is_method(func)
@wraps(func)
def inner(*args, **kwargs):
from flask import request
error = None
# Handle arguments
try:
request.parsed_args = _parser.parse_args()
except Exception as e:
error = e
# Handle Marshmallow schema
if schema:
obj, err = schema(many=many).load(request.get_json())
if err:
error = error or ValueError("Invalid parsing error.")
if hasattr(error, "data"):
error.data["message"].update({"schema_errors": err})
else:
error.data = {"schema_errors": err}
request.parsed_obj = obj
# If any parsing produced an error, combine them and re-raise
if error:
raise (error)
return func(*args, **kwargs)
# Add Swagger
if api and use_swagger and _IS_METHOD:
if schema:
inner = api.doc(
params={qp["name"]: qp for qp in query_params},
body=for_swagger(schema=schema, api=api),
)(inner)
elif _parser:
inner = api.expect(_parser)(inner)
return inner
def decorator(func):
# Check if we are decorating a class method
_IS_METHOD = _is_method(func)
@wraps(func)
def inner(*args, **kwargs):
rv = func(*args, **kwargs)
# If a Flask response has been made already, it is passed through unchanged
if isinstance(rv, Response):
return rv
if schema:
serialized = schema.dump(rv)
else:
from flask_restplus import marshal
serialized = marshal(rv, model_from_parser)
if not _is_method(func):
# Regular route, need to manually create Response
return jsonify(serialized), status_code
return serialized, status_code
# Add Swagger
if api and use_swagger and _IS_METHOD:
if schema:
inner = _document_like_marshal_with(
for_swagger(schema=schema,
model_name=model_name,
api=api,
operation="dump"),
status_code=status_code,
description=description,
)(inner)
elif _parser:
api.add_model(model_name, model_from_parser)
inner = _document_like_marshal_with(
model_from_parser, status_code=status_code)(inner)
return inner
def decorator(func):
from functools import wraps
# Check if we are decorating a class method
_IS_METHOD = _is_method(func)
@wraps(func)
def inner(*args, **kwargs):
from flask import request
error = schema_error = None
# Handle arguments
try:
request.parsed_args = _parser.parse_args()
except Exception as e:
error = e
# Handle Marshmallow schema for request body
if schema:
try:
obj = schema.load(request.get_json())
request.parsed_obj = obj
except ValidationError as ex:
schema_error = ex.messages
if schema_error:
error = error or BadRequest(
f"Error parsing request body: {schema_error}")
if hasattr(error, "data"):
error.data["errors"].update(
{"schema_errors": schema_error})
else:
error.data = {"schema_errors": schema_error}
# Handle Marshmallow schema for query params
if query_params_schema:
request_args = _convert_multidict_values_to_schema(
request.args, query_params_schema)
try:
obj = query_params_schema.load(request_args)
request.parsed_query_params = obj
except ValidationError as ex:
schema_error = ex.messages
if schema_error:
error = error or BadRequest(
f"Error parsing query params: {schema_error}")
if hasattr(error, "data"):
error.data["errors"].update(
{"schema_errors": schema_error})
else:
error.data = {"schema_errors": schema_error}
# Handle Marshmallow schema for headers
if headers_schema:
request_headers = _convert_multidict_values_to_schema(
request.headers, headers_schema)
try:
obj = headers_schema.load(request_headers)
request.parsed_headers = obj
except ValidationError as ex:
schema_error = ex.messages
if schema_error:
error = error or BadRequest(
f"Error parsing headers: {schema_error}")
if hasattr(error, "data"):
error.data["errors"].update(
{"schema_errors": schema_error})
else:
error.data = {"schema_errors": schema_error}
# If any parsing produced an error, combine them and re-raise
if error:
raise error
return func(*args, **kwargs)
# Add Swagger
if api and use_swagger and _IS_METHOD:
if schema:
body = for_swagger(
schema=schema,
model_name=model_name or get_default_model_name(schema),
api=api,
operation="load",
)
params = {
"expect": [body, _parser],
}
inner = api.doc(**params)(inner)
elif _parser:
inner = api.expect(_parser)(inner)
return inner
def decorator(func):
# Check if we are decorating a class method
_IS_METHOD = _is_method(func)
@wraps(func)
def inner(*args, **kwargs):
rv = func(*args, **kwargs)
# If a Flask response has been made already, it is passed through unchanged
if isinstance(rv, Response):
return rv
if schema:
serialized = schema.dump(rv)
# Validate data if asked to (throws)
if validate:
errs = schema.validate(serialized)
if errs:
raise InternalServerError(
description=
"Server attempted to return invalid data")
# Apply the flask-restx mask after validation
serialized = _apply_restx_mask(serialized)
else:
from flask_restx import marshal
serialized = marshal(rv, model_from_parser)
if envelope:
serialized = OrderedDict([(envelope,
serialized)]) if ordered else {
envelope: serialized
}
if skip_none:
def remove_none(obj):
if isinstance(obj, list):
return [
remove_none(entry) for entry in obj
if entry is not None
]
if isinstance(obj, dict):
result = {}
for key, value in obj.items():
value = remove_none(value)
if key is not None and value is not None:
result[key] = value
return result
return obj
serialized = remove_none(serialized)
if not _is_method(func):
# Regular route, need to manually create Response
return jsonify(serialized), status_code
return serialized, status_code
# Add Swagger
if api and use_swagger and _IS_METHOD:
if schema:
api_model = for_swagger(schema=schema,
model_name=model_name,
api=api,
operation="dump")
if schema.many is True:
api_model = [api_model]
inner = _document_like_marshal_with(
api_model,
status_code=status_code,
description=description,
)(inner)
elif _parser:
api.add_model(model_name, model_from_parser)
inner = _document_like_marshal_with(
model_from_parser,
status_code=status_code,
description=description)(inner)
return inner
def decorator(func):
from functools import wraps
# Check if we are decorating a class method
_IS_METHOD = _is_method(func)
@wraps(func)
def inner(*args, **kwargs):
from flask import request
error = schema_error = None
# Handle arguments
try:
request.parsed_args = _parser.parse_args()
except Exception as e:
error = e
# Handle Marshmallow schema for request body
if schema:
try:
headers = request.headers.get('content-type', '')
# allow parsing multipart/form-data and x-www-form-urlencoded
if 'form' in headers:
data = {**request.form}
# convert form data with value string of dict/list to object dict/list
for key, value in data.items():
if isinstance(value, str) and value.strip():
try:
data[key] = literal_eval(value)
except (ValueError, SyntaxError):
pass
# add files to data
data.update(request.files)
else:
data = request.get_json(force=True)
obj = schema.load(data)
request.parsed_obj = obj
except ValidationError as ex:
schema_error = ex.messages
if schema_error:
error = error or BadRequest(
f"Error parsing request body: {schema_error}")
if hasattr(error, "data"):
error.data["errors"].update(
{"schema_errors": schema_error})
else:
error.data = {"schema_errors": schema_error}
# Handle Marshmallow schema for query params
if query_params_schema:
request_args = _convert_multidict_values_to_schema(
request.args, query_params_schema)
try:
obj = query_params_schema.load(request_args)
request.parsed_query_params = obj
except ValidationError as ex:
schema_error = ex.messages
if schema_error:
error = error or BadRequest(
f"Error parsing query params: {schema_error}")
if hasattr(error, "data"):
error.data["errors"].update(
{"schema_errors": schema_error})
else:
error.data = {"schema_errors": schema_error}
# Handle Marshmallow schema for headers
if headers_schema:
request_headers = _convert_multidict_values_to_schema(
request.headers, headers_schema)
try:
obj = headers_schema.load(request_headers)
request.parsed_headers = obj
except ValidationError as ex:
schema_error = ex.messages
if schema_error:
error = error or BadRequest(
f"Error parsing headers: {schema_error}")
if hasattr(error, "data"):
error.data["errors"].update(
{"schema_errors": schema_error})
else:
error.data = {"schema_errors": schema_error}
# If any parsing produced an error, combine them and re-raise
if error:
raise error
return func(*args, **kwargs)
# Add Swagger
if api and use_swagger and _IS_METHOD:
if schema:
body = for_swagger(
schema=schema,
model_name=model_name or get_default_model_name(schema),
api=api,
operation="load",
)
if schema.many is True:
body = [body]
params = {
"expect": [body, _parser],
}
inner = api.doc(**params)(inner)
elif _parser:
inner = api.expect(_parser)(inner)
return inner
