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);
}
List <ShoppingCartRuleResult> IShoppingCartRule.ProcessCart(ShoppingCart_V02 cart, ShoppingCartRuleReason reason)
{
List <ShoppingCartRuleResult> result = new List <ShoppingCartRuleResult>();
ShoppingCartRuleResult defaultResult = new ShoppingCartRuleResult();
defaultResult.RuleName = "PurchasingLimits 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);
}
CartItemWithDetailList GetEventProductList(ShoppingCart_V02 cart)
{
var ret = new CartItemWithDetailList();
if (Helper.Instance.HasData(cart.CurrentItems))
{
foreach (var cartItem in cart.CurrentItems)
{
if (!IsEventProduct(cartItem.SKU))
{
continue;
}
SKU_V01 sku_v01 = null;
SkuList.TryGetValue(cartItem.SKU, out sku_v01);
if (sku_v01 == null)
{
continue;
}
var child = new CartItemWithDetail
{
CurrentItem = cartItem,
SKU = sku_v01
};
ret.Add(child);
}
}
if (Helper.Instance.HasData(cart.CartItems))
{
foreach (var cartItem in cart.CartItems)
{
if (!IsEventProduct(cartItem.SKU))
{
continue;
}
var child = ret.FirstOrDefault(x => x.SkuCode == cartItem.SKU);
if (child != null)
{
child.CartItem = cartItem;
}
else
{
child = new CartItemWithDetail
{
CartItem = cartItem,
SKU = SkuList[cartItem.SKU],
};
ret.Add(child);
}
}
}
return(ret);
}
private bool IsWHOrderForPF(ShoppingCart_V02 cart)
{
bool isWHOrderForPF = false;
var myCart = cart as MyHLShoppingCart;
if (myCart.ActualWarehouseCode == "PFT")
{
isWHOrderForPF = true;
}
return(isWHOrderForPF);
}
protected override ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart, ShoppingCartRuleReason reason,
ShoppingCartRuleResult Result)
{
if (reason == ShoppingCartRuleReason.CartItemsBeingAdded)
{
GetPurchasingLimits(cart.DistributorID, string.Empty);
Result = base.PerformRules(cart, reason, Result);
}
return(Result);
}
public void PerformDiscountRules(ShoppingCart_V02 cart, Order_V01 order, string locale, ShoppingCartRuleReason reason)
{
if (reason == ShoppingCartRuleReason.CartCalculated)
{
if (cart != null && (cart as MyHLShoppingCart).Totals != null)
{
//call promotionalRules to calculate discount amount
(new PromotionalRules()).ProcessCart(cart, ShoppingCartRuleReason.CartCalculated);
}
}
}
private bool IsShippingWithInRomania(ShoppingCart_V02 cart)
{
bool isShippedWithInRomania = false;
var myCart = cart as MyHLShoppingCart;
if (myCart.DeliveryInfo.Address.Address.Country == "RO")
{
isShippedWithInRomania = true;
}
return(isShippedWithInRomania);
}
public void PerformDiscountRules(ShoppingCart_V02 cart, Order_V01 order, string locale, ShoppingCartRuleReason reason)
{
if (reason == ShoppingCartRuleReason.CartBeingCalculated)
{
MyHLShoppingCart shoppingCart = cart as MyHLShoppingCart;
if (order != null && shoppingCart != null && shoppingCart.SelectedDSSubType == "RE")
{
order.UseSlidingScale = false;
order.DiscountPercentage = 0;
}
}
}
/// <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);
}
void CommitTrace(ShoppingCart_V02 cart)
{
if (!IsLoggingTraceEnabled || (SB.Length == 0))
{
return;
}
LoggingTrace(string.Format("End"));
LoggerHelper.Verbose(SB.ToString());
SB.Clear();
}
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);
}
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);
}
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 bool IsElegibleForPromo(ShoppingCart_V02 cart, MyHLShoppingCart hlCart, out decimal volume)
{
var isElegible = false;
volume = 0;
LoggerHelper.Info(
string.Format("CheckPromoInCart.ShoppingCart V02 items {0}",
string.Concat(cart.CartItems.Select(i => string.Format("{0},", i.SKU)))));
LoggerHelper.Info(
string.Format("CheckPromoInCart.MyHLShoppingCart items {0}",
string.Concat(hlCart.CartItems.Select(i => string.Format("{0},", i.SKU)))));
LoggerHelper.Info(
string.Format("AllowedSKUToAddPromoSKU {0}",
string.Concat(AllowedSKUToAddPromoSKU.Select(i => string.Format("{0},", i)))));
var cartItemsV02 = (from a in AllowedSKUToAddPromoSKU
join b in cart.CartItems on a equals b.SKU
select
new
{
Sku = b.SKU,
Qty = b.Quantity,
Volume = CatalogProvider.GetCatalogItem(b.SKU, "IT").VolumePoints
}).ToList();
if (cartItemsV02.Any())
{
isElegible = true;
volume = cartItemsV02.Sum(oi => oi.Qty * oi.Volume);
}
else
{
var shoppingcartItemsV02 = (from a in AllowedSKUToAddPromoSKU
join b in hlCart.ShoppingCartItems on a equals b.SKU
select
new { Sku = b.SKU, Qty = b.Quantity, Volume = b.CatalogItem.VolumePoints })
.ToList();
if (shoppingcartItemsV02.Any())
{
isElegible = true;
volume = shoppingcartItemsV02.Sum(oi => oi.Qty * oi.Volume);
}
else
{
LoggerHelper.Info("No Items in Cart or MyHLCart. Rule fails");
}
}
return(isElegible);
}
/// <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);
}
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, check if courier location is available
if (cart != null)
{
var shoppingCart = cart as MyHLShoppingCart;
if (shoppingCart != null && (shoppingCart.IsSavedCart || shoppingCart.IsFromCopy))
{
var shippingProvider = ShippingProvider.GetShippingProvider(Country);
if (shoppingCart.DeliveryInfo == null &&
shoppingCart.DeliveryOption == ServiceProvider.CatalogSvc.DeliveryOptionType.PickupFromCourier)
{
var theOrderShippingAddress =
shippingProvider.GetShippingInfoFromID(shoppingCart.DistributorID, Locale,
ServiceProvider.ShippingSvc.DeliveryOptionType.PickupFromCourier,
shoppingCart.DeliveryOptionID, 0);
if (theOrderShippingAddress == null)
{
if (shoppingCart.SaveCopyResults == null)
{
shoppingCart.SaveCopyResults = new List <ShoppingCartRuleResult>();
}
if (shoppingCart.SaveCopyResults.All(x => x.RuleName != "PickUpLocationRemoved"))
{
var notAvailable = new ShoppingCartRuleResult {
RuleName = "PickUpLocationRemoved"
};
shoppingCart.SaveCopyResults.Add(notAvailable);
}
defaultResult.Result = RulesResult.Success;
}
}
string warehouse = shippingProvider.GetWarehouseFromShippingMethod(shoppingCart.FreightCode, shoppingCart.DeliveryInfo.Address);
if (!string.IsNullOrEmpty(warehouse))
{
shoppingCart.DeliveryInfo.WarehouseCode = warehouse;
}
}
}
}
return(result);
}
private ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart, ShoppingCartRuleReason reason, ShoppingCartRuleResult result)
{
if (reason == ShoppingCartRuleReason.CartItemsBeingAdded && cart.CartItems != null)
{
DefineRuleSkus();
// Check for isolated skus
var isolated = cart.CartItems.FirstOrDefault(i => IsolatedSkus.Contains(i.SKU));
string error = string.Empty;
if (isolated != null && !isolated.SKU.Equals(cart.CurrentItems[0].SKU))
{
error = string.Format(HttpContext.GetGlobalResourceObject(string.Format("{0}_Rules", HLConfigManager.Platform),
"StandaloneSku").ToString(), isolated.SKU);
result.Result = RulesResult.Failure;
if (!cart.RuleResults.Exists(r => r.Messages != null ? r.Messages.Any(m => m.Equals(error)) : false))
{
result.AddMessage(error);
cart.RuleResults.Add(result);
}
return(result);
}
if (cart.CartItems.Any() && cart.CartItems.Select(s => s.SKU).Except(IsolatedSkus.Select(i => i)).Count() > 0 && IsolatedSkus.Contains(cart.CurrentItems[0].SKU))
{
error = string.Format(HttpContext.GetGlobalResourceObject(string.Format("{0}_Rules", HLConfigManager.Platform),
"StandaloneSku").ToString(), cart.CurrentItems[0].SKU);
result.Result = RulesResult.Failure;
if (!cart.RuleResults.Exists(r => r.Messages != null ? r.Messages.Any(m => m.Equals(error)) : false))
{
result.AddMessage(error);
cart.RuleResults.Add(result);
}
return(result);
}
// Check for not combinable skus
if ((cart.CartItems.Any(i => StandaloneSkus.Contains(i.SKU)) && !StandaloneSkus.Contains(cart.CurrentItems[0].SKU)) ||
(cart.CartItems.Any(i => !StandaloneSkus.Contains(i.SKU)) && StandaloneSkus.Contains(cart.CurrentItems[0].SKU)))
{
error = HttpContext.GetGlobalResourceObject(string.Format("{0}_Rules", HLConfigManager.Platform), "StandaloneSkus").ToString();
result.Result = RulesResult.Failure;
if (!cart.RuleResults.Exists(r => r.Messages != null ? r.Messages.Any(m => m.Equals(error)) : false))
{
result.AddMessage(error);
cart.RuleResults.Add(result);
}
return(result);
}
}
return(result);
}
private ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart,
ShoppingCartRuleReason reason,
ShoppingCartRuleResult Result)
{
if (reason == ShoppingCartRuleReason.CartItemsBeingAdded)
{
bool bEventTicket = isEventTicket(cart.DistributorID, Locale);
var thisCart = cart as MyHLShoppingCart;
if (null != thisCart)
{
//Kiosk items must have inventory
string sku = thisCart.CurrentItems[0].SKU;
var catItem = CatalogProvider.GetCatalogItem(sku, Country);
WarehouseInventory warehouseInventory = null;
var isSplitted = false;
if (thisCart.DeliveryInfo != null && thisCart.DeliveryInfo.Option == ServiceProvider.ShippingSvc.DeliveryOptionType.Shipping &&
HLConfigManager.Configurations.DOConfiguration.WhCodesForSplit.Contains(thisCart.DeliveryInfo.WarehouseCode))
{
//split order scenario
ShoppingCartProvider.CheckInventory(catItem, thisCart.CurrentItems[0].Quantity, thisCart.DeliveryInfo.WarehouseCode, thisCart.DeliveryInfo.FreightCode, ref isSplitted);
}
if (!isSplitted && null != thisCart.DeliveryInfo && !string.IsNullOrEmpty(thisCart.DeliveryInfo.WarehouseCode) && !bEventTicket && !isNonInventoryItem(sku))
{
catItem.InventoryList.TryGetValue(thisCart.DeliveryInfo.WarehouseCode, out warehouseInventory);
if ((warehouseInventory != null && (warehouseInventory as WarehouseInventory_V01).QuantityAvailable <= 0) || warehouseInventory == null)
{
Result.AddMessage(string.Format(HttpContext.GetGlobalResourceObject(string.Format("{0}_ErrorMessage", HLConfigManager.Platform), "BackOrderItem").ToString(), sku));
Result.Result = RulesResult.Failure;
cart.RuleResults.Add(Result);
}
else
{
int availQuantity = InventoryHelper.CheckInventory(thisCart, thisCart.CurrentItems[0].Quantity, catItem, thisCart.DeliveryInfo.WarehouseCode);
if (availQuantity - thisCart.CurrentItems[0].Quantity < 0)
{
Result.AddMessage(string.Format(HttpContext.GetGlobalResourceObject(string.Format("{0}_ErrorMessage", HLConfigManager.Platform), "OutOfInventory").ToString(), sku));
Result.Result = RulesResult.Failure;
cart.RuleResults.Add(Result);
}
}
}
}
}
return(Result);
}
private ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart,
ShoppingCartRuleResult result,
ShoppingCartRuleReason reason)
{
if (null != cart && ((reason == ShoppingCartRuleReason.CartCreated) || (reason == ShoppingCartRuleReason.CartRetrieved)))
{
var myhlCart = cart as MyHLShoppingCart;
var sku = APFDueProvider.GetAPFSku();
myhlCart.DeleteItemsFromCart(
(from a in cart.CartItems where a.SKU == sku.Trim() select a.SKU).ToList(), true);
}
return(result);
}
private ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart,
ShoppingCartRuleReason reason,
ShoppingCartRuleResult result)
{
if (reason == ShoppingCartRuleReason.CartCreated)
{
result = this.CheckForHFFSKU(cart, result);
if (result.Result == RulesResult.Failure)
{
LoggerHelper.Error(string.Join("\r\n", result.Messages.ToArray()));
}
}
return(result);
}
private ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart, ShoppingCartRuleReason reason, ShoppingCartRuleResult result)
{
if (cart != null && (reason == ShoppingCartRuleReason.CartItemsAdded || reason == ShoppingCartRuleReason.CartItemsRemoved))
{
var provider = ShippingProvider.GetShippingProvider(this.Country);
if (provider != null)
{
provider.SetShippingInfo(cart);
result.Result = RulesResult.Success;
cart.RuleResults.Add(result);
}
}
return(result);
}
private void GetMessagesForAddToCart(ShoppingCart_V02 cart)
{
if (cart != null)
{
var myHLCart = cart as MyHLShoppingCart;
if (myHLCart != null && cart.CurrentItems != null)
{
var currentSKU = cart.CurrentItems[0].SKU;
if (!string.IsNullOrEmpty(currentSKU) && !string.IsNullOrWhiteSpace(currentSKU))
{
List <string> skusShowed = new List <string>();
skusShowed = (List <string>)Session["showedMessages"];
if (skusShowed != null)
{
skusShowed.Remove(currentSKU);
}
Session["showedMessages"] = skusShowed;
var cart2 = cart as MyHLShoppingCart;
//get the details from catalog provider
var details = CatalogProvider.GetSkuExpiration(cart.Locale, currentSKU, cart2.DeliveryInfo.WarehouseCode);
if (details != null)
{
var message = HttpContext.GetGlobalResourceObject(
string.Format("{0}_ErrorMessage", HLConfigManager.Platform),
"ShortExpirationDate") as string;
if (message != null)
{
var eta = details.BlockedReason.Split(',');
//formatting the date to be displayed in local format
var dateresults = Dateresults(eta[1]);
var fullmessage = string.Format(message, currentSKU,
dateresults);
List <string> messages = new List <string>();
var sesionValues = Session["messagesToShow"];
messages = (sesionValues != null ? (List <string>)sesionValues : new List <string>());
if (!messages.Any(k => k == fullmessage))
{
messages.Add(string.Format("-SKU:{0}", currentSKU));
messages.Add(fullmessage);
Session["messagesToShow"] = messages;
}
}
}
}
}
}
}
public List <ShoppingCartRuleResult> ProcessCartManagementRules(ShoppingCart_V02 cart)
{
List <ShoppingCartRuleResult> result = new List <ShoppingCartRuleResult>();
ShoppingCartRuleResult defaultResult = new ShoppingCartRuleResult();
defaultResult.RuleName = "Cart Management Rules";
defaultResult.Result = RulesResult.Unknown;
if (cart != null && cart.CartItems != null && cart.CartItems.Any(f => f.SKU == _feeSku))
{
(cart as MyHLShoppingCart).DeleteItemsFromCart(new List <string>(new string[] { _feeSku }), true);
}
return(result);
}
protected override ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart,
ShoppingCartRuleResult result,
ShoppingCartRuleReason reason)
{
if (reason == ShoppingCartRuleReason.CartItemsBeingAdded)
{
MyHLShoppingCart shoppingCart = cart as MyHLShoppingCart;
var items = shoppingCart.CartItems.SkipWhile(i => i.SKU.Equals(HLConfigManager.Configurations.DOConfiguration.HFFHerbalifeSku));
if (!items.Any()) // standalone HFF
{
return(result);
}
}
return(base.PerformRules(cart, result, reason));
}
private ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart,
ShoppingCartRuleReason reason,
ShoppingCartRuleResult Result)
{
if (reason == ShoppingCartRuleReason.CartItemsBeingAdded)
{
try
{
bool bCheckProductType = false;
{
var tins = DistributorOrderingProfileProvider.GetTinList(cart.DistributorID, true);
if (tins.Count > 0)
{
if (tins.Find(t => t.IDType.Key == "IDID") == null) // DS has no national ID
{
bCheckProductType = true;
}
}
else
{
bCheckProductType = true;
}
if (bCheckProductType)
{
var currentItem = CatalogProvider.GetCatalogItem(cart.CurrentItems[0].SKU,
Country);
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);
}
}
}
}
catch (Exception ex)
{
LoggerHelper.Error(
string.Format(
"Error while performing Add to Cart Rule for Indonesia distributor: {0}, Cart Id:{1}, \r\n{2}",
cart.DistributorID, cart.ShoppingCartID, ex));
}
}
return(Result);
}
/// <summary>
/// Validate if the RequiredSKU and PromoSkU is available in Inventory.
/// </summary>
/// <returns></returns>
private bool ApplyForPromo(ref ShoppingCart_V02 cart, ref MyHLShoppingCart hlCart)
{
var allSkus = CatalogProvider.GetAllSKU(Locale);
// Validate if SKUs are available
if (!allSkus.ContainsKey(RequiredSKU) || !allSkus.ContainsKey(PromoSKU))
{
return(false); // No requiredSKU and/or PromoSKU available in catalog
}
// Validatation - Recalculate PromoSKU if the RequiredSKU has been recalculate (remove items)
if (hlCart.CartItems.Any(i => i.SKU.Equals(PromoSKU)) && hlCart.PromoQtyToAdd > 0)
{
var sciRequiredSKU = hlCart.CartItems.FirstOrDefault(i => i.SKU.Equals(RequiredSKU));
var sciPromoSKU = hlCart.CartItems.FirstOrDefault(i => i.SKU.Equals(PromoSKU));
if (sciPromoSKU.Quantity > sciRequiredSKU.Quantity)
{
// Recalculate - Remove PromoSKU
hlCart.DeleteItemsFromCart(new List <string>(new[] { PromoSKU }), true);
hlCart.AddItemsToCart(
new List <ShoppingCartItem_V01>(new[] { new ShoppingCartItem_V01(0, PromoSKU, sciRequiredSKU.Quantity, DateTime.Now) }), true);
hlCart.IsPromoDiscarted = true;
}
hlCart.PromoQtyToAdd = 0;
return(false);
}
// Validate if PromoSKU Qty is available in inventory
WarehouseInventory warehouseInventory;
var catItemPromo = CatalogProvider.GetCatalogItem(PromoSKU, Country);
if (catItemPromo.InventoryList.TryGetValue(hlCart.DeliveryInfo.WarehouseCode, out warehouseInventory))
{
if (warehouseInventory != null)
{
var warehouseInventory01 = warehouseInventory as WarehouseInventory_V01;
if (warehouseInventory01 != null && warehouseInventory01.QuantityAvailable > 0)
{
hlCart.PromoQtyToAdd = cart.CurrentItems.FirstOrDefault(i => i.SKU.Equals(RequiredSKU)).Quantity;
hlCart.PromoQtyToAdd = warehouseInventory01.QuantityAvailable >= hlCart.PromoQtyToAdd ? hlCart.PromoQtyToAdd : warehouseInventory01.QuantityAvailable;
return(true);
}
}
}
return(false);
}
public static int CheckInventory(ShoppingCart_V02 shoppingCart, int quantity, CatalogItem catalogItem, string warehouse)
{
string errorMessage = string.Empty;
int newQuantity = quantity;
if (shoppingCart.RuleResults == null)
{
shoppingCart.RuleResults = new List <ShoppingCartRuleResult>();
}
var freightCode = string.Empty;
var isSplit = false;
var myhlCart = shoppingCart as MyHLShoppingCart;
if (myhlCart != null && myhlCart.DeliveryInfo != null)
{
freightCode = myhlCart.DeliveryInfo.FreightCode;
}
int availQuantity = ShoppingCartProvider.CheckInventory(catalogItem as CatalogItem_V01, newQuantity, warehouse, freightCode, ref isSplit);
if (availQuantity == 0)
{
var resulst = new ShoppingCartRuleResult();
errorMessage = (HttpContext.GetGlobalResourceObject(string.Format("{0}_ErrorMessage", HLConfigManager.Platform),
"OutOfInventory") ?? string.Empty) as string;
errorMessage = string.Format(errorMessage, catalogItem.SKU);
resulst.AddMessage(errorMessage);
resulst.RuleName = "Inventory Rules";
resulst.Result = RulesResult.Failure;
shoppingCart.RuleResults.Add(resulst);
}
else if (availQuantity != newQuantity)
{
var resulst = new ShoppingCartRuleResult();
errorMessage = (HttpContext.GetGlobalResourceObject(string.Format("{0}_ErrorMessage", HLConfigManager.Platform),
"LessInventory") ?? string.Empty) as string;
errorMessage = string.Format(errorMessage, catalogItem.SKU, availQuantity);
resulst.AddMessage(errorMessage);
resulst.RuleName = "Inventory Rules";
resulst.Result = RulesResult.Failure;
shoppingCart.RuleResults.Add(resulst);
HLRulesManager.Manager.PerformBackorderRules(shoppingCart, catalogItem);
}
else
{
availQuantity = quantity;
}
return(availQuantity);
}
public List <ShoppingCartRuleResult> ProcessCart(ShoppingCart_V02 cart, ShoppingCartRuleReason reason)
{
var result = new List <ShoppingCartRuleResult>();
var defaultResult = new ShoppingCartRuleResult
{
RuleName = RuleName,
Result = RulesResult.Unknown
};
if (HLConfigManager.Configurations.DOConfiguration.IsEventInProgress)
{
result.Add(PerformRules(cart, reason, defaultResult));
}
return(result);
}
