/// <summary>
/// Adds an item to the shopping cart and saves the newly created cart into the database. Also saves the shopping cart if it wasn't saved yet.
/// </summary>
/// <param name="skuId">ID of the added product's SKU object.</param>
/// <param name="quantity">Number of added product units.</param>
public void AddItem(int skuId, int quantity = 1)
{
var parameters = new ShoppingCartItemParameters
{
SKUID = skuId,
Quantity = quantity
};
var cartItem = ShoppingCartInfoProvider.SetShoppingCartItem(OriginalCart, parameters);
if (cartItem == null)
{
return;
}
if (OriginalCart.ShoppingCartID == 0)
{
Save(false);
}
ShoppingCartItemInfoProvider.SetShoppingCartItemInfo(cartItem);
mActivityLogger?.LogProductAddedToShoppingCartActivity(cartItem.SKU, quantity);
mItems = null;
}
public CartItem AddCartItem(NewCartItem newItem, MailingList mailingList = null)
{
var addedAmount = newItem?.Quantity ?? 0;
if (addedAmount < 1)
{
throw new ArgumentException(resources.GetResourceString("Kadena.Product.InsertedAmmountValueIsNotValid"));
}
var productDocument = DocumentHelper.GetDocument(newItem.DocumentId, new TreeProvider(MembershipContext.AuthenticatedUser));
var productType = productDocument.GetValue("ProductType", string.Empty);
var isTemplatedType = ProductTypes.IsOfType(productType, ProductTypes.TemplatedProduct);
var cartItem = ECommerceContext.CurrentShoppingCart.CartItems
.FirstOrDefault(i => i.SKUID == productDocument.NodeSKUID && i.GetValue("ChilliEditorTemplateID", Guid.Empty) == newItem.TemplateId);
var isNew = false;
if (cartItem == null)
{
isNew = true;
cartItem = isTemplatedType
? CreateCartItem(productDocument, newItem.TemplateId)
: CreateCartItem(productDocument);
}
var existingAmountInCart = isNew ? 0 : cartItem.CartItemUnits;
if (productType.Contains(ProductTypes.InventoryProduct))
{
EnsureInventoryAmount(productDocument, addedAmount, existingAmountInCart);
}
var isMailingType = ProductTypes.IsOfType(productType, ProductTypes.MailingProduct);
if (isTemplatedType || isMailingType)
{
if (isMailingType)
{
if (mailingList?.AddressCount != addedAmount)
{
throw new ArgumentException(resources.GetResourceString("Kadena.Product.InsertedAmmountValueIsNotValid"));
}
SetMailingList(cartItem, mailingList);
}
SetAmount(cartItem, addedAmount);
}
else
{
SetAmount(cartItem, addedAmount + existingAmountInCart);
}
SetArtwork(cartItem, productDocument.GetStringValue("ProductArtwork", string.Empty));
RefreshPrice(cartItem, productDocument);
SetCustomName(cartItem, newItem.CustomProductName);
ShoppingCartItemInfoProvider.SetShoppingCartItemInfo(cartItem);
return(GetShoppingCartItems().FirstOrDefault(i => i.Id == cartItem.CartItemID));
}
/// <summary>
/// Create Shopping cart with item by customer
/// </summary>
/// <param name="customerAddressID"></param>
/// <param name="txtQty"></param>
private void CreateShoppingCartByCustomer(SKUInfo product, int customerAddressID, int productQty, double skuPrice)
{
try
{
var customerAddress = AddressInfoProvider.GetAddressInfo(customerAddressID);
if (!DataHelper.DataSourceIsEmpty(product))
{
ShoppingCartInfo cart = new ShoppingCartInfo();
cart.ShoppingCartSiteID = CurrentSite.SiteID;
cart.ShoppingCartCustomerID = customerAddressID;
cart.ShoppingCartCurrencyID = CurrencyInfoProvider.GetMainCurrency(CurrentSite.SiteID).CurrencyID;
cart.SetValue("ShoppingCartCampaignID", ProductCampaignID);
cart.SetValue("ShoppingCartProgramID", ProductProgramID);
cart.SetValue("ShoppingCartDistributorID", customerAddressID);
cart.SetValue("ShoppingCartInventoryType", ProductType);
cart.User = CurrentUser;
cart.ShoppingCartShippingAddress = customerAddress;
cart.ShoppingCartShippingOptionID = ProductShippingID;
ShoppingCartInfoProvider.SetShoppingCartInfo(cart);
ShoppingCartItemParameters parameters = new ShoppingCartItemParameters(product.SKUID, productQty);
parameters.CustomParameters.Add("CartItemCustomerID", customerAddressID);
ShoppingCartItemInfo cartItem = cart.SetShoppingCartItem(parameters);
cartItem.SetValue("CartItemPrice", skuPrice);
cartItem.SetValue("CartItemDistributorID", customerAddressID);
cartItem.SetValue("CartItemCampaignID", ProductCampaignID);
cartItem.SetValue("CartItemProgramID", ProductProgramID);
ShoppingCartItemInfoProvider.SetShoppingCartItemInfo(cartItem);
cart.InvalidateCalculations();
}
}
catch (Exception ex)
{
EventLogProvider.LogException("CustomerCartOperations.ascx.cs", "CreateShoppingCartByCustomer()", ex);
}
}
private void SaveCartItem(ShoppingCartItemInfo scii)
{
// Set new cart
if (ShoppingCart.ShoppingCartID == 0)
{
ShoppingCartInfoProvider.SetShoppingCartInfo(ShoppingCart);
}
ShoppingCartItemInfoProvider.SetShoppingCartItemInfo(scii);
}
/// <summary>
/// Adds content of order to current shopping cart.
/// </summary>
private void AddToCart(int orderId)
{
if (!ShowOrderToShoppingCart)
{
return;
}
// Get order
OrderInfo order = OrderInfoProvider.GetOrderInfo(orderId);
if (order != null)
{
CustomerInfo customer = CustomerInfoProvider.GetCustomerInfo(order.OrderCustomerID);
if (customer.CustomerUserID == CurrentUser.UserID)
{
// Get current shopping cart
ShoppingCartInfo cart = ECommerceContext.CurrentShoppingCart;
// Set new cart
if (cart.ShoppingCartID == 0)
{
ShoppingCartInfoProvider.SetShoppingCartInfo(cart);
}
string cartUrl = ECommerceSettings.ShoppingCartURL(CurrentSite.SiteName);
// Update shopping cart by items from order
if (!ShoppingCartInfoProvider.UpdateShoppingCartFromOrder(cart, orderId))
{
cartUrl = URLHelper.AddParameterToUrl(cartUrl, "notallreordered", "1");
}
// Update shopping cart items in database
foreach (ShoppingCartItemInfo item in cart.CartItems)
{
ShoppingCartItemInfoProvider.SetShoppingCartItemInfo(item);
}
// Redirect to shopping cart page
URLHelper.ResponseRedirect(cartUrl);
}
}
}
/// <summary>
/// Updating the unit count of shopping cart Item
/// </summary>
private void Updatingtheunitcountofcartitem(SKUInfo product, int shoppinCartID, int unitCount, int customerAddressID, double skuPrice)
{
try
{
var customerAddress = AddressInfoProvider.GetAddressInfo(customerAddressID);
if (!DataHelper.DataSourceIsEmpty(product))
{
ShoppingCartItemInfo item = null;
ShoppingCartInfo cart = ShoppingCartInfoProvider.GetShoppingCartInfo(shoppinCartID);
cart.User = CurrentUser;
cart.ShoppingCartShippingAddress = customerAddress;
if (cart.ShoppingCartCurrencyID <= 0)
{
cart.ShoppingCartCurrencyID = CurrencyInfoProvider.GetMainCurrency(CurrentSite.SiteID).CurrencyID;
cart.Update();
}
var campaingnID = ValidationHelper.GetInteger(cart.GetValue("ShoppingCartCampaignID"), default(int));
var programID = ValidationHelper.GetInteger(cart.GetValue("ShoppingCartProgramID"), default(int));
item = cart.CartItems.Where(g => g.SKUID == product.SKUID).FirstOrDefault();
if (!DataHelper.DataSourceIsEmpty(item))
{
item.CartItemPrice = skuPrice;
ShoppingCartItemInfoProvider.UpdateShoppingCartItemUnits(item, unitCount);
cart.InvalidateCalculations();
}
else
{
ShoppingCartItemParameters parameters = new ShoppingCartItemParameters(product.SKUID, unitCount);
parameters.CustomParameters.Add("CartItemCustomerID", customerAddressID);
ShoppingCartItemInfo cartItem = cart.SetShoppingCartItem(parameters);
cartItem.SetValue("CartItemPrice", skuPrice);
cartItem.SetValue("CartItemDistributorID", customerAddressID);
cartItem.SetValue("CartItemCampaignID", cartItem.SetValue("CartItemCampaignID", campaingnID));
cartItem.SetValue("CartItemProgramID", programID);
ShoppingCartItemInfoProvider.SetShoppingCartItemInfo(cartItem);
}
}
}
catch (Exception ex)
{
EventLogProvider.LogException("CustomerCartOperations.ascx.cs", "Updatingtheunitcountofcartitem()", ex);
}
}
/// <summary>
/// Saves the shopping cart into the database.
/// </summary>
/// <param name="validate">Specifies whether the validation should be performed.</param>
public void Save(bool validate = true)
{
if (validate)
{
var result = Validate();
if (result.CheckFailed)
{
throw new InvalidOperationException();
}
}
SaveCustomer();
SaveAddresses();
ShoppingCartInfoProvider.SetShoppingCartInfo(OriginalCart);
foreach (var item in OriginalCart.CartItems)
{
item.ShoppingCart = OriginalCart;
item.ShoppingCartID = OriginalCart.ShoppingCartID;
ShoppingCartItemInfoProvider.SetShoppingCartItemInfo(item);
}
}
/// <summary>
/// Creates a new shopping cart record and corresponding shopping cart items records in the database
/// as a copy of given shopping cart info.
/// Currency is set according to the currency of given cart.
/// If a configuration of cart item is no longer available it is not cloned to new shopping cart.
/// Correct user id for logged user is _not_ handled in this method, because it does not depend on
/// abandoned cart's user id. It should be handled according to user's status (logged in/anonymous)
/// in the browser where the cart is loaded:
/// - anonymous cart or user's cart opened in the browser where user is logged in - new cart userId should be set to logged user's id
/// - anonymous cart or user's cart opened in the browser where user is _not_ logged in - new cart userId should be empty (anonymous cart)
/// </summary>
/// <param name="originalCart">Original cart to clone.</param>
/// <returns>Created shopping cart info.</returns>
private ShoppingCartInfo CloneShoppingCartInfo(ShoppingCartInfo originalCart)
{
using (new CMSActionContext {
UpdateTimeStamp = false
})
{
ShoppingCartInfo cartClone = ShoppingCartFactory.CreateCart(CurrentSite.SiteID, originalCart.User);
cartClone.ShoppingCartCurrencyID = originalCart.ShoppingCartCurrencyID;
cartClone.ShoppingCartLastUpdate = originalCart.ShoppingCartLastUpdate;
ShoppingCartInfoProvider.SetShoppingCartInfo(cartClone);
ShoppingCartInfoProvider.CopyShoppingCartItems(originalCart, cartClone);
// Set the shopping cart items into the database
foreach (ShoppingCartItemInfo item in cartClone.CartItems)
{
ShoppingCartItemInfoProvider.SetShoppingCartItemInfo(item);
}
return(cartClone);
}
}
protected void RptCartItemCommand(object source, RepeaterCommandEventArgs e)
{
if (e.CommandName.Equals("Remove"))
{
var cartItemGuid = new Guid(e.CommandArgument.ToString());
// Remove product and its product option from list
this.ShoppingCart.RemoveShoppingCartItem(cartItemGuid);
if (!this.ShoppingCartControl.IsInternalOrder)
{
// Delete product from database
ShoppingCartItemInfoProvider.DeleteShoppingCartItemInfo(cartItemGuid);
}
ReloadData();
}
if (e.CommandName.Equals("Decrease"))
{
var cartItemGuid = new Guid(e.CommandArgument.ToString());
ShoppingCartItemInfo cartItem = ShoppingCart.GetShoppingCartItem(cartItemGuid);
if (cartItem != null)
{
if (cartItem.CartItemUnits - 1 > 0)
{
cartItem.CartItemUnits--;
// Update units of child bundle items
foreach (ShoppingCartItemInfo bundleItem in cartItem.BundleItems)
{
bundleItem.CartItemUnits--;
}
if (!ShoppingCartControl.IsInternalOrder)
{
ShoppingCartItemInfoProvider.SetShoppingCartItemInfo(cartItem);
// Update product options in database
foreach (ShoppingCartItemInfo option in cartItem.ProductOptions)
{
ShoppingCartItemInfoProvider.SetShoppingCartItemInfo(option);
}
}
ReloadData();
}
}
}
if (e.CommandName.Equals("Increase"))
{
var cartItemGuid = new Guid(e.CommandArgument.ToString());
ShoppingCartItemInfo cartItem = ShoppingCart.GetShoppingCartItem(cartItemGuid);
if (cartItem != null)
{
if (cartItem.CartItemUnits + 1 > 0)
{
cartItem.CartItemUnits++;
// Update units of child bundle items
foreach (ShoppingCartItemInfo bundleItem in cartItem.BundleItems)
{
bundleItem.CartItemUnits++;
}
if (!ShoppingCartControl.IsInternalOrder)
{
ShoppingCartItemInfoProvider.SetShoppingCartItemInfo(cartItem);
// Update product options in database
foreach (ShoppingCartItemInfo option in cartItem.ProductOptions)
{
ShoppingCartItemInfoProvider.SetShoppingCartItemInfo(option);
}
}
ReloadData();
}
}
}
}
/// <summary>
/// Adds product to the shopping cart.
/// </summary>
private void AddProductToShoppingCart()
{
// Validate input data
if (!IsValid() || (this.SKU == null))
{
// Do not proces
return;
}
if (this.RedirectToDetailsEnabled)
{
if (!this.ShowProductOptions && !this.ShowDonationProperties)
{
// Does product have some enabled product option categories?
bool hasOptions = !DataHelper.DataSourceIsEmpty(OptionCategoryInfoProvider.GetSKUOptionCategories(this.SKUID, true));
// Is product a customizable donation?
bool isCustomizableDonation = ((this.SKU != null) &&
(this.SKU.SKUProductType == SKUProductTypeEnum.Donation) &&
(!((this.SKU.SKUPrice == this.SKU.SKUMinPrice) && (this.SKU.SKUPrice == this.SKU.SKUMaxPrice)) || this.SKU.SKUPrivateDonation));
if (hasOptions || isCustomizableDonation)
{
// Redirect to product details
URLHelper.Redirect("~/CMSPages/GetProduct.aspx?productid=" + this.SKUID);
}
}
}
// Get cart item parameters
ShoppingCartItemParameters cartItemParams = this.GetShoppingCartItemParameters();
// Check if it is possible to add this item to shopping cart
if (!ShoppingCartInfoProvider.CheckNewShoppingCartItems(this.ShoppingCart, cartItemParams))
{
// Show error message and cancel adding the product to shopping cart
string error = String.Format(this.GetString("ecommerce.cartcontent.productdisabled"), this.SKU.SKUName);
ScriptHelper.RegisterStartupScript(this.Page, typeof(string), "ShoppingCartAddItemErrorAlert", ScriptHelper.GetAlertScript(error));
return;
}
// If donation properties are used and donation properties form is not valid
if (this.donationProperties.Visible && !String.IsNullOrEmpty(this.donationProperties.Validate()))
{
return;
}
// Fire on add to shopping cart event
CancelEventArgs eventArgs = new CancelEventArgs();
if (this.OnAddToShoppingCart != null)
{
this.OnAddToShoppingCart(this, eventArgs);
}
// If adding to shopping cart was cancelled
if (eventArgs.Cancel)
{
return;
}
// Get cart item parameters in case something changed
cartItemParams = this.GetShoppingCartItemParameters();
// Log activity
LogProductAddedToSCActivity(this.SKUID, this.SKU.SKUName, this.Quantity);
if (this.ShoppingCart != null)
{
bool updateCart = false;
// Assign current shopping cart to current user
CurrentUserInfo ui = CMSContext.CurrentUser;
if (!ui.IsPublic())
{
this.ShoppingCart.UserInfoObj = ui;
updateCart = true;
}
// Shopping cart is not saved yet
if (this.ShoppingCart.ShoppingCartID == 0)
{
updateCart = true;
}
// Update shopping cart when required
if (updateCart)
{
ShoppingCartInfoProvider.SetShoppingCartInfo(this.ShoppingCart);
}
// Add item to shopping cart
ShoppingCartItemInfo addedItem = this.ShoppingCart.SetShoppingCartItem(cartItemParams);
if (addedItem != null)
{
// Update shopping cart item in database
ShoppingCartItemInfoProvider.SetShoppingCartItemInfo(addedItem);
// Update product options in database
foreach (ShoppingCartItemInfo option in addedItem.ProductOptions)
{
ShoppingCartItemInfoProvider.SetShoppingCartItemInfo(option);
}
// Update bundle items in database
foreach (ShoppingCartItemInfo bundleItem in addedItem.BundleItems)
{
ShoppingCartItemInfoProvider.SetShoppingCartItemInfo(bundleItem);
}
// Track 'Add to shopping cart' conversion
ECommerceHelper.TrackAddToShoppingCartConversion(addedItem);
// If user has to be redirected to shopping cart
if (this.RedirectToShoppingCart)
{
// Set shopping cart referrer
SessionHelper.SetValue("ShoppingCartUrlReferrer", URLHelper.CurrentURL);
// Ensure shopping cart update
SessionHelper.SetValue("checkinventory", true);
// Redirect to shopping cart
URLHelper.Redirect(this.ShoppingCartUrl);
}
else
{
// Localize SKU name
string skuName = (addedItem.SKUObj != null) ? ResHelper.LocalizeString(addedItem.SKUObj.SKUName) : "";
// Check inventory
string checkInventoryMessage = ShoppingCartInfoProvider.CheckShoppingCart(this.ShoppingCart).Replace(";", "\n");
// Get prodcut added message
string message = String.Format(this.GetString("com.productadded"), skuName);
// Add inventory check message
if (!String.IsNullOrEmpty(checkInventoryMessage))
{
message += "\n\n" + checkInventoryMessage;
}
// Count and show total price with options
CalculateTotalPrice();
// Register the call of JS handler informing about added product
ScriptHelper.RegisterStartupScript(this.Page, typeof(string), "ShoppingCartItemAddedHandler", "if (typeof ShoppingCartItemAddedHandler == 'function') { ShoppingCartItemAddedHandler(" + ScriptHelper.GetString(message) + "); }", true);
}
}
}
}
/// <summary>
/// Sets product in the shopping cart.
/// </summary>
/// <param name="itemParams">Shoppping cart item parameters</param>
protected void AddProducts(ShoppingCartItemParameters itemParams)
{
// Get main product info
int productId = itemParams.SKUID;
int quantity = itemParams.Quantity;
if ((productId > 0) && (quantity > 0))
{
// Check product/options combination
if (ShoppingCartInfoProvider.CheckNewShoppingCartItems(ShoppingCartInfoObj, itemParams))
{
// Get requested SKU info object from database
SKUInfo skuObj = SKUInfoProvider.GetSKUInfo(productId);
if (skuObj != null)
{
// On the live site
if (!ShoppingCartControl.IsInternalOrder)
{
bool updateCart = false;
// Assign current shopping cart to current user
CurrentUserInfo ui = CMSContext.CurrentUser;
if (!ui.IsPublic())
{
this.ShoppingCartInfoObj.UserInfoObj = ui;
updateCart = true;
}
// Shopping cart is not saved yet
if (ShoppingCartInfoObj.ShoppingCartID == 0)
{
updateCart = true;
}
// Update shopping cart when required
if (updateCart)
{
ShoppingCartInfoProvider.SetShoppingCartInfo(ShoppingCartInfoObj);
}
// Set item in the shopping cart
ShoppingCartItemInfo product = this.ShoppingCartInfoObj.SetShoppingCartItem(itemParams);
// Update shopping cart item in database
ShoppingCartItemInfoProvider.SetShoppingCartItemInfo(product);
// Update product options in database
foreach (ShoppingCartItemInfo option in product.ProductOptions)
{
ShoppingCartItemInfoProvider.SetShoppingCartItemInfo(option);
}
// Update bundle items in database
foreach (ShoppingCartItemInfo bundleItem in product.BundleItems)
{
ShoppingCartItemInfoProvider.SetShoppingCartItemInfo(bundleItem);
}
// Track add to shopping cart conversion
ECommerceHelper.TrackAddToShoppingCartConversion(product);
}
// In CMSDesk
else
{
// Set item in the shopping cart
this.ShoppingCartInfoObj.SetShoppingCartItem(itemParams);
}
}
}
// Avoid adding the same product after page refresh
if (lblError.Text == "")
{
string url = URLRewriter.CurrentURL;
if (!string.IsNullOrEmpty(URLHelper.GetUrlParameter(url, "productid")) ||
!string.IsNullOrEmpty(URLHelper.GetUrlParameter(url, "quantity")) ||
!string.IsNullOrEmpty(URLHelper.GetUrlParameter(url, "options")))
{
// Remove parameters from URL
url = URLHelper.RemoveParameterFromUrl(url, "productid");
url = URLHelper.RemoveParameterFromUrl(url, "quantity");
url = URLHelper.RemoveParameterFromUrl(url, "options");
URLHelper.Redirect(url);
}
}
}
}
/// <summary>
/// On btnUpdate click event.
/// </summary>
protected void btnUpdate_Click1(object sender, EventArgs e)
{
if (this.ShoppingCartInfoObj != null)
{
this.ShoppingCartInfoObj.ShoppingCartCurrencyID = ValidationHelper.GetInteger(this.selectCurrency.CurrencyID, 0);
// Skip if method was called by btnAddProduct
if (sender != this.btnAddProduct)
{
foreach (GridViewRow row in gridData.Rows)
{
// Get shopping cart item Guid
Guid cartItemGuid = ValidationHelper.GetGuid(((Label)row.Cells[1].Controls[1]).Text, Guid.Empty);
// Try to find shopping cart item in the list
ShoppingCartItemInfo cartItem = this.ShoppingCartInfoObj.GetShoppingCartItem(cartItemGuid);
if (cartItem != null)
{
// If product and its product options should be removed
if (((CheckBox)row.Cells[4].Controls[1]).Checked && (sender != null))
{
// Remove product and its product option from list
this.ShoppingCartInfoObj.RemoveShoppingCartItem(cartItemGuid);
if (!this.ShoppingCartControl.IsInternalOrder)
{
if (CMSContext.ViewMode == ViewModeEnum.LiveSite)
{
// Log activity
if (!cartItem.IsProductOption && !cartItem.IsBundleItem)
{
this.ShoppingCartControl.TrackActivityProductRemovedFromShoppingCart(cartItem.SKUID, ResHelper.LocalizeString(cartItem.SKUObj.SKUName), this.ContactID,
CMSContext.CurrentSiteName, URLHelper.CurrentRelativePath, cartItem.CartItemUnits);
}
}
// Delete product from database
ShoppingCartItemInfoProvider.DeleteShoppingCartItemInfo(cartItemGuid);
}
}
// If product units has changed
else if (!cartItem.IsProductOption)
{
// Get number of units
int itemUnits = ValidationHelper.GetInteger(((TextBox)(row.Cells[6].Controls[1])).Text.Trim(), 0);
if ((itemUnits > 0) && (cartItem.CartItemUnits != itemUnits))
{
// Update units of the parent product
cartItem.CartItemUnits = itemUnits;
// Update units of the child product options
foreach (ShoppingCartItemInfo option in cartItem.ProductOptions)
{
option.CartItemUnits = itemUnits;
}
// Update units of child bundle items
foreach (ShoppingCartItemInfo bundleItem in cartItem.BundleItems)
{
bundleItem.CartItemUnits = itemUnits;
}
if (!this.ShoppingCartControl.IsInternalOrder)
{
ShoppingCartItemInfoProvider.SetShoppingCartItemInfo(cartItem);
// Update product options in database
foreach (ShoppingCartItemInfo option in cartItem.ProductOptions)
{
ShoppingCartItemInfoProvider.SetShoppingCartItemInfo(option);
}
}
}
}
}
}
}
CheckDiscountCoupon();
ReloadData();
if ((ShoppingCartInfoObj.ShoppingCartDiscountCouponID > 0) && (!this.ShoppingCartInfoObj.IsDiscountCouponApplied))
{
// Discount coupon code is valid but not applied to any product of the shopping cart
lblError.Text = GetString("ShoppingCart.DiscountCouponNotApplied");
}
// Inventory shloud be checked
this.checkInventory = true;
}
}
/// <summary>
/// Adds product to the shopping cart.
/// </summary>
private void AddProductToShoppingCart()
{
SKUID = hdnSKUID.Value.ToInteger(0);
// Validate input data
if (!IsValid() || (SKU == null))
{
// Do not process
return;
}
// Try to redirect before any currently selected variant checks (selector in listings issue)
if (RedirectToDetailsEnabled)
{
if (!ShowProductOptions)
{
// Does product have some enabled product option categories?
bool hasOptions = !DataHelper.DataSourceIsEmpty(OptionCategoryInfoProvider.GetProductOptionCategories(SKUID, true));
if (hasOptions)
{
// Redirect to product details
URLHelper.Redirect("~/CMSPages/Ecommerce/GetProduct.aspx?productid=" + SKUID);
}
}
}
if (SKU.HasVariants)
{
// Check if configured variant is available
if ((SelectedVariant == null) || !SelectedVariant.Variant.SKUEnabled)
{
ScriptHelper.RegisterStartupScript(Page, typeof(string), "ShoppingCartAddItemErrorAlert", ScriptHelper.GetAlertScript(GetString("com.cartcontent.nonexistingvariantselected")));
return;
}
}
// Get cart item parameters
var cartItemParams = GetShoppingCartItemParameters();
string error = null;
// Check if it is possible to add this item to shopping cart
if (!Service.Resolve <ICartItemChecker>().CheckNewItem(cartItemParams, ShoppingCart))
{
error = String.Format(GetString("ecommerce.cartcontent.productdisabled"), SKU.SKUName);
}
if (!string.IsNullOrEmpty(error))
{
// Show error message and cancel adding the product to shopping cart
ScriptHelper.RegisterStartupScript(Page, typeof(string), "ShoppingCartAddItemErrorAlert", ScriptHelper.GetAlertScript(error));
return;
}
// Fire on add to shopping cart event
var eventArgs = new CancelEventArgs();
OnAddToShoppingCart?.Invoke(this, eventArgs);
// If adding to shopping cart was canceled
if (eventArgs.Cancel)
{
return;
}
// Get cart item parameters in case something changed
cartItemParams = GetShoppingCartItemParameters();
if (ShoppingCart != null)
{
// Shopping cart is not saved yet
if (ShoppingCart.ShoppingCartID == 0)
{
ShoppingCartInfoProvider.SetShoppingCartInfo(ShoppingCart);
}
// Add item to shopping cart
var addedItem = ShoppingCartInfoProvider.SetShoppingCartItem(ShoppingCart, cartItemParams);
if (addedItem != null)
{
addedItem.CartItemAutoAddedUnits = 0;
// Update shopping cart item in database
ShoppingCartItemInfoProvider.SetShoppingCartItemInfo(addedItem);
// Update product options and bundle items in database
addedItem.ProductOptions.ForEach(ShoppingCartItemInfoProvider.SetShoppingCartItemInfo);
addedItem.BundleItems.ForEach(ShoppingCartItemInfoProvider.SetShoppingCartItemInfo);
if (TrackAddToShoppingCartConversion)
{
// Track 'Add to shopping cart' conversion
ECommerceHelper.TrackAddToShoppingCartConversion(addedItem);
}
// Recalculate shopping cart
ShoppingCart.Evaluate();
// Log activity before possible redirect to shopping cart
LogProductAddedToSCActivity(addedItem);
// If user has to be redirected to shopping cart
if (RedirectToShoppingCart)
{
// Set shopping cart referrer
SessionHelper.SetValue("ShoppingCartUrlReferrer", RequestContext.CurrentURL);
// Ensure shopping cart update
SessionHelper.SetValue("checkinventory", true);
// Redirect to shopping cart
URLHelper.Redirect(UrlResolver.ResolveUrl(ShoppingCartUrl));
}
else
{
// Localize SKU name
string skuName = (addedItem.SKU != null) ? ResHelper.LocalizeString(addedItem.SKU.SKUName) : String.Empty;
// Check inventory
ShoppingCartCheckResult checkResult = ShoppingCartInfoProvider.CheckShoppingCart(ShoppingCart);
string checkInventoryMessage = checkResult.GetFormattedMessage();
// Get product added message
string message = String.Format(GetString("com.productadded"), skuName);
// Add inventory check message
if (!String.IsNullOrEmpty(checkInventoryMessage))
{
message += "\n\n" + checkInventoryMessage;
}
// Count and show total price with options
CalculateTotalPrice();
// Register the call of JS handler informing about added product
ScriptHelper.RegisterStartupScript(Page, typeof(string), "ShoppingCartItemAddedHandler", "if (typeof ShoppingCartItemAddedHandler == 'function') { ShoppingCartItemAddedHandler(" + ScriptHelper.GetString(message) + "); }", true);
}
}
}
}