def handle_error(self, e): ''' Error handler for the API transforms a raised exception into a Flask response, with the appropriate HTTP status code and body. :param Exception e: the raised Exception object ''' got_request_exception.send(current_app._get_current_object(), exception=e) headers = Headers() if e.__class__ in self.error_handlers: handler = self.error_handlers[e.__class__] result = handler(e) default_data, code, headers = unpack(result, 500) elif isinstance(e, HTTPException): code = e.code default_data = { 'message': getattr(e, 'description', HTTP_STATUS_CODES.get(code, '')) } headers = e.get_response().headers elif self._default_error_handler: result = self._default_error_handler(e) default_data, code, headers = unpack(result, 500) else: code = 500 default_data = { 'message': HTTP_STATUS_CODES.get(code, str(e)), } default_data['message'] = default_data.get('message', str(e)) data = getattr(e, 'data', default_data) fallback_mediatype = None if code >= 500: exc_info = sys.exc_info() if exc_info[1] is None: exc_info = None current_app.log_exception(exc_info) elif code == 404 and current_app.config.get("ERROR_404_HELP", True): data['message'] = self._help_on_404(data.get('message', None)) elif code == 406 and self.default_mediatype is None: # if we are handling NotAcceptable (406), make sure that # make_response uses a representation we support as the # default mediatype (so that make_response doesn't throw # another NotAcceptable error). supported_mediatypes = list(self.representations.keys()) fallback_mediatype = supported_mediatypes[0] if supported_mediatypes else "text/plain" # Remove blacklisted headers for header in HEADERS_BLACKLIST: headers.pop(header, None) resp = self.make_response(data, code, headers, fallback_mediatype=fallback_mediatype) if code == 401: resp = self.unauthorized(resp) return resp
def get_status_msg(status_code): """将status code转换为status message 200 => 'OK' 400 => 'Bad Request' 500 => 'Internal Server Error' """ return HTTP_STATUS_CODES.get(status_code, 'Unknown Error')
def error_response(status_code, message=None): payload = {'error': HTTP_STATUS_CODES.get(status_code, 'Unknown error')} if message: payload['message'] = message response = jsonify(payload) response.status_code = status_code return response
def as_dict(self): if self.args: message = str(self) else: message = HTTP_STATUS_CODES.get(self.status_code, '') return { 'status': self.status_code, 'message': message }
def abort(self, status, error=None, encoder=True): (self.log.exception if self.app.debug and exc_info()[0] else self.log.error)( '%r %s %s >> %s', status, request.method, request.path, error or HTTP_STATUS_CODES.get(status, 'Unknown Error')) if error: return abort(status, description=error, response = self.encoders[encoder].make_response( dict(status=status, error=error), status=status)) else: return abort(status)
def error_response(status_code, description): # pragma: no cover response = make_response( json.dumps({ "message": HTTP_STATUS_CODES.get(status_code), "status": status_code, "description": description }) ) response.mimetype = 'application/json' response.status_code = status_code return response
def error_response(status_code, message=None): payload = { "error": HTTP_STATUS_CODES.get(status_code, "Unknown error"), } if message: payload["message"] = message response = jsonify(payload) response.status_code = status_code return response
def error_response(status_code, message=None): # Using HTTP_STATUS_CODES dictionary to get the short description of a HTTP status code. payload = {'error': HTTP_STATUS_CODES.get(status_code, 'Unknown error')} if message: payload['message'] = message # using jsonify method to convert the response in JSON structure. response = jsonify(payload) response.status_code = status_code return response
def response(status_code, message=None, data=None, meta=None): payload = {'error': HTTP_STATUS_CODES.get(status_code, 'Unknown error')} if message: payload['msg'] = message if data: payload['data'] = data if meta: payload['meta'] = meta response = jsonify(payload) response.status_code = status_code return response
def error_response(status_code, message=None): """ 错误处理函数 :param status_code: :param message: :return: """ payload = {'error': HTTP_STATUS_CODES.get(status_code, 'Unknown error')} if message: payload['message'] = message response = jsonify(payload) response.status_code = status_code return response
def error_response(status_code, message=None): body = { 'error': HTTP_STATUS_CODES.get(status_code), } if message: body['message'] = message response = jsonify(body) response.status_code = status_code return response
def error_response(status_code, message=None): ''' Generates an error response payload jsonify() returns a default 200 for the response because of this, we must set the response status_code manually ''' payload = {'error': HTTP_STATUS_CODES.get(status_code, 'Unknown error')} if message: payload['message'] = message response = jsonify(payload) response.status_code = status_code return response
def error_response(status_code, message=''): if message is None: response = '' else: payload = { 'error': HTTP_STATUS_CODES.get(status_code, 'Unknown error') } if message != '': payload['message'] = message response = jsonify(payload) #response.status_code = status_code return make_response(response, status_code)
def error_response(status_code, message=None): payload = {'error': HTTP_STATUS_CODES.get(status_code, 'Unknown error')} if message: payload['message'] = message response = jsonify(payload) response.status_code = status_code ''' ###Michael: from site: The jsonify() function returns a Flask Response object with a default status code of 200, so after I create the response, I set the status code to the correct one for the error. ''' return response
def get_reason_phrase(status_code: int, default: str = 'Unknown') -> str: """A helper function to get the reason phrase of the given status code. Arguments: status_code: A standard HTTP status code. default: The default phrase to use if not found, defaults to "Unknown". *Version Changed: 0.6.0* - Add `default` parameter. """ return HTTP_STATUS_CODES.get(status_code, default)
def error_response(status_code, message=None): """ Error handling routine which produces short descriptions for the provided HTTP error code. Returns: Response to client (the message and an HTTP error code) """ payload = {'ERROR': HTTP_STATUS_CODES.get(status_code, 'Unknown error')} if message: payload['message'] = message response = jsonify(payload) response.status_code = status_code return response
def error_response(status_code, message=None): payload = { 'error': HTTP_STATUS_CODES.get(status_code, 'Unknown error'), 'error_code': status_code } if message: payload['message'] = message response = jsonify(payload) response.status_code = status_code return response
def handle_error(self, err): print(type(err)) print(err) # Handle HTTPExceptions if isinstance(err, HTTPException): return jsonify({ 'detail': getattr(err, 'description', HTTP_STATUS_CODES.get(err.code, '')) }), err.code #Handle validation error if isinstance(err, ValidationError) or isinstance( err, ModelValidationError) or isinstance( err, PasswordValidationError): return jsonify({'detail': getattr(err, 'description', str(err))}), 400 #Handle authorization issues jwt_err_types = list( map(lambda ty: getattr(jwt_errs, ty), filter(lambda x: not x.startswith("__"), dir(jwt_errs)))) jwt_extended_err_types = list( map( lambda ty: getattr(jwt_extended_errs, ty), filter(lambda x: not x.startswith("__"), dir(jwt_extended_errs)))) if type(err) in jwt_err_types + jwt_extended_err_types + [ AuthenticationFailedError ]: return jsonify({'detail': getattr(err, 'description', str(err))}), 401 #Handle duplication if isinstance(err, NotUniqueError): expr = re.compile("(\{\s*.*\})") m = expr.findall(str(err)) print(type(m[0])) str(err) return jsonify({ 'detail': getattr( err, 'description', f"There is a unique constraint violation. {m[0] if len(m)>0 else ''}" ) }), 400 # If msg attribute is not set, # consider it as Python core exception and # hide sensitive error info from end user if not getattr(err, 'message', None): return jsonify({'detail': 'Server has encountered some error'}), 500 # Handle application specific custom exceptions return jsonify(**err.kwargs), err.http_status_code
def error(status_code, message=None): """Return the error specified by the status_code. If message is present, attach also it to the response. """ payload = {"error": HTTP_STATUS_CODES.get(status_code, "Unknown")} if message: payload["message"] = message response = jsonify(payload) response.status_code = status_code return response
def error_response(status_code, message=None): """构造错误响应数据""" # payload 根据状态码返回错误信息,未能识别的状态码默认为Unknown error payload = {'error': HTTP_STATUS_CODES.get(status_code, 'Unknown error')} # 如果有消息则设置消息. if message: payload['message'] = message # 构造响应对象 response = jsonify(payload) response.status_code = status_code return response
def create_response(status_code, message, details): header = {'error': HTTP_STATUS_CODES.get(status_code, 'Unknown error')} if message: header['message'] = message if details: header['details'] = details response = jsonify(header) response.status_code = status_code return response
def error_response(status_code, message=None): """ Return a response with message :param status_code: HTTP Status code in Integer. :param message: String to context the error. :return: Response object. """ payload = {'error': HTTP_STATUS_CODES.get(status_code, 'Unknown error')} if message: payload['message'] = message response = jsonify(payload) response.status_code = status_code return response
def get_title(self, status_code, pointer, error): """Get the title of the error to be returned to the user. Args: status_code (int): The status code of the error. pointer (list): A list of str (pointer segments) to the field which raised the initial errors. error (:drf_gh:`rest_framework.exceptions.ErrorDetail <rest_framework/exceptions.py>`): The DRF-provided detail of the error. Returns: str: The title of the message. """ return HTTP_STATUS_CODES.get(status_code, None)
def error_response(status_code, message=None): """ Return an error response in JSON format. status_code: X message: X """ payload = {"error": HTTP_STATUS_CODES.get(status_code, "Unknown error")} if message: payload["message"] = message response = jsonify(payload) response.status_code = status_code return response
def error_response(status: int, message: Optional[str] = None) -> Response: """Helper function for returning more meaningful error messages. :param status: HTTP status code :param message: optional message """ if type(status) is not int: status = status.code error = HTTP_STATUS_CODES.get(status, 'Unknown Error') if _wants_json_response(): return _api_error_response(status, error, message) else: return _html_error_response(status, error, message)
def __init__(self, status_code, message=None, details=None): super().__init__() error = HTTP_STATUS_CODES.get(status_code, "Unknown error") self.status_code = status_code self.payload = {"error": error} if message is not None: self.payload["message"] = message if details is not None: self.payload["details"] = details
def _get_response(exception): """ Return a JSON Flask response object. The properties of the JSON object and the status code of the result are set based on the details of the exception. """ response = { "statusCode": exception.code, "error": HTTP_STATUS_CODES.get(exception.code, "Unknown error"), "message": exception.description, } return jsonify(response), exception.code
def error_response(status_code, message=None): # HTTP_STATUS_CODES is a dictionary with the status codes as the keys and # a short description of each one for the value payload = {'error': HTTP_STATUS_CODES.get(status_code, 'Unknown error')} if message: payload['message'] = message # jsonify returns Flask Response object with default status code of 200 # wraps dumps and sets media type correctly to application/json # Also a little more versatile than dumps response = jsonify(payload) # Reset status_code to correct passed in value (vs. default of 200) response.status_code = status_code return response
def abort(self, status, error=None, encoder=True): (self.log.exception if self.app.debug and exc_info()[0] else self.log.error)('%r %s %s >> %s', status, request.method, request.path, error or HTTP_STATUS_CODES.get(status, 'Unknown Error')) if error: return abort(status, description=error, response=self.encoders[encoder].make_response( dict(status=status, error=error), status=status)) else: return abort(status)
def handle_error(self, err): """ This class overrides 'handle_error' method of 'Api' class , to extend global exception handing functionality of 'flask-restful' and helps preventing writing unnecessary try/except block though out the application """ logger.exception(err, stack_info=True) # Handle HTTPExceptions, the base exception for all Werkzeug exceptions if isinstance(err, HTTPException): return jsonify({ 'success': False, 'message': getattr(err, 'description', HTTP_STATUS_CODES.get(err.code, '')), 'data': { 'type': 'error', 'class': err.__class__.__name__, 'base': 'HTTPException', 'source': 'werkzeug' } }), err.code if isinstance(err, ValidationError): resp = { 'success': False, 'message': err.messages, 'data': { 'type': 'error', 'class': 'ValidationError', 'source': 'Serializer' } } return jsonify(resp), 400 # If msg attribute is not set, # consider it as Python core exception and # hide sensitive error info from end user if getattr(err, 'message', None): return jsonify({ 'success': False, 'message': 'Server has encountered some error' }), 500 # Handle application specific custom exceptions try: err.kwargs['message'] = err.kwargs['msg'] del (err.kwargs['msg']) except KeyError: pass return jsonify(**err.kwargs), err.http_status_code
def log_request(self, *args): '''Use standard logging''' code = self.request.response_code if app.config['DEBUG']: message = '%s [%s: %s]' % (self.request.uri, code, HTTP_STATUS_CODES.get(code, 'Unknown')) else: message = self.format_request(*args) if code < 404: logger.info(message) elif code < 500: logger.warn(message) else: logger.error(message)
def error_response(status_code, message=None): """ Returns an API friendly error (as opposed to the standard html errors :param status_code: <int> http status code :param message: <str> message with extra information :return: returns http response with json payload and correct status code """ payload = {'error': HTTP_STATUS_CODES.get(status_code, 'Unknown error')} if message: payload['message'] = message response = jsonify(payload) response.status_code = status_code return response
def response(code=200, data=None, error=None, msg=None): ''' :param code: 状态码 :param data: 返回数据 :param error: 错误信息 :param msg: 提示信息 ''' if code is not None and code >= 400: error = HTTP_STATUS_CODES.get(code, "unknown error") pay_load = { "code": code, "data": data, "err": error, "message": msg or HTTP_STATUS_CODES.get(code, "unknown error") } # with ttt_app.app_context(): _res = jsonify(pay_load) _res.status_code = code return _res
def error(e): if isinstance(e, HTTPException): error_code = e.code error_desc = e.description else: error_code = 500 error_desc = _("internal_error") app.log_exception(e) error_name = HTTP_STATUS_CODES.get(error_code, "Unknown Error") return render_template("error.html", error_code=error_code, error_name=error_name, error_desc=error_desc), error_code
def response(status_code=200, data=None, message=None): if data == None and status_code == 200: status_code = 204 pay_load = { "code": status_code, "message": message or HTTP_STATUS_CODES.get(status_code, "unknown code"), "data": data, "timestamp": int(time.time()) } _response = jsonify(pay_load) _response.status_code = status_code return _response
def __call__(self, environ, start_response): if "HTTP_USER_AGENT" not in environ: status_code = 403 status = "%s %s" % (status_code, HTTP_STATUS_CODES.get(status_code, "")) headers = [("Content-Type", "text/html")] start_response(status, headers) return "" user_agent = environ["HTTP_USER_AGENT"] path_info = environ["PATH_INFO"] print("middleware") print(environ) for k, v in environ.items(): print("%s : %s" % (k, v)) # print(v) if path_info == "/404": status = "404 %s" % HTTP_STATUS_CODES.get(404, "") headers = [("Content-Type", "text/html")] start_response(status, headers) return "" result = self.wsgi_app(environ, start_response) return result
def error_response(status_code, message=None): """错误响应 结构 { "error": "short error description", "message": "error message (optional)" } """ payload = {'error': HTTP_STATUS_CODES.get(status_code, 'Unknown error')} if message: payload['message'] = message response = jsonify(payload) response.status_code = status_code return response
def http_status_message(code): """Maps an HTTP status code to the textual status""" return HTTP_STATUS_CODES.get(code, '')
def as_dict(self): return { 'status': self.status_code, 'message': HTTP_STATUS_CODES.get(self.status_code, '') }
def name(self): return HTTP_STATUS_CODES.get(503, 'Service Unavailable')
def http_status_message(code): return HTTP_STATUS_CODES.get(code, '')
def as_dict(self): return {"status": self.status_code, "message": HTTP_STATUS_CODES.get(self.status_code, "")}