def custom_handler(exc, context):
    """
    Handle exceptions that are NOT `rest_framework.exceptions.APIException`-based exceptions
    """
    # Call REST framework's default exception handler first,
    # to get the standard error response.
    response = exception_handler(exc, context)
    request = context.get('request', None)
    view = context.get('view', None)

    if not response:

        q('CUSTOM EXCEPTION!', exc, request.data)

        # Get exception info
        exc_type, exc_value, exc_trace = sys.exc_info()

        q(exc_type, exc_value, exc_trace)

        # Customize exceptions that translate to HTTP-4XX status-codes
        if isinstance(exc, core_exceptions.ObjectDoesNotExist):
            msg = str(exc) # TODO! Translate this!
            data = {'detail': six.text_type(msg)}
            status_code = status.HTTP_404_NOT_FOUND

        elif isinstance(exc, AssertionError):
            if isinstance(exc.message, basestring):
              data = {'detail': six.text_type(exc.message)}
            else:
              data = exc.message
            status_code = status.HTTP_400_BAD_REQUEST

        else:
            q('UNHANDLED CUSTOM EXCEPTION!')

            # Unhandled exception; print and then just wrap to make render properly
            traceback.print_exception(exc_type, exc_value, exc_trace)
            try:
              msg = str(exc) # TODO! Translate this!
              # http://stackoverflow.com/a/696095/1008905
              raise WrappedException, (msg, exc_type, exc_value), exc_trace
            except Exception, exc:
              response = exception_handler(exc, context)
              return response

        # Add some additional information to the response-data
        if view:
            data['view'] = view.__class__.__name__

        if context.get('kwargs', None):
            data['kwargs'] = context['kwargs']

        if request.data:
            data['request'] = request.data

        if not status_code:
          status_code = exc.status_code if exc.status_code else 500

        set_rollback()
        return Response(data, status=status_code)

def get_exception_handler(exc, context=None):
    """
    `exception_handler` did not accept context as an argument prior to DRF 3.1.
    """
    from rest_framework.views import exception_handler
    if len(inspect.getargspec(exception_handler)[0]) == 2:
        return exception_handler(exc, context)
    else:
        return exception_handler(exc)

def api_exception_handler(exc, context=None):
    response = exception_handler(exc, context) if context else exception_handler(exc)

    if response is not None and hasattr(response, "data"):
        if hasattr(exc, "errno"):
            response.data["errno"] = exc.errno
        else:
            response.data["errno"] = -1

    return response

def my_exception_handler(exc, context):
    if (
                isinstance(exc, exceptions.APIException) and
                isinstance(exc.detail, (list, dict))
    ):
        detail = " - ".join(
            ["{}: {}".format(k, v[0]) for k, v in exc.detail.items()])
        response = {"error": detail}
        set_rollback()
        return Response(response, status=exc.status_code)
    else:
        exception_handler(exc, context)

def custom_exception_handler(exc, context=None):
    # Call REST framework's default exception handler first,
    # to get the standard error response.
    if DJANGO_VERSION[0] >= 1 and DJANGO_VERSION[1] >= 7:
    	response = exception_handler(exc, context)
    else: 
    	response = exception_handler(exc, context)
    # Now add the HTTP status code to the response.
    if response is not None:
        response.data['status_code'] = response.status_code

    return response

def customer_exception_handler(exc, context):
    """
    customer exception handler

    :param exc:
    :param context:
    :return:
    """

    response = exception_handler(exc, context)

    # customer one
    if isinstance(exc, DBRelyOnException) or \
        isinstance(exc, DBIntegrityException) or \
        isinstance(exc, DBFieldLengthException) or \
        isinstance(exc, ParamNotEnoughException) or \
        isinstance(exc, ParamTypeException) or \
        isinstance(exc, ObjectNotExistException) or \
        isinstance(exc, OffsetOutOfRangeException):
        response = Response(
            exc.__dict__,
            status=status.HTTP_400_BAD_REQUEST
        )

    # add response filter here

    # return default one
    return response

 def __new__(self, exc, context):
     response = exception_handler(exc, context)
     error_logger.error(exc)
     if response is not None:
         return ErrorResponse(status=response.status_code,
                              message=exc.message)
     return ErrorResponse(message="An unexpected error occurred. Please try again.")

