public override bool PurchasingLimitsAreExceeded(string distributorId)
{
if (PurchasingLimitProvider.IsRestrictedByMarketingPlan(distributorId))
{
return(base.PurchasingLimitsAreExceeded(distributorId));
}
return(false);
}
public void ReloadPurchasingLimits(string distributorID)
{
try
{
if (PurchasingLimitProvider.IsRestrictedByMarketingPlan(distributorID))
{
CreatePurchasingLimits(GetDistributorPurchasingLimitsCollection());
}
if (PurchasingLimits != null)
{
SaveToCache();
}
}
catch (Exception ex)
{
LoggerHelper.Error(ex.ToString());
}
}
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)
{
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);
}
protected override ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart, ShoppingCartRuleReason reason, ShoppingCartRuleResult Result)
{
decimal NewVolumePoints = 0m;
decimal cartVolume = 0m;
if (reason == ShoppingCartRuleReason.CartItemsBeingAdded)
{
CatalogItem_V01 currentItem = CatalogProvider.GetCatalogItem(cart.CurrentItems[0].SKU, Country);
if (currentItem == null)
{
return(Result);
}
List <string> codes = new List <string>(CountryType.SG.HmsCountryCodes);
codes.Add(CountryType.SG.Key);
var tins = DistributorOrderingProfileProvider.GetTinList(cart.DistributorID, true);
IPurchasingLimitManager manager = new PurchasingLimitManagerFactory().GetPurchasingLimitManager(cart.DistributorID);
if (!codes.Contains(DistributorProfileModel.ProcessingCountryCode)) // foreign DS
{
//Foreign DS without local National ID they cannot purchase "P" type products.
if (tins != null && tins.Find(t => t.IDType.Key == "SNID") == null)
{
if (currentItem.ProductType == ServiceProvider.CatalogSvc.ProductType.Product)
{
Result.Result = RulesResult.Failure;
Result.AddMessage(HttpContext.GetGlobalResourceObject(string.Format("{0}_Rules", HLConfigManager.Platform), "CantPurchase").ToString());
cart.RuleResults.Add(Result);
return(Result);
}
}
//Foreign DS with local National ID they can purchase P L and A type items.
}
if (PurchasingLimitProvider.IsRestrictedByMarketingPlan(cart.DistributorID))
{
return(base.PerformRules(cart, reason, Result));
}
// 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)
{
MyHLShoppingCart myCart = cart as MyHLShoppingCart;
if (!string.IsNullOrEmpty(myCart.VolumeInCart.ToString()))
{
cartVolume = myCart.VolumeInCart;
}
NewVolumePoints = currentItem.VolumePoints * cart.CurrentItems[0].Quantity;
if (cartVolume + NewVolumePoints > MaxVolPoints)
{
Result.AddMessage(
string.Format(
HttpContext.GetGlobalResourceObject(
string.Format("{0}_Rules", HLConfigManager.Platform), "VolumePointExceeds")
.ToString(), cart.CurrentItems[0].SKU));
Result.Result = RulesResult.Failure;
cart.RuleResults.Add(Result);
return(Result);
}
else
{
return(Result);
}
}
}
return(Result);
}
//protected OrderMonth _orderMonth ;
public virtual Dictionary <int, PurchasingLimits_V01> GetPurchasingLimits(string distributorId, string TIN)
{
try
{
//Fetch these records from Web Service
var purchasingLimitManager = PurchasingLimitManager(distributorId);
if (PurchasingLimitProvider.IsRestrictedByMarketingPlan(distributorId))
{
purchasingLimitManager.PurchasingLimitsRestriction = PurchasingLimitRestrictionType.MarketingPlan;
}
int ordermonth = GetOrderMonth();
purchasingLimitManager.SetPurchasingLimits(ordermonth);
var currentLimits = PurchasingLimitProvider.GetCurrentPurchasingLimits(distributorId);
//Get the current Limits if the exist
var storedLimits = PurchasingLimitProvider.GetPurchasingLimitsFromStore(Country,
distributorId);
//Get the saved limits for the DS and country
PurchasingLimits_V01 theLimits = null;
bool shouldUpdateStore = false;
if (null != currentLimits && null != storedLimits && storedLimits.Id > 0) //Decide if we use the stored limits
{
//if (null == currentLimits)
//{
// currentLimits = storedLimits;
//}
storedLimits.MaxEarningsLimit = currentLimits.MaxEarningsLimit;
storedLimits.maxVolumeLimit = currentLimits.maxVolumeLimit;
if (IsBlackoutPeriod() || storedLimits.OutstandingOrders > 0 ||
PurchasingLimitProvider.GetDistributorPurchasingLimitsSource(Country, distributorId) ==
DistributorPurchasingLimitsSourceType.InternetOrdering)
{
if (HLConfigManager.Configurations.DOConfiguration.PurchasingLimitRestrictionType ==
PurchasingLimitRestrictionType.Quarterly)
{
var lastCutoff = GetLastQuarterlyCutoff();
if (storedLimits.LastRead < lastCutoff)
{
storedLimits = currentLimits;
if (null != storedLimits)
{
PurchasingLimitProvider.UpdatePurchasingLimits(storedLimits, distributorId, true);
}
theLimits = storedLimits;
}
}
else
{
theLimits = storedLimits;
PurchasingLimitProvider.UpdatePurchasingLimits(theLimits, distributorId);
}
}
else
{
theLimits = currentLimits;
shouldUpdateStore = true;
}
}
else
{
theLimits = currentLimits;
}
if (null == theLimits) //We're bare and need the DS
{
theLimits = new PurchasingLimits_V01();
var newLimits =
purchasingLimitManager.ReloadPurchasingLimits(ordermonth) as
PurchasingLimits_V01;
if (newLimits != null)
{
if (null != currentLimits) //if We're already init'ed resolve against current refreshed DS
{
if (currentLimits.RemainingVolume > newLimits.RemainingVolume)
{
currentLimits.RemainingVolume = newLimits.RemainingVolume;
}
if (currentLimits.RemainingEarnings > newLimits.RemainingEarnings)
{
currentLimits.RemainingEarnings = newLimits.RemainingEarnings;
}
currentLimits.MaxEarningsLimit = newLimits.MaxEarningsLimit;
currentLimits.maxVolumeLimit = newLimits.maxVolumeLimit;
theLimits = currentLimits;
theLimits.LastRead = DateTime.UtcNow;
}
else
{
//Probably first time in - refresh from DS.
theLimits.RemainingVolume = newLimits.RemainingVolume;
theLimits.RemainingEarnings = newLimits.RemainingEarnings;
theLimits.MaxEarningsLimit = newLimits.MaxEarningsLimit;
theLimits.maxVolumeLimit = newLimits.maxVolumeLimit;
theLimits.LastRead = DateTime.UtcNow;
}
}
}
if (null == storedLimits || shouldUpdateStore)
{
PurchasingLimitProvider.UpdatePurchasingLimits(theLimits, distributorId, true);
}
else
{
PurchasingLimitProvider.UpdatePurchasingLimits(theLimits, distributorId,
ordermonth);
}
var theCurrentLimits = PurchasingLimitProvider.GetCurrentPurchasingLimits(distributorId);
var limitsType = PurchaseLimitType.Volume;
if (HLConfigManager.Configurations.DOConfiguration.PurchasingLimitRestrictionType ==
PurchasingLimitRestrictionType.MarketingPlan && theCurrentLimits.maxVolumeLimit < 0)
{
limitsType = PurchaseLimitType.None;
}
if (DistributorIsExemptFromPurchasingLimits(distributorId) &&
PurchasingLimitManager(distributorId).PurchasingLimitsRestriction !=
PurchasingLimitRestrictionType.MarketingPlan)
{
limitsType = PurchaseLimitType.None;
}
else
{
limitsType = PurchaseLimitType.Volume;
}
purchasingLimitManager.PurchasingLimits.Values.AsQueryable()
.ToList()
.ForEach(pl => pl.PurchaseLimitType = limitsType);
return(purchasingLimitManager.PurchasingLimits);
}
catch (Exception ex)
{
LoggerHelper.Error(
string.Format(
"Messages:{0},StackTrace:{1},Locale:{2},DistributorId{3},Purchasing Months:{4}",
ex.Message, ex.StackTrace, Locale, distributorId, GetOrderMonth()));
return(null);
}
}
public virtual bool PurchasingLimitsAreExceeded(string distributorId)
{
bool exceeded = false;
if (!PurchasingLimitProvider.RequirePurchasingLimits(distributorId, Country))
{
return(exceeded);
}
var cart = ShoppingCartProvider.GetShoppingCart(distributorId, Locale, true);
PurchasingLimits_V01 limits = null;
if (HLConfigManager.Configurations.DOConfiguration.SaveDSSubType)
{
limits = PurchasingLimitProvider.GetPurchasingLimits(distributorId, cart.SelectedDSSubType);
}
else
{
limits = PurchasingLimitProvider.GetCurrentPurchasingLimits(distributorId);
}
if (null != cart && null != cart.Totals && cart.OrderCategory != ServiceProvider.CatalogSvc.OrderCategoryType.ETO)
{
bool restrictedByMarketingPlan = PurchasingLimitProvider.IsRestrictedByMarketingPlan(distributorId);
if ((null != limits && (limits.PurchaseLimitType != PurchaseLimitType.None) ||
restrictedByMarketingPlan))
{
if (limits.PurchaseType != OrderPurchaseType.Consignment ||
(limits.PurchaseType == OrderPurchaseType.Consignment && cart.OrderSubType == "B1"))
{
if (restrictedByMarketingPlan)
{
limits.PurchaseLimitType = (limits.maxVolumeLimit == -1)
? PurchaseLimitType.None
: PurchaseLimitType.Volume;
}
else
{
limits.PurchaseLimitType = (limits.maxVolumeLimit == -1)
? PurchaseLimitType.None
: limits.PurchaseLimitType;
}
switch (limits.PurchaseLimitType)
{
case PurchaseLimitType.Earnings:
{
exceeded = ((limits.RemainingEarnings - cart.ProductEarningsInCart) < 0);
break;
}
case PurchaseLimitType.Volume:
{
exceeded = ((limits.RemainingVolume - cart.VolumeInCart) < 0);
break;
}
case PurchaseLimitType.DiscountedRetail:
{
exceeded = ((limits.RemainingVolume - cart.ProductDiscountedRetailInCart) < 0);
break;
}
case PurchaseLimitType.TotalPaid:
{
if (null != cart.Totals)
{
exceeded = ((limits.RemainingVolume - (cart.Totals as OrderTotals_V01).AmountDue) < 0);
}
break;
}
}
}
}
//else if (ods.PurchasingLimitsRestriction == PurchasingLimitRestrictionType.MarketingPlan)
//{
// exceeded = ((limits.RemainingVolume - cart.VolumeInCart) < 0);
//}
}
return(exceeded);
}
public virtual bool DistributorIsExemptFromPurchasingLimits(string distributorId)
{
return(!PurchasingLimitProvider.IsRestrictedByMarketingPlan(distributorId));
}
/// <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)
{
if (cart.CurrentItems == null || cart.CurrentItems.Count == 0)
{
Result.Result = RulesResult.Failure;
return(Result);
}
CatalogItem_V01 currentItem = CatalogProvider.GetCatalogItem(cart.CurrentItems[0].SKU, Country);
List <string> codes = new List <string>(CountryType.TH.HmsCountryCodes);
decimal NewVolumePoints = 0m;
decimal cartVolume = 0m;
TaxIdentification tid = null;
string dummyTin = "TH00000000000";
bool isCOPThai = codes.Contains(DistributorProfileModel.ProcessingCountryCode);
var tins = DistributorOrderingProfileProvider.GetTinList(cart.DistributorID, true);
isDummyTin = tins.Find(t => t.ID == dummyTin) != null;
codes.Add(CountryType.TH.Key);
tid = tins.Find(t => t.IDType.Key == "THID");
//COP = Thai Tin = No TIN, Can place only L and A items
//COP Not Thai, No Tin- Can place L & A item
if ((isCOPThai && tid == null) || (!isCOPThai && tid == null && !isDummyTin))
{
if (currentItem.ProductType == ProductType.Product)
{
Result.Result = RulesResult.Failure;
Result.AddMessage(HttpContext.GetGlobalResourceObject(string.Format("{0}_Rules", HLConfigManager.Platform), "CantPurchase") as string);
cart.RuleResults.Add(Result);
}
}
// marketing plan
if (PurchasingLimitProvider.IsRestrictedByMarketingPlan(cart.DistributorID))
{
return(base.PerformRules(cart, reason, Result));
}
if (isCOPThai) //COP Thai
{
if (isDummyTin) //have dummyTIN
{
MyHLShoppingCart myCart = cart as MyHLShoppingCart;
if (!string.IsNullOrEmpty(myCart.VolumeInCart.ToString()))
{
cartVolume = myCart.VolumeInCart;
}
NewVolumePoints = currentItem.VolumePoints * cart.CurrentItems[0].Quantity;
if (cartVolume + NewVolumePoints > MaxVolPoints)
{
Result.AddMessage(string.Format(HttpContext.GetGlobalResourceObject(string.Format("{0}_Rules", HLConfigManager.Platform), "VolumePointExceeds").ToString(), cart.CurrentItems[0].SKU.ToString()));
Result.Result = RulesResult.Failure;
cart.RuleResults.Add(Result);
}
}
}
else
{
//COP Not Thai, Tin =Dummy tin Code – Can place any item (P,L, A and Volume limitation is set 1050 VP per order.)
if (isDummyTin)//have dummyTIN
{
MyHLShoppingCart myCart = cart as MyHLShoppingCart;
if (!string.IsNullOrEmpty(myCart.VolumeInCart.ToString()))
{
cartVolume = myCart.VolumeInCart;
}
NewVolumePoints = currentItem.VolumePoints * cart.CurrentItems[0].Quantity;
if (cartVolume + NewVolumePoints > MaxVolPoints)
{
Result.AddMessage(string.Format(HttpContext.GetGlobalResourceObject(string.Format("{0}_Rules", HLConfigManager.Platform), "VolumePointExceeds").ToString(), cart.CurrentItems[0].SKU.ToString()));
Result.Result = RulesResult.Failure;
cart.RuleResults.Add(Result);
}
}
}
}
return(Result);
}
protected override ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart, ShoppingCartRuleReason reason,
ShoppingCartRuleResult Result)
{
if (reason == ShoppingCartRuleReason.CartItemsBeingAdded)
{
try
{
bool IsWithOutHKID = true;
bool IsForeignDS = false;
var currentItem = CatalogProvider.GetCatalogItem(cart.CurrentItems[0].SKU, Country);
bool IsProduct = currentItem != null && currentItem.ProductType == ProductType.Product;
var codes = new List <string>(CountryType.HK.HmsCountryCodes);
codes.Add(CountryType.HK.Key);
if (codes.Contains(DistributorProfileModel.ProcessingCountryCode))
{
//Local DS
var tins = DistributorOrderingProfileProvider.GetTinList(cart.DistributorID, true);
if (tins.Count > 0)
{
var requiredTins = new List <string>(new[] { "HKID", "HKBL" });
var tin =
(from t in tins from r in requiredTins where t.IDType.Key == r select t).ToList();
if (tin != null && tin.Count > 0)
{
IsWithOutHKID = false;
}
}
}
else
{
//Foreign DS
IsForeignDS = true;
}
//Rule
if (IsWithOutHKID && !IsForeignDS && IsProduct)
{
//DS with COM as HK without HKID OR HKBL can purchase “L” and “A” type items only.
Result.Result = RulesResult.Failure;
Result.AddMessage(
HttpContext.GetGlobalResourceObject(
string.Format("{0}_Rules", HLConfigManager.Platform), "CantPurchase") as string);
cart.RuleResults.Add(Result);
}
if (PurchasingLimitProvider.IsRestrictedByMarketingPlan(cart.DistributorID))
{
return(base.PerformRules(cart, reason, Result));
}
}
catch (Exception ex)
{
LoggerHelper.Error(
string.Format(
"Error while performing Add to Cart Rule for Hong Kong distributor: {0}, Cart Id:{1}, \r\n{2}",
cart.DistributorID, cart.ShoppingCartID, ex));
}
}
return(Result);
}
