/// <summary>
/// Adds a single item to the basket of the given user. If the items has already been added
/// then it is updated.
/// </summary>
/// <param name="userId">The user ID for whom to add the basket item to.</param>
/// <param name="basketItem">The basket item to add.</param>
/// <returns>A response containing success/failure of the operation and an error message if one occurs.</returns>
public async Task <BasketItemResponse> AddItem(int userId, BasketItem basketItem)
{
var basket = GetOrCreateAndGetBasket(userId);
basket.AddOrUpdate(basketItem.ItemId, basketItem, (_, bi) => basketItem);
var itemDetails = await GetItemDetails(basketItem);
/*
* Bit of a cheat... If the item does not exist we ought to not add it.
* This is breaking my integration test which is the only way to show the whole
* service working since I did not manage to complete a UI.
* The below commented implementation is what I had am replacing it to allow the addition.
*
* if (!itemDetails.IsEmpty())
* {
* basket.AddOrUpdate(basketItem.ItemId, basketItem, (_, bi) => basketItem);
*
* return BasketItemResponse.CreateSuccessfulResult(
* new DetailedBasketItem(basketItem.ItemId,
* itemDetails.Description,
* itemDetails.Price,
* basketItem.Quantity));
* }
*
* return BasketItemResponse.CreateFailedResult($"Item with ID={basketItem.ItemId} is not a valid item and cannot be added to your basket.");
*/
return(BasketItemResponse.CreateSuccessfulResult(await CreateDetailedBasketItem(basketItem)));
}
public async Task <BasketItemResponse> Put([FromBody] BasketItem update)
{
return(await _authorizationLayer.ExecuteAuthorizedAction(User.Identity,
id => _basketItemsRepository.AddItem(id, update),
e => BasketItemResponse.CreateFailedResult(e),
"An error occurred while trying to add a new item in your basket."));
}
public async Task <BasketItemResponse> Post([FromBody] List <BasketItem> updates)
{
return(await _authorizationLayer.ExecuteAuthorizedAction(User.Identity,
id => _basketItemsRepository.UpdateItems(id, updates),
e => BasketItemResponse.CreateFailedResult(e),
"An error occurred while trying to fetch the users basket items."));
}
public async Task <BasketItemResponse> Delete([FromRoute] int itemId)
{
return(await _authorizationLayer.ExecuteAuthorizedAction(User.Identity,
id => _basketItemsRepository.RemoveItem(id, itemId),
e => BasketItemResponse.CreateFailedResult(e),
"An error occurred while trying to clear your basket items."));
}
/// <summary>
/// Remove an item to the user's basket.
/// </summary>
/// <param name="itemId">The ID of the item to remove.</param>
/// <returns>A response containing success/failure of the operation and an error message if one occurs.</returns>
public async Task <BasketItemResponse> RemoveItemFromBasket(BasketItem item)
{
return(await DeleteCall(
$"{EnvironmentService.ServiceEndpoints[KnownService.BasketService]}/{item.ItemId}",
item,
e => { return BasketItemResponse.CreateFailedResult(e.Message); }));
}
/// <summary>
/// Updates multiple items from the user's basket.
/// - If the item does not exist it will be added.
/// - If the item quantity is set to zero it will be removed.
/// </summary>
/// <param name="updates">A list of basket updates.</param>
/// <returns>A response containing success/failure of the operation and an error message if one occurs.</returns>
public async Task <BasketItemResponse> UpdateBasketItem(List <BasketItem> items)
{
return(await PostCall(
$"{EnvironmentService.ServiceEndpoints[KnownService.BasketService]}",
items,
e => { return BasketItemResponse.CreateFailedResult(e.Message); }));
}
/// <summary>
/// Add an item to the user's basket.
/// </summary>
/// <param name="item">The item to add. This includes the item ID as well as the quantity.</param>
/// <returns>A response containing success/failure of the operation and an error message if one occurs.</returns>
public async Task <BasketItemResponse> AddItemToBasket(BasketItem item)
{
return(await PutCall(
$"{EnvironmentService.ServiceEndpoints[KnownService.BasketService]}",
item,
e => { return BasketItemResponse.CreateFailedResult(e.Message); }));
}
/// <summary>
/// Clears all the contents from the user's basket.
/// </summary>
/// <returns>A response containing success/failure of the operation and an error message if one occurs.</returns>
public async Task <BasketItemResponse> ClearBasket()
{
return(await DeleteCall <object, BasketItemResponse>(
$"{EnvironmentService.ServiceEndpoints[KnownService.BasketService]}",
null,
e => { return BasketItemResponse.CreateFailedResult(e.Message); }));
}
/// <summary>
/// Clears all the items from the given users basket.
/// </summary>
/// <param name="userId">The user ID for whom to clear all basket items.</param>
/// <returns>A response containing success/failure of the operation and an error message if one occurs.</returns>
public async Task <BasketItemResponse> ClearItems(int userId)
{
var basket = GetOrCreateAndGetBasket(userId);
basket.Clear();
return(BasketItemResponse.CreateSuccessfulResult(DetailedBasketItem.Empty));
}
/// <summary>
/// Removes a single item from the basket of the given user.
/// </summary>
/// <param name="userId">The user ID for whom to remove the basket item from.</param>
/// <param name="itemId">The item ID to remove from the basket.</param>
/// <returns>A response containing success/failure of the operation and an error message if one occurs.</returns>
public async Task <BasketItemResponse> RemoveItem(int userId, int itemId)
{
var basket = GetOrCreateAndGetBasket(userId);
basket.TryRemove(itemId, out BasketItem _);
return(BasketItemResponse.CreateSuccessfulResult(DetailedBasketItem.Empty));
}
/// <summary>
/// Updates (or adds if not present) a single item from the basket of the given user.
/// The only thing that can be updated is the quantity. If the quantity is set to zero
/// then the item will be removed.
/// </summary>
/// <param name="userId">The user ID for whom to update the basket item.</param>
/// <param name="basketItem">The basket item to update.</param>
/// <returns>A response containing success/failure of the operation and an error message if one occurs.</returns>
public async Task <BasketItemResponse> UpdateItem(int userId, BasketItem basketItem)
{
var basket = GetOrCreateAndGetBasket(userId);
UpdateOrRemoveBasketItem(basket, basketItem);
var detailedBasketItem = await CreateDetailedBasketItem(basketItem);
return(BasketItemResponse.CreateSuccessfulResult(detailedBasketItem));
}
/// <summary>
/// Updates (or adds if not present) multiple items from the basket of the given user.
/// The only thing that can be updated is the quantity. If the quantity is set to zero
/// then the item will be removed.
/// </summary>
/// <param name="userId">The user ID for whom to update the basket item.</param>
/// <param name="basketItems">The basket items to update.</param>
/// <returns>A response containing success/failure of the operation and an error message if one occurs.</returns>
public async Task <BasketItemResponse> UpdateItems(int userId, IEnumerable <BasketItem> basketItems)
{
var basket = GetOrCreateAndGetBasket(userId);
var detailedBasketItems = new List <DetailedBasketItem>();
foreach (var basketItem in basketItems)
{
UpdateOrRemoveBasketItem(basket, basketItem);
// OK this is not optimal but im running out of time :-)
var detailedBasketItem = await CreateDetailedBasketItem(basketItem);
detailedBasketItems.Add(detailedBasketItem);
}
return(BasketItemResponse.CreateSuccessfulResult(detailedBasketItems));
}
