public bool AddToBasket(AddProductToBasketRequestModel basketItems)
{
var productAvailability = CheckProductIsAvailable(basketItems);
if (!productAvailability.IsAvailable)
{
_logger.LogError("Product is not available ! Check Logs. ");
throw new ProductIsNotAvailableException("Product is not available ! Check Logs. ");
}
var userBasket = _basketRepository.GetUserBasket(basketItems.UserId);
if (userBasket == null)
{
userBasket = CreateNewBasket(basketItems, productAvailability);
}
else
{
UpdateBasket(basketItems, productAvailability, userBasket);
}
_basketRepository.SaveBasket(userBasket);
_eventPublisher.Publish(new ProductAddedToBasketEvent()
{
BasketId = userBasket.Id.ToString(),
BasketLines = userBasket.BasketLines,
UserId = userBasket.UserId
});
return(true);
}
public Basket UpdateBasket(AddProductToBasketRequestModel basketItems, ProductAvailability productAvailability, Basket userBasket)
{
var addedBasketLine = userBasket.BasketLines.FirstOrDefault(x => x.ProductId == basketItems.ProductId);
if (addedBasketLine != null)
{
var newQuantity = addedBasketLine.Quantity + basketItems.Quantity;
var availableStockModelForNewQuantity = _stockService.HasAvailableStock(new StockRequestModel()
{
ProductId = basketItems.ProductId, Quantity = newQuantity
});
if (availableStockModelForNewQuantity == null)
{
_logger.LogError("Stock is not sufficient");
throw new ProductIsNotAvailableException("Stock is not sufficient");
}
addedBasketLine.Quantity = newQuantity;
addedBasketLine.GiftNote = basketItems.GiftNote;
}
else
{
userBasket.BasketLines.Add(CreateNewBasketLine(basketItems, productAvailability));
}
return(userBasket);
}
public BasketLine CreateNewBasketLine(AddProductToBasketRequestModel basketItems, ProductAvailability productAvailability)
{
var basketLine = new BasketLine()
{
ProductId = basketItems.ProductId,
Quantity = basketItems.Quantity,
StockId = productAvailability.StockId,
GiftNote = basketItems.GiftNote
};
return(basketLine);
}
public void Setup()
{
addProductToBasketRequestModel
= new AddProductToBasketRequestModel()
{
ProductId = 10,
GiftNote = "test",
UserId = 11,
Quantity = 12,
CreatedDate = new DateTime(2020, 3, 3)
};
}
public Basket CreateNewBasket(AddProductToBasketRequestModel basketItems, ProductAvailability productAvailability)
{
List <BasketLine> basketLines = new List <BasketLine>();
basketLines.Add(CreateNewBasketLine(basketItems, productAvailability));
var basket = new Basket()
{
UserId = basketItems.UserId,
CreatedDate = DateTime.UtcNow,
BasketLines = basketLines,
IsActive = true,
IsOrdered = false,
UpdateDate = DateTimeProvider.Instance.GetUtcNow()
};
return(basket);
}
public ProductAvailability CheckProductIsAvailable(AddProductToBasketRequestModel basketItems)
{
var product = _productService.GetProduct(new ProductRequestModel()
{
ProductId = basketItems.ProductId
});
if (product == null)
{
return(ProductAvailability.NotAvailable);
}
var user = _userService.GetUser(new UserRequestModel()
{
UserId = basketItems.UserId
});
if (user == null)
{
return(ProductAvailability.NotAvailable);
}
var stockModelForRequestQuantity = _stockService.HasAvailableStock(new StockRequestModel()
{
ProductId = basketItems.ProductId, Quantity = basketItems.Quantity
});
if (stockModelForRequestQuantity == null)
{
return(ProductAvailability.NotAvailable);
}
var priceOfProduct = _priceService.GetProductPrice(new PriceRequestModel()
{
ProductId = basketItems.ProductId, RequestDate = DateTimeProvider.Instance.GetUtcNow()
});
if (priceOfProduct == null)
{
return(ProductAvailability.NotAvailable);
}
return(new ProductAvailability(stockModelForRequestQuantity.Id, priceOfProduct.Value, basketItems.ProductId, true));
}
public ActionResult AddToBasket([FromBody] AddProductToBasketRequestModel basketItems)
{
_logger.LogInformation("AddToBasket service initializer");
try
{
var addToBasketResult = _basketService.AddToBasket(basketItems);
_logger.LogInformation("AddToBasket finish own operation");
return(Ok());
}
catch (ProductIsNotAvailableException productIsNotAvailableException)
{
_logger.LogError(productIsNotAvailableException.Message);
return(StatusCode(406, productIsNotAvailableException.Message));
}
catch (Exception unExpectedException)
{
_logger.LogError(unExpectedException.Message);
return(StatusCode(500, unExpectedException.Message));
}
}
