private async void SeedShoppingCart()
{
var user = await _userManager.FindByNameAsync("*****@*****.**");
var product1 = _context.Products.First();
var product2 = _context.Products.Last();
await _shoppingCartService.AddToCart(product1.ProductID, user.UserName, 1);
await _shoppingCartService.AddToCart(product2.ProductID, user.UserName, 1);
}
public async void DeleteFromCartWorks()
{
var product = await _productService.GetProduct(1);
var user = await _userManager.FindByNameAsync("*****@*****.**");
var cartItem = await _shoppingCartService.AddToCart(product.ProductID, user.UserName, 1);
await _shoppingCartService.DeleteFromCart(cartItem.ShoppingCartID);
await Assert.ThrowsAsync <Exception>(() => _shoppingCartService.DeleteFromCart(cartItem.ShoppingCartID));
}
public ActionResult ChangeItem(int ID, decimal?Quantity, decimal?QuantityBit, bool?Delete, int?Attribute, int?qtype)
{
if (!LS.isHaveID())
{
return(Json(new { result = "error", action = "login", message = "You must login first", data = ID }));
}
var item = new ShoppingCartItem()
{
ID = ID
};
var addmodel = ShoppingCartService.AddToCart(LS.CurrentUser.ID, item, Quantity, QuantityBit, Delete, Attribute, qtype);
if (addmodel.errors.Count > 0)
{
return(Json(new { result = "error", message = addmodel.errors.FirstOrDefault(), data = addmodel.item }));
}
bool withship = true;
if (Request.UrlReferrer != null && Request.UrlReferrer.PathAndQuery.ToLower().Contains("shoppingcart"))
{
withship = true;
}
var model = _shoppingCartService.GetShoppingCartModel(addmodel.item.ShopID, loadattributes: false, withship: withship);
var curCartItem = model.Items.FirstOrDefault(x => x.ID == ID); //GetShoppingCartItemByID(ID);
if (curCartItem != null)
{
return(Json(new { result = "ok", data = curCartItem, cart = model }));
}
return(Json(new { result = "ok", data = addmodel.item, cart = model }));
}
public ActionResult ReOrder(int ID)
{
if (!LS.isHaveID())
{
return(Json(new
{
result = "error",
message = new Dictionary <string, Dictionary <string, List <string> > >()
{
{ "general", new Dictionary <string, List <string> >()
{
{ "errors", new List <string>()
{
"Please log in"
} }
} }
}
}));
}
var order = _db.Orders.FirstOrDefault(x => x.ID == ID && x.UserID == LS.CurrentUser.ID);
if (order != null)
{
// add to cart
var items = _db.OrderItems.Where(x => x.OrderID == order.ID).ToList();
foreach (var oi in items)
{
if (oi.Quantity > 0)
{
ShoppingCartService.AddToCart(order.UserID, new ShoppingCartItem()
{
ProductAttributeOptionID = oi.ProductAttributeOptionID,
ProductShopID = oi.ProductShopID,
Quantity = oi.Quantity,
ShopID = order.ShopID,
});
}
}
return(Json(new
{
result = "ok",
url = Url.Action("Index", "ShoppingCart", new { ID = order.ShopID })
}));
}
return(Json(new
{
result = "error",
message = new Dictionary <string, Dictionary <string, List <string> > >()
{
{ "general", new Dictionary <string, List <string> >()
{
{ "errors", new List <string>()
{
"order not found"
} }
} }
}
}));
}
public ActionResult ChangeShop(int ID, int ToShopID)
{
//if (!LS.isLogined())
//{
// return RedirectToAction("Index","Main");
//}
var curShopModel = new ShoppingCartOverviewModel();
curShopModel.Items = _shoppingCartService.GetShoppingCartItems(ID, true);
var model = new ShoppingCartOverviewModel();
model.Items = ShoppingCartService.GetShoppingCartItemsByList(ToShopID, curShopModel.Items);
var items = model.Items.Where(x => !x.IsNotAvaliable &&
!x.SelectedAttributeNotAvaliable &&
!x.IsHaveNotQuantity).ToList();
foreach (var oi in items)
{
if (oi.Quantity > 0)
{
ShoppingCartService.AddToCart(LS.CurrentUser.ID, new ShoppingCartItem()
{
ProductAttributeOptionID = oi.ProductAttributeOptionID,
ProductShopID = oi.ProductShopID,
Quantity = oi.Quantity,
ShopID = oi.ShopID,
});
}
}
Shop shop = _db.Shops.FirstOrDefault(r => r.ID == ToShopID);
return(Redirect("/" + shop.SeoUrl));
}
void AddToCart_should_add_second_product()
{
var user = CreateUser();
var product1 = CreateProduct(1);
var product2 = CreateProduct(2);
var userService = Substitute.For <IUserService>();
userService.IsUserLoggedIn(user.Id).Returns(true);
var shoppingCartService = new ShoppingCartService(userService);
shoppingCartService.AddToCart(user.Id, product1);
shoppingCartService.AddToCart(user.Id, product2);
shoppingCartService.GetProductsByUserId(user.Id)
.Should().ContainEquivalentOf(product2);
}
// public string Title = "Percent or fixed amount discount";
//public DiscountType Type
//{
// get
// {
// return DiscountType.ForCartTotal;
// }
//}
public bool Process(ShoppingCartOverviewModel model, Discount curdiscount, object DiscountConfigItem, User user, int lim)
{
var rule = (BuyOneGetOtherFreeDicountConfig)DiscountConfigItem;
var productsList = curdiscount.GetProductsList();
var totalQuantity = model.Items.Where(x => productsList.Contains(x.ProductShopID.ToString())).Select(x => x.Quantity)
.DefaultIfEmpty(0).Sum();
if (totalQuantity >= rule.QuantityFrom)
{
var items = model.Items.Where(x => rule.FreeProductShopID == x.ProductShopID)
.ToList();
if (items.Count == 0)
{
if (rule.AutoAddToCart)
{
var cartItem = new ShoppingCartItem()
{
ProductShopID = rule.FreeProductShopID,
Quantity = 1,
ShopID = model.ShopID
};
ShoppingCartService.AddToCart(user.ID, cartItem);
var cartItemModel = ShoppingCartService.GetShoppingCartItemByID(cartItem.ID);
model.Items.Add(cartItemModel);
items.Add(cartItemModel);
}
}
if (items.Count > 0)
{
foreach (var item in items)
{
if (!DiscountService.LimitCheck(lim, curdiscount.Limit, curdiscount.LimitType))
{
break;
}
if (item.Quantity <= rule.MaxFreeQuantity)
{
item.Price = 0;// show that price is zero
}
else
{
item.TotalDiscountAmount += item.Price * rule.MaxFreeQuantity;// can be only one free, so we change unit price
}
lim++;
}
return true;
}
}
return false;
}
// Add products to Cart
public ActionResult AddToCart(long productId, int quantity)
{
var account = (User) Session["Account"];
if (account == null)
{
return RedirectToAction("Login", "Login");
}
var cart = Session[CartSession];
Session[CartSession] = shoppingCartService.AddToCart(productId, quantity, account, cart);
return RedirectToAction("ShowCart");
}
public RedirectToActionResult AddToShoppingCart(int productId)
{
var product = _productRepository.GetProducts
.FirstOrDefault(p => p.ProductId == productId);
if (product != null)
{
_shoppingCart.AddToCart(product, 1);
}
return(RedirectToAction("Index"));
}
public RedirectToActionResult AddToShoppingCart(int productId)
{
Product selectedProduct = _productRepository.GetAllProducts().FirstOrDefault(p => p.ProductId == productId);
if (selectedProduct != null)
{
_shoppingCartService.AddToCart(selectedProduct, 1);
}
return(RedirectToAction("Index"));
}
public ActionResult AddToCartAjx(ShoppingCartItem item, decimal?OverrideQuantity, bool isMobile = false)
{
if (!LS.isHaveID())
{
return(Json(new { result = "error", action = "login", message = "You must login first", data = item }));
}
var addmodel = ShoppingCartService.AddToCart(LS.CurrentUser.ID, item, OverrideQuantity, isMobile: isMobile);
if (addmodel.errors.Count > 0)
{
return(Json(new { result = "error", message = addmodel.errors.FirstOrDefault(), data = addmodel.item }));
}
return(Json(new { result = "ok", data = addmodel.item }));
}
void GetProductsByUserId_should_return_products()
{
var user = CreateUser();
var product = CreateProduct(1);
var userService = Substitute.For <IUserService>();
userService.IsUserLoggedIn(user.Id).Returns(true);
var shoppingCartService = new ShoppingCartService(userService);
shoppingCartService.AddToCart(user.Id, product);
var products = shoppingCartService.GetProductsByUserId(user.Id);
products.Should().ContainEquivalentOf(product);
}
public async Task VerifyAddingToCartAddsItToTheCollection()
{
var cachingRegionFactory = new Mock <ICachingRegionFactory>();
var cachingRegion = new Mock <ICachingRegion <IEnumerable <CartItemModel> > >();
cachingRegionFactory.Setup(f => f.CreateRegion <IEnumerable <CartItemModel> >("ShoppingCart")).Returns(cachingRegion.Object);
var service = new ShoppingCartService(cachingRegionFactory.Object);
var book = new BookDto {
Id = 2
};
await service.AddToCart(book);
service.CartItems.Count.ShouldBe(1);
service.CartItems[0].Book.ShouldBe(book);
}
public RedirectToActionResult AddToShoppingCart(int productId)
{
var productVM = _productService.GetProductById(productId);
if (!HelperService.AProductExists(productVM))
{
RedirectToAction(nameof(ProductController.ProductNotFound), nameof(Product), new { message = "" });
}
else
{
var productToAdd = _mapper.Map <Product>(productVM);
_shoppingCart.AddToCart(productToAdd, 1);
_logger.LogInfo($"A product with id: {productId} has been added to the shopping cart.");
}
return(RedirectToAction(nameof(ShoppingCartIndex)));
}
public ActionResult OrderReject(int ID)
{
if (CurrentShop == null)
{
return(Json(new { result = "error", message = RP.S("Member.Error.ShopNotFound") }));
}
var order = _db.Orders.FirstOrDefault(x => x.ID == ID && x.ShopID == CurrentShop.ID);
if (order == null)
{
return(Json(new { result = "error", message = RP.S("Member.Error.OrderNotFound") }));
}
if (order.OrderStatus != OrderStatus.New && order.OrderStatus != OrderStatus.Paid)
{
return(Json(new { result = "error", message = RP.S("Member.Error.OrderAlreadyProcessed") }));
}
order.OrderStatus = OrderStatus.Rejected; //ShoppingService.RejectedOrderStatus();
_db.SaveChanges();
// add to cart
var items = _db.OrderItems.Where(x => x.OrderID == order.ID).ToList();
OrderItemStatus outItemStatus = OrderItemStatus.OutOfStock;
foreach (var oi in items)
{
if (oi.OrderItemStatus != outItemStatus && oi.Quantity > 0)
{
ShoppingCartService.AddToCart(order.UserID, new ShoppingCartItem()
{
ProductAttributeOptionID = oi.ProductAttributeOptionID,
ProductShopID = oi.ProductShopID,
Quantity = oi.Quantity,
ShopID = order.ShopID,
});
}
}
//send email
var messService = new MessageService(_db);
var user = _db.Users.FirstOrDefault(x => x.ID == order.UserID);
var shop = _db.Shops.FirstOrDefault(x => x.ID == order.ShopID);
messService.OrderCanceledSmsToUser(order, user);
messService.OrderCanceledEmailToUser(order, shop);
return(Json(new { result = "ok", message = RP.S("Member.OrderChange.Rejected") }));
}
public ActionResult AddToCartAjx(ShoppingCartItem item)
{
if (item.ProductShopID < 1)
{
return(Json(new { result = "error", message = "Data issuse", data = item }));
}
if (!LS.isHaveID())
{
return(Json(new { result = "error", action = "login", message = "You must login first", data = item }));
}
if (item.Quantity < 1)
{
return(Json(new { result = "error", message = "Quantity can`t be less then 1", data = item }));
}
//check existing
ShoppingCartService.AddToCart(LS.CurrentUser.ID, item);
return(Json(new { result = "ok", data = item }));
}
public ActionResult AddToCart(string values)
{
if (!HttpContext.User.Identity.IsAuthenticated)
{
return(Json(new { redirectToUrl = Url.Action("Login", "Account") }));
}
else
{
var AddToCart = shoppingCartService.AddToCart();
var AddToCartItems = shoppingCartService.AddToCartItems(values);
if (AddToCart.isSuccessful && AddToCartItems.isSuccessful)
{
return(Json(new { redirectToUrl = Url.Action("ShopCart") }));
}
else
{
var Error = AddToCart.exception;
ViewBag.ErrorToAddCart = Error.ToString();
return(Json(new { redirectToUrl = Url.Action("ShopCart") }));
}
}
}
public void AddToCart_ShoulAdd_ProductToCart()
{
// Arrrange
var shoppingCartService = new ShoppingCartService(db, this.shoppingCart);
var product = new Product {
Id = 1, Price = 1, Title = "TestProduct"
};
// Act
shoppingCartService.AddToCart(product, 1);
var result = this.shoppingCart
.ShoppingCartItems
.FirstOrDefault(p => p.Product.Title == "TestProduct");
// Arrange
result.Should().NotBeNull();
result
.Should()
.Match <ShoppingCartItem>(p => p.Product.Id == 1 &&
p.Product.Title == "TestProduct" &&
p.Product.Price == 1);
}
public ActionResult OrderMissing(int ID)
{
if (CurrentShop == null)
{
return(Json(new { result = "error", message = RP.S("Member.Error.ShopNotFound") }));
}
var order = _db.Orders.FirstOrDefault(x => x.ID == ID && x.ShopID == CurrentShop.ID);
if (order == null)
{
return(Json(new { result = "error", message = RP.S("Member.Error.OrderNotFound") }));
}
if (order.OrderStatus != OrderStatus.New && order.OrderStatus != OrderStatus.Paid)
{
return(Json(new { result = "error", message = RP.S("Member.Error.OrderAlreadyProcessed") }));
}
OrderItemStatus outItemStatus = OrderItemStatus.OutOfStock;
OrderItemStatus changedItemStatus = OrderItemStatus.Changed;
var any = _db.OrderItems.Any(x => x.OrderID == order.ID && (x.OrderItemStatus == outItemStatus
||
x.OrderItemStatus == changedItemStatus)
);
if (!any) //check out of stock items
{
return(Json(new { result = "error", message = RP.S("Member.Error.YouDontHaveChangedProducts") }));
}
order.OrderStatus = OrderStatus.Rejected; //ShoppingService.RejectedOrderStatus();//canceled
_db.SaveChanges();
// add to cart
var items = _db.OrderItems.Where(x => x.OrderID == order.ID).ToList();
foreach (var oi in items)
{
if (oi.OrderItemStatus != outItemStatus && oi.Quantity > 0)
{
ShoppingCartService.AddToCart(order.UserID, new ShoppingCartItem()
{
ProductAttributeOptionID = oi.ProductAttributeOptionID,
ProductShopID = oi.ProductShopID,
Quantity = oi.Quantity,
ShopID = order.ShopID,
});
}
}
//send email
var messService = new MessageService(_db);
messService.SendOrderChangedEmailToUser(order, items
.Where(x => x.OrderItemStatus == OrderItemStatus.Changed
).ToList(),
items
.Where(x => x.OrderItemStatus == OrderItemStatus.OutOfStock
).ToList()
);
var user = _db.Users.FirstOrDefault(x => x.ID == order.UserID);
messService.SendOrderChangedSmsToUser(order, user);
//
return(Json(new { result = "ok", message = RP.S("Member.OrderChanged.ProductsReturnedToClientOrderRejected") }));
}