private void RenderFacebookMetaTags(ProductPageViewModel model)
{
if (ViewBag.UseFaceBook)
{
var faceBookAdmins = HccApp.CurrentStore.Settings.FaceBook.Admins;
var faceBookAppId = HccApp.CurrentStore.Settings.FaceBook.AppId;
var currencyInfo =
HccApp.GlobalizationServices.Countries.FindAllForCurrency()
.FirstOrDefault(c => c.CultureCode == HccApp.CurrentStore.Settings.CurrencyCultureCode);
var sb = new StringBuilder();
sb.Append("<!-- FaceBook OpenGraph Tags -->");
sb.AppendFormat("<meta property=\"og:title\" content=\"{0}\"/>", PageTitle);
sb.Append("<meta property=\"og:type\" content=\"product\"/>");
sb.AppendFormat("<meta property=\"og:url\" content=\"{0}\"/>", ViewBag.CurrentUrl);
sb.AppendFormat("<meta property=\"og:image\" content=\"{0}\"/>", model.ImageUrls.MediumlUrl);
sb.AppendFormat("<meta property=\"og:price:amount\" content=\"{0}\" />", model.Prices.SitePrice.Text);
// TODO: Replace this with ISO 4217-3 currency code
//
// This will require:
// - Adding the necessary column to hcc_Countries table
// - Updating the upgrade script to include the official currency codes for all out of the box currencies
// - Adding the necessary column to DAL classes (updating EF)
// - Adding the currency to the Settings > Countries admin view to edit
//
// Documentation:
// https://developers.facebook.com/docs/payments/product
// https://developers.pinterest.com/rich_pins_product/
// http://www.nationsonline.org/oneworld/currencies.htm
sb.AppendFormat("<meta property=\"og:price:currency\" content=\"{0}\" />", currencyInfo.IsoAlpha3);
sb.AppendFormat("<meta property=\"og:site_name\" content=\"{0}\" />", ViewBag.StoreName);
sb.AppendFormat("<meta property=\"fb:admins\" content=\"{0}\" />", faceBookAdmins);
sb.AppendFormat("<meta property=\"fb:app_id\" content=\"{0}\" />", faceBookAppId);
RenderToHead("FaceBookMetaTags", sb.ToString());
}
}
private ActionResult RenderView(bool addedToBasket)
{
Product currentProduct = SiteContext.Current.CatalogContext.CurrentProduct;
var productViewModel = new ProductViewModel();
productViewModel.Sku = currentProduct.Sku;
productViewModel.PriceCalculation = UCommerce.Api.CatalogLibrary.CalculatePrice(currentProduct);
productViewModel.Name = currentProduct.DisplayName();
productViewModel.LongDescription = currentProduct.LongDescription();
productViewModel.IsVariant = false;
productViewModel.IsOrderingAllowed = currentProduct.AllowOrdering;
productViewModel.TaxCalculation = CatalogLibrary.CalculatePrice(currentProduct).YourTax.ToString();
productViewModel.IsProductFamily = currentProduct.ProductDefinition.IsProductFamily();
productViewModel.Reviews = MapReviews(currentProduct);
if (!string.IsNullOrEmpty(currentProduct.PrimaryImageMediaId))
{
var media = ObjectFactory.Instance.Resolve <IImageService>().GetImage(currentProduct.PrimaryImageMediaId).Url;
productViewModel.ThumbnailImageUrl = media;
}
productViewModel.Properties = MapProductProperties(currentProduct);
if (currentProduct.ProductDefinition.IsProductFamily())
{
productViewModel.Variants = MapVariants(currentProduct.Variants);
}
bool isInBasket = TransactionLibrary.GetBasket(true).PurchaseOrder.OrderLines.Any(x => x.Sku == currentProduct.Sku);
ProductPageViewModel productPageViewModel = new ProductPageViewModel()
{
ProductViewModel = productViewModel,
AddedToBasket = addedToBasket,
ItemAlreadyExists = isInBasket
};
return(View("/Views/Product.cshtml", productPageViewModel));
}
private void RegisterSocialFunctionality(ProductPageViewModel model)
{
var socialService = HccApp.SocialService;
socialService.SaveProductToJournal(model.LocalProduct);
// Obsolete - may need to add a method to retrieve the social item in the future (if integrating directly into Evoq Social again)
//model.SocialItem = socialService.GetProductSocialItem(model.LocalProduct);
// Social Media Globals
ViewBag.UseFaceBook = HccApp.CurrentStore.Settings.FaceBook.UseFaceBook;
ViewBag.UseTwitter = HccApp.CurrentStore.Settings.Twitter.UseTwitter;
ViewBag.TwitterHandle = HccApp.CurrentStore.Settings.Twitter.TwitterHandle;
ViewBag.TwitterDefaultTweetText = HccApp.CurrentStore.Settings.Twitter.DefaultTweetText;
ViewBag.UseGooglePlus = HccApp.CurrentStore.Settings.GooglePlus.UseGooglePlus;
ViewBag.UsePinterest = HccApp.CurrentStore.Settings.Pinterest.UsePinterest;
RenderFacebookMetaTags(model);
}
// GET: Product
public ViewResult List(string category, int page)
{
int PageSize = 2;
IProductRepository repository = new EFProductRepository();
ProductPageViewModel model = new ProductPageViewModel
{
products = (repository.Products
.Where(p => category == (String)null || p.Category == category)
.OrderBy(p => p.ProductId)
.Skip((page - 1) * PageSize)
.Take(PageSize)
),
info = new PagingInfo
{
CurrentPage = page,
TotalItems = repository.Products.Where(p => p.Category == null || p.Category == category).Count(),
ItemsPerPage = PageSize,
},
currentCategory = category
};
return(View(model));
}
private bool AddToCart(ProductPageViewModel model)
{
var isValidSelections = ValidateSelections(model);
var isValidQty = DetermineQuantityToAdd(model);
var isValidUserPrice = ValidateUserPrice(model);
var isValidGiftCardPrice = ValidateGiftCardAmount(model);
var isNotRecurringMixed = ValidateRecurringItems(model);
if (isValidSelections &&
isValidQty &&
isValidUserPrice &&
isValidGiftCardPrice &&
isNotRecurringMixed)
{
var li = ConvertProductToLineItem(model);
var currentCart = HccApp.OrderServices.EnsureShoppingCart();
RemovePreviousLineItem(model, currentCart);
return(HccApp.AddToOrderWithCalculateAndSave(currentCart, li));
}
return(false);
}
private bool ValidateSelections(ProductPageViewModel model)
{
bool result = false;
if ((model.LocalProduct.HasOptions()))
{
if ((model.LocalProduct.HasVariants()))
{
Variant v = model.LocalProduct.Variants.FindBySelectionData(model.Selections, model.LocalProduct.Options);
if ((v != null))
{
result = true;
}
else
{
model.ValidationMessage = "<div class=\"flash-message-warning\">The options you've selected aren't available at the moment. Please select different options.</div>";
}
}
else
{
result = true;
}
// Make sure no "labels" are selected
if (model.Selections.HasLabelsSelected())
{
result = false;
model.ValidationMessage = "<div class=\"flash-message-warning\">Please make all selections before adding to cart.</div>";
}
}
else
{
result = true;
}
return(result);
}
public IActionResult Index()
{
var contentEntity = this.InstanceRepository.ContentProductRepository.GetAll().FirstOrDefault(x => x.Language == this.SiteLanguage);
var viewmodel = new ProductPageViewModel()
{
ContentProduct = Mapper.ToModel(contentEntity)
};
var productEntities = this.InstanceRepository.ProductRepository.GetAll()
.Include(x => x.ProductLanguages)
.Include("ProductLanguages.ImageDetails")
.Include("ProductLanguages.ProductLanguageDescriptionDetails")
.Include("ProductLanguages.ProductLanguageProductDetails")
.Include("ProductLanguages.ProductLanguageReviewDetails")
.ToList();
var products = new List <ProductModel>();
foreach (var item in productEntities)
{
var p = Mapper.ToModel(item);
p.ProductLanguages = item.ProductLanguages.Select(pl =>
{
var plm = Mapper.ToModel(pl);
if (plm != null)
{
plm.ImageDetails = pl?.ImageDetails?.Select(Mapper.ToModel).ToList();
plm.ProductLanguageDescriptionDetails = pl?.ProductLanguageDescriptionDetails?.Select(Mapper.ToModel).ToList();
plm.ProductLanguageProductDetails = pl?.ProductLanguageProductDetails?.Select(Mapper.ToModel).ToList();
plm.ProductLanguageReviewDetails = pl?.ProductLanguageReviewDetails?.Select(Mapper.ToModel).ToList();
}
return(plm);
}).ToList();
products.Add(p);
}
viewmodel.Products = products;
ViewBag.Tab = "products";
return(View(viewmodel));
}
private SystemOperationResult InventoryCheck(ProductPageViewModel model)
{
var data = HccApp.CatalogServices.InventoryCheck(model.LocalProduct, model.Selections);
model.StockMessage = data.InventoryMessage;
model.IsAvailableForSale = data.IsAvailableForSale;
var formQuantity = Request.Form["qty"];
if (!string.IsNullOrEmpty(formQuantity))
{
formQuantity = security.InputFilter(formQuantity.Trim(), PortalSecurity.FilterFlag.NoMarkup);
}
var qty = 0;
if (int.TryParse(formQuantity, out qty))
{
var li = ConvertProductToLineItem(model);
li.Quantity = Convert.ToInt16(formQuantity);
return(HccApp.CheckForStockOnItems(li));
}
return(new SystemOperationResult(false, Localization.GetString("EnterProperQty")));
}
public ActionResult Product(string productAlias)
{
ProductPageDTO productPageDTO = _productService.GetProductPage(productAlias);
if (productPageDTO == null)
{
return(NotFound());
}
IMapper mapper = new MapperConfiguration(cfg =>
{
cfg.CreateMap <ProductPageDTO, ProductPageViewModel>();
cfg.CreateMap <ImageDTO, ImageViewModel>();
}).CreateMapper();
ProductPageViewModel model = mapper.Map <ProductPageViewModel>(productPageDTO);
if (_siteSettings.TryGetValue("BigBannerId", out string bannerIdString))
{
if (int.TryParse(bannerIdString, out int singleBannerId))
{
BannerDTO bannerDTO = _bannerService.GetBanner(singleBannerId);
IMapper bannerMapper = new MapperConfiguration(cfg =>
{
cfg.CreateMap <BannerDTO, BannerViewModel>();
cfg.CreateMap <ImageDTO, ImageViewModel>();
}).CreateMapper();
BannerViewModel banner = bannerMapper.Map <BannerViewModel>(bannerDTO);
ViewBag.SingleBanner = banner;
}
}
ViewBag.Title = model.Title;
return(View(model));
}
private void LoadImageUrls(ProductPageViewModel model)
{
model.ImageUrls = new ProductImageUrls();
model.ImageUrls.LoadProductImageUrls(HccApp, model.LocalProduct);
}
private ProductPageViewModel LoadProductModel(string slug)
{
CustomUrl customUrl;
var product = HccApp.ParseProductBySlug(slug, out customUrl);
if (customUrl != null && !IsConcreteItemModule)
{
var redirectUrl = HccUrlBuilder.RouteHccUrl(HccRoute.Product, new { slug = customUrl.RedirectToUrl });
if (customUrl.IsPermanentRedirect)
{
Response.RedirectPermanent(redirectUrl);
}
else
{
Response.Redirect(redirectUrl);
}
}
if (product == null)
{
StoreExceptionHelper.ShowInfo(Localization.GetString("ProductNotFound"));
}
else if (product.Status != ProductStatus.Active)
{
StoreExceptionHelper.ShowInfo(Localization.GetString("ProductNotActive"));
}
else if (!HccApp.CatalogServices.TestProductAccess(product))
{
StoreExceptionHelper.ShowInfo(Localization.GetString("ProductNotEnoughPermission"));
}
var model = new ProductPageViewModel {
LocalProduct = product
};
LoadImageUrls(model);
model.Prices = CreateProductPrices(product);
LoadRelatedItems(model);
LoadBundledItems(model);
model.IsAvailableForWishList = SessionManager.IsUserAuthenticated(HccApp);
model.AllowReviews = product.AllowReviews.HasValue
? product.AllowReviews.Value
: HccApp.CurrentStore.Settings.AllowProductReviews;
LoadAlternateImages(model);
model.PreRenderedTypeValues = product.RenderTypeProperties();
model.SwatchHtml = ImageHelper.GenerateSwatchHtmlForProduct(product, HccApp);
model.LineItemId = Request.QueryString["LineItemId"].ConvertToNullable <long>();
// make the minimum quantity be the new default if necessary, otherwise use the actual default (1)
if (product.MinimumQty > 0)
{
model.Quantity = product.MinimumQty;
}
LoadGiftCardAmounts(model);
if (AuthorizedToEditCatalog())
{
model.ProductAnalyticsUrl = string.Format(ProductAnalyticsUrlFormat, product.Bvin);
model.ProductEditUrl = string.Format(ProductEditUrlFormat, product.Bvin);
model.StoreAdminUrl = DashboardAdminUrl;
model.AuthorizedToEditCatalog = true;
}
else
{
model.AuthorizedToEditCatalog = false;
}
return(model);
}
public IntegrationResult BeforeProductAddedToCart(HotcakesApplication hccApp, ProductPageViewModel model)
{
return(new IntegrationResult());
}
public ActionResult IndexPost(string slug)
{
ProductPageViewModel model = IndexSetup(slug);
// see if we're editing a line item instead of a new add
string lineItemString = Request.Form["lineitemid"];
if (!string.IsNullOrEmpty(lineItemString))
{
if (model.LineItemId == string.Empty)
{
model.LineItemId = lineItemString;
}
}
ParseSelections(model);
if (Request.Form["savelaterbutton.x"] != null)
{
// Save for Later
MTApp.CatalogServices.SaveProductToWishList(model.LocalProduct, model.Selections, 1, MTApp);
return(Redirect("~/account/saveditems"));
}
else
{
// Add to Cart
bool IsPurchasable = ValidateSelections(model);
if ((IsPurchasable))
{
DetermineQuantityToAdd(model);
if (model.Quantity > 0)
{
LineItem li = MTApp.CatalogServices.ConvertProductToLineItem(model.LocalProduct,
model.Selections,
model.Quantity,
MTApp);
Order Basket = SessionManager.CurrentShoppingCart(MTApp.OrderServices, MTApp.CurrentStore);
if (Basket.UserID != MTApp.CurrentCustomerId)
{
Basket.UserID = MTApp.CurrentCustomerId;
}
if (model.LineItemId.Trim().Length > 0)
{
long lineItemId = 0;
long.TryParse(model.LineItemId, out lineItemId);
var toRemove = Basket.Items.Where(y => y.Id == lineItemId).SingleOrDefault();
if (toRemove != null)
{
Basket.Items.Remove(toRemove);
}
}
MTApp.AddToOrderWithCalculateAndSave(Basket, li);
SessionManager.SaveOrderCookies(Basket, MTApp.CurrentStore);
return(Redirect("~/cart"));
}
}
}
// Load Selections from form here
// Do checks and add
model.PreRenderedOptions = HtmlRendering.ProductOptions(model.LocalProduct.Options, model.Selections);
return(View(model));
}
private void RenderOptionsJavascript(ProductPageViewModel model)
{
if (!model.LocalProduct.HasOptions())
{
return;
}
StringBuilder sb = new StringBuilder();
sb.Append("<script type=\"text/javascript\">");
// Evaluate Selections
sb.Append("function EvaluateSelections() {" + System.Environment.NewLine);
sb.Append(" var loadingUrl = '" + Url.Content("~/images/system/ajax-loader.gif") + "';" + System.Environment.NewLine);
sb.Append(" var loadingTag = '<img src=\"' + loadingUrl + '\" border=\"0\" alt=\"loading...\" />';" + System.Environment.NewLine);
//sb.Append(" $('#sku').html(loadingTag);")
//sb.Append(" $('#pricewrapper').html(loadingTag);")
sb.Append(" $('.buttons').hide();" + System.Environment.NewLine);
sb.Append(" $('#localmessage').html('<label> </label><span class=\"choice\">' + loadingTag + '</span>');" + System.Environment.NewLine);
//sb.Append(" $('#imgMain').attr('src',loadingUrl);"+ System.Environment.NewLine)
// Write each option to temp varible so we can get it's value as a string
// This ensures the JSON will get correctly quoted by JQuery
foreach (Option opt in model.LocalProduct.Options)
{
if (opt.OptionType == OptionTypes.CheckBoxes | opt.OptionType == OptionTypes.DropDownList | opt.OptionType == OptionTypes.RadioButtonList)
{
sb.Append("var opt" + opt.Bvin.Replace("-", "") + "=");
if (opt.OptionType == OptionTypes.RadioButtonList)
{
sb.Append("$('.radio" + opt.Bvin.Replace("-", "") + ":checked').val();" + System.Environment.NewLine);
}
else if (opt.OptionType == OptionTypes.CheckBoxes)
{
sb.Append("$('.check" + opt.Bvin.Replace("-", "") + ":checked').val();" + System.Environment.NewLine);
}
else
{
sb.Append("$('#opt" + opt.Bvin.Replace("-", "") + "').val();" + System.Environment.NewLine);
}
sb.Append("opt" + opt.Bvin.Replace("-", "") + "+='';" + System.Environment.NewLine);
//sb.Append("alert(opt" + opt.Bvin.Replace("-", "") + ");" + System.Environment.NewLine);
}
}
sb.Append("$.post('" + Url.Content("~/products/validate") + "'," + System.Environment.NewLine);
sb.Append(" {\"productbvin\":\"" + model.LocalProduct.Bvin + "\"" + System.Environment.NewLine);
foreach (Option opt in model.LocalProduct.Options)
{
if (opt.OptionType == OptionTypes.CheckBoxes | opt.OptionType == OptionTypes.DropDownList | opt.OptionType == OptionTypes.RadioButtonList)
{
sb.Append(", \"opt" + opt.Bvin.Replace("-", "") + "\": opt" + opt.Bvin.Replace("-", ""));
}
}
sb.Append("}, " + System.Environment.NewLine);
sb.Append(" function(data) {" + System.Environment.NewLine);
//sb.Append(" alert(data.Message);" + System.Environment.NewLine);
sb.Append(" if (data.Message === null || data.Message.Length < 1) { $('#localmessage').html('');} else {");
sb.Append("$('#localmessage').html('<label> </label><span class=\"choice\">' + data.Message + '</span>');");
sb.Append("}" + System.Environment.NewLine);
sb.Append(" $('#imgMain').attr('src',data.ImageUrl);" + System.Environment.NewLine);
sb.Append(" $('#sku').html(data.Sku);" + System.Environment.NewLine);
sb.Append(" $('.stockdisplay').html(data.StockMessage);" + System.Environment.NewLine);
sb.Append(" $('#pricewrapper').html(data.Price);" + System.Environment.NewLine);
//sb.Append(" alert(data.IsValid); "+ System.Environment.NewLine)
sb.Append(" if (data.IsValid === false) { $('.buttons').hide();} else { $('.buttons').show();}" + System.Environment.NewLine);
sb.Append(" }, 'json');" + System.Environment.NewLine);
// end post function
sb.Append("}" + System.Environment.NewLine);
// end evaluate function
// Document Ready Function
sb.Append("$(document).ready(function() {" + System.Environment.NewLine);
sb.Append("$(\".isoption\").change(function() {" + System.Environment.NewLine);
sb.Append(" EvaluateSelections();" + System.Environment.NewLine);
sb.Append(" return true;" + System.Environment.NewLine);
sb.Append("});" + System.Environment.NewLine);
sb.Append(" EvaluateSelections(); " + System.Environment.NewLine);
sb.Append("});" + System.Environment.NewLine + System.Environment.NewLine);
// End of Document Ready
sb.Append("</script>" + System.Environment.NewLine);
model.JavaScripts += sb.ToString();
}
private ProductPageViewModel IndexSetup(string slug)
{
ViewBag.BodyClass = "store-product-page";
ProductPageViewModel model = new ProductPageViewModel();
model.LocalProduct = ParseProductFromSlug(slug);
RenderOptionsJavascript(model);
// Page Title
ViewBag.Title = model.LocalProduct.MetaTitle.Trim();
if (model.LocalProduct.MetaTitle.Trim().Length > 0)
{
ViewBag.Title = model.LocalProduct.MetaTitle;
}
else
{
ViewBag.Title = model.LocalProduct.ProductName;
}
// Meta Keywords
ViewBag.MetaKeywords = model.LocalProduct.MetaKeywords.Trim();
if (model.LocalProduct.MetaKeywords.Trim().Length > 0)
{
ViewBag.MetaKeywords = model.LocalProduct.MetaKeywords;
}
// Meta Description
ViewBag.MetaDescription = model.LocalProduct.MetaDescription.Trim();
if (model.LocalProduct.MetaDescription.Trim().Length > 0)
{
ViewBag.MetaDescription = model.LocalProduct.MetaDescription;
}
ViewBag.RelatedItemsTitle = SiteTerms.GetTerm(SiteTermIds.RelatedItems);
ViewBag.AddToCartButtonUrl = MTApp.ThemeManager().ButtonUrl("addtocart", Request.IsSecureConnection);
ViewBag.SubmitButtonUrl = MTApp.ThemeManager().ButtonUrl("submit", Request.IsSecureConnection);
ViewBag.SaveLaterButton = MTApp.ThemeManager().ButtonUrl("SaveForLater", Request.IsSecureConnection);
CheckForBackOrder(model);
// Allow custom image names instead of the auto-generated ones
string imageName = model.LocalProduct.ImageFileMedium;
if (imageName.Trim().Length < 3)
{
imageName = model.LocalProduct.ImageFileSmall;
}
model.MainImageUrl = MerchantTribe.Commerce.Storage.DiskStorage.ProductImageUrlMedium(MTApp, model.LocalProduct.Bvin, imageName, Request.IsSecureConnection);
model.MainImageAltText = model.LocalProduct.ImageFileMediumAlternateText;
if (model.MainImageAltText.Trim().Length < 1)
{
model.MainImageAltText = model.LocalProduct.ImageFileSmallAlternateText;
}
model.PreRenderedTypeValues = model.LocalProduct.GetTypeProperties(this.MTApp);
// Prices
RenderPrices(model);
LoadRelatedItems(model);
RenderAdditionalImages(model);
if (Request.QueryString["LineItemId"] != null)
{
model.OrderId = Request.QueryString["OrderBvin"];
model.LineItemId = Request.QueryString["LineItemId"];
}
if (SessionManager.IsUserAuthenticated(MTApp))
{
model.IsAvailableForWishList = true;
}
StringBuilder sb = new StringBuilder();
sb.Append("<script src=\"" + Url.Content("~/scripts/tabs.js") + "\" type=\"text/javascript\"></script>");
sb.Append("<script src=\"" + Url.Content("~/scripts/ProductPage.js") + "\" type=\"text/javascript\"></script>");
sb.Append(model.JavaScripts);
if (ViewBag.UseFaceBook == true)
{
sb.Append("<!-- FaceBook OpenGraph Tags -->");
sb.Append("<meta property=\"og:title\" content=\"" + ViewBag.Title + "\"/>");
sb.Append("<meta property=\"og:type\" content=\"product\"/>");
sb.Append("<meta property=\"og:url\" content=\"" + ViewBag.CurrentUrl + "\"/>");
sb.Append("<meta property=\"og:image\" content=\"" + model.MainImageUrl + "\"/>");
sb.Append("<meta property=\"og:site_name\" content=\"" + ViewBag.StoreName + "\" />");
sb.Append("<meta property=\"fb:admins\" content=\"" + ViewBag.FaceBookAdmins + "\" />");
sb.Append("<meta property=\"fb:app_id\" content=\"" + ViewBag.FaceBookAppId + "\" />");
}
ViewData["AnalyticsTop"] += sb.ToString();
StringBuilder sbb = new StringBuilder();
sbb.Append("<div id=\"fb-root\"></div>");
sbb.Append("<script> (function (d, s, id) {");
sbb.Append("var js, fjs = d.getElementsByTagName(s)[0];");
sbb.Append("if (d.getElementById(id)) { return; }");
sbb.Append("js = d.createElement(s); js.id = id;");
sbb.Append("js.src = \"//connect.facebook.net/en_US/all.js#xfbml=1\";");
sbb.Append("fjs.parentNode.insertBefore(js, fjs);");
sbb.Append("} (document, 'script', 'facebook-jssdk'));</script>");
ViewData["AnalyticsBottom"] += sbb.ToString();
// Bread Crumbs
var breadRender = new code.TemplateEngine.TagHandlers.BreadCrumbs();
model.BreadCrumbsFinal = breadRender.RenderProduct(MTApp, new List <BreadCrumbItem>(), model.LocalProduct);
// Columns
var columnRender = new code.TemplateEngine.TagHandlers.ContentColumn();
model.PreColumn = columnRender.RenderColumnToString(model.LocalProduct.PreContentColumnId, MTApp, ViewBag);
model.PostColumn = columnRender.RenderColumnToString(model.LocalProduct.PostContentColumnId, MTApp, ViewBag);
model.SwatchHtml = MerchantTribe.Commerce.Utilities.ImageHelper.GenerateSwatchHtmlForProduct(model.LocalProduct, this.MTApp);
MTApp.CurrentRequestContext.CurrentProduct = model.LocalProduct;
return(model);
}
public IntegrationResult BeforeProductAddedToCart(HotcakesApplication hccApp, ProductPageViewModel model)
{
return(new IntegrationResult
{
IsAborted = true,
AbortMessage =
string.Format("My Test Product Integration - Product Name: {0}", model.LocalProduct.ProductName)
});
}
