private ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart, ShoppingCartRuleReason reason,
ShoppingCartRuleResult Result)
{
//45479, SG:Foreign ds with SNID and foreign DS with dummy tinid are both able to add more than 12 p type products to cart.
if (reason == ShoppingCartRuleReason.CartItemsBeingAdded)
{
List <TaxIdentification> tins = DistributorOrderingProfileProvider.GetTinList(cart.DistributorID, true);
TaxIdentification tid = null;
if (tins != null && (tid = tins.Find(t => t.IDType.Key == "SNID")) != null) // have national ID
{
if (tid.ID == "S0000000S" || !DistributorProfileModel.ProcessingCountryCode.Equals(CountryType.SG.Key))
// dummy TIN and foreign DS
{
if (getPTypeSKUCount(cart.CartItems, cart.CurrentItems[0]) > ForeingDSLines)
{
Result.Result = RulesResult.Failure;
Result.AddMessage(
string.Format(
HttpContext.GetGlobalResourceObject(
string.Format("{0}_Rules", HLConfigManager.Platform), "AnySKUQuantityExceeds")
.ToString(), ForeingDSLines.ToString()));
cart.RuleResults.Add(Result);
return(Result);
}
}
}
}
return(Result);
}
private ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart,
ShoppingCartRuleReason reason,
ShoppingCartRuleResult Result)
{
if (reason == ShoppingCartRuleReason.CartItemsBeingAdded)
{
try
{
if (!CanPurchase(cart.DistributorID, Country))
{
Result.Result = RulesResult.Failure;
Result.AddMessage(
HttpContext.GetGlobalResourceObject(
string.Format("{0}_Rules", HLConfigManager.Platform), "CantPurchase").ToString());
cart.RuleResults.Add(Result);
}
}
catch (Exception ex)
{
LoggerHelper.Error(
string.Format(
"Error while performing Add to Cart Rule for Peruvian distributor: {0}, Cart Id:{1}, \r\n{2}",
cart.DistributorID, cart.ShoppingCartID, ex));
}
}
return(Result);
}
/// <summary>
/// Performs shopping cart rules.
/// </summary>
/// <param name="cart">The cart.</param>
/// <param name="reason">The reason.</param>
/// <param name="result">The result.</param>
/// <returns></returns>
private ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart, ShoppingCartRuleReason reason, ShoppingCartRuleResult result)
{
var hlCart = cart as MyHLShoppingCart;
if (cart == null || hlCart == null)
{
return(result);
}
switch (reason)
{
case ShoppingCartRuleReason.CartItemsBeingAdded:
// Avoid the DS adds the promo sku to the cart
if (cart.CurrentItems[0].SKU.Equals(PromoSKU))
{
cart.CurrentItems.Clear();
}
break;
case ShoppingCartRuleReason.CartItemsBeingRemoved:
hlCart.IsPromoDiscarted = cart.CurrentItems[0].SKU.Equals(PromoSKU) ? true : hlCart.IsPromoDiscarted;
break;
case ShoppingCartRuleReason.CartItemsAdded:
case ShoppingCartRuleReason.CartItemsRemoved:
hlCart.IsPromoDiscarted = (reason == ShoppingCartRuleReason.CartItemsAdded) ? false : hlCart.IsPromoDiscarted;
if (!hlCart.IsPromoDiscarted)
{
result = CheckPromoInCart(cart, hlCart, result);
}
break;
}
return(result);
}
private ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart, ShoppingCartRuleReason reason, ShoppingCartRuleResult Result)
{
if (cart == null)
{
return(Result);
}
var myhlCart = cart as MyHLShoppingCart;
if (myhlCart == null)
{
return(Result);
}
if (reason == ShoppingCartRuleReason.CartItemsAdded || reason == ShoppingCartRuleReason.CartItemsRemoved ||
reason == ShoppingCartRuleReason.CartCalculated || reason == ShoppingCartRuleReason.CartCreated)
{
//check volume in cart and the quantity of todays magazine sku
myhlCart.TodaysMagaZineQuantity = AllowedTodaysMagazineQuantity(myhlCart.VolumeInCart);
var tmSku = (from i in myhlCart.ShoppingCartItems
where i.SKU == HLConfigManager.Configurations.DOConfiguration.TodayMagazineSku
select i).FirstOrDefault();
if (tmSku != null)
{
if (tmSku.Quantity > myhlCart.TodaysMagaZineQuantity)
{
myhlCart.DeleteTodayMagazine(tmSku.SKU);
myhlCart.AddTodayMagazine(myhlCart.TodaysMagaZineQuantity, tmSku.SKU);
}
}
}
return(Result);
}
private ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart,
ShoppingCartRuleReason reason,
ShoppingCartRuleResult result)
{
if (reason == ShoppingCartRuleReason.CartItemsBeingAdded)
{
string TodaysMagazineAllowedLoales = Settings.GetRequiredAppSetting("TodaysMagazineAllowedLocales", "");
if (cart.CurrentItems[0].SKU != HLConfigManager.Configurations.DOConfiguration.TodayMagazineSku && !TodaysMagazineAllowedLoales.Contains(cart.Locale))
{
result = CheckForInvalidSKU(cart, result);
result = CheckForInvalidQuantity(cart, result);
}
}
else if (reason == ShoppingCartRuleReason.CartBeingClosed)
{
//for non-mobile clients, need to do all the usual cleanup done by web
CleanupCart(cart as MyHLShoppingCart);
}
else if (reason == ShoppingCartRuleReason.CartItemsAdded)
{
if (HLConfigManager.Configurations.DOConfiguration.CheckSKUExpirationDate)
{
GetMessagesForEntireCart(cart, result);
}
}
return(result);
}
protected virtual ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart,
ShoppingCartRuleResult result,
ShoppingCartRuleReason reason)
{
//Do the rules
if (null == cart.RuleResults)
{
cart.RuleResults = new List <ShoppingCartRuleResult>();
}
else if (reason == ShoppingCartRuleReason.CartItemsBeingAdded)
{
if (_iEventTicketProviderLoader == null)
{
_iEventTicketProviderLoader = new EventTicketProviderLoader();
}
return(CartItemBeingAddedRuleHandler(cart, result));
}
else if (reason == ShoppingCartRuleReason.CartRetrieved)
{
return(CartRetrievedRuleHandler(cart, result));
}
return(result);
}
private ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart,
ShoppingCartRuleReason reason,
ShoppingCartRuleResult Result)
{
if (reason == ShoppingCartRuleReason.CartItemsBeingAdded && cart != null)
{
var item = from c in cart.CartItems
from n in cart.CurrentItems
where c.SKU == n.SKU
select c;
if (item.ToList().Count == 0)
{
if (cart.CartItems.Count >= NTSLines)
{
Result.Result = RulesResult.Failure;
Result.AddMessage(
string.Format(
HttpContext.GetGlobalResourceObject(
string.Format("{0}_Rules", HLConfigManager.Platform), "AnySKUQuantityExceeds")
.ToString(), NTSLines.ToString()));
cart.RuleResults.Add(Result);
}
}
}
return(Result);
}
private ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart, ShoppingCartRuleReason reason, ShoppingCartRuleResult result)
{
if (reason == ShoppingCartRuleReason.CartItemsAdded || reason == ShoppingCartRuleReason.CartItemsRemoved ||
reason == ShoppingCartRuleReason.CartCalculated || reason == ShoppingCartRuleReason.CartCreated)
{
if (cart != null)
{
var myHLCart = cart as MyHLShoppingCart;
if (myHLCart != null)
{
var maxQty = GetFTMMaxQuantity(cart);
myHLCart.TodaysMagaZineQuantity = maxQty;
var tmSku = (from i in myHLCart.ShoppingCartItems
where i.SKU == HLConfigManager.Configurations.DOConfiguration.TodayMagazineSku
select i).FirstOrDefault();
if (tmSku != null)
{
if (tmSku.Quantity > maxQty)
{
myHLCart.DeleteTodayMagazine(tmSku.SKU);
myHLCart.AddTodayMagazine(maxQty, tmSku.SKU);
}
}
}
}
}
return(result);
}
private ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart,
ShoppingCartRuleReason reason,
ShoppingCartRuleResult Result)
{
//Nothing defined yet
return(Result);
}
public List <ShoppingCartRuleResult> ProcessPromoInCart(ShoppingCart_V02 cart,
List <string> skus,
ShoppingCartRuleReason reason)
{
var result = new List <ShoppingCartRuleResult>();
var defaultResult = new ShoppingCartRuleResult
{
RuleName = "Promotional Rules",
Result = RulesResult.Unknown
};
if (IsRuleTime())
{
if (reason == ShoppingCartRuleReason.CartItemsBeingRemoved)
{
PromoSKUs = HLConfigManager.Configurations.ShoppingCartConfiguration.PromotionalSku.Split(',').ToList();
var hlCart = cart as MyHLShoppingCart;
if (cart != null && hlCart != null)
{
if (skus.Any(i => PromoSKUs.Contains(i)))
{
hlCart.IsPromoDiscarted = true;
defaultResult.Result = RulesResult.Success;
cart.RuleResults.Add(defaultResult);
}
}
}
}
result.Add(defaultResult);
return(result);
}
/// <summary>
/// Performs shopping cart rules.
/// </summary>
/// <param name="cart">The cart.</param>
/// <param name="reason">The reason.</param>
/// <param name="result">The result.</param>
/// <returns></returns>
private ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart, ShoppingCartRuleReason reason, ShoppingCartRuleResult result)
{
var hlCart = cart as MyHLShoppingCart;
if (cart == null || hlCart == null)
{
return(result);
}
if (!IsRuleTime())
{
return(result);
}
switch (reason)
{
case ShoppingCartRuleReason.CartItemsBeingAdded:
if (cart.CurrentItems[0].SKU == promoSkuZ479 || cart.CurrentItems[0].SKU == promoSkuZ480)
{
cart.CurrentItems.Clear();
}
break;
case ShoppingCartRuleReason.CartItemsAdded:
case ShoppingCartRuleReason.CartItemsRemoved:
result = CheckPromoIncart(hlCart, result, AllowedSKUToAddPromoSKU_Z479, promoSkuZ479);
result = CheckPromoIncart(hlCart, result, AllowedSKUToAddPromoSKU_Z480, promoSkuZ480);
break;
}
return(result);
}
private ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart, ShoppingCartRuleReason reason, ShoppingCartRuleResult result)
{
if (reason == ShoppingCartRuleReason.CartItemsAdded || reason == ShoppingCartRuleReason.CartItemsRemoved ||
reason == ShoppingCartRuleReason.CartCalculated || reason == ShoppingCartRuleReason.CartCreated ||
reason == ShoppingCartRuleReason.CartWarehouseCodeChanged || reason == ShoppingCartRuleReason.CartFreightCodeChanging)
{
if (cart != null)
{
var myHLCart = cart as MyHLShoppingCart;
if (myHLCart != null && myHLCart.DeliveryInfo.Option == ServiceProvider.ShippingSvc.DeliveryOptionType.Shipping)
{
var shippingProvider = ShippingProvider.GetShippingProvider(Country);
//get URB locales GetFreightCodeAndWarehouseFromService
var FCandWH = shippingProvider.GetFreightCodeAndWarehouse(myHLCart.DeliveryInfo.Address);
if (FCandWH != null && FCandWH[0] == "URB")
{
//User Story 229708
//a.Orders under 500.9999 VP = Remains as URB freight code
if (myHLCart.VolumeInCart < URBVP)
{
myHLCart.DeliveryInfo.FreightCode =
myHLCart.FreightCode = "URB";
}
//b.Order above 501.0000 VP = System should be redirected and calculate PMS freight code instead of URB.
else if ((myHLCart.VolumeInCart >= URBVP))
{
myHLCart.DeliveryInfo.FreightCode =
myHLCart.FreightCode = "PMS";
}
}
}
}
}
return(result);
}
private ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart,
ShoppingCartRuleReason reason,
ShoppingCartRuleResult result)
{
if (reason == ShoppingCartRuleReason.CartCalculated)
{
result = CheckForInvalidSKUs(cart, result);
result = CheckForDuplicateSKUs(cart, result);
result = CheckForInvalidQuantities(cart, result);
if (result.Result == RulesResult.Failure)
{
LoggerHelper.Error(string.Join("\r\n", result.Messages.ToArray()));
}
}
//prevent to able to add products blocked by the skuToNoDisplayForNonQualifyMembers and EventId config key
if (reason == ShoppingCartRuleReason.CartItemsBeingAdded)
{
var DSType = DistributorOrderingProfileProvider.CheckDsLevelType(cart.DistributorID, cart.Locale.Substring(3, 2));
if (DSType == ServiceProvider.DistributorSvc.Scheme.Member)
{
string errormessage =
HttpContext.GetGlobalResourceObject("MyHL_ErrorMessage", "PMTypeRestrictOrdering").ToString();
result.AddMessage(errormessage);
result.Result = RulesResult.Failure;
}
else
{
result = checkForConfigBlockedSKU(cart, result);
}
}
return(result);
}
private ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart, ShoppingCartRuleReason reason, ShoppingCartRuleResult Result)
{
if (reason == ShoppingCartRuleReason.CartRetrieved)
{
try
{
if (CanPurchase(cart.DistributorID, Country))
{
MyHLShoppingCart myShoppingCart = ShoppingCartProvider.GetShoppingCart(cart.DistributorID, cart.Locale, true);
if (myShoppingCart != null && myShoppingCart.DeliveryInfo != null && myShoppingCart.DeliveryInfo.Option == ServiceProvider.ShippingSvc.DeliveryOptionType.Shipping)
{
if (myShoppingCart.VolumeInCart > 250M)
{
myShoppingCart.DeliveryInfo.FreightCode =
myShoppingCart.FreightCode = "NOF";
}
else
{
myShoppingCart.DeliveryInfo.FreightCode =
myShoppingCart.FreightCode = "MCF";
}
//ShoppingCartProvider.UpdateShoppingCart(myShoppingCart);
}
}
}
catch (Exception ex)
{
LoggerHelper.Error(string.Format("Error while performing Add to Cart Rule for Macau distributor: {0}, Cart Id:{1}, \r\n{2}", cart.DistributorID, cart.ShoppingCartID, ex.ToString()));
}
}
return(Result);
}
public List <ShoppingCartRuleResult> ProcessCart(ShoppingCartRuleReason reason, MyHLShoppingCart shoppingCart)
{
if (shoppingCart == null)
{
return(null);
}
// if reason is CartCreated
// set parameters
if (reason == ShoppingCartRuleReason.CartCreated)
{
IPurchaseRestrictionManager manager = GetPurchaseRestrictionManager(shoppingCart.DistributorID);
SetPurchaseRestriction(manager.Tins, shoppingCart.OrderMonth, shoppingCart.DistributorID, manager);
}
else if (reason == ShoppingCartRuleReason.CartItemsBeingAdded || reason == ShoppingCartRuleReason.CartBeingPaid || reason == ShoppingCartRuleReason.CartClosed)
{
var result = new List <ShoppingCartRuleResult>();
var defaultResult = new ShoppingCartRuleResult();
defaultResult.RuleName = "PurchaseRestriction Rules";
defaultResult.Result = RulesResult.Unknown;
result.Add(PerformRules(shoppingCart, reason, defaultResult));
return(result);
}
return(shoppingCart.RuleResults);
}
public List <ShoppingCartRuleResult> processCart(MyHLShoppingCart cart,
List <ShoppingCartItem_V01> items,
ShoppingCartRuleReason reason)
{
return(Providers.ShoppingCartProvider.processCart(cart,
items,
reason));
}
private ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart, ShoppingCartRuleReason reason, ShoppingCartRuleResult result)
{
if (reason == ShoppingCartRuleReason.CartItemsBeingAdded)
{
result = CheckQualifiedEventSkus(cart, result);
}
return(result);
}
private ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart, ShoppingCartRuleReason reason, ShoppingCartRuleResult result)
{
if (reason == ShoppingCartRuleReason.CartCreated && cart != null)
{
var myHLCart = cart as MyHLShoppingCart;
validateAndUpdateWH(ref myHLCart);
}
return(result);
}
private ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart,
ShoppingCartRuleReason reason,
ShoppingCartRuleResult Result)
{
if (reason == ShoppingCartRuleReason.CartItemsBeingAdded)
{
var SKUIds = new List <string[]>();
SKUIds.Add(new[] { HLConfigManager.Configurations.DOConfiguration.TodayMagazineSku, "3" });
SKUIds.Add(new[] { "4150", "10" });
if (cart.CurrentItems[0].SKU == HLConfigManager.Configurations.DOConfiguration.TodayMagazineSku)
{
var catItems = CatalogProvider.GetCatalogItems((from c in cart.CartItems
select c.SKU.Trim()).ToList <string>(),
Country);
if (catItems != null)
{
if (!catItems.Any(c => c.Value.ProductType == ProductType.Product))
{
Result.Result = RulesResult.Failure;
Result.AddMessage(
string.Format(
HttpContext.GetGlobalResourceObject(
string.Format("{0}_Rules", HLConfigManager.Platform), "AddProductFirst")
.ToString(), cart.CurrentItems[0].SKU));
cart.RuleResults.Add(Result);
return(Result);
}
}
}
foreach (string[] sku in SKUIds)
{
int quantity = 0;
if (cart.CurrentItems[0].SKU == sku[0])
{
quantity += cart.CurrentItems[0].Quantity;
if (cart.CartItems.Exists(item => item.SKU == sku[0]))
{
quantity += cart.CartItems.Where(item => item.SKU == sku[0]).First().Quantity;
}
if (quantity > Convert.ToInt32(sku[1]))
{
Result.Result = RulesResult.Failure;
Result.AddMessage(
string.Format(
HttpContext.GetGlobalResourceObject(
string.Format("{0}_Rules", HLConfigManager.Platform), "SKUQuantityExceeds")
.ToString(), sku[1], sku[0]));
cart.RuleResults.Add(Result);
}
}
}
}
return(Result);
}
public List <ShoppingCartRuleResult> ProcessCart(ShoppingCart_V02 cart, ShoppingCartRuleReason reason)
{
var result = new List <ShoppingCartRuleResult>();
var defaultResult = new ShoppingCartRuleResult();
defaultResult.RuleName = "SkuLimitation Rules";
defaultResult.Result = RulesResult.Unknown;
result.Add(PerformRules(cart, reason, defaultResult));
return(result);
}
public List <ShoppingCartRuleResult> ProcessCart(ShoppingCart_V02 cart, ShoppingCartRuleReason reason)
{
List <ShoppingCartRuleResult> result = new List <ShoppingCartRuleResult>();
ShoppingCartRuleResult defaultResult = new ShoppingCartRuleResult();
defaultResult.RuleName = "PurchasingPermission Rules";
defaultResult.Result = RulesResult.Unknown;
result.Add(PerformRules(cart, reason, defaultResult));
return(result);
}
protected override ShoppingCartRuleResult PerformRules(MyHLShoppingCart cart,
ShoppingCartRuleReason reason,
ShoppingCartRuleResult Result)
{
///volume on orders placed against the French Polynesia warehouse in Oracle, only warehouses defined in “PFT” inventory org should be considered
if (IsWHOrderForPF(cart))
{
Result = base.PerformRules(cart, reason, Result);
}
return(Result);
}
/// <summary>
/// Process shopping cart rules.
/// </summary>
/// <param name="cart">The cart.</param>
/// <param name="reason">The reason.</param>
/// <returns></returns>
public List <ShoppingCartRuleResult> ProcessCart(ShoppingCart_V02 cart, ShoppingCartRuleReason reason)
{
var result = new List <ShoppingCartRuleResult>();
var defaultResult = new ShoppingCartRuleResult
{
RuleName = "Promotional Rules",
Result = RulesResult.Unknown
};
result.Add(PerformRules(cart, reason, defaultResult));
return(result);
}
private ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart,
ShoppingCartRuleReason reason,
ShoppingCartRuleResult Result)
{
if (reason == ShoppingCartRuleReason.CartItemsBeingAdded ||
reason == ShoppingCartRuleReason.CartItemsBeingRemoved)
{
try
{
if (!CanPurchase(cart.DistributorID, Country))
{
Result.Result = RulesResult.Failure;
Result.AddMessage(
string.Format(
HttpContext.GetGlobalResourceObject(
string.Format("{0}_ErrorMessage", HLConfigManager.Platform),
"CountryOfProcessingOnly").ToString()));
cart.RuleResults.Add(Result);
}
else
{
string key = PaymentsConfiguration.GetPaymentInfoSessionKey(string.Empty, string.Empty);
var items = Session[key] as List <CreditPayment>;
if (null != items)
{
int maxCards = HLConfigManager.Configurations.PaymentsConfiguration.MaxCardsToDisplay;
if (items.Count(p => (!string.IsNullOrEmpty(p.AuthorizationCode))) == maxCards)
{
if (reason == ShoppingCartRuleReason.CartItemsBeingRemoved)
{
cart.CurrentItems.Clear();
}
Result.Result = RulesResult.Failure;
Result.AddMessage(
string.Format(
HttpContext.GetGlobalResourceObject(
string.Format("{0}_ErrorMessage", HLConfigManager.Platform),
"MustDeleteACardToChangeItemsInCart").ToString()));
cart.RuleResults.Add(Result);
}
}
}
}
catch (Exception ex)
{
LoggerHelper.Error(
string.Format(
"Error while performing Add or Delete from Cart Rule for Korean distributor: {0}, Cart Id:{1}, \r\n{2}",
cart.DistributorID, cart.ShoppingCartID, ex));
}
}
return(Result);
}
protected override ShoppingCartRuleResult PerformRules(MyHLShoppingCart cart,
ShoppingCartRuleReason reason,
ShoppingCartRuleResult Result)
{
Result.Result = RulesResult.Success;
if (null == cart)
{
LoggerHelper.Error(
string.Format("{0} cart is null {1}, MyHerbalife3.Ordering.Rules.PurchaseRestriction.JP.PurchaseRestrictionRules.", Locale, cart.DistributorID));
Result.Result = RulesResult.Failure;
return(Result);
}
if (Settings.GetRequiredAppSetting <bool>("EnableJPSKURestriction", false))
{
string orderMonth = SKULimitationProvider.GetOrderMonthString();
if (reason == ShoppingCartRuleReason.CartItemsBeingAdded && cart.ItemsBeingAdded != null && cart.ItemsBeingAdded.Count > 0)
{
var allLimits = SKULimitationProvider.SKUPurchaseRestrictionInfo(cart.DistributorID, orderMonth);
if (allLimits != null)
{
Result = HandleCartItemsBeingAdded(cart, Result, allLimits);
if (Result.Result == RulesResult.Failure)
{
return(Result);
}
}
}
else if (reason == ShoppingCartRuleReason.CartBeingPaid)
{
var allLimits = SKULimitationProvider.SKUPurchaseRestrictionInfo(cart.DistributorID, orderMonth);
if (allLimits != null)
{
Result = HandleCartBeingPaid(cart, Result, allLimits);
if (Result.Result == RulesResult.Failure)
{
return(Result);
}
}
}
else if (reason == ShoppingCartRuleReason.CartClosed) // order placed
{
var allLimits = SKULimitationProvider.SKUPurchaseRestrictionInfo(cart.DistributorID, cart.OrderMonth.ToString());
if (allLimits != null)
{
Result = HandleCartClosed(cart, Result, allLimits);
SKULimitationProvider.SetSKUPurchaseRestrictionInfo(cart.DistributorID, cart.OrderMonth.ToString(), allLimits);
}
}
}
base.PerformRules(cart, reason, Result);
return(Result);
}
private ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart, ShoppingCartRuleReason reason, ShoppingCartRuleResult Result)
{
if (reason == ShoppingCartRuleReason.CartItemsBeingAdded)
{
CatalogItem_V01 currentItem = CatalogProvider.GetCatalogItem(cart.CurrentItems[0].SKU, Country);
try
{
List <string> codes = new List <string>(CountryType.TH.HmsCountryCodes);
codes.Add(CountryType.TH.Key);
bool isCOPThai = codes.Contains(DistributorProfileModel.ProcessingCountryCode);
TaxIdentification tid = null;
var tins = DistributorOrderingProfileProvider.GetTinList(cart.DistributorID, true);
tid = tins.Find(t => t.IDType.Key == "THID");
//Simulate the dummy tin with an foreign DS
//TaxIdentification ti = new TaxIdentification() { CountryCode = "TH", ID = "dummy", IDType = new TaxIdentificationType(dummyTin) };
//ods.Value.TinList.Add(ti);
if (CanPurchase(cart.DistributorID, Country))
{
//Additional Check to allow DS COP = Thai Tin = No TIN, Can place only L and A items
if (IsWithOutTinCode)
{
if (currentItem.ProductType == ProductType.Product)
{
Result.Result = RulesResult.Failure;
Result.AddMessage(HttpContext.GetGlobalResourceObject(string.Format("{0}_Rules", HLConfigManager.Platform), "CantPurchase").ToString());
cart.RuleResults.Add(Result);
}
}
}
else
{
if (IsWithOutTinCode)
{
if (currentItem.ProductType == ProductType.Product)
{
Result.Result = RulesResult.Failure;
Result.AddMessage(HttpContext.GetGlobalResourceObject(string.Format("{0}_Rules", HLConfigManager.Platform), "CantPurchase").ToString());
cart.RuleResults.Add(Result);
}
}
}
}
catch (Exception ex)
{
LoggerHelper.Error(string.Format("Error while performing Add to Cart Rule for Singapore distributor: {0}, Cart Id:{1}, \r\n{2}", cart.DistributorID, cart.ShoppingCartID, ex.ToString()));
}
}
return(Result);
}
private ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart,
ShoppingCartRuleReason reason,
ShoppingCartRuleResult Result)
{
if (reason == ShoppingCartRuleReason.CartItemsBeingAdded)
{
List <string> codes = new List <string>(CountryType.KZ.HmsCountryCodes);
codes.Add(CountryType.KZ.Key);
bool isCOPKZ = codes.Contains(DistributorProfileModel.ProcessingCountryCode);
if (!isCOPKZ)
{
return(Result);
}
if (!HasActiveAppTinCode(cart.DistributorID))
{
try
{
var cartVolume = 0m;
var currentItem = CatalogProvider.GetCatalogItem(cart.CurrentItems[0].SKU, Country);
var myCart = cart as MyHLShoppingCart;
if (myCart != null && !string.IsNullOrEmpty(myCart.VolumeInCart.ToString()))
{
cartVolume = myCart.VolumeInCart;
}
var 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);
}
}
catch (Exception ex)
{
LoggerHelper.Error(
string.Format(
"Error while performing Add to Cart Rule for Belarus distributor: {0}, Cart Id:{1}, \r\n{2}",
cart.DistributorID, cart.ShoppingCartID, ex.ToString()));
}
}
}
return(Result);
}
/// <summary>
/// This rule returns success if the current cart contains Event Tickets
/// </summary>
/// <param name="cart"></param>
/// <param name="reason"></param>
/// <returns></returns>
public List <ShoppingCartRuleResult> ProcessCart(ShoppingCart_V02 cart, ShoppingCartRuleReason reason)
{
var result = new List <ShoppingCartRuleResult>();
var defaultResult = new ShoppingCartRuleResult();
defaultResult.RuleName = "ETO Rules";
defaultResult.Result = RulesResult.Unknown;
if (null != cart)
{
result.Add(PerformRules(cart, defaultResult, reason));
}
return(result);
}
public List <ShoppingCartRuleResult> ProcessCart(ShoppingCart_V02 cart, ShoppingCartRuleReason reason)
{
var result = new List <ShoppingCartRuleResult>();
var defaultResult = new ShoppingCartRuleResult {
RuleName = "APF Rules", Result = RulesResult.Unknown, ApfRuleResponse = new ApfRuleResponse()
};
if (cart != null)
{
result.Add(PerformRules(cart, defaultResult, reason));
}
return(result);
}
protected override ShoppingCartRuleResult PerformRules(MyHLShoppingCart cart,
ShoppingCartRuleReason reason,
ShoppingCartRuleResult Result)
{
var currentlimits = GetCurrentPurchasingLimits(cart.DistributorID, GetCurrentOrderMonth());
if (cart == null || currentlimits == null)
{
return(Result);
}
Result = performRules(cart, Result, currentlimits);
if (cart.ItemsBeingAdded != null && cart.ItemsBeingAdded.Count > 0)
{
if (currentlimits.PurchaseLimitType == PurchaseLimitType.Earnings && cart.OrderSubType == "B1")
{
bool bExceed = false;
List <string> skuToAdd = new List <string>();
var itemsToCalc = new List <ShoppingCartItem_V01>();
itemsToCalc.AddRange(cart.CartItems);
foreach (var item in cart.ItemsBeingAdded)
{
if (bExceed == true)
{
Result = reportError(cart, item, Result);
continue;
}
itemsToCalc.Add(item);
OrderTotals_V01 orderTotals = cart.Calculate(itemsToCalc, false) as OrderTotals_V01;
if (orderTotals != null)
{
decimal earningsInCart = ProductEarningsInCart(itemsToCalc, orderTotals.DiscountPercentage);
if (currentlimits.RemainingEarnings - earningsInCart < 0)
{
bExceed = true;
Result = reportError(cart, item, Result);
}
else
{
skuToAdd.Add(item.SKU);
}
}
}
cart.ItemsBeingAdded.RemoveAll(s => !skuToAdd.Contains(s.SKU));
}
}
return(Result);
}
