public ExceptionHandler(IExceptionMapper mapper, ILogger <ExceptionHandler> logger, IOptions <MvcNewtonsoftJsonOptions> options, IOptions <Options.AppSettings> appSettings) { _mapper = mapper ?? throw new ArgumentNullException(nameof(mapper)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _options = options ?? throw new ArgumentNullException(nameof(options)); _appSettings = appSettings.Value ?? throw new ArgumentNullException(nameof(appSettings)); }
public DbContextBase( string nameOrConnectionString, IExceptionMapper exceptionMapper = null) : base(nameOrConnectionString) { SetExceptionMapper(exceptionMapper); }
public ExceptionHandler(IExceptionMapper mapper, ILogger <ExceptionHandler> logger, IOptions <MvcJsonOptions> options) { _mapper = mapper; _logger = logger; _options = options; }
/// <summary> /// Initializes a new instance of the <see cref="ExceptionMappingErrorHandler"/> class. /// </summary> /// <param name="attribute">The attribute.</param> public ExceptionMappingErrorHandler(ExceptionHandlingAttribute attribute) { handlingAttribute = attribute; if (handlingAttribute.ExceptionMapper != null) exceptionMapper = (IExceptionMapper)Activator.CreateInstance(handlingAttribute.ExceptionMapper); }
public DbContextBase( string nameOrConnectionString, DbCompiledModel model, IExceptionMapper exceptionMapper = null) : base(nameOrConnectionString, model) { SetExceptionMapper(exceptionMapper); }
public DbContextBase( DbConnection existingConnection, bool contextOwnsConnection, IExceptionMapper exceptionMapper = null) : base(existingConnection, contextOwnsConnection) { SetExceptionMapper(exceptionMapper); }
public DbContextBase( ObjectContext objectContext, bool dbContextOwnsObjectContext, IExceptionMapper exceptionMapper = null) : base(objectContext, dbContextOwnsObjectContext) { SetExceptionMapper(exceptionMapper); }
protected DbContextBase( IExceptionMapper exceptionMapper = null, IEntityAdder entityAdder = null, IEntityUpdater entityUpdater = null, IEntityDeleter entityDeleter = null, IEntityDetacher entityDetacher = null) : base() { Init(exceptionMapper, entityAdder, entityUpdater, entityDeleter, entityDetacher); }
/// <summary> /// Create new instance. /// </summary> public ExceptionHandlerMiddleware(RequestDelegate next, IExceptionMapper <TException> mapper, IOptions <ExceptionHandlerOptions> options, ILogger <ExceptionHandlerMiddleware <TException> > logger) { _next = next ?? throw new ArgumentNullException(nameof(next)); _mapper = mapper ?? throw new ArgumentNullException(nameof(mapper)); _options = options?.Value ?? throw new ArgumentNullException(nameof(options)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
public ApiExceptionFilter(IExceptionMapper mapper, IHostingEnvironment env, ILogger <ApiExceptionFilter> logger) { _mapper = mapper; _env = env; _logger = logger; _serializer = new JsonSerializer { ContractResolver = new CamelCasePropertyNamesContractResolver() }; }
public DbContextBase( string nameOrConnectionString, IExceptionMapper exceptionMapper = null, IEntityAdder entityAdder = null, IEntityUpdater entityUpdater = null, IEntityDeleter entityDeleter = null, IEntityDetacher entityDetacher = null) : base(nameOrConnectionString) { Init(exceptionMapper, entityAdder, entityUpdater, entityDeleter, entityDetacher); }
/// <summary> /// Executes registered exception mapping schemes and returns an <see cref="ExceptionHandlingResult"/>. /// </summary> /// <param name="mapper">The exception mapper.</param> /// <param name="exception">The exception to handle.</param> public static Task <ExceptionHandlingResult> MapAsync( this IExceptionMapper mapper, Exception exception) { if (mapper == null) { throw new ArgumentNullException(nameof(mapper)); } return(mapper.MapAsync(exception, null)); }
public DbContextBase( DbConnection existingConnection, bool contextOwnsConnection, IExceptionMapper exceptionMapper = null, IEntityAdder entityAdder = null, IEntityUpdater entityUpdater = null, IEntityDeleter entityDeleter = null, IEntityDetacher entityDetacher = null) : base(existingConnection, contextOwnsConnection) { Init(exceptionMapper, entityAdder, entityUpdater, entityDeleter, entityDetacher); }
public DbContextBase( ObjectContext objectContext, bool dbContextOwnsObjectContext, IExceptionMapper exceptionMapper = null, IEntityAdder entityAdder = null, IEntityUpdater entityUpdater = null, IEntityDeleter entityDeleter = null, IEntityDetacher entityDetacher = null) : base(objectContext, dbContextOwnsObjectContext) { Init(exceptionMapper, entityAdder, entityUpdater, entityDeleter, entityDetacher); }
internal ApiExceptionHandler(IExceptionMapper mapper, IHostingEnvironment env, ILogger <ApiExceptionHandler> logger, Action <Exception>[] exceptionListeners) { _mapper = mapper; _env = env; _logger = logger; _exceptionListeners = exceptionListeners; _serializer = new JsonSerializer { ContractResolver = new CamelCasePropertyNamesContractResolver() }; }
private void Init( IExceptionMapper exceptionMapper, IEntityAdder entityAdder, IEntityUpdater entityUpdater, IEntityDeleter entityDeleter, IEntityDetacher entityDetacher) { SetExceptionMapper(exceptionMapper); SetEntityAdder(entityAdder); SetEntityUpdater(entityUpdater); SetEntityDeleter(entityDeleter); SetEntityDetacher(entityDetacher); }
public ApiExceptionFilterImpl(IExceptionMapper mapper, IHostEnvironment env, ILogger <ApiExceptionFilter> logger, Action <Exception>[] exceptionListeners) { _mapper = mapper; _env = env; _logger = logger; _exceptionListeners = exceptionListeners; _serializerOptions = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase, IgnoreNullValues = true }; }
public ExceptionHandler(IExceptionMapper mapper, ILogger <ExceptionHandler> logger, IOptions <MvcJsonOptions> options, IOptions <ApiExtensionOptions> apiExtensionOptions) { if (mapper == null) { throw new ArgumentNullException(nameof(mapper)); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } _mapper = mapper; _logger = logger; _options = options; _apiExtensionOptions = apiExtensionOptions; }
/// <summary> /// Handles exception using registered schemes and executes the handling result. /// </summary> /// <param name="mapper">The exception mapper.</param> /// <param name="exception">The exception to handle.</param> /// <param name="context">The data context shared by all components used by the mapper.</param> public static async Task <object?> MapExceptionAsync( this IExceptionMapper mapper, Exception exception, ExceptionMappingContext?context = null) { if (mapper == null) { throw new ArgumentNullException(nameof(mapper)); } if (exception == null) { throw new ArgumentNullException(nameof(exception)); } var result = await mapper.MapAsync(exception, context); return(result.GetResult()); }
/// <inheritdoc/> public OpenApiResult GetResponse(Exception exception, OpenApiOperation operation) { Type exceptionType = exception.GetType(); OpenApiMappedException mappedException = this.GetMappedException(operation, exceptionType); IExceptionMapper mapper = this.GetExceptionMapperFor(mappedException, exception, operation); if (mapper == null) { string operationId = operation.GetOperationId(); this.logger.LogError( "Unmapped exception thrown by [{operationId}]: [{exception}]", operationId, exception); throw new OpenApiServiceMismatchException($"Operation {operationId} has thrown an exception of type {exception.GetType().FullName}. You should either handle this in your service, or add an exception mapping defining which status code this exception corresponds to."); } return(mapper.MapException(operation.Responses, exception, mappedException?.StatusCode)); }
/// <summary> /// Adds exception mapping middleware to re-execute request in an alternative request pipeline. /// </summary> /// <param name="app">The application builder.</param> /// <param name="mapper">The exception mapper to use.</param> public static IApplicationBuilder UseEndpointExceptionMapping( this IApplicationBuilder app, IExceptionMapper mapper) { if (app == null) { throw new ArgumentNullException(nameof(app)); } if (mapper == null) { throw new ArgumentNullException(nameof(mapper)); } var options = new EndpointExceptionMappingOptions { Mapper = mapper, ApplicationBuilder = app.New() }; return(app.UseEndpointExceptionMapping(options)); }
public static IExceptionMapper RegisterMapper(this IExceptionMapper mapper) { return(mapper .AddMap <IValidationException, ValidationException>()); }
public ExceptionStatusCodeDecoratorMiddleware(RequestDelegate next, IExceptionMapper mapper, ILogger <ExceptionStatusCodeDecoratorMiddleware> logger) { _next = next; _mapper = mapper; _logger = logger; }
private void SetExceptionMapper(IExceptionMapper exceptionMapper) { _exceptionMapper = exceptionMapper ?? new NullExceptionMapper(); }
public void Add(IExceptionMapper ex) { _children.Add(ex); }
protected virtual void SetExceptionMapper(IExceptionMapper exceptionMapper) { _exceptionMapper = exceptionMapper ?? new NullExceptionMapper(); }
private void SetExceptionMapper(IExceptionMapper exceptionMapper) { if (exceptionMapper != null) _exceptionMapper = exceptionMapper; }
protected ControllerBase(IServiceCollection service, ILogger <Controller> logger) { this.Logger = logger; this.Service = service; _exceptionMapper = service.BuildServiceProvider().GetService <IExceptionMapper>(); }
public DbContextBase( IExceptionMapper exceptionMapper) : base() { SetExceptionMapper(exceptionMapper); }
public ExceptionHandlingDynamicProxy(IExceptionMapper exceptionMapper) { _exceptionMapper = exceptionMapper; }
protected DbContextBase() : base() { _exceptionMapper = new NullExceptionMapper(); }
internal static ApiError Build <TCategoryName>(HttpContext context, Exception ex, IExceptionMapper mapper, ILogger <TCategoryName> logger, bool isDevelopment, Action <Exception>[] exceptionListeners) { //Execute custom exception handlers first. foreach (var customExceptionListener in exceptionListeners) { try { customExceptionListener.Invoke(ex); } catch (Exception e) { logger.LogWarning(e, "Custom exception listener {exceptionListener} threw an exception.", customExceptionListener.GetType().ToString()); } } context.Response.ContentType = "application/json"; HttpStatusCode statusCode; (int errorCode, string error)errorObject; object developerContext = null; object exceptionContext = new {}; switch (ex) { case BaseApiException baseApiException: try { if (mapper.Options.RespondWithDeveloperContext) { developerContext = baseApiException.DeveloperContext; } exceptionContext = baseApiException.Context; errorObject = mapper.GetError(baseApiException); statusCode = mapper.GetExceptionHandlerReturnCode(baseApiException); context.Response.StatusCode = (int)statusCode; logger.LogInformation(ex, "Mapped BaseApiException of type {exceptionType} caught by ApiExceptionHandler. Will return with {statusCodeInt} {statusCodeString}. Unexpected: {unexpected}", ex.GetType(), (int)statusCode, statusCode.ToString(), false); } catch (ArgumentException) { goto default; } break; case OperationCanceledException _: errorObject = (-1, "Frogvall.AspNetCore.ExceptionHandling.OperationCanceled"); statusCode = HttpStatusCode.InternalServerError; context.Response.StatusCode = (int)statusCode; logger.LogWarning(ex, "OperationCanceledException exception caught by ApiExceptionHandler. Will return with {statusCodeInt} {statusCodeString}. Unexpected: {unexpected}", (int)statusCode, statusCode.ToString(), true); break; default: errorObject = (-1, "Frogvall.AspNetCore.ExceptionHandling.InternalServerError"); statusCode = HttpStatusCode.InternalServerError; context.Response.StatusCode = (int)statusCode; logger.LogError(ex, "Unhandled exception of type {exceptionType} caught by ApiExceptionHandler. Will return with {statusCodeInt} {statusCodeString}. Unexpected: {unexpected}", ex.GetType(), (int)statusCode, statusCode.ToString(), true); break; } var error = new ApiError(mapper.Options.ServiceName) { CorrelationId = context.TraceIdentifier, Context = exceptionContext, DeveloperContext = developerContext, ErrorCode = errorObject.errorCode, Error = errorObject.error }; if (isDevelopment) { error.Message = ex.Message; error.DetailedMessage = ex.ToString(); } else { error.Message = Regex.Replace(statusCode.ToString(), "[a-z][A-Z]", m => m.Value[0] + " " + char.ToLower(m.Value[1])); error.DetailedMessage = ex.Message; } return(error); }
internal static ApiError Build <TCategoryName>(HttpContext context, Exception ex, IExceptionMapper mapper, ILogger <TCategoryName> logger, bool isDevelopment) { context.Response.ContentType = "application/json"; HttpStatusCode statusCode; int errorCode; object developerContext = null; switch (ex) { case BaseApiException _: try { developerContext = (ex as BaseApiException)?.DeveloperContext; errorCode = mapper.GetErrorCode(ex as BaseApiException); statusCode = mapper.GetExceptionHandlerReturnCode(ex as BaseApiException); context.Response.StatusCode = (int)statusCode; logger.LogInformation(ex, "Mapped BaseApiException of type {exceptionType} caught by ApiExceptionHandler. Will return with {statusCodeInt} {statusCodeString}. Unexpected: {unexpected}", ex.GetType(), (int)statusCode, statusCode.ToString(), false); } catch (ArgumentException) { goto default; } break; case ApiException _: errorCode = -2; statusCode = (ex as ApiException).StatusCode; context.Response.StatusCode = (int)statusCode; logger.LogInformation(ex, "ApiException caught by ApiExceptionHandler with {statusCodeInt} {statusCodeString}. Unexpected: {unexpected}", (int)statusCode, statusCode.ToString(), false); break; default: errorCode = -1; statusCode = HttpStatusCode.InternalServerError; context.Response.StatusCode = (int)statusCode; logger.LogError(ex, "Unhandled exception of type {exceptionType} caught by ApiExceptionHandler. Will return with {statusCodeInt} {statusCodeString}. Unexpected: {unexpected}", ex.GetType(), (int)statusCode, statusCode.ToString(), true); break; } var error = new ApiError(mapper.Options.ServiceName) { CorrelationId = context.TraceIdentifier, DeveloperContext = developerContext, ErrorCode = errorCode, }; if (isDevelopment) { error.Message = ex.Message; error.DetailedMessage = ex.ToAsyncString(); } else { error.Message = Regex.Replace(statusCode.ToString(), "[a-z][A-Z]", m => m.Value[0] + " " + char.ToLower(m.Value[1])); error.DetailedMessage = ex.Message; } return(error); }