private static void ConfigureExceptionMapping(ExceptionHandlerConfiguration configuration)
{
configuration
.Map <BadRequestException>()
.ToStatusCode(HttpStatusCode.BadRequest)
.WithBody((ex, context) => ExceptionResponseBody(ex));
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
app.UseDatabaseMigration();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseBrowserLink();
app.UseDatabaseErrorPage();
}
else
{
ExceptionHandlerConfiguration.AddExceptionHandler(app);
}
RewriteOptions rewriteOptions = new RewriteOptions().AddRedirectToHttps();
app.UseRewriter(rewriteOptions);
app.UseStaticFiles(new StaticFileOptions
{
ServeUnknownFileTypes = true
});
app.UseCookiePolicy();
app.UseAuthentication();
app.UseMvc(routes =>
{
routes.MapRoute(
"default",
"{controller=Store}/{action=All}/{id?}");
});
}
private static void ConfigureReleaseInternalError(ExceptionHandlerConfiguration configuration, ILogger <BaseStartup> logger)
{
configuration.ResponseBody(s =>
{
logger.LogError(s.ToString());
return(JsonConvert.SerializeObject(new ExeceptionResponse("Ocorreu um erro interno não tratado.")));
});
}
private static void ConfigureDebugInternalError(ExceptionHandlerConfiguration configuration, ILogger <BaseStartup> logger)
{
configuration.ResponseBody(s =>
{
logger.LogError(s.ToString());
return(JsonConvert.SerializeObject(new ExeceptionResponse(s.Message, s.StackTrace, s.InnerException?.Message)));
});
}
private static void ExceptionConfiguration(ExceptionHandlerConfiguration configuration, ILogger <BaseStartup> logger)
{
configuration.ContentType = "application/problem+json";
ConfigureDebugInternalError(configuration, logger);
ConfigureReleaseInternalError(configuration, logger);
ConfigureOnError(configuration, logger);
}
private static void ConfigureOnError(ExceptionHandlerConfiguration configuration, ILogger <BaseStartup> logger)
{
configuration.OnError((exception, httpContext) =>
{
var error = new ExeceptionResponse(exception.Message, exception.StackTrace, exception.InnerException?.Message);
logger.LogError(error.ToString());
return(Task.CompletedTask);
});
}
public static void PublishException(Exception exception, string policyName)
{
lock (s_lockObject)
{
if (s_ehsh == null)
{
try
{
s_ehsh = ConfigurationManager.GetSection("exceptionHandler") as ExceptionHandlerConfiguration;
}
catch (ConfigurationException ce)
{
throw new Exception("Fault with exceptionHandler configuration", ce);
}
}
}
if (s_ehsh == null)
{
throw new ArgumentNullException("s_ehsh", "Missing exceptionHandler configuration section");
}
foreach (Policy p in ExceptionManager.s_ehsh.Policies)
{
if (p.Name == policyName)
{
foreach (Publisher pub in p)
{
if (pub.Enabled)
{
try
{
pub.PublisherObject.PublishException(exception);
}
catch (OutOfMemoryException)
{
throw;
}
catch (StackOverflowException)
{
throw;
}
catch (Exception x)
{
string xy = x.Message;
}
}
}
break;
}
}
}
public static void MapExceptions(this ExceptionHandlerConfiguration cfg)
{
cfg.ContentType = "application/json";
cfg.ResponseBody(s => JsonConvert.SerializeObject(new
{
Message = s is BussinesExceptions ? s.Message : "An error occured whilst processing your request"
}));
cfg.Map <FluentValidation.ValidationException>()
.ToStatusCode(HttpStatusCode.BadRequest)
.WithBody((ex, ctx) => SerializeValidationException(ex));
}
