/// <summary>
/// Checks stock for given product
/// </summary>
/// <param name="productId">Id of the product to check stock for</param>
/// <param name="optionList">The option list of the product to check stock for</param>
/// <param name="kitProductIds">If its a kit product the Ids of the kit products to check stock for</param>
/// <returns>InventoryManagerData object containing stock details for the given product</returns>
public static InventoryManagerData CheckStock(int productId, string optionList, List <int> kitProductIds)
{
Product product = ProductDataSource.Load(productId);
if (product == null)
{
throw new InvalidProductException();
}
if (kitProductIds == null)
{
kitProductIds = new List <int>();
}
ProductVariant variant = null;
if (!string.IsNullOrEmpty(optionList))
{
variant = ProductVariantDataSource.LoadForOptionList(productId, optionList);
}
List <KitProduct> kitProducts = new List <KitProduct>();
foreach (int kpid in kitProductIds)
{
KitProduct kp = KitProductDataSource.Load(kpid);
if (kp != null)
{
kitProducts.Add(kp);
}
}
return(CheckStock(product, variant, kitProducts));
}
protected void KitProductList_RowCommand(object sender, GridViewCommandEventArgs e)
{
if (e.CommandName == "DoDelete")
{
int kitProductId = AlwaysConvert.ToInt(e.CommandArgument);
KitProduct kitProduct = KitProductDataSource.Load(kitProductId);
if (kitProduct != null)
{
int index = kitProduct.KitComponent.KitProducts.IndexOf(kitProductId);
if (index >= 0)
{
kitProduct.KitComponent.KitProducts.RemoveAt(index);
}
kitProduct.Delete();
}
}
}
protected void Page_Init(object sender, EventArgs e)
{
//INITIALIZE VARIABLES
_CategoryId = AbleCommerce.Code.PageHelper.GetCategoryId();
_Category = CategoryDataSource.Load(_CategoryId);
_ProductId = AlwaysConvert.ToInt(Request.QueryString["ProductId"]);
_Product = ProductDataSource.Load(_ProductId);
if (_Product == null)
{
Response.Redirect(AbleCommerce.Code.NavigationHelper.GetAdminUrl("Catalog/Browse.aspx"));
}
_KitProductId = AlwaysConvert.ToInt(Request.QueryString["KitProductId"]);
_KitProduct = KitProductDataSource.Load(_KitProductId);
if (_KitProduct == null)
{
Response.Redirect("EditKit.aspx?CategoryId=" + _CategoryId.ToString() + "&ProductId=" + _ProductId.ToString());
}
_KitComponentId = _KitProduct.KitComponentId;
_KitComponent = _KitProduct.KitComponent;
//INITIALIZE PAGE ELEMENTS
Caption.Text = string.Format(Caption.Text, _KitComponent.Name);
KitName.Text = _Product.Name;
KitComponentName.Text = _KitComponent.Name;
SelectedProductName.Text = _KitProduct.Product.Name;
DisplayName.Text = _KitProduct.Name;
KitQuantity.Text = _KitProduct.Quantity.ToString();
ProductPrice.Text = _KitProduct.Product.Price.LSCurrencyFormat("lc");
PriceMode.SelectedIndex = (int)_KitProduct.PriceMode;
PriceMode_SelectedIndexChanged(sender, e);
Price.Text = string.Format("{0:F2}", _KitProduct.Price);
ProductWeight.Text = string.Format("{0:F2}", _KitProduct.Product.Weight);
WeightMode.SelectedIndex = (int)_KitProduct.WeightMode;
WeightMode_SelectedIndexChanged(sender, e);
Weight.Text = string.Format("{0:F2}", _KitProduct.Weight);
phOptions.Controls.Clear();
selectedOptions = AbleCommerce.Code.ProductHelper.BuildProductOptions(_KitProduct, phOptions);
IsSelected.Checked = _KitProduct.IsSelected;
WeightUnit.Text = AbleContext.Current.Store.WeightUnit.ToString();
}
/// <summary>
/// Gets a list of KitProduct objects associated with this BasketItem
/// </summary>
/// <param name="includeHidden">If true, items in hidden components are included. If false, only items in visible component are included.</param>
/// <returns>A list of KitProduct objects</returns>
public List <KitProduct> GetKitProducts(bool includeHidden)
{
// BUILD LIST OF KIT PRODUCTS
List <KitProduct> kitProductList = new List <KitProduct>();
int[] kitProductIds = AlwaysConvert.ToIntArray(this.KitList);
if (kitProductIds != null && kitProductIds.Length > 0)
{
for (int i = 0; i < kitProductIds.Length; i++)
{
KitProduct kp = KitProductDataSource.Load(kitProductIds[i]);
if (kp != null)
{
bool addToList = (includeHidden || (kp.KitComponent.InputType != KitInputType.IncludedHidden));
if (addToList)
{
kitProductList.Add(kp);
}
}
}
}
return(kitProductList);
}
/// <summary>
/// Recalculates all items in the basket, for example price and kit member products
/// </summary>
internal void Recalculate()
{
// BUILD A LIST OF ANY CHILD (GENERATED) PRODUCTS
List <int> childItemIds = new List <int>();
List <BasketItem> childProducts = new List <BasketItem>();
foreach (BasketItem item in this)
{
if (item.OrderItemType == OrderItemType.Product && item.IsChildItem)
{
childItemIds.Add(item.BasketItemId);
childProducts.Add(item);
}
}
// MOVE THROUGH THE COLLECTION AND REMOVE ANY ITEMS ASSOCIATED WITH A CHILD ITEM
for (int i = this.Count - 1; i >= 0; i--)
{
BasketItem item = this[i];
List <int> childPath = item.GetPath();
if (IsChildItemInPath(childItemIds, childPath))
{
if (item.OrderItemType == OrderItemType.Product)
{
this.RemoveAt(i);
}
else
{
this.DeleteAt(i);
}
}
}
// LOOP EACH REMAINING ITEM AND RECALCULATE
int currentCount = this.Count;
for (int i = 0; i < currentCount; i++)
{
BasketItem basketItem = this[i];
Basket basket = basketItem.Basket;
int userId = (basket == null ? Token.Instance.UserId : basket.UserId);
// WE ONLY NEED TO CHECK PRODUCTS, NON-PRODUCT ITEMS HAVE NO RECALCULATION TASKS
if (basketItem.OrderItemType == OrderItemType.Product)
{
// IF WE HAVE A KIT, WE MUST REFRESH ANY CONFIGURED KIT OPTIONS
bool isKit = (basketItem.Product.KitStatus == KitStatus.Master);
if (isKit)
{
basketItem.KitList = basketItem.Product.Kit.RefreshKitProducts(basketItem.KitList);
}
// RECALCULATE THE STARTING SKU/PRICE/WEIGHT FOR THIS ITEM
ProductCalculator pcalc = ProductCalculator.LoadForProduct(basketItem.ProductId, basketItem.Quantity, basketItem.OptionList, basketItem.KitList, userId);
basketItem.Sku = pcalc.Sku;
basketItem.Weight = pcalc.Weight;
if (isKit || !basketItem.Product.UseVariablePrice)
{
// KITS AND NONVARIABLE PRICED PRODUCTS MUST HAVE PRICE RECALCULATED
basketItem.Price = pcalc.Price;
}
basketItem.Save();
// REGENERATE THE KIT ITEMS FOR THIS ITEM
if (basket != null && isKit)
{
// OBTAIN THE KIT PRODUCTS THAT ARE SELECTED RATHER THAN INCLUDED
int[] kitProductIds = AlwaysConvert.ToIntArray(basketItem.KitList);
if (kitProductIds != null && kitProductIds.Length > 0)
{
//keep track of the price/weight of the master line item
//decrement these values for each line item registered
LSDecimal masterPrice = basketItem.Price;
LSDecimal masterWeight = basketItem.Weight;
foreach (int kitProductId in kitProductIds)
{
KitProduct kitProduct = KitProductDataSource.Load(kitProductId);
if (kitProduct != null && kitProduct.KitComponent.InputType != KitInputType.IncludedHidden)
{
// WE WANT TO GENERATE BASKET RECORDS FOR ALL ITEMS *EXCEPT* INCLUDED HIDDEN ITEMS
// INCLUDED HIDDEN ITEMS ARE TREATED AS PART OF THE MAIN PRODUCT AND ARE NOT GENERATED
// UNTIL THE ORDER IS FINALIZED
Product product = kitProduct.Product;
BasketItem searchItem = new BasketItem();
searchItem.BasketId = basket.BasketId;
searchItem.OrderItemType = OrderItemType.Product;
searchItem.ParentItemId = basketItem.BasketItemId;
searchItem.ProductId = product.ProductId;
searchItem.OptionList = kitProduct.OptionList;
searchItem.BasketShipmentId = basketItem.BasketShipmentId;
// LOOK FOR ITEM
BasketItem childItem = FindChildProduct(childProducts, searchItem);
// UPDATE CALCULATED PROPERTIES
childItem.Name = kitProduct.DisplayName;
childItem.Quantity = (short)(kitProduct.Quantity * basketItem.Quantity);
childItem.TaxCodeId = product.TaxCodeId;
childItem.Shippable = product.Shippable;
childItem.Price = kitProduct.CalculatedPrice / kitProduct.Quantity;;
childItem.Weight = kitProduct.CalculatedWeight / kitProduct.Quantity;
// CALCULATE SKU
ProductCalculator childCalc = ProductCalculator.LoadForProduct(childItem.ProductId, childItem.Quantity, childItem.OptionList, childItem.KitList, basket.UserId);
childItem.Sku = childCalc.Sku;
basket.Items.Add(childItem);
childItem.Save();
masterPrice -= kitProduct.CalculatedPrice;
masterWeight -= kitProduct.CalculatedWeight;
}
}
// UPDATE MASTER PRICE, FACTORING IN CHILD ITEMS
basketItem.Price = masterPrice;
basketItem.Weight = masterWeight;
basketItem.Save();
}
}
}
}
// DELETE ANY CHILD PRODUCTS THAT WERE NOT PRESERVED
foreach (BasketItem bi in childProducts)
{
bi.Delete();
}
}
public static List <AbleCommerce.Code.ProductAssetWrapper> GetAssets(Page page, Product product, string optionList, string kitList, string returnUrl)
{
// BUILD LIST OF ASSETS
List <string> assetTracker = new List <string>();
string encodedReturnUrl;
if (!string.IsNullOrEmpty(returnUrl))
{
encodedReturnUrl = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(returnUrl));
}
else
{
encodedReturnUrl = string.Empty;
}
List <AbleCommerce.Code.ProductAssetWrapper> assetList = new List <AbleCommerce.Code.ProductAssetWrapper>();
string agreeUrl = page.ResolveUrl("~/ViewLicenseAgreement.aspx") + "?id={0}&ReturnUrl=" + encodedReturnUrl;
string agreePopup = agreeUrl + "\" onclick=\"" + AbleCommerce.Code.PageHelper.GetPopUpScript(agreeUrl, "license", 640, 480, "resizable=1,scrollbars=yes,toolbar=no,menubar=no,location=no,directories=no") + ";return false";
string readmeUrl = page.ResolveUrl("~/ViewReadme.aspx") + "?ReadmeId={0}&ReturnUrl=" + encodedReturnUrl;
string readmePopup = readmeUrl + "\" onclick=\"" + AbleCommerce.Code.PageHelper.GetPopUpScript(readmeUrl, "readme", 640, 480, "resizable=1,scrollbars=yes,toolbar=no,menubar=no,location=no,directories=no") + ";return false";
List <ProductAndOptionList> products = new List <ProductAndOptionList>();
products.Add(new ProductAndOptionList(product, optionList));
// IF IT IS A KIT LOOK FOR CHILD PRODUCTS AS WELL
if (!String.IsNullOrEmpty(kitList))
{
if (product.IsKit)
{
bool kitIsBundled = !product.Kit.ItemizeDisplay;
int[] kitProductIds = AlwaysConvert.ToIntArray(kitList);
if (kitProductIds != null && kitProductIds.Length > 0)
{
foreach (int kitProductId in kitProductIds)
{
KitProduct kitProduct = KitProductDataSource.Load(kitProductId);
if ((kitProduct != null) &&
(kitProduct.KitComponent.InputType == KitInputType.IncludedHidden || kitIsBundled))
{
products.Add(new ProductAndOptionList(kitProduct.Product, kitProduct.OptionList));
}
}
}
}
}
foreach (ProductAndOptionList pol in products)
{
foreach (ProductDigitalGood pdg in pol.Product.DigitalGoods)
{
if ((string.IsNullOrEmpty(pdg.OptionList)) || (pol.OptionList == pdg.OptionList))
{
DigitalGood digitalGood = pdg.DigitalGood;
Readme readme = digitalGood.Readme;
if (readme != null && assetTracker.IndexOf("R" + readme.Id.ToString()) < 0)
{
assetList.Add(new AbleCommerce.Code.ProductAssetWrapper(string.Format(readmePopup, readme.Id), readme.DisplayName));
assetTracker.Add("R" + readme.Id.ToString());
}
LicenseAgreement agreement = digitalGood.LicenseAgreement;
if (agreement != null && assetTracker.IndexOf("L" + agreement.Id.ToString()) < 0)
{
assetList.Add(new AbleCommerce.Code.ProductAssetWrapper(string.Format(agreePopup, agreement.Id), agreement.DisplayName));
assetTracker.Add("L" + agreement.Id.ToString());
}
}
}
}
return(assetList);
}
private void Calculate()
{
Product product = ProductDataSource.Load(_ProductId);
if (product != null)
{
if (string.IsNullOrEmpty(_OptionList))
{
//NO VARIANT, SET VALUES FROM BASE PRODCUT
_Sku = product.Sku;
_Price = GetPriceFromRules(product);
_Weight = product.Weight;
}
else
{
//VARIANT PRESENT, CHECK VARIANT FOR CORRECT VALUES
ProductVariant variant = ProductVariantDataSource.LoadForOptionList(_ProductId, _OptionList);
if (variant == null)
{
throw new InvalidOptionsException("The options specified for " + product.Name + " are invalid.");
}
_Sku = variant.Sku;
if (variant.Price != 0)
{
if (variant.PriceMode == ModifierMode.Modify)
{
_Price = GetPriceFromRules(product) + variant.Price;
}
else
{
_Price = variant.Price;
}
}
else
{
_Price = GetPriceFromRules(product);
}
if (variant.Weight != 0)
{
if (variant.WeightMode == ModifierMode.Modify)
{
_Weight = product.Weight + variant.Weight;
}
else
{
_Weight = variant.Weight;
}
}
else
{
_Weight = product.Weight;
}
}
// CALCULATE PRICE WITH TAX IF SPECIFIED
if (_CalculateTax)
{
_PriceWithTax = TaxHelper.GetShopPrice(_Price, product.TaxCodeId);
}
//CHECK FOR KIT PRODUCTS
if (_KitProductIds != null)
{
foreach (int kitProductId in _KitProductIds)
{
KitProduct kp = KitProductDataSource.Load(kitProductId);
if (kp != null)
{
_Price += kp.CalculatedPrice;
_Weight += kp.CalculatedWeight;
// CALCULATE PRICE WITH TAX IF SPECIFIED
if (_CalculateTax)
{
int taxCodeId = 0;
KitComponent component = kp.KitComponent;
if (component.InputType == KitInputType.IncludedHidden)
{
taxCodeId = product.TaxCodeId;
}
else if (kp.Product != null)
{
taxCodeId = kp.Product.TaxCodeId;
}
_PriceWithTax += TaxHelper.GetShopPrice(kp.CalculatedPrice, taxCodeId);
}
}
}
}
_Calculated = true;
}
}
/// <summary>
/// Saves this KitProduct object to the database.
/// </summary>
/// <returns><b>SaveResult</b> enumeration that represents the result of the save operation.</returns>
public virtual SaveResult Save()
{
if (this.IsDirty)
{
Database database = Token.Instance.Database;
bool recordExists = true;
if (this.KitProductId == 0)
{
recordExists = false;
}
if (this.OrderBy < 0)
{
this.OrderBy = KitProductDataSource.GetNextOrderBy(this.KitComponentId);
}
if (recordExists)
{
//verify whether record is already present
StringBuilder selectQuery = new StringBuilder();
selectQuery.Append("SELECT COUNT(*) As RecordCount FROM ac_KitProducts");
selectQuery.Append(" WHERE KitProductId = @KitProductId");
using (DbCommand selectCommand = database.GetSqlStringCommand(selectQuery.ToString()))
{
database.AddInParameter(selectCommand, "@KitProductId", System.Data.DbType.Int32, this.KitProductId);
if ((int)database.ExecuteScalar(selectCommand) == 0)
{
recordExists = false;
}
}
}
int result = 0;
if (recordExists)
{
//UPDATE
StringBuilder updateQuery = new StringBuilder();
updateQuery.Append("UPDATE ac_KitProducts SET ");
updateQuery.Append("KitComponentId = @KitComponentId");
updateQuery.Append(", ProductId = @ProductId");
updateQuery.Append(", OptionList = @OptionList");
updateQuery.Append(", Name = @Name");
updateQuery.Append(", Quantity = @Quantity");
updateQuery.Append(", Price = @Price");
updateQuery.Append(", PriceModeId = @PriceModeId");
updateQuery.Append(", Weight = @Weight");
updateQuery.Append(", WeightModeId = @WeightModeId");
updateQuery.Append(", IsSelected = @IsSelected");
updateQuery.Append(", OrderBy = @OrderBy");
updateQuery.Append(" WHERE KitProductId = @KitProductId");
using (DbCommand updateCommand = database.GetSqlStringCommand(updateQuery.ToString()))
{
database.AddInParameter(updateCommand, "@KitProductId", System.Data.DbType.Int32, this.KitProductId);
database.AddInParameter(updateCommand, "@KitComponentId", System.Data.DbType.Int32, this.KitComponentId);
database.AddInParameter(updateCommand, "@ProductId", System.Data.DbType.Int32, this.ProductId);
database.AddInParameter(updateCommand, "@OptionList", System.Data.DbType.String, NullableData.DbNullify(this.OptionList));
database.AddInParameter(updateCommand, "@Name", System.Data.DbType.String, this.Name);
database.AddInParameter(updateCommand, "@Quantity", System.Data.DbType.Int16, this.Quantity);
database.AddInParameter(updateCommand, "@Price", System.Data.DbType.Decimal, this.Price);
database.AddInParameter(updateCommand, "@PriceModeId", System.Data.DbType.Byte, this.PriceModeId);
database.AddInParameter(updateCommand, "@Weight", System.Data.DbType.Decimal, this.Weight);
database.AddInParameter(updateCommand, "@WeightModeId", System.Data.DbType.Byte, this.WeightModeId);
database.AddInParameter(updateCommand, "@IsSelected", System.Data.DbType.Boolean, this.IsSelected);
database.AddInParameter(updateCommand, "@OrderBy", System.Data.DbType.Int16, this.OrderBy);
//RESULT IS NUMBER OF RECORDS AFFECTED
result = database.ExecuteNonQuery(updateCommand);
}
}
else
{
//INSERT
StringBuilder insertQuery = new StringBuilder();
insertQuery.Append("INSERT INTO ac_KitProducts (KitComponentId, ProductId, OptionList, Name, Quantity, Price, PriceModeId, Weight, WeightModeId, IsSelected, OrderBy)");
insertQuery.Append(" VALUES (@KitComponentId, @ProductId, @OptionList, @Name, @Quantity, @Price, @PriceModeId, @Weight, @WeightModeId, @IsSelected, @OrderBy)");
insertQuery.Append("; SELECT Scope_Identity()");
using (DbCommand insertCommand = database.GetSqlStringCommand(insertQuery.ToString()))
{
database.AddInParameter(insertCommand, "@KitProductId", System.Data.DbType.Int32, this.KitProductId);
database.AddInParameter(insertCommand, "@KitComponentId", System.Data.DbType.Int32, this.KitComponentId);
database.AddInParameter(insertCommand, "@ProductId", System.Data.DbType.Int32, this.ProductId);
database.AddInParameter(insertCommand, "@OptionList", System.Data.DbType.String, NullableData.DbNullify(this.OptionList));
database.AddInParameter(insertCommand, "@Name", System.Data.DbType.String, this.Name);
database.AddInParameter(insertCommand, "@Quantity", System.Data.DbType.Int16, this.Quantity);
database.AddInParameter(insertCommand, "@Price", System.Data.DbType.Decimal, this.Price);
database.AddInParameter(insertCommand, "@PriceModeId", System.Data.DbType.Byte, this.PriceModeId);
database.AddInParameter(insertCommand, "@Weight", System.Data.DbType.Decimal, this.Weight);
database.AddInParameter(insertCommand, "@WeightModeId", System.Data.DbType.Byte, this.WeightModeId);
database.AddInParameter(insertCommand, "@IsSelected", System.Data.DbType.Boolean, this.IsSelected);
database.AddInParameter(insertCommand, "@OrderBy", System.Data.DbType.Int16, this.OrderBy);
//RESULT IS NEW IDENTITY;
result = AlwaysConvert.ToInt(database.ExecuteScalar(insertCommand));
this._KitProductId = result;
}
}
//OBJECT IS DIRTY IF NO RECORDS WERE UPDATED OR INSERTED
this.IsDirty = (result == 0);
if (this.IsDirty)
{
return(SaveResult.Failed);
}
else
{
return(recordExists ? SaveResult.RecordUpdated : SaveResult.RecordInserted);
}
}
//SAVE IS SUCCESSFUL IF OBJECT IS NOT DIRTY
return(SaveResult.NotDirty);
}
/// <summary>
/// Gets the order items that would result from the addition of the given product to an order.
/// </summary>
/// <param name="productId">The id of the product to add.</param>
/// <param name="quantity">The quantity of the product to add.</param>
/// <param name="optionList">List of option choice ids if this is a variant</param>
/// <param name="kitList">List of kit products if it is a Kit</param>
/// <returns>The order items that would result from the addition of the given product to an order</returns>
public static List <OrderItem> CreateForProduct(int productId, short quantity, string optionList, string kitList)
{
List <OrderItem> orderItems = new List <OrderItem>();
Product product = ProductDataSource.Load(productId);
if (product != null)
{
//CREATE THE BASE ORDER ITEM
OrderItem baseItem = new OrderItem();
baseItem.Name = product.Name;
baseItem.OrderItemType = OrderItemType.Product;
baseItem.ProductId = productId;
baseItem.TaxCodeId = product.TaxCodeId;
baseItem.Quantity = quantity;
baseItem.ShippableId = product.ShippableId;
//CALCULATE THE PRICE OF THE PRODUCT
ProductCalculator pcalc = ProductCalculator.LoadForProduct(productId, quantity, optionList, kitList);
baseItem.Sku = pcalc.Sku;
baseItem.Price = pcalc.Price;
baseItem.Weight = pcalc.Weight;
//CHECK PRODUCT VARIANT
ProductVariant variant = ProductVariantDataSource.LoadForOptionList(productId, optionList);
if (variant != null)
{
baseItem.OptionList = optionList;
baseItem.VariantName = variant.VariantName;
}
//CHECK FOR DIGITAL GOODS
foreach (ProductDigitalGood dg in product.DigitalGoods)
{
if (dg.DigitalGood != null && (String.IsNullOrEmpty(baseItem.OptionList) || baseItem.OptionList == dg.OptionList))
{
OrderItemDigitalGood oidg = new OrderItemDigitalGood();
oidg.OrderItemId = baseItem.OrderItemId;
oidg.DigitalGoodId = dg.DigitalGoodId;
oidg.Name = dg.DigitalGood.Name;
baseItem.DigitalGoods.Add(oidg);
}
}
orderItems.Add(baseItem);
//CHECK FOR KIT ITEMS
int[] kitProductIds = AlwaysConvert.ToIntArray(kitList);
if (kitProductIds != null && kitProductIds.Length > 0)
{
LSDecimal baseItemPrice = baseItem.Price;
LSDecimal baseItemWeight = baseItem.Weight;
foreach (int kitProductId in kitProductIds)
{
KitProduct kitProduct = KitProductDataSource.Load(kitProductId);
if (kitProduct != null)
{
OrderItem kitItem = new OrderItem();
kitItem.Name = kitProduct.DisplayName;
kitItem.OrderItemType = OrderItemType.Product;
kitItem.ParentItemId = baseItem.OrderItemId;
kitItem.ProductId = kitProduct.ProductId;
kitItem.OptionList = kitProduct.OptionList;
kitItem.Quantity = (short)(kitProduct.Quantity * baseItem.Quantity);
kitItem.Sku = kitProduct.Product.Sku;
kitItem.TaxCodeId = kitProduct.Product.TaxCodeId;
kitItem.Price = kitProduct.CalculatedPrice / kitProduct.Quantity;
kitItem.Weight = kitProduct.CalculatedWeight / kitProduct.Quantity;
//CHECK FOR DIGITAL GOODS
foreach (DigitalGood dg in kitItem.Product.DigitalGoods)
{
OrderItemDigitalGood oidg = new OrderItemDigitalGood();
oidg.OrderItemId = kitItem.OrderItemId;
oidg.DigitalGoodId = dg.DigitalGoodId;
kitItem.DigitalGoods.Add(oidg);
}
baseItemPrice -= kitProduct.CalculatedPrice;
baseItemWeight -= kitProduct.CalculatedWeight;
orderItems.Add(kitItem);
}
}
baseItem.Price = baseItemPrice;
baseItem.Weight = baseItemWeight;
}
}
return(orderItems);
}
/// <summary>
/// Converts kit product assoications into order line items for a basket that is
/// being finalized.
/// </summary>
/// <param name="basket">The basket checking out</param>
/// <param name="order">The order being created</param>
/// <param name="idLookup">A translation table to map basket ids to order ids</param>
internal static void GenerateKitProducts(Basket basket, Order order, Dictionary <string, int> idLookup)
{
foreach (BasketItem basketItem in basket.Items)
{
if (basketItem.OrderItemType == OrderItemType.Product)
{
int[] kitProductIds = AlwaysConvert.ToIntArray(basketItem.KitList);
if (kitProductIds != null && kitProductIds.Length > 0)
{
//keep track of the price/weight of the master line item
//decrement these values for each line item registered
LSDecimal masterPrice = basketItem.Price;
LSDecimal masterWeight = basketItem.Weight;
foreach (int kitProductId in kitProductIds)
{
// WE ONLY NEED TO GENERATE RECORDS FOR THE HIDDEN ITEMS
// VISIBLE KIT MBMER PRODUCTS ARE GENERATED DURING THE BASKET RECALCULATION
KitProduct kp = KitProductDataSource.Load(kitProductId);
if (kp.KitComponent.InputType == KitInputType.IncludedHidden)
{
Product p = kp.Product;
ProductVariant pv = kp.ProductVariant;
OrderItem item = new OrderItem();
item.OrderId = order.OrderId;
// SET THE PARENT ITEM ID FOR THIS ITEM
if (idLookup.ContainsKey("I" + basketItem.BasketItemId))
{
item.ParentItemId = idLookup["I" + basketItem.BasketItemId];
}
item.OrderItemType = OrderItemType.Product;
if (idLookup.ContainsKey("S" + basketItem.BasketShipmentId))
{
item.OrderShipmentId = idLookup["S" + basketItem.BasketShipmentId];
}
if (idLookup.ContainsKey("I" + basketItem.BasketItemId))
{
item.ParentItemId = idLookup["I" + basketItem.BasketItemId];
}
item.ProductId = kp.ProductId;
item.Name = kp.DisplayName;
item.OptionList = kp.OptionList;
if (pv != null)
{
item.VariantName = pv.VariantName;
item.Sku = pv.Sku;
}
else
{
item.Sku = p.Sku;
}
item.Quantity = (short)(kp.Quantity * basketItem.Quantity);
item.TaxCodeId = p.TaxCodeId;
//THE CALCULATED PRICE IS FOR ALL ITEMS (EXT PRICE)
//TO GET A LINE ITEM PRICE WE MUST DIVIDE BY QUANTITY
item.Price = kp.CalculatedPrice / kp.Quantity;
item.Weight = kp.CalculatedWeight / kp.Quantity;
item.CostOfGoods = p.CostOfGoods;
item.WishlistItemId = basketItem.WishlistItemId;
item.WrapStyleId = basketItem.WrapStyleId;
item.IsHidden = (kp.KitComponent.InputType == KitInputType.IncludedHidden);
//USE PARENT SHIPPABLE STATUS FOR HIDDEN KITTED PRODUCTS
item.Shippable = basketItem.Shippable;
item.Save();
order.Items.Add(item);
masterPrice -= kp.CalculatedPrice;
masterWeight -= kp.CalculatedWeight;
}
}
//UPDATE THE PRICE OF THE KIT LINE ITEM (BASE PRICE OF PRODUCT LESS KIT PARTS)
if (idLookup.ContainsKey("I" + basketItem.BasketItemId))
{
int index = order.Items.IndexOf(idLookup["I" + basketItem.BasketItemId]);
if (index > -1)
{
order.Items[index].Price = masterPrice;
order.Items[index].Weight = masterWeight;
order.Items[index].Save();
}
}
}
}
}
}
public static Basket GetAcBasket(AutoGen.ShoppingCart shoppingcart, bool clearShipNTax)
{
TraceContext trace = WebTrace.GetTraceContext();
string traceKey = "GoogleCheckout.AC.AcHelper";
trace.Write(traceKey, "Begin AcHelper.GetAcBasket");
int basketId = AcHelper.GetAcBasketId(shoppingcart);
trace.Write(traceKey, "Look for basket ID " + basketId.ToString());
Basket basket = BasketDataSource.Load(basketId, false);
if (basket == null)
{
trace.Write(traceKey, "Basket not found. Creating New Basket.");
basket = new Basket();
}
else
{
//basket found. check if content hash matches
string contentHash = GetReportedBasketHash(shoppingcart);
if (contentHash.Equals(GetAcBasketHash(basket)))
{
//hash matched. basket has not changed.
if (clearShipNTax)
{
ClearShippingAndTaxes(basket);
}
return(basket);
}
}
trace.Write(traceKey, "Clear existing Basket contents and populate with Google Input.");
basket.Clear();
if (shoppingcart.items != null)
{
trace.Write(traceKey, "Looping " + shoppingcart.items.Length.ToString() + " items in Google cart");
}
foreach (Item thisItem in shoppingcart.items)
{
trace.Write(traceKey, "itemName: " + thisItem.itemname);
BasketItem basketItem = new BasketItem();
basketItem.Name = thisItem.itemname;
basketItem.Quantity = (short)thisItem.quantity;
basketItem.Price = thisItem.unitprice.Value;
XmlNode[] privateNodes = thisItem.merchantprivateitemdata.Any;
foreach (XmlNode privateNode in privateNodes)
{
trace.Write(traceKey, "privateNode.Name: " + privateNode.Name);
switch (privateNode.Name)
{
case "productId":
basketItem.ProductId = AlwaysConvert.ToInt(privateNode.InnerText);
break;
case "orderItemType":
basketItem.OrderItemType = (OrderItemType)AlwaysConvert.ToEnum(typeof(OrderItemType), privateNode.InnerText, OrderItemType.Product, true);
break;
case "shippable":
basketItem.Shippable = (Shippable)AlwaysConvert.ToEnum(typeof(Shippable), privateNode.InnerText, Shippable.Yes, true);
break;
case "taxCodeId":
basketItem.TaxCodeId = AlwaysConvert.ToInt(privateNode.InnerText);
break;
case "weight":
basketItem.Weight = AlwaysConvert.ToDecimal(privateNode.InnerText);
break;
case "wrapStyleId":
basketItem.WrapStyleId = AlwaysConvert.ToInt(privateNode.InnerText);
break;
case "optionList":
basketItem.OptionList = privateNode.InnerText;
break;
case "giftMessage":
basketItem.GiftMessage = privateNode.InnerText;
break;
case "lineMessage":
basketItem.LineMessage = privateNode.InnerText;
break;
case "lastModifiedDate":
basketItem.LastModifiedDate = AlwaysConvert.ToDateTime(privateNode.InnerText, LocaleHelper.LocalNow);
break;
case "orderBy":
basketItem.OrderBy = AlwaysConvert.ToInt16(privateNode.InnerText);
break;
case "parentItemId":
basketItem.ParentItemId = AlwaysConvert.ToInt(privateNode.InnerText);
break;
case "sku":
basketItem.Sku = privateNode.InnerText;
break;
case "wishlistItemId":
basketItem.WishlistItemId = AlwaysConvert.ToInt(privateNode.InnerText);
break;
case "basketItemKitProducts":
List <string> kitList = new List <string>();
foreach (XmlNode subNode in privateNode.ChildNodes)
{
if (subNode.Name.Equals("kitProductId"))
{
int kitProductId = AlwaysConvert.ToInt(subNode.InnerText);
KitProduct kitProd = KitProductDataSource.Load(kitProductId);
if (kitProd != null)
{
kitList.Add(kitProductId.ToString());
}
}
}
if (kitList.Count > 0)
{
basketItem.KitList = string.Join(",", kitList.ToArray());
}
break;
case "inputs":
foreach (XmlNode subNode in privateNode.ChildNodes)
{
if (subNode.Name.Equals("itemInput"))
{
int inputFieldId = 0;
foreach (XmlAttribute attr in subNode.Attributes)
{
if (attr.Name.Equals("inputFieldId"))
{
inputFieldId = AlwaysConvert.ToInt(attr.InnerText);
break;
}
}
InputField inputField = InputFieldDataSource.Load(inputFieldId);
if (inputField != null)
{
BasketItemInput bInput = new BasketItemInput();
bInput.InputFieldId = inputFieldId;
bInput.InputValue = subNode.InnerText;
basketItem.Inputs.Add(bInput);
}
}
}
break;
case "couponCode":
basketItem.Sku = privateNode.InnerText;
break;
}
}
basket.Items.Add(basketItem);
}
trace.Write(traceKey, "Saving basket");
basket.Save();
string key = "Basket_" + basket.BasketId.ToString();
ContextCache.SetObject(key, basket);
trace.Write(traceKey, "Basket created, returning to caller (End GetAcBasket)");
return(basket);
}
){kind=link}
){kind=link}
){kind=link}
){kind=link}
){kind=link}
){kind=link}