public double CalcDiscount(PurchaseBasket basket)
{
if (mergeType == CommonStr.DiscountMergeTypes.OR)
{
double sum_discounts = 0;
foreach (DiscountPolicy child in children)
{
sum_discounts += child.CalcDiscount(basket);
}
return(sum_discounts);
}
else if (mergeType == CommonStr.DiscountMergeTypes.XOR)
{
double maxDiscount = 0;
foreach (DiscountPolicy child in children)
{
double discount = child.CalcDiscount(basket);
if (discount > maxDiscount)
{
maxDiscount = discount;
}
}
return(maxDiscount);
}
else if (mergeType == CommonStr.DiscountMergeTypes.AND)
{
return(0);
}
else
{
return(0);
}
}
public ActionResult _AddPurchaseUnit(int id)
{
PurchaseBasket basket = GetPurchaseBasket();
Stock stock = _stockService.GetStock(id);
var ru = new PurchaseUnit
{
Stock = stock,
StockId = id,
PurchasedDate = basket.StartDate,
//UnitId = basket.PurchasedUnits.NextIndex(c => c.UnitId),
RetailCost = stock.Model.RetailPrice,
CustomerAccountId = basket.CustomerAccountId
};
if ((ru.Stock.ProductLifeCycleStatus.ProductLifeCycleActions & ProductLifeCycleActions.CanBeSold) != ProductLifeCycleActions.CanBeSold)
{
return(ReturnJsonError("Unit selected is not available. Status is : " + ru.Stock.ProductLifeCycleStatus.Description));
}
if (basket.PurchasedUnits.Any(u => u.StockId == id))
{
return(ReturnJsonFormSuccess());
}
basket.PurchasedUnits.Add(ru);
AddContractsToUnits(basket);
UpdateBasket(basket);
return(ReturnJsonFormSuccess());
}
public bool IsFulfilledProductPriceAboveEqXDiscount(PurchaseBasket basket, int productId, double minPrice)
{
if (basket.Store.Inventory.InvProducts.ContainsKey(productId))
{
return(basket.Store.Inventory.InvProducts[productId].Item1.Price >= minPrice);
}
return(false);
}
public bool IsFufillledMinProductUnitDiscount(PurchaseBasket basket, int productId, int minUnits)
{
if (basket.products.ContainsKey(productId))
{
return(basket.products[productId] >= minUnits);
}
return(false);
}
public ActionResult AddPurchaseUnitStep1(PurchaseBasketVM mBasketVM)
{
PurchaseBasket basket = GetPurchaseBasket();
basket.StartDate = mBasketVM.StartDate;
UpdateBasket(basket);
return(RedirectToAction(Stepper2.NextStep()));
}
public bool IsFulfilledMaxUnitsOfProductPurchase(PurchaseBasket basket, int productId, int maxAmount)
{
if (!basket.Products.ContainsKey(productId))
{
return(true);
}
return(basket.Products[productId] <= maxAmount);
}
private void SetPurchaseBasketUnitsLifeCycle(PurchaseBasket purchaseBasket, ProductLifeCycleStatus productLifeCycleStatus)
{
if (purchaseBasket.PurchasedUnits == null)
{
return;
}
SetPurchaseStockLifeCycle(purchaseBasket.PurchasedUnits, productLifeCycleStatus);
}
public void TestRevealedDiscount1()
{
cart.AddProduct(store, 1, 10, false);
PurchaseBasket basket = cart.GetBasket(store);
DiscountPolicy discountplc = new RevealdDiscount(1, 30);
double discount = discountplc.CalcDiscount(basket);
double expected = 30000;
Assert.AreEqual(expected, discount);
}
public void TestBasketPurchasePolicy_NoCondtion()
{
cart.AddProduct(store, 2, 2, false);
cart.AddProduct(store, 3, 2, false);
PurchaseBasket basket = cart.GetBasket(store);
PurchasePolicy purchaseplc = new BasketPurchasePolicy(pre: preConditionsDict[CommonStr.PurchasePreCondition.allwaysTrue]);
bool eligiblePurchase = purchaseplc.IsEligiblePurchase(basket);
Assert.AreEqual(true, eligiblePurchase);
}
public bool IsFulfilledMinItemAtBasketPurchase(PurchaseBasket basket, int minItems)
{
int totalamount = 0;
foreach (int amount in basket.Products.Values)
{
totalamount += amount;
}
return(totalamount >= minItems);
}
public bool IsFulfilledMinUnitsAtBasketDiscount(PurchaseBasket basket, int minUnits)
{
int count = 0;
foreach (int amount in basket.products.Values)
{
count += amount;
}
return(count >= minUnits);
}
public void TestBasketPurchasePolicy_MaxBasketPriceInValid()
{
cart.AddProduct(store, 2, 2, false);
cart.AddProduct(store, 3, 2, false);
PurchaseBasket basket = cart.GetBasket(store);
PurchasePolicy purchaseplc = new BasketPurchasePolicy(maxBasketPrice: 100, pre: preConditionsDict[CommonStr.PurchasePreCondition.MaxBasketPrice]);
bool eligiblePurchase = purchaseplc.IsEligiblePurchase(basket);
Assert.AreEqual(false, eligiblePurchase);
}
public double GetBasketPriceWithDiscount(PurchaseBasket basket)
{
Logger.logEvent(this, System.Reflection.MethodBase.GetCurrentMethod());
double basketPrice = GetBasketOrigPrice(basket);
double overallDiscount = DiscountPolicy.CalcDiscount(basket);
double priceAfterDiscount = basketPrice - overallDiscount;
return(priceAfterDiscount);
}
public void TestConditionalDiscount_BasketPrdouctPriceAboveX()
{
cart.AddProduct(store, 1, 2, false);
cart.AddProduct(store, 2, 2, false);
PurchaseBasket basket = cart.GetBasket(store);
DiscountPolicy discountplc = new ConditionalBasketDiscount(preCondition: preConditionsDict[CommonStr.DiscountPreConditions.BasketProductPriceAboveEqX], discount: 10, minProductPrice: 10000);
double discount = discountplc.CalcDiscount(basket);
double expected = 2000;
Assert.AreEqual(expected, discount);
}
public void TestSimpleByUser()
{
cart.AddProduct(store, 3, 2, false);
PurchaseBasket basket = cart.GetBasket(store);
basket.User = "******";
PurchasePolicy purchaseplc = new UserPurchasePolicy(preConditionsDict[CommonStr.PurchasePreCondition.OwnerCantBuy]);
bool eligiblePurchase = purchaseplc.IsEligiblePurchase(basket);
Assert.AreEqual(false, eligiblePurchase);
}
public void TestSimpleByBasket1_MinAmountInValid()
{
cart.AddProduct(store, 1, 10, false);
cart.AddProduct(store, 2, 1, false);
cart.AddProduct(store, 3, 3, false);
PurchaseBasket basket = cart.GetBasket(store);
PurchasePolicy purchaseplc = new ProductPurchasePolicy(minAmount: 11, pre: preConditionsDict[CommonStr.PurchasePreCondition.MinUnitsOfProductType], productId: 1);
bool eligiblePurchase = purchaseplc.IsEligiblePurchase(basket);
Assert.AreEqual(false, eligiblePurchase);
}
public void TestConditialDiscount_MinUnitsOfProductX()
{
cart.AddProduct(store, 1, 6, false);
cart.AddProduct(store, 2, 2, false);
PurchaseBasket basket = cart.GetBasket(store);
DiscountPolicy discountplc = new ConditionalProductDiscount(preCondition: preConditionsDict[CommonStr.DiscountPreConditions.NumUnitsOfProductAboveEqX], discount: 10, minUnits: 5, productId: 1);
double discount = discountplc.CalcDiscount(basket);
double expected = 6000;
Assert.AreEqual(expected, discount);
}
public void TestConditionalDiscount_MinItemsAtBasket()
{
cart.AddProduct(store, 1, 1, false);
cart.AddProduct(store, 2, 2, false);
PurchaseBasket basket = cart.GetBasket(store);
DiscountPolicy discountplc = new ConditionalBasketDiscount(preCondition: preConditionsDict[CommonStr.DiscountPreConditions.NumUnitsInBasketAboveEqX], discount: 20, minUnitsAtBasket: 2);
double discount = discountplc.CalcDiscount(basket);
double expected = 1090 * 2;
Assert.AreEqual(expected, discount);
}
public void TestConditionalDiscoun_NoDiscount()
{
cart.AddProduct(store, 1, 2, false);
cart.AddProduct(store, 2, 2, false);
PurchaseBasket basket = cart.GetBasket(store);
DiscountPolicy discountplc = new ConditionalBasketDiscount(preCondition: preConditionsDict[CommonStr.DiscountPreConditions.NoDiscount], discount: 0);
double discount = discountplc.CalcDiscount(basket);
double expected = 0;
Assert.AreEqual(expected, discount);
}
public override bool IsEligiblePurchase(PurchaseBasket basket)
{
if (PreCondition.preCondNumber == CommonStr.PurchasePreCondition.OwnerCantBuy)
{
return(PreCondition.IsFulfilledOwnerCantBuyPurchase(basket.User, basket.Store.Id));
}
else
{
return(false);
}
}
public void TestBasketPurchasePolicy_MinItemPerBasketValid()
{
cart.AddProduct(store, 1, 2, false);
cart.AddProduct(store, 2, 2, false);
cart.AddProduct(store, 3, 2, false);
PurchaseBasket basket = cart.GetBasket(store);
PurchasePolicy purchaseplc = new BasketPurchasePolicy(minItems: 6, pre: preConditionsDict[CommonStr.PurchasePreCondition.MinItemsAtBasket]);
bool eligiblePurchase = purchaseplc.IsEligiblePurchase(basket);
Assert.AreEqual(true, eligiblePurchase);
}
public override bool IsEligiblePurchase(PurchaseBasket basket)
{
if (PreCondition.preCondNumber == CommonStr.PurchasePreCondition.StoreMustBeActive)
{
return(PreCondition.IsFulfilledStoreMustBeActivePurchase(StoreId));
}
else
{
return(false);
}
}
public ActionResult AddPurchaseUnitStep4() //Setup Item Charges
{
PurchaseBasket purchaseAcc = GetPurchaseBasket();
if (purchaseAcc.OneOffItems == null || purchaseAcc.OneOffItems.Count == 0)
{
purchaseAcc.OneOffItems = InitiateOneOffItems(c => c.PurchaseDefault);
}
purchaseAcc.OneOffItems.ForEach(o => o.Quantity = purchaseAcc.PurchasedUnits.Count);
return(View(GetPurchaseBasketVM()));
}
public void TestSimpleBySystem1_Valid()
{
cart = new Cart("liav");
cart.AddProduct(store, 1, 7, false);
PurchaseBasket basket = cart.GetBasket(store);
PurchasePolicy purchaseplc = new SystemPurchasePolicy(preConditionsDict[CommonStr.PurchasePreCondition.StoreMustBeActive], 100);
store.ActiveStore = false;
bool eligiblePurchase = purchaseplc.IsEligiblePurchase(basket);
Assert.AreEqual(false, eligiblePurchase);
}
public double CalcDiscount(PurchaseBasket basket)
{
double reduction = 0;
if (basket.Products.ContainsKey(discountProdutId))
{
int numProducts = basket.Products[discountProdutId];
double price = basket.Store.GetProductDetails(discountProdutId).Item1.Price;
reduction = numProducts * ((discount / 100) * price);
}
return(reduction);;
}
public Tuple <bool, string> CheckIsValidBasket(PurchaseBasket basket)
{
Logger.logEvent(this, System.Reflection.MethodBase.GetCurrentMethod());
//checks if the basket accomodate the store's purchase policy
if (!PurchasePolicy.IsEligiblePurchase(basket))
{
Logger.logEvent(this, System.Reflection.MethodBase.GetCurrentMethod(), CommonStr.StoreErrorMessage.BasketNotAcceptPurchasePolicy);
return(new Tuple <bool, string>(false, CommonStr.StoreErrorMessage.BasketNotAcceptPurchasePolicy));
}
return(Inventory.isValidBasket(basket.Products));
}
public override ActionResult AddUnitBasket(int customerAccountId)
{
var basket = new PurchaseBasket {
CustomerAccountId = customerAccountId
};
_accountService.AddBasket(basket);
_accountService.CommitChanges();
BasketId = basket.BasketId;
BuildPurchaseAccountStepper();
return(RedirectToAction(Stepper2.FirstStep()));
}
public bool IsEligiblePurchase(PurchaseBasket basket)
{
if (mergeType == CommonStr.PurchaseMergeTypes.AND)
{
foreach (PurchasePolicy child in children)
{
if (!child.IsEligiblePurchase(basket))
{
return(false);
}
}
return(true);
}
else if (mergeType == CommonStr.PurchaseMergeTypes.OR)
{
foreach (PurchasePolicy child in children)
{
if (child.IsEligiblePurchase(basket))
{
return(true);
}
}
return(false);
}
else if (mergeType == CommonStr.PurchaseMergeTypes.XOR)
{
// assuming xor accept only 2 inputs at most!
if (children.Count == 0)
{
return(true);
}
if (children.Count > 2)
{
return(false);
}
if (children.Count == 1)
{
return(children[0].IsEligiblePurchase(basket));
}
if (children.Count == 2)
{
bool firstRes = children[0].IsEligiblePurchase(basket);
bool secondRes = children[1].IsEligiblePurchase(basket);
return(firstRes & !secondRes || secondRes & !firstRes);
}
return(false);
}
else
{
return(false);
}
}
public bool IsFulfilledMinUnitsOfProductTypePurchase(PurchaseBasket basket, int productId, int minAmount)
{
if (minAmount == 0)
{
return(true);
}
if (!basket.Products.ContainsKey(productId))
{
return(false);
}
return(basket.Products[productId] >= minAmount);
}
public override bool IsEligiblePurchase(PurchaseBasket basket)
{
if (PreCondition.preCondNumber == CommonStr.PurchasePreCondition.MinUnitsOfProductType)
{
return(PreCondition.IsFulfilledMinUnitsOfProductTypePurchase(basket, ProductId, MinAmount));
}
else if (PreCondition.preCondNumber == CommonStr.PurchasePreCondition.MaxUnitsOfProductType)
{
return(PreCondition.IsFulfilledMaxUnitsOfProductPurchase(basket, ProductId, MaxAmount));
}
else
{
return(false);
}
}
