public async Task <IActionResult> UpdateCartItem(int id, [FromBody] CartItemDto cartItem)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var cartItemFromDb = await _cartItemService.GetCartItemAsync(id);
if (cartItemFromDb == null)
{
await _cartItemService.AddCartItemAsync(cartItem);
return(CreatedAtRoute("GetCartItemById", cartItem.Id, cartItem));
}
await _cartItemService.UpdateCartItemAsync(cartItem);
return(Ok());
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
private CartProductDto MapCartProduct(CartItem ci,
CartItemDto ciDto,
CartProductDto cpDto,
ResolutionContext rContext)
{
return(fixture.Generate <CartProductDto>(constraints: new { Id = ci.ProductId }));
}
public void Publish(CartItemDto dto)
{
var factory = new ConnectionFactory
{
Uri = new Uri("amqp://*****:*****@localhost:5672")
};
using var connection = factory.CreateConnection();
using var channel = connection.CreateModel();
channel.QueueDeclare(QueueName,
durable: true,
exclusive: false,
autoDelete: false,
arguments: null);
var cartItemAddedEvent = JsonConvert.SerializeObject(
new CartItemAddedEvent
{
ProductId = dto.ProductId,
Qty = dto.Qty
});
var body = Encoding.UTF8.GetBytes(cartItemAddedEvent);
channel.BasicPublish("", QueueName, null, body);
}
public List <CartItemDto> GetProductsAvailableInCart(string cartID)
{
try
{
List <CartItemDto> cartItemList = new List <CartItemDto>();
List <CartItems> cartItems = _dbContext.CartItems.Where(x => x.CartId == cartID).ToList();
foreach (CartItems item in cartItems)
{
Product product = GetProductData(item.ProductId);
CartItemDto objCartItem = new CartItemDto
{
Product = product,
Quantity = item.Quantity
};
cartItemList.Add(objCartItem);
}
return(cartItemList);
}
catch
{
throw;
}
}
public async Task AddAsync_CartItemDto_AddOne()
{
string dbName = "AddAsync_CartItemDto_AddOne";
// Arrange
Product product1 = new Product
{
Id = 1,
ProductName = "Racing Car",
CategoryId = 1,
Description = "Nice Racing Car",
ImagePath = "abc.png",
UnitPrice = 23.1
};
var cartId = Guid.NewGuid().ToString();
var context = new WingtipContext(new DbContextOptionsBuilder <WingtipContext>().UseInMemoryDatabase("WingtipToysDB").Options);
context.Products.Add(product1);
context.SaveChanges();
ICartService service = new CartService(context, _mapper);
CartItemDto cartDto = new CartItemDto
{
CartId = cartId,
ProductId = product1.Id,
Quantity = 3
};
// Act
string result = await service.AddAsync(cartDto);
// Assert
Assert.AreEqual(cartId, result);
}
public CartItemDto Add(CartItemDto item)
{
var nItem = this._dbContext.CartItems.Add(item).Entity;
this._dbContext.SaveContextChanges();
return(nItem);
}
public async Task <IEnumerable <CartItemDto> > GetItemsInCart(string cartId)
{
try
{
var cartItemsDto = new List <CartItemDto>();
var cartItems = await db.CartItems.Where(x => x.CartId == cartId).ToListAsync();
if (cartItems == null)
{
return(cartItemsDto);
}
foreach (var item in cartItems)
{
var book = await db.Books.SingleOrDefaultAsync(x => x.Id == item.BookId);
var cartIt = new CartItemDto
{
Quantity = item.Quantity
};
cartIt.Book = mapper.Map <BookDto>(book);
cartItemsDto.Add(cartIt);
}
return(cartItemsDto);
}
catch (Exception)
{
throw;
}
}
public CartItemDto Update(CartItemDto entity)
{
var uItem = this._dbContext.CartItems.Update(entity).Entity;
this._dbContext.SaveContextChanges();
return(uItem);
}
public IActionResult Post([FromBody] CartItemDto cartItemDto)
{
var cartItem = _mapper.Map <CartItem>(cartItemDto);
var createdCartItem = _cartItemService.Create(cartItem);
var createdCartItemDto = _mapper.Map <CartItemDto>(createdCartItem);
return(StatusCode((int)HttpStatusCode.Created, createdCartItemDto));
}
public async Task UpdateCartItemAsync(CartItemDto cartItem)
{
var cartItemEntity = _mapper.Map <CartItemDto, CartItem>(cartItem);
await _uow.CartItems.UpdateAsync(cartItemEntity);
await _uow.SaveAsync();
}
private static bool EqualTo(this ShoppingCartItem expected, CartItemDto actual)
{
return(expected.ProductId == actual.ProductId &&
expected.Name == actual.ProductName &&
expected.Price == actual.Price &&
expected.Quantity == actual.Quantity &&
expected.ItemTotal == actual.ItemTotal);
}
public void Add_CartItemDto_AddOne()
{
// Arrange
Product product1 = new Product
{
Id = 1,
ProductName = "Racing Car",
CategoryId = 1,
Description = "Nice Racing Car",
ImagePath = "abc.png",
UnitPrice = 23.1
};
var cartId = Guid.NewGuid().ToString();
var dataProduct = new List <Product>
{
product1
}.AsQueryable();
var mockSetProducts = new Mock <DbSet <Product> >();
mockSetProducts.As <IQueryable <Product> >().Setup(m => m.Provider).Returns(dataProduct.Provider);
mockSetProducts.As <IQueryable <Product> >().Setup(m => m.Expression).Returns(dataProduct.Expression);
mockSetProducts.As <IQueryable <Product> >().Setup(m => m.ElementType).Returns(dataProduct.ElementType);
mockSetProducts.As <IQueryable <Product> >().Setup(m => m.GetEnumerator()).Returns(dataProduct.GetEnumerator());
var data = new List <CartItem>
{
}.AsQueryable();
var mockSet = new Mock <DbSet <CartItem> >();
mockSet.As <IQueryable <CartItem> >().Setup(m => m.Provider).Returns(data.Provider);
mockSet.As <IQueryable <CartItem> >().Setup(m => m.Expression).Returns(data.Expression);
mockSet.As <IQueryable <CartItem> >().Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.As <IQueryable <CartItem> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
var mockContext = new Mock <WingtipContext>(new DbContextOptionsBuilder <WingtipContext>().Options);
mockContext.Setup(m => m.Products).Returns(mockSetProducts.Object);
mockContext.Setup(m => m.CartItems).Returns(mockSet.Object);
ICartService service = new CartService(mockContext.Object, _mapper);
CartItemDto cartDto = new CartItemDto
{
CartId = cartId,
ProductId = product1.Id,
Quantity = 3
};
// Act
string result = service.Add(cartDto);
// Assert
Assert.AreEqual(cartId, result);
mockSet.Verify(m => m.Add(It.IsAny <CartItem>()), Times.Once());
mockContext.Verify(m => m.SaveChanges(), Times.Once());
}
public async Task <ActionResult <string> > AddToCart(CartItemDto cart)
{
var user = _helper.GetCurrentUserEmail();
cart.UserId = user;
var data = await _cartService.CreateCartItem(cart);
return(Ok(data));
}
public CartItem MapToCartItem(CartItemDto cartItemDto)
{
return(new CartItem
{
CartId = cartItemDto.CartId,
ProductId = cartItemDto.Product.Id,
Quantity = cartItemDto.Quantity
});
}
public async Task AddAsync_AddOne_UpdateIfExists()
{
// Arrange
Product product1 = new Product
{
Id = 1,
ProductName = "Racing Car",
CategoryId = 1,
Description = "Nice Racing Car",
ImagePath = "abc.png",
UnitPrice = 23.1
};
var cartId = Guid.NewGuid().ToString();
CartItem cartItem = new CartItem
{
Id = Guid.NewGuid().ToString(),
CartId = cartId,
ProductId = product1.Id,
Product = product1,
Created = DateTime.Now,
Quantity = 1
};
var context = new WingtipContext(new DbContextOptionsBuilder <WingtipContext>().UseInMemoryDatabase("WingtipToysDB").Options);
context.Products.Add(product1);
context.CartItems.Add(cartItem);
context.SaveChanges();
ICartService service = new CartService(context, _mapper);
CartItemDto cartDto = new CartItemDto
{
CartId = cartId,
ProductId = product1.Id,
Quantity = 3
};
// Act
await service.AddAsync(cartDto);
// Assert
var tempList = context.CartItems.ToList();
Assert.AreEqual(1, tempList.Count);
Assert.AreEqual(cartItem.Id, tempList[0].Id);
Assert.AreEqual(cartItem.CartId, tempList[0].CartId);
Assert.AreEqual(cartItem.ProductId, tempList[0].ProductId);
Assert.AreEqual(3, tempList[0].Quantity);
// Clean data
context.Products.RemoveRange(context.Products);
context.CartItems.RemoveRange(context.CartItems);
context.SaveChanges();
context.Dispose();
}
public void RemoveFromCart(CartDto cart, object productId)
{
CartItemDto cartItem = cart.CartItems.SingleOrDefault(o => object.Equals(o.ProductId, productId));
if (cartItem != null)
{
cart.CartItems.Remove(cartItem);
CalculateCart(cart);
}
}
public async Task <IActionResult> Post([FromBody] CartItemDto CartItem)
{
if (!ModelState.IsValid)
{
return(new ApiActionResult(new ApiResponse(HttpStatusCode.BadRequest, "Invalid model")));
}
var apiResponse = await _addCartItem.ExecutePipeline(CartItem);
return(new ApiActionResult(apiResponse));
}
public IActionResult Patch(int id, [FromBody] CartItemDto cartItemDto)
{
var cartItem = _mapper.Map <CartItem>(cartItemDto);
cartItem.Id = id;
var updatedCartItem = _cartItemService.Update(cartItem);
var updatedCartItemDto = _mapper.Map <CartItemDto>(updatedCartItem);
return(StatusCode((int)HttpStatusCode.Accepted, updatedCartItemDto));
}
public async Task AddCartItemAsync(CartItemDto cartItem)
{
var cartItemEntity = _mapper.Map <CartItemDto, CartItem>(cartItem);
await _uow.CartItems.AddAsync(cartItemEntity);
await _uow.SaveAsync();
cartItem.Id = cartItemEntity.Id;
}
public ActionResult AddProductVariant([FromBody] CartItemDto cartItem)
{
var result = this.cartRepository.AddProductVariantToCart(cartItem.ProductId, cartItem.VariantId, cartItem.Quantity);
if (result.Success)
{
return(this.JsonOk(result.Data));
}
return(this.JsonError(result.Errors?.ToArray(), HttpStatusCode.InternalServerError, tempData: result.Data));
}
public static CartItem MapToCartItem(this CartItemDto cartItemDto)
{
var cartItem = new CartItem
{
CartId = cartItemDto.CartId,
ProductId = cartItemDto.Product.Id,
Quantity = cartItemDto.Quantity
};
return(cartItem);
}
public ActionResult Patch([FromBody] CartItemDto dto)
{
string cartId = dto.CartId;
string itemId = dto.Id;
int quantity = dto.Quantity;
if (cartId == null || itemId == null || quantity <= 0)
{
return(BadRequest("Not enough information to update."));
}
_cartService.Patch(cartId, itemId, quantity);
return(NoContent());
}
public static CartItemDto MapToCartItemDto(this CartItem cartItem)
{
var productDto = cartItem.Product.MapToProductDto();
var cartItemDto = new CartItemDto
{
Id = cartItem.Id,
CartId = cartItem.CartId,
Product = productDto,
Quantity = cartItem.Quantity
};
return(cartItemDto);
}
public void AddtoCart(CartItemDto item)
{
if (_cart.CartItems.Exists(i => i.ProductId == item.ProductId))
{
var cartItem = _cart.CartItems.Find(i => i.ProductId == item.ProductId);
cartItem.Quantity += item.Quantity;
var index = _cart.CartItems.FindIndex(i => i.ProductId == item.ProductId);
_cart.CartItems.RemoveAt(index);
_cart.CartItems.Add(cartItem);
}
else
{
_cart.CartItems.Add(item);
}
}
public async Task <string> CreateCartItem(CartItemDto cart)
{
var c = new CartItem
{
EquipmentId = cart.EquipmentId,
UserId = cart.UserId,
DateCreated = DateTime.Now,
NoOfDays = cart.NoOfDays
};
_cartRepository.Add(c);
await _uow.CompleteAsync();
return(c.CartItemId.ToString());
}
private CartDto MapCartQueryToDto(CartQuery cart)
{
var cartDto = new CartDto();
cartDto.CartItems = new List <CartItemDto>();
foreach (var item in cart.CartItems)
{
var transformedItem = new CartItemDto(item.CartItemCode)
{
Quantity = item.Quantity
};
cartDto.CartItems.Add(transformedItem);
cartDto.CartValue += transformedItem.UnitPrice * transformedItem.Quantity;
}
return(cartDto);
}
public async Task <string> AddAsync(CartItemDto dto)
{
if (dto.Quantity <= 0)
{
dto.Quantity = 1;
}
var q = _context.Products.Where(p => p.Id == dto.ProductId);
var product = await q.FirstOrDefaultAsync();
if (product == null)
{
throw new KeyNotFoundException($"The product with ID={dto.ProductId} was not found.");
}
CartItem cartItem = null;
Guid x;
if (!Guid.TryParse(dto.CartId, out x))
{
dto.CartId = Guid.NewGuid().ToString();
}
else
{
cartItem = await _context.CartItems.FirstOrDefaultAsync(c => c.CartId == dto.CartId && c.ProductId == dto.ProductId);
}
if (cartItem == null)
{ // create new
cartItem = new CartItem
{
Id = Guid.NewGuid().ToString(),
CartId = dto.CartId,
ProductId = dto.ProductId,
Quantity = dto.Quantity,
Created = DateTime.Now
};
await _context.CartItems.AddAsync(cartItem);
await _context.SaveChangesAsync();
}
else
{
cartItem.Quantity = dto.Quantity;
_context.Entry(cartItem).Property("Quantity").IsModified = true;
await _context.SaveChangesAsync();
}
return(cartItem.CartId);
}
private List <CartItemDto> GetCart()
{
var cart = _shoppingCart.GetCart();
var listCartDto = new List <CartItemDto>();
foreach (var cartItem in cart)
{
var cartDto = new CartItemDto
{
Product = cartItem.Product,
Quantity = cartItem.Quantity
};
listCartDto.Add(cartDto);
}
return(listCartDto);
}
public CartItem MapToCartItme(CartItemDto cartItemDto)
{
var cartItem = new CartItem();
if (cartItemDto != null)
{
cartItem.CartId = cartItemDto.CartIdDto;
cartItem.CreatedDate = cartItemDto.CreatedDateDto;
cartItem.Id = cartItemDto.IdDto;
cartItem.IsDeleted = cartItemDto.IsDeletedDto;
cartItem.ModifiedDate = cartItemDto.ModifiedDateDto;
cartItem.Quantity = cartItemDto.QuantityDto;
cartItem.ProductId = cartItemDto.productDto.IdDto;
}
;
return(cartItem);
}
public async Task <string> UpdateCartItem(CartItemDto cart)
{
var editor = _cartRepository.CartItemsById(cart.CartItemId);
if (editor != null)
{
editor.Result.NoOfDays = cart.NoOfDays;
editor.Result.DateCreated = cart.DateCreated;
editor.Result.UserId = cart.UserId;
editor.Result.EquipmentId = cart.EquipmentId;
await _uow.CompleteAsync();
return(editor.Result.CartItemId.ToString());
}
return("");
}
