/// <inheritdoc />
public async Task <Unit> Handle(AddBasketCommand request, CancellationToken cancellationToken)
{
_basketRepository.AddBasket(request.Basket);
await _basketRepository.SaveChanges();
return(Unit.Value);
}
public async Task <IActionResult> AddBasket([FromBody] SaveBasketResource basketResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var basket = mapper.Map <SaveBasketResource, Basket>(basketResource);
if (basket.BasketItems.Any(item => item.ProductId == 0))
{
basket = new Basket()
{
BasketItems = new OrderDetails[] {}
}
}
;
basketRepositry.AddBasket(basket);
await unitOfWok.CompleteAsync();
basket = await basketRepositry.GetBasketAsync(basket.BasketId);
var result = mapper.Map <Basket, BasketResource>(basket);
return(Ok(result));
}
public async Task <ActionResult <Basket> > Post(BasketForCreation basketForCreation)
{
var basketEntity = mapper.Map <Entities.Basket>(basketForCreation);
basketRepository.AddBasket(basketEntity);
await basketRepository.SaveChanges();
var basketToReturn = mapper.Map <Basket>(basketEntity);
return(CreatedAtRoute(
"GetBasket",
new { basketId = basketEntity.BasketId },
basketToReturn));
}
public CustomerBasket AddItem(string customerId, BasketItem input)
{
if (string.IsNullOrWhiteSpace(customerId))
{
throw new ArgumentNullException(nameof(customerId));
}
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
return(_repository.AddBasket(customerId, input));
}
public async Task <ActionResult <BasketDto> > Post(BasketForCreationDto basketForCreation)
{
var basketEntity = _mapper.Map <Wall.Basket.Entity.Basket>(basketForCreation);
_basketRepository.AddBasket(basketEntity);
await _basketRepository.SaveChanges();
var basketToReturn = _mapper.Map <BasketDto>(basketEntity);
return(CreatedAtRoute(
"GetBasket",
new { basketId = basketEntity.BasketId },
basketToReturn));
}
public async Task <ActionResult <Basket> > Post(BasketForCreation basket)
{
var entity = _mapper.Map <Entities.Basket>(basket);
_repository.AddBasket(entity);
await _repository.SaveChanges();
var model = _mapper.Map <Basket>(entity);
return(CreatedAtRoute(
"GetBasket",
new { basketId = entity.BasketId },
model));
}
public async Task AddBasket(int id, BasketItem basketItem)
{
await _repo.AddBasket(id, basketItem);
}
public async Task <(Basket basket, BusinessErrorCollection errors)> AddItemToBasket(string userId, int productId, int quantity)
{
var product = await _productBusinessComponent.GetProductById(productId);
var errors = new BusinessErrorCollection();
var newBasket = false;
// Validate product is found
if (product == null)
{
errors.Add(BusinessErrors.P001ProductNotFound);
return(null, errors);
}
// Other business rules
if (product.Stock.Total - product.Stock.Reserved < quantity)
{
errors.Add(BusinessErrors.S001InsufficientStock);
}
var basket = await _basketRepository.GetBasketByUserId(userId);
if (!errors.IsValid)
{
return(basket, errors);
}
if (basket == null)
{
newBasket = true;
basket = new Basket
{
UserId = userId,
Items = new List <BasketItem>()
};
}
var item = basket.Items.SingleOrDefault(i => i.ProductId == productId);
try
{
await _shopDbTransactionManager.BeginTransaction();
if (newBasket)
{
await _basketRepository.AddBasket(basket);
}
else
{
await _basketRepository.UpdateBasket(basket);
}
if (item == null)
{
item = new BasketItem
{
BasketId = basket.Id,
ProductId = productId,
Quantity = quantity
};
await _basketRepository.AddBasketItem(item);
}
else
{
item.Quantity += quantity;
await _basketRepository.UpdateBasketItem(item);
}
await _shopDbTransactionManager.CommitTransaction();
}
catch
{
await _shopDbTransactionManager.RollbackTransaction();
throw;
}
return(basket, errors);
}
