public async Task <int> UpdateShoppingCart(ShoppingCartDto model)
{
var shopCart = await _service.QueryAsync(model.Id);
shopCart.Number += 1;
return(await _service.EditAsync(shopCart));
}
public async Task <IActionResult> PutShoppingCart(int id, ShoppingCartDto shoppingCartDto)
{
if (id != shoppingCartDto.Id)
{
return(BadRequest());
}
var shoppingCart = _mapper.Map <ShoppingCart>(shoppingCartDto);
_context.Entry(shoppingCart).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ShoppingCartExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public IActionResult AddItem([FromBody] ShoppingCartDto item)
{
_logger.LogInformation("Hello from dummy controller!");
//_logger.LogInformation("User name: " + User.Identity.Name + "User role: " + User.Identity.ToString() + "Time: " + DateTime.Now.ToString("h:mm:ss tt") + "ShoppingCartController:CheckIfUserHasShoppingCart()");
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (item.itemQuantity == 0)
{
return(NoContent());
}
var userName = JWTtoken.GetTokenInfo(Request, "sub");
if (userName == null)
{
return(NotFound("Could not get token"));
}
var itemFromDb = _itemsRepository.GetItem(item.itemId);
if (itemFromDb == null)
{
return(NotFound("Item with given id not found"));
}
var shoppingCart = _shoppingCartRepository.Get(userName);
_shoppingCartRepository.Add(shoppingCart, itemFromDb.Id, item.itemQuantity);
return(Ok("Item(s) added successfully"));
}
public async Task <ActionResult> CreateCartAsync(ShoppingCartDto cartDto)
{
if (cartDto is null)
{
return(NotFound());
}
int cartId = 0;
try
{
var cart = new ShoppingCart
{
DateCreatedUtc = DateTime.Parse(cartDto.DateCreatedUtc).ToUniversalTime()
};
cartId = await _cartService.CreateCartAsync(cart);
}
catch (Exception e)
{
return(BadRequest());
}
return(Ok(new { cartId }));
}
public ShoppingCartDto getShoppingCartInfo(string userId)
{
var loggedInUser = this._userRepository.Get(userId);
var userShoppingCart = loggedInUser.UserCart;
var AllProducts = userShoppingCart.products.ToList();
var allProductPrice = AllProducts.Select(z => new
{
ProductPrice = z.product.ProductPrice,
Quanitity = z.Qantity
}).ToList();
var totalPrice = 0;
foreach (var item in allProductPrice)
{
totalPrice += item.Quanitity * item.ProductPrice;
}
ShoppingCartDto scDto = new ShoppingCartDto
{
productInShoppingCart = AllProducts,
TotalPrice = totalPrice
};
return(scDto);
}
public IShoppingCartDto GetShoppingCartById(int id)
{
SqlConnection conn = webShopContext.GetConnection();
IShoppingCartDto shoppingCart = null;
try
{
conn.Open();
string sql = "SELECT profile_id, product_id, amount FROM shoppingcart WHERE profile_id = @id;";
SqlCommand cmd = new SqlCommand(sql, conn);
cmd.Parameters.AddWithValue("@id", id);
SqlDataReader rdr = cmd.ExecuteReader();
while (rdr.Read())
{
shoppingCart = new ShoppingCartDto()
{
ProfileID = rdr.GetInt32(0),
ProductID = rdr.GetInt32(1),
Amount = rdr.GetInt32(2),
};
}
rdr.Close();
}
catch (Exception e)
{
throw e;
}
conn.Close();
return(shoppingCart);
}
public List <ShoppingCartDto> AddToCart(long id, int quantity, User user, object session)
{
List <ShoppingCartDto> listItem = new List <ShoppingCartDto>();
var product = new ShoppingDao().GetDetailProduct(id);
if (session != null)
{
listItem = (List <ShoppingCartDto>)session;
if (listItem.Exists(x => x.ProductId == id))
{
foreach (var item in listItem)
{
if (item.ProductId == id)
{
item.Quantity += quantity;
item.TotalPrice = item.Quantity * item.Price;
}
}
}
else
{
var newCart = new ShoppingCartDto();
long orderId = new OrderDao().GetOrderId() + 1;
newCart.OrderId = orderId;
newCart.CustomerId = user.UserID;
newCart.ProductId = product.ProductID;
newCart.ProductName = product.ProductName;
newCart.Image = product.Image;
newCart.Price = product.Price;
newCart.Quantity = quantity;
newCart.TotalPrice = product.Price * newCart.Quantity;
newCart.CustomerName = user.Name;
newCart.Address = user.Address;
newCart.Phone = user.Phone;
newCart.Email = user.Email;
listItem.Add(newCart);
}
}
else
{
var newCart = new ShoppingCartDto();
long orderId = new OrderDao().GetOrderId() + 1;
newCart.OrderId = orderId;
newCart.CustomerId = user.UserID;
newCart.ProductId = product.ProductID;
newCart.ProductName = product.ProductName;
newCart.Image = product.Image;
newCart.Price = product.Price;
newCart.Quantity = quantity;
newCart.TotalPrice = product.Price * newCart.Quantity;
newCart.CustomerName = user.Name;
newCart.Address = user.Address;
newCart.Phone = user.Phone;
newCart.Email = user.Email;
listItem.Add(newCart);
}
return(listItem);
}
public static CheckoutDto CreateCheckOutDto(
ShoppingCartDto shoppingCart = null,
double shippingCost = 0,
double customerDiscount = 0,
double total = 0
)
{
return(new(shoppingCart, shippingCost, customerDiscount, total));
}
public async Task <ActionResult <ShoppingCart> > PostShoppingCart(ShoppingCartDto shoppingCartDto)
{
var shoppingCart = _mapper.Map <ShoppingCart>(shoppingCartDto);
await _context.ShoppingCart.AddAsync(shoppingCart);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetShoppingCart", new { id = shoppingCart.Id }, shoppingCart));
}
public void When_Coupon_Is_Null_Return_Zero()
{
var sut = new CouponEngine();
var shoppingCartDto = new ShoppingCartDto()
{
Id = "1", Items = Utility.GenerateListOfDtoItems()
};
var checkout = new CheckoutDto(shoppingCartDto, 10, 1, 100);
var result = sut.CalculateDiscount(checkout, null);
result.Should().Be(0);
}
public ShoppingCartDto CreateShoppingCart(int clientId)
{
var client = _clientRepo.SingleOrDefault(x => x.Id == clientId);
var shoppingCart = _cartRepo.Create(
new ShoppingCart
{
Client = client,
Products = new List <Product>()
});
return(ShoppingCartDto.ToDto(shoppingCart));
}
public async Task <int> AddShoppingCart(ShoppingCartDto model)
{
IProductService service2 = new ProductService();
var product = await service2.QueryAsync(model.ProductId);
return(await _service.AddAsync(new ShoppingCart()
{
ProductId = model.ProductId,
ColorId = product.ColorId,
SizeId = product.SizeId,
Number = 1,
UserId = model.UserId
}));
}
public async Task <IActionResult> Addtocart(ShoppingCartDto shoppingCartDto)
{
ErrorDto errorDto = new ErrorDto();
var usercontrole = await _shoppingCartService.AppuserControl(shoppingCartDto.AppuserId);
if (!usercontrole.IsOk)
{
errorDto.Errors = usercontrole.Errors;
errorDto.Status = usercontrole.Status;
return(NotFound(errorDto));
}
var userproductstokcontrol = await _shoppingCartService.ProductStockControl(shoppingCartDto.ProductId, shoppingCartDto.Count);
if (!userproductstokcontrol.IsOk)
{
errorDto.Errors = usercontrole.Errors;
errorDto.Status = usercontrole.Status;
return(NotFound(errorDto));
}
var shoppingCartControl = await _shoppingCartService.ShoppingCartControl(shoppingCartDto.ProductId, shoppingCartDto.AppuserId);
if (!shoppingCartControl.IsOk)
{
var newshoppingCartDto = await _shoppingCartService.AddAsync(_mapper.Map <ShoppingCart>(shoppingCartDto));
return(Created(string.Empty, _mapper.Map <ShoppingCartDto>(newshoppingCartDto)));
}
var shoppingCart = shoppingCartControl.Model;
shoppingCart.Count = shoppingCart.Count + shoppingCartDto.Count;
if (userproductstokcontrol.Model.Stock < shoppingCart.Count)
{
errorDto.Status = 400;
errorDto.Errors.Add("Product is out of stock");
return(NotFound(errorDto));
}
var cart = _shoppingCartService.Update(shoppingCart);
return(Ok(cart));
}
private ShoppingCartDto MapOrderToShoppingCartDto(Order order)
{
var shoppingCart = new ShoppingCartDto
{
CustomerId = order.CustomerId,
OrderId = order.Id,
TotalPrice = order.TotalPrice,
Discount = order.Discount,
Subtotal = order.TotalPrice + order.Discount,
VoucherCode = order?.Voucher?.Code,
Items = MapOrderItemsToShoppingCartItemDtos(order.OrderItems).ToList()
};
return(shoppingCart);
}
public async Task <IActionResult> StartOrder(ShoppingCartDto shoppingCartDto)
{
var command = new StartOrderCommand(CustomerId, shoppingCartDto.OrderId, shoppingCartDto.TotalPrice, shoppingCartDto.Payment.CardName, shoppingCartDto.Payment.CardNumber,
shoppingCartDto.Payment.CardExpirationDate, shoppingCartDto.Payment.CardCvv);
await _mediatrHandler.SendCommand(command);
if (IsOperationValid())
{
return(RedirectToAction("Index", "Order"));
}
shoppingCartDto = await _orderQueries.GetCustomerShoppingCart(CustomerId);
return(View("PurchaseSummary", shoppingCartDto));
}
public void Coupon_Cannot_Be_Greater_Than_Cart_Total()
{
var sut = new CouponEngine();
var shoppingCartDto = new ShoppingCartDto()
{
Id = "1", Items = Utility.GenerateListOfDtoItems()
};
var checkout = new CheckoutDto(shoppingCartDto, 10, 1, 10);
Action result = () => sut.CalculateDiscount(checkout, new Coupon()
{
Amount = 100, ExpiryDate = DateTime.Now.AddDays(-60)
});
result.Should().Throw <CouponExpiredException>()
.WithMessage("Coupon past 30 days and has expired.");
}
public void Coupon_Calculated_As_A_Percentage()
{
var sut = new CouponEngine();
var shoppingCartDto = new ShoppingCartDto()
{
Id = "1", Items = Utility.GenerateListOfDtoItems()
};
var checkout = new CheckoutDto(shoppingCartDto, 10, 1, 10);
var result = sut.CalculateDiscount(checkout,
new Coupon()
{
Amount = 2, Type = CouponType.Percentage, ExpiryDate = DateTime.Now.AddDays(10)
});
result.Should().Be(20);
}
public async Task <ActionResult <ProductDto> > GetCartAsync(int cartId)
{
var cart = await _cartService.GetCartByIdAsync(cartId);
if (cart == null)
{
return(NotFound());
}
var dto = new ShoppingCartDto
{
ShoppingCartId = cart.ShoppingCartId,
DateCreatedUtc = cart.DateCreatedUtc.ToString("MM/dd/yyyy HH:mm:ss"),
ShoppingCartItems = _mapper.Map <IEnumerable <ShoppingCartItemDto> >(cart.ShoppingCartItems)
};
return(Ok(dto));
}
public void Coupon_Cannot_Be_A_Negative_Number()
{
var sut = new CouponEngine();
var shoppingCartDto = new ShoppingCartDto()
{
Id = "1", Items = Utility.GenerateListOfDtoItems()
};
var checkout = new CheckoutDto(shoppingCartDto, 10, 1, 10);
Action result = () => sut.CalculateDiscount(checkout,
new Coupon()
{
Amount = -2, ExpiryDate = DateTime.Now.AddDays(10)
});
result.Should().Throw <InvalidCouponException>()
.WithMessage("Coupon amount cannot be negative.");
}
public void Coupon_No_More_Than_OneHundred()
{
var sut = new CouponEngine();
var shoppingCartDto = new ShoppingCartDto()
{
Id = "1", Items = Utility.GenerateListOfDtoItems()
};
var checkout = new CheckoutDto(shoppingCartDto, 20, 10, 200);
Action result = () => sut.CalculateDiscount(checkout,
new Coupon()
{
Amount = 100, Type = CouponType.Percentage, ExpiryDate = DateTime.Now.AddDays(10)
});
result.Should().Throw <InvalidCouponException>()
.WithMessage("Coupon amount cannot be equal to 100.");
}
public void Complex_Class_Auto_Mapping_Test()
{
//the mappings are declared in reverse order to test that the order does not influence the mappings
//as long as the <ShoppingCartDto, ShoppingCart> compilation batch is not done at a later time
Mapper.CreateMap <ShoppingCart, ShoppingCartDto>();
Mapper.CreateMap <Product, ProductDto>();
ShoppingCart shoppingCart = GenerateShoppingCart();
ShoppingCartDto shoppingCartDto = Mapper.Map <ShoppingCart, ShoppingCartDto>(shoppingCart);
Assert.IsNotNull(shoppingCartDto);
Assert.IsNotNull(shoppingCartDto.Products);
Assert.AreEqual(2, shoppingCartDto.Products.Count);
Assert.AreEqual("First Product", shoppingCartDto.Products[0].Name);
Assert.AreEqual(13m, shoppingCartDto.Products[0].Price);
Assert.AreEqual("Second Product", shoppingCartDto.Products[1].Name);
Assert.AreEqual(12.5m, shoppingCartDto.Products[1].Price);
Assert.AreEqual(2, shoppingCart.Products[0].Feedback.Count);
}
public async Task <IActionResult> Create(ShoppingCartDto shoppingcartRequest)
{
if (shoppingcartRequest == null)
{
throw new ArgumentNullException("Invalid supermarket");
}
if (shoppingcartRequest.Name == null)
{
throw new ArgumentNullException("Supermarket's name is required");
}
var newShoppingCart = _mapper.Map <ShoppingCart>(shoppingcartRequest);
newShoppingCart.CreatedAt = DateTime.Now;
newShoppingCart.CreatedBy = CurrentUserId;
var shoppingcart = await _shoppingcartRepository.Add(newShoppingCart);
return(Ok(shoppingcart));
}
/// <summary>
/// Gets the shopping cart products.
/// </summary>
/// <param name="id">The identifier.</param>
/// <returns>Shopping Cart Dto.</returns>
public async Task <ShoppingCartDto> GetShoppingCartProducts(string id)
{
if (!await this.unitOfWork.Set <ShoppingCart>().AnyAsync(sc => sc.ShoppingCartID == id))
{
return(null);
}
ShoppingCartDto shoppingCart = await this.unitOfWork.Set <ShoppingCart>()
.Where(sc => sc.ShoppingCartID == id)
.Select(sc => new ShoppingCartDto
{
ShoppingCartID = sc.ShoppingCartID,
Products = sc.CartContents.Select(p => new ProductDto
{
ProductID = p.ProductID,
CartContentID = p.CartContentID,
Type = p.Product.ProductType.Value,
Characteristic = p.Product.ProductCharacteristics
.Select(pc => new
{
Key = pc.Characteristic.Name,
Value = pc.Value
}).ToDictionary(d => d.Key, d => d.Value)
}).ToArray()
}).SingleOrDefaultAsync();
double totalPrice = 0.0;
foreach (ProductDto product in shoppingCart.Products)
{
totalPrice += Convert.ToDouble(product.Characteristic["Price"], CultureInfo.InvariantCulture);
}
shoppingCart.TotalPrice = totalPrice;
return(shoppingCart);
}
public virtual async Task <List <ShoppingCartDto> > GetShoppingCartItem(int id)
{
_logger.LogInformation($"Getting shopping cart items");
List <ShoppingCartDto> listOfShoppingCart = new List <ShoppingCartDto>();
Product product = await GetProductById(id);
if (accessor.HttpContext.Session.GetInt32("counter") != null)
{
listOfShoppingCart = JsonConvert.DeserializeObject <List <ShoppingCartDto> >(accessor.HttpContext.Session.GetString("data"));
}
if (listOfShoppingCart.Any(x => x.ProductID == id))
{
listOfShoppingCart.Where(x => x.ProductID == id).Select(x => { x.Quantity = x.Quantity + 1; x.Total = x.Quantity * x.Price; return(x); }).ToList();
}
else
{
ShoppingCartDto dto = new ShoppingCartDto
{
ProductID = product.ProductID,
ProductName = product.ProductName,
Description = product.Description,
Price = product.Price,
Image = product.Image,
Quantity = 1,
Total = product.Price
};
listOfShoppingCart.Add(dto);
}
accessor.HttpContext.Session.SetInt32("counter", listOfShoppingCart.Count);
accessor.HttpContext.Session.SetString("data", JsonConvert.SerializeObject(listOfShoppingCart));
return(listOfShoppingCart);
}
public async Task <ActionResult <ProductDto> > CreateCartAsync()
{
try
{
var cart = new ShoppingCart
{
DateCreatedUtc = DateTime.UtcNow
};
int cartId = await _cartService.CreateCartAsync(cart);
var dto = new ShoppingCartDto
{
ShoppingCartId = cartId,
DateCreatedUtc = cart.DateCreatedUtc.ToString("MM/dd/yyyy HH:mm:ss"),
};
return(Ok(dto));
}
catch (Exception)
{
return(BadRequest());
}
}
public void GetShoppingCartById_ShoppingCartExists_ReturnShoppingCart()
{
//Arrange
var shoppingCartProductId = 34;
var shoppingCartProfileId = 21;
var shoppingCartAmount = 2;
var shoppingCartDto = new ShoppingCartDto
{
ProductID = shoppingCartProductId,
ProfileID = shoppingCartProfileId,
Amount = shoppingCartAmount,
};
_shoppingCartRepoMock.Setup(x => x.GetShoppingCartById(shoppingCartProductId)).Returns(shoppingCartDto);
//Act
var shoppingCart = _sut.GetShoppingCartById(shoppingCartProductId);
//Assert
Assert.AreEqual(shoppingCartProductId, shoppingCart.ProductID);
Assert.AreEqual(shoppingCartProfileId, shoppingCart.ProfileID);
Assert.AreEqual(shoppingCartAmount, shoppingCart.Amount);
}
public IActionResult Delete(int id)
{
cartItems = JsonConvert.DeserializeObject <List <ShoppingCartDto> >(HttpContext.Session.GetString("data"));
int productQuantity = cartItems.Where(x => x.ProductID == id).Select(x => x.Quantity).FirstOrDefault();
if (productQuantity == 1)
{
ShoppingCartDto removeItem = cartItems.Where(x => x.ProductID == id).FirstOrDefault();
if (removeItem != null)
{
cartItems.Remove(removeItem);
HttpContext.Session.SetString("data", JsonConvert.SerializeObject(cartItems));
HttpContext.Session.SetInt32("counter", cartItems.Count);
}
}
else
{
cartItems.Where(x => x.ProductID == id).Select(x => { x.Quantity = x.Quantity - 1; x.Total = x.Price * x.Quantity; return(x); }).ToList();
HttpContext.Session.SetString("data", JsonConvert.SerializeObject(cartItems));
HttpContext.Session.SetInt32("counter", cartItems.Count);
}
return(RedirectToAction("ShoppingCart"));
}
public IEnumerable <IShoppingCart> GetAll()
{
_connection.SqlConnection.Open();
var cmd = new MySqlCommand("SELECT * FROM shoppingcart", _connection.SqlConnection);
var reader = cmd.ExecuteReader();
var shoppingCartRecords = new List <IShoppingCart>();
while (reader.Read())
{
var shoppingCart = new ShoppingCartDto
{
ShoppingCartId = (int)reader["ShoppingCartId"],
UserId = (int)reader["UserId"],
OrderId = (int)reader["OrderId"],
Date = DateTime.Parse(reader["Date"]?.ToString() ?? ""),
Quantity = (int)reader["Quantity"]
};
shoppingCartRecords.Add(shoppingCart);
}
return(shoppingCartRecords);
}
public ShoppingCartDto GetShoppingCart(int shoppingCartId)
{
var cart = _cartRepo.SingleOrDefault(x => x.Id == shoppingCartId);
return(ShoppingCartDto.ToDto(cart));
}
public GetUserShoppingCartResponse()
{
ShoppingCartDto = new ShoppingCartDto();
}
public async Task CheckoutAsync(ShoppingCartDto shoppingCartDto)
=> await _client.PostAsJsonAsync("o/api/v1/orders", shoppingCartDto);