public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
// before controller
if (!context.ModelState.IsValid)
{
var errors = context.ModelState.Where(x => x.Value.Errors.Count > 0)
.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.Errors.Select(x => x.ErrorMessage)).ToArray();
var errorResponse = new ErrorResponseDto();
foreach (var err in errors)
{
foreach (var subError in err.Value)
{
var errorModel = new ErrorModel
{
FieldName = err.Key,
Message = subError
};
errorResponse.Errors.Add(errorModel);
}
}
context.Result = new BadRequestObjectResult(errorResponse);
}
next();
// after controller
}
public void OnException(ExceptionContext context)
{
this.logger.LogError(new EventId(context.Exception.HResult),
context.Exception,
context.Exception.Message);
if (context.Exception is PassiveMQException)
{
ErrorResponseDto json = new ErrorResponseDto()
{
ExceptionName = context.Exception.GetType().Name,
Messages = new[] { context.Exception.Message }
};
context.Result = new BadRequestObjectResult(json);
context.HttpContext.Response.StatusCode = (int)HttpStatusCode.BadRequest;
}
else
{
ErrorResponseDto json = new ErrorResponseDto()
{
Messages = new[] { "An error ocurr.Try it again." }
};
if (this.enviroment.IsDevelopment())
{
json.DeveloperMeesage = context.Exception.ToString();
}
context.Result = new InternalServerErrorObjectResult(json);
context.HttpContext.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
}
context.ExceptionHandled = true;
}
public async Task <IActionResult> AcceptedCards(string processor)
{
AdminCommandResponse <IList <CardType> > result;
using (var authorizerService = _authorizerFactory.Create(processor))
{
if (authorizerService is null)
{
return(NotFound(
ErrorResponseDto.FromMissingProcessor(processor)
));
}
result = await authorizerService.GetAcceptedCardTypesAsync();
}
if (result.Success)
{
return(Ok(new CardTypesResponseDto(result)));
}
else
{
return(BadRequest(ErrorResponseDto.FromProcessorResponse(result)));
}
}
/// <summary>
/// アクション実行前の処理を行います。
/// </summary>
/// <param name="context">コンテキスト。</param>
public override void OnActionExecuting(ActionExecutingContext context)
{
// モデル検証エラーの場合は処理終了
if (context.ModelState.IsValid == false)
{
// モデルエラーの取得
var errors = new List <ErrorResponseDto.ErrorArgument>();
foreach (var value in context.ModelState.Values)
{
foreach (var error in value.Errors)
{
errors.Add(
new ErrorResponseDto.ErrorArgument()
{
Message = error.ErrorMessage
});
}
}
var responseDto = new ErrorResponseDto();
responseDto.Errors = errors;
context.HttpContext.Response.StatusCode = (int)HttpStatusCode.BadRequest;
context.HttpContext.Response.Headers.Clear();
context.Result = new ObjectResult(responseDto);
return;
}
base.OnActionExecuting(context);
}
public async void ValidateLoginNotFound()
{
CredentialsRequestDto request = new CredentialsRequestDto()
{
Username = "******",
Password = "******"
};;
var expected = new ErrorResponseDto()
{
Code = "U404"
};
_userService.Setup(x => x.ValidateUser(It.IsAny <string>(), It.IsAny <string>()))
.Callback(() =>
{
throw new UserNotFoundException($"User {request.Username} not found");
});
// Act
var result = await _usersController.Post(request);
// Assert
var okResult = Assert.IsType <NotFoundObjectResult>(result);
Assert.Equal(expected.Code, (okResult.Value as ErrorResponseDto).Code);
}
public async Task <IActionResult> Transaction([FromBody] TransactionDto transaction, string processor)
{
var transDef = _mapper.Map <TransactionDto, TransactionRequest>(transaction);
TransactionResponse result;
using (var authorizerService = _authorizerFactory.Create(processor))
{
if (authorizerService is null)
{
return(BadRequest(ErrorResponseDto.FromMissingProcessor(processor)));
}
result = await authorizerService.ProcessTransactionAsync(transDef);
}
switch (result.ResultCode)
{
case BaseResponse.ResultCodesEnum.InternalProcessorError:
case BaseResponse.ResultCodesEnum.CommunicationsError:
return(StatusCode(500, ErrorResponseDto.FromProcessorResponse(result)));
case BaseResponse.ResultCodesEnum.NotReady:
case BaseResponse.ResultCodesEnum.InvalidParametersError:
case BaseResponse.ResultCodesEnum.ProcessorError:
return(BadRequest(ErrorResponseDto.FromProcessorResponse(result)));
default:
return(Ok(new TransactionResponseDto(result)));
}
}
public ActionResult HandleRequestException(RequestException exception, ControllerBase controller)
{
_logger.LogWarning(exception, "A Request Exception was thrown! Containing message: {ExceptionMessage}", exception.HumanMessage);
var errorResponse = new ErrorResponseDto(exception.HumanMessage);
var dataForClient = new DataForClient <IResponse>(errorResponse, exception.Fixes);
return(controller.Ok(dataForClient));
}
public ActionResult HandleException(Exception exception, ControllerBase controller)
{
_logger.LogWarning(exception, "A generic Exception was thrown! Containing message: {ExceptionMessage}", exception.Message);
var errorResponse = new ErrorResponseDto(_textService.Error_ServerError);
var dataForClient = new DataForClient <IResponse>(errorResponse, new FixResponseDto[0]);
return(controller.Ok(dataForClient));
}
// ***
public async Task <IResponseDto> CreateOrder(CreateOrderDto request)
{
bool areAllAvailable = true;
var wantedDishesEnumerator = request.WantedDishes.GetEnumerator();
IList <Dish> wantedDishes = new List <Dish>();
IDictionary <Guid, int> wantedDishesCount = new Dictionary <Guid, int>();
while (wantedDishesEnumerator.MoveNext() && areAllAvailable == true)
{
var wantedDish = await _unitOfWork.DishesRepository.Get(wantedDishesEnumerator.Current.Id);
wantedDishes.Add(wantedDish);
wantedDishesCount.Add(wantedDish.Id, wantedDishesEnumerator.Current.Count);
areAllAvailable = wantedDish.IsAvailable;
}
wantedDishesEnumerator.Dispose();
if (areAllAvailable == false)
{
return(ErrorResponseDto.Create("Some dishes are not available."));
}
var createdOrder = Order.Create(DateTime.Now, request.Adress);
await _unitOfWork.OrdersRepository.Add(createdOrder);
foreach (var wantedDish in wantedDishes)
{
wantedDishesCount.TryGetValue(wantedDish.Id, out int count);
var orderDish = OrderDish.Create(wantedDish, createdOrder, count);
await _unitOfWork.OrderDishesRepository.Add(orderDish);
foreach (var wantedDishIngredient in wantedDish.DishIngredients)
{
IngredientOnStock usedIngredient = wantedDishIngredient.Ingredient;
usedIngredient.Quantity -= wantedDishIngredient.Quantity;
await _unitOfWork.IngredientsRepository.Update(wantedDishIngredient.Ingredient);
foreach (var usedIngredientDish in wantedDishIngredient.Ingredient.IngredientDishes)
{
if (usedIngredientDish.Quantity > wantedDishIngredient.Ingredient.Quantity)
{
usedIngredientDish.Dish.IsAvailable = false;
await _unitOfWork.DishesRepository.Update(usedIngredientDish.Dish);
}
}
}
}
await _unitOfWork.CommitAsync();
// cauta dishurile orderului
//verifica daca sunt available
// create order
// scade din fiecare ingredient folosit in dishurile alese
//si pentru fiecare ingredient modificat se verifica dishurile la care se foloseste ingredientul (is available?)
return(SuccessResponseDto.Create(_mapper.Map <OrderDto>(createdOrder)));
}
public void OnException(ExceptionContext context)
{
ErrorResponseDto errorResponseDto = ErrorResponseDto.GetErrorResposenDtoFromExceprion(context.Exception);
context.Result = new ObjectResult(errorResponseDto)
{
StatusCode = 500
};
}
private JsonResult CreateErrorResponse(string errorMessage)
{
var responseDto = new ErrorResponseDto
{
ErrorMessage = errorMessage
};
return(new JsonResult(responseDto));
}
public async Task <IActionResult> Get(
string processor,
string terminalId = "")
{
if (processor is null || processor == "")
{
return(BadRequest(ErrorResponseDto.CustomInvalidRequest("'processor' parameter missing")));
}
return(Ok(await _processorConfigService.GetConfig(processor, terminalId)));
}
public async Task <IResponseDto> Get(string id)
{
Guid.TryParse(id, out Guid dishId);
var searchedDish = await _unityOfWork.DishesRepository.Get(dishId);
if (searchedDish == null)
{
return(ErrorResponseDto.Create(ErrorMessages.IdNotFound));
}
return(SuccessResponseDto.Create(_mapper.Map <DishDto>(searchedDish)));
}
private JsonResult InteralError(Exception ex)
{
ErrorResponseDto errorResponse = new ErrorResponseDto();
List <ErrorDto> errors = new List <ErrorDto>
{
new ErrorDto(ex.GetType().Name, ex.Message)
};
errorResponse.Errors = errors.ToArray();
return(new JsonResult(errorResponse)
{
StatusCode = (int)HttpStatusCode.InternalServerError
});
}
public async Task <IActionResult> GetConfig(int merchantId, string processor, [FromQuery(Name = "terminal_id")] string terminalId = "")
{
var merchant = await _context.Merchants.Include(p => p.Config).FirstOrDefaultAsync(p => p.Id == merchantId);
if (merchant is null)
{
return(NotFound(ErrorResponseDto.FromNotFoundInDb("merchantId", merchantId.ToString())));
}
var config = await _merchantConfigService.GetConfig(processor, merchantId, terminalId);
if (processor is null || processor == "")
{
return(Ok(config));
}
protected override string CreateErrorMessage(string content)
{
string errorMessage = string.Empty;
try
{
ErrorResponseDto error = JsonConvert.DeserializeObject <ErrorResponseDto>(content);
errorMessage = $"{error.Error.Code} {error.Error.Message}";
}
catch (Exception ex)
{
Logger.Error(ex);
}
return(errorMessage);
}
public static void AddProductionExceptionHandler(this IApplicationBuilder app)
{
app.UseExceptionHandler(config =>
{
config.Run(async context =>
{
context.Response.StatusCode = 500;
context.Response.ContentType = "application/json";
var error = context.Features.Get <Microsoft.AspNetCore.Diagnostics.IExceptionHandlerFeature>();
if (error != null)
{
var ex = error.Error;
ErrorResponseDto errorDto;
switch (ex.GetType().ToString())
{
//case "SomeExceptionType":
// errorDto = new ErrorResponseDto
// {
// ErrorCode = "SomeError",
// ErrorList = new List<string>() { ex.Message },
// ErrorMessage = "Error Description",
// ErrorSource = "utg"
// };
// break;
default:
errorDto = new ErrorResponseDto
{
ErrorCode = "UnhandledError",
ErrorList = new List <string>()
{
ex.Message
},
ErrorMessage = "Error inesperado (" + ex.GetType().ToString() + ") dentro del processor",
ErrorSource = "utg"
};
break;
}
var output = JsonConvert.SerializeObject(errorDto);
await context.Response.WriteAsync(output);
}
});
});
}
private async Task <string> ParseErrorMessage(HttpResponseMessage response)
{
switch (response.StatusCode)
{
// allowed http statuses
case HttpStatusCode.BadRequest:
case HttpStatusCode.NoContent:
case HttpStatusCode.Unauthorized:
case HttpStatusCode.NotModified:
case HttpStatusCode.UpgradeRequired:
{
string responseString = await response.Content.ReadAsStringAsync();
ErrorResponseDto error = JsonConvert.DeserializeObject <ErrorResponseDto>(responseString);
if (!string.IsNullOrEmpty(error?.Message))
{
return(error.Message);
}
if (!string.IsNullOrEmpty(error?.OtherMessage))
{
return(error.OtherMessage);
}
if (!string.IsNullOrEmpty(error?.ErrorDescription))
{
return(error.ErrorDescription);
}
if (!string.IsNullOrEmpty(error?.Error))
{
return(error.Error);
}
return(null);
}
// fatal error from server: 500, 404, 403 etc.
default:
return(null);
}
}
/// <inheritdoc/>
public void OnException(ExceptionContext context)
{
// transform the exception into JSON
if (context.Exception is ExceptionBase)
{
_logger.LogInformation(context.Exception, context.ActionDescriptor.DisplayName);
ExceptionBase customException = context.Exception as ExceptionBase;
var exceptionJson = new ErrorResponseDto
{
Message = customException.Message,
InnerExceptionMessage = customException.InnerException?.Message,
};
switch (_hostingEnvironment.EnvironmentName.ToLowerInvariant())
{
case "local":
case "dev":
case "development":
exceptionJson.StackTrace = customException.StackTrace;
break;
default:
break;
}
context.Result = new JsonResult(exceptionJson)
{
StatusCode = (int)customException.StatusCode
};
context.ExceptionHandled = true;
}
else
{
// unexpected exception so log to _logger (which probably will be Application Insights)
_logger.LogCritical(context.Exception, context.ActionDescriptor.DisplayName);
// unhandled exception keeps percolating and will be handled by ASP.NET Core
}
}
public override void OnActionExecuting(ActionExecutingContext context)
{
if (context.ModelState.IsValid)
{
return;
}
string[] validationErrors = context.ModelState
.Keys
.SelectMany(k => context.ModelState[k].Errors)
.Select(e => e.ErrorMessage)
.ToArray();
ErrorResponseDto json = new ErrorResponseDto()
{
ExceptionName = nameof(PassiveMQValidationException),
Messages = validationErrors
};
context.Result = new BadRequestObjectResult(json);
}
public HttpResponseMessage GetPostById(int Id)
{
var response = new HttpResponseMessage();
try
{
var post = _Uow.Posts.GetPostById(Id);
response = Request.CreateResponse(HttpStatusCode.OK, post);
return(response);
}
catch (Exception ex)
{
var ErrorResponse = new ErrorResponseDto
{
ExceptionMessage = ex.Message,
InnerExceptionMessage = ex.InnerException == null ? "None" : ex.InnerException.Message
};
response = Request.CreateResponse(HttpStatusCode.BadRequest, ErrorResponse);
return(response);
}
}
public HttpResponseMessage CreatePost(PostRequestDto postRequestDto)
{
var response = new HttpResponseMessage();
try
{
_Uow.Posts.CreatePost(postRequestDto);
response = Request.CreateResponse(HttpStatusCode.OK, "Post created successfully");
return(response);
}
catch (Exception ex)
{
var ErrorResponse = new ErrorResponseDto
{
ExceptionMessage = ex.Message,
InnerExceptionMessage = ex.InnerException == null ? "None" : ex.InnerException.Message
};
response = Request.CreateResponse(HttpStatusCode.BadRequest, ErrorResponse);
return(response);
}
}
public HttpResponseMessage DeleteComment(int Id)
{
var response = new HttpResponseMessage();
try
{
_Uow.Comments.DeleteComment(Id);
_Uow.SaveChanges();
response = Request.CreateResponse(HttpStatusCode.OK, "Comment deleted successfully");
return(response);
}
catch (Exception ex)
{
var ErrorResponse = new ErrorResponseDto
{
ExceptionMessage = ex.Message,
InnerExceptionMessage = ex.InnerException == null ? "None" : ex.InnerException.Message
};
response = Request.CreateResponse(HttpStatusCode.BadRequest, ErrorResponse);
return(response);
}
}
/// <summary>
/// Error result exception
/// </summary>
/// <param name="exception">Exception result</param>
/// <param name="context">Context application</param>
/// <returns>Void</returns>
/// <auhtor>Oscar Julian Rojas</auhtor>
/// <date>10/07/2021</date>
public async Task ErrorResult(Exception exception, HttpContext context)
{
context.Response.StatusCode = (int)GetErrorCode(exception);
context.Response.ContentType = ApisConstants.ContentType;
var errorResponse = new ErrorResponseDto
{
ErrorCode = context.Response.StatusCode,
Message = exception.Message,
ErrorType = exception.GetType().Name,
Source = exception.Source,
ActionName = (string)context.GetRouteData()?.Values[ApisConstants.ActionName],
ControllerName = (string)context.GetRouteData()?.Values[ApisConstants.ControllerName],
UserId = context.User.HasClaim(x => x.Value.Equals("Id")) ? context.User.FindFirst("Id").Value : string.Empty
};
_logger.LogInformation("Error application");
await context.Response.WriteAsync(JsonConvert.SerializeObject(new Response <ErrorResponseDto>
{
Data = errorResponse,
IsSuccess = errorResponse.ErrorCode == default,
ReturnMessage = errorResponse.Message
}));
protected async Task <IActionResult> ExecuteCommandAsync <TResponse>(IRequest <TResponse> request, Func <TResponse, object> success, CancellationToken cancellationToken = default, HttpStatusCode statusCode = HttpStatusCode.OK)
{
try
{
TResponse response = await this.Mediator.Send(request, cancellationToken);
return(new JsonResult(success(response))
{
StatusCode = (int)statusCode
});
}
// Failures in validation copy to error response
catch (FluentValidation.ValidationException ex)
{
ErrorResponseDto errorResponse = new ErrorResponseDto();
List <ErrorDto> errors = new List <ErrorDto>();
foreach (FluentValidation.Results.ValidationFailure error in ex.Errors)
{
errors.Add(new ErrorDto(error.ErrorCode, error.ErrorMessage));
}
errorResponse.Errors = errors.ToArray();
return(new JsonResult(errorResponse)
{
StatusCode = (int)HttpStatusCode.BadRequest
});
}
catch (NotFoundException)
{
return(this.NotFound());
}
catch (Exception ex)
{
return(this.InteralError(ex));
}
}
