public ActionResult AddToCart(int qty, int balloonID)
{
Dictionary <int, CartItemViewModel> shoppingCart = null;
if (Session["cart"] != null)
{
//session cart exsists - puts its items in the local version which is easier to work with
shoppingCart = (Dictionary <int, CartItemViewModel>)Session["cart"];
//when we unbox a session object to its smaller more specific type, we use explicit casting
}
else
{
//if the sessioncartvariable yet does not exsist, we need to instantize it
shoppingCart = new Dictionary <int, CartItemViewModel>();
} //after this if/else, we have a local cart we can add things to
//find the product by its id (bookID)
Balloon product = db.Balloons.Where(b => b.BalloonID == balloonID).FirstOrDefault();
if (product == null)
{
//if we recieveda bad ID, we need to send them back to some page to try again or we could throw an error message
return(RedirectToAction("Index"));
}
else
{
//if book is valid, then add the line item to the cart.
CartItemViewModel item = new CartItemViewModel(qty, product);
if (shoppingCart.ContainsKey(product.BalloonID))
{
//here the product was already in the cart, we just needed to increase the quantity
shoppingCart[product.BalloonID].Qty += qty;
}
else
{
//here the product is being added to the cart for the first time.
shoppingCart.Add(product.BalloonID, item);
}
//now we need to update the session version of the cart so we can maintain that info between request and response cycle
Session["cart"] = shoppingCart; //no explicit casting is needed because this is a smaller container going into a larger container
//confirmation message into a session variable so that it is available after the redirect
Session["confirm"] = $"'{product.BalloonTitle}' (Quantity: {qty}) added to cart";
}
return(RedirectToAction("Index", "ShoppingCart"));
}
//Add To Cart
public ActionResult AddToCart(int qty, int productID)
{
//create an empty shell for the local shopping cart variable.
Dictionary <int, CartItemViewModel> shoppingCart = null;
//Check if the session shopping cart exists. If so, use it to populate values into the local shoppingCart variable
if (Session["cart"] != null)
{
//If you get here, the session cart exists and we need to unbox it.
shoppingCart = (Dictionary <int, CartItemViewModel>)Session["cart"];
}
else
{
//if Session["cart"] doesn't exist, we will new up an empty dictionary (intialize the collection)
shoppingCart = new Dictionary <int, CartItemViewModel>();
}
//find the product that the user is adding to their cart
Product product = db.Products.Where(p => p.ProductID == productID).FirstOrDefault();
if (product == null)
{
//If we get here, we got a bad id and we need to kick them back to the index to try again.
return(RedirectToAction("Index"));
}
else
{
//If we get here, we were able to find a book with the ID passed to this method.
CartItemViewModel item = new CartItemViewModel(qty, product);
//put item in the local shopping cart variable BUT if we already have 1 of this product in the cart, we need to just update the quantity, not add a new listing
if (shoppingCart.ContainsKey(product.ProductID))
{
shoppingCart[product.ProductID].Qty += qty;
}
else
{
shoppingCart.Add(product.ProductID, item);
}
//now we need to update Session so that we can persist the info in the cart between request/response cycles (page loads)
Session["cart"] = shoppingCart; //implicit casting happens here. (Boxing up into the arraylist). the shoppingCart Dictionary object becomes a generic object
Session["confirm"] = $"\"{product.Name}\" (Quantity: {qty}) added to cart.";
}
//send the user to the index of the shopping cart controller
return(RedirectToAction("Index", "ShoppingCart"));
}//end AddToCart
public async Task <IActionResult> RemoveFromCart([FromBody] CartItemViewModel model)
{
try
{
#region Check user
var userID = HttpContext.User.Identity.Name;
if (userID == null)
{
return(StatusCode(StatusCodes.Status401Unauthorized));
}
ApplicationUser user = await _context.Set <ApplicationUser>().SingleOrDefaultAsync(item => item.UserName == userID);
Account account = _context.Set <Account>()
.Include(x => x.Cart)
.ThenInclude(x => x.CartItems)
.FirstOrDefault(x => x.ID == user.AccountID);
if (user == null || account == null)
{
return(null);
}
//if (!user.IsVerified) return StatusCode(StatusCodes.Status426UpgradeRequired);
#endregion
var cartItem = account.Cart?.CartItems.FirstOrDefault(x => x.ItemID == model.ItemID);
if (cartItem == null)
{
return(NoContent());
}
if (cartItem.OfferID != null)
{
var removeItem = _context.Set <CartItem>().Where(x => x.OfferID == cartItem.OfferID);
_context.Set <CartItem>().RemoveRange(removeItem);
}
_context.Set <CartItem>().Remove(cartItem);
await _context.SaveChangesAsync();
await account.Cart.FixMissingOfferItems(_context);
await account.Cart.UpdateCart(_context);
return(NoContent());
}
catch (Exception ex)
{
return(BadRequest());
}
}
public IActionResult Index(CartItemViewModel cart_list_update, string submitButton)
{
HttpClient httpclient = new HttpClient();
if (!string.IsNullOrEmpty(submitButton))
{
switch (submitButton)
{
case "Update":
for (var i = 0; i < cart_list_update.Carts.Count; i++)
{
var cartId = cart_list_update.Carts[i].Id;
var quantity = cart_list_update.Carts[i].Quantity;
var model = httpclient.PutAsJsonAsync(uri, new CartViewModel {
Id = cartId, Quantity = quantity
}).Result;
}
break;
case "Checkout":
return(RedirectToAction("Index", "Orders"));
default:
break;
}
//var temp = submitButton;
}
int?userIdTemp = HttpContext.Session.GetInt32("id");
if (userIdTemp == null)
{
return(RedirectToAction("Login", "UsersApp"));
}
var result = JsonConvert.DeserializeObject <List <CartViewModel> >(httpclient.GetStringAsync(uri + "GetCarts/" + userIdTemp).Result);
var number_of_items = 0;
for (var i = 0; i < result.Count; i++)
{
number_of_items += result[i].Quantity;
}
HttpContext.Session.SetInt32("number_of_items", number_of_items);
return(View(new CartItemViewModel()
{
Carts = result
}));
}
private async Task <CartItemViewModel> AddItem(int id, string languageId, int quan)
{
var product = await _productApiClient.GetById(id, languageId);
var cartItem = new CartItemViewModel
{
ProductId = product.Id,
Description = product.Description,
Name = product.Name,
Price = product.Price,
Quantity = quan,
Image = product.Image
};
return(cartItem);
}
public ActionResult AddToCart(int id)
{
MyCart cart = Session["cart"] as MyCart;
CartItemViewModel cartItem = new CartItemViewModel();
var eklenenAlbum = _albumService.Get(id);
cartItem.ID = eklenenAlbum.ID;
cartItem.Name = eklenenAlbum.Title;
cartItem.Price = eklenenAlbum.Discounted ? eklenenAlbum.Price * 0.9m : eklenenAlbum.Price;
cartItem.Amount = 1;
cart.AddCart(cartItem);
Session["cart"] = cart;
return(PartialView("_CartButton"));
}
private CartItemViewModel ConvertEntityToVM(CartItem item)
{
CartItemViewModel itemVM = new CartItemViewModel
{
BookId = item.BookId,
BookAuthor = item.Book.Author.Name,
BookCategory = item.Book.Category.Name,
BookTitle = item.Book.Title,
ImgUrl = item.Book.ImageUrl,
ItemPrice = item.Book.Price,
ItemsCount = item.Count,
TotalPrice = item.Count * item.Book.Price
};
return(itemVM);
}
public void AddItem(CartItemViewModel item)
{
CartItemViewModel unit = ItemsSet.FirstOrDefault(i => i.ProductID == item.ProductID);
if (unit == null)
{
ItemsSet.Add(item);
}
else
{
foreach (var element in ItemsSet.Where(i => i.ProductID == item.ProductID))
{
element.Quantity = item.Quantity;
}
}
}
public ActionResult AddToCart(int qty, int seedID)
{ //had to add reference
Dictionary <int, CartItemViewModel> shoppingCart = null;
//check cart in session (global)
//if the cart has seeds in it, then assign its value to the local dictionary
if (Session["cart"] != null)
{
shoppingCart = (Dictionary <int, CartItemViewModel>)Session["cart"];
}//end if
//if Global is empty
else
{
//create an empty instance of the Local dictionary
shoppingCart = new Dictionary <int, CartItemViewModel>();
}//end else
//here get the products object being added
Seed product = ctx.Seeds.Where(s => s.SeedID == seedID).FirstOrDefault();//which will allow a null value
//if productID (seedID) is null, return them to the seeds index
if (product == null)
{
return(RedirectToAction("Index"));
}//end if
//else the productID IS valid
else
{
//create the shopping cart view model object
CartItemViewModel item = new CartItemViewModel(qty, product);
//if the productID is represented in the shoppingcart, do an increase of quantity.. functionality
if (shoppingCart.ContainsKey(product.SeedID))
{
shoppingCart[product.SeedID].Qty += qty;
}//end iff
//else the product is NOT in the cart, add it there
else
{
shoppingCart.Add(product.SeedID, item);
}//end else
//have to update the Global (session) cart with the values from the local (dictionary)
Session["cart"] = shoppingCart;
}//end else
//if the product was added => redirect to the ShoppingCart Index
return(RedirectToAction("Index", "ShoppingCart"));
}//end ActionResult
//public void DeleteCartItem(CartItemViewModel cartItem)
//{
// _cartList.Remove(cartItem);
// CartListChanged(this, null);
// RaisePropertyChanged(() => CartList);
//}
public void AddProductToCartList(ProductViewModel product, int quantities)
{
CartItemViewModel cartItem = _cartList.FirstOrDefault(c => c.Product.Id == product.Id);
if (cartItem == null)
{
cartItem = new CartItemViewModel(product, quantities);
_cartList.Add(cartItem);
RaisePropertyChanged(() => CartList);
}
else
{
cartItem.AddQuantities(quantities);
}
product.DeductQuantities(quantities);
CartListChanged?.Invoke(this, null);
}
public async Task <IActionResult> DeleteFromCart([FromBody] CartItemViewModel cartItem)
{
if (!ModelState.IsValid)
{
return(BadRequest("Bad request 400"));
}
string cookie = "BeachTowelShop-Session";
if (!Request.Cookies.ContainsKey(cookie))
{
await Set("BeachTowelShop-Session", Guid.NewGuid().ToString(), 100).ConfigureAwait(false);
}
var userId = Request.Cookies[cookie];
var productId = cartItem.ProductId;
var cartItemDto = _mapper.Map <UserSessionCartDto>(cartItem);
cartItem.ImgName = await __orderService.GetItemFolderPath(productId).ConfigureAwait(false);
await __orderService.DeleteItemFromCart(userId, cartItemDto).ConfigureAwait(false);
var itemsInCache = _cache.Get($"CartViewModel{userId}") as List <CartViewModel>;
var item = itemsInCache.Where(a => a.ProductId == cartItemDto.ProductId && a.SessionId == userId && a.Size == cartItemDto.Size).FirstOrDefault();
itemsInCache.Remove(item);
if (itemsInCache.Count > 0)
{
_cache.Remove($"CartViewModel{userId}");
_cache.Set($"CartViewModel{userId}", itemsInCache);
}
else
{
_cache.Remove($"CartViewModel{userId}");
}
await DeleteFromServerAsync(productId, cartItem).ConfigureAwait(false);
//TODO:Make it async as it is irelevent for the user
return(Ok("Removed from Cart"));
}
public JsonResult addVariant(Guid Id, int num)
{
var viewModel = new CartListViewModel();
var list = GetShoppingCart();
//viewModel.Products = GetSopiingCart();
if (!list.ContainsKey(Id.ToString()))
{
var product = _productSevice.Get(Id);
if (product != null)
{
var a = new CartItemViewModel
{
name = product.Name,
Count = num,
Id = product.Id,
};
list.Add(a.Id.ToString(), a);
viewModel.Count = list.Count;
viewModel.State = 1;
}
else
{
viewModel.State = 0;
viewModel.Message = "Không tìm thấy sản phẩm!";
}
}
else
{
((CartItemViewModel)list[Id.ToString()]).Count = num;
viewModel.State = 1;
}
viewModel.Products = new List <CartItemViewModel>();
foreach (DictionaryEntry it in list)
{
viewModel.Products.Add((CartItemViewModel)it.Value);
}
return(Json(viewModel));
}
public ActionResult Commit()
{
var viewModel = new CartViewModel();
var list = GetShoppingCart();
//viewModel.Products = GetSopiingCart();
var pricmodel = _productSevice.GetAttribute("Price");
viewModel.Products = new List <CartItemViewModel>();
foreach (DictionaryEntry it in list)
{
CartItemViewModel item = (CartItemViewModel)it.Value;
var pr = _productSevice.Get(item.Id);
if (pr != null)
{
viewModel.Products.Add(item);
item.name = pr.Name;
item.Image = pr.Image;
item.link = AppHelpers.ProductUrls(pr.Category_Id, pr.Slug);
var price = _productSevice.GetAttributeValue(item.Id, pricmodel.Id);
if (price != null)
{
try
{
int p = int.Parse(price.Value);
item.Priceint = p;
item.Price = p.ToString("N0").Replace(",", ".") + "đ";
viewModel.TotalMoney += p * item.Count;
}
catch
{
item.Price = "Liên hệ";
}
}
else
{
item.Price = "Liên hệ";
}
}
}
return(View(viewModel));
}
public async Task AddItemToCart(Buyer buyer, CartItemViewModel cartItem)
{
var cart = await GetCart(buyer);
var itemFound = cart.Items.Find(x => x.Prod_ID == cartItem.Prod_ID);
if (itemFound == null)
{
cart.Items.Add(cartItem);
}
else
{
itemFound.Quantity++;
}
await Updatecart(cart);
}
public ActionResult AddToCart(int id)
{
//MyCartı session içindeki karta eşitliyoruz.
MyCart cart = Session["cart"] as MyCart;
CartItemViewModel cartItem = new CartItemViewModel();
var eklenenUrun = _productService.Get(id); //Eklenen albümü bul. Sepete ekleye basınca o ID ye ait ürünü bulması için
//CartItem ın özelliklerine eşitle
cartItem.ID = eklenenUrun.ID;
cartItem.Name = eklenenUrun.Title;
cartItem.Price = eklenenUrun.Price;
cartItem.Amount = 1;
//Session dan oluşturduğum carta ekliyorum
cart.AddCart(cartItem);
Session["cart"] = cart;
return(PartialView("_CartButton")); //Sepet içindeki ürün sayısını dönmesi için
}
public IActionResult Index()
{
CheckoutViewModel cvm = new CheckoutViewModel();
List <CartItem> cart = new List <CartItem>();
string cartString = HttpContext.Session.GetString("cart");
if (cartString != null)
{
cart = JsonConvert.DeserializeObject <List <CartItem> >(cartString);
}
List <CartItemViewModel> cartvm = new List <CartItemViewModel>();
double totalPrice = 0;
ViewBag.totalAmount = 0;
foreach (CartItem ci in cart)
{
CartItemViewModel civm = new CartItemViewModel();
civm.ProductId = ci.ProductId;
civm.Amount = ci.Amount;
Product p = _context.Product.Find(ci.ProductId);
civm.Name = p.Title;
civm.Price = p.Price;
civm.ImageUrl = p.Image;
ViewBag.totalAmount += civm.Amount;
totalPrice += ci.Amount * p.Price;
cartvm.Add(civm);
}
cvm.CartItems = cartvm;
cvm.TotalPrice = totalPrice;
return(View(cvm));
}
public virtual CartItemViewModel CreateCartItemViewModel(ICart cart, ILineItem lineItem, EntryContentBase entry)
{
var basePrice = lineItem.Properties["BasePrice"] != null?decimal.Parse(lineItem.Properties["BasePrice"].ToString()) : 0;
var optionPrice = lineItem.Properties["OptionPrice"] != null?decimal.Parse(lineItem.Properties["OptionPrice"].ToString()) : 0;
var viewModel = new CartItemViewModel
{
Code = lineItem.Code,
DisplayName = lineItem.DisplayName,
ImageUrl = entry.GetAssets <IContentImage>(_contentLoader, _urlResolver).FirstOrDefault() ?? "",
DiscountedPrice = GetDiscountedPrice(cart, lineItem),
BasePrice = new Money(basePrice, _currencyService.GetCurrentCurrency()),
OptionPrice = new Money(optionPrice, _currencyService.GetCurrentCurrency()),
PlacedPrice = new Money(lineItem.PlacedPrice, _currencyService.GetCurrentCurrency()),
Quantity = lineItem.Quantity,
Url = entry.GetUrl(_relationRepository, _urlResolver),
Entry = entry,
IsAvailable = _pricingService.GetCurrentPrice(entry.Code).HasValue,
DiscountedUnitPrice = GetDiscountedUnitPrice(cart, lineItem),
IsGift = lineItem.IsGift,
Description = entry["Description"] != null ? entry["Description"].ToString() : "",
IsDynamicProduct = lineItem.Properties["VariantOptionCodes"] != null
};
var productLink = entry is VariationContent?
entry.GetParentProducts(_relationRepository).FirstOrDefault() :
entry.ContentLink;
if (_contentLoader.TryGet(productLink, out EntryContentBase catalogContent))
{
var product = catalogContent as GenericProduct;
if (product != null)
{
viewModel.Brand = GetBrand(product);
var variant = entry as GenericVariant;
if (variant != null)
{
viewModel.AvailableSizes = GetAvailableSizes(product, variant);
}
}
}
return(viewModel);
}
public void AddItem(BookViewModel book, int quantity)
{
//check if list item already contains book
CartItemViewModel item = CartItems.Where(i => i.BookItem.Id == book.Id).FirstOrDefault();
if (item != null)
{
//update quantity
item.Quantity += quantity;
}
else
{
//add new item
CartItems.Add(new CartItemViewModel {
BookItem = book, Quantity = quantity
});
}
}
// GET: Cart/ShowCart
public ActionResult ShowCart()
{
string userId = User.Identity.GetUserId();
Cart cart = db.Carts.FirstOrDefault(c => c.CartId == userId);
if (cart == null)
{
return(HttpNotFound(ErrorMessage.CartDoesNotExist));
}
List <CartItemViewModel> cartItemsViewModel = new List <CartItemViewModel>();
foreach (CartItem cartItem in cart.Items)
{
CartItemViewModel cartItemViewModel = new CartItemViewModel(cartItem);
cartItemsViewModel.Add(cartItemViewModel);
}
return(View(cartItemsViewModel));
}
public async Task <IActionResult> AddToCart(ProductViewModel product)
{
var cartItem = new CartItemViewModel
{
Id = Guid.NewGuid().ToString(),
Prod_ID = product.Prod_ID,
Prod_Name = product.Prod_Name,
Price = product.Price,
Quantity = 1,
//PictureUri = movie.PictureUri
};
var buyer = _buyerService.Get(User);
await _cartApiClient.AddItemToCart(buyer, cartItem);
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> ChangeInCart([FromBody] CartItemViewModel cartItem)
{
if (!ModelState.IsValid)
{
return(BadRequest("Bad request 400"));
}
string cookie = "BeachTowelShop-Session";
if (!Request.Cookies.ContainsKey(cookie))
{
await Set("BeachTowelShop-Session", Guid.NewGuid().ToString(), 100).ConfigureAwait(false);
}
//double price = __productService.GetPriceForSizeGeneric(cartItem.Size);
// cartItem.Sum = int.Parse(cartItem.Count) * price;
var userId = Request.Cookies[cookie];
//TODO pass sum
double count = 0;
var canConvert = double.TryParse(cartItem.Count, out count);
if (!canConvert || double.Parse(cartItem.Count) <= 0)
{
cartItem.Count = "1";
}
var userCartDto = _mapper.Map <UserSessionCartDto>(cartItem);
var updatedItemDto = await __orderService.UpdateCart(userId, userCartDto).ConfigureAwait(false);
var itemsInCache = _cache.Get($"CartViewModel{userId}") as List <CartViewModel>;
var item = itemsInCache.Where(a => a.ProductId == userCartDto.ProductId && a.SessionId == userId && a.Size == updatedItemDto.Size).FirstOrDefault();
var updatedItem = _mapper.Map <CartViewModel>(updatedItemDto);
updatedItem.SessionId = userId;
updatedItem.DesignFolderPath = item.DesignFolderPath;
updatedItem.DesignName = item.DesignName;
itemsInCache.Remove(item);
itemsInCache.Add(updatedItem);
// _cache.Remove($"CartViewModel{userId}");
_cache.Set($"CartViewModel{userId}", itemsInCache);
return(Ok("Ok"));
}
public ActionResult AddToCart(int qty, int tentID)
{
Dictionary <int, CartItemViewModel> shoppingCart = null;
if (Session["cart"] != null)
{
shoppingCart = (Dictionary <int, CartItemViewModel>)Session["cart"];
}
else
{
shoppingCart = new Dictionary <int, CartItemViewModel>();
}
Tent product = db.Tents.Where(b => b.TentID == tentID).FirstOrDefault();
if (product == null)
{
return(RedirectToAction("Index"));
}
else
{
CartItemViewModel item = new CartItemViewModel(qty, product);
if (shoppingCart.ContainsKey(product.TentID))
{
shoppingCart[product.TentID].Qty += qty;
}
else
{
shoppingCart.Add(product.TentID, item);
}
Session["cart"] = shoppingCart;
}
return(RedirectToAction("Index", "ShoppingCart"));
}
//Action thêm sản phẩm và số lượng vào Session[CartSession]
public ActionResult AddItem(int productId, int quantity)
{
cartService = new CartImplement();
var product = cartService.GetProductByID(productId);
var cart = Session[CartSession];
if (cart != null)
{
var list = (List <CartItemViewModel>)cart;
if (list.Exists(x => x.product.MASP == productId))
{
foreach (var item in list)
{
if (item.product.MASP == productId)
{
item.Quantity += quantity;
}
}
}
else
{
//tạo mới đối tượng cart item
var item = new CartItemViewModel();
item.product = product;
item.Quantity = quantity;
list.Add(item);
}
//Gán vào session
Session[CartSession] = list;
}
else
{
//tạo mới đối tượng cart item
var item = new CartItemViewModel();
item.product = product;
item.Quantity = quantity;
var list = new List <CartItemViewModel>();
list.Add(item);
//Gán vào session
Session[CartSession] = list;
}
return(RedirectToAction("Index"));
}
public IActionResult AddToCart([FromBody] CartItemViewModel model)
{
Product ProductToAdd = _context.product.Where(p => p.ProductId == model.ProductId).SingleOrDefault();
Cart ActiveCart;
Cart ExistingCart = _context.cart.Include(c => c.CartItems).Where(c => c.UserId == model.UserId && c.Status == "active").SingleOrDefault();
if (ExistingCart == null)
{
Cart NewCart = new Cart {
UserId = model.UserId, Status = "active"
};
_context.Add(NewCart);
_context.SaveChanges();
ActiveCart = NewCart;
}
else
{
ActiveCart = ExistingCart;
}
if (ActiveCart.ContainsCartItem(ProductToAdd) == false)
{
if (model.Quantity <= ProductToAdd.Quantity)
{
CartItem NewCartItem = new CartItem {
Quantity = model.Quantity, Cart = ActiveCart, Product = ProductToAdd
};
_context.Add(NewCartItem);
_context.SaveChanges();
return(StatusCode(201));
}
else
{
string response = "This quantity is not available";
return(Json(response));
}
}
else
{
string response = "This product is already in your cart. Please update quantity in cart.";
return(Json(response));
}
}
public async Task <IActionResult> AddOrderRequest(CartItemViewModel viewModel)
{
// if (ModelState.IsValid)
// {
var user = await _userManager.GetUserAsync(HttpContext.User);
var userId = user.Id;
var cartItem = await _context.CartItems.FirstOrDefaultAsync(c => c.CartItemID == viewModel.CartItemID);
if (cartItem != null)
{
var product = await _context.Products.FirstOrDefaultAsync(p => p.ProductID == cartItem.ProductID);
var request = await _context.Requests.FirstOrDefaultAsync(r => r.CartItemID == cartItem.CartItemID);
var order = new Order
{
Amount = product.Price * cartItem.Quantity,
Quantity = cartItem.Quantity,
Status = Status.PENDING,
DateOrdered = DateTime.Now,
IsRequested = true,
PaymentMethod = viewModel.PaymentMethod,
ProductID = product.ProductID,
UserID = userId
};
_context.Orders.Add(order);
_context.CartItems.Remove(cartItem);
_context.Requests.Remove(request);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(MyOrders)));
}
return(View("CheckoutRequestedProduct", viewModel));
// }
// return View("Checkout");
}
public IActionResult UpdateCartItem([FromBody] CartItemViewModel model)
{
CartItem ItemToUpdate = _context.cartItem.Include(i => i.Product).Where(i => i.Id == model.CartItemId).SingleOrDefault();
if (ItemToUpdate != null)
{
if (model.Quantity <= ItemToUpdate.Product.Quantity)
{
ItemToUpdate.Quantity = model.Quantity;
_context.SaveChanges();
return(StatusCode(201));
}
else
{
string response = "This quantity is not available";
return(Json(response));
}
}
return(StatusCode(400));
}
public async Task <IActionResult> Post([FromBody] CartItemViewModel cartItem)
{
try
{
var newCartItem = Mapper.Map <CartItem>(cartItem);
_repository.AddCartItem(newCartItem);
if (await _repository.SaveChangesAsync())
{
return(Created($"api/cart/{cartItem.CartItemId}", Mapper.Map <CartItemViewModel>(newCartItem)));
}
}
catch (Exception ex)
{
_logger.LogError("Failed to save cart item {0}", ex);
}
return(BadRequest("Failed to save cart item"));
}
public ActionResult UpdateCartItem(CartItemViewModel cartItemViewModel)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Index"));
}
var currentCart = _cartOperations.GetAllCart();
var cartItem = currentCart.FirstOrDefault(x => x.ProductId == cartItemViewModel.ProductId);
if (cartItem != null)
{
cartItem.Quantity = cartItemViewModel.Quantity;
_cartOperations.UpdateItemQuantityInCart(cartItem);
}
return(RedirectToAction("Index"));
}
public ActionResult AddToCart(int quantity, int productID)
{
Dictionary <int, CartItemViewModel> shoppingCart = null;
if (Session["cart"] != null)
{
shoppingCart = (Dictionary <int, CartItemViewModel>)Session["cart"];
}
else
{
shoppingCart = new Dictionary <int, CartItemViewModel>();
}
Product product = db.Products.Where(p => p.ProductID == productID).FirstOrDefault();
if (product == null)
{
RedirectToAction("Index");
}
else
{
if (!User.Identity.IsAuthenticated)
{
return(RedirectToAction("Register", "Account"));
}
CartItemViewModel item = new CartItemViewModel(quantity, product);
if (shoppingCart.ContainsKey(product.ProductID))
{
shoppingCart[product.ProductID].Quantity += quantity;
}
else
{
shoppingCart.Add(product.ProductID, item);
}
Session["cart"] = shoppingCart;
}
return(RedirectToAction("Index", "ShoppingCart"));
}
public static void AddNewStoreOrder(this Order order, CartItemViewModel model, DunkeyContext ctx)
{
try
{
StoreOrder storeOrder = new StoreOrder();
storeOrder.Store_Id = model.StoreId;
storeOrder.OrderNo = Guid.NewGuid().ToString("N").ToUpper();
storeOrder.AddNewOrderItem(model, ctx);
var businessTypeTax = ctx.BusinessTypeTax.FirstOrDefault(x => x.BusinessType == ctx.Stores.FirstOrDefault(x1 => x1.Id == model.StoreId).BusinessType);
if (businessTypeTax != null)
{
storeOrder.BusinessTypeTax = businessTypeTax.Tax;
storeOrder.BusinessType = businessTypeTax.BusinessType;
}
order.StoreOrders.Add(storeOrder);
}
catch (Exception ex)
{
DunkeyDelivery.Utility.LogError(ex);
}
}
