Python views.exception_handler函数代码示例

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