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);
}
public void ddlInstallments_SelectedIndexChanged(object sender, EventArgs e)
{
ResetFees();
int fees = CalculateFees();
if (fees > 0)
{
var items = new List <ShoppingCartItem_V01>();
items.Add(new ShoppingCartItem_V01(0, _cards.FeeSKU, fees, DateTime.Now));
_page.ShoppingCart.AddItemsToCart(items);
if (_page.ShoppingCart.RuleResults.Any(r => r.Result == RulesResult.Failure))
{
ddlInstallments.SelectedIndex = 0;
ShoppingCartRuleResult result =
_page.ShoppingCart.RuleResults.FindAll(r => r.Result == RulesResult.Failure).FirstOrDefault();
if (result.RuleName == "PurchasingLimits Rules")
{
lblError.Text =
GetLocalResourceObject("AdditionalInstallmentFeesCausePurchasingLimitOverage") as string;
}
else if (result.RuleName == "SkuLimitation Rules")
{
lblError.Text =
GetLocalResourceObject("AdditionalInstallmentFeesCauseLineItemLimitOverage") as string;
}
else
{
lblError.Text = result.Messages[0];
}
}
_page.ShoppingCart.RuleResults.Clear();
}
onPaymentInfoChanged(this, null);
upInstallments.Update();
}
public void PerformBackorderRules(ShoppingCart_V02 shoppingCart, CatalogItem item)
{
var cart = shoppingCart as MyHLShoppingCart;
if (cart != null && cart.DeliveryInfo != null && item != null)
{
if (item.ProductType != ProductType.Product)
{
if (cart.DeliveryInfo.Option == ServiceProvider.ShippingSvc.DeliveryOptionType.ShipToCourier ||
cart.DeliveryInfo.Option == ServiceProvider.ShippingSvc.DeliveryOptionType.Pickup)
{
if (cart.RuleResults == null)
{
cart.RuleResults = new List <ShoppingCartRuleResult>();
}
var resulst = new ShoppingCartRuleResult();
resulst.AddMessage(
HttpContext.GetGlobalResourceObject(
string.Format("{0}_ErrorMessage", HLConfigManager.Platform), "NoBackOrdersAllowed") as
string);
resulst.Result = RulesResult.Failure;
cart.RuleResults.Add(resulst);
resulst.RuleName = "Back Order";
}
}
}
}
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 CartRetrievedRuleHandler(ShoppingCart_V01 cart,
ShoppingCartRuleResult result)
{
var sessioninfo = SessionInfo.GetSessionInfo(cart.DistributorID, cart.Locale);
var distributorOrderingProfile = DistributorOrderingProfileProvider.GetProfile(cart.DistributorID, "CN");
if (sessioninfo != null && distributorOrderingProfile != null)
{
if (sessioninfo.IsEventTicketMode)
{
if (sessioninfo.IsReplacedPcOrder)
{
var shoppingCart = cart as MyHLShoppingCart;
var items = new List <string>();
if (cart.CartItems != null)
{
items.AddRange(cart.CartItems.Select(item => item.SKU));
}
if (items.Any())
{
if (shoppingCart != null)
{
shoppingCart.DeleteItemsFromCart(items, true);
}
}
}
}
}
return(result);
}
public ShoppingCartRuleResult HandleCartBeingPaid(MyHLShoppingCart cart, ShoppingCartRuleResult Result, List <PurchaseRestrictionInfo> allLimits)
{
var error1 = defaultError1();
var error2 = defaultError2();
List <string> errorList = new List <string>();
List <string> itemsToRemove = new List <string>();
// non formula one
var nonFormulaOneLimits = allLimits.Where(f => !f.Group.Equals(groupFormulaOne));
if (nonFormulaOneLimits != null && nonFormulaOneLimits.Count() > 0)
{
var itemsCannotAdd = (from a in nonFormulaOneLimits.First().SKUInfoList
from b in cart.CartItems
where a.SKU == b.SKU && b.Quantity > a.QuantityAllow
select new { SKU = b, Qty = a.QuantityAllow }
);
// set error message
errorList.AddRange(from c in itemsCannotAdd
select string.Format(error1.ToString(), c.SKU.SKU, 100, c.Qty));
}
// formula one
var formulaOneLimits = allLimits.Where(l => l.Group.Equals(groupFormulaOne));
if (formulaOneLimits != null && formulaOneLimits.Count() > 0)
{
var formulaOneSKUs = formulaOneLimits.First().SKUInfoList;
var formulaOneToAdd = (from a in formulaOneSKUs
from b in cart.CartItems
where a.SKU == b.SKU
select new { SKU = b, Qty = a.QuantityAllow }
);
// exceed formula-1 group limit
if (formulaOneToAdd.Sum(f => f.SKU.Quantity) > formulaOneSKUs.First().QuantityAllow)
{
errorList.Add(
string.Format(
error2.ToString(),
string.Join("と", formulaOneToAdd.Select(x => x.SKU.SKU)),
200,
formulaOneSKUs.First().QuantityAllow)
);
itemsToRemove.AddRange(from c in formulaOneToAdd
select c.SKU.SKU);
}
}
errorList = errorList.Distinct().ToList();
if (errorList.Count > 0)
{
Result.Result = RulesResult.Failure;
Result.RuleName = "PurchaseRestriction Rules";
Array.ForEach(errorList.ToArray(), a => Result.AddMessage(a));
cart.RuleResults.Add(Result);
cart.ItemsBeingAdded.RemoveAll(s => itemsToRemove.Select(a => a).Contains(s.SKU));
}
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);
}
private ShoppingCartRuleResult CheckForHFFSKU(ShoppingCart_V01 shoppingCart, ShoppingCartRuleResult ruleResult)
{
var cart = shoppingCart as MyHLShoppingCart;
if (cart != null)
{
// look for the HFF sku
var itemsToRemove = from item in shoppingCart.CartItems
where item.SKU == HLConfigManager.Configurations.DOConfiguration.HFFHerbalifeSku
select item;
if (itemsToRemove.Count() > 0)
{
var SKUsToRemove = itemsToRemove.Select(s => s.SKU).ToList();
var deleted = ShoppingCartProvider.DeleteShoppingCart(cart, SKUsToRemove);
ruleResult.Result = RulesResult.Failure;
Array.ForEach(SKUsToRemove.ToArray(),
a =>
ruleResult.AddMessage(
string.Format(
"Invalid sku found. DS: {0}, CART: {1}, SKU {2} : removed from cart.",
cart.DistributorID, cart.ShoppingCartID, a)));
// should be a safe removal
Array.ForEach(SKUsToRemove.ToArray(),
a => shoppingCart.CartItems.Remove(shoppingCart.CartItems.Find(x => x.SKU == a)));
// for DistributorShoppingCartItem, have to find match 'cause it may not exist
cart.ShoppingCartItems.RemoveAll(
delegate(DistributorShoppingCartItem x)
{ return(SKUsToRemove.Where(s => s == x.SKU).Count() > 0); });
}
}
return(ruleResult);
}
/// <summary>
/// Porcess the Saved Cart rules.
/// </summary>
/// <param name="cart">The cart.</param>
/// <param name="reason">The reason.</param>
/// <returns></returns>
public List <ShoppingCartRuleResult> ProcessSavedCartManagementRules(ShoppingCart_V02 cart, ShoppingCartRuleReason reason)
{
var result = new List <ShoppingCartRuleResult>();
var defaultResult = new ShoppingCartRuleResult
{
RuleName = "Saved Cart Management Rules",
Result = RulesResult.Unknown
};
var hlCart = cart as MyHLShoppingCart;
if (cart == null || hlCart == null)
{
return(result);
}
// Each time a saved cart or a copy from order is retrieved, check the promo in cart
if (reason == ShoppingCartRuleReason.CartRetrieved)
{
if (hlCart.IsSavedCart || hlCart.IsFromCopy)
{
result.Add(CheckPromoInCart(cart, hlCart, defaultResult));
ShoppingCartProvider.UpdateShoppingCart(hlCart);
}
}
return(result);
}
public List <ShoppingCartRuleResult> ProcessSavedCartManagementRules(ShoppingCart_V02 cart, ShoppingCartRuleReason reason)
{
var result = new List <ShoppingCartRuleResult>();
var defaultResult = new ShoppingCartRuleResult
{
RuleName = "Saved Cart Management Rules",
Result = RulesResult.Unknown
};
if (reason == ShoppingCartRuleReason.CartRetrieved)
{
// Each time a saved cart or a copy from order is retrieved, set the freight code as default
if (cart != null)
{
var shoppingCart = cart as MyHLShoppingCart;
if (shoppingCart != null && (shoppingCart.IsSavedCart || shoppingCart.IsFromCopy))
{
if (shoppingCart.DeliveryInfo != null)
{
//force shipping to have default freight code
if (shoppingCart.DeliveryInfo.Option == ServiceProvider.ShippingSvc.DeliveryOptionType.Shipping)
{
shoppingCart.FreightCode = HLConfigManager.Configurations.ShoppingCartConfiguration.DefaultFreightCode;
shoppingCart.DeliveryInfo.FreightCode = HLConfigManager.Configurations.ShoppingCartConfiguration.DefaultFreightCode;
}
}
}
}
}
return(result);
}
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));
}
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);
}
public ShoppingCartRuleResult checkForConfigBlockedSKU(ShoppingCart_V01 shoppingCart,
ShoppingCartRuleResult ruleResult)
{
if (EventId > 0 && !DistributorOrderingProfileProvider.IsEventQualified(EventId, shoppingCart.Locale))
{
var cart = shoppingCart as MyHLShoppingCart;
List <string> listToHide =
HLConfigManager.Configurations.DOConfiguration.SkuToNoDisplayForNonQualifyMembers.Split(',').ToList();
if (cart != null && listToHide.Contains(cart.CurrentItems[0].SKU))
{
var message = "SKUNotAvailable";
var globalResourceObject =
HttpContext.GetGlobalResourceObject(string.Format("{0}_ErrorMessage", HLConfigManager.Platform),
"SKUNotAvailable");
if (globalResourceObject != null)
{
message = string.Format(globalResourceObject.ToString(), shoppingCart.CurrentItems[0].SKU);
}
ruleResult.AddMessage(message);
ruleResult.Result = RulesResult.Failure;
}
}
return(ruleResult);
}
public ShoppingCartRuleResult CheckForInvalidQuantities(ShoppingCart_V01 shoppingCart,
ShoppingCartRuleResult ruleResult)
{
var cart = shoppingCart as MyHLShoppingCart;
if (cart != null)
{
var invalidKSUList = (from s in cart.CartItems where s.Quantity <= 0 select s.SKU).ToList <string>();
if (invalidKSUList.Count() > 0)
{
cart.DeleteItemsFromCart(invalidKSUList, true);
cart.AddItemsToCart(
(from s in invalidKSUList
select new ShoppingCartItem_V01
{
SKU = s,
Quantity = 1,
Updated = DateTime.Now
}
).ToList(), true
);
ruleResult.Result = RulesResult.Failure;
Array.ForEach(invalidKSUList.ToArray(),
a =>
ruleResult.AddMessage(
string.Format(
"Invalid sku quantity found. DS: {0}, CART: {1}, SKU {2} : quantity updated to 1.",
cart.DistributorID, cart.ShoppingCartID, a)));
}
}
return(ruleResult);
}
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);
}
/// <summary>
/// Porcess the Saved Cart rules.
/// </summary>
/// <param name="cart">The cart.</param>
/// <param name="reason">The reason.</param>
/// <returns></returns>
public List <ShoppingCartRuleResult> ProcessSavedCartManagementRules(ShoppingCart_V02 cart, ShoppingCartRuleReason reason)
{
var result = new List <ShoppingCartRuleResult>();
var defaultResult = new ShoppingCartRuleResult
{
RuleName = "Saved Cart Management Rules",
Result = RulesResult.Unknown
};
var hlCart = cart as MyHLShoppingCart;
if (cart == null || hlCart == null)
{
return(result);
}
// Each time a saved cart or a copy from order is retrieved, check the promo in cart
if (reason == ShoppingCartRuleReason.CartRetrieved)
{
if (hlCart.IsSavedCart || hlCart.IsFromCopy)
{
var isPromoInCart = cart.CartItems != null && cart.CartItems.Any(i => i.SKU.Equals(PromoSku.Sku));
if (isPromoInCart)
{
hlCart.DeleteItemsFromCart(new List <string> {
PromoSku.Sku
}, true);
}
result.Add(CheckPromoInCart(cart, hlCart, defaultResult, false));
ShoppingCartProvider.UpdateShoppingCart(hlCart);
}
}
return(result);
}
protected override ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart, ShoppingCartRuleReason reason,
ShoppingCartRuleResult Result)
{
if (reason == ShoppingCartRuleReason.CartItemsAdded)
{
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);
}
List <TaxIdentification> tins = DistributorOrderingProfileProvider.GetTinList(cart.DistributorID, true);
if (tins != null && tins.Find(t => t.IDType.Key == "OBRT") != null)
{
///Poštovani - ukoliko imate registriran OBRT, možete platisa sa vašom Business karticom ili vašom osobnom kreditnom karticom ukoliko kupnja ne prelazi 5000 HRK. U slučaju da plaćate bankovnim transferom možete platiti sa vašeg Business transakcijskog računa vezanog uz vaš Obrt ili sa vašeg osobnog računa ukoliko kupnja ne prelazi 5000 HRK
Result.Result = RulesResult.Failure;
Result.AddMessage(
string.Format(
HttpContext.GetGlobalResourceObject(
string.Format("{0}_Rules", HLConfigManager.Platform),
"Croatia_SpecialMessage").ToString()));
cart.RuleResults.Add(Result);
}
}
return(base.PerformRules(cart, reason, Result));
}
private ShoppingCartRuleResult CheckForInvalidSKU(ShoppingCart_V01 shoppingCart,
ShoppingCartRuleResult ruleResult)
{
var cart = shoppingCart as MyHLShoppingCart;
if (cart != null)
{
bool isValid = false;
SKU_V01 testThisItem = null;
var validSKUList = CatalogProvider.GetAllSKU(Locale);
if (null != validSKUList)
{
isValid = validSKUList.TryGetValue(cart.CurrentItems[0].SKU, out testThisItem);
if (isValid)
{
isValid = (null != testThisItem.CatalogItem);
}
}
if (!isValid)
{
ruleResult.Result = RulesResult.Failure;
var errorMessage =
HttpContext.GetGlobalResourceObject(string.Format("{0}_Rules", HLConfigManager.Platform),
"SkuIsInvalid") ??
"SKU {0} is not available.";
ruleResult.AddMessage(string.Format(errorMessage.ToString(), cart.CurrentItems[0].SKU));
}
}
return(ruleResult);
}
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)
{
//Nothing defined yet
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);
}
private ShoppingCartRuleResult CartRetrievedRuleHandler(ShoppingCart_V01 cart,
ShoppingCartRuleResult result)
{
var myhlCart = cart as MyHLShoppingCart;
if (null != myhlCart)
{
if (isCheckEventTicket(myhlCart.DistributorID, cart.Locale))
{
if (myhlCart.DeliveryInfo != null)
{
if (
!string.IsNullOrEmpty(
HLConfigManager.Configurations.CheckoutConfiguration.EventTicketFreightCode))
{
myhlCart.DeliveryInfo.FreightCode =
HLConfigManager.Configurations.CheckoutConfiguration.EventTicketFreightCode;
}
if (
!string.IsNullOrEmpty(
HLConfigManager.Configurations.CheckoutConfiguration.EventTicketWarehouseCode))
{
myhlCart.DeliveryInfo.WarehouseCode =
HLConfigManager.Configurations.CheckoutConfiguration.EventTicketWarehouseCode;
}
}
}
}
cart.RuleResults.Add(result);
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
};
var hlCart = cart as MyHLShoppingCart;
if (cart == null || hlCart == null)
{
return(result);
}
// If it's a saved cart or a copy from order, check the promo in cart
if (reason == ShoppingCartRuleReason.CartRetrieved)
{
if (!hlCart.IsPromoDiscarted && (hlCart.IsSavedCart || hlCart.IsFromCopy))
{
result.Add(CheckPromoIncart(hlCart, defaultResult, AllowedSKUToAddPromoSKU_K214, promoSkuK214));
result.Add(CheckPromoIncart(hlCart, defaultResult, AllowedSKUToAddPromoSKU_K215, promoSkuK215));
}
}
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);
}
private ShoppingCartRuleResult CheckForDuplicateSKUs(ShoppingCart_V01 shoppingCart,
ShoppingCartRuleResult ruleResult)
{
var cart = shoppingCart as MyHLShoppingCart;
if (cart != null)
{
var skuGroups = from s in cart.CartItems group s by s.SKU into g select new { SKU = g.Key, Items = g };
foreach (var g in skuGroups)
{
if (g.Items.Count() > 1)
{
cart.DeleteItemsFromCart(new List <string> {
g.SKU
}, true);
ruleResult.Result = RulesResult.Failure;
ruleResult.AddMessage(
string.Format("Duplicate sku found. DS: {0}, CART: {1}, SKU {2} removed from cart.",
cart.DistributorID, cart.ShoppingCartID, g.SKU));
}
}
}
return(ruleResult);
}
private ShoppingCartRuleResult ShippingTemperatureControlled(ShoppingCart_V01 cart,
ShoppingCartRuleResult Result)
{
var SKUIds = new List <string> {
"Q638", "Q639", "Q640", "Q641"
};
if (!SKUIds.Any(s => s == cart.CurrentItems[0].SKU))
{
return(Result);
}
try
{
var x = (from a in APFDueProvider.GetAPFSkuList()
from b in cart.CartItems
from c in SKUIds
where
b.SKU != c && b.SKU != a &&
b.SKU != HLConfigManager.Configurations.DOConfiguration.HFFHerbalifeSku
select b);
if (x.Count() > 0)
{
Result.Result = RulesResult.Feedback;
Result.AddMessage(
string.Format(
"Il codice {0} non può essere ordinato insieme ad altri prodotti. Se hai già inserito altri prodotti nel carrello, rimuovili prima di completare il tuo ordine. La mancata rimozione dal carrello degli altri prodotti comporterà la cancellazione e l'eventuale rimborso dell'ordine stesso",
cart.CurrentItems[0].SKU));
cart.RuleResults.Add(Result);
}
}
catch
{
}
return(Result);
}
private void SetApfRuleResponse(ShoppingCartRuleResult ruleResult, ApfAction action, string sku, string name, TypeOfApf apfType, string message)
{
ruleResult.ApfRuleResponse.Action = action;
ruleResult.ApfRuleResponse.Sku = sku;
ruleResult.ApfRuleResponse.Name = name;
ruleResult.ApfRuleResponse.Type = apfType;
ruleResult.ApfRuleResponse.Message = message;
}
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);
}
private ShoppingCartRuleResult CanCheckout(ref ShoppingCart_V02 cart, ShoppingCartRuleResult result)
{
MyHLShoppingCart myCart = cart as MyHLShoppingCart;
var vp = (myCart.Totals as OrderTotals_V01) != null ? (myCart.Totals as OrderTotals_V01).VolumePoints : getTotalvolumePoints(cart as MyHLShoppingCart, this.Country);
//HAP order is allowed a minimum of 100 VP
if (vp < MIN_VP)
{
result.Result = RulesResult.Failure;
result.AddMessage(HttpContext.GetGlobalResourceObject(
string.Format("{0}_ErrorMessage", HLConfigManager.Platform),
myCart.DsType == Scheme.Member
? "HAPOrderLessVPForMB"
: "HAPOrderLessVP") as string);
}
if (myCart.HAPType == "01")
{
if (vp > MAX_VP)
{
result.Result = RulesResult.Failure;
result.AddMessage(HttpContext.GetGlobalResourceObject(
string.Format("{0}_ErrorMessage", HLConfigManager.Platform),
myCart.DsType == Scheme.Member
? "HAPOrderExceedVPForMB"
: "HAPOrderExceedVP") as string);
}
if (myCart.CartItems != null && myCart.CartItems.Count > 0)
{
foreach (var a in myCart.CartItems)
{
if (globalContext.CultureConfiguration.IsBifurcationEnabled && myCart.DsType == Scheme.Member)
{
if (a.Quantity > 4)
{
result.Result = RulesResult.Failure;
result.AddMessage(HttpContext.GetGlobalResourceObject(
string.Format("{0}_ErrorMessage", HLConfigManager.Platform),
"HAPOrderExceedSKUForMember") as string);
break;
}
}
else if (a.Quantity > 6)
{
result.Result = RulesResult.Failure;
result.AddMessage(HttpContext.GetGlobalResourceObject(
string.Format("{0}_ErrorMessage", HLConfigManager.Platform),
"HAPOrderExceedSKU") as string);
break;
}
}
}
}
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);
}
