public ActionResult AddToBasket(int id)
{
BasketProduct element = Basket.FirstOrDefault(x => x.ProductId == id);
if (element == null)
{
Product product = db.Urunler.Find(id);
element = new BasketProduct
{
ProductId = id,
ProductName = product.ProductName,
UnitPrice = product.UnitPrice,
Piece = 1,
Content = product.Content,
PicturePath = product.PicturePath
};
Basket.Add(element);
}
else
{
element.Piece++;
}
return(Json(new { TotalPruduct = Basket.Count }));
}
public async Task <IActionResult> Add(int id)
{
Product product = await _context.Products.Include(x => x.ProductImages).FirstOrDefaultAsync(p => p.Id == id);
BasketProduct basket = product;
string cart = HttpContext.Session.GetString("cart");
List <BasketProduct> products = new List <BasketProduct>();
if (cart != null)
{
products = JsonConvert.DeserializeObject <List <BasketProduct> >(cart);
}
var selected = products.FirstOrDefault(p => p.Id == id);
if (selected == null)
{
products.Add(basket);
}
else
{
selected.Quantity++;
}
string productJson = JsonConvert.SerializeObject(products);
HttpContext.Session.SetString("cart", productJson);
return(RedirectToAction(nameof(Index)));
}
/// <summary>
/// Deletes a basketProduct item from the table matching composite keys
/// </summary>
/// <param name="basketID">Composite basket key</param>
/// <param name="productID">Composite product key</param>
/// <returns>Product removed from basket</returns>
public async Task DeleteBasketProductByID(int basketID, int productID)
{
BasketProduct basketProduct = await _context.BasketProducts.FirstOrDefaultAsync(bp => bp.BasketID == basketID && bp.ProductID == productID);
_context.BasketProducts.Remove(basketProduct);
await _context.SaveChangesAsync();
}
public async Task <BasketProduct> AddBasketProduct(int productId)
{
var userBasket = await GetUsersNonOrderedBasket();
if (userBasket == null)
{
userBasket = await AddBasket();
}
var basketProduct = await GetBasketProductByUserBasketIdAndProductId(userBasket.Id, productId);
if (basketProduct != null)
{
var incrementedProductCount = basketProduct.ProductCount + 1;
await UpdateBasketProductCount(userBasket.Id, productId, incrementedProductCount);
}
else
{
BasketProduct newBasketProduct = new BasketProduct();
newBasketProduct.ProductId = productId;
newBasketProduct.UserBasketId = userBasket.Id;
newBasketProduct.ProductCount = 1;
await _unitOfWork.BasketProducts.AddAsync(newBasketProduct);
await _unitOfWork.CommitAsync();
return(newBasketProduct);
}
return(basketProduct);
}
public void StartAddingProduct(string sku)
{
var newProduct = new BasketProduct()
{
Sku = sku, State = Enums.RequestState.InProgress
};
_products.Add(newProduct);
var tiket = _basketRepository.AddToBasket(sku);
tiket.OnSuccess += (response) =>
{
if (response.Data.Succseeded != null && response.Data.Succseeded.Value)
{
newProduct.PositionId = response.Data.PositionId;
newProduct.State = Enums.RequestState.Succseeded;
OnProductAddedSuccessfully?.Invoke(newProduct.Sku, newProduct.PositionId);
}
else
{
OnProductAddedFailure?.Invoke(sku);
newProduct.State = Enums.RequestState.Failed;
}
};
var priceTicket = _catalogRepository.GetPriceTicket(sku);
priceTicket.OnSuccess += (response) =>
{
if (response.Data != null)
{
newProduct.Price = response.Data.Price;
}
};
}
/// <summary>Update the quantity of a product in a <paramref name="basket"/></summary>
/// <exception cref="Exception">Throws runtime excpetion if an error response code is recieved</exception>
public async Task <Basket> UpdateQuantityOfProductInBasket(Basket basket, BasketProduct basketProduct)
{
var endpoint = string.Format(_uri + _basketProductsEndpoint, basket.Id, "");
var content = ObjectToJson(_basketProductSerializer, basketProduct);
return(await SendRequestAndParseReponse <Basket>(HttpMethod.Put, endpoint, content, _basketSerializer));
}
public async Task <IActionResult> AddProduct([FromBody] BasketProduct basketProduct)
{
await basketService.AddProduct(basketProduct);
var basketQuantity = await basketService.GetBasketQuantity();
return(Json(new { basketQuantity }));
}
public void CanGetQuantity()
{
BasketProduct basketProduct = new BasketProduct()
{
Quantity = 1
};
Assert.Equal(1, basketProduct.Quantity);
}
public void CanGetBasketID()
{
BasketProduct basketProduct = new BasketProduct()
{
BasketID = 1
};
Assert.Equal(1, basketProduct.BasketID);
}
private static ApiResultModel SetResultModel(BasketProduct model, bool isAdded)
{
var result = new ApiResultModel();
result.Code = isAdded ? (int)ApiResultMessageCode.ProductAddToBasketSuccess : (int)ApiResultMessageCode.ProductAddToBasketError;
result.Message = ((ApiResultMessageCode)result.Code).ToString();
result.Data = model;
return(result);
}
public void CanSetQuantity()
{
BasketProduct basketProduct = new BasketProduct()
{
Quantity = 1
};
basketProduct.Quantity = 2;
Assert.Equal(2, basketProduct.Quantity);
}
public void CanSetProductID()
{
BasketProduct basketProduct = new BasketProduct()
{
ProductID = 1
};
basketProduct.ProductID = 2;
Assert.Equal(2, basketProduct.ProductID);
}
public void RemoveFromBasket(BasketProduct basketProduct)
{
var basket = dbContext.Baskets.Find(basketProduct.BasketId);
var existingProductInBasket = dbContext.BasketProducts.Find(basketProduct.BasketId, basketProduct.ProductId);
if (basket != null && existingProductInBasket != null)
{
basket.BasketProducts.Remove(existingProductInBasket); //delete relationship
dbContext.BasketProducts.Remove(existingProductInBasket); //delete from DB
}
}
/// <summary>
/// The given <see cref="BasketProduct"/> has changed so update it.
/// </summary>
/// <param name="basketProductToRemove">The <see cref="BasketProduct"/> to update.</param>
/// <returns>The <see cref="Basket"/> as it now stands.</returns>
public Basket UpdateBasket(BasketProduct basketProductToRemove)
{
this._persistence.Change(basketProductToRemove);
this._persistence.Commit();
var basket = this._persistence.Find(
new PersistenceSearcher <Basket>(b => b.Id == basketProductToRemove.BasketId));
return(basket);
}
/// <summary>Add a <paramref name="quantity"/> of a <paramref name="product"/> to a <paramref name="basket"/></summary>
/// <exception cref="Exception">Throws runtime excpetion if an error response code is recieved</exception>
public async Task <Basket> AddProductToBasket(Basket basket, long quantity, Product product)
{
var endpoint = string.Format(_uri + _basketProductsEndpoint, basket.Id, "");
BasketProduct basketProduct = new BasketProduct {
Quantity = quantity, Product = product
};
var content = ObjectToJson(_basketProductSerializer, basketProduct);
return(await SendRequestAndParseReponse <Basket>(HttpMethod.Post, endpoint, content, _basketSerializer));
}
//RemoveProduct
public bool RemoveProduct(BasketProductOption bskProdOpt)
{
BasketProduct bskProd = db.BasketProducts.Find(bskProdOpt);
if (bskProd != null)
{
db.BasketProducts.Remove(bskProd);
db.SaveChanges();
return(true);
}
return(false);
}
public async Task AddProduct(BasketProduct basketProduct)
{
var addProductDto = new AddProductToBasketDto
{
Product = basketProduct,
UserId = userId
};
var addProductUrl = $"{baseUrl}add/product";
await customHttpClient.PostAsync(addProductUrl, addProductDto);
}
//AddProduct
public BasketProduct AddProduct(BasketProductOption bskProd)
{
BasketProduct basketProduct = new BasketProduct
{
Basket = db.Baskets.Find(bskProd.BasketId),
Product = db.Products.Find(bskProd.ProductId)
};
db.BasketProducts.Add(basketProduct);
db.SaveChanges();
return(basketProduct);
}
public void TestCreateBasket()
{
var product = new BasketProduct { ProductId = 1 };
var baskets = new List<Basket>();
this._fakePersistence.Setup(p => p.Add(It.IsAny<Basket>())).Callback<Basket>(baskets.Add);
this._target.CreateBasket(product);
Assert.IsTrue(baskets.Any());
}
/// <summary>
/// Add a <see cref="Product"/> to an existing <see cref="Basket"/>.
/// </summary>
/// <param name="basket">The <see cref="Basket"/> to add a <see cref="Product"/> too.</param>
/// <param name="productToAdd">The new <see cref="Product"/> for the <paramref name="basket"/>.</param>
/// <param name="quantity">The quantity of <see cref="Product"/> for the <paramref name="basket"/>.</param>
/// <returns>The <see cref="Basket"/>.</returns>
public Basket AddProductToBasket(Basket basket, Product productToAdd, int quantity)
{
var basketProduct = new BasketProduct { Basket = basket, Product = productToAdd, Quantity = quantity };
basket.Products.Add(basketProduct);
this._persistence.Change(basket);
this._persistence.Commit();
return basket;
}
/// <summary>
/// The given <see cref="BasketProduct"/> is no longer required so take it out of the <see cref="M:BasketProduct.Basket"/>
/// </summary>
/// <param name="basketProductToRemove">The <see cref="BasketProduct"/> to remove.</param>
/// <returns>The <see cref="Basket"/> as it now stands.</returns>
public Basket RemoveFromBasket(BasketProduct basketProductToRemove)
{
var basketId = basketProductToRemove.BasketId;
this._persistence.Remove(basketProductToRemove);
this._persistence.Commit();
var basket = this._persistence.Find(
new PersistenceSearcher <Basket>(b => b.Id == basketId));
return(basket);
}
public BasketProduct AddProduct(BasketProductOption bskProd)
{
CustomerManagement cstMng = new CustomerManagement(db);
BasketProduct basketProduct = new BasketProduct
{
Basket = db.Baskets.Find(bskProd.BasketId),
Product = db.Products.Find(bskProd.ProductId)
};
db.BasketProducts.Add(basketProduct);
db.SaveChanges();
return(basketProduct);
}
public void SuccessfullyAddProduct()
{
var productDto = new ProductDto
{
Id = 1,
Name = "product",
Stock = new StockDto()
{
Id = 1, CityId = 1, Quantity = 10
},
MinOrderQuantity = 1,
MaxOrderQuantity = 100
};
var basketId = 1;
var basketProductEntity = new BasketProduct()
{
BasketId = 1,
ProductId = 1,
Quantity = 2
};
var productResponseDto = new ProductDto()
{
Id = 1,
Stock = new StockDto()
{
Id = 1, CityId = 1, Quantity = 8
},
};
var requestDto = new AddToBasketRequestDto()
{
CityId = 1,
ProductId = 1,
Quantity = 2
};
ConstraintHelper.mockProductStock.Setup(x => x.GetProductForCityId(1, 1, 2)).Returns(Task.FromResult(productDto));
ConstraintHelper.mockBasket.Setup(x => x.GetOrCreateBasketId(ConstraintHelper.UserId)).Returns(Task.FromResult(basketId));
ConstraintHelper.mockBasketProduct.Setup(x => x.AddToBasket(basketProductEntity));
ConstraintHelper.mockBasketProduct.Setup(x => x.BeginTransaction()).Returns(ConstraintHelper.mockContextTransaction.Object);
ConstraintHelper.mockProductStock.Setup(x => x.UpdateStock(1, 8));
var service = new BasketService(ConstraintHelper.mockBasketProduct.Object, ConstraintHelper.mockBasket.Object, ConstraintHelper.mockProductStock.Object, ConstraintHelper.mockUnitOfWork.Object, ConstraintHelper.mockLogger.Object);
var actual = service.AddToBasket(ConstraintHelper.UserId, requestDto);
Assert.AreEqual(true, actual.Result.IsSuccess);
Assert.AreEqual(AddToBasketReturnTypes.Success, actual.Result.ResponseCode);
}
/// <summary>
/// Add a <see cref="Product"/> to an existing <see cref="Basket"/>.
/// </summary>
/// <param name="basket">The <see cref="Basket"/> to add a <see cref="Product"/> too.</param>
/// <param name="productToAdd">The new <see cref="Product"/> for the <paramref name="basket"/>.</param>
/// <param name="quantity">The quantity of <see cref="Product"/> for the <paramref name="basket"/>.</param>
/// <returns>The <see cref="Basket"/>.</returns>
public Basket AddProductToBasket(Basket basket, Product productToAdd, int quantity)
{
var basketProduct = new BasketProduct {
Basket = basket, Product = productToAdd, Quantity = quantity
};
basket.Products.Add(basketProduct);
this._persistence.Change(basket);
this._persistence.Commit();
return(basket);
}
public IHttpActionResult PostBasket(BasketProduct basketProduct)
{
Basket basket = new Basket();
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!ProductInBundle(basketProduct.ProductID, basketProduct.BundleID))
{
basketProduct = new BasketProduct();
BasketProduct error = new BasketProduct();
return(CreatedAtRoute("DefaultApi", new { id = basketProduct.ID }, basketProduct));
}
if (BasketProductsCompleted(basketProduct.BasketID, basketProduct.BundleID))
{
basketProduct = new BasketProduct();
BasketProduct error = new BasketProduct();
return(CreatedAtRoute("DefaultApi", new { id = basketProduct.ID }, basketProduct));
}
if (basketProduct.BasketID == 0)
{
basket.Date = DateTime.Now;
basket.Complete = false;
db.Baskets.Add(basket);
db.SaveChanges();
basketProduct.BasketID = basket.ID;
}
else
{
basket = db.Baskets.Where(b => b.ID == basketProduct.BasketID).FirstOrDefault();
}
db.BasketProducts.Add(basketProduct);
db.SaveChanges();
List <BasketProduct> lstbasketProduct = db.BasketProducts.Where(b => b.BundleID == basketProduct.BundleID).ToList();
List <BundleProduct> lstbundleProduct = db.BundleProducts.Where(b => b.BundleID == basketProduct.BundleID).ToList();
basket.Complete = GetBasketStatus(lstbasketProduct, lstbundleProduct);
PutBasket(basket.ID, basket);
basketProduct.basket = basket;
return(CreatedAtRoute("DefaultApi", new { id = basketProduct.ID }, basketProduct));
}
public void TestCreateBasket()
{
var product = new BasketProduct {
ProductId = 1
};
var baskets = new List <Basket>();
this._fakePersistence.Setup(p => p.Add(It.IsAny <Basket>())).Callback <Basket>(baskets.Add);
this._target.CreateBasket(product);
Assert.IsTrue(baskets.Any());
}
//[OutputCache(Location = System.Web.UI.OutputCacheLocation.None)] //типо откл кэщ
public ActionResult Products(string Mark = "", string Price = "")
{
ViewBag.App_name = L_Resources.LocolizationResource.LOGO;
if (Mark == "" && Price == "")
{
if (Session["ListProduct"] != null)
{
var tmp = VerifyOnValid((Session["ListProduct"] as List <BasketProduct>), "0");
ViewBag.ListProduct = (Session["ListProduct"] as List <BasketProduct>);
}
return(View());
}
if (Session["ListProduct"] == null)
{
Session["ListProduct"] = new List <BasketProduct>()
{
new BasketProduct {
ShortName = Mark.Split('-')[0], Marks = Mark.Split('-')[1], Price = Convert.ToDecimal(Price), Count = 1
}
};
ViewBag.ListProduct = (Session["ListProduct"] as List <BasketProduct>);
return(View());
}
else
{
var t = (Session["ListProduct"] as List <BasketProduct>);
BasketProduct ss = t.Where(x => x.Marks == Mark.Split('-')[1]).FirstOrDefault();
var s1 = t.Where(x => x.Marks == Mark.Split('-')[1]);
var s11 = s1.Where(x => x.ShortName == Mark.Split('-')[0]).FirstOrDefault();
if (s11 != null)
{
if (s11.Count < 1)//maby isn't need
{
t.Remove(s11);
ss.Count += 1;
t.Add(s11);
}
}
else
{
t.Add(new BasketProduct {
ShortName = Mark.Split('-')[0], Marks = Mark.Split('-')[1], Price = Convert.ToDecimal(Price), Count = 1
});
}
Session["ListProduct"] = t;
ViewBag.ListProduct = t;
}
return(View());
}
/// <summary>
/// Creates a new basketProduct object and adds it to the BasketProduct table
/// </summary>
/// <param name="id">Primary Key value of product</param>
/// <param name="quantity">Quantity of product</param>
/// <param name="basketID">Composite Key value</param>
/// <returns>New basketProduct added to table</returns>
public async Task AddBasketProduct(int id, int quantity, int basketID)
{
Product product = await _context.Products.FirstOrDefaultAsync(p => p.ID == id);
BasketProduct basketProduct = new BasketProduct
{
Product = product,
ProductID = product.ID,
Quantity = quantity,
BasketID = basketID
};
_context.BasketProducts.Add(basketProduct);
await _context.SaveChangesAsync();
}
public async Task <IActionResult> Update(int id, int quantity)
{
string userEmail = User.Identity.Name;
var userRaw = await _userManager.FindByEmailAsync(userEmail);
string userID = userRaw.Id;
var basket = await _basket.GetBasketByUserId(userID);
BasketProduct basketProduct = await _basketProduct.GetBasketProductByID(basket.ID, id);
basketProduct.Quantity = quantity;
await _basketProduct.UpdateQuantity(basketProduct);
return(RedirectToAction("Index", "BasketProduct"));
}
private async Task AddProductToBasketAndIncreaseBasketTotalPrice(BasketProduct basketProduct,
UserBasketDto basket, AddProductCommand request)
{
if (basketProduct != null)
{
basketProduct.Quantity += request.Product.Quantity;
}
else
{
basket.Products.Add(request.Product);
}
basket.TotalPrice += (request.Product.Price * request.Product.Quantity);
await basketRedisService.SaveBasket(request.UserId, basket);
}
public BasketProduct BasketProdUpdate(BasketProductOption bskProdOption, int bskProdId)
{
BasketProduct basketProduct = db.BasketProducts.Find(bskProdId);
if (bskProdOption.ProdQuantity > 0)
{
basketProduct.ProdQuantity = bskProdOption.ProdQuantity;
}
else if (bskProdOption.ProdQuantity == 0)
{
RemoveProduct(bskProdId);
}
db.SaveChanges();
return(basketProduct);
}
public async Task <int> AddProduct(BasketId id, BasketProduct basketProduct)
{
Validator.Begin(basketProduct, nameof(basketProduct))
.NotDefault()
.ThrowApiException(nameof(BasketService), nameof(AddProduct));
var basket = await _repository.Get(id);
if (basket == null)
{
basket = new Basket(id, new EmptyBasketState(_config.GetMaxBasketSize()));
}
basket.Add(basketProduct);
await _repository.Save(basket);
return(await _uow.SaveAsync());
}
/// <summary>
/// The given <see cref="BasketProduct"/> is no longer required so take it out of the <see cref="M:BasketProduct.Basket"/>
/// </summary>
/// <param name="basketProductToRemove">The <see cref="BasketProduct"/> to remove.</param>
/// <returns>The <see cref="Basket"/> as it now stands.</returns>
public Basket RemoveFromBasket(BasketProduct basketProductToRemove)
{
var basketId = basketProductToRemove.BasketId;
this._persistence.Remove(basketProductToRemove);
this._persistence.Commit();
var basket = this._persistence.Find(
new PersistenceSearcher<Basket>(b => b.Id == basketId));
return basket;
}
/// <summary>
/// The given <see cref="BasketProduct"/> has changed so update it.
/// </summary>
/// <param name="basketProductToRemove">The <see cref="BasketProduct"/> to update.</param>
/// <returns>The <see cref="Basket"/> as it now stands.</returns>
public Basket UpdateBasket(BasketProduct basketProductToRemove)
{
this._persistence.Change(basketProductToRemove);
this._persistence.Commit();
var basket = this._persistence.Find(
new PersistenceSearcher<Basket>(b => b.Id == basketProductToRemove.BasketId));
return basket;
}
