protected override ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart, ShoppingCartRuleReason reason, ShoppingCartRuleResult Result) { if (reason == ShoppingCartRuleReason.CartItemsBeingAdded) { var myhlCart = cart as MyHLShoppingCart; if (null == myhlCart) { LoggerHelper.Error( string.Format("{0} myhlCart is null {1}", Locale, cart.DistributorID)); Result.Result = RulesResult.Failure; return(Result); } // to set purchasing limit type var theLimits = GetPurchasingLimits(cart.DistributorID, myhlCart.SelectedDSSubType ?? string.Empty); var currentLimits = theLimits[PurchasingLimitProvider.GetOrderMonth()]; if (currentLimits.PurchaseLimitType == PurchaseLimitType.Earnings) { var itemsToCalc = new List <ShoppingCartItem_V01>(); itemsToCalc.AddRange(myhlCart.CartItems); if (myhlCart.CurrentItems != null && myhlCart.CurrentItems.Count > 0) { itemsToCalc.Add(myhlCart.CurrentItems[0]); } OrderTotals_V01 orderTotals = myhlCart.Calculate(itemsToCalc) as OrderTotals_V01; if (orderTotals != null && orderTotals.DiscountPercentage != 0.0M) { myhlCart.SetDiscountForLimits(orderTotals.DiscountPercentage); myhlCart.Totals = orderTotals; } } } return(base.PerformRules(cart, reason, Result)); }
public override Dictionary <int, PurchasingLimits_V01> GetPurchasingLimits(string distributorId, string TIN) { var currentLimits = base.GetPurchasingLimits(distributorId, TIN); var theLimits = currentLimits[PurchasingLimitProvider.GetOrderMonth()]; var limitsType = PurchaseLimitType.ProductCategory; var codes = new List <string>(CountryType.VN.HmsCountryCodes); codes.Add(CountryType.VN.Key); if (codes.Contains(DistributorProfileModel.ProcessingCountryCode)) { var hasValidTin = HasValidTin(distributorId); //var hasMandatoryNotes = HasMandatoryNotes(distributorId); //if (hasValidTin && !hasMandatoryNotes && DistributorProfileModel.TypeCode.ToUpper().Equals("DS")) if (hasValidTin && DistributorProfileModel.TypeCode.ToUpper().Equals("DS")) { limitsType = PurchaseLimitType.Volume; theLimits.RemainingVolume = MaxVolPoints; } } currentLimits.Values.AsQueryable().ToList().ForEach(pl => pl.PurchaseLimitType = limitsType); return(currentLimits); }
public override Dictionary <int, PurchasingLimits_V01> GetPurchasingLimits(string distributorId, string TIN) { Dictionary <int, PurchasingLimits_V01> currentLimits = base.GetPurchasingLimits(distributorId, TIN); PurchasingLimits_V01 theLimits = currentLimits[PurchasingLimitProvider.GetOrderMonth()]; PurchaseLimitType limitsType = PurchaseLimitType.ProductCategory; var tins = DistributorOrderingProfileProvider.GetTinList(distributorId, true); bool bHasMYID = tins.Find(t => t.IDType.Key == "MYID") != null; if (!DistributorIsExemptFromPurchasingLimits(distributorId)) { limitsType = PurchaseLimitType.Volume; if (!bHasMYID) { limitsType = PurchaseLimitType.ProductCategory; } } else { if (bHasMYID) { limitsType = PurchaseLimitType.None; } } currentLimits.Values.AsQueryable().ToList().ForEach(pl => pl.PurchaseLimitType = limitsType); return(currentLimits); }
private DateTime GetLastQuarterlyCutoff() { int currentOrderMonth = PurchasingLimitProvider.GetOrderMonth(); var lastCutoff = DateTime.MinValue; int month = int.Parse(currentOrderMonth.ToString().Substring(4)); int year = int.Parse(currentOrderMonth.ToString().Substring(0, 4)); switch (month) { case 1: case 2: case 3: { lastCutoff = new DateTime(year - 1, 12, 31, 23, 59, 59); break; } case 4: case 5: case 6: { lastCutoff = new DateTime(year, 3, 31, 23, 59, 59); break; } case 7: case 8: case 9: { lastCutoff = new DateTime(year, 6, 30, 23, 59, 59); break; } case 10: case 11: case 12: { lastCutoff = new DateTime(year, 9, 30, 23, 59, 59); break; } } return(lastCutoff); }
public override Dictionary <int, PurchasingLimits_V01> GetPurchasingLimits(string distributorId, string TIN) { Dictionary <int, PurchasingLimits_V01> currentLimits = base.GetPurchasingLimits(distributorId, TIN); PurchasingLimits_V01 theLimits = currentLimits[PurchasingLimitProvider.GetOrderMonth()]; PurchaseLimitType limitsType = PurchaseLimitType.ProductCategory; var tins = DistributorOrderingProfileProvider.GetTinList(distributorId, true); List <string> codes = new List <string>(CountryType.SG.HmsCountryCodes); codes.Add(CountryType.SG.Key); if (tins != null) { TaxIdentification tid = null; if ((tid = tins.Find(t => t.IDType.Key == "SNID")) != null) { limitsType = PurchaseLimitType.None; } else { // no SNID if (codes.Contains(DistributorProfileModel.ProcessingCountryCode)) { limitsType = PurchaseLimitType.None; } } } // DS with Dummy TIN No "S0000000S", can purchase any category of products up to 1100 vp per order if (tins != null && tins.Find(t => t.ID == "S0000000S") != null) { limitsType = PurchaseLimitType.Volume; theLimits.RemainingVolume = MaxVolPoints; } if (PurchasingLimitProvider.IsRestrictedByMarketingPlan(distributorId)) { limitsType = PurchaseLimitType.Volume; } currentLimits.Values.AsQueryable().ToList().ForEach(pl => pl.PurchaseLimitType = limitsType); return(currentLimits); }
public override Dictionary <int, PurchasingLimits_V01> GetPurchasingLimits(string distributorId, string TIN) { var currentLimits = base.GetPurchasingLimits(distributorId, TIN); var theLimits = currentLimits[PurchasingLimitProvider.GetOrderMonth()]; if (TIN.Equals("ETO")) { TIN = "E"; } theLimits.PurchaseSubType = TIN; if (RetailSubTypes.Contains(theLimits.PurchaseSubType)) { theLimits.PurchaseType = OrderPurchaseType.PersonalConsumption; theLimits.PurchaseLimitType = PurchaseLimitType.DiscountedRetail; } else if (ResaleSubTypes.Contains(theLimits.PurchaseSubType)) { theLimits.PurchaseType = OrderPurchaseType.Consignment; theLimits.PurchaseLimitType = PurchaseLimitType.None; } else { if (PurchasingLimitManager(distributorId).PurchasingLimitsRestriction != PurchasingLimitRestrictionType.MarketingPlan) { theLimits.PurchaseLimitType = PurchaseLimitType.None; if (!ExemptSubTypes.Contains(theLimits.PurchaseSubType)) { LoggerHelper.Error( string.Format( "Unknown Distributor Subtype of \"{0}\" encountered in PurchasingLimitRules for fr-FR, Distributor: {1}", theLimits.PurchaseSubType, distributorId)); } } } return(currentLimits); }
protected override ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart, ShoppingCartRuleReason reason, ShoppingCartRuleResult Result) { if (reason == ShoppingCartRuleReason.CartItemsBeingAdded) { var currentLimits = base.GetPurchasingLimits(cart.DistributorID, string.Empty); var theLimits = currentLimits[PurchasingLimitProvider.GetOrderMonth()]; // If it's threshold volume point for all product types is counted if (PurchasingLimitProvider.IsOrderThresholdMaxVolume(theLimits)) { Result = base.PerformRules(cart, reason, Result); } else if (!DistributorIsExemptFromPurchasingLimits(cart.DistributorID)) { CatalogItem_V01 currentItem = CatalogProvider.GetCatalogItem(cart.CurrentItems[0].SKU, Country); Result = base.PerformRules(cart, reason, Result); } } return(Result); }
public override Dictionary <int, PurchasingLimits_V01> GetPurchasingLimits(string distributorId, string TIN) { Dictionary <int, PurchasingLimits_V01> currentLimits = base.GetPurchasingLimits(distributorId, TIN); PurchasingLimits_V01 theLimits = currentLimits[PurchasingLimitProvider.GetOrderMonth()]; theLimits.PurchaseSubType = TIN; if (PurchasingLimitProvider.IsRestrictedByMarketingPlan(distributorId)) { theLimits.PurchaseLimitType = PurchaseLimitType.Volume; return(currentLimits); } if (DistributorIsExemptFromPurchasingLimits(distributorId)) { theLimits.PurchaseLimitType = PurchaseLimitType.None; } else { theLimits.PurchaseType = OrderPurchaseType.PersonalConsumption; theLimits.PurchaseLimitType = PurchaseLimitType.TotalPaid; } return(currentLimits); }
public override Dictionary <int, PurchasingLimits_V01> GetPurchasingLimits(string distributorId, string TIN) { var currentLimits = base.GetPurchasingLimits(distributorId, TIN); var theLimits = currentLimits[PurchasingLimitProvider.GetOrderMonth()]; //conditional massage of subtype if (TIN.Equals("D") || TIN.Equals("ETO")) { TIN = "D2"; } theLimits.PurchaseSubType = TIN; if (RetailSubTypes.Contains(theLimits.PurchaseSubType)) { theLimits.PurchaseType = OrderPurchaseType.PersonalConsumption; theLimits.PurchaseLimitType = PurchaseLimitType.Volume; } else if (ResaleSubTypes.Contains(theLimits.PurchaseSubType)) { theLimits.PurchaseType = OrderPurchaseType.Consignment; theLimits.PurchaseLimitType = PurchaseLimitType.Earnings; } else { if (!ExemptSubTypes.Contains(theLimits.PurchaseSubType)) { LoggerHelper.Error( string.Format( "Unknown Distributor Subtype of \"{0}\" encountered in PurchasingLimitRules for it-IT, Distributor: {1}", theLimits.PurchaseSubType, distributorId)); } } return(currentLimits); }
public virtual int GetOrderMonth() { return(PurchasingLimitProvider.GetOrderMonth()); }
protected override ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart, ShoppingCartRuleReason reason, ShoppingCartRuleResult Result) { if (reason == ShoppingCartRuleReason.CartItemsBeingAdded) { var currentLimits = base.GetPurchasingLimits(cart.DistributorID, string.Empty); var theLimits = currentLimits[PurchasingLimitProvider.GetOrderMonth()]; // If it's threshold volume point for all product types is counted if (PurchasingLimitProvider.IsOrderThresholdMaxVolume(theLimits)) { Result = base.PerformRules(cart, reason, Result); } else if (!DistributorIsExemptFromPurchasingLimits(cart.DistributorID)) { CatalogItem_V01 currentItem = CatalogProvider.GetCatalogItem(cart.CurrentItems[0].SKU, Country); Result = base.PerformRules(cart, reason, Result); } } if (reason == ShoppingCartRuleReason.CartCreated && cart.CartItems.Any()) { var currentLimits = base.GetPurchasingLimits(cart.DistributorID, string.Empty); var theLimits = currentLimits[PurchasingLimitProvider.GetOrderMonth()]; // If it's threshold volume point for all product types is counted if (PurchasingLimitProvider.IsOrderThresholdMaxVolume(theLimits)) { Result = base.PerformRules(cart, reason, Result); } else if (!DistributorIsExemptFromPurchasingLimits(cart.DistributorID)) { var purchasingLimitManager = PurchasingLimitManager(cart.DistributorID); decimal DistributorRemainingVolumePoints = 0; decimal DistributorRemainingDiscountedRetail = 0; var myhlCart = cart as MyHLShoppingCart; if (null == myhlCart) { LoggerHelper.Error( string.Format("{0} myhlCart is null {1}", Locale, cart.DistributorID)); Result.Result = RulesResult.Failure; return(Result); } PurchasingLimits_V01 PurchasingLimits = PurchasingLimitProvider.GetCurrentPurchasingLimits(cart.DistributorID); purchasingLimitManager.SetPurchasingLimits(PurchasingLimits); if (null == PurchasingLimits) { LoggerHelper.Error( string.Format("{0} PurchasingLimits could not be retrieved for distributor {1}", Locale, cart.DistributorID)); Result.Result = RulesResult.Failure; return(Result); } DistributorRemainingVolumePoints = DistributorRemainingDiscountedRetail = PurchasingLimits.RemainingVolume; if (PurchasingLimits.PurchaseLimitType == PurchaseLimitType.Volume) { if (PurchasingLimits.maxVolumeLimit == -1) { return(Result); } decimal cartVolume = (cart as MyHLShoppingCart).VolumeInCart; if (DistributorRemainingVolumePoints - cartVolume < 0) { Result.Result = RulesResult.Failure; Result.AddMessage( PlatformResources.GetGlobalResourceString("ErrorMessage", "NoCheckoutPurchaseLimitsExceeded")); cart.RuleResults.Add(Result); } } else { Result.Result = RulesResult.Success; } } else { Result = base.PerformRules(cart, reason, Result); } } return(Result); }
public override Dictionary <int, PurchasingLimits_V01> GetPurchasingLimits(string distributorId, string TIN) { if (DistributorIsExemptFromPurchasingLimits(distributorId)) { return(null); } //Fetch these records from Web Service string country = DistributorProfileModel.ProcessingCountryCode; var purchasingLimitManager = PurchasingLimitManager(distributorId); purchasingLimitManager.SetPurchasingLimits(PurchasingLimitProvider.GetOrderMonth()); PurchasingLimits_V01 currentLimits = PurchasingLimitProvider.GetCurrentPurchasingLimits(distributorId); //Get the current Limits if the exist PurchasingLimits_V01 storedLimits = PurchasingLimitProvider.GetPurchasingLimitsFromStore(Country, distributorId); //Get the saved limits for the DS and country PurchasingLimits_V01 theLimits = null; if (null != storedLimits && storedLimits.Id > 0) //Decide if we use the stored limits { storedLimits.MaxEarningsLimit = purchasingLimitManager.MaxEarningsLimit; storedLimits.maxVolumeLimit = purchasingLimitManager.MaxPersonalConsumptionLimit; if (IsBlackoutPeriod() || storedLimits.OutstandingOrders > 0 || PurchasingLimitProvider.GetDistributorPurchasingLimitsSource(Country, distributorId) == DistributorPurchasingLimitsSourceType.InternetOrdering) { theLimits = storedLimits; PurchasingLimitProvider.UpdatePurchasingLimits(theLimits, distributorId); } else { theLimits = currentLimits; } } else { theLimits = currentLimits; } if (null == theLimits) //We're bare and need the DS { theLimits = new PurchasingLimits_V01(); var limit = purchasingLimitManager.ReloadPurchasingLimits(PurchasingLimitProvider.GetOrderMonth()); if (null != currentLimits) //if We're already init'ed resolve against current refreshed DS { if (currentLimits.RemainingVolume > purchasingLimitManager.RemainingPersonalConsumptionLimit) { currentLimits.RemainingVolume = purchasingLimitManager.RemainingPersonalConsumptionLimit; } if (currentLimits.RemainingEarnings > purchasingLimitManager.RemainingEarningsLimit) { currentLimits.RemainingEarnings = purchasingLimitManager.RemainingEarningsLimit; } currentLimits.MaxEarningsLimit = purchasingLimitManager.MaxEarningsLimit; currentLimits.maxVolumeLimit = purchasingLimitManager.MaxPersonalConsumptionLimit; theLimits = currentLimits; theLimits.LastRead = DateTime.UtcNow; } else { //Probably first time in - refresh from DS. theLimits.RemainingVolume = purchasingLimitManager.RemainingPersonalConsumptionLimit; theLimits.RemainingEarnings = purchasingLimitManager.RemainingEarningsLimit; theLimits.MaxEarningsLimit = purchasingLimitManager.MaxEarningsLimit; theLimits.maxVolumeLimit = purchasingLimitManager.MaxPersonalConsumptionLimit; theLimits.LastRead = DateTime.UtcNow; } } if (null == storedLimits) { PurchasingLimitProvider.UpdatePurchasingLimits(theLimits, distributorId, country, true); } else { PurchasingLimitProvider.UpdatePurchasingLimits(theLimits, distributorId, PurchasingLimitProvider.GetOrderMonth()); } var theCurrentLimits = PurchasingLimitProvider.GetCurrentPurchasingLimits(distributorId); var limitsType = PurchaseLimitType.Volume; if (theCurrentLimits.maxVolumeLimit < 0) { limitsType = PurchaseLimitType.None; } purchasingLimitManager.PurchasingLimits.Values.AsQueryable().ToList().ForEach(pl => pl.PurchaseLimitType = limitsType); return(purchasingLimitManager.PurchasingLimits); }
/// <summary> /// The IShoppingCart Rule Interface implementation /// </summary> /// <param name="cart">The current Shopping Cart</param> /// <param name="reason">The Rule invoke Reason</param> /// <param name="Result">The Rule Results collection</param> /// <returns>The cumulative rule results - including the results of this iteration</returns> protected override ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart, ShoppingCartRuleReason reason, ShoppingCartRuleResult Result) { if (reason == ShoppingCartRuleReason.CartItemsBeingAdded) { decimal DistributorRemainingVolumePoints = 0; decimal NewVolumePoints = 0; if (cart.CurrentItems == null || cart.CurrentItems.Count == 0) { Result.Result = RulesResult.Failure; return(Result); } var orderMonth = new OrderMonth(Country); PurchasingLimitManager(cart.DistributorID).SetPurchasingLimits(PurchasingLimitProvider.GetOrderMonth()); var PurchasingLimits = PurchasingLimitProvider.GetCurrentPurchasingLimits(cart.DistributorID); if (null == PurchasingLimits) { LoggerHelper.Error( string.Format("{0} PurchasingLimits could not be retrieved for distributor {1}", Locale, cart.DistributorID)); Result.Result = RulesResult.Failure; return(Result); } DistributorRemainingVolumePoints = PurchasingLimits.RemainingVolume; var currentItem = CatalogProvider.GetCatalogItem(cart.CurrentItems[0].SKU, Country); if (currentItem != null) { if (currentItem.ProductType == ServiceProvider.CatalogSvc.ProductType.EventTicket) { PurchasingLimitProvider.GetPurchasingLimits(cart.DistributorID, "ETO"); } else { NewVolumePoints = currentItem.VolumePoints * cart.CurrentItems[0].Quantity; } } // validate order threshold first if (PurchasingLimits.maxVolumeLimit == -1) { return(Result); } if (PurchasingLimits.PurchaseLimitType == PurchaseLimitType.ProductCategory && currentItem.ProductType == ServiceProvider.CatalogSvc.ProductType.Product) { Result.Result = RulesResult.Failure; Result.AddMessage( string.Format( HttpContext.GetGlobalResourceObject( string.Format("{0}_Rules", HLConfigManager.Platform), "PurchaseLimitTypeProductCategory") as string ?? string.Empty, cart.CurrentItems[0].SKU)); cart.RuleResults.Add(Result); return(Result); } // validate against order threshold first decimal cartVolume = (cart as MyHLShoppingCart).VolumeInCart; if (PurchasingLimitProvider.IsOrderThresholdMaxVolume(PurchasingLimits) || PurchasingLimits.PurchaseLimitType != PurchaseLimitType.None) { if (DistributorRemainingVolumePoints - (cartVolume + NewVolumePoints) < 0) { Result.Result = RulesResult.Failure; string message = string.Empty; if (cart.CartItems.Exists(item => item.SKU == cart.CurrentItems[0].SKU)) { Result.Messages.Add( string.Format( HttpContext.GetGlobalResourceObject( string.Format("{0}_Rules", HLConfigManager.Platform), "VolumePointExceedsThresholdByIncreasingQuantity") as string ?? string.Empty, cart.CurrentItems[0].SKU, cart.CurrentItems[0].Quantity)); } else { Result.Messages.Add( string.Format( HttpContext.GetGlobalResourceObject( string.Format("{0}_Rules", HLConfigManager.Platform), "VolumePointExceedsThreshold") as string ?? string.Empty, cart.CurrentItems[0].SKU)); } if (Result.Messages.Any()) { cart.RuleResults.Add(Result); } else { Result.Result = RulesResult.Success; } return(Result); // if fails, just return } } if (PurchasingLimits.PurchaseLimitType == PurchaseLimitType.ProductCategory) { if (DistributorRemainingVolumePoints - ((cart as MyHLShoppingCart).VolumeInCart + NewVolumePoints) < 0) { Result.Result = RulesResult.Failure; if (cart.CartItems.Exists(item => item.SKU == cart.CurrentItems[0].SKU)) { Result.AddMessage( string.Format( HttpContext.GetGlobalResourceObject( string.Format("{0}_Rules", HLConfigManager.Platform), "VolumePointExceedsThresholdByIncreasingQuantity") as string ?? string.Empty, cart.CurrentItems[0].SKU, cart.CurrentItems[0].Quantity)); } else { Result.AddMessage( string.Format( HttpContext.GetGlobalResourceObject( string.Format("{0}_Rules", HLConfigManager.Platform), "VolumePointExceedsThreshold") as string ?? string.Empty, cart.CurrentItems[0].SKU)); } } } else { Result.Result = RulesResult.Success; } } return(Result); }