def exception_handler(exc, context=None):
"""
Call REST framework's default exception handler first.
Return None if the exception can not be handled.
:param exc:
:param context:
:return: Response or None
"""
message = traceback.format_exc()
response = rest_exception_handler(exc, context)
if response is not None and isinstance(exc, BaseAPIBusinessError):
logger.warning(message)
response.data['error_code'] = response.data['detail'].code
return response
if response is not None and isinstance(exc, BaseAPISystemError):
logger.error(message)
response.data['error_code'] = response.data['detail'].code
return response
if response is not None:
return response
logger.error(message)
return Response(
{
'error_code': BaseAPISystemError.default_code,
'detail': BaseAPISystemError.default_detail,
},
status=BaseAPISystemError.status_code)
def exception_handler(exc: Exception,
context: ExceptionHandlerContext) -> Optional[Response]:
if isinstance(exc, Error):
sentry_report(exc, level='debug')
if settings.DEBUG:
if context['request'].content_type.startswith('application/json'):
exc = exc(traceback=traceback.format_exc())
else:
return None
elif isinstance(exc, APIException):
sentry_report(exc, level='debug')
exc = Error(context['request'],
exc.__class__.__name__,
detail=exc.detail,
status_code=exc.status_code)
elif not isinstance(exc, (Http404, PermissionDenied)):
event_id = sentry_report(exc)
event_id = f'event_id: {event_id}' if event_id is not None else None
if settings.DEBUG:
return None
else:
exc = Error(context['request'], detail=event_id)
return rest_exception_handler(exc, context)
def exception_handler(exc, context):
response = rest_exception_handler(exc, context)
if response is None:
if hasattr(exc, "name") and callable(exc.name):
name = exc.name()
else:
name = exc.__class__.__name__
response = {
"detail": str(exc),
"name": name
}
if settings.DEBUG:
import traceback
response['traceback'] = traceback.format_tb(exc.__traceback__)
response = Response(response)
else:
response.data["name"] = exc.__class__.__name__
response.status_code = 500
return response
def custom_exception_handler(exc, context):
response = rest_exception_handler(exc, context)
if isinstance(exc, DjangoValidationError):
data = {'detail': exc.messages}
set_rollback()
return Response(data, status=status.HTTP_400_BAD_REQUEST)
return response
def exception_handler(exc, context):
if isinstance(exc, exceptions.ValidationError):
exc.detail = {
'data': exc.detail,
'detail': 'Unfortunately, there are some problems with the data you committed'
}
return rest_exception_handler(exc, context)
def exception_handler(exc, context):
if isinstance(exc, exceptions.ValidationError):
exc.detail = {
'data':
exc.detail,
'detail':
'Unfortunately, there are some problems with the data you committed'
}
return rest_exception_handler(exc, context)
def exception_handler(exc, context):
# Call REST framework's default exception handler first,
# to get the standard error response.
response = rest_exception_handler(exc, context)
# make sure if any error, we unset maintenance mode
clear_maintain_task_id_cache()
return response
def handle_api_exception(exception, context):
response = rest_exception_handler(exception, context)
if response:
if isinstance(exception, Banned):
response.data["ban"] = exception.ban.get_serialized_message()
elif isinstance(exception, PermissionDenied):
try:
response.data["detail"] = exception.args[0]
except IndexError:
pass
return response
def test_rest_framework_exception(exception):
"""Ensure response returned by our and rest_framework handler are equal."""
rest_framework_response = rest_exception_handler(exception, {})
response = exception_handler(exception, {})
assert rest_framework_response
assert response
assert response.status_code == rest_framework_response.status_code
assert set(response.items()) == set(rest_framework_response.items())
assert response.data == rest_framework_response.data
def handle_api_exception(exception, context):
response = rest_exception_handler(exception, context)
if response:
if isinstance(exception, Banned):
response.data["ban"] = exception.ban.get_serialized_message()
elif isinstance(exception, PermissionDenied):
try:
response.data["detail"] = exception.args[0]
except IndexError:
pass
return response
def handle_api_exception(exception, context):
response = rest_exception_handler(exception, context)
if response:
if isinstance(exception, Banned):
response.data['ban'] = exception.ban
elif isinstance(exception, PermissionDenied):
try:
response.data['detail'] = exception.args[0]
except IndexError:
pass
return response
else:
return None
def handle_api_exception(exception, context):
response = rest_exception_handler(exception, context)
if response:
if isinstance(exception, Banned):
response.data['ban'] = exception.ban
elif isinstance(exception, PermissionDenied):
try:
response.data['detail'] = exception.args[0]
except IndexError:
pass
return response
else:
return None
def handle_api_exception(exception):
response = rest_exception_handler(exception)
if response:
if isinstance(exception, PermissionDenied):
try:
response.data['detail'] = exception.args[0]
try:
response.data.update(exception.args[1])
except IndexError:
pass
except IndexError:
pass
return response
else:
return None
def handle_api_exception(exception):
response = rest_exception_handler(exception)
if response:
if isinstance(exception, PermissionDenied):
try:
response.data['detail'] = exception.args[0]
try:
response.data.update(exception.args[1])
except IndexError:
pass
except IndexError:
pass
return response
else:
return None
def exception_handler(exc, context):
response = rest_exception_handler(exc, context)
if response is None:
return response
if 'status_code' in response.data:
del response.data['status_code']
if 'detail' in response.data:
message = response.data['detail']
del response.data['detail']
response.data['message'] = message
return response
def handle_api_exception(exception, context):
response = rest_exception_handler(exception, context)
if response:
if isinstance(exception, Banned):
response.data = exception.ban.get_serialized_message()
elif isinstance(exception, PermissionDenied) and exception.args:
response.data = {
'detail': six.text_type(exception),
}
elif isinstance(exception, Http404):
response.data = {
'detail': six.text_type(exception) or "NOT FOUND",
}
return response
else:
return None
def exception_handler(exc, context):
if isinstance(exc, exceptions.ValidationError):
logging.warn(exc.detail)
errors = []
if isinstance(exc.detail, list):
errors.extend(purify_error(exc.detail))
if isinstance(exc.detail, dict):
for field, errs in exc.detail.items():
field = translate_error_field(field)
if isinstance(errs, list):
errors.extend(purify_error(errs, field))
else:
errors.append(purify_error(errs, field))
data = {"detail": errors}
return Response(data, status=exc.status_code)
return rest_exception_handler(exc, context)
def test_other_exception(exception):
"""Ensure response returned by our and rest_framework handler are equal."""
assert (exception_handler(exception,
{}) == rest_exception_handler(exception, {}))
