private void setValues(PurchasingLimits_V01 l, PurchasingLimitRestrictionPeriod period, decimal maxValue)
{
l.RestrictionPeriod = period;
l.maxVolumeLimit = l.RemainingVolume = maxValue;
l.LimitsRestrictionType = LimitsRestrictionType.PurchasingLimits;
}
public override void SetLimits(int orderMonth, IPurchaseRestrictionManager manager, PurchasingLimits_V01 limits)
{
if (manager.PurchasingLimits == null)
{
manager.PurchasingLimits = new Dictionary <int, PurchasingLimits_V01>();
}
var FOPlimits = GetFOPLimits(manager);
if (FOPlimits != null && FOPlimits.maxVolumeLimit != -1 && !FOPlimits.Completed)
{
manager.PurchasingLimits[orderMonth] = CopyPurchasingLimits(FOPlimits);
}
else
{
manager.PurchasingLimits[orderMonth] = CopyPurchasingLimits(limits);
}
switch (manager.PurchasingLimits[orderMonth].LimitsRestrictionType)
{
// Purchasing Limits
case LimitsRestrictionType.PurchasingLimits:
{
PurchaseRestrictionProvider.SetValues(manager.PurchasingLimits[orderMonth], HLConfigManager.Configurations.DOConfiguration.PurchasingLimitRestrictionPeriod, manager.PurchasingLimits[orderMonth].PurchaseLimitType);
}
break;
default:
// FOP and OT is volume
PurchaseRestrictionProvider.SetValues(manager.PurchasingLimits[orderMonth], PurchasingLimitRestrictionPeriod.OneTime, manager.PurchasingLimits[orderMonth].maxVolumeLimit > -1 ? PurchaseLimitType.Volume : PurchaseLimitType.None);
break;
}
}
private ShoppingCartRuleResult performRules(MyHLShoppingCart cart, ShoppingCartRuleResult Result, PurchasingLimits_V01 currentlimits)
{
if (!GetPurchaseRestrictionManager(cart.DistributorID).CanPurchase)
{
cart.ItemsBeingAdded.Clear();
Result.AddMessage(
string.Format(
HttpContext.GetGlobalResourceObject(
string.Format("{0}_ErrorMessage", HLConfigManager.Platform), "CantBuy").ToString()));
Result.Result = RulesResult.Failure;
return(Result);
}
if (cart.ItemsBeingAdded == null || cart.ItemsBeingAdded.Count == 0)
{
return(Result);
}
bool bCanPurchasePType = CanPurchasePType(cart.DistributorID);
var errors = new List <string>();
decimal NewVolumePoints = decimal.Zero;
decimal cartVolume = cart.VolumeInCart;
bool bLimitExceeded = false;
List <string> skuToAdd = new List <string>();
foreach (var item in cart.ItemsBeingAdded)
{
var currentItem = CatalogProvider.GetCatalogItem(item.SKU, Country);
if (currentItem == null)
{
continue;
}
if (!bCanPurchasePType)
{
if (currentItem.ProductType == ServiceProvider.CatalogSvc.ProductType.Product)
{
Result.Result = RulesResult.Failure;
errors.Add(
string.Format(
HttpContext.GetGlobalResourceObject(
string.Format("{0}_Rules", HLConfigManager.Platform),
"PurchaseLimitTypeProductCategory").ToString(), item.SKU));
continue;
}
}
if (currentlimits.PurchaseLimitType == PurchaseLimitType.Volume)
{
if (currentlimits.maxVolumeLimit == -1)
{
skuToAdd.Add(item.SKU);
continue;
}
NewVolumePoints += currentItem.VolumePoints * item.Quantity;
if (currentlimits.RemainingVolume - (cartVolume + NewVolumePoints) < 0)
{
Result.Result = RulesResult.Failure;
if (currentlimits.LimitsRestrictionType == LimitsRestrictionType.FOP)
//MPE FOP
{
string processingCountryCode = DistributorProfileModel.ProcessingCountryCode;
///Order exceeds the allowable volume for First Order Program. The Volume on the order needs to be reduced by {0:F2} VPs. The following SKU(s) have not been added to the cart.
if (!bLimitExceeded) // to add this message only once
{
if (currentlimits.PurchaseType == OrderPurchaseType.Consignment)
{
errors.Add(
string.Format(
HttpContext.GetGlobalResourceObject(
string.Format("{0}_Rules", HLConfigManager.Platform),
"FOPConsignmentVolumePointExceeds").ToString(), 1100, PurchaseRestrictionProvider.GetVolumeLimitsAfterFirstOrderFOP(processingCountryCode), PurchaseRestrictionProvider.GetThresholdPeriod(processingCountryCode)));
}
else if (currentlimits.PurchaseType == OrderPurchaseType.PersonalConsumption)
{
errors.Add(
string.Format(
HttpContext.GetGlobalResourceObject(
string.Format("{0}_Rules", HLConfigManager.Platform),
"FOPPersonalConsumptionVolumePointExceeds").ToString(), 1100, PurchaseRestrictionProvider.GetThresholdPeriod(processingCountryCode)));
}
else
{
errors.Add(
string.Format(
HttpContext.GetGlobalResourceObject(
string.Format("{0}_Rules", HLConfigManager.Platform),
"FOPVolumePointExceeds").ToString(), 1100,
PurchaseRestrictionProvider.GetVolumeLimitsAfterFirstOrderFOP(
processingCountryCode),
PurchaseRestrictionProvider.GetThresholdPeriod(processingCountryCode), -999));
// -999 should be replaced with caluclated value.
}
bLimitExceeded = true;
}
/// Item SKU:{0}.
//errors.Add(
// string.Format(
// HttpContext.GetGlobalResourceObject(
// string.Format("{0}_Rules", HLConfigManager.Platform),
// "VolumePointExceedsThreshold").ToString(), item.SKU));
}
else
{
if (cart.CartItems.Exists(i => i.SKU == item.SKU))
{
///The quantity of the item SKU:{0} can not be increased by {1} because it exceeds your volume points limit.
errors.Add(
string.Format(
HttpContext.GetGlobalResourceObject(
string.Format("{0}_Rules", HLConfigManager.Platform),
"VolumePointExceedsByIncreasingQuantity").ToString(),
item.SKU, item.Quantity));
}
else
{
///Item SKU:{0} has not been added to the cart since by adding that into the cart, you exceeded your volume points limit.
errors.Add(
string.Format(
HttpContext.GetGlobalResourceObject(
string.Format("{0}_Rules", HLConfigManager.Platform),
"VolumePointExceeds").ToString(), item.SKU));
}
}
}
else
{
skuToAdd.Add(item.SKU);
}
}
else
{
skuToAdd.Add(item.SKU);
}
}
if (Result.Result == RulesResult.Failure && errors.Count > 0)
{
errors = errors.Select(x => x.Replace("-999", ((cartVolume + NewVolumePoints) - currentlimits.RemainingVolume).ToString())).ToList <string>();
Array.ForEach(errors.ToArray(), a => Result.AddMessage(a));
}
cart.ItemsBeingAdded.RemoveAll(s => !skuToAdd.Contains(s.SKU));
return(Result);
}
/// <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)
{
var dpm = DistributorProfileModel;
CurrentSession = (dpm != null)
? SessionInfo.GetSessionInfo(dpm.Id, Locale)
: SessionInfo.GetSessionInfo(cart.DistributorID, Locale);
string dsid = string.Empty;
if (CurrentSession.IsReplacedPcOrder)
{
dsid = CurrentSession.ReplacedPcDistributorOrderingProfile != null && CurrentSession.ReplacedPcDistributorOrderingProfile.Id != null ? CurrentSession.ReplacedPcDistributorOrderingProfile.Id : cart.DistributorID;
}
else
{
dsid = cart.DistributorID;
}
// OrderTotals_V01 totals = (OrderTotals_V01)(cart as MyHLShoppingCart).Totals;
if (reason == ShoppingCartRuleReason.CartItemsBeingAdded || reason == ShoppingCartRuleReason.CartRetrieved)
{
var Cart = cart as MyHLShoppingCart;
var calcTheseItems = new List <ShoppingCartItem_V01>();
var purchasingLimitManager = PurchasingLimitManager(dsid);
var myhlCart = cart as MyHLShoppingCart;
if (null == myhlCart)
{
LoggerHelper.Error(
string.Format("{0} myhlCart is null {1}", Locale, dsid));
Result.Result = RulesResult.Failure;
return(Result);
}
PurchasingLimits_V01 PurchasingLimits =
PurchasingLimitProvider.GetCurrentPurchasingLimits(dsid);
purchasingLimitManager.SetPurchasingLimits(PurchasingLimits);
if (null == PurchasingLimits)
{
LoggerHelper.Error(
string.Format("{0} PurchasingLimits could not be retrieved for distributor {1}", Locale,
dsid));
Result.Result = RulesResult.Failure;
return(Result);
}
var shoppingCart = cart as MyHLShoppingCart;
if (shoppingCart == null)
{
return(Result);
}
if (PurchasingLimits.MaxPCEarningsLimit == -1)
{
return(Result);
}
DistributorOrderingProfile distributorOrderingProfile = DistributorOrderingProfileProvider.GetProfile(cart.DistributorID, "CN");
if ((CurrentSession.ReplacedPcDistributorOrderingProfile != null && CurrentSession.ReplacedPcDistributorOrderingProfile.IsPC) || (distributorOrderingProfile != null && distributorOrderingProfile.IsPC))
{
if (cart.CurrentItems != null)
{
calcTheseItems.AddRange(from i in cart.CurrentItems
where !APFDueProvider.IsAPFSku(i.SKU)
select
new ShoppingCartItem_V01(i.ID, i.SKU, i.Quantity, i.Updated,
i.MinQuantity));
}
if (cart.CartItems != null)
{
calcTheseItems.AddRange(from i in cart.CartItems
where !APFDueProvider.IsAPFSku(i.SKU)
select
new ShoppingCartItem_V01(i.ID, i.SKU, i.Quantity, i.Updated,
i.MinQuantity));
}
var totals = Cart.Calculate(calcTheseItems, false) as OrderTotals_V01;
//OrderTotals_V01 totals = (OrderTotals_V01)(cart as MyHLShoppingCart).Totals;
if (totals != null && totals.DiscountedItemsTotal > purchasingLimitManager.MaxPersonalPCConsumptionLimit)
{
if (cart.CurrentItems.Count > 0)
{
var sessionInfo = SessionInfo.GetSessionInfo(cart.DistributorID, Locale);
if (sessionInfo != null && sessionInfo.ShoppingCart != null && sessionInfo.ShoppingCart.CurrentItems != null)
{
sessionInfo.ShoppingCart.CurrentItems.RemoveAll(x => x.SKU != null);
}
cart.CurrentItems.RemoveAll(s => s.SKU != null);
}
Result.Result = RulesResult.Failure;
Result.AddMessage(
string.Format(
HttpContext.GetGlobalResourceObject(
string.Format("{0}_Rules", HLConfigManager.Platform),
"ErrorMessageToPCWhenhittheFOPLimits").ToString(),
purchasingLimitManager.MaxPersonalPCConsumptionLimit));
}
else
{
var ruleMessage = cart.RuleResults.FirstOrDefault(x => x.Messages != null && x.Messages.Count > 0 && x.RuleName == "PurchasingLimits Rules");
if (ruleMessage != null)
{
cart.RuleResults.Remove(ruleMessage);
}
}
cart.RuleResults.Add(Result);
}
else
{
decimal DistributorRemainingVolumePoints = 0;
decimal NewVolumePoints = 0;
if (null == myhlCart)
{
LoggerHelper.Error(
string.Format("{0} myhlCart is null {1}", Locale, cart.DistributorID));
Result.Result = RulesResult.Failure;
return(Result);
}
DistributorRemainingVolumePoints = PurchasingLimits.RemainingVolume;
if (cart.CurrentItems != null && cart.CurrentItems.Count > 0)
{
var currentItem = CatalogProvider.GetCatalogItem(cart.CurrentItems[0].SKU, Country);
if (currentItem != null)
{
NewVolumePoints = currentItem.VolumePoints * cart.CurrentItems[0].Quantity;
}
}
if (NewVolumePoints > 0 || purchasingLimitManager.PurchasingLimitsRestriction == PurchasingLimitRestrictionType.MarketingPlan)
{
//if (PurchasingLimits.PurchaseLimitType == PurchaseLimitType.Volume)
{
if (PurchasingLimits.maxVolumeLimit == -1)
{
return(Result);
}
decimal cartVolume = (cart as MyHLShoppingCart).VolumeInCart;
if (DistributorRemainingVolumePoints - (cartVolume + NewVolumePoints) < 0)
{
Result.Result = RulesResult.Failure;
Result.AddMessage(
string.Format(
HttpContext.GetGlobalResourceObject(
string.Format("{0}_Rules", HLConfigManager.Platform),
"VolumePointExceedsThresholdByIncreasingQuantity").ToString(),
purchasingLimitManager.MaxPersonalPCConsumptionLimit));
cart.RuleResults.Add(Result);
//if (purchasingLimitManager.PurchasingLimitsRestriction ==
// PurchasingLimitRestrictionType.MarketingPlan)
// //MPE Thresholds
//{
// if (cart.CartItems.Exists(item => item.SKU == cart.CurrentItems[0].SKU))
// {
// Result.AddMessage(
// string.Format(
// HttpContext.GetGlobalResourceObject(
// string.Format("{0}_Rules", HLConfigManager.Platform),
// "VolumePointExceedsThresholdByIncreasingQuantity").ToString(),
// cart.CurrentItems[0].SKU, cart.CurrentItems[0].Quantity));
// }
//else
//{
// Result.AddMessage(
// string.Format(
// HttpContext.GetGlobalResourceObject(
// string.Format("{0}_Rules", HLConfigManager.Platform),
// "VolumePointExceedsThreshold").ToString(), cart.CurrentItems[0].SKU));
//}
//}
//else
//{
// if (cart.CartItems.Exists(item => item.SKU == cart.CurrentItems[0].SKU))
// {
// Result.AddMessage(
// string.Format(
// HttpContext.GetGlobalResourceObject(
// string.Format("{0}_Rules", HLConfigManager.Platform),
// "VolumePointExceedsByIncreasingQuantity").ToString(),
// cart.CurrentItems[0].SKU, cart.CurrentItems[0].Quantity));
// }
// else
// {
// Result.AddMessage(
// string.Format(
// HttpContext.GetGlobalResourceObject(
// string.Format("{0}_Rules", HLConfigManager.Platform),
// "VolumePointExceeds").ToString(), cart.CurrentItems[0].SKU));
// }
//}
}
}
}
}
}
return(Result);
}
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);
}
public void UpdatePurchasingLimits(PurchasingLimits_V01 limits, int orderMonth)
{
PurchasingLimits[orderMonth] = limits;
SetPurchasingLimits(orderMonth);
}
/// <summary>
/// setValues
/// </summary>
/// <param name="l"></param>
/// <param name="period"></param>
/// <param name="maxValue"></param>
public static void SetValues(PurchasingLimits_V01 l, PurchasingLimitRestrictionPeriod period, PurchaseLimitType limitType)
{
l.RestrictionPeriod = period;
l.PurchaseLimitType = limitType;
}
private void DisplayRemainingValues(string DSSubType, bool Refresh)
{
var limits = new PurchasingLimits_V01();
trRemainingVal.Visible = true;
ShoppingCart.EmailValues.RemainingVolume = string.Empty;
if (string.IsNullOrEmpty(DSSubType))
{
limits = PurchasingLimitProvider.GetCurrentPurchasingLimits(DistributorID);
}
else
{
limits = PurchasingLimitProvider.GetPurchasingLimits(DistributorID, DSSubType);
}
if (FOPEnabled)
{
if (limits != null && limits.LimitsRestrictionType == LimitsRestrictionType.FOP)
{
DisplayRemainingValuesFOP(DistributorID, Refresh, limits);
return;
}
}
if (DSSubType == "RE")
{
trRemainingVal.Visible = false;
OnOrderSubTypeChanged(this,
new OrderSubTypeEventArgs(ddl_DSSubType.SelectedItem.Value, true, false, Refresh));
}
else if (DSSubType == "PC")
{
lblRemainingValDisplay.Text = GetLocalResourceObject("RemainingVolume").ToString();
if (ShoppingCart != null)
{
decimal discountedRetail = (null != ShoppingCart.Totals)
? ShoppingCart.ProductDiscountedRetailInCart
: 0.0M;
decimal remaining = limits.RemainingVolume - discountedRetail;
if (remaining < 0)
{
remaining = 0;
}
lblRemainingVal.Text = limits.PurchaseLimitType == PurchaseLimitType.Volume
? remaining.ToString("N2")
: getAmountString(remaining);
}
OnOrderSubTypeChanged(this,
new OrderSubTypeEventArgs(ddl_DSSubType.SelectedItem.Value, false, true, Refresh));
}
else
{
trRemainingVal.Visible = false;
OnOrderSubTypeChanged(this, new OrderSubTypeEventArgs("NA", true, false, Refresh));
}
if (trRemainingVal.Visible)
{
ShoppingCart.EmailValues.RemainingVolume = lblRemainingVal.Text;
}
}
private void copyPurchasingLimits(PurchasingLimits_V01 source, PurchasingLimits_V01 target)
{
var copy = source.Clone();
}
private void DisplayRemaining(string orderSubType)
{
//string DSType = ProductsBase.LevelSubType;
ShoppingCart.EmailValues.RemainingVolume = string.Empty;
//ShoppingCart.SelectedDSSubType = orderSubType;
PurchasingLimits_V01 limits = PurchasingLimitProvider.GetPurchasingLimits(DistributorID, orderSubType);
decimal cartVolume = 0M;
if (null != limits)
{
if (FOPEnabled)
{
if (limits.PurchaseLimitType == PurchaseLimitType.TotalPaid)
{
cartVolume = TotalsExcludeAPF(ShoppingCart, this.CountryCode);
lblRemainingValDisplay.Text = GetLocalResourceObject("RemainingAmount").ToString();
}
else
{
cartVolume = (limits.LimitsRestrictionType == LimitsRestrictionType.PurchasingLimits) ? ShoppingCart.ProductPromoVolumeInCart : ShoppingCart.VolumeInCart;
}
}
else
{
var purchasingLimitManager = PurchasingLimitManager(this.DistributorID);
cartVolume = (purchasingLimitManager.PurchasingLimitsRestriction == PurchasingLimitRestrictionType.MarketingPlan) ? ShoppingCart.VolumeInCart : ShoppingCart.ProductVolumeInCart;
}
decimal remaining = (limits.RemainingVolume - cartVolume);
if (remaining < 0)
{
remaining = 0;
}
if (limits.PurchaseLimitType == PurchaseLimitType.Volume)
{
lblRemainingVal.Text = ProductsBase.GetVolumePointsFormat(remaining);
}
//else
//{
// lblRemainingVal.Text = ProductsBase.getAmountString(remaining);
//}
}
if (PurchasingLimitProvider.DisplayLimits(DistributorID, CountryCode))
{
if (HasMemberVPLimitations())
{
trRemainingVal.Visible = null != limits ? true : false;
//trRemainingVal.Visible = null != limits &&
// (limits.PurchaseLimitType == PurchaseLimitType.Earnings ||
// limits.PurchaseLimitType == PurchaseLimitType.Volume ||
// limits.PurchaseLimitType == PurchaseLimitType.TotalPaid);
PurchaseLimitType limitType = PurchaseLimitType.Volume;
limits.PurchaseLimitType = limitType;
}
else
{
if (limits.LimitsRestrictionType == LimitsRestrictionType.FOP)
{
trRemainingVal.Visible = null != limits ? true : false; //Show remaining VP when FOP regardless of Limitations
}
else
{
trRemainingVal.Visible = false;
}
}
}
else
{
trRemainingVal.Visible = false;
}
if (trRemainingVal.Visible)
{
ShoppingCart.EmailValues.RemainingVolume = lblRemainingVal.Text;
}
}
public bool PurchasingLimitsAreExceeded(string distributorId, MyHLShoppingCart cart)
{
bool exceeded = false;
if (cart.OrderCategory == OrderCategoryType.HSO)
{
return(exceeded);
}
if (CanPurchase)
{
// PurchasingLimits_V01 limits = PurchasingLimitProvider.GetCurrentPurchasingLimits(distributorId);
PurchasingLimits_V01 limits = GetPurchasingLimits(intOrderMonth(OrderMonth.GetCurrentOrderMonth()));
if (limits == null || cart == null)
{
return(exceeded);
}
if (null != cart.Totals && cart.OrderCategory == OrderCategoryType.ETO)
{
return(exceeded);
}
if (null != limits && limits.LimitsRestrictionType == LimitsRestrictionType.PurchasingLimits && limits.PurchaseLimitType != PurchaseLimitType.None)
{
switch (limits.PurchaseLimitType)
{
case PurchaseLimitType.Earnings:
{
exceeded = limits.NextMaxEarningsLimit > -1 && ((limits.RemainingEarnings - cart.ProductEarningsInCart) < 0);
break;
}
case PurchaseLimitType.Volume:
{
exceeded = limits.maxVolumeLimit > -1 && ((limits.RemainingVolume - cart.ProductVolumeInCart) < 0);
break;
}
case PurchaseLimitType.DiscountedRetail:
{
exceeded = limits.maxVolumeLimit > -1 && ((limits.RemainingVolume - cart.ProductDiscountedRetailInCart) < 0);
break;
}
case PurchaseLimitType.TotalPaid:
{
if (null != cart.Totals)
{
if (APFDueProvider.containsOnlyAPFSku(cart.ShoppingCartItems))
{
return(exceeded);
}
exceeded = limits.maxVolumeLimit > -1 && ((limits.RemainingVolume - (cart.Totals as OrderTotals_V01).AmountDue) < 0);
}
break;
}
}
}
if (null != limits && limits.LimitsRestrictionType != LimitsRestrictionType.PurchasingLimits)
{
exceeded = ((limits.RemainingVolume - cart.VolumeInCart) < 0);
if (exceeded)
{
cart.RuleResults = new List <ShoppingCartRuleResult>();
ShoppingCartRuleResult Result = new ShoppingCartRuleResult();
Result.RuleName = "PurchaseRestriction Rules";
Result.Result = RulesResult.Failure;
Result.AddMessage(string.Format(HttpContext.GetGlobalResourceObject(
string.Format("{0}_Rules", HLConfigManager.Platform),
"FOPVolumePointExceedsOnCheckout").ToString(), 1100, PurchaseRestrictionProvider.GetVolumeLimitsAfterFirstOrderFOP(_processingCountry), PurchaseRestrictionProvider.GetThresholdPeriod(_processingCountry), cart.VolumeInCart - limits.RemainingVolume));
cart.RuleResults.Add(Result);
}
}
else if (exceeded)
{
cart.RuleResults = new List <ShoppingCartRuleResult>();
ShoppingCartRuleResult Result = new ShoppingCartRuleResult();
Result.RuleName = "PurchaseRestriction Rules";
Result.Result = RulesResult.Failure;
Result.AddMessage(string.Format(HttpContext.GetGlobalResourceObject(
string.Format("{0}_Rules", HLConfigManager.Platform),
"RemainingVolumePointExceeds").ToString(), (cart.VolumeInCart - limits.RemainingVolume)));
cart.RuleResults.Add(Result);
}
}
else //member can't purchase
{
if ((cart.Totals as OrderTotals_V01).AmountDue > 0) //can't purchase and there are items in cart
{
exceeded = true;
cart.RuleResults = new List <ShoppingCartRuleResult>();
ShoppingCartRuleResult Result = new ShoppingCartRuleResult();
Result.RuleName = "PurchaseRestriction Rules";
Result.Result = RulesResult.Failure;
Result.AddMessage(string.Format(HttpContext.GetGlobalResourceObject(
string.Format("{0}_ErrorMessage", HLConfigManager.Platform),
"CantBuy").ToString(), 1100, cart.DistributorID));
cart.RuleResults.Add(Result);
}
}
return(exceeded);
}
private void DisplayRemaining()
{
string DSType = ProductsBase.LevelSubType;
ShoppingCart.EmailValues.RemainingVolume = string.Empty;
PurchasingLimits_V01 limits = PurchasingLimitProvider.GetPurchasingLimits(DistributorID, DSType);
ShoppingCart.SelectedDSSubType = !countries.Trim().Contains(Locale.Substring(3)) ? DSType : "";
//var purchasingLimitManager = PurchasingLimitManager(this.DistributorID);
//decimal cartVolume = (purchasingLimitManager.PurchasingLimitsRestriction == PurchasingLimitRestrictionType.MarketingPlan) ? ShoppingCart.VolumeInCart : ShoppingCart.ProductVolumeInCart;
decimal cartVolume = 0M;
if (null != limits)
{
if (FOPEnabled)
{
if (limits.PurchaseLimitType == PurchaseLimitType.TotalPaid)
{
cartVolume = TotalsExcludeAPF(ShoppingCart, this.CountryCode);
lblRemainingValDisplay.Text = GetLocalResourceObject("RemainingAmount").ToString();
}
else
{
cartVolume = (limits.LimitsRestrictionType == LimitsRestrictionType.PurchasingLimits) ? ShoppingCart.ProductPromoVolumeInCart : ShoppingCart.VolumeInCart;
}
}
else
{
var purchasingLimitManager = PurchasingLimitManager(this.DistributorID);
cartVolume = (purchasingLimitManager.PurchasingLimitsRestriction == PurchasingLimitRestrictionType.MarketingPlan) ? ShoppingCart.VolumeInCart : ShoppingCart.ProductVolumeInCart;
}
decimal remaining = (limits.RemainingVolume - cartVolume);
if (remaining < 0)
{
remaining = 0;
}
if (limits.PurchaseLimitType == PurchaseLimitType.Volume)
{
lblRemainingVal.Text = ProductsBase.GetVolumePointsFormat(remaining);
}
else
{
lblRemainingVal.Text = ProductsBase.getAmountString(remaining);
}
}
if (PurchasingLimitProvider.DisplayLimits(DistributorID, CountryCode))
{
trRemainingVal.Visible = null != limits &&
(limits.PurchaseLimitType == PurchaseLimitType.Earnings ||
limits.PurchaseLimitType == PurchaseLimitType.Volume ||
limits.PurchaseLimitType == PurchaseLimitType.TotalPaid);
}
else
{
trRemainingVal.Visible = false;
}
if (trRemainingVal.Visible)
{
ShoppingCart.EmailValues.RemainingVolume = lblRemainingVal.Text;
}
}
public static void UpdatePurchasingLimits(PurchasingLimits_V01 limits, string distributorId, int orderMonth)
{
PurchasingLimitManager(distributorId).UpdatePurchasingLimits(limits, orderMonth);
}
public override void SetLimits(int orderMonth, IPurchaseRestrictionManager manager, PurchasingLimits_V01 limits)
{
if (manager.PurchasingLimits == null)
{
manager.PurchasingLimits = new Dictionary <int, PurchasingLimits_V01>();
}
var FOPlimits = GetFOPLimits(manager);
if (FOPlimits != null && FOPlimits.maxVolumeLimit != -1 && !FOPlimits.Completed)
{
manager.PurchasingLimits[orderMonth] = FOPlimits;
manager.PurchasingLimits[orderMonth].PurchaseLimitType = PurchaseLimitType.Volume;
}
else
{
manager.PurchasingLimits[orderMonth] = limits;
manager.PurchasingLimits[orderMonth].PurchaseLimitType = PurchaseLimitType.DiscountedRetail;
}
}
public static bool checkVolumeLimits(MyHLShoppingCart cart, ref decimal previousVolumePoints, ShoppingCartRuleResult Result, PurchasingLimits_V01 currentLimits, string Locale, string Country, ShoppingCartItem_V01 currentItem)
{
decimal DistributorRemainingVolumePoints = 0;
decimal NewVolumePoints = 0;
if (currentLimits.PurchaseLimitType == PurchaseLimitType.None || currentLimits.LimitsRestrictionType != LimitsRestrictionType.PurchasingLimits)
{
return(true);
}
if (null == currentLimits)
{
return(false);
}
DistributorRemainingVolumePoints = currentLimits.RemainingVolume;
var current = CatalogProvider.GetCatalogItem(currentItem.SKU, Country);
if (current != null)
{
NewVolumePoints = current.VolumePoints * currentItem.Quantity;
}
if (NewVolumePoints > 0)
{
if (currentLimits.maxVolumeLimit == -1)
{
return(true);
}
decimal cartVolume = cart.VolumeInCart + previousVolumePoints;
previousVolumePoints += NewVolumePoints;
if (DistributorRemainingVolumePoints - (cartVolume + NewVolumePoints) < 0)
{
Result.Result = RulesResult.Failure;
var orderMonth = new OrderMonth(Country);
var msg = HttpContext.GetGlobalResourceObject(string.Format("{0}_Rules", HLConfigManager.Platform) ?? string.Empty, "VolumePointExceedsOnOrderMonth") as string;
msg = string.Format(msg, orderMonth.CurrentOrderMonth.ToString("MM-yyyy"), DistributorRemainingVolumePoints);
Result.AddMessage(msg);
cart.RuleResults.Add(Result);
return(false);
}
}
return(true);
}
