@nuskin/ns-product-lib 1.3.7

package/src/product.js

@@ -0,0 +1,803 @@
+"use strict";
+
+const { isTrue }  = require("@nuskin/ns-common-lib");
+
+const ProductUtils = require("./productUtils.js");
+
+const Agelocme = require("./agelocme.js");
+const PriceType = require("./priceType.js");
+const ProductStatus = require("./productStatus.js");
+
+const Product = function(productData) {
+  this.priceMap = {};
+  this.pvMap = {};
+  this.cvMap = {};
+  this.orderTypes = {};
+  this.childSkus = [];
+  this.custTypes = [];
+  this.addOns = [];
+  this.productCarouselImages = [];
+
+  //class variables to be used instead of getters/setters
+  this.globalProductID = "";
+  this.sku = "";
+  this.title = "";
+  this.country = "";
+  this.lang = "";
+  this.shortDescr = "";
+  this.longDescr = "";
+  this.sizeWeight = "";
+  this.nettoWeight = "";
+  this.productLabels = {};
+  this.count = "";
+  this.flavor = "";
+  this.shade = "";
+  this.size = "";
+  this.variantType = "";
+  this.variantDropdownLabel = "";
+  this.variantDropdownPlaceholder = "";
+  this.variantsLabel = "";
+  this.ingredients = "";
+  this.benefits = "";
+  this.usage = "";
+  this.resources = "";
+  this.contentSection = "";
+  this.videos = "";
+  this.personalOffer = false;
+  this.groupOffer = false;
+  this.scanQualified;
+  this.status = ProductStatus.ReleasedForSale;
+  this.availableQuantity = 0; // total available quantity
+  this.maxQuantity = 999; // max quantity allowed for purchase
+  this.priceType = null;
+  this.division = "";
+  this.backOrderDate = null;
+  this.baseSku = "";
+  this.variants = {};
+  this.eventName = null; // set if pricing is based off of an event
+  // Used to remember an event that was used for pricing in case ADR checkbox was clicked where
+  //  event pricing is not available. If the event was active when the product was added then
+  //  then the event can be used for the duration of the cart.
+  this.savedEventName = null;
+  this.salesLabel = "";
+  this.searchScore = 0;
+  this.isExclusive = false;
+  this.movie = "";
+  this.youtube = "";
+  this.marketAttributes = {};
+  this.salesEventText = "";
+
+  // agelocme stuff
+  this.agelocme = null; // object containing agelocme information (like code, label, name)
+
+  this.setMarketAttributes = function(productStatus) {
+    if (productStatus.marketAttributes) {
+      this.marketAttributes = productStatus.marketAttributes;
+    }
+  };
+
+  this.getAgelocmeKeyPart = function() {
+    let keyPart = null;
+    if (this.agelocme) {
+      keyPart =
+        this.agelocme.code +
+        "-" +
+        this.agelocme.label +
+        "-" +
+        this.agelocme.name;
+    }
+
+    return keyPart;
+  };
+
+  this.getHighlightedSku = function() {
+    let rv = this.sku;
+    if (this.highlightedSku) rv = this.highlightedSku;
+    return rv;
+  };
+
+  this.getProductSearchTitle = function() {
+    if (this.agelocme && this.agelocme.label) {
+      return this.agelocme.label;
+    }
+    return this.title;
+  };
+
+  this.getProductSearchSku = function() {
+    if (this.agelocme && this.agelocme.code) {
+      return this.agelocme.code;
+    }
+    return this.getHighlightedSku();
+  };
+
+  this.getDescription = function() {
+    let description = this.longDescr;
+    if (!description || description.length === 0) {
+      return this.shortDescr;
+    }
+    return description;
+  };
+
+  this.setFullImage = function(fullImage) {
+    if (fullImage) {
+      this.fullImage = fullImage.replace("http:", "https:");
+    } else {
+      this.fullImage = "";
+    }
+  };
+
+  this.getFullImage = function() {
+    return this.fullImage ? this.fullImage.replace("http:", "https:") : "";
+  };
+
+  this.setProductCarouselImages = function(productCarouselImages) {
+    this.productCarouselImages = productCarouselImages;
+  };
+
+  this.getProductCarouselImages = function() {
+    return this.productCarouselImages;
+  };
+
+  this.setImageAltText = function(altText) {
+    if (altText) {
+      this.imageAltText = altText;
+    } else {
+      this.imageAltText = this.title;
+    }
+  };
+
+  this.getImageAltText = function() {
+    return this.imageAltText || this.title;
+  };
+
+  this.setThumbnail = function(thumbnail) {
+    if (thumbnail) {
+      this.thumbnail = thumbnail.replace("http:", "https:");
+    } else {
+      this.thumbnail = "";
+    }
+  };
+
+  this.setThumbnailFromSku = function(sku) {
+    // WARNING: Base URL will need to be handled in the client (call setBaseUrl)
+    // eslint-disable-next-line max-len
+    // this.thumbnail = `${RunConfigService.getBaseUrl()}/content/products/${ProductUtils.getTokenizedSku(sku)}/jcr:content/fullImage.img.100.100.png`;
+
+    this.thumbnail = `/content/products/${ProductUtils.getTokenizedSku(
+      sku
+    )}/jcr:content/fullImage.img.100.100.png`;
+  };
+
+  this.getThumbnail = function() {
+    return this.thumbnail ? this.thumbnail.replace("http:", "https:") : "";
+  };
+
+  this.hasAvailableQuantity = function(qty = 1) {
+    return Math.min(this.maxQuantity, this.availableQuantity) >= qty;
+  };
+
+  this.setPoints = function(points) {
+    this.points = ensureFloatVal(points) || "";
+  };
+
+  this.getPointsFixed = function() {
+    return parseFloat(this.points).toFixed(2);
+  };
+
+  this.setCv = function(cv) {
+    this.cv = ensureFloatVal(cv) || "";
+  };
+
+  this.getCvFixed = function() {
+    return parseFloat(this.cv).toFixed(2);
+  };
+
+  this.setPv = function(pv) {
+    this.pv = ensureFloatVal(pv) || "";
+  };
+
+  this.getPvFixed = function() {
+    return parseFloat(this.pv || 0).toFixed(2);
+  };
+
+  this.setPrice = function(price) {
+    this.price = ensureFloatVal(price, true);
+  };
+
+  this.setFormattedPrice = function(formattedPrice) {
+    this.formattedPrice = formattedPrice;
+  };
+
+  /**
+   * Use to save the eventName if one exists. Added originally for when a product is
+   * added to the cart the event pricing needs to be remembered if toggling between
+   * pricetypes with event pricing and pricetype without event pricing
+   */
+  this.lockEventName = function() {
+    if (!this.savedEventName && this.eventName) {
+      this.savedEventName = this.eventName;
+    }
+  };
+
+  this.setPriceAndPvFromType = function(_priceType, _activeEvents = null) {
+    // WARNING: priceType needs to be handled client-side
+    // const priceType = ConfigService.getMarketConfig().showWholeSalePricing && !AccountManager.isLoggedIn()
+    //     ? PriceType.WWHL
+    //     : (_priceType ? _priceType : this.priceType),
+    const priceType = _priceType ? _priceType : this.priceType;
+    const eventPricing = getEventPricing(this, priceType, _activeEvents);
+
+    let changed = false;
+    if (
+      !this.price ||
+      priceType !== this.priceType ||
+      this.eventName !== eventPricing.eventName
+    ) {
+      this.setPrice(eventPricing.price || this.getPricing(priceType));
+      this.setCv(eventPricing.cv || this.getCvWithType(priceType));
+      this.setPv(eventPricing.pv || this.getPvWithType(priceType));
+      this.priceType = priceType;
+      this.eventName = eventPricing.eventName;
+      changed = true;
+    }
+
+    this.variantSkus().forEach((variantSku) => {
+      if (
+        this.variants[variantSku].setPriceAndPvFromType(
+          priceType,
+          _activeEvents
+        )
+      ) {
+        changed = true;
+      }
+    }, this);
+
+    return changed;
+  };
+
+  this.getPrice = function() {
+    return this.price ? this.price : 0;
+  };
+
+  this.getPriceFixed = function() {
+    if (typeof this.price === "number") {
+      return parseFloat(this.price.toFixed(2));
+    } else {
+      return this.getPrice();
+    }
+  };
+
+  this.getOriginalPrice = function() {
+    return this.priceType ? this.priceMap[this.priceType] : null;
+  };
+
+  this.addPricing = function(type, price) {
+    this.priceMap[type] = price;
+  };
+
+  this.addPricingFromStatus = function(productStatus, priceType) {
+    let modified = false;
+
+    if (!priceType) {
+      priceType = this.priceType;
+    }
+
+    // previous code stored sku as all caps
+    const productStatusSku = productStatus.SKU || productStatus.sku;
+    if (productStatusSku === this.sku) {
+      this.globalProductID = productStatus.globalProductID;
+      this.status = productStatus.status;
+      this.availableQuantity = productStatus.availableQuantity;
+      this.maxQuantity = productStatus.maxQuantity || 999;
+      if (productStatus.backordered) {
+        this.backOrderDate = productStatus.backorderedAvailableDate;
+      }
+      if (productStatus.price) {
+        this.setPoints(productStatus.price.PTS);
+        Object.keys(productStatus.price).forEach((priceKey) => {
+          this.addPricing(priceKey, productStatus.price[priceKey]);
+        }, this);
+      }
+      if (productStatus.psv) {
+        Object.keys(productStatus.psv).forEach((psvKey) => {
+          this.addPvWithType(psvKey, productStatus.psv[psvKey]);
+        }, this);
+      }
+      if (productStatus.csv) {
+        Object.keys(productStatus.csv).map((csvKey) => {
+          this.addCvWithType(csvKey, productStatus.csv[csvKey]);
+        }, this);
+      }
+      this.orderTypes = ProductUtils.mergeOrderTypes(this.orderTypes, productStatus.orderType);
+      if(productStatus.childSkus) {
+        this.childSkus = productStatus.childSkus;
+      }
+      this.setPriceAndPvFromType(priceType);
+      modified = true;
+    } else {
+      let variant = this.getVariant(productStatusSku);
+
+      if (variant) {
+        if (variant.addPricingFromStatus(productStatus, priceType)) {
+          variant.setMarketAttributes(productStatus);
+          updateBaseRanges(this, variant);
+          modified = true;
+        }
+      }
+    }
+
+    return modified;
+  };
+
+  this.addPvWithType = function(type, pv) {
+    this.pvMap[type] = pv;
+  };
+
+  this.addCvWithType = function(type, cv) {
+    this.cvMap[type] = cv;
+  };
+
+  this.getPricing = function(type) {
+    let retVal = null;
+
+    if (type) {
+      retVal = this.priceMap[type];
+
+      if (!retVal && isAdrType(type)) {
+        retVal = this.priceMap[getOppisiteAdrType(type)];
+      }
+    }
+    return retVal;
+  };
+    
+  this.getEventPriceTypes = () => {
+    const eventPriceTypes = [];
+
+    Object.keys(this.priceMap).forEach(priceTypeKey => {
+      const eventPriceType = priceTypeKey.substring(0, priceTypeKey.indexOf(`-${this.priceType}`));
+
+      if (eventPriceType) {
+        eventPriceTypes.push(eventPriceType);
+      }
+    });
+
+    return eventPriceTypes;
+  };
+
+  this.getPvWithType = function(type) {
+    let rv = this.pvMap[type];
+    if (rv == null) {
+      // Assumption: we always have WWHL from the service
+      // default to wholesale if a PV of a particular type is not there
+      rv = this.pvMap[PriceType.WWHL];
+    }
+    return rv;
+  };
+
+  this.getCvWithType = function(type) {
+    let rv = this.cvMap[type];
+    if (rv == null) {
+      rv = this.cvMap[PriceType.WWHL];
+    }
+    return rv;
+  };
+
+  this.hasAdrOption = function() {
+    return this.orderTypes["adr"];
+  };
+
+  this.isAdrOnly = function() {
+    return this.hasAdrOption() && !this.hasOrderOption();
+  };
+
+  this.hasMultipleOrderTypes = function() {
+    return this.hasOrderOption() && this.hasAdrOption();
+  };
+
+  this.hasOrderOption = function() {
+    return this.orderTypes["order"];
+  };
+
+  this.isDistributor = function() {
+    return this.custTypes.includes("10");
+  };
+
+  this.isCustomer = function() {
+    return this.custTypes.includes("20");
+  };
+
+  this.isPreferredCustomer = function() {
+    return this.custTypes.includes("30");
+  };
+
+  this.isBase = function() {
+    return this.sku.substring(2, 4) === "55";
+  };
+
+  this.isVariant = function() {
+    return this.baseSku.length > 0 && this.variantSkus().length === 0;
+  };
+
+  this.setVariant = function(variantProduct) {
+    if (variantProduct && variantProduct.sku) {
+      this.variants[variantProduct.sku] = variantProduct;
+    }
+  };
+
+  this.getVariant = function(sku) {
+    return this.variants[sku];
+  };
+
+  this.variantSkus = function() {
+    return Object.keys(this.variants);
+  };
+
+  this.getVariantsList = function() {
+    return Object.values(this.variants);
+  };
+
+  this.getMinPrice = function() {
+    return this.priceMap[`min-${this.priceType}`];
+  };
+
+  this.getMaxPrice = function() {
+    return this.priceMap[`max-${this.priceType}`];
+  };
+
+  this.getMinPv = function() {
+    return this.pvMap[`min-${this.priceType}`];
+  };
+
+  this.getMaxPv = function() {
+    return this.pvMap[`max-${this.priceType}`];
+  };
+
+  this.toJSON = function() {
+    let retData = {};
+    retData.sku = this.sku;
+    retData.globalProductID = this.globalProductID;
+    retData.title = this.title;
+    retData.country = this.country;
+    retData.language = this.lang;
+    retData.shortDescr = this.shortDescr;
+    retData.longDescr = this.longDescr;
+    retData.fullImage = this.fullImage;
+    retData.imageAltText = this.imageAltText;
+    retData.productCarouselImages = this.productCarouselImages;
+    retData.thumbnail = this.thumbnail;
+    retData.ingredients = this.ingredients;
+    retData.benefits = this.benefits;
+    retData.usage = this.usage;
+    retData.resources = this.resources;
+    retData.videos = this.videos;
+    retData.movie = this.movie;
+    retData.youtube = this.youtube;
+    retData.salesEventText = this.salesEventText;
+    retData.contentSection = this.contentSection;
+    retData.scanQualified = this.scanQualified;
+    retData.availableQuantity = this.availableQuantity;
+    retData.maxQuantity = this.maxQuantity;
+    retData.points = this.points;
+    retData.cv = this.cv;
+    retData.pv = this.pv;
+    retData.priceType = this.priceType;
+    retData.price = this.price;
+    retData.priceMap = this.priceMap;
+    retData.cvMap = this.cvMap;
+    retData.pvMap = this.pvMap;
+    retData.orderTypes = this.orderTypes;
+    retData.childSkus = this.childSkus;
+    retData.custTypes = this.custTypes;
+    retData.division = this.division;
+    retData.backOrderDate = this.backOrderDate;
+    retData.agelocme = this.agelocme ? this.agelocme.toJSON() : null;
+    retData.count = this.count;
+    retData.flavor = this.flavor;
+    retData.size = this.size;
+    retData.shade = this.shade;
+    retData.status = this.status;
+    retData.variantType = this.variantType;
+    retData.variantDropdownLabel = this.variantDropdownLabel;
+    retData.variantDropdownPlaceholder = this.variantDropdownPlaceholder;
+    retData.variantsLabel = this.variantsLabel;
+    retData.groupOffer = this.groupOffer;
+    retData.personalOffer = this.personalOffer;
+    retData.savedEventName = this.savedEventName;
+    retData.salesLabel = this.salesLabel;
+    retData.eventName = this.eventName;
+    retData.sizeWeight = this.sizeWeight;
+    retData.nettoWeight = this.nettoWeight;
+    retData.productLabels = this.productLabels;
+    retData.variants = toVariantJSON(this.variants);
+    retData.searchScore = this.searchScore;
+    retData.isExclusive = this.isExclusive;
+    retData.marketAttributes = this.marketAttributes;
+
+    return retData;
+  };
+
+  this.setMeCommerceProductData = function(/*productData*/) {
+    console.error("setMeCommerceProductData is deprecated!");
+  };
+
+  this.setBaseUrl = function(baseUrl) {
+    this.thumbnail = ProductUtils.applyBaseUrl(this.thumbnail, baseUrl);
+    this.fullImage = ProductUtils.applyBaseUrl(this.fullImage, baseUrl);
+
+    if (this.isBase()) {
+      for (const variantSku in this.variants) {
+        const variant = this.variants[variantSku];
+        variant.setBaseUrl(baseUrl);
+      }
+    }
+  };
+
+  this.setProductData = function(productData) {
+    let data;
+
+    if (productData) {
+      if (productData instanceof Product) {
+        data = productData.toJSON();
+      } else {
+        data = productData;
+      }
+      if (data.sku) {
+        this.sku = data.sku;
+      }
+      this.globalProductID = data.globalProductID || '';
+      this.title = data.title;
+      this.country = data.country;
+      this.lang = data.language;
+      this.shortDescr = data.shortDescr;
+      this.longDescr = data.longDescr;
+      this.isExclusive = isTrue(data.isExclusive);
+
+      // WARNING: Browser Detection will need to be handled in the client
+      // if (!BrowserDetection.isEdge() && !BrowserDetection.isFirefox()) {
+      //     this.fullImage = data.fullImage ? `${data.fullImage.split('?')[0]}?format=pjpg` : undefined;
+      //     this.thumbnail = data.thumbnail ? `${data.thumbnail.split('?')[0]}?format=pjpg` : undefined;
+      // }
+      this.fullImage = data.fullImage;
+      this.thumbnail = data.thumbnail;
+      this.imageAltText = data.imageAltText;
+      this.productCarouselImages = data.productCarouselImages;
+
+      this.ingredients = data.ingredients;
+      this.benefits = data.benefits;
+      this.usage = data.usage;
+      this.resources = data.resources;
+      this.videos = data.videos;
+      this.movie = data.movie;
+      this.youtube = data.youtube;
+      this.salesEventText = data.salesEventText;
+      this.contentSection = data.contentSection;
+      this.scanQualified = data.scanQualified;
+      this.status = data.status ? data.status : this.status;
+      if (data.availableQuantity) {
+        this.availableQuantity = data.availableQuantity;
+      }
+      if (data.maxQuantity >= 0) {
+        this.maxQuantity = data.maxQuantity;
+      }
+      if (data.points) {
+        this.setPoints(data.points);
+      }
+      if (data.cv) {
+        this.setCv(data.cv);
+      }
+      if (data.pv) {
+        this.setPv(data.pv);
+      }
+      if (data.price) {
+        this.setPrice(data.price);
+      }
+      if (data.formattedPrice) {
+        this.setFormattedPrice(data.formattedPrice);
+      }
+      if (data.priceType) {
+        this.priceType = data.priceType;
+      }
+      this.count = productData.count;
+      this.flavor = productData.flavor;
+      this.size = productData.size;
+      this.shade = productData.shade;
+      this.variantType = productData.variantType;
+      this.variantDropdownLabel = productData.variantDropdownLabel;
+      this.variantDropdownPlaceholder = productData.variantDropdownPlaceholder;
+      this.variantsLabel = productData.variantsLabel;
+      this.groupOffer = productData.groupOffer;
+      this.personalOffer = productData.personalOffer;
+      this.baseSku = productData.baseSku ? productData.baseSku : "";
+      this.savedEventName = productData.savedEventName;
+      this.sizeWeight = productData.sizeWeight;
+      this.nettoWeight = productData.nettoWeight;
+      this.productLabels = productData.productLabels;
+      this.salesLabel = productData.salesLabel;
+      this.eventName = productData.eventName;
+      this.variants = fromVariantJSON(this, productData.variants);
+      this.searchScore = productData.searchScore ? productData.searchScore : 0;
+      this.marketAttributes = productData.marketAttributes;
+      this.addOns = productData.addOns || [];
+
+      if (data.priceType) {
+        this.addPricing(data.priceType, data.price);
+        this.addPvWithType(data.priceType, data.pv);
+        this.addCvWithType(data.priceType, data.cv);
+      }
+      this.priceMap =
+        data.priceMap && Object.keys(data.priceMap).length > 0
+          ? data.priceMap
+          : this.priceMap;
+      this.cvMap =
+        data.cvMap && Object.keys(data.cvMap).length > 0
+          ? data.cvMap
+          : this.cvMap;
+      this.pvMap =
+        data.pvMap && Object.keys(data.pvMap).length > 0
+          ? data.pvMap
+          : this.pvMap;
+      this.orderTypes = ProductUtils.mergeOrderTypes(this.orderTypes, data.orderTypes);
+      if(data.childSkus) {
+        this.childSkus = data.childSkus;
+      }
+      this.custTypes = data.custTypes || [];
+
+      this.division = data.division;
+      this.backOrderDate = data.backOrderDate;
+
+      if (data.agelocme) {
+        this.agelocme = new Agelocme(data.agelocme);
+      }
+    }
+  };
+
+  this.isEmpty = function() {
+    return (
+      isFieldEmpty(this.sku) &&
+      isFieldEmpty(this.title) &&
+      isFieldEmpty(this.country) &&
+      isFieldEmpty(this.lang) &&
+      isFieldEmpty(this.shortDescr) &&
+      isFieldEmpty(this.longDescr) &&
+      isFieldEmpty(this.fullImage) &&
+      isFieldEmpty(this.thumbnail) &&
+      isFieldEmpty(this.points) &&
+      isFieldEmpty(this.cv) &&
+      isFieldEmpty(this.pv) &&
+      Object.keys(this.priceMap).length === 0
+    );
+  };
+
+  function isAdrType(priceType) {
+    return (
+      priceType === PriceType.WADW ||
+      priceType === PriceType.ADW ||
+      priceType === PriceType.WADR ||
+      priceType === PriceType.ADR
+    );
+  }
+
+  function getOppisiteAdrType(priceType) {
+    let retVal = priceType;
+
+    switch (priceType) {
+      case PriceType.WADW:
+        retVal = PriceType.ADW;
+        break;
+      case PriceType.ADW:
+        retVal = PriceType.WADW;
+        break;
+      case PriceType.WADR:
+        retVal = PriceType.ADR;
+        break;
+      case PriceType.ADR:
+        retVal = PriceType.WADR;
+        break;
+    }
+    return retVal;
+  }
+
+  function toVariantJSON(variants) {
+    let json = {};
+
+    Object.keys(variants).forEach((sku) => {
+      json[sku] = variants[sku].toJSON();
+    });
+
+    return json;
+  }
+
+  function fromVariantJSON(baseProduct, variantsJson) {
+    let variants = {};
+
+    if (variantsJson) {
+      for (const variantSku of Object.keys(variantsJson)) {
+        const variantJson = variantsJson[variantSku];
+        const variant = new Product(variantJson);
+
+        variant.baseSku = baseProduct.sku;
+
+        variants[variantSku] = variant;
+      }
+    }
+
+    return variants;
+  }
+
+  function updateBaseRanges(scope, variant) {
+    Object.keys(variant.priceMap).forEach((priceType) => {
+      let minPriceType = `min-${priceType}`,
+        maxPriceType = `max-${priceType}`;
+
+      scope.priceMap[minPriceType] = Math.min(
+        scope.priceMap[minPriceType] || variant.priceMap[priceType],
+        variant.priceMap[priceType]
+      );
+      scope.priceMap[maxPriceType] = Math.max(
+        scope.priceMap[maxPriceType] || 0.0,
+        variant.priceMap[priceType]
+      );
+
+      scope.pvMap[minPriceType] = Math.min(
+        scope.pvMap[minPriceType] || variant.pvMap[priceType],
+        variant.pvMap[priceType]
+      );
+      scope.pvMap[maxPriceType] = Math.max(
+        scope.pvMap[maxPriceType] || 0.0,
+        variant.pvMap[priceType]
+      );
+    });
+  }
+
+  function ensureFloatVal(val, acceptString) {
+    let intVal;
+    if (typeof val === "number") {
+      intVal = val;
+    } else if (typeof val === "string") {
+      intVal = Number(val.replace(/[^0-9.]+/g, ""));
+      if (isNaN(intVal) && acceptString) {
+        intVal = val;
+      }
+    }
+    return intVal;
+  }
+
+  function isFieldEmpty(fieldValue) {
+    return (
+      fieldValue === null || fieldValue === undefined || fieldValue.length === 0
+    );
+  }
+
+  let activeEvents = [];
+  function getEventPricing(scope, priceType, _activeEvents = null) {
+    let eventNames = scope.savedEventName
+      ? [scope.savedEventName]
+      : _activeEvents || activeEvents;
+    let retVal = { eventName: null };
+
+    eventNames.forEach((event) => {
+      let _eventPriceType = `${event}-${priceType}`;
+
+      if (scope.getPricing(_eventPriceType)) {
+        retVal.price = scope.getPricing(_eventPriceType);
+        retVal.cv = scope.getCvWithType(_eventPriceType);
+        retVal.pv = scope.getPvWithType(_eventPriceType);
+        retVal.priceType = _eventPriceType;
+        retVal.eventName = scope.effectiveEventName = event;
+      }
+    });
+
+    return retVal;
+  }
+
+  // WARNING: Product events will need to be handled in the client
+  // $.getValue(events.salesevent.ACTIVE_EVENTS, _activeEvents => {
+  //     if (_activeEvents) {
+  //         activeEvents = _activeEvents;
+  //     }
+  // }, true);
+
+  this.setProductData(productData);
+};
+
+module.exports = Product;