public ActionResult AjaxGetKitData(KitAddToCartPostModel model)
{
var product = new Product(model.ProductId);
if (model.VariantId == 0)
{
model.VariantId = AppLogic.GetDefaultProductVariant(model.ProductId);
}
var variant = new ProductVariant(model.VariantId);
var customer = HttpContext.GetCustomer();
var cartType = model.IsWishlist
? CartTypeEnum.WishCart
: CartTypeEnum.ShoppingCart;
if (!product.IsAKit)
{
return(Content(string.Empty));
}
KitProductData kitData = KitProductData.Find(
productId: product.ProductID,
cartRecId: model.CartRecordId.HasValue
? model.CartRecordId.Value
: 0,
thisCustomer: customer);
// Manipulate the default selections to reflect the selections made so far
var selectedItems = model.GetSelectedItems(kitData);
foreach (var item in kitData.Groups.SelectMany(g => g.Items))
{
if (selectedItems.Contains(item))
{
item.IsSelected = true;
}
else
{
item.IsSelected = false;
}
}
var quantity = Math.Max(model.Quantity, 1);
var kitAddToCartViewModel = BuildDefaultKitAddToCartViewModel(kitData, product, variant, quantity, customer, model.CartRecordId);
var itemDisplayNames = kitAddToCartViewModel.KitGroups
.SelectMany(group => group.Items)
.ToDictionary(item => item.Id.ToString(), item => item.NameDisplay);
return(Json(
new AjaxKitDataViewModel
{
SummaryHtml = ControllerContext.GetHtmlHelper().Partial(
partialViewName: ViewNames.KitSummaryPartial,
model: kitAddToCartViewModel).ToString(),
ItemDisplayNames = itemDisplayNames
}));
}
static KitComposition BuildCompositionFromModel(KitAddToCartPostModel model, KitProductData kitData, int customerId)
{
// Build up the kit selections from the model
var selectedItems = model.GetSelectedItems(kitData);
// Now build the composition
var composition = new KitComposition(0);
foreach (var selectedItem in selectedItems)
{
KitCartItem kcItem = new KitCartItem();
kcItem.ProductID = model.ProductId;
kcItem.VariantID = model.VariantId;
kcItem.KitGroupID = selectedItem.Group.Id;
kcItem.KitItemID = selectedItem.Id;
kcItem.CustomerID = customerId;
kcItem.TextOption = selectedItem.TextOption;
int qty = 1;
if (selectedItem.HasMappedVariant &&
selectedItem.InventoryQuantityDelta > 1)
{
qty = selectedItem.InventoryQuantityDelta;
}
kcItem.Quantity = qty;
composition.Compositions.Add(kcItem);
}
return(composition);
}
protected override void OnInit(EventArgs e)
{
int productId = Request.QueryStringNativeInt("productId");
int groupId = Request.QueryStringNativeInt("groupId");
int kitItemId = Request.QueryStringNativeInt("itemId");
KitProductData kitProduct = KitProductData.Find(productId, Customer.Current);
KitData = kitProduct;
if (kitProduct != null)
{
KitGroupData kitGroup = kitProduct.GetGroup(groupId);
if (kitGroup != null)
{
KitItemData item = kitGroup.GetItem(kitItemId);
if (item != null)
{
KitItem = item;
kitProduct.TempFileStub = Request.QueryStringCanBeDangerousContent("stub");
}
}
}
base.OnInit(e);
}
protected void ddLocale_SelectedIndexChanged(object sender, EventArgs e)
{
string currentLocale = ddLocale.SelectedValue;
Kit = KitProductData.Find(Kit.Id, ThisCustomer, currentLocale);
InitializeDataSources();
BindData();
// force the update of the whole groups
pnlUpdateAllGroups.Update();
}
protected override void OnInit(EventArgs e)
{
Response.CacheControl = "private";
Response.Expires = 0;
Response.AddHeader("pragma", "no-cache");
ThisCustomer = Customer.Current;
VariantId = Request.QueryStringNativeInt("variantId");
Variant = ProductVariantForKit.Find(ThisCustomer, VariantId);
LocaleSetting = Request.QueryStringCanBeDangerousContent("locale");
MappedKitProducts = KitProductData.GetProductsThatHasKitItemsMappedToVariant(VariantId, ThisCustomer, LocaleSetting);
BindData();
base.OnInit(e);
}
KitItemInfo GetKitItemInfo(int itemId, string stub)
{
int productId = 0;
int groupId = 0;
using (var connection = new SqlConnection(DB.GetDBConn()))
using (var command = new SqlCommand())
{
command.Connection = connection;
command.CommandText = @"select kg.ProductID, kg.KitGroupID from KitItem ki
left join KitGroup kg on kg.KitGroupID = ki.KitGroupID
where KitItemId = @KitItemId" ;
command.Parameters.AddWithValue("KitItemId", itemId);
connection.Open();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
productId = reader.FieldInt("ProductID");
groupId = reader.FieldInt("kitgroupID");
}
}
}
var kitData = KitProductData.Find(productId, Customer.Current);
if (kitData == null)
{
return(null);
}
// Put the temporary file stub on the kit data object so that later it can be saved with the right filename.
kitData.TempFileStub = stub;
var kitGroup = kitData.GetGroup(groupId);
if (kitGroup == null)
{
return(null);
}
return(new KitItemInfo
{
KitItem = kitGroup.GetItem(itemId),
ProductId = productId,
GroupId = groupId
});
}
private void LoadThisKitData()
{
int productId = Request.QueryStringNativeInt("productId");
int cartId = Request.QueryStringNativeInt("cartrecid");
if (cartId > 0)
{
this.KitData = KitProductData.Find(productId, cartId, ThisCustomer);
GetQuantityFromCart();
}
else
{
this.KitData = KitProductData.Find(productId, ThisCustomer);
}
}
static KitComposition BuildCompositionFromModel(KitAddToCartPostModel model, KitProductData kitData, int customerId)
{
// Build up the kit selections from the model
var selectedItems = model.GetSelectedItems(kitData);
// Validate Kit options
if (kitData.HasRequiredGroups)
{
foreach (var requiredGroup in kitData.Groups.Where(g => g.IsRequired))
{
var requirementIsMet = requiredGroup
.Items
.Intersect(selectedItems)
.Any();
if (!requirementIsMet)
{
return(null);
}
}
}
// Now build the composition
var composition = new KitComposition(0);
foreach (var selectedItem in selectedItems)
{
KitCartItem kcItem = new KitCartItem();
kcItem.ProductID = model.ProductId;
kcItem.VariantID = model.VariantId;
kcItem.KitGroupID = selectedItem.Group.Id;
kcItem.KitItemID = selectedItem.Id;
kcItem.CustomerID = customerId;
kcItem.TextOption = selectedItem.TextOption;
int qty = 1;
if (selectedItem.HasMappedVariant &&
selectedItem.InventoryQuantityDelta > 1)
{
qty = selectedItem.InventoryQuantityDelta;
}
kcItem.Quantity = qty;
composition.Compositions.Add(kcItem);
}
return(composition);
}
protected override void OnInit(EventArgs e)
{
Response.CacheControl = "private";
Response.Expires = -1;
Response.AddHeader("pragma", "no-cache");
ThisCustomer = Customer.Current;
int kitId = Request.QueryStringNativeInt("kitId");
int groupId = Request.QueryStringNativeInt("groupId");
KitProductData kit = KitProductData.Find(kitId, ThisCustomer);
KitGroup = kit.GetGroup(groupId);
BindData();
base.OnInit(e);
}
public static AddToCartContext ConvertToAddToCartContext(this KitAddToCartPostModel kitAddToCartPostModel, Customer customer, CartTypeEnum cartType)
{
// Start with default kit data with no customer selections
var kitData = KitProductData.Find(
productId: kitAddToCartPostModel.ProductId,
cartRecId: kitAddToCartPostModel.CartRecordId ?? 0,
thisCustomer: customer);
// Move uploaded files to their permanent location.
kitData.TempFileStub = kitAddToCartPostModel.TemporaryImageNameStub;
if (kitData.HasFileUploadGroup)
{
kitData.MoveAllTempImagesToOrdered(); // This also updates the text option field for file uploads.
}
return(new AddToCartContext()
{
Customer = customer,
CartType = cartType,
ShoppingCartRecId = kitAddToCartPostModel.CartRecordId,
Quantity = kitAddToCartPostModel.Quantity,
ProductId = kitAddToCartPostModel.ProductId,
VariantId = kitAddToCartPostModel.VariantId,
UpsellProducts = kitAddToCartPostModel.UpsellProducts,
IsWishlist = kitAddToCartPostModel.IsWishlist,
CustomerEnteredPrice = 0,
Color = string.Empty,
Size = string.Empty,
TextOption = string.Empty,
TemporaryImageNameStub = kitAddToCartPostModel.TemporaryImageNameStub,
KitData = kitData,
Composition =
BuildCompositionFromModel(
model: kitAddToCartPostModel,
kitData: kitData,
customerId: customer.CustomerID)
});
}
public static AddToCartContext ConvertToAddToCartContext(this KitAddToCartPostModel kitAddToCartPostModel, Customer customer, CartTypeEnum cartType)
{
// Start with default kit data with no customer selections
var kitData = KitProductData.Find(
productId: kitAddToCartPostModel.ProductId,
cartRecId: kitAddToCartPostModel.CartRecordId ?? 0,
thisCustomer: customer);
// Add the temp file stup to the kit data for use later.
kitData.TempFileStub = kitAddToCartPostModel.TemporaryImageNameStub;
return(new AddToCartContext()
{
Customer = customer,
CartType = cartType,
ShoppingCartRecId = kitAddToCartPostModel.CartRecordId,
Quantity = kitAddToCartPostModel.Quantity,
ProductId = kitAddToCartPostModel.ProductId,
VariantId = kitAddToCartPostModel.VariantId,
UpsellProducts = kitAddToCartPostModel.UpsellProducts,
IsWishlist = kitAddToCartPostModel.IsWishlist,
CustomerEnteredPrice = 0,
Color = string.Empty,
Size = string.Empty,
TextOption = string.Empty,
TemporaryImageNameStub = kitAddToCartPostModel.TemporaryImageNameStub,
KitData = kitData,
Composition =
BuildCompositionFromModel(
model: kitAddToCartPostModel,
kitData: kitData,
customerId: customer.CustomerID)
});
}
public ActionResult KitAddToCartForm(int?productId = null, int?variantId = null, int?cartRecordId = null)
{
var product = new Product(productId ?? 0);
if (variantId == null || variantId == 0)
{
variantId = AppLogic.GetDefaultProductVariant(product.ProductID);
}
var variant = new ProductVariant(variantId.Value);
var customer = HttpContext.GetCustomer();
if (!product.IsAKit)
{
throw new Exception(string.Format("product {0} is not a kit and so we cannot show the kit add to cart form", product.ProductID));
}
var kitData = KitProductData.Find(
productId: product.ProductID,
cartRecId: cartRecordId.HasValue
? cartRecordId.Value
: 0,
thisCustomer: customer);
var quantity = GetKitQuantity(cartRecordId, variant.MinimumQuantity);
if (kitData == null)
{
return(Content("Details for this kit have not been setup"));
}
var kitAddToCartViewModel = BuildDefaultKitAddToCartViewModel(kitData, product, variant, quantity, customer, cartRecordId);
return(PartialView(ViewNames.KitAddToCartFormPartial, kitAddToCartViewModel));
}
protected override void OnInit(EventArgs e)
{
int productId = Request.QueryStringNativeInt("productId");
Customer ThisCustomer = Customer.Current;
this.Kit = KitProductData.Find(productId, ThisCustomer);
if (this.Kit != null)
{
InitializeDataSources();
BindData();
if (!this.IsPostBack)
{
InitializeLocales();
}
CreateBreadCrumb();
}
base.OnInit(e);
}
public string KitItemRelativePriceDeltaDisplayText(KitItemData item, string currencySetting, bool isTaxable, KitProductData kitData)
{
if (item.IsSelected)
{
return(null);
}
var deltaText = item.RelativePriceDeltaIsAdd
? "Add"
: "Subtract";
var customer = HttpContext.GetCustomer();
var deltaDisplayFormat = string.Empty;
var vatSuffix = customer.VATSettingReconciled == VATSettingEnum.ShowPricesInclusiveOfVAT
? "inc vat" // Vat inclusive
: "Excluding VAT"; // Vat exclusive
var priceDelta = item.PriceDelta;
if (item.Group.SelectionControl == KitGroupData.SINGLE_SELECT_DROPDOWN_LIST ||
item.Group.SelectionControl == KitGroupData.SINGLE_SELECT_RADIO_LIST)
{
priceDelta = item.RelativePriceDelta;
}
if (priceDelta == 0)
{
return(null);
}
if (kitData.ShowTaxInclusive)
{
var taxMultiplier = 1M + (kitData.TaxRate / 100M);
priceDelta *= taxMultiplier;
}
deltaDisplayFormat = Localization.CurrencyStringForDisplayWithExchangeRate(Math.Abs(priceDelta), currencySetting);
var displayText = string.Format("{0} {1}", deltaText, deltaDisplayFormat);
if (AppLogic.AppConfigBool("VAT.Enabled") && isTaxable)
{
displayText = string.Format("{0} {1}", displayText, vatSuffix);
}
return(displayText);
}
KitAddToCartViewModel BuildDefaultKitAddToCartViewModel(
KitProductData kitData,
Product product,
ProductVariant variant,
int quantity,
Customer customer,
int?cartRecordId)
{
var cartType = cartRecordId == null
? CartTypeEnum.ShoppingCart // we won't use this, so what it's set to doesn't matter
: CachedShoppingCartProvider.Get(customer, CartTypeEnum.ShoppingCart, AppLogic.StoreID())
.CartItems
.Where(c => c.ShoppingCartRecordID == cartRecordId)
.Any()
? CartTypeEnum.ShoppingCart
: CartTypeEnum.WishCart;
var isUnorderable = false;
if (!AppLogic.AppConfigBool("KitInventory.AllowSaleOfOutOfStock") &&
(!kitData.HasStock || kitData.HasRequiredOrReadOnlyButUnOrderableKitGroup))
{
isUnorderable = true;
}
var isCallToOrder = product.IsCalltoOrder;
kitData.ComputePrices(quantity);
var kitGroups = new List <KitGroupViewModel>();
foreach (var group in kitData.Groups)
{
var kitItems = new List <KitItemViewModel>();
foreach (var item in group.Items)
{
var priceDeltaDisplay = FormatCurrencyDisplay(item.PriceDelta, customer, variant.IsTaxable);
var showOutOfStock = item.HasMappedVariant &&
!item.VariantHasStock &&
!AppLogic.AppConfigBool("KitInventory.AllowSaleOfOutOfStock") &&
AppLogic.AppConfigBool("KitInventory.ShowOutOfStockMessage");
var kitItemRelativePriceDeltaDisplayText = KitItemRelativePriceDeltaDisplayText(item, customer.CurrencySetting, variant.IsTaxable, kitData);
kitItems.Add(new KitItemViewModel
{
Name = item.Name,
NameDisplay = !string.IsNullOrEmpty(kitItemRelativePriceDeltaDisplayText)
? string.Format("{0} [{1}]", item.Name, kitItemRelativePriceDeltaDisplayText)
: item.Name,
Description = item.Description,
IsDefault = item.IsDefault,
PriceDelta = item.PriceDelta,
PriceDeltaDisplay = priceDeltaDisplay,
WeightDelta = item.WeightDelta,
DisplayOrder = item.DisplayOrder,
Id = item.Id,
IsSelected = item.IsSelected,
TextOption = item.TextOption,
ImageUrl = item.HasImage
? item.ImagePath
: string.Empty,
OutOfStockMessage = showOutOfStock
? "Out of stock"
: string.Empty
});
}
var selectedItemId = group.FirstSelectedItem != null
? group.FirstSelectedItem.Id
: 0;
var groupViewModel = new KitGroupViewModel
{
Id = group.Id,
Name = group.Name,
Description = group.Description,
Summary = group.Summary,
ImageUrl = group.HasImage
? group.ImagePath
: string.Empty,
KitGroupType = group.SelectionControl,
Items = kitItems,
SelectedItemId = selectedItemId,
IsRequired = group.IsRequired,
IsReadOnly = group.IsReadOnly
};
kitGroups.Add(groupViewModel);
}
var regularBasePrice = kitData.Price;
var basePrice = kitData.BasePrice + kitData.ReadOnlyItemsSum;
var customizedPrice = kitData.CustomizedPrice;
var customerLevelPrice = kitData.LevelPrice;
PayPalAd payPalAd = null;
// If this is a single variant product, setup the PayPal ad.
if (AppLogic.GetNextVariant(product.ProductID, variant.VariantID) == variant.VariantID)
{
payPalAd = new PayPalAd(PayPalAd.TargetPage.Product);
}
// Values need for the Schema.Org tags
var storeDefaultCultureInfo = CultureInfo.GetCultureInfo(Localization.GetDefaultLocale());
var formattedSchemaPrice = string.Format(storeDefaultCultureInfo, "{0:C}", kitData.BasePrice);
var schemaRegionInfo = new RegionInfo(storeDefaultCultureInfo.Name);
// Build the view model
return(new KitAddToCartViewModel(
isUnorderable: isUnorderable,
isCallToOrder: isCallToOrder,
regularBasePrice: FormatCurrencyDisplay(regularBasePrice, customer, variant.IsTaxable),
basePrice: FormatCurrencyDisplay(basePrice, customer, variant.IsTaxable),
customizedPrice: FormatCurrencyDisplay(customizedPrice, customer, variant.IsTaxable),
customerLevelPrice: FormatCurrencyDisplay(customerLevelPrice, customer, variant.IsTaxable),
showRegularBasePrice: kitData.IsDiscounted,
showBasePrice: !AppLogic.AppConfigBool("HideKitPrice"),
showCustomerLevelPrice: kitData.HasCustomerLevelPricing,
showQuantity: AppLogic.AppConfigBool("ShowQuantityOnProductPage") &&
!AppLogic.AppConfigBool("HideKitQuantity"),
showBuyButton: AppLogic.AppConfigBool("ShowBuyButtons") &&
product.ShowBuyButton &&
!AppLogic.HideForWholesaleSite(customer.CustomerLevelID),
showWishlistButton: AppLogic.AppConfigBool("ShowWishButtons"),
hidePriceUntilCart: product.HidePriceUntilCart,
restrictedQuantities: RestrictedQuantityProvider.BuildRestrictedQuantityList(variant.RestrictedQuantities),
payPalAd: payPalAd,
showSchemaOrgPrice: kitData.BasePrice > 0 && !AppLogic.AppConfigBool("HideKitPrice"),
schemaBasePrice: formattedSchemaPrice,
isoThreeLetterCurrency: schemaRegionInfo.ISOCurrencySymbol,
schemaProductUrl: string.Format("{0}://schema.org/Product", Request.Url.Scheme),
schemaOfferUrl: string.Format("{0}://schema.org/Offer", Request.Url.Scheme),
cartType: cartType)
{
ProductId = product.ProductID,
VariantId = variant.VariantID,
CartRecordId = cartRecordId,
Quantity = quantity,
KitGroups = kitGroups,
UpsellProducts = null,
IsWishlist = false,
ReturnUrl = UrlHelper.MakeSafeReturnUrl(Request.RawUrl),
TemporaryImageNameStub = Guid.NewGuid().ToString()
});
}
private void UpdateKitItems(bool updateAll)
{
foreach (RepeaterItem rptItemKit in dlMappedKits.Items)
{
if (rptItemKit.ItemType == ListItemType.Item ||
rptItemKit.ItemType == ListItemType.AlternatingItem)
{
HiddenField hdfKitProductId = rptItemKit.FindControl <HiddenField>("hdfKitProductId");
int kitId = hdfKitProductId.Value.ToNativeInt();
KitProductData kit = MappedKitProducts.Find(k => k.Id == kitId);
if (kit != null)
{
Repeater rptKitGroups = rptItemKit.FindControl <Repeater>("rptKitGroups");
foreach (RepeaterItem rptItemGroup in rptKitGroups.Items)
{
if (rptItemGroup.ItemType == ListItemType.Item ||
rptItemGroup.ItemType == ListItemType.AlternatingItem)
{
HiddenField hdfGroupId = rptItemGroup.FindControl <HiddenField>("hdfGroupId");
int groupId = hdfGroupId.Value.ToNativeInt();
KitGroupData group = kit.GetGroup(groupId);
if (group != null)
{
Repeater rptKitItems = rptItemGroup.FindControl <Repeater>("rptKitItems");
foreach (RepeaterItem rptKitItem in rptKitItems.Items)
{
if (rptKitItem.ItemType == ListItemType.Item ||
rptKitItem.ItemType == ListItemType.AlternatingItem)
{
HiddenField hdfKitItemtId = rptKitItem.FindControl <HiddenField>("hdfKitItemtId");
int kitItemId = hdfKitItemtId.Value.ToNativeInt();
CheckBox chkUpdate = rptKitItem.FindControl <CheckBox>("chkUpdate");
if (chkUpdate.Checked)
{
KitItemData kitItem = group.GetItem(kitItemId);
if (kitItem != null)
{
kitItem.Name = XmlCommon.GetLocaleEntry(Variant.Name, LocaleSetting, false);
kitItem.Description = XmlCommon.GetLocaleEntry(Variant.Description, LocaleSetting, false);
if (updateAll)
{
kitItem.PriceDelta = Variant.SalePrice > decimal.Zero ? Variant.SalePrice : Variant.Price;
kitItem.WeightDelta = Variant.Weight;
}
kitItem.Save(LocaleSetting);
}
}
}
}
}
}
}
}
}
}
BindData();
}
public static IEnumerable <KitItemData> GetSelectedItems(this KitAddToCartPostModel model, KitProductData kitData)
{
var selectedItems = new List <KitItemData>();
foreach (var group in kitData.Groups)
{
// If the group is readonly add it to the list regardless of selections
if (group.IsReadOnly)
{
selectedItems.AddRange(group.Items);
continue;
}
var groupSelection = model.KitGroups
.Where(g => g.Id == group.Id)
.FirstOrDefault();
// If this group was not selected move to the next
if (groupSelection == null)
{
continue;
}
// For single select items use the SelectedItemId property from the model.
if ((group.SelectionControl == KitGroupData.SINGLE_SELECT_DROPDOWN_LIST || group.SelectionControl == KitGroupData.SINGLE_SELECT_RADIO_LIST) &&
groupSelection.SelectedItemId > 0)
{
var selectedItem = group.Items
.Where(i => i.Id == groupSelection.SelectedItemId)
.FirstOrDefault();
if (selectedItem != null)
{
selectedItems.Add(selectedItem);
}
continue;
}
if (groupSelection.Items == null)
{
continue;
}
// Otherwise we'll loop through the items to get the individual selections
foreach (var item in group.Items)
{
var itemSelection = groupSelection.Items
.Where(i => i.Id == item.Id)
.FirstOrDefault();
// If this item was not selected move to the next
if (itemSelection == null)
{
continue;
}
// If it's a text option and there's content in the text option field add it to the selected items.
if ((group.SelectionControl == KitGroupData.TEXT_OPTION || group.SelectionControl == KitGroupData.TEXT_AREA || group.SelectionControl == KitGroupData.FILE_OPTION) &&
!string.IsNullOrWhiteSpace(itemSelection.TextOption))
{
item.TextOption = itemSelection.TextOption;
selectedItems.Add(item);
continue;
}
else if (group.SelectionControl == KitGroupData.MULTI_SELECT_CHECKBOX_LIST &&
itemSelection.IsSelected)
{
selectedItems.Add(item);
continue;
}
}
}
return(selectedItems);
}
