public void OnException(ExceptionContext context)
{
if (context.Exception is BadRequestException)
{
context.HttpContext.Response.StatusCode = (int)HttpStatusCode.BadRequest;
}
else if (context.Exception is NotFoundException)
{
context.HttpContext.Response.StatusCode = (int)HttpStatusCode.NotFound;
}
else
{
context.HttpContext.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
}
var errorDetails = new ErrorDetails()
{
StatusCode = context.HttpContext.Response.StatusCode,
Message = context.Exception.Message ?? Constantes.ERRO_NAO_TRATADO
};
context.Result = new ObjectResult(errorDetails);
context.ExceptionHandled = true;
}
/// <inheritdoc />
public override void OnException(ExceptionContext context)
{
if (!context.ExceptionHandled)
{
this._logger.LogError($"{context.HttpContext.Request.GetEncodedUrl()} is Error");
if (context.HttpContext.Request.IsAjaxRequest())
{
context.Result = new JsonResult(new
{
Result = false,
Msg = context.Exception.Message
});//中断式---请求到这里结束了，不再继续Action
}
else
{
var result = new ViewResult {
ViewName = "~/Views/Shared/Error.cshtml"
};
result.ViewData = new ViewDataDictionary(_modelMetadataProvider, context.ModelState);
result.ViewData.Add("Exception", context.Exception);
context.Result = result;
}
context.ExceptionHandled = true;
}
}
public override void OnException(Microsoft.AspNetCore.Mvc.Filters.ExceptionContext context)
{
base.OnException(context);
if (context.Exception is BadRequestException)
{
context.Result = new BadRequestObjectResult(context.Exception.Message);
context.ExceptionHandled = true;
}
}
public void OnException(ExceptionContext context)
{
var ctx = _contextFactor.Create(context);
if (ctx.Exception is BadRequestException)
{
ctx.SetResult(new BadRequestObjectResult(ctx.Exception.Message));
ctx.ResetException();
}
}
public void OnException(ExceptionContext context)
{
var ctx = _contextFactor.Create(context);
if (ctx.Exception is SecurityTokenExpiredException)
{
ctx.SetResult(new BadRequestObjectResult("INVALID_OTP_TOKEN"));
ctx.ResetException();
}
}
/// <summary>
/// Handle exception.
/// </summary>
/// <param name="context">The cu<see cref="Filters.ExceptionContext"/>.</param>
/// <returns>The task to handle exception.</returns>
public override async Task OnExceptionAsync(Filters.ExceptionContext context)
{
Guard.ArgumentNotNull(context, nameof(context));
context.ExceptionHandled = true;
_options = context.HttpContext.RequestServices.GetRequiredService <IOptions <HandleExceptionFilterOptions> >().Value;
if (context.Exception == null)
{
return;
}
ExceptionManager manager = context.HttpContext.RequestServices.GetRequiredService <ExceptionManager>();
string exceptionPolicy = this.GetExceptionPolicy(context);
try
{
if (!string.IsNullOrEmpty(exceptionPolicy))
{
await manager.HandleExceptionAsync(context.Exception, exceptionPolicy);
}
else
{
manager.HandleExceptionAsync(context.Exception).Wait();
}
}
catch (Exception ex)
{
ex = (ex as AggregateException)?.InnerException ?? ex;
var exceptionInfo = new ExceptionInfo(ex, _options.IncludeInnerException);
if (this.TryGetHandlerAction(context, out ActionDescriptor handlerAction))
{
context.HttpContext.SetExceptionInfo(exceptionInfo);
ActionContext actionContext = new ActionContext(context.HttpContext, context.RouteData, handlerAction);
IActionInvoker actionInvoker = context.HttpContext.RequestServices.GetRequiredService <IActionInvokerFactory>().CreateInvoker(actionContext);
await actionInvoker.InvokeAsync();
return;
}
if (context.HttpContext.IsAjaxRequest())
{
JsonResult json = new JsonResult(exceptionInfo, _options.JsonSerializerSettings);
await json.ExecuteResultAsync(new ActionContext(context));
return;
}
var viewData = new ViewDataDictionary(new EmptyModelMetadataProvider(), context.ModelState)
{
Model = exceptionInfo
};
ViewResult view = new ViewResult {
ViewData = viewData
};
await view.ExecuteResultAsync(context);
}
}
private static ExceptionContext ConstractExceptionContext()
{
var actionContext = new ActionContext(
new Mock <HttpContext>().Object,
new RouteData(),
new Mock <ControllerActionDescriptor>().Object,
new Mock <ModelStateDictionary>().Object);
var exceptionContext = new ExceptionContext(
actionContext,
new List <IFilterMetadata>());
return(exceptionContext);
}
public void OnException(ExceptionContext context)
{
if (context.Exception is FluentValidationException fluentValidationException)
{
var errorResponse = new BadRequestErrorResponse(fluentValidationException.Errors);
SetResult(context, new BadRequestObjectResult(errorResponse));
ResetException(context);
}
if (context.Exception is BadRequestException badRequestException)
{
SetResult(context, new BadRequestObjectResult(badRequestException.Response));
ResetException(context);
}
}
/// <summary>
/// Try to get the exception handler action to process the request.
/// </summary>
/// <param name="context">The current <see cref="ExceptionContext"/>.</param>
/// <param name="handlerAction">The <see cref="ActionDescriptor"/> representing the exception handler action.</param>
/// <returns>Indicates whether the current action specific handler action exists.</returns>
protected virtual bool TryGetHandlerAction(Filters.ExceptionContext context, out ActionDescriptor handlerAction)
{
Guard.ArgumentNotNull(context, nameof(context));
ControllerActionDescriptor actionDescriptor = context.ActionDescriptor as ControllerActionDescriptor;
if (null != actionDescriptor)
{
var attribute = actionDescriptor.MethodInfo.GetCustomAttribute <HandlerActionAttribute>()
?? actionDescriptor.ControllerTypeInfo.GetCustomAttribute <HandlerActionAttribute>();
string handlerActionName = attribute?.HandlerAction ?? _options.ResolveHandlerAction(actionDescriptor.ActionName);
var provider = context.HttpContext.RequestServices.GetRequiredService <IActionDescriptorCollectionProvider>();
var result = from it in provider.ActionDescriptors.Items
let it2 = it as ControllerActionDescriptor
where it2 != null && it2.ActionName == handlerActionName && it2.ControllerTypeInfo == actionDescriptor.ControllerTypeInfo
select it;
return((handlerAction = result.FirstOrDefault()) != null);
}
return((handlerAction = null) != null);
}
/// <summary>
/// Get the name of exception policy to handle the exception.
/// </summary>
/// <param name="context">The current <see cref="ExceptionContext"/>.</param>
/// <returns>The name of exception policy to handle the exception.</returns>
protected virtual string GetExceptionPolicy(Filters.ExceptionContext context)
{
Guard.ArgumentNotNull(context, nameof(context));
if (!string.IsNullOrEmpty(this.ExceptionPolicy))
{
return(this.ExceptionPolicy);
}
ControllerActionDescriptor actionDescriptor = context.ActionDescriptor as ControllerActionDescriptor;
if (null != actionDescriptor)
{
var attribute = actionDescriptor.MethodInfo.GetCustomAttribute <ExceptionPolicyAttribute>()
?? actionDescriptor.ControllerTypeInfo.GetCustomAttribute <ExceptionPolicyAttribute>();
if (null != attribute)
{
return(attribute.PolicyName);
}
}
return(_options.ExceptionPolicy);
}
public override void OnException(Microsoft.AspNetCore.Mvc.Filters.ExceptionContext context)
{
var exception = context.Exception;
var exceptionType = exception.GetType();
if (!exceptionHandlers.ContainsKey(exceptionType))
{
var request = context.HttpContext.Request;
var response = new UnhandledExceptionResponse
{
Message = context.Exception.ToString()
};
context.HttpContext.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
context.Result = new JsonResult(response);
}
else
{
context.Result = exceptionHandlers[exceptionType](context, exception);
}
base.OnException(context);
}
public override void OnException(Microsoft.AspNetCore.Mvc.Filters.ExceptionContext actionExecutedContext)
{
//TODO Logs
actionExecutedContext.Exception = new Exception("Erro interno. Informe ao admnistrador do sistema");
}
public override Task OnExceptionAsync(ExceptionContext context)
{
OnException(context);
return(Task.CompletedTask);
}
/// <summary>
/// 异常拦截
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public async Task OnExceptionAsync(ExceptionContext context)
{
// 解析异常处理服务，实现自定义异常额外操作，如记录日志等
var globalExceptionHandler = context.HttpContext.RequestServices.GetService <IGlobalExceptionHandler>();
if (globalExceptionHandler != null)
{
await globalExceptionHandler.OnExceptionAsync(context);
}
// 如果异常在其他地方被标记了处理，那么这里不再处理
if (context.ExceptionHandled)
{
return;
}
// 获取控制器信息
var actionDescriptor = context.ActionDescriptor as ControllerActionDescriptor;
// 解析异常信息
var exceptionMetadata = UnifyContext.GetExceptionMetadata(context);
// 判断是否是验证异常
var isValidationException = context.Exception is AppFriendlyException friendlyException && friendlyException.ValidationException;
// 判断是否跳过规范化结果，如果是，则只处理为友好异常消息
if (UnifyContext.CheckFailedNonUnify(actionDescriptor.MethodInfo, out var unifyResult))
{
// 如果是验证异常，返回 400
if (isValidationException)
{
context.Result = new BadRequestResult();
}
else
{
// 返回友好异常
context.Result = new ContentResult()
{
Content = exceptionMetadata.Errors.ToString(),
StatusCode = exceptionMetadata.StatusCode
};
}
}
else
{
// 判断是否支持 MVC 规范化处理
if (!UnifyContext.CheckSupportMvcController(context.HttpContext, actionDescriptor, out _))
{
return;
}
// 执行规范化异常处理
context.Result = unifyResult.OnException(context, exceptionMetadata);
}
// 判断异常消息是否是验证异常（比如数据验证异常，业务抛出异常）
if (isValidationException)
{
// 解析验证消息
var validationMetadata = ValidatorContext.GetValidationMetadata((context.Exception as AppFriendlyException).ErrorMessage);
App.PrintToMiniProfiler("Validation", "Failed", $"Validation Failed:\r\n{validationMetadata.Message}", true);
}
else
{
PrintToMiniProfiler(context.Exception);
}
}
private void ResetException(ExceptionContext context)
{
context.Exception = null;
}
private void SetResult(ExceptionContext context, IActionResult result)
{
context.Result = result;
}
public override void OnException(Microsoft.AspNetCore.Mvc.Filters.ExceptionContext context)
{
base.OnException(context);
}
