public IHttpActionResult AddProductToBasket([FromBody] AddProductToBasketRequest request)
{
User user = GetCurrentUser();
if (user == null)
{
return(Unauthorized());
}
IProductRepo repo = UnitOfWork.ProductRepo;
Product product = repo.FindById(request.Id);
try
{
UnitOfWork.Context.Database.ExecuteSqlCommand($"do $$ begin perform \"dbo\".add_product_to_basket({user.Id}, {product.Id}); end $$");
return(Ok(
UnitOfWork
.Context.Database
.SqlQuery <int>($"select \"dbo\".get_product_count_from_basket({user.Id}, {product.Id});")
.FirstOrDefault()));
}
catch
{
return(BadRequest());
}
}
public async Task <IActionResult> AddProductToBasket([FromBody] AddProductToBasketRequest request)
{
// some logic ...
await Task.Delay(1000);
return(Ok(request));
}
public async Task <IActionResult> AddProductToBasket([FromBody] AddProductToBasketRequest request)
{
var response = await _basketService.AddProductToBasket(new AddProductToBasketContext { BasketId = request.BasketId, ProductId = request.ProductId });
if (response.IsSuccessful)
{
_logger.LogInformation($"Product {request.ProductId} added to basket {request.BasketId}");
}
return(Ok(response));
}
private void CheckStringIsObjectId(AddProductToBasketRequest addProductToBasketRequest, ValidationResult validationResult)
{
if (!ObjectId.TryParse(addProductToBasketRequest.BasketId, out _))
{
validationResult.IsValid = false;
validationResult.Message = $"{Constants.ValidationMessages.IdIsInvalid}: {nameof(addProductToBasketRequest.BasketId)}";
}
else if (!ObjectId.TryParse(addProductToBasketRequest.ProductId, out _))
{
validationResult.IsValid = false;
validationResult.Message = $"{Constants.ValidationMessages.IdIsInvalid}: {nameof(addProductToBasketRequest.ProductId)}";
}
}
public async Task <ActionResult <BasketREST> > AddProductToBasketAsync([FromBody] AddProductToBasketRequest data)
{
if (data.UserId == Guid.Empty ||
data.ProductId == Guid.Empty ||
data.Quantity == 0)
{
return(BadRequest("Invalid parameters"));
}
var basketModel = await BasketService.AddProductToBasketAsync(data.UserId, data.ProductId, data.Quantity);
var basketREST = Mapper.Map <BasketREST>(basketModel);
return(Ok(basketREST));
}
private void CheckHasDefaultValue(AddProductToBasketRequest addProductToBasketRequest, ValidationResult validationResult)
{
if (addProductToBasketRequest is null)
{
validationResult.IsValid = false;
validationResult.Message = $"{Constants.ValidationMessages.ValueCanNotBeNull}: {nameof(addProductToBasketRequest)}";
}
else if (string.IsNullOrEmpty(addProductToBasketRequest.BasketId))
{
validationResult.IsValid = false;
validationResult.Message = $"{Constants.ValidationMessages.StringCanNotBeNullEmptyOrWhiteSpace}: {nameof(addProductToBasketRequest.BasketId)}";
}
else if (string.IsNullOrWhiteSpace(addProductToBasketRequest.ProductId))
{
validationResult.IsValid = false;
validationResult.Message = $"{Constants.ValidationMessages.StringCanNotBeNullEmptyOrWhiteSpace}: {nameof(addProductToBasketRequest.ProductId)}";
}
}
public async Task <ResponseModel <bool> > Handle(AddProductToBasketRequest request, CancellationToken cancellationToken)
{
// StockCount get value via GetProductCountRequestHandler which run before the current request
if (request.Count > request.StockCount)
{
return(new ResponseModel <bool>(HttpStatusCode.OK, Errors.InsufficientStockCount, false));
}
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.RequiresNew, new TransactionOptions {
IsolationLevel = IsolationLevel.RepeatableRead
}))
{
int effectedCount = await _stockRepository.UpdateProductCount(request.ProductId, request.Count);
if (effectedCount <= 0)
{
scope.Dispose();
return(new ResponseModel <bool>(HttpStatusCode.OK, Errors.OperationFailed, false));
}
//TODO AutoMapper useful for object mapping
effectedCount = await _basketRepository.AddProduct(new BasketProduct
{
BasketId = request.BasketId,
ProductId = request.ProductId,
Count = request.Count
});
if (effectedCount <= 0)
{
scope.Dispose();
return(new ResponseModel <bool>(HttpStatusCode.OK, Errors.OperationFailed, false));
}
scope.Complete();
}
return(new ResponseModel <bool>(true));
}
public async Task Should_Response_false_When_StockCount_less_than_basket_Count()
{
var mockBasketRepo = new Mock <IBasketRepository>();
mockBasketRepo.Setup(x => x.AddProduct(It.IsAny <BasketProduct>())).Returns(Task.FromResult(1));
var mockStockRepo = new Mock <IStockRepository>();
mockStockRepo.Setup(x => x.UpdateProductCount(It.IsAny <int>(), It.IsAny <int>())).Returns(Task.FromResult(1));
var handler = new AddProductToBasketRequestHandler(mockBasketRepo.Object, mockStockRepo.Object);
var request = new AddProductToBasketRequest()
{
BasketId = 1, ProductId = 100, Count = 4, StockCount = 3
};
var sut = await handler.Handle(request, new CancellationToken());
Assert.Equal(HttpStatusCode.OK, sut.StatusCode);
Assert.Equal(Errors.InsufficientStockCount, sut.Message);
Assert.False(sut.Data);
}
public async Task <IActionResult> Put([FromBody] AddProductToBasketRequest request) =>
await _addProductToBasketCommand.Value.ExecuteAsync(new AddProductToBasketMessage(request.CustomerId) { Product = request.Product });
public async Task <IActionResult> Add([FromBody] AddProductToBasketRequest request)
{
var response = await _mediator.Send(request);
return(Ok(response));
}
public async Task <ResponseModel <bool> > AddBasketProductAsync(AddProductToBasketRequest request)
{
return(await _mediator.Send(request));
}
