public async Task <ActionResult> AddToCart(int id, int quantity)
{
var cart = new CartService(HttpContext);
cart.MakeProxyCreationFalse();
await cart.AddItemsInCart(id, quantity);
var items = await cart.GetCartItemsAsync();
var totalsum = CalculateCart(items);
var model = new CartItemsViewModel
{
Items = items,
Sum = totalsum
};
var result = JsonConvert.SerializeObject(model, Formatting.Indented,
new JsonSerializerSettings
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
});
return(Json(result, JsonRequestBehavior.AllowGet));
}
public ActionResult CartItems()
{
List <CartItemsViewModel> cdList = new List <CartItemsViewModel>();
if (Session["cart"] != null)
{
List <CartItems> cartIds = (List <CartItems>)Session["cart"];
using (RahmanDbEntities db = new RahmanDbEntities())
{
foreach (var item in cartIds)
{
CartItemsViewModel cd = db.tblProductDetails.Where(c => c.Id == item.ProductId).Select(c => new CartItemsViewModel
{
CompanyName = c.CompanyName,
ProdDescription = c.ProdDescription,
Id = c.Id,
Images = c.Images,
Price = c.Price,
ProductId = c.ProductId,
Quantity = item.Quantity
}).FirstOrDefault();
cdList.Add(cd);
}
}
}
return(View(cdList));
}
public async Task <IActionResult> AddToCart([FromForm] CartItemsViewModel vm,
[FromForm] decimal Price)
{
if (ModelState.IsValid)
{
await new CreateCartItem(_context).Do(vm);
await new UpdateShoppingCart(_context).UpdateTotal(vm.CartRefId, 1, Price);
return(Ok());
}
return(BadRequest());
}
public async Task <IActionResult> Items()
{
var shoppingCartId = this.HttpContext.Session.GetShoppingCartId();
var carItemsWithDetails = new CartItemsViewModel
{
ShoppingSongs = await this.GetSongCartItemsWithDetails(shoppingCartId),
ShoppingAlbums = await this.GetAlbumCartItemsWithDetails(shoppingCartId)
};
return(View(carItemsWithDetails));
}
public async Task <ActionResult> Index()
{
var cart = new CartService(HttpContext);
var items = await cart.GetCartItemsAsync();
var model = new CartItemsViewModel
{
Items = items,
Sum = CalculateCart(items)
};
return(View(model));
}
/// <summary>
/// displays cart
/// </summary>
/// <returns></returns>
public ActionResult ViewCart()
{
try
{
CartItemsDTO CartInfoDTO = CartBusinessContextObject.GetCart(new Guid(Session["UserID"].ToString()));
CartItemsViewModel cartItemsViewModel = new CartItemsViewModel();
cartItemsViewModel = CartInfoMapper.Map <CartItemsDTO, CartItemsViewModel>(CartInfoDTO);
return(View(cartItemsViewModel));
}
catch (Exception ex)
{
return(RedirectToAction("ExceptionCatch", "Static", new { exception = ex.Message }));
}
}
public async Task <IActionResult> Post([FromBody] CartItemsViewModel vm)
{
if (ModelState.IsValid)
{
var newCartItem = Mapper.Map <CartItems>(vm);
newCartItem.UserName = User.Identity.Name;
_repository.AddCartItem(newCartItem);
if (await _repository.SaveChangesAsync())
{
return(Created($"/api/cartitems/{vm.Name}",
Mapper.Map <CartItemsViewModel>(newCartItem)));
}
}
return(BadRequest("Failed to add item to cart"));
}
public async Task <IActionResult> Cart()
{
var user = await this.userManager.GetUserAsync(this.User);
var cartId = user.CartId;
var itemIds = this.cartItemsService.GetItemIds(cartId);
var viewModel = new CartItemsViewModel
{
Items = this.itemsService.GetAllCartItems <CartItemViewModel>(itemIds),
TotalCost = await this.cartsService.CalculateTotalCostAsync(cartId),
Discount = this.cartsService.CalculateDiscount(cartId),
};
foreach (var item in viewModel.Items)
{
item.Amount = this.cartItemsService.GetAmount(cartId, item.Id);
}
return(this.View(viewModel));
}
public ActionResult Index(int page = 1, bool isAjaxCall = false)
{
var cartItemsViewModel = new CartItemsViewModel();
CartItem cartItem = new CartItem(this.HttpContext);
var cartItems = _cartItemService.GetCartItems(cartItem.CartId, page, PageSize);
cartItemsViewModel.AddCartItems(cartItems);
if (isAjaxCall)
{
return(PartialView("_PagedCartItemResults", cartItemsViewModel));
}
if (cartItemsViewModel.CartTotal == 0)
{
return(RedirectToAction("Index", "Dashboard"));
}
return(View(cartItemsViewModel));
}
public List <CartItemsViewModel> SetCartSets(List <Cart> cartProducts)
{
List <CartItemsViewModel> carts = new List <CartItemsViewModel>();
foreach (var c in cartProducts)
{
CartItemsViewModel model = new CartItemsViewModel();
model.Id = c.Id;
model.ProductId = c.ProductId;
model.ProductName = c.ProductName;
model.Photo = c.Photo;
model.Color = c.Color;
model.Size = c.Size;
model.DiscountPrice = c.DiscountPrice;
model.ComboPrice = c.ComboPrice;
model.Quantity = c.Quantity;
model.MaxLimit = c.MaxLimit;
model.OriginalPrice = c.OriginalPrice;
if (c.Color != null)
{
model.Colours = _context.Colour.Where(p => p.ProductId == c.ProductId).ToList();
}
if (c.Size != null)
{
var productSizes = _context.ProductSize.Where(p => p.ProductId == c.ProductId).ToList();
model.ProductSize = new List <SelectListItem>();
foreach (var p in productSizes)
{
var selectListItem = new SelectListItem()
{
Text = p.ItemSize,
};
model.ProductSize.Add(selectListItem);
}
}
carts.Add(model);
}
return(carts);
}
public ActionResult Notification()
{
var cartId = Request.Cookies["ecmCart"]?.Value;
IEnumerable <CartItem> items;
using (ApplicationDbContext context = new ApplicationDbContext())
{
items = context.CartItems.Where(x => x.CartId == cartId)
.Include(x => x.Product)
.OrderByDescending(x => x.DateCreated)
.ToList();
}
var totalsum = items.Sum(x => x.Product.FinalPrice * x.Count);
var model = new CartItemsViewModel
{
Items = items,
Sum = totalsum
};
return(PartialView(model));
}
public async Task <ActionResult> RemoveFromCart(int productId)
{
var cart = new CartService(HttpContext);
await cart.RemoveAync(productId);
var items = await cart.GetCartItemsAsync();
var totalsum = CalculateCart(items);
var model = new CartItemsViewModel
{
Items = items,
Sum = totalsum
};
var result = JsonConvert.SerializeObject(model, Formatting.Indented,
new JsonSerializerSettings
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
});
return(Json(result, JsonRequestBehavior.AllowGet));
}
public void Post([FromBody] CartItemsViewModel item)
{
CartViewModel cart = HttpContext.Session.GetObjectFromJson <CartViewModel>("Cart");
if (cart == null)
{
cart = new CartViewModel();
}
//TbItem item = itemsServices.GetById(id);
CartItemsViewModel cartItemsViewModel = cart.ListItems.Where(a => a.ItemId == item.ItemId).FirstOrDefault();
if (cartItemsViewModel != null)
{
cartItemsViewModel.Qty++;
cartItemsViewModel.Total = cartItemsViewModel.Price * cartItemsViewModel.Qty;
}
else
{
cart.ListItems.Add(new CartItemsViewModel()
{
ItemId = item.ItemId,
ItemName = item.ItemName,
ImageName = item.ImageName,
Price = item.Price,
Qty = 1,
Total = item.Price
});
}
cart.Total = cart.ListItems.Sum(a => a.Total);
HttpContext.Session.SetObjectAsJson("Cart", cart);
//return Redirect("/Home/Index");
}
public ActionResult CartItems(string promoCode)
{
CartItemsViewModel model = new CartItemsViewModel();
var cartItemsCookie = Request.Cookies["cartItems"];
if (cartItemsCookie != null && !string.IsNullOrEmpty(cartItemsCookie.Value))
{
model.ProductIDs = cartItemsCookie.Value.Split('-').Select(x => int.Parse(x)).ToList();
if (model.ProductIDs.Count > 0)
{
model.Products = ProductsService.Instance.GetProductsByIDs(model.ProductIDs.Distinct().ToList());
}
if (!string.IsNullOrEmpty(promoCode))
{
model.PromoCode = promoCode;
model.Promo = PromosService.Instance.GetPromoByCode(promoCode);
}
}
return(PartialView("_CartItems", model));
}
public async Task <IActionResult> UpdateCartItem([FromForm] CartItemsViewModel vm,
[FromForm] decimal Price, [FromForm] int PrevQuantity)
{
if (ModelState.IsValid)
{
await new UpdateCartItem(_context).Do(new CartItemsViewModel
{
CartRefId = vm.CartRefId,
ProductRefId = vm.ProductRefId,
Quantity = vm.Quantity,
});
if (PrevQuantity > vm.Quantity)
{
await new UpdateShoppingCart(_context).UpdateTotal(vm.CartRefId, PrevQuantity - vm.Quantity, -Price);
}
else
{
await new UpdateShoppingCart(_context).UpdateTotal(vm.CartRefId, vm.Quantity - PrevQuantity, Price);
}
return(Ok());
}
return(BadRequest());
}