def json_api_exception_handler(exc, context):
    """ Custom exception handler that returns errors object as an array """

    # Import inside method to avoid errors when the OSF is loaded without Django
    from rest_framework.views import exception_handler
    response = exception_handler(exc, context)

    # Error objects may have the following members. Title removed to avoid clash with node "title" errors.
    top_level_error_keys = ['id', 'links', 'status', 'code', 'detail', 'source', 'meta']
    errors = []

    if response:
        message = response.data

        if isinstance(message, dict):
            for error_key, error_description in message.iteritems():
                if error_key in top_level_error_keys:
                    errors.append({error_key: error_description})
                else:
                    if isinstance(error_description, basestring):
                        error_description = [error_description]
                    errors.extend([{'source': {'pointer': '/data/attributes/' + error_key}, 'detail': reason}
                                   for reason in error_description])
        else:
            if isinstance(message, basestring):
                message = [message]
            errors.extend([{'detail': error} for error in message])

        response.data = {'errors': errors}

    return response

def custom_exception_handler(exc):
    '''
        自定义异常handler
        django rest 的异常返回为{'detail': 'Error message'}
        我们需求的异常返回为{
            'message': 'Error message',
            'errors': {
                'email': 'missing',
            },
        }
        missing: 这意味着资源不存在
        missing_field: 这意味着对资源所需的领域尚未确定
        invalid: 这意味着领域格式不合法。资源文档应该给您提供更专业的信息。
        already_exists: 这意味着已经存在和该领域同样值的资源了。这就要求要有独立的key
    '''

    # 获取django标准的异常response
    response = exception_handler(exc)
    if response is not None:
        message = response.data.get('detail', '')
        errors = {}
        if message.startswith('errors||'):
            errors = json.loads(message.split('||')[1])
            message = 'Validation Failed'
        response.data = {'message': message, 'errors': errors}
        return response

def custom_exception_handler(exc, context):
    response = exception_handler(exc, context)
    res = {}

    if response is not None:
        if response.status_code != 200:
            if 'detail' in response.data:
                response.data['error'] = response.data['detail']
                response.data.pop('detail')
            else:
                for k,v in response.data.items():
                    if isinstance(response.data[k], list):
                        res[k] = response.data[k]
                        response.data.pop(k)
                    else:
                        res.update(v)
                        response.data.pop(k)

                response.data['error'] = res

                #     if isinstance(response.data[k], dict):
                #         # response.data.update(v)
                #         res.update(v)
                #         response.data['error'] = res
                #         response.data.pop(k)
                #     else:
                #         response.data['error'] = 'trace'#response.data[k]
                #         # response.data[k] = response.data[k]


            # response.data['error']  = response.data['detail'] if 'detail' in response.data else dict((k) for k in response.data.items())
            # response.data.pop('detail') if 'detail' in response.data else [response.data.pop(k) for k in response.data if k != 'error']

    return response

def custom_exception_handler(exc, context):
    """
    Django Restframework fails silently to the errors it doesn't handle.
    This handler will bubble up errors that are not handled by DRF.
    Users of this handler will have to catch the error themselves..
    ..NOTE : ValidationErrors esp django model errors are context specific
    hence handling them here will provide a generic message that won't
    be helpful for that context..therefore they are better handled by the
    users themselves.
    """

    response = exception_handler(exc, context)
    if response:
        return response

    if isinstance(exc, ValidationError):
        LOGGER.error(exc)
        return Response(exc, status=status.HTTP_400_BAD_REQUEST)
    else:
        data = {'detail': ['Server Error: {}'.format(exc.__class__.__name__)]}

        # Keep this or you'll pull your hair out when **** hits the fan
        import traceback
        traceback.print_exc()
        LOGGER.error(exc)
        return Response(data, status=500)

