public Boolean Update(ShoppingCartProduct shoppingCartProduct)
{
using (SqlConnection con = new SqlConnection(_connectionString))
{
con.Open();
SqlCommand cmd = new SqlCommand("usp_ECom_UpdateShoppingCartProduct", con);
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("Id", shoppingCartProduct.Id);
cmd.Parameters.AddWithValue("ShoppingCartId", shoppingCartProduct.ShoppingCartId);
cmd.Parameters.AddWithValue("ProductId", shoppingCartProduct.ProductId);
cmd.Parameters.AddWithValue("Quantity", shoppingCartProduct.Quantity);
cmd.Parameters.AddWithValue("UnitPrice", shoppingCartProduct.UnitPrice);
cmd.Parameters.AddWithValue("UnitOfMeasure", shoppingCartProduct.UnitOfMeasure);
cmd.Parameters.AddWithValue("SubTotal", shoppingCartProduct.SubTotal);
cmd.Parameters.AddWithValue("ModifiedBy", "Deyi");
cmd.Parameters.AddWithValue("ModifiedDate", DateTime.Now);
SqlParameter retval = cmd.Parameters.Add("Return", SqlDbType.Int);
retval.Direction = System.Data.ParameterDirection.ReturnValue;
if (cmd.ExecuteNonQuery() == 1)
{
return(true);
}
}
return(false);
}
public async Task SeedDisabledProduct(ApplicationDbContext context)
{
var product1 = new Product()
{
Id = "ProductId1",
Available = false,
};
var shoppingCart1 = new ShoppingCart()
{
Id = "1",
};
var shoppingCartProduct1 = new ShoppingCartProduct()
{
ShoppingCartId = "1",
Product = product1,
Quantity = 2,
};
await context.ShoppingCarts.AddAsync(shoppingCart1);
await context.ShoppingCartProducts.AddAsync(shoppingCartProduct1);
await context.SaveChangesAsync();
}
public String AddToCart(int id)
{
//not supposed to be here, should be after login event
customer = customerRepo.GetById(1);
shoppingCart = new ShoppingCart(customer.Id);
shoppingCart.CreatedBy = shoppingCart.LastModifiedBy = "Customer Name";
// create a ShoppingCartRepository scr object
//use scr to save shoppingCart
ShoppingCartRepository scr = new ShoppingCartRepository(ConstantUtil.MyConnectionString);
int shoppingCartId = scr.Insert(shoppingCart);
ProductRepository pr = new ProductRepository(ConstantUtil.MyConnectionString);
Product p = pr.GetById(id);
ShoppingCartProduct scp = new ShoppingCartProduct(shoppingCartId, id);
scp.Quantity = 100;
scp.UnitOfMeasure = p.UnitOfMeasure;
scp.UnitPrice = p.UnitPrice;
scp.CreatedBy = p.CreatedBy;
scp.LastModifiedBy = p.LastModifiedBy;
scp.CreatedDate = p.CreatedDate;
scp.LastModifiedDate = p.LastModifiedDate;
scp.SubTotal = scp.Quantity * scp.UnitPrice;
//create a ShoppinngCartProductRepository scpr
//use scpr to save scp
ShoppingCartProductRepository scpr = new ShoppingCartProductRepository(ConstantUtil.MyConnectionString);
scpr.Create(scp);
return("Add product " + id + " to the cart successfully!");
}
public int Create(ShoppingCartProduct shoppingCartProduct)
{
using (SqlConnection con = new SqlConnection(_connectionString))
{
con.Open();
SqlCommand cmd = new SqlCommand("usp_ECom_InsertShoppingCartProduct", con);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("ShoppingCartId", shoppingCartProduct.ShoppingCartId);
cmd.Parameters.AddWithValue("ProductId", shoppingCartProduct.ProductId);
cmd.Parameters.AddWithValue("Quantity", shoppingCartProduct.Quantity);
cmd.Parameters.AddWithValue("UnitPrice", shoppingCartProduct.UnitPrice);
if (shoppingCartProduct.UnitOfMeasure == null)
{
shoppingCartProduct.UnitOfMeasure = "EA";
}
cmd.Parameters.AddWithValue("UnitOfMeasure", shoppingCartProduct.UnitOfMeasure);
cmd.Parameters.AddWithValue("SubTotal", shoppingCartProduct.SubTotal);
cmd.Parameters.AddWithValue("CreatedBy", "DDD");
cmd.Parameters.AddWithValue("CreatedDate", DateTime.Now);
cmd.Parameters.AddWithValue("LastModifiedBy", "DDD");
cmd.Parameters.AddWithValue("LastModifiedDate", DateTime.Now);
SqlParameter retval = cmd.Parameters.Add("Return", SqlDbType.Int);
retval.Direction = System.Data.ParameterDirection.ReturnValue;
return(cmd.ExecuteNonQuery());
}
return(0);
}
public void AddToShoppingCart(ShoppingCart cart, Product product)
{
var products =
this.Data.ShoppingCartProducts.All()
.Where(sp => sp.ShoppingCartId == cart.Id).Select(sp => sp.Product).ToList();
ShoppingCartProduct shoppingCartProduct =
this.Data.ShoppingCartProducts.All()
.FirstOrDefault(sp => sp.ShoppingCartId == cart.Id && sp.ProductId == product.Id);
if (products.Any())
{
foreach (var cartProduct in products)
{
if (cartProduct.Id == product.Id)
{
if (shoppingCartProduct != null)
{
shoppingCartProduct.Units++;
}
this.Data.SaveChanges();
return;
}
}
}
var newShoppingCartProduct = new ShoppingCartProduct()
{
ShoppingCartId = cart.Id,
ProductId = product.Id
};
this.Data.ShoppingCartProducts.Add(newShoppingCartProduct);
this.Data.SaveChanges();
}
public void AddProductInCart(int productId, string username)
{
var product = this.productsService.GetProductById(productId);
var user = this.userService.GetUserByUsername(username);
var userShoppingCartId = user.ShoppingCartId;
if (product == null || user == null)
{
return;
}
var shoppingCartProduct = this.GetShoppingCartProduct(productId, userShoppingCartId);
if (shoppingCartProduct != null)
{
return;
}
shoppingCartProduct = new ShoppingCartProduct
{
Product = product,
ShoppingCartId = userShoppingCartId,
};
this.db.ShoppingCartProducts.Add(shoppingCartProduct);
this.db.SaveChanges();
}
public async Task <bool> AddProductToShoppingCartAsync(string productId, string username, int quantity)
{
var product = this.context
.Products
.SingleOrDefault(x => x.Id == productId);
var user = await this.userService.GetUserByUsername(username);
if (product == null || quantity <= 0 || user == null)
{
return(false);
}
var shoppingCartProduct = new ShoppingCartProduct()
{
Product = product,
ShoppingCartId = user.ShoppingCartId,
Quantity = quantity
};
this.context.ShoppingCartProduct.Add(shoppingCartProduct);
var result = await this.context.SaveChangesAsync();
return(result > 0);
}
public async Task <Result> AddProductAsync(
ShoppingCartRequestModel model, string userId)
{
var productId = model.ProductId;
var requestQuantity = model.Quantity;
var productQuantity = await this.GetProductQuantityById(productId);
if (productQuantity < requestQuantity)
{
return(NotEnoughProductsMessage);
}
var shoppingCart = await this
.All()
.FirstOrDefaultAsync(c => c.UserId == userId);
shoppingCart ??= new ShoppingCart
{
UserId = userId
};
var shoppingCartProduct = new ShoppingCartProduct
{
ShoppingCart = shoppingCart,
ProductId = productId,
Quantity = requestQuantity
};
await this.Data.AddAsync(shoppingCartProduct);
await this.Data.SaveChangesAsync();
return(Result.Success);
}
public ActionResult AddProduct(int cartId, int productId)
{
Session["cartId"] = cartId;
Product product = getProduct(productId);
if (db.ShoppingCartProducts.Any(p => p.ProductID == productId && p.ShoppingCartID == cartId))
{
ShoppingCartProduct cartProduct = getCartProductById(cartId, productId);
cartProduct.Quantity = cartProduct.Quantity + 1;
cartProduct.Price = cartProduct.Price + getProductPrice(productId);
db.SaveChanges();
Session["quantity"] = getQuantity(cartId);
}
else
{
var cartProduct = new ShoppingCartProduct();
cartProduct.ShoppingCartID = cartId;
cartProduct.ProductID = product.ProductID;
cartProduct.ProductName = product.ProductName;
cartProduct.Price = product.Price;
cartProduct.DateCreated = DateTime.Now;
cartProduct.Quantity = cartProduct.Quantity + 1;
db.ShoppingCartProducts.Add(cartProduct);
db.SaveChanges();
Session["quantity"] = getQuantity(cartId);
}
return(RedirectToAction("Welcome", "Users"));
}
public void AddProductInShoppingCart(int productId, string username, int?quntity = null)
{
var product = this.productService.GetProductById(productId);
var user = this.userService.GetUserByUsername(username);
if (product == null || user == null)
{
return;
}
var shoppingCartProduct = GetShoppingCartProduct(productId, user.ShoppingCartId);
if (shoppingCartProduct != null)
{
return;
}
shoppingCartProduct = new ShoppingCartProduct
{
Product = product,
Quantity = quntity == null ? DEFAULT_PRODUCT_QUANTITY : quntity.Value,
ShoppingCartId = user.ShoppingCartId
};
this.db.ShoppingCartProducts.Add(shoppingCartProduct);
this.db.SaveChanges();
}
public async Task <IActionResult> PutShoppingCartProduct([FromRoute] int id, [FromBody] ShoppingCartProduct shoppingCartProduct)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != shoppingCartProduct.Id)
{
return(BadRequest());
}
_context.Entry(shoppingCartProduct).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ShoppingCartProductExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void AddShoppingCartProduct_WithExistentShoppingCartProductAndProductQuantityMoreThenOne_ShouldSuccessfullyIncreaseQuantity()
{
string errorMessagePrefix = "ShoppingCartsService AddShoppingCartProduct() method does not work properly.";
var context = UniShopDbContextInMemoryFactory.InitializeContext();
this.SeedData(context);
this.shoppingCartsService = new ShoppingCartsService(context, new UniShopUsersService(context),
new ProductsService(context, new ChildCategoriesService(context, new ParentCategoriesService(context))));
UniShopUser user = context.Users.First();
int productId = context.Products.First().Id;
ShoppingCartProduct testShoppingCartProduct = new ShoppingCartProduct
{
ProductId = productId,
ShoppingCartId = user.ShoppingCartId,
Quantity = 1
};
context.Add(testShoppingCartProduct);
context.SaveChanges();
ShoppingCartProduct shoppingCartProduct = context.ShoppingCartProducts
.First(s => s.ShoppingCartId == user.ShoppingCartId && s.ProductId == productId);
int expectedCount = shoppingCartProduct.Quantity + 1;
bool actualResult = this.shoppingCartsService.AddShoppingCartProduct(productId, user.UserName);
int actualCount = shoppingCartProduct.Quantity;
Assert.True(actualResult, errorMessagePrefix);
Assert.Equal(expectedCount, actualCount);
}
public async Task AddProductToShoppingCartAsync(int cartId, int productId, int quantity)
{
ShoppingCartProduct shoppingCartProduct = new ShoppingCartProduct(cartId, productId, quantity);
await _context.ShoppingCartProducts.AddAsync(shoppingCartProduct);
await _context.SaveChangesAsync();
}
public void ReduceQuantity_WithShoppingCartProductQuantityOne_ShouldReturnFalse()
{
string errorMessagePrefix = "ShoppingCartsService ReduceQuantity() method does not work properly.";
var context = UniShopDbContextInMemoryFactory.InitializeContext();
this.SeedData(context);
this.shoppingCartsService = new ShoppingCartsService(context, new UniShopUsersService(context),
new ProductsService(context, new ChildCategoriesService(context, new ParentCategoriesService(context))));
UniShopUser user = context.Users.First();
int productId = context.Products.Where(p => p.Quantity == 0).First().Id;
ShoppingCartProduct testShoppingCartProduct = new ShoppingCartProduct
{
ProductId = productId,
ShoppingCartId = user.ShoppingCartId,
Quantity = 1
};
context.Add(testShoppingCartProduct);
context.SaveChanges();
int expectedCount = testShoppingCartProduct.Quantity;
bool actualResult = this.shoppingCartsService.ReduceQuantity(productId, user.UserName);
int actualCount = testShoppingCartProduct.Quantity;
Assert.False(actualResult, errorMessagePrefix);
Assert.Equal(expectedCount, actualCount);
}
public void RemoveShoppingCartProduct_WithCorrectData_ShouldSuccessfullyRemove()
{
string errorMessagePrefix = "ShoppingCartsService RemoveShoppingCartProduct() method does not work properly.";
var context = UniShopDbContextInMemoryFactory.InitializeContext();
this.SeedData(context);
this.shoppingCartsService = new ShoppingCartsService(context, new UniShopUsersService(context),
new ProductsService(context, new ChildCategoriesService(context, new ParentCategoriesService(context))));
UniShopUser user = context.Users.First();
int productId = context.Products.First().Id;
ShoppingCartProduct testShoppingCartProduct = new ShoppingCartProduct
{
ProductId = productId,
ShoppingCartId = user.ShoppingCartId,
Quantity = 2
};
context.Add(testShoppingCartProduct);
context.SaveChanges();
int expectedCount = user.ShoppingCart.ShoppingCartProducts.Count() - 1;
bool actualResult = this.shoppingCartsService.RemoveShoppingCartProduct(productId, user.UserName);
int actualCount = user.ShoppingCart.ShoppingCartProducts.Count();
Assert.True(actualResult, errorMessagePrefix);
Assert.Equal(expectedCount, actualCount);
}
/// <summary>
/// Add a new shopping cart product
/// </summary>
/// <param name="shoppingCartProduct"></param>
public static void AddShoppingCartProduct(ShoppingCartProduct shoppingCartProduct)
{
List <ShoppingCartProduct> NewShoppingCartProductList = ShoppingCartProductList;
NewShoppingCartProductList.Add(shoppingCartProduct);
ShoppingCartProductList = NewShoppingCartProductList;
}
public ActionResult Delete(int id)
{
ShoppingCartProduct product = db.shoppingCartProducts.Find(id);
db.shoppingCartProducts.Remove(product);
TempData["message"] = "Produsul a fost sters!";
db.SaveChanges();
return(RedirectToAction("Index"));
}
private void InitializeFields()
{
this.firstShoppingCart = new ShoppingCart
{
UserId = "1",
};
this.user = new PhotoPavilionUser
{
Id = "1",
Gender = Gender.Male,
UserName = "******",
FullName = "Peter Petrov",
Email = "*****@*****.**",
PasswordHash = "123456",
ShoppingCartId = 1,
};
this.firstBrand = new Brand
{
Name = "Canon",
};
this.firstCategory = new Category
{
Name = "Cameras",
Description = "Sample category description",
};
this.firstProduct = new Product
{
Id = 1,
Name = "Canon eos 1100D",
Code = 10600,
Description = "Sample description for Canon eos 1100D",
Price = 1500,
ImagePath = TestProductImageUrl,
BrandId = 1,
CategoryId = 1,
};
this.firstOrderProduct = new OrderProduct
{
ProductId = 1,
Quantity = 1,
Status = OrderStatus.Accepted,
Date = DateTime.UtcNow,
UserId = "1",
};
this.firstShoppingCartProduct = new ShoppingCartProduct
{
ShoppingCartId = 1,
ProductId = 1,
Quantity = 1,
};
}
public ActionResult Delete(int productId, int cartId)
{
ShoppingCartProduct cartProduct = getCartProductById(cartId, productId);
db.ShoppingCartProducts.Remove(cartProduct);
db.SaveChanges();
return(RedirectToAction("CartView", new { cartId }));
}
public async Task <int> ChangeShoppingCartProductCountAsync(Product product, ShoppingCart shoppingCart, string operation, ISession session)
{
if (shoppingCart != null)
{
int returnCode = 1;
await Task.Run(() =>
{
try
{
ShoppingCartProduct shoppingCartProduct = _context.ShoppingCartProduct
.Where(scp => scp.Product.Name == product.Name && scp.ShoppingCart == shoppingCart)
.FirstOrDefault();
//Change
if (operation == "reduce" && shoppingCartProduct.Quantity > 1)
{
shoppingCartProduct.Quantity--;
}
else if (operation == "increase")
{
shoppingCartProduct.Quantity++;
}
_context.Update(shoppingCartProduct);
_context.Update(shoppingCart);
var t2 = Task.Run(
async() =>
{
await _context.SaveChangesAsync();
});
t2.Wait();
returnCode = 0;
}
catch (Exception)
{
returnCode = 1;
}
});
return(returnCode);
}
else
{
if (operation == "reduce")
{
await session.AddSessionProductAsync(product.Id, -1);
}
else if (operation == "increase")
{
await session.AddSessionProductAsync(product.Id, 1);
}
return(0);
}
}
public async Task AddProductToCartAsync(string productId, string userId)
{
var shoppingCart = this.shoppingCartRepository.All().FirstOrDefault(x => x.UserId == userId);
if (shoppingCart == null)
{
shoppingCart = new ShoppingCart()
{
User = this.usersService.GetUserById(userId),
ShoppingCartProducts = new List <ShoppingCartProduct>(),
};
var shoppingCartProduct = new ShoppingCartProduct()
{
ShoppingCart = shoppingCart,
ProductId = productId,
};
shoppingCart.ShoppingCartProducts.Add(shoppingCartProduct);
await this.shoppingCartRepository.AddAsync(shoppingCart);
}
var shoppingCartProducts = this.shoppingCartRepository
.All()
.SelectMany(x => x.ShoppingCartProducts)
.Where(x => x.ShoppingCartId == shoppingCart.Id)
.ToList();
if (shoppingCartProducts == null)
{
shoppingCart.ShoppingCartProducts = new List <ShoppingCartProduct>()
{
new ShoppingCartProduct()
{
ShoppingCart = shoppingCart,
ProductId = productId,
},
};
}
if (!shoppingCartProducts.Any(x => x.ProductId == productId))
{
var shoppingCartProduct = new ShoppingCartProduct()
{
ShoppingCart = shoppingCart,
ProductId = productId,
};
shoppingCartProducts.Add(shoppingCartProduct);
shoppingCart.ShoppingCartProducts = shoppingCartProducts;
}
await this.shoppingCartRepository.SaveChangesAsync();
}
public ActionResult UpdateQuantity(int productId, int cartId, int quant)
{
ShoppingCartProduct product = getCartProductById(cartId, productId);
product.Quantity = quant;
product.Price = product.Price * product.Quantity;
db.SaveChanges();
return(RedirectToAction("CartView", new { cartId }));
}
private ShoppingCartProduct CreateShoppingCartProductByProduct(Product product, int?quantity, ShoppingCart shoppingCart)
{
var shoppingCartProduct = new ShoppingCartProduct
{
Product = product,
Quantity = quantity == null ? DefaultProductQuantity : quantity.Value,
ShoppingCartId = shoppingCart.Id,
ProductId = product.Id,
};
return(shoppingCartProduct);
}
public ActionResult AddToCart(int ProductId)
{
ShoppingCartProduct prod = new ShoppingCartProduct();
prod.ProductId = ProductId;
prod.UserId = User.Identity.GetUserId();
db.shoppingCartProducts.Add(prod);
db.SaveChanges();
return(Redirect(Request.UrlReferrer.ToString()));
}
public async Task <IActionResult> PostShoppingCartProduct([FromBody] ShoppingCartProduct shoppingCartProduct)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.ShoppingCartProduct.Add(shoppingCartProduct);
_context.SaveChangesAsync();
return(Ok());
//return CreatedAtAction("GetShoppingCartProduct", new { id = shoppingCartProduct.Id }, shoppingCartProduct);
}
private OrderProduct CreateOrderProduct(Order order, ShoppingCartProduct shoppingCartProduct)
{
var orderProduct = new OrderProduct
{
Order = order,
Product = shoppingCartProduct.Product,
Quantity = shoppingCartProduct.Quantity,
Price = shoppingCartProduct.Product.Price,
};
return(orderProduct);
}
public IHttpActionResult Create([FromBody] ShoppingCartProductDto shoppingCartProductDto)
{
var shoppingCartProduct = new ShoppingCartProduct()
{
ShoppingCartId = shoppingCartProductDto.ShoppingCartId,
ProductId = shoppingCartProductDto.ProductId,
Quantity = shoppingCartProductDto.Quantity
};
shoppingCartProductRepository.Add(shoppingCartProduct);
shoppingCartProductRepository.SaveChanges();
return(Ok(shoppingCartProduct));
}
//
// public async Task<CreateShoppingCartResponse> CreateCartAsync(CreateShoppingCartRequest request)
// {
// var cart = Domain.ShoppingCart.Create(request.CustomerId);
// await repo.SaveAsync(cart);
//
// var cartDTO = mapper.Map<ShoppingCartDTO>(cart);
//
// return new CreateShoppingCartResponse {ShoppingCart = cartDTO};
// }
public async Task <AddProductResponse> AddProduct(AddProductRequest request)
{
var cart = await repo.GetCartByIdAsync(request.CartId);
var product = request.Product;
//double dispatch pattern
cart.AddProduct(ShoppingCartProduct.Create(product.Id, product.Name, cart, new Money(product.Price.Amount)));
await repo.SaveAsync(cart);
return(new AddProductResponse(true, ResponseAction.Updated));
}
public async Task <bool> AddProductToCart(string productId, string userId, int quantity)
{
// Validations for input data
bool productExists = await this.ProductExists(productId);
bool userExists = await this.UserExists(userId);
bool isValidQuantity = quantity < 1 ? false : true;
if (!productExists || !userExists || !isValidQuantity)
{
return(false);
}
// Calls a private method to do the job for getting the shopping cart id
string shoppingCartId = await this.GetOrCreateUserShoppingCartById(userId);
// Checks if a product is added to the cart and if so, applies just the quantity
// Otherwise shopping cart product is created with the data
bool isProductAdded = this.context
.ShoppingCartProducts
.Any(scp => scp.ProductId == productId && scp.ShoppingCartId == shoppingCartId);
int result = 0;
if (isProductAdded)
{
this.context
.ShoppingCartProducts
.SingleOrDefault(scp => scp.ProductId == productId && scp.ShoppingCartId == shoppingCartId)
.Quantity += quantity;
result = await this.context.SaveChangesAsync();
return(result > 0);
}
var shoppingCartProduct = new ShoppingCartProduct
{
ProductId = productId,
ShoppingCartId = shoppingCartId,
Quantity = quantity,
};
await this.context.ShoppingCartProducts.AddAsync(shoppingCartProduct);
result = await this.context.SaveChangesAsync();
return(result > 0);
}
public static double GetPrice(ShoppingCartProduct shoppingCartProduct, string currency)
{
switch (currency)
{
case "CAD":
return(shoppingCartProduct.Product.Price);
case "USD":
return(shoppingCartProduct.Product.PriceUSD);
default:
return(shoppingCartProduct.Product.Price);
}
}
