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);
            }
        }
Beispiel #2
0
        protected async Task <IActionResult> ExecuteAsync(Func <Task <IActionResult> > action)
        {
            try
            {
                return(await action());
            }
            catch (InvalidLoginCredentialsException ex)
            {
                // Right now, "Unauthorized" doesn't accept any body object.
                // Thus, returning "BadRequest" with correct error model.
                var error = new UnauthorizedErrorResponse(ex.Message);
                return(BadRequest(error));

                // return Unauthorized();
            }
            catch (ValidationException ex)
            {
                var error = new BadRequestErrorResponse("Validation failed. See 'validationErrors' for details.");
                error.Error.ValidationErrors = ex.Errors.Select(e => e.ErrorMessage).ToArray();
                return(BadRequest(error));
            }
            catch (InvalidRequestException ex)
            {
                var error = new BadRequestErrorResponse(ex.Message);
                return(BadRequest(error));
            }
            catch (EntityNotFoundException ex)
            {
                var error = new NotFoundErrorResponse(ex.Message);
                return(NotFound(error));
            }
            catch (InvalidOperationException ex)
            {
                var error = new ErrorResponse(ex.Message);
                return(StatusCode(StatusCodes.Status500InternalServerError, error));
            }
            catch (Exception ex)
            {
                var error = new ErrorResponse(ex.Message);
                return(StatusCode(StatusCodes.Status500InternalServerError, error));
            }
        }
        private static BadRequestErrorResponse ConvertResponseErrorToBadRequestErrorResponse(ResponseError responseError)
        {
            var response = new BadRequestErrorResponse();

            response.ErrorCode    = responseError.ErrorCode;
            response.ErrorMessage = responseError.ErrorMessage;

            if (responseError is InvalidArgumentsResponseError)
            {
                response.ArgumentErrors = new List <BadRequestErrorResponse.ArgumentError>();
                foreach (var resArgumentError in ((InvalidArgumentsResponseError)responseError).ArgumentErrors)
                {
                    var argError = new BadRequestErrorResponse.ArgumentError
                    {
                        ArgumentName = resArgumentError.ArgumentName,
                        ErrorCode    = resArgumentError.ArgumentError.ErrorCode,
                        ErrorMessage = resArgumentError.ArgumentError.ErrorMessage
                    };
                    response.ArgumentErrors.Add(argError);
                }
            }

            return(response);
        }