def custom_exception_handler(exc):
    """
    Formats REST exceptions like:
    {
        "error": "error_code",
        "error_description": "description of the error",
    }
    :param exc: Exception
    :return: Response
    """
    response = exception_handler(exc)

    if not response:
        # Unhandled exceptions (500 internal server errors)
        response = Response(data={
            'error': 'server_error',
            'error_description': unicode(exc),
        }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
        return response

    if hasattr(exc, 'default_error'):
        response.data['error'] = exc.default_error
    else:
        response.data['error'] = 'api_error'

    if hasattr(exc, 'default_detail'):
        response.data['error_description'] = exc.default_detail
    elif 'detail' in response.data:
        response.data['error_description'] = response.data['details']

    if 'detail' in response.data:
        del response.data['detail']

    return response

def mhacks_exception_handler(exc, context):
    # Call REST framework's default exception handler first,
    # to get the standard error response.
    response = exception_handler(exc, context)

    if not response:
        return response
    if isinstance(response.data, str):
        response.data = {'detail': response}
    elif isinstance(response.data, list):
        response.data = {'detail': response.data[0]}
    elif not response.data.get('detail', None):
        if len(response.data) == 0:
            response.data = {'detail': 'Unknown error'}
        elif isinstance(response.data, list):
            response.data = {'detail': response.data[0]}
        elif isinstance(response.data, dict):
            first_key = response.data.keys()[0]
            detail_for_key = response.data[first_key]
            if isinstance(detail_for_key, list):
                detail_for_key = detail_for_key[0]
            if first_key.lower() == 'non_field_errors':
                response.data = {'detail': "{}".format(detail_for_key)}
            else:
                response.data = {'detail': "{}: {}".format(first_key.title(), detail_for_key)}
        else:
            response.data = {'detail': 'Unknown error'}
    return response

def rest_exception_handler(exc):
    response = exception_handler(exc)

    if response is not None:
        response.data['__all__'] = [response.data['detail']]

    return response

def custom_exception_handler(exc):
    """
    Custom exception handler for DRF, which doesn't provide one for HTTP
    responses like tastypie does.
    """
    # Call REST framework's default exception handler first,
    # to get the standard error response.
    response = exception_handler(exc)

    # If the response is None, then DRF didn't handle the exception and we
    # should do it ourselves.
    if response is None:
        # Start with a generic default error message.
        data = {"detail": "Internal Server Error"}

        # Include traceback if DEBUG is active.
        if settings.DEBUG:
            import traceback
            import sys

            data['error_message'] = unicode(exc)
            data['traceback'] = '\n'.join(
                traceback.format_exception(*(sys.exc_info())))

        request = getattr(exc, '_request', None)
        klass = getattr(exc, '_klass', None)

        # Send the signal so other apps are aware of the exception.
        got_request_exception.send(klass, request=request)

        # Send the 500 response back.
        response = Response(data, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

    return response

def datal_exception_handler(exception, context):
    # Call REST framework's default exception handler first,
    # to get the standard error response.
    response = exception_handler(exception, context)

    # Now add the HTTP status code to the response.
    if response is not None:
        response.data['status'] = response.status_code
        if not 'description' in response.data:
            response.data['description'] = ''
            if 'detail' in response.data:
                response.data['description'] =  response.data.pop('detail')
        response.data['error'] = str(exception.__class__.__name__)
        response.data['type'] = 'api-error'
    elif isinstance(exception, DATALException):
        set_rollback()
        response = Response({}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
        response.data['status'] = exception.status_code
        response.data['description'] =  exception.description % {}
        response.data['error'] = str(exception.__class__.__name__)
        response.data['type'] = exception.tipo
    elif not settings.DEBUG:
        logger = logging.getLogger(__name__)
        trace = '\n'.join(traceback.format_exception(*(sys.exc_info())))
        logger.error('[UnexpectedCatchError] %s. %s %s' % (
                str(exception), repr(exception), trace))
        set_rollback()
        response = Response({}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
        response.data['status'] = response.status_code
        response.data['description'] = str(exception)
        response.data['error'] = str(exception.__class__.__name__)
        response.data['type'] = 'unexpected-error'

    return response

def custom_exception_handler(exc, context):
    """Return a response from customized exception handling.

    :param exc: An exception
    :type exc: Exception

    """

    # Call REST framework's default exception handler first,
    # to get the standard error response.
    response = exception_handler(exc, context)

    # All other generated exceptions should be logged and handled here.
    if response is None:
        if isinstance(exc, elasticsearch.exceptions.ElasticsearchException) or\
           isinstance(exc, elasticsearch.exceptions.ImproperlyConfigured):

            response = es_custom_exception_handler(exc)

        elif isinstance(exc, Exception):
            data = {'detail': "There was an error processing this request. "
                              "Please file a ticket with support.",
                    'message': str(exc)}
            logger.exception(exc)
            response = Response(data,
                                status=status.HTTP_500_INTERNAL_SERVER_ERROR)
        else:
            # not an exception
            return None

    return response

def json_api_exception_handler(exc, context):
    """ Custom exception handler that returns errors object as an array """

    # Import inside method to avoid errors when the OSF is loaded without Django
    from rest_framework.views import exception_handler

    response = exception_handler(exc, context)

    # Error objects may have the following members. Title removed to avoid clash with node "title" errors.
    top_level_error_keys = ["id", "links", "status", "code", "detail", "source", "meta"]
    errors = []

    if response:
        message = response.data
        if isinstance(message, dict):
            for key, value in message.iteritems():
                if key in top_level_error_keys:
                    errors.append({key: value})
                else:
                    if isinstance(value, list):
                        for reason in value:
                            errors.append({"detail": reason, "meta": {"field": key}})
                    else:
                        errors.append({"detail": value, "meta": {"field": key}})
        elif isinstance(message, (list, tuple)):
            for error in message:
                errors.append({"detail": error})
        else:
            errors.append({"detail": message})

        response.data = {"errors": errors}

    return response

def rest_exception_handler(exc, context):
    # Let builtin exception handler process first
    # This will handle 404, 403, and general APIException
    response = exception_handler(exc, context)

    if response:
        reason = exc.__class__.__name__
        entity = {'status': 'error'}

        # Find the error code if available
        if isinstance(exc, APIException):
            reason = exc.get_codes()
            entity['code'] = unwrap(reason)

        # Wraps the response data if it is not in `dict`
        if not isinstance(response.data, dict):
            entity['detail'] = unwrap(response.data)
            response.data = entity

        # ValidationError returns `dict` but not in our favor
        elif isinstance(exc, ValidationError):
            entity['code'] = 'params_invalid'
            entity['detail'] = response.data
            response.data = entity
        else:
            response.data.update(entity)

        # Log our own error and set expectable status field
        logger.info('Status code %s, reason %s', response.status_code, reason)

    return response

def custom_exception_handler(exc, context):
    """An example handler for custom exceptions that aren't taken care of by
     DRF.

    :param exc: An exception
    :type exc: Exception

    """

    # Call REST framework's default exception handler first,
    # to get the standard error response.
    response = exception_handler(exc, context)

    # All other generated exceptions should be logged and handled here.
    if response is None:
        if isinstance(exc, elasticsearch.exceptions.ElasticsearchException) or\
           isinstance(exc, elasticsearch.exceptions.ImproperlyConfigured):

            response = es_custom_exception_handler(exc)

        elif isinstance(exc, Exception):
            data = {'detail': "There was an error processing this request. ",
                    'message': exc.message}
            response = Response(data,
                                status=status.HTTP_500_INTERNAL_SERVER_ERROR)
        else:
            # not an exception
            return None

    return response