public async Task <IActionResult> AddBasketItem([FromBody] AddBasketItemRequest data)
{
if (data == null || data.Quantity == 0)
{
return(BadRequest("Invalid payload"));
}
// Step 1: Get the item from catalog
var item = await _catalog.GetCatalogItem(data.CatalogItemId);
//item.PictureUri =
// Step 2: Get current basket status
var currentBasket = (await _basket.GetById(data.BasketId)) ?? new BasketData(data.BasketId);
// Step 3: Merge current status with new product
currentBasket.Items.Add(new BasketDataItem()
{
UnitPrice = item.Price,
PictureUrl = item.PictureUri,
ProductId = item.Id.ToString(),
ProductName = item.Name,
Quantity = data.Quantity,
Id = Guid.NewGuid().ToString()
});
// Step 4: Update basket
await _basket.Update(currentBasket);
return(Ok());
}
public async Task <BaseResponseDto <bool> > Handle(AddBasketItemRequest request, CancellationToken cancellationToken)
{
BaseResponseDto <Boolean> response = new BaseResponseDto <Boolean>();
try
{
var basketItem = new BasketItem
{
BasketId = request.BasketId,
Price = request.Price,
ProductId = request.ProductId,
ProductName = request.ProductName,
Quantity = request.Quantity
};
var result = await _repository.Create(basketItem);
if (result != null)
{
response.Data = true;
}
else
{
response.Errors.Add("An error occurred while creating BasketItem data in database.");
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
response.Data = false;
response.Errors.Add(exception.Message);
}
return(response);
}
public async Task <ActionResult> AddItemToBasket([FromBody] AddBasketItemRequest data)
{
if (data == null || data.Quantity == 0)
{
return(BadRequest("Invalid payload"));
}
// Step 1: Get the item from catalog
var item = await _catalogService.GetCatalogItemAsync(data.CatalogItemId);
// Step 2: Get current basket status
var currentBasket = await _repository.GetBasketAsync(data.BasketId) ?? new CustomerBasket(data.BasketId);
// Step 3: Merge current status with new product
currentBasket.Items.Add(new BasketItem()
{
UnitPrice = item.Price,
ISBN13 = item.ISBN13,
ProductId = item.Id.ToString(),
ProductName = item.Name,
Quantity = data.Quantity,
Id = Guid.NewGuid().ToString()
});
// Step 4: Update basket
await _repository.UpdateBasketAsync(currentBasket);
return(Ok());
}
public UpdateBasketItemTests()
{
var factory = new WebApplicationFactory <Startup>();
_client = new CheckoutHttpClient(factory.CreateClient());
_basketItem1 = new AddBasketItemRequest
{
Quantity = 2,
Ref = "ABC",
Name = "Banana",
Price = 2.99M,
};
_basketItem2 = new AddBasketItemRequest
{
Quantity = 1,
Ref = "XYZ",
Name = "Apple",
Price = 4.99M,
};
_updateBasketItem1Request = new UpdateBasketItemRequest
{
Quantity = 50
};
}
public async Task <IActionResult> AddBasketItem(Guid basketId, [FromBody] AddBasketItemRequest basketItem)
{
if (ModelState.IsValid)
{
var basketItemId = await _mediatr.Send(new AddBasketItemCommand
{
BasketId = basketId,
Ref = basketItem.Ref,
Name = basketItem.Name,
Price = basketItem.Price,
Quantity = basketItem.Quantity
});
return(Ok(new AddBasketItemResponse {
BasketItemId = basketItemId
}));
}
var errorList = ModelState.ToDictionary(
kvp => kvp.Key,
kvp => kvp.Value.Errors.Select(e => e.ErrorMessage).ToArray()
);
return(BadRequest(errorList));
}
public async Task <BasketDto> Put([FromBody] AddBasketItemRequest request)
{
return(MapToDto(await _client.UpdateAsync(new UpdateItemRequest
{
User = request.User,
Product = request.ProductId,
Unit = request.Unit
}, deadline: _deadline)));
}
public async Task <IActionResult> AddToBasket(string user, string session, AddBasketItemRequest request)
{
var task = await _basketService.AddToBasket(
user,
session,
new BasketItem(request.FoodId, request.FoodName, request.ImageUrl,
request.UnitPrice, request.Quantity));
return(HandleTaskResult(task));
}
public UpdateBasketItemBadRequestTests()
{
var factory = new WebApplicationFactory <Startup>();
_client = new CheckoutHttpClient(factory.CreateClient());
_basketItem = new AddBasketItemRequest
{
Quantity = 2,
Ref = "ABC",
Name = "Banana",
Price = 2.99M,
};
}
public async Task <Guid> AddBasketItemAsync(Guid basketId, AddBasketItemRequest addBasketItemRequest)
{
if (addBasketItemRequest == null)
{
throw new ArgumentNullException(nameof(addBasketItemRequest));
}
return((await PostAsync <AddBasketItemInternalResponse>($"/basket/{basketId}", new AddBasketItemInternalRequest
{
Quantity = addBasketItemRequest.Quantity,
Ref = addBasketItemRequest.Ref,
Name = addBasketItemRequest.Name,
Price = addBasketItemRequest.Price
})).BasketItemId);
}
public async Task It_Returns_BadRequest_When_Quantity_Is_Invalid(int quantity)
{
var basketItem = new AddBasketItemRequest
{
Quantity = 2,
Ref = "ABC",
Name = "Banana",
Price = 2.99M,
};
var basketId = (await _client.PostAsync <CreateBasketResponse>("/basket")).BasketId;
var basketItem1Id = (await _client.PostAsync <AddBasketItemResponse>($"/basket/{basketId}", basketItem)).BasketItemId;
var response = await _client.PutAsync($"/basket/{basketId}/{basketItem1Id}", new UpdateBasketItemRequest { Quantity = quantity });
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}
public async Task <ActionResult> AddBasketItemAsync([FromBody] AddBasketItemRequest data)
{
if (data == null || data.Quantity == 0)
{
return(BadRequest("Invalid payload"));
}
// Step 1: Get the item from catalog
var item = await _catalog.GetCatalogItemAsync(data.CatalogItemId);
//item.PictureUri =
// Step 2: Get current basket status
var currentBasket = (await _basket.GetById(data.BasketId)) ?? new BasketData(data.BasketId);
currentBasket.Coupon = currentBasket.Coupon ?? new Coupon
{
Discount = 0
};
// Step 3: Search if exist product into basket
var product = currentBasket.Items.SingleOrDefault(i => i.ProductId == item.Id);
if (product != null)
{
// Step 4: Update quantity for product
product.Quantity += data.Quantity;
}
else
{
// Step 4: Merge current status with new product
currentBasket.Items.Add(new BasketDataItem()
{
UnitPrice = item.Price,
PictureUrl = item.PictureUri,
ProductId = item.Id,
ProductName = item.Name,
Quantity = data.Quantity,
Id = Guid.NewGuid().ToString()
});
}
// Step 5: Update basket
await _basket.UpdateAsync(currentBasket);
return(Ok());
}
public async Task <ActionResult> AddBasketItemAsync([FromBody] AddBasketItemRequest data)
{
if (data == null || data.Slots == 0)
{
return(BadRequest("Invalid payload"));
}
// Step 1: Get the item from scholarship
var item = await _scholarship.GetScholarshipItemAsync(data.ScholarshipItemId);
//item.PictureUri =
// Step 2: Get current basket status
var currentBasket = (await _basket.GetById(data.BasketId)) ?? new BasketData(data.BasketId);
// Step 3: Search if exist scholarshipItem into basket
var scholarshipItem = currentBasket.Items.SingleOrDefault(i => i.ScholarshipItemId == item.Id);
if (scholarshipItem != null)
{
// Step 4: Update quantity for scholarshipItem
scholarshipItem.Slots += data.Slots;
}
else
{
// Step 4: Merge current status with new scholarshipItem
currentBasket.Items.Add(new BasketDataItem()
{
SlotAmount = item.Amount,
PictureUrl = item.PictureUri,
ScholarshipItemId = item.Id,
ScholarshipItemName = item.Name,
Slots = data.Slots,
Id = Guid.NewGuid().ToString()
});
}
// Step 5: Update basket
await _basket.UpdateAsync(currentBasket);
return(Ok());
}
public async Task <ActionResult> AddBasketItemAsync([FromBody] AddBasketItemRequest data)
{
if (data == null || data.Quantity == 0)
{
return(BadRequest("Invalid data"));
}
var item = await _productService.GetProductByIdAsync(data.ProductId);
var currentBasket = (await _basketService.GetByIdAsync(data.BasketId)) ?? new BasketModel(data.BasketId);
currentBasket.Items.Add(new BasketItemModel()
{
UnitPrice = item.Price,
ProductImageUrl = item.ImageUrl,
ProductId = item.Id,
ProductName = item.Name,
Quantity = data.Quantity
});
await _basketService.UpdateAsync(currentBasket);
return(Ok());
}
public async Task <BaseResponseDto <Boolean> > AddBasketItemAsync(AddBasketItemRequest request)
{
return(await _mediator.Send(request));
}
