private void checkPerOrderLimit(MyHLShoppingCart myCart, ShoppingCartRuleResult Result)
{
ShoppingCartItem_V01 backupItem = null;
var existingItem =
myCart.ShoppingCartItems.FirstOrDefault(p => p.SKU == myCart.CurrentItems[0].SKU);
if (null != existingItem)
{
backupItem = new ShoppingCartItem_V01(existingItem.ID, existingItem.SKU,
existingItem.Quantity,
DateTime.Now, existingItem.MinQuantity);
}
myCart.AddItemsToCart(myCart.CurrentItems, true);
var Totals = myCart.Calculate() as OrderTotals_V01;
if (Totals != null && Totals.AmountDue > MaxAmount)
{
var globalResourceObject =
HttpContext.GetGlobalResourceObject(
string.Format("{0}_Rules", HLConfigManager.Platform), "AmountLimitExceeds");
if (globalResourceObject != null)
{
Result.AddMessage(
string.Format(
globalResourceObject
.ToString(), MaxAmount.ToString()));
}
globalResourceObject =
HttpContext.GetGlobalResourceObject(
string.Format("{0}_Rules", HLConfigManager.Platform),
"DisgardCommonMessage");
if (globalResourceObject != null)
{
Result.AddMessage(globalResourceObject.ToString());
}
Result.Result = RulesResult.Failure;
}
myCart.DeleteItemsFromCart(new List <string> {
myCart.CurrentItems[0].SKU
}, true);
if (backupItem != null)
{
myCart.AddItemsToCart(new List <ShoppingCartItem_V01> {
backupItem
}, true);
myCart.Calculate();
}
}
/// <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);
}
private ShoppingCartRuleResult AddToCart(MyHLShoppingCart cart,
ShoppingCartRuleResult Result,
string SkuToBeAdded)
{
var allSkus = CatalogProvider.GetAllSKU(Locale);
if (!allSkus.Keys.Contains(SkuToBeAdded))
{
if (Environment.MachineName.IndexOf("PROD") < 0)
{
var country = new RegionInfo(new CultureInfo(Locale, false).LCID);
string message =
string.Format(
HttpContext.GetGlobalResourceObject(string.Format("{0}_Rules", HLConfigManager.Platform),
"NoPromoSku").ToString(), country.DisplayName,
SkuToBeAdded);
LoggerHelper.Error(message);
Result.Result = RulesResult.Feedback;
Result.AddMessage(message);
cart.RuleResults.Add(Result);
return(Result);
}
return(Result);
}
//Promo items must have inventory
var catItem = CatalogProvider.GetCatalogItem(SkuToBeAdded, Country);
WarehouseInventory warehouseInventory = null;
if (null != cart.DeliveryInfo && !string.IsNullOrEmpty(cart.DeliveryInfo.WarehouseCode))
{
if (catItem.InventoryList.TryGetValue(cart.DeliveryInfo.WarehouseCode, out warehouseInventory))
{
if ((warehouseInventory as WarehouseInventory_V01).QuantityAvailable > 0)
{
cart.AddItemsToCart(
new List <ShoppingCartItem_V01>(new[]
{ new ShoppingCartItem_V01(0, SkuToBeAdded, quantity, DateTime.Now) }), true);
Result.Result = RulesResult.Success;
cart.RuleResults.Add(Result);
}
}
}
return(Result);
}
public void GracePeriodAPFDisplay()
{
_apfSku = APFDueProvider.GetAPFSku();
List <ShoppingCartItem_V01> item = (from c in _cart.CartItems where c.SKU == _apfSku select c).ToList();
_APFExempted = APFDueProvider.IsAPFExemptOn200VP(DistributorOrderingProfile, _cart.VolumeInCart);
if (_APFStatus != 2)
{
return;
}
if (_APFExempted)
{
pnlAPFPaid.Visible = false;
}
if (item.Count >= 1)
{
ShowApfAddedMessage();
}
else
{
var apfSku = new List <ShoppingCartItem_V01>();
if (!_APFExempted)
{
if (_quantityToAdd < 1)
{
_quantityToAdd = 1;
}
apfSku.Add(new ShoppingCartItem_V01(0, APFDueProvider.GetAPFSku(), _quantityToAdd, DateTime.Now));
_cart.AddItemsToCart(apfSku);
}
item = (from c in _cart.CartItems where c.SKU == _apfSku select c).ToList();
if (item.Count >= 1)
{
ShowApfAddedMessage();
}
}
}
private ShoppingCartRuleResult CheckPromoInCart(ShoppingCart_V02 shoppingCart,
MyHLShoppingCart cart,
ShoppingCartRuleResult result)
{
LoggerHelper.Info(string.Format("Entered CheckPromoInCart."));
// Define the promo quantity to add
decimal volumeInCartForPromo = 0;
var applyForPromo = IsElegibleForPromo(shoppingCart, cart, out volumeInCartForPromo);
var allSkus = CatalogProvider.GetAllSKU(Locale);
if (applyForPromo && !allSkus.Keys.Contains(PromotionalSku))
{
LoggerHelper.Info("No promo sku in catalog");
if (Environment.MachineName.IndexOf("PROD", StringComparison.Ordinal) < 0)
{
var country = new RegionInfo(new CultureInfo(Locale, false).LCID);
string message = "NoPromoSku";
var globalResourceObject =
HttpContext.GetGlobalResourceObject(string.Format("{0}_Rules", HLConfigManager.Platform),
"NoPromoSku");
if (globalResourceObject != null)
{
message = string.Format(globalResourceObject.ToString(), country.DisplayName, PromotionalSku);
}
LoggerHelper.Error(message);
result.Result = RulesResult.Feedback;
result.AddMessage(message);
cart.RuleResults.Add(result);
return(result);
}
return(result);
}
// Define the promo quantity to add
var elegibleQuantity = Convert.ToInt32(Math.Truncate(volumeInCartForPromo / PromotionalRequiredVolumePoints)) *
PromoQuantity;
var promoSkuInCart = (from c in cart.CartItems where c.SKU.Equals(PromotionalSku) select c).FirstOrDefault();
if (elegibleQuantity == 0 && promoSkuInCart == null)
{
// Nothing to do
LoggerHelper.Info("Not elegible for promo and not promo sku in cart");
result.Result = RulesResult.Success;
cart.RuleResults.Add(result);
return(result);
}
if (promoSkuInCart != null)
{
if (promoSkuInCart.Quantity == elegibleQuantity)
{
// Check if nothing to do
LoggerHelper.Info("Not quantity change to do in promo sku");
result.Result = RulesResult.Success;
cart.RuleResults.Add(result);
return(result);
}
if (promoSkuInCart.Quantity > elegibleQuantity)
{
// Remove the promo sku if quantity to add is minor than the quantity in cart
LoggerHelper.Info("Removing promo sku from cart");
cart.DeleteItemsFromCart(new List <string> {
PromotionalSku
}, true);
if (elegibleQuantity == 0)
{
result.Result = RulesResult.Success;
cart.RuleResults.Add(result);
return(result);
}
}
else
{
// Change item quantity adding the excess to the existent sku
elegibleQuantity -= promoSkuInCart.Quantity;
}
}
// Adding promo if it has inventory and if it is allowed
if (applyForPromo && cart.DeliveryInfo != null && !string.IsNullOrEmpty(cart.DeliveryInfo.WarehouseCode))
{
LoggerHelper.Info("Checking Inventory");
WarehouseInventory warehouseInventory;
var catItemPromo = CatalogProvider.GetCatalogItem(PromotionalSku, Country);
if (catItemPromo.InventoryList.TryGetValue(cart.DeliveryInfo.WarehouseCode, out warehouseInventory))
{
if (warehouseInventory != null)
{
var warehouseInventory01 = warehouseInventory as WarehouseInventory_V01;
if (warehouseInventory01 != null && warehouseInventory01.QuantityAvailable > elegibleQuantity)
{
cart.AddItemsToCart(
new List <ShoppingCartItem_V01>(new[]
{ new ShoppingCartItem_V01(0, PromotionalSku, elegibleQuantity, DateTime.Now) }), true);
result.Result = RulesResult.Success;
cart.RuleResults.Add(result);
}
else
{
LoggerHelper.Info("Warehouse information is null or not enough quantity is available");
}
}
}
else
{
LoggerHelper.Info("Not inventory list was gotten for promo sku");
}
}
return(result);
}
/// <summary>
/// Validates if the promo should be in cart.
/// </summary>
/// <param name="shoppingCart">The shopping cart.</param>
/// <param name="cart">The MyHL shopping cart.</param>
/// <param name="result">The promo rule result.</param>
/// <returns></returns>
private ShoppingCartRuleResult CheckPromoInCart(ShoppingCart_V02 shoppingCart, MyHLShoppingCart cart, ShoppingCartRuleResult result, bool removed)
{
// Check the order type
var session = SessionInfo.GetSessionInfo(cart.DistributorID, cart.Locale);
if (session.IsEventTicketMode)
{
return(result);
}
// Check if APF standalone order
if (APFDueProvider.hasOnlyAPFSku(cart.CartItems, cart.Locale))
{
return(result);
}
// Check HFF standalone
if (ShoppingCartProvider.IsStandaloneHFF(cart.ShoppingCartItems))
{
return(result);
}
// Check if promo sku has been removed
if (removed && (cart.CartItems.Count == 0 || (!string.IsNullOrEmpty(cart.PromoSkuDiscarted) && cart.PromoSkuDiscarted.Contains(PromoSku.Sku))))
{
result.Result = RulesResult.Success;
return(result);
}
// Check if promo sku should be in cart
var isRuleTime = IsRuleTime();
var isPromoInCart = cart.CartItems != null && cart.CartItems.Any(i => i.SKU.Equals(PromoSku.Sku));
var promoInCart = isPromoInCart ? cart.CartItems.FirstOrDefault(i => i.SKU.Equals(PromoSku.Sku)) : null;
var applyForPromo = cart.CartItems != null && cart.CartItems.Any(i => i.SKU.Equals(RequiredSku.Sku) && i.Quantity >= RequiredSku.Quantity);
// Define the quantity to add
var requiredSkuQuantityInCart = cart.CartItems == null ? 0 : cart.CartItems.Where(i => i.SKU == RequiredSku.Sku).Sum(i => i.Quantity);
var remainder = 0;
var allowedQuantity = Math.DivRem(requiredSkuQuantityInCart, RequiredSku.Quantity, out remainder);
if (!applyForPromo || !isRuleTime)
{
if (isPromoInCart)
{
cart.DeleteItemsFromCart(new List <string> {
PromoSku.Sku
}, true);
var message = "HTML|PromotionalSKU087PRemoved.html";
result.AddMessage(message);
result.Result = RulesResult.Feedback;
}
// Nothing to do
cart.RuleResults.Add(result);
return(result);
}
if (promoInCart != null)
{
if (promoInCart.Quantity == allowedQuantity)
{
// Nothing to do
result.Result = RulesResult.Success;
cart.RuleResults.Add(result);
return(result);
}
if (promoInCart.Quantity > allowedQuantity)
{
// Remove the promo sku if quantity to add is minor than the quantity in cart
cart.DeleteItemsFromCart(new List <string> {
PromoSku.Sku
}, true);
var message = "HTML|PromotionalSKU087PRemoved.html";
result.AddMessage(message);
result.Result = RulesResult.Feedback;
isPromoInCart = false;
}
else
{
if (cart.CurrentItems != null && cart.CurrentItems.Count > 0 && cart.CurrentItems[0].SKU.Equals(PromoSku.Sku))
{
allowedQuantity = promoInCart.Quantity;
cart.IsPromoNotified = false;
}
cart.DeleteItemsFromCart(new List <string> {
PromoSku.Sku
}, true);
isPromoInCart = false;
cart.IsPromoNotified = true;
}
}
else
{
cart.IsPromoNotified = true;
}
// Check promo sku in catalog info
var allSkus = CatalogProvider.GetAllSKU(Locale);
if (!allSkus.Keys.Contains(PromoSku.Sku))
{
if (Environment.MachineName.IndexOf("PROD", StringComparison.Ordinal) < 0)
{
var country = new RegionInfo(new CultureInfo(Locale, false).LCID);
string message = "NoPromoSku";
var globalResourceObject = HttpContext.GetGlobalResourceObject(string.Format("{0}_Rules", HLConfigManager.Platform), "NoPromoSku");
if (globalResourceObject != null)
{
message = string.Format(globalResourceObject.ToString(), country.DisplayName, PromoSku.Sku);
}
result.Result = RulesResult.Feedback;
result.AddMessage(message);
cart.RuleResults.Add(result);
return(result);
}
return(result);
}
// Adding promo sku if possible
if (!isPromoInCart && !string.IsNullOrEmpty(cart.DeliveryInfo.WarehouseCode))
{
WarehouseInventory warehouseInventory;
var catItemPromo = CatalogProvider.GetCatalogItem(PromoSku.Sku, Country);
if (catItemPromo.InventoryList.TryGetValue(cart.DeliveryInfo.WarehouseCode, out warehouseInventory))
{
if (warehouseInventory != null)
{
var warehouseInventory01 = warehouseInventory as WarehouseInventory_V01;
if (warehouseInventory01 != null && warehouseInventory01.QuantityAvailable > allowedQuantity)
{
if (cart.IsPromoNotified)
{
var message = "HTML|PromotionalSku087PAdded.html";
result.AddMessage(message);
result.Result = RulesResult.Feedback;
cart.IsPromoNotified = false;
}
else
{
result.Result = RulesResult.Success;
}
cart.AddItemsToCart(new List <ShoppingCartItem_V01>(new[] { new ShoppingCartItem_V01(0, PromoSku.Sku, allowedQuantity, DateTime.Now) }), true);
cart.RuleResults.Add(result);
}
}
}
}
return(result);
}
private ShoppingCartRuleResult CheckPromoInCart(MyHLShoppingCart shoppingCart,
bool checkPayment,
ShoppingCartRuleResult result)
{
var promo = ShoppingCartProvider.GetEligibleForPromo(shoppingCart.DistributorID, shoppingCart.Locale);
PromoSKUs = HLConfigManager.Configurations.ShoppingCartConfiguration.PromotionalSku.Split(',').ToList();
var promoWarehouse = string.IsNullOrEmpty(HLConfigManager.Configurations.ShoppingCartConfiguration.PromotionalWarehouse) ?
PromotionWarehouse : HLConfigManager.Configurations.ShoppingCartConfiguration.PromotionalWarehouse;
var allSkus = CatalogProvider.GetAllSKU(Locale);
if (promo != null && !allSkus.Keys.Contains(promo.Sku))
{
LoggerHelper.Info("No promo sku in catalog");
if (Environment.MachineName.IndexOf("PROD", StringComparison.Ordinal) < 0)
{
var country = new RegionInfo(new CultureInfo(Locale, false).LCID);
string message = "NoPromoSku";
var globalResourceObject =
HttpContext.GetGlobalResourceObject(string.Format("{0}_Rules", HLConfigManager.Platform),
"NoPromoSku");
if (globalResourceObject != null)
{
message = string.Format(globalResourceObject.ToString(), country.DisplayName, promo.Sku);
}
LoggerHelper.Error(message);
result.Result = RulesResult.Feedback;
result.AddMessage(message);
shoppingCart.RuleResults.Add(result);
return(result);
}
return(result);
}
result = RemovePromoOnEmptyCart(shoppingCart, result);
int selectedPaymentMethod = 0;
if (checkPayment)
{
var session = SessionInfo.GetSessionInfo(shoppingCart.DistributorID, shoppingCart.Locale);
selectedPaymentMethod = session.SelectedPaymentMethod;
}
var promoSkuInCart = promo != null?
shoppingCart.CartItems.Where(i => i.SKU == promo.Sku).Select(i => i.SKU).ToList() :
shoppingCart.CartItems.Where(i => PromoSKUs.Contains(i.SKU)).Select(i => i.SKU).ToList();
if (promo == null && promoSkuInCart.Count == 0)
{
// Nothing to do
LoggerHelper.Info("Not elegible for promo and not promo sku in cart");
result.Result = RulesResult.Success;
shoppingCart.RuleResults.Add(result);
return(result);
}
if (shoppingCart.Totals == null)
{
// Nothing to do
LoggerHelper.Info("Not able to add or remove sku. Totals are null");
result.Result = RulesResult.Failure;
shoppingCart.RuleResults.Add(result);
return(result);
}
if (shoppingCart.CartItems.Count == 0)
{
// Just remove promo sku and nothing more to do
LoggerHelper.Info("No items in cart to add promo");
result.Result = RulesResult.Success;
shoppingCart.RuleResults.Add(result);
return(result);
}
if (promoSkuInCart.Count > 0)
{
// Remove promoSkus from cart
shoppingCart.DeleteItemsFromCart(promoSkuInCart, true);
if (!AlowedOrderSubTypes.Contains(shoppingCart.OrderSubType) ||
(promo != null && !shoppingCart.CartItems.Any(i => !i.SKU.Equals(promo.Sku))) ||
(checkPayment && selectedPaymentMethod > 1) || shoppingCart.IsPromoDiscarted)
{
// Just remove promo sku and nothing more to do
LoggerHelper.Info("Removed promo sku in cart");
result.Result = RulesResult.Success;
shoppingCart.RuleResults.Add(result);
return(result);
}
else if (shoppingCart.IgnorePromoSKUAddition)
{
shoppingCart.IgnorePromoSKUAddition = false;
result.Result = RulesResult.Failure;
string message = string.Format(HttpContext.GetGlobalResourceObject(string.Format("{0}_Rules", HLConfigManager.Platform), "SKUCantBePurchased").ToString(), promoSkuInCart[0]);
result.AddMessage(message);
shoppingCart.RuleResults.Add(result);
}
}
// Adding promo if it has inventory and if it is allowed
if (promo != null && AlowedOrderSubTypes.Contains(shoppingCart.OrderSubType) && shoppingCart.CartItems.Any() &&
shoppingCart.DeliveryInfo != null && !string.IsNullOrEmpty(shoppingCart.DeliveryInfo.WarehouseCode) && shoppingCart.DeliveryInfo.WarehouseCode.Equals(promoWarehouse) &&
((checkPayment && selectedPaymentMethod <= 1) || !checkPayment) && !shoppingCart.IsPromoDiscarted && !APFDueProvider.IsAPFSkuPresent(shoppingCart.CartItems))
{
LoggerHelper.Info("Checking Inventory");
WarehouseInventory warehouseInventory;
var catItemPromo = CatalogProvider.GetCatalogItem(promo.Sku, Country);
if (catItemPromo.InventoryList.TryGetValue(shoppingCart.DeliveryInfo.WarehouseCode,
out warehouseInventory))
{
if (warehouseInventory != null)
{
var warehouseInventory01 = warehouseInventory as WarehouseInventory_V01;
if (warehouseInventory01 != null && warehouseInventory01.QuantityAvailable > promo.Quantity)
{
var country = new RegionInfo(new CultureInfo(Locale, false).LCID);
string message = "PromoInCart";
var globalResourceObject = HttpContext.GetGlobalResourceObject(string.Format("{0}_Rules", HLConfigManager.Platform), "PromoInCart");
if (globalResourceObject != null)
{
message = string.Format(globalResourceObject.ToString(), country.DisplayName);
}
shoppingCart.AddItemsToCart(
new List <ShoppingCartItem_V01>(new[]
{ new ShoppingCartItem_V01(0, promo.Sku, promo.Quantity, DateTime.Now) }), true);
if (result.Result != RulesResult.Failure)
{
result.Result = checkPayment ? RulesResult.Success : (shoppingCart.IsPromoNotified ? RulesResult.Feedback : RulesResult.Success);
result.AddMessage(message);
shoppingCart.RuleResults.Add(result);
}
shoppingCart.IsPromoNotified = false;
}
else
{
LoggerHelper.Info("Warehouse information is null or not enough quantity is available");
}
}
}
else
{
LoggerHelper.Info("Not inventory list was gotten for promo sku");
}
}
return(result);
}
/// <summary>
/// Validates if the promo should be in cart.
/// </summary>
/// <param name="cart">The cart.</param>
/// <param name="result">The promo rule result.</param>
/// <param name="requiredSkus">The required sku list.</param>
/// <param name="promoSku">The promo sku.</param>
/// <returns></returns>
private ShoppingCartRuleResult CheckPromoIncart(MyHLShoppingCart cart, ShoppingCartRuleResult result, List <string> requiredSkus, string promoSku)
{
// Check if promo sku should be in cart
var quantityToAdd = cart.CartItems.Where(i => requiredSkus.Contains(i.SKU)).Sum(i => i.Quantity);
var promoInCart = cart.CartItems.FirstOrDefault(i => i.SKU.Equals(promoSku));
// If not elegibe for promo then nothing to do
if (quantityToAdd == 0)
{
if (promoInCart != null)
{
cart.DeleteItemsFromCart(new List <string> {
promoSku
}, true);
}
// Nothing to do
result.Result = RulesResult.Success;
cart.RuleResults.Add(result);
return(result);
}
// Define the quantity to add
if (promoInCart != null)
{
if (promoInCart.Quantity == quantityToAdd)
{
// Check if nothing to do
result.Result = RulesResult.Success;
cart.RuleResults.Add(result);
return(result);
}
if (promoInCart.Quantity > quantityToAdd)
{
// Remove the promo sku if quantity to add is minor than the quantity in cart
cart.DeleteItemsFromCart(new List <string> {
promoSku
}, true);
}
else
{
// Change item quantity adding the excess to the existent sku
quantityToAdd -= promoInCart.Quantity;
}
}
// Check promo items in catalog
var allSkus = CatalogProvider.GetAllSKU(Locale);
if (!allSkus.Keys.Contains(promoSku))
{
if (Environment.MachineName.IndexOf("PROD", StringComparison.Ordinal) < 0)
{
var country = new RegionInfo(new CultureInfo(Locale, false).LCID);
string message = "NoPromoSku";
var globalResourceObject =
HttpContext.GetGlobalResourceObject(string.Format("{0}_Rules", HLConfigManager.Platform),
"NoPromoSku");
if (globalResourceObject != null)
{
message = string.Format(globalResourceObject.ToString(), country.DisplayName, promoSku);
}
result.Result = RulesResult.Feedback;
result.AddMessage(message);
cart.RuleResults.Add(result);
}
return(result);
}
//Promo items must have inventory
var catItem = CatalogProvider.GetCatalogItem(promoSku, Country);
if (cart.DeliveryInfo != null && !string.IsNullOrEmpty(cart.DeliveryInfo.WarehouseCode))
{
WarehouseInventory warehouseInventory = null;
if (catItem.InventoryList.TryGetValue(cart.DeliveryInfo.WarehouseCode, out warehouseInventory))
{
if (warehouseInventory != null)
{
var warehouseInventory01 = warehouseInventory as WarehouseInventory_V01;
if (warehouseInventory01 != null && warehouseInventory01.QuantityAvailable > 0)
{
cart.AddItemsToCart(
new List <ShoppingCartItem_V01>(new[]
{ new ShoppingCartItem_V01(0, promoSku, quantityToAdd, DateTime.Now) }), true);
result.Result = RulesResult.Success;
cart.RuleResults.Add(result);
}
}
}
}
return(result);
}
/// <summary>
/// Adds to cart.
/// </summary>
/// <param name="cart">The cart.</param>
/// <param name="Result">The result.</param>
/// <returns></returns>
private ShoppingCartRuleResult AddToCart(MyHLShoppingCart cart, ShoppingCartRuleResult Result, int quantity, ShoppingCartRuleReason reason, bool displayMessage)
{
cart.IsPromoDiscarted = false;
var allSkus = CatalogProvider.GetAllSKU(Locale);
if (!allSkus.Keys.Contains(promoSku))
{
if (Environment.MachineName.IndexOf("PROD") < 0)
{
var country = new RegionInfo(new CultureInfo(Locale, false).LCID);
string message =
string.Format(
HttpContext.GetGlobalResourceObject(string.Format("{0}_Rules", HLConfigManager.Platform),
"NoPromoSku").ToString(), country.DisplayName, promoSku);
LoggerHelper.Error(message);
Result.Result = RulesResult.Failure;
Result.AddMessage(message);
cart.RuleResults.Add(Result);
return(Result);
}
return(Result);
}
//Promo items must have inventory
var catItem = CatalogProvider.GetCatalogItem(promoSku, Country);
WarehouseInventory warehouseInventory = null;
if (null != cart.DeliveryInfo && !string.IsNullOrEmpty(cart.DeliveryInfo.WarehouseCode))
{
if (catItem.InventoryList.TryGetValue(cart.DeliveryInfo.WarehouseCode, out warehouseInventory))
{
if ((warehouseInventory as WarehouseInventory_V01).QuantityAvailable > 0)
{
cart.AddItemsToCart(
new List <ShoppingCartItem_V01>(new[]
{ new ShoppingCartItem_V01(0, promoSku, quantity, DateTime.Now) }), true);
string message = string.Empty;
if (reason == ShoppingCartRuleReason.CartItemsAdded)
{
if (displayMessage)
{
message =
string.Format(
HttpContext.GetGlobalResourceObject(
string.Format("{0}_Rules", HLConfigManager.Platform),
"PromotionalSkuAdded").ToString());
Result.Result = RulesResult.Feedback;
}
else if (cart.CurrentItems.Count > 0 && cart.CurrentItems[0].SKU == promoSku)
{
message = string.Format(HttpContext.GetGlobalResourceObject(string.Format("{0}_Rules", HLConfigManager.Platform), "NoModifyPromoSku").ToString());
Result.Result = RulesResult.Failure;
}
else
{
Result.Result = RulesResult.Success;
}
}
Result.AddMessage(message);
cart.IsPromoNotified = true;
cart.RuleResults.Add(Result);
}
}
}
return(Result);
}
/// <summary>
/// Validates if the promo should be in cart.
/// </summary>
/// <param name="shoppingCart">The shopping cart.</param>
/// <param name="cart">The MyHL shopping cart.</param>
/// <param name="result">The promo rule result.</param>
/// <returns></returns>
private ShoppingCartRuleResult CheckPromoInCart(ShoppingCart_V02 shoppingCart,
MyHLShoppingCart cart,
ShoppingCartRuleResult result)
{
// Check the order type
var session = SessionInfo.GetSessionInfo(cart.DistributorID, cart.Locale);
if (session.IsEventTicketMode)
{
return(result);
}
// Check if promo sku should be in cart
var promoInCart = cart.CartItems != null && cart.CartItems.Any(i => i.SKU.Equals(PromoSKU));
var apfSkus = APFDueProvider.GetAPFSkuList();
var applyForPromo = cart.CartItems != null &&
cart.CartItems.Any(
i =>
!apfSkus.Contains(i.SKU) &&
!i.SKU.Equals(HLConfigManager.Configurations.DOConfiguration.HFFHerbalifeSku) &&
!i.SKU.Equals(PromoSKU));
// Check if APF standalone order
if (APFDueProvider.hasOnlyAPFSku(cart.CartItems, cart.Locale))
{
return(result);
}
// Check HFF standalone
if (ShoppingCartProvider.IsStandaloneHFF(cart.ShoppingCartItems))
{
return(result);
}
if (!applyForPromo)
{
if (promoInCart)
{
cart.DeleteItemsFromCart(new List <string> {
PromoSKU
}, true);
}
// Nothing to do
result.Result = RulesResult.Success;
cart.RuleResults.Add(result);
return(result);
}
//Check promo sku catalog info
var allSkus = CatalogProvider.GetAllSKU(Locale);
if (!allSkus.Keys.Contains(PromoSKU))
{
if (Environment.MachineName.IndexOf("PROD", StringComparison.Ordinal) < 0)
{
var country = new RegionInfo(new CultureInfo(Locale, false).LCID);
string message = "NoPromoSku";
var globalResourceObject =
HttpContext.GetGlobalResourceObject(string.Format("{0}_Rules", HLConfigManager.Platform),
"NoPromoSku");
if (globalResourceObject != null)
{
message = string.Format(globalResourceObject.ToString(), country.DisplayName, PromoSKU);
}
result.Result = RulesResult.Feedback;
result.Messages.Add(message);
cart.RuleResults.Add(result);
return(result);
}
return(result);
}
// Adding promo sku if possible
var isRuleTime = IsRuleTime();
if (!promoInCart && isRuleTime && !string.IsNullOrEmpty(cart.DeliveryInfo.WarehouseCode))
{
WarehouseInventory warehouseInventory;
var catItemPromo = CatalogProvider.GetCatalogItem(PromoSKU, Country);
if (catItemPromo.InventoryList.TryGetValue(cart.DeliveryInfo.WarehouseCode, out warehouseInventory))
{
if (warehouseInventory != null)
{
var warehouseInventory01 = warehouseInventory as WarehouseInventory_V01;
if (warehouseInventory01 != null && warehouseInventory01.QuantityAvailable > 0)
{
cart.AddItemsToCart(
new List <ShoppingCartItem_V01>(new[]
{ new ShoppingCartItem_V01(0, PromoSKU, 1, DateTime.Now) }), true);
result.Result = RulesResult.Success;
cart.RuleResults.Add(result);
}
}
}
}
else if (promoInCart && !isRuleTime)
{
// Remove the promo sku
cart.DeleteItemsFromCart(new List <string> {
PromoSKU
}, true);
result.Result = RulesResult.Success;
cart.RuleResults.Add(result);
}
return(result);
}
