private void dgvCart_CellContentClick(object sender, DataGridViewCellEventArgs e)
{
if (e.RowIndex == -1 || e.ColumnIndex == -1)
{
return;
}
ProductInCart selectedProduct = (ProductInCart)dgvCart.Rows[e.RowIndex].DataBoundItem;
if (dgvCart.Columns[e.ColumnIndex].Name == CartColAddOne.Name)
{
if (selectedProduct.AvailableQuantity > selectedProduct.SellingQuantity)
{
selectedProduct.SellingQuantity++;
CalculateTotalBillAmoutForCart(false);
}
}
else if (dgvCart.Columns[e.ColumnIndex].Name == CartColRemoveOne.Name)
{
if (selectedProduct.SellingQuantity == 1)
{
RemoveProductFromCart(selectedProduct.DealerBillBreakupId);
}
else if (selectedProduct.SellingQuantity > 1)
{
selectedProduct.SellingQuantity--;
CalculateTotalBillAmoutForCart(false);
}
}
}
private void dgvCart_CellEndEdit(object sender, DataGridViewCellEventArgs e)
{
if (e.ColumnIndex == dgvCart.Columns[CartColUnitSellPrice.Name].Index) // Editing Unit selling price
{
if (decimal.Parse(dgvCart.CurrentCell.Value.ToString())
<= decimal.Parse(dgvCart.Rows[e.RowIndex].Cells[dgvCart.Columns[CartColUnitPrice.Name].Index].Value.ToString()))
{
MessageBox.Show("Selling price is tool low");
dgvCart.CurrentCell.Value = previousSellingPrice;
return;
}
}
else if (e.ColumnIndex == dgvCart.Columns[CartColProductQuantityInCart.Name].Index) // Edit product quantity in cart
{
if (int.Parse(dgvCart.CurrentCell.Value.ToString()) == 0)
{
ProductInCart selectedProduct = (ProductInCart)dgvCart.Rows[e.RowIndex].DataBoundItem;
if (!RemoveProductFromCart(selectedProduct.DealerBillBreakupId))
{
dgvCart.CurrentCell.Value = previousQuantityInCart;
}
return;
}
else if (int.Parse(dgvCart.CurrentCell.Value.ToString()) >
int.Parse(dgvCart.Rows[e.RowIndex].Cells[dgvCart.Columns[CartColTotalQuantity.Name].Index].Value.ToString()))
{
MessageBox.Show("Selling Quantity can not be more than Available Quantity");
dgvCart.CurrentCell.Value = previousQuantityInCart;
return;
}
}
CalculateTotalBillAmoutForCart(true);
}
public IActionResult AddProductById(int id)
{
Product product = productRepository.GetById(id);
var user = userRepository.GetByUsername(User.Identity.Name);
var cart = repository.GetById(user.ShoppingCartId);
ProductInCart productInCart = new ProductInCart()
{
Ammount = 1,
ProductId = product.Id,
ShoppingCartId = cart.Id
};
var p = productInCartRepository.GetById(new Tuple <long, long>(product.Id, cart.Id));
if (p != null)
{
p.Ammount++;
productInCartRepository.Update(p);
}
else
{
productInCartRepository.AddEntity(productInCart);
}
return(RedirectToAction("Index", "Home"));
}
public void AddProductToCartUser(int productId, int productQuantity, int cartId)
{
using (var db = new Bagaround_ShopEntities1())
{
if (db.ProductInCart.Any(x => x.CartId == cartId && x.BagId == productId))
{
var productInCart = db.ProductInCart
.Where(x => x.CartId == cartId && x.BagId == productId)
.ToList();
foreach (var item in productInCart)
{
item.Quantity += productQuantity;
}
db.SaveChanges();
}
else
{
var productInCart = new ProductInCart
{
BagId = productId,
Price = db.Product.Where(x => x.BagId == productId).Select(x => x.Price).SingleOrDefault(),
Quantity = productQuantity,
DateDelivery = DateTime.Now.AddDays(3),
CartId = cartId
};
db.ProductInCart.Add(productInCart);
db.SaveChanges();
}
}
}
public IActionResult RemoveFromCart([FromBody] ProductInCart product)
{
//Retrieve userId and SessionId from cookies
string sessionId = HttpContext.Request.Cookies["sessionId"];
string userId = null;
if (sessionId != null)
{
if (HttpContext.Request.Cookies["userId"] != null)
{
userId = HttpContext.Request.Cookies["userId"];
}
}
/*
* Create a session object to query data since items in the cart can be temporary
* or permanent based on whether the user has logged in or not.
* Session object allows to query based on session id or user id based on whether the user
* has logged in
*/
Session sess = new Session()
{
SessionId = sessionId,
UserId = userId
};
CartData.DeleteFromCart(product, sess);
return(Json(new
{
success = true
}));
}
private void addProducts()
{
Product p1 = new Product(1, "p1", null, null, -1);
ProductInCart pc1 = new ProductInCart(3, user.Basket.ShoppingCarts[store.Id], p1);
user.Basket.ShoppingCarts[store.Id].Products.Add(1, pc1);
}
public bool AddProductToUserCart(ProductInCart product)
{
return(EditUserCart
(
new ProductInCart[] { product },
Enumerable.Empty <ProductId>(),
Enumerable.Empty <ProductInCart>()
));
}
public IActionResult Add(ProductInCart position)
{
if (!ModelState.IsValid)
{
return(View());
}
repository.AddEntity(position);
return(RedirectToAction("All"));
}
public bool EditProductInUserCart(ProductInCart product)
{
return(EditUserCart
(
Enumerable.Empty <ProductInCart>(),
Enumerable.Empty <ProductId>(),
new ProductInCart[] { product }
));
}
private void successSetUp()
{
system.Users.Add(user.Id, user);
system.Stores.Add(store.Id, store);
user.Basket.ShoppingCarts.Add(store.Id, new ShoppingCart(store.Id, store));
ProductInCart pc = new ProductInCart(2, user.Basket.ShoppingCarts[store.Id], product);
user.Basket.ShoppingCarts[store.Id].Products.Add(product.Id, pc);
}
public IActionResult Create(int?id)
{
var productInCart = new ProductInCart();
productInCart.product = _context.Product.Where(p => p.Id == id).FirstOrDefault();
productInCart.ProductId = productInCart.product.Id;
productInCart.Amount = 1;
ViewData["ProductId"] = new SelectList(_context.Product, "Id", "Desc");
return(View(productInCart));
}
public void TestMethod_cart_success_edit()
{
setUp();
ShoppingCart cart = new ShoppingCart(store.Id, null);
ProductInCart pc = new ProductInCart(2, cart, null);
cart.Products.Add(product.Id, pc);
Assert.AreEqual(true, cart.editProductQuantityInCart(product.Id, 3));
Assert.AreEqual(3, cart.Products[product.Id].Quantity);
}
private void successsetup()
{
system.Users.Add(user.Id, user);
system.Stores.Add(store.Id, store);
user.Basket.ShoppingCarts.Add(store.Id, new ShoppingCart(store.Id, store));
ProductInCart pc = new ProductInCart(2, user.Basket.ShoppingCarts[store.Id], product);
user.Basket.ShoppingCarts[store.Id].Products.Add(product.Id, pc);
productsToRemove = new List <int>(product.Id);
productsToRemove.Add(product.Id);
}
public void testmethod_cart_success_remove()
{
setup();
productsToRemove = new List <int>();
productsToRemove.Add(product.Id);
ShoppingCart cart = new ShoppingCart(store.Id, null);
ProductInCart pc = new ProductInCart(2, cart, null);
cart.Products.Add(product.Id, pc);
Assert.AreEqual(true, cart.removeProductsFromCart(productsToRemove));
}
public bool EditUserCart(IEnumerable <ProductInCart> productsAdd, IEnumerable <ProductId> productsRemove, IEnumerable <ProductInCart> productsEdit)
{
Result <Dictionary <Guid, Dictionary <ProductData, int> > >?result = marketShoppingCartService.EditShoppingCart
(
Username,
productsRemove.Select(x => x.Value).ToList(),
ProductInCart.ToDictionary(productsAdd),
ProductInCart.ToDictionary(productsEdit)
).Result;
return(result != null && !result.IsErr);
}
public void removeProductFromCart(ProductInCart productInCart)
{
lock (this)
{
try
{
productInCarts.Remove(productInCart);
}
catch
{
}
}
}
public void Success_BasketExists()
{
Success_NoBasket();
IEnumerable <ProductInCart> productsBefore = ProductForCart.ToProductInCart(ProductsAdd);
IEnumerable <ProductInCart> productsAdd = new ProductInCart[]
{
new ProductInCart(ShopImage.ShopProducts[1].ProductId, 14)
};
IEnumerable <ProductInCart> products = productsBefore.Concat(productsAdd);
testLogic.Success_Normal_CheckCartItems(productsAdd, products);
testLogic.Products?.AddRange(productsAdd);
}
private void dgvProductList_CellContentClick(object sender, DataGridViewCellEventArgs e)
{
if (e.RowIndex == -1 || e.ColumnIndex == -1)
{
return;
}
if (dgvProductList.Columns[e.ColumnIndex].Name == ColAddToCart.Name)
{
ProductInCart selectedProduct = (ProductInCart)dgvProductList.Rows[e.RowIndex].DataBoundItem;
customerBillBreakListForm.AddProductToCart(selectedProduct.ShallowCopy());
}
}
public IEnumerable <ProductInCart> Success_Normal_NoCheckCartItems()
{
IDictionary <ProductId, ProductInCart> expected = ProductForCart.ToDictionary_InCart(useCase_addProductToCart.ProductsAdd);
foreach (ProductCartEditInfo productEdit in ProductsEdit)
{
ProductId productId = productEdit.ProductOriginal.ProductId;
var productEditBare = new ProductInCart(productId, productEdit.NewQuantity);
Assert.IsTrue(MarketBridge.EditProductInUserCart(productEditBare));
expected[productId] = productEditBare;
}
return(expected.Values);
}
public int AddUpdate(ProductInCart newProductInCart)
{
var oldProductInCart = Get(newProductInCart.ProductId, newProductInCart.UserId);
if (oldProductInCart == null)
{
return(Add(newProductInCart));
}
else
{
return(Update(newProductInCart, oldProductInCart));
}
}
public async Task <IActionResult> Create([Bind("Id,ProductId,Amount,FinalPrice")] ProductInCart productInCart)
{
productInCart.product = _context.Product.Where(p => p.Id == productInCart.ProductId).FirstOrDefault();
if (HttpContext.Session.GetString("userId") == null)
{
return(View("../users/LogIn"));
}
if (ModelState.IsValid)
{
var myShoppingCartId = HttpContext.Session.GetString("MyShoppingCartId");
if (myShoppingCartId == null)
{
var myNewShoppingCart = new ShoppingCart()
{
DateCreate = DateTime.Now,
products = new List <ProductInCart>(),
UserId = int.Parse(HttpContext.Session.GetString("userId")),
user = _context.User.Where(u => u.Id == int.Parse(HttpContext.Session.GetString("userId"))).FirstOrDefault()
};
_context.Add(myNewShoppingCart);
await _context.SaveChangesAsync();
myShoppingCartId = myNewShoppingCart.Id.ToString();
HttpContext.Session.SetString("MyShoppingCartId", myShoppingCartId);
}
var newProductInCart = new ProductInCart()
{
Amount = productInCart.Amount,
product = _context.Product.Where(p => p.Id == productInCart.ProductId).FirstOrDefault(),
ProductId = productInCart.ProductId,
FinalPrice = (float)Math.Round(productInCart.Amount * productInCart.product.Price, 2),
ShoppingCart = _context.ShoppingCart.Where(S => S.Id == int.Parse(myShoppingCartId)).FirstOrDefault(),
ShoppingCartId = int.Parse(myShoppingCartId)
};
var prodactExsits = _context.ProductInCart.Where(p => p.ProductId == productInCart.ProductId && p.ShoppingCartId == int.Parse(myShoppingCartId)).FirstOrDefault();
if (prodactExsits != null)
{
newProductInCart.Id = prodactExsits.Id;
return(View("../Products/Index", _context.Product));
}
_context.Add(newProductInCart);
await _context.SaveChangesAsync();
return(View("../Products/Index", _context.Product));
}
ViewData["ProductId"] = new SelectList(_context.Product, "Id", "Desc", productInCart.ProductId);
return(View(productInCart));
}
public void Update(ProductInCart entity)
{
var item = context.ProductInCarts.FirstOrDefault(x => x.ProductId == entity.ProductId && x.ShoppingCartId == entity.ShoppingCartId);
if (item != null)
{
item.Product = entity.Product;
item.SCart = entity.SCart;
item.ProductId = entity.ProductId;
item.ShoppingCartId = entity.ShoppingCartId;
item.Ammount = entity.Ammount;
}
context.Update(item);
//context.SaveChanges();
}
// PUT: api/Cart
public IHttpActionResult Put([FromBody] ProductInCart productInCart)
{
AuthenticateWithTokenInHeaders();
try
{
this.businessLogic.Cart.AddProduct(productInCart.Product, productInCart.Quantity);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
internal void AddProductToCart(ProductInCart productToBeAddedToCart)
{
ProductInCart alredyProductInCart = productListCart.Find(x => x.DealerBillBreakupId == productToBeAddedToCart.DealerBillBreakupId);
if (alredyProductInCart != null)
{
MessageBox.Show("Product already availble in cart");
return;
}
// Override box details
productToBeAddedToCart.QuantityInBox = 1;
productToBeAddedToCart.TotalBoxes = 1;
productListCart.Add(productToBeAddedToCart);
CalculateTotalBillAmoutForCart(false);
}
public ActionResult EditQuantity(int quantity, int productId)
{
ProductInCart pic = ProductsInCartService.GetProductInCart(productId);
try
{
pic.Quantity = quantity;
pic.SubtotalForProduct = quantity * pic.Product.PriceEU;
ProductsInCartService.UpdateProductInCart(pic);
ProductsInCartService.SaveProductInCart();
}
catch (Exception e)
{
throw new Exception(e.ToString());
}
return(Json("Success!", JsonRequestBehavior.AllowGet));
}
// To remove an item from the Cart records
public static void DeleteFromCart(ProductInCart P, Session sess)
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
string sql = "";
if (sess.UserId != null) //user is logged in
{
sql = @"DELETE FROM Cart WHERE ProductID ='" + P.ProductID + "' and UserId='" + sess.UserId + "'";
}
else // user is not logged in
{
sql = @"DELETE FROM TemporaryCart WHERE ProductID ='" + P.ProductID + "' and SessionId='" + sess.SessionId + "'";
}
SqlCommand cmd = new SqlCommand(sql, conn);
int noAfffectedRows = cmd.ExecuteNonQuery();
}
}
//To update the database when user edits the cart
public static void EditItemQuantity(ProductInCart P, Session sess)
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
string sql = "";
if (sess.UserId != null) // user is logged in
{
sql = @"update Cart set Quantity ='" + P.Quantity + "'where UserId='" + sess.UserId + "' and ProductID= '" + P.ProductID + "'";
}
else // user is not logged in
{
sql = @"update TemporaryCart set Quantity ='" + P.Quantity + "'where SessionId='" + sess.SessionId + "' and ProductID= '" + P.ProductID + "'";
}
SqlCommand cmd = new SqlCommand(sql, conn);
int noAfffectedRows = cmd.ExecuteNonQuery();
}
}
public void TestMethod_success_cart()
{
setUp();
ShoppingCart cart = new ShoppingCart(store.Id, store);
//empty cart
Assert.AreEqual(0, cart.showCart().Count);
//non-empty cart
Product p = new Product(1, "p", null, null, -1);
ProductInCart pc = new ProductInCart(3, cart, p);
cart.Products.Add(p.Id, pc);
List <KeyValuePair <string, int> > list = new List <KeyValuePair <string, int> >();
list.Add(new KeyValuePair <string, int>(p.ProductName, 3));
Assert.IsTrue(list[0].Equals(cart.showCart()[0]));
}
public void Setup()
{
db = DBtransactions.getInstance(false);
db.Db = new DBmanager(false);
store = new Store(7, "adidas");
admin = new User(14, "guti", "1234", true, true);
user = new User(18, "halo", "halo", false, true);
p1 = new Product(4, "ramos", "", "", 10);
pis1 = new ProductInStore(10, store, p1);
store.Products.Add(p1.Id, pis1);
manager = new Manager(store, user, new List <int>());
admin.Basket.ShoppingCarts.Add(store.Id, new ShoppingCart(store.Id, store));
pic1 = new ProductInCart(1, admin.Basket.ShoppingCarts[store.Id], p1);
admin.Basket.ShoppingCarts[store.Id].Products.Add(p1.Id, pic1);
adminOwner = new Owner(store, admin);
store.RolesDictionary.Add(admin.Id, store.Roles.AddChild(adminOwner));
admin.Roles.Add(store.Id, adminOwner);
}
public void SaveCartContent(List <string> cartitemlist, int userId)
{
User curuser = _context.users.SingleOrDefault(u => u.userId == userId);
Cart curcart = _context.carts.SingleOrDefault(c => c.user == curuser);
int cartid = -1;
if (curcart == null)
{
Cart newcart = new Cart();
newcart.user = curuser;
_context.Add(newcart);
_context.SaveChanges();
cartid = newcart.cartId;
}
else
{
cartid = curcart.cartId;
_context.productInCarts.RemoveRange(_context.productInCarts.Where(p => p.cartId == curcart.cartId));
}
Dictionary <string, int> cartitem = new Dictionary <string, int>();
foreach (string id in cartitemlist)
{
if (!cartitem.ContainsKey(id))
{
cartitem.Add(id, 1);
}
else
{
cartitem[id] += 1;
}
}
foreach (KeyValuePair <string, int> entry in cartitem)
{
ProductInCart newitem = new ProductInCart();
newitem.productId = Convert.ToInt32(entry.Key);
newitem.cartId = cartid;
newitem.quantity = entry.Value;
newitem.created_At = DateTime.Now;
_context.productInCarts.Add(newitem);
}
_context.SaveChanges();
}
