Geek asks and answers

How to return JSON for errors outside the WebApi pipeline?

I create a public API using WebApi 2.1, have a dedicated WebApi project (without MVC), have an API hosted in IIS 7.5 on my own server, and have a design goal that returns only JSON or empty content, and never return HTML .

I am pleased to use ExceptionFilterAttribute to handle exceptions that occur in the WebApi pipeline, as follows:

public class GlobalExceptionHandler : ExceptionFilterAttribute
{
    public override void OnException(HttpActionExecutedContext context)
    {
        // Log the exception to Elmah
        Elmah.Error error = new Elmah.Error(context.Exception, HttpContext.Current);
        error.Detail = ActionState.GetRequestParameters(context) + error.Detail;
        Elmah.ErrorLog.GetDefault(HttpContext.Current).Log(error);

        if (context.Exception is NotImplementedException)
        {
            context.Response = context.Request.CreateErrorResponse(
                HttpStatusCode.NotImplemented
                , "The API method has not yet been implemented"
            );
        }
        else
        {
            context.Response = context.Request.CreateErrorResponse(
                HttpStatusCode.InternalServerError
                , "A " + context.Exception.GetType().ToString() + " was thrown"
            );
        }

        base.OnException(context);
    }
}

The filter is correctly added to App_Start:

config.Filters.Add(new SecureVideoApiGlobalExceptionHandler());

, , WebApi. , URI -, https://mysite.com/, - 403.11 HTML, : "- , ". , Application_Start global.asax, , AutoMapper, , .

: , - API JSON HTML?

<modules runAllManagedModulesForAllRequests="true">

Application_Error() global.asax, Response, JSON.

+3
1

-

[AttributeUsageAttribute(AttributeTargets.All, Inherited = true, AllowMultiple = true)]
public class ExceptionActionFilter : ExceptionFilterAttribute
{
    private static Logger _log ;//= LogManager.GetLogger("mysite");

    public override void OnException(HttpActionExecutedContext contex)
    {
        if (_log == null)
            _log = LogManager.GetCurrentClassLogger();

        var ex = contex.Exception;

        _log.Error(ex);

        contex.Response = contex.Request.CreateResponse(HttpStatusCode.OK,
           new 
           {
               ErrorMessage = contex.Exception.Message,
               RealStatusCode = (int)(ex is NotImplementedException || ex is ArgumentNullException ? HttpStatusCode.NoContent : HttpStatusCode.BadRequest), 
               ReturnUrl = CommonContext.ErrorUrl
           },
           new JsonMediaTypeFormatter());

        base.OnException(contex);
    }      
}

exc clie

 public class ExceptionLoggerFilter : System.Web.Http.Filters.IExceptionFilter
{
    private static Logger _log;
    public ExceptionLoggerFilter()
    {
        if (_log == null)
            _log = LogManager.GetCurrentClassLogger();
    }

    public bool AllowMultiple { get { return true; } }

    public System.Threading.Tasks.Task ExecuteExceptionFilterAsync(
            System.Web.Http.Filters.HttpActionExecutedContext contex,
            System.Threading.CancellationToken cancellationToken)
    {
        return System.Threading.Tasks.Task.Factory.StartNew(() =>
        {
            _log.Error(contex.Exception);

            contex.Response = contex.Request.CreateResponse(HttpStatusCode.OK, 
                new { RealStatusCode = (int)HttpStatusCode.Forbidden, ReturnUrl = "#/error.html"},
                contex.ActionContext.ControllerContext.Configuration.Formatters.JsonFormatter);

        }, cancellationToken);
    }
}

Global.asax.cs

protected void Application_Start()
{
    GlobalConfiguration.Configure(WebApiConfig.Register);
    Database.SetInitializer<MySiteContext>(null);
}


public static class WebApiConfig
{
    public static void Register(HttpConfiguration config)//RouteCollection config)//
    {
        config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
        config.Filters.Add(new ExceptionLoggerFilter());
        // Web API routes
        config.MapHttpAttributeRoutes();
        config.Routes.MapHttpRoute(
            name: "DefaultApi",
            routeTemplate: "api/{controller}/{action}/{id}",
            defaults: new { id = RouteParameter.Optional });

    }
}

maybee somthing like

$.controller.ajax.promise = controller.ajax.promise = function ( obj )
{
    var deferred = q.defer();
    $.ajax( {
        type: obj.type || "GET",
        url: obj.url,
        context: obj.context || null,
        data: obj.data || null,
        contentType: obj.contentType || "application/json; charset=utf-8",
        dataType: obj.dataType || "json",
        success: function ( res, textStatus, jqXHR )
        {
            if ( res.RealStatusCode )
            {
                switch ( res.RealStatusCode )
                {
                    case 400://x error
                        res.ClientMessage = res.ErrorMessage;
                        deferred.reject(res);
                        break;
                    case 408://y errors
                        location.href = res.ReturnUrl;
                        return false;
                    case 403://ext
                        msgbox.alert( {
                            message: 'Ma belle msg',
                            title: "Error"
                        } );
                        deferred.reject();
                        location.href = res.ReturnUrl;
                        return false;
                    default:
                        deferred.reject();
                        location.href = res.ReturnUrl;
                        break;
                }
            }
            deferred.resolve( res );
            return true;
        },
        error: function ( jqXHR, textStatus, errorThrown )
        {
            deferred.reject( { msg: jqXHR.statusText, jqXHR: jqXHR, textStatus:textStatus, errorThrown:errorThrown } );
        }
    } );

    return deferred.promise;
};

, ! ( @Thomas C. G. de Vilhena =)

+4

More articles:


All Articles