private async Task <double> CheckCampaignDiscountAmountAsync(CartDTO cart, CampaignDTO campaignItem)
{
double discountAmount = 0;
IList <CartDetailDTO> cartDetailDTOs = await GetCartDetailsAsync(cart.CartId);
int itemCount = 0;
double totalProductPriceForCategory = 0;
foreach (var item in cartDetailDTOs)
{
ProductDTO productDTO = _mapper.Map <ProductDTO>(await _productEFService.GetProductAsync(item.ProductId));
CategoryDTO categoryDTO = _mapper.Map <CategoryDTO>(await _categoryEFService.GetCategoryAsync(productDTO.CategoryId));
if (categoryDTO.CategoryId == campaignItem.CategoryId)
{
itemCount += item.ProductQuantity;
totalProductPriceForCategory += productDTO.Price * item.ProductQuantity;
}
}
if (itemCount >= campaignItem.Quantity)
{
switch (campaignItem.DiscountType)
{
case DiscountType.Rate:
discountAmount = totalProductPriceForCategory * campaignItem.Discount / 100;
break;
case DiscountType.Amount:
discountAmount = campaignItem.Discount;
break;
default:
break;
}
}
return(discountAmount);
}
public CartDTO GetCartForUser(string userId)
{
var cart = new CartDTO();
using (var context = GenerateContext())
{
var currentCart = GetNewestCartForUser(context, userId);
var cartId = GetCartIdFromCurrentCart(context, userId, currentCart);
cart.UserId = userId;
foreach (var item in context.CartDetails.Where(cd => cd.CartId == cartId).ToList())
{
var product = context.Products.Single(p => p.ProductId == item.ProductId);
var itemData = new CartItem
{
Amount = item.Quantity,
ProductName = product.Name,
ProductId = product.ProductId
};
cart.Cart.Add(itemData);
cart.Total += product.Cost * item.Quantity;
}
}
return(cart);
}
public CartDTO AddToCart(CartDTO cart)
{
//Checando se já existe produto no carrinho
if (cart.Cart.Count(_ => _.Id == cart.Product.Id) <= 0)
{
cart.Cart.Add(new ProductCartDTO()
{
Id = cart.Product.Id,
Name = cart.Product.Name,
Description = cart.Product.Description,
Picture = cart.Product.Picture,
Price = cart.Product.Price,
Qty = 1 //Primeira vez q coloca no carrinho
});
}
else
{
//Adquirindo produto existente no carrinho
var prodInCart = cart.Cart.Where(_ => _.Id == cart.Product.Id).First();
int newQty = prodInCart.Qty + 1;
cart.Cart.Remove(prodInCart);
//Readicionando com a qtd certa
cart.Cart.Add(new ProductCartDTO()
{
Id = cart.Product.Id,
Name = cart.Product.Name,
Description = cart.Product.Description,
Picture = cart.Product.Picture,
Price = cart.Product.Price,
Qty = newQty //Nova qtd
});
}
return(cart);
}
public JsonResult AddToCart(CartDTO cartDTO)
{
if (!ModelState.IsValid)
{
Response.StatusCode = 400;
return(Json(new { }, JsonRequestBehavior.AllowGet));
}
// create cart item from Json object
Cart sc = new Cart();
sc.ProductID = cartDTO.ProductID;
sc.CustomerID = cartDTO.CustomerID;
sc.Quantity = cartDTO.Quantity;
// save changes
using (NorthwindEntities db = new NorthwindEntities())
{
/*if there is a duplicate product id in cart, simply update the quantity
* if (db.Carts.SingleOrDefault(c => c.ProductID == sc.ProductID &&
* c.CustomerID == sc.CustomerID))
* {
* if (cart != null)
* {
* cart.Quantity += cartDTO.Quantity;
* }
* }
* else
* {
* // cart does not exist
* sc.Quantity = cartDTO.Quantity;
* db.Carts.Add(sc);
* }*/
}
return(Json(sc, JsonRequestBehavior.AllowGet));
}
public async Task <CartDTO> RemoveProductFromCart(string cardId, string productId)
{
CartDTO cart = null;
cart = await _cacheRepository.GetItemAsync <CartDTO>("cart-" + cardId);
if (cart == null)
{
cart = new CartDTO()
{
Id = Guid.NewGuid().ToString(),
CreatedDate = DateTime.Now
};
}
else
{
cart.Items.RemoveAll(item => item.Id == productId);
await _cacheRepository.SetItemAsync("cart-" + cardId, cart);
cart.UpdateDate = DateTime.Now;
}
return(cart);
}
public CartDTO ShowCart(Guid userId)
{
using var unit = new UnitOfWork();
var cartsId = unit.Cart.GetAll().Where(x => x.UserId == userId).Select(x => x.ProductsId);
CartDTO cartDTO = new CartDTO();
List <ProductDTO> productsInCart = new List <ProductDTO>();
var products = unit.Products.GetAll();
foreach (var cartId in cartsId)
{
foreach (var product in products)
{
if (product.Id == cartId)
{
productsInCart.Add(new ProductDTO
{
Id = product.Id,
Price = product.Price,
Category = product.Category,
Name = product.Name,
Description = product.Description,
Image = product.Image,
});
cartDTO.Sum += product.Price;
}
}
}
cartDTO.Products = productsInCart;
cartDTO.Id = Guid.NewGuid();
cartDTO.UserId = userId;
return(cartDTO);
}
public CartDTO PostCartDTO(CartDTO item)
{
this.cartBL.SaveCart(item);
return(item);
}
public CartDTO RemoveFromCart(CartDTO cart)
{
return(_productService.RemoveFromCart(cart));
}
public CartDTO AddToCart(CartDTO cart)
{
return(_productService.AddToCart(cart));
}
public async Task <double> GetCouponDiscountAsync(CartDTO cart)
{
CartCouponDTO cartCouponDTO = _mapper.Map <CartCouponDTO>(await _cartEFService.GetCartCouponAsync(cart.CartId));
return(cartCouponDTO.DiscountAmount);
}
private List <DiscountViewModel> CalculateDiscounts(List <ProductItemDTO> productDTOs, CartDTO cart)
{
List <DiscountViewModel> listOfDiscounts = cart.CartItems.Where(x => x.Product.Price * x.Quantity > x.DiscountedPrice).Select(x =>
new DiscountViewModel()
{
Product = x.Product.Description + ": ",
Discount = x.Product.Price * x.Quantity - x.DiscountedPrice
}).ToList();
decimal totalDiscountedPrice = cart.CartItems.Select(x => x.DiscountedPrice).Sum();
if (cart.Total < totalDiscountedPrice)
{
listOfDiscounts.Add(new DiscountViewModel()
{
Product = "Discount on Total: ", Discount = totalDiscountedPrice - cart.Total
});
}
return(listOfDiscounts);
}
public bool DelCartItems(CartDTO item)
{
return(cartDL.DelCartItems(item));
}
public bool RemoveCartItems(CartDTO item)
{
this.cartDL.RemoveCartItem(item);
return(true);
}
protected async Task <bool> AddOrderProduct(CartServiceModel cart, List <ProductDTO> products, CartDTO cartDTO)
{
List <int> productIds = cart.CartProducts.Select(x => x.ProductId).ToList();
for (int i = 0; i < productIds.Count; i++)
{
var productId = productIds[i];
var product = products.FirstOrDefault(x => x.Id == productId && x.IsAvailable);
var cartQuantity = cart.CartProducts.Single(x => x.ProductId == productId).Quantity;
if (!IsValidProduct(product, cartQuantity, productId, i))
{
continue;
}
product.AvailableCount -= cartQuantity;
if (product.AvailableCount == 0)
{
product.IsAvailable = false;
}
var cartProductInCart = DoesCartHaveProduct(cartDTO, productId);
if (cartProductInCart != null)
{
cartProductInCart.Quantity += cartQuantity;
await _unitOfWork.CartProductRepository.UpdateAsync(cartProductInCart);
}
else
{
await _unitOfWork.CartProductRepository.InsertAsync(new CartProductDTO { CartId = cartDTO.Id, ProductId = productId, Quantity = cartQuantity });
}
}
return(_validationDictionary.IsValid);
}
private string BuildCreateCartQuery(CartDTO cart)
{
return(string.Format($@"INSERT INTO Cart (cart_id, customer_id, cart_date, book_id, quantity)
VALUES('{cart.CartId}', '{cart.CustomerId}', '{cart.CartDate}', '{cart.BookId}', {cart.Quantity})"));
}
public IActionResult SaveBrand(CartDTO cartDto)
{
var result = cartService.SaveCart(cartDto);
return(Ok(result));
}
public bool RemoveCartItem(CartDTO item)
{
_context.Cart.Update(item);
_context.SaveChanges();
return(true);
}
public void OnGet()
{
CartDTO = this._checkoutManager.GetCart();
}
public void RequestOrder(CartDTO cart)
{
_StockMovService.RequestOrder(cart);
}
public bool RemoveFromCart(CartDTO item)
{
this.cartBL.RemoveCartItems(item);
return(true);
}
public CartDTO DeleteCartDTO(CartDTO item)
{
this.cartBL.DelCartItems(item);
return(item);
}
private CartProductDTO DoesCartHaveProduct(CartDTO cartDTO, int productId)
{
return(cartDTO.CartProducts.FirstOrDefault(cartProduct => cartProduct.ProductId == productId));
}
public bool SaveCart(CartDTO items)
{
cartDL.AddToCart(items);
return(true);
}
public void Delete(CartDTO entity)
{
throw new NotImplementedException();
}
public async Task <bool> InsertOrderAsync(CartServiceModel cart)
{
try
{
await _unitOfWork.BeginTransactionAsync();
var products = await _unitOfWork.ProductRepository.GetAllAsyncWithTracking();
var users = await _unitOfWork.UserRepository.GetAllAsyncWithNoTracking();
var user = users.FirstOrDefault(x => x.Id == cart.UserId);
if (user == null)
{
_validationDictionary.AddError("UserId", "შეყვანილი იუზერი არ არსებობს!");
return(false);
}
var doesUserHaveCart = DoesUserHaveActiveCart(user.Id);
CartDTO newCart;
if (doesUserHaveCart == null)
{
newCart = new CartDTO {
UserId = cart.UserId,
};
await _unitOfWork.CartRepository.InsertAsync(newCart);
}
else
{
newCart = doesUserHaveCart;
}
if (!await AddOrderProduct(cart, products.ToList(), newCart))
{
await _unitOfWork.RollbackAsync();
return(false);
}
await _unitOfWork.SaveChangesAsync();
if (doesUserHaveCart == null)
{
var jobId = BackgroundJob.Schedule(() => DeleteCart(newCart.Id),
TimeSpan.FromMinutes(_config.GetValue <int>("CartOptions:CartExpireTimeInMinute")));
newCart.JobId = jobId;
await _unitOfWork.SaveChangesAsync();
}
await _unitOfWork.CommitAsync();
return(true);
}
catch (Exception)
{
await _unitOfWork.RollbackAsync();
throw;
}
}
public async Task <double> GetDeliveryCostAsync(CartDTO cart)
{
List <DeliveryDTO> deliveryDTOs = _mapper.Map <List <DeliveryDTO> >(await _cartEFService.GetCartDeliveriesAsync(cart.CartId));
return(deliveryDTOs.Sum(d => d.Cost));
}
public async Task OnGet()
{
CategoryDTO categoryDTO = new CategoryDTO()
{
Tittle = "Food2"
};
Category category = new Category(_mapper, _categoryEFService);
categoryDTO.CategoryId = await category.CreateNewCategoryAsync(categoryDTO);
ProductDTO productAppleDTO = new ProductDTO()
{
CategoryId = categoryDTO.CategoryId,
Price = 100,
Tittle = "Apple"
};
ProductDTO productAlmondDTO = new ProductDTO()
{
CategoryId = categoryDTO.CategoryId,
Price = 150,
Tittle = "Almond"
};
Product product = new Product(_mapper, _productEFService);
productAppleDTO.ProductId = await product.CreateProductAsync(productAppleDTO);
productAlmondDTO.ProductId = await product.CreateProductAsync(productAlmondDTO);
Cart cart = new Cart(_cartEFService, _mapper, _productEFService, _categoryEFService);
CartDetailDTO cartDetailDTO1 = new CartDetailDTO()
{
ProductId = productAlmondDTO.ProductId,
ProductQuantity = 3
};
CartDetailDTO cartDetailDTO2 = new CartDetailDTO()
{
ProductId = productAppleDTO.ProductId,
ProductQuantity = 1
};
CartDTO cartDTO = new CartDTO()
{
CustomerId = 1
};
cartDTO.CartId = await cart.CreateCartAsync(cartDTO);
await cart.AddItemAsync(cartDTO.CartId, productAppleDTO, 3);
List <CampaignDTO> campaigns = new List <CampaignDTO>();
CampaignDTO campaignDTO1 = new CampaignDTO()
{
CategoryId = categoryDTO.CategoryId,
Discount = 20,
DiscountType = DiscountType.Rate,
Quantity = 3
};
CampaignDTO campaignDTO2 = new CampaignDTO()
{
CategoryId = categoryDTO.CategoryId,
Discount = 50,
DiscountType = DiscountType.Rate,
Quantity = 5
};
CampaignDTO campaignDTO3 = new CampaignDTO()
{
CategoryId = categoryDTO.CategoryId,
Discount = 5,
DiscountType = DiscountType.Amount,
Quantity = 5
};
Campaign campaign = new Campaign(_mapper, _campaignEFService);
campaignDTO1.CampaignId = await campaign.CreateCampaignAsync(campaignDTO1);
campaignDTO2.CampaignId = await campaign.CreateCampaignAsync(campaignDTO2);
campaignDTO3.CampaignId = await campaign.CreateCampaignAsync(campaignDTO3);
campaigns.Add(campaignDTO1);
campaigns.Add(campaignDTO2);
campaigns.Add(campaignDTO3);
await cart.ApplyCampaignDiscountAsync(cartDTO, campaigns);
CouponDTO couponDTO = new CouponDTO()
{
Discount = 10,
DiscountType = ECommerce.Business.Models.DiscountType.Rate,
MinimumCartCost = 100
};
Coupon coupon = new Coupon(_mapper, _couponEFService);
couponDTO.CouponId = await coupon.CreateNewCouponAsync(couponDTO);
await cart.ApplyCouponDiscountAsync(cartDTO, couponDTO);
Delivery delivery = new Delivery(_deliveryEFService, _cartEFService, _productEFService, _categoryEFService, _mapper);
double costPerDelivery = _configuration.GetValue <double>("CostPerDelivery");
double costPerProduct = _configuration.GetValue <double>("CostPerProduct");
double fixedCost = _configuration.GetValue <double>("FixedCost");
double deliveryCost = await delivery.CalculateDeliveryCostAndCountAsync(cartDTO.CartId, costPerDelivery, costPerProduct, fixedCost);
double cartAmount = await cart.GetTotalAmountAfterDiscountsAsync(cartDTO);
double couponDiscount = await cart.GetCouponDiscountAsync(cartDTO);
double campaignDiscount = await cart.GetCampaignDiscountAsync(cartDTO);
double getDeliveryCost = await delivery.GetDeliveryCostAsync(cartDTO);
IList <PrintModel> printModels = await cart.PrintAsync(cartDTO);
}
private UserContextDTO BuildResponseDTO(List <PendingReviewDTO> pendingReviews, CartDTO pendingCart)
{
UserContextDTO response = new UserContextDTO();
response.PendingsReviewDTO = pendingReviews;
response.PendingCart = pendingCart;
return(response);
}
public IActionResult AddCartProduct([FromBody] CartDTO cartPoduct)
{
_CartContext.AddProduct(cartPoduct.cartIdentifier, cartPoduct.ProductId, cartPoduct.Quantity);
return(Ok());
}
public async Task <double> GetCampaignDiscountAsync(CartDTO cart)
{
List <CartCampaignDTO> cartCampaignList = _mapper.Map <List <CartCampaignDTO> >(await _cartEFService.GetCartCampaignAsync(cart.CartId));
return(cartCampaignList.Sum(cc => cc.DiscountAmount));
}
