async void DecreaseAmount(CartItemModel obj)
{
if (obj.Amount > 1)
{
obj.Amount--;
await App.DB.UpdateItemAsync(obj);
GetItems();
}
}
public CartItems ParseCartItem(CartItemModel cartItems)
{
return(new CartItems()
{
Cart = cartItems.CartID,
Product = cartItems.productID,
Quantity = cartItems.quantity,
Id = cartItems.id
});
}
public IHttpActionResult AddItem(Guid userId, CartItemModel cartItem)
{
CartItem result = Manager.AddItemToUserCart(userId, cartItem.CartId, cartItem.ItemId, cartItem.Quantity);
if (result == null)
{
return(NotFound());
}
return(Ok("Added " + result.Quantity));
}
public static ShoppingBasketItem MapFrom(CartItemModel cartItem)
{
return(new ShoppingBasketItem()
{
ProductID = cartItem.Product.Id,
ProductName = cartItem.Product.Name,
TotalPrice = cartItem.TotalPrice,
Quantity = cartItem.Quantity
});
}
public JsonResult AddItem(int productCode, int Amount)
{
if (Session[CommonConstants.USER_SESSION] != null)
{
var product = new ProductDao().GetByProductCode(productCode);
var cartItem = new CartItemModel();
cartItem.ProductCode = productCode;
cartItem.Image = product.ImageFirst;
cartItem.MetaTitle = product.MetaTitle;
cartItem.Name = product.Name;
if (product.Promotion.Value)
{
cartItem.Price = product.Price - (product.Price * (decimal)product.PercentSale.Value / 100);
}
else
{
cartItem.Price = product.Price;
}
cartItem.Amount = Amount;
if (Session[CommonConstants.CartSession] != null)
{
var listItem = (List <CartItemModel>)Session[CommonConstants.CartSession];
bool exist = false;
foreach (var item in listItem)
{
if (item.ProductCode == cartItem.ProductCode)
{
item.Amount += cartItem.Amount;
exist = true;
break;
}
}
if (!exist)
{
listItem.Add(cartItem);
}
Session[CommonConstants.CartSession] = listItem;
}
else
{
var listItem = new List <CartItemModel>();
listItem.Add(cartItem);
Session[CommonConstants.CartSession] = listItem;
}
Session[CommonConstants.ADD_ITEM] = cartItem.Name;
return(Json(new
{
status = true
}));
}
return(Json(new
{
status = false
}));
}
public ActionResult AddToCart(CartItemModel model)
{
List <CartItem> list = null;
list = (List <CartItem>)Session["list"];
if (list == null)
{
list = new List <CartItem>();
}
double total = Convert.ToInt32(Session["total"].ToString());
int index = -1;
for (int i = 0; i < list.Count; i++)
{
if (list[i].p_id == model.p_id)
{
index = i;
}
}
if (index != -1)
{
list[index].quantity = list[index].quantity + model.quantity;
list[index].total_cost = list[index].total_cost + list[index].Product.p_price * model.quantity;
total = total + list[index].Product.p_price * model.quantity;
}
else
{
var p = db.Products.Find(model.p_id);
CartItem item = new CartItem();
item.p_id = model.p_id;
item.quantity = model.quantity;
item.Product = p;
item.total_cost = p.p_price * item.quantity;
list.Add(item);
Session["list"] = list;
total += item.total_cost;
}
Session["total"] = total;
int cat = Convert.ToInt32(Session["cat"].ToString());
return(RedirectToAction("products/" + cat));
}
public async Task <IActionResult> Create([Bind("CartId,PricePuppyID,PricePuppyDesc,PricePuppy,TrainingServicesPriceID,TrainingName,PriceTraining,CartQty,Email")] CartItemModel cartItemModel)
{
if (ModelState.IsValid)
{
_context.Add(cartItemModel);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(cartItemModel));
}
public void Create(CartItemModel cartItemModel, string ID)
{
var _dto = new DTOOrder()
{
CartID = ID,
DrinkID = cartItemModel.DrinkID,
Quantity = cartItemModel.Quantity
};
CartItemFactory.orderConnectionHandler.CreateOrder(_dto);
}
/// <summary>
/// Add item to cart
/// </summary>
/// <param name="cartItem">item to be added in cart</param>
/// <returns>whether the task was succesful or not</returns>
public bool AddCartItem(CartItemModel cartItem, out HttpStatusCode status)
{
bool success = false;
status = HttpStatusCode.OK;
try
{
CartItem newCartItem = new CartItem();
newCartItem.CartId = cartItem.CartId;
newCartItem.ItemId = cartItem.ItemId;
newCartItem.Quantity = cartItem.Quantity;
using (ShoppingCartEntities context = new ShoppingCartEntities())
{
//check if item already exists in cart
CartItem cartExists = context.CartItems
.Include("Item")
.Where(c => c.ItemId == newCartItem.ItemId && c.CartId == newCartItem.CartId)
.FirstOrDefault();
if (cartExists == null)
{
//Add new item to car
context.CartItems.Add(newCartItem);
context.SaveChanges();
success = true;
}
else
{
if (cartExists.Quantity + newCartItem.Quantity > cartExists.Item.Quantity)
{
//HTTP 410 - Not enough quantity in stock
status = HttpStatusCode.Gone;
}
else
{
//Update quantity of item in cart
cartExists.Quantity += newCartItem.Quantity;
context.CartItems.Attach(cartExists);
context.Entry(cartExists).State = EntityState.Modified;
context.SaveChanges();
success = true;
}
}
}
}
catch (Exception ex)
{
new Logging().LogProgress(token, Common.CallerIP, ex);
}
return(success);
}
public ActionResult RemoveItem(int id)
{
List <CartItemModel> cartItems = db.CartItems.ToList();
CartItemModel cartItem = cartItems.Find(p => p.Id == id);
db.Entry(cartItem).State = EntityState.Deleted;
db.SaveChanges();
return(RedirectToAction("Index", "Cart"));
}
public static ShoppingCartItem FromCartItemModel(CartItemModel cartItemModel)
{
var cartItemDbModel = new ShoppingCartItem {
Id = cartItemModel.Id,
Amount = cartItemModel.Amount,
Item = ToItemDbModel(cartItemModel.Item),
User = cartItemModel.User
};
return(cartItemDbModel);
}
public async Task <IActionResult> AddToBasket(CartItemModel productDetails)
{
if (productDetails?.Id == null)
{
return(RedirectToAction("Index", "Catalog"));
}
var basketViewModel = await GetBasketViewModelAsync();
await _basketService.AddItemToBasket(basketViewModel.Id, productDetails.Id, productDetails.Price, 1);
return(RedirectToAction("Index"));
}
public IActionResult AddToCart(CartItemModel cartItem)
{
try
{
cartItemService.AddProductToCart(cartItem);
return(CreatedAtAction("AddToCart", cartItem));
}
catch (Exception)
{
return(BadRequest());
}
}
public CartItemModel AddProductToCart(CartItemModel cartItem)
{
CartItemModel cartItems = new CartItemModel()
{
CartID = cartItem.CartID,
productID = cartItem.productID,
quantity = cartItem.quantity
};
dBRepo.AddProductToCart(cartItem);
return(cartItem);
}
public CartItemModel GetCartItem(int id, int qty = CartRules.DEFAULT_QTY)
{
Product prod = prodRepo.GetProduct(id);
CartItemModel item = new CartItemModel();
item.ProductID = prod.productID;
item.ProductName = prod.productName;
item.Price = (decimal)prod.price;
item.Quantity = qty;
return item;
}
public ActionResult AddItem(int product_ID, int qty)
{
var session = (UserLogin)Session[CommonConstants.USER_SESSION];
if (session == null)
{
ViewBag.Login = "******";
return(RedirectToAction("Index", "LoginClient"));
}
else
{
var product = new ProductDAO().ViewDetail(product_ID);
var cart = Session[CartSession];
if (cart != null)
{
var list = (List <CartItemModel>)cart;
if (list.Exists(x => x.Product.id == product_ID))
{
foreach (var item in list)
{
if (item.Product.id == product_ID)
{
item.Qty += qty;
}
}
}
else
{
//create a new cart item
var item = new CartItemModel();
item.Product = product;
item.Qty = qty;
list.Add(item);
}
//assigned to the session
Session[CartSession] = list;
}
else
{
//create a new cart item
var item = new CartItemModel();
item.Product = product;
item.Qty = qty;
var list = new List <CartItemModel>();
list.Add(item);
//assigned to the session
Session[CartSession] = list;
}
return(RedirectToAction("Index"));
}
}
public void Initialize(CartItemModel itemInformation)
{
_itemInformation = itemInformation;
itemPrice.text = FormatPriceText(_itemInformation.Currency, _itemInformation.Price);
itemName.text = _itemInformation.Name;
itemQuantity.text = _itemInformation.Quantity.ToString();
if (_loadingRoutine == null && itemImage.sprite == null && _itemInformation.ImgUrl != "")
{
storeController.GetImageAsync(_itemInformation.ImgUrl, LoadImageCallback);
}
}
public IActionResult DeleteCartItem(CartItemModel cartItem)
{
try
{
cartItemService.DeleteProductInCart(cartItem);
int id = cartItem.id;
return(Ok());
}
catch (Exception)
{
return(BadRequest());
}
}
private async Task OnUpdateCartItemCompleted(CartItemModel cartItem)
{
if (cartItem.Quantity == 0)
{
Carts.Remove(cartItem);
}
else
{
var cart = Carts.FirstOrDefault(x => x.ProductId == cartItem.ProductId);
cart.Quantity = cartItem.Quantity;
}
UpdateOrderSummaryUI();
}
public async Task <IActionResult> Add(int id)
{
if (id == null)
{
return(RedirectToAction("Index"));
}
// check if product exist
var productServiceClient = new ProductServiceClient();
var selectedItem = await productServiceClient.GetProductById(id);
if (selectedItem == null)
{
return(RedirectToAction("Index"));
}
// check if there are already cart instance
var cartItems = new List <CartItemModel>();
if (HttpContext.Session.GetString(_cartItesmSessionKey) != null)
{
cartItems = JsonConvert.DeserializeObject <List <CartItemModel> >(HttpContext.Session.GetString(_cartItesmSessionKey));
}
// check if the item are already in the cart
// if the item is already in the cart,
// increase the quantity by 1
if (cartItems.Exists(x => x.Id == selectedItem.Id))
{
cartItems.Find(x => x.Id == selectedItem.Id).Quantity++;
}
else
{
var item = new CartItemModel
{
Id = selectedItem.Id,
Name = selectedItem.Name,
Price = selectedItem.Price,
ProductImage = selectedItem.ProductImage,
Quantity = 1
};
cartItems.Add(item);
}
// add to session
HttpContext.Session.SetString(_cartItesmSessionKey, JsonConvert.SerializeObject(cartItems));
HttpContext.Session.SetInt32(_cartItemsCountSessionKey, cartItems.Count());
return(RedirectToAction("Index"));
}
protected void Button_Addtocart_Click1(object sender, EventArgs e)
{
if (Session[Constants.USER_ID] is null)
{
Session[Constants.REDIRECT_BOOK] = Label_ISBN.Text;
Response.Redirect("~/Login.aspx");
}
else
{
CartItemModel.AddToCart(Label_ISBN.Text, Session[Constants.USER_ID].ToString(), Convert.ToInt32(TextBox_Quantity.Text));
Response.Write("<script LANGUAGE='JavaScript' >alert('Book added successful')</script>");
TextBox_Quantity.Text = "";
}
}
public JsonResult RemoveFromCart(Guid id)
{
var c = cartService.GetCart(HttpContext.Session);
CartItemModel item = c.LineList.FirstOrDefault(x => x.Item.ID == id);
if (item != null)
{
c.RemoveLine(item);
}
cartService.SetCart(c, HttpContext.Session);
return(Json(Url.Action("Display", "Cart")));
}
public async Task <CartItemModel> UpdateAsync(CartItemModel cartModel)
{
var cart = await _context.Cart.FirstOrDefaultAsync(s => s.Id == cartModel.Id);
if (cart == null)
{
throw new ArgumentException();
}
cart.Count = cartModel.Count;
await _context.SaveChangesAsync();
return(cartModel);
}
protected void Page_Load(object sender, EventArgs e)
{
Label2.Text = DateTime.Now.ToString();
if (!IsPostBack)
{
string username = Session[Constants.USER_ID].ToString();
GridView1.DataSource = CartItemModel.GetCartItems(username);
GridView1.DataBind();
List <UserDetail> user = new List <UserDetail>();
user.Add(UserDetailModel.GetUserByUserName(username));
DetailsView1.DataSource = user;
DetailsView1.DataBind();
}
}
private async Task OnAddProductToCartCompleted(CartItemModel cartItem)
{
var cart = Carts.FirstOrDefault(x => x.ProductId == cartItem.ProductId);
if (cart == null)
{
Carts.Add(cartItem);
}
else
{
cart.Quantity = cartItem.Quantity;
}
UpdateCart();
}
protected void RefreshButton_Click(object sender, EventArgs e)
{
foreach (GridViewRow row in GridView1.Rows)
{
if (row.RowType == DataControlRowType.DataRow)
{
TextBox textBox = row.FindControl("TextBox1") as TextBox;
int newQuantity = Convert.ToInt32(textBox.Text);
int cartItemId = Convert.ToInt32(GridView1.DataKeys[row.RowIndex].Values[0]);
CartItemModel.UpdateCartItemQuantity(cartItemId, newQuantity);
}
}
BindGrid();
TotalAmountLabel.Text = string.Format("{0:C}", TotalPrice(CartItemModel.GetCartItems(username)));
}
public static CartItemModel ToCartItemModel(ShoppingCartItem shoppingCartItem)
{
var cartItem = new CartItemModel {
Id = shoppingCartItem.Id,
Amount = shoppingCartItem.Amount,
Item = ToItemCartModel(shoppingCartItem.Item),
User = shoppingCartItem.User
};
//Be aware of object items cycle
//We already specify the cart items. No need to specify them to user too
cartItem.User.ShoppingCartItems = null;
return(cartItem);
}
private void Remove(CartItemModel model)
{
_cartService.RemoveFromCart(UserId, model.Product.Id);
Items.Remove(model);
CheckCartIsEmpty();
var eventPayload = new CartItemEventModel
{
Product = model.Product,
Quantity = model.Quantity,
Action = CartAction.Remove
};
_eventAggregator.GetEvent <UpdateUserCartEvent>().Publish(eventPayload);
}
public void AddToCart()
{
var item = new CartItemModel
{
Product = SelectedProduct,
QuantityInCart = ItemQuantity
};
CartModelDto.AddProduct(item);
NotifyOfPropertyChange(() => Cart);
NotifyOfPropertyChange(() => Subtotal);
NotifyOfPropertyChange(() => Tax);
NotifyOfPropertyChange(() => Total);
}
public async Task <IActionResult> Edit(CartItemModel cartItemModel)
{
if (cartItemModel.Id <= 0)
{
return(NotFound());
}
if (ModelState.IsValid)
{
await _cartRepository.UpdateAsync(cartItemModel);
return(RedirectToAction(nameof(Index)));
}
return(View(cartItemModel));
}
public async Task VerifyRemoveItemGetsCalledOnServiceWhenRemovingItem()
{
var shoppingCartService = new Mock <IShoppingCartService>();
var viewModel = new ShoppingCartViewModel(shoppingCartService.Object);
var book = new BookDto {
Id = 5, Title = "Some book"
};
var cartItem = new CartItemModel
{
Book = book
};
await viewModel.RemoveOne(cartItem);
shoppingCartService.Verify(s => s.RemoveFromCart(book), Times.Once);
}
//
// GET: /Cart/
public ActionResult Index()
{
decimal total = 0;
using (QLBHEntities ctx = new QLBHEntities())
{
List<CartItemModel> list = new List<CartItemModel>();
Cart cart = CurrentContext.GetCart();
foreach (var item in cart.Items)
{
Product pro = ctx.Products.Where(p => p.ProID == item.ProID).First();
CartItemModel cim = new CartItemModel
{
Item = item,
Product = pro
};
total += pro.Price * item.Quantity;
list.Add(cim);
}
ViewBag.Total = total;
return View(list);
}
}
