@nuskin/ns-product-lib 1.3.7

package/src/productContentMapper.js

@@ -0,0 +1,196 @@
+"use strict";
+
+const { isNullOrEmpty, isTrue }  = require("@nuskin/ns-common-lib");
+
+const Product = require("./product.js");
+const ProductUtils = require("./productUtils.js");
+
+/**
+ * Contains functions to map the AEM Product Content to a Product (product.js).
+ */
+const ProductContentMapper = {
+  /**
+   * Creates a Product (product.js) object from the AEM Product Content response.
+   * @param {Object} productContent the AEM response
+   * @param {Object} options {language, country, isGroupOffer, isPersonalOffer, productStatus, priceType}
+   */
+  createProduct: function(productContent, options = {}) {
+    if (isNullOrEmpty(productContent)) {
+      return null;
+    }
+
+    if (isNullOrEmpty(options)) {
+      options = {};
+    }
+
+    let product = new Product();
+
+    // set market values
+    let marketData = productContent.market;
+
+    if (Array.isArray(marketData)) {
+      marketData = getMarketData(marketData, options.country);
+    }
+
+    if (marketData) {
+      product.country = marketData.countryCode;
+      product.productLabels = marketData.populateProductLabels;
+      product.scanQualified = marketData.scanQualified;
+
+      const marketOrderTypes = marketData.orderType;
+      if (marketOrderTypes) {
+        product.orderTypes = ProductUtils.getOrderTypesMapping(marketOrderTypes);
+      }
+
+      const marketCustomerTypes = marketData.custType;
+      if (marketCustomerTypes) {
+        product.custTypes = marketCustomerTypes;
+      }
+
+      const restrictedMarkets = marketData.restrictedMarket;
+      if (restrictedMarkets) {
+        product.restrictedMarkets = restrictedMarkets;
+      }
+    }
+
+    // set product values
+    product.sku = productContent.sku;
+    product.isExclusive = isTrue(productContent.isExclusive);
+
+    if (productContent.contents) {
+      const fullImage = productContent.contents.fullImage;
+      if (fullImage) {
+        product.setFullImage(fullImage);
+        product.setThumbnail(
+          fullImage.replace(
+            /\.img\.[0-9]+\.[0-9]+\.png/i,
+            ".img.160.160.png"
+          )
+        );
+      }
+
+      const imageCarousel = productContent.contents.imageCarousel;
+      if (imageCarousel) {
+        product.setProductCarouselImages(imageCarousel);
+      }
+
+      // set product language data
+      let languageData = getLanguageData(
+        productContent.contents.language,
+        options.language
+      );
+  
+      // AEM-8320 - it returns two BP (08007070 and 08129080), 08129080 does not have any translation yet.
+      // language data can be null (have a BP that does not have any translation)
+      if (languageData) {
+        product.lang = languageData.languageCode || "";
+        product.title = languageData.name || "";
+        product.shortDescr = languageData.shortDescription || "";
+        product.longDescr = languageData.longDescription || "";
+        product.ingredients = languageData.ingredients || "";
+        product.benefits = languageData.benefits || "";
+        product.usage = languageData.usage || "";
+        product.resources = languageData.resources || "";
+        product.videos = languageData.videos || "";
+        product.contentSection = languageData.contentSection || "";
+        product.sizeWeight = languageData.size_weight || "";
+        product.nettoWeight = languageData.netto_weight || "";
+        product.movie = languageData.movie || "";
+        product.youtube = languageData.youtube || "";
+        product.salesEventText = languageData.tdc_salesEventText || "";
+        product.salesLabel = languageData.salesLabel || "";
+
+        if (languageData.variantInfo) {
+          if (languageData.variantInfo.tdc_dropdownLabel) {
+            product.variantDropdownLabel =
+            languageData.variantInfo.tdc_dropdownLabel;
+          }
+          if (languageData.variantInfo.tdc_dropdownPlaceholder) {
+            product.variantDropdownPlaceholder =
+            languageData.variantInfo.tdc_dropdownPlaceholder;
+          }
+          if (languageData.variantInfo.tdc_variantsLabel) {
+            product.variantsLabel = languageData.variantInfo.tdc_variantsLabel;
+          }
+        }
+  
+        product.setImageAltText(productContent.contents.altText);
+      }
+    }
+
+    product.division = productContent.division;
+  
+    product.isGroupOffer = !!options.isGroupOffer;
+    product.isPersonalOffer = !!options.isPersonalOffer;
+
+    // set product variants values
+    if (productContent.variantConfig) {
+      if (productContent.variantConfig.variantType) {
+        product.variantType = productContent.variantConfig.variantType;
+      }
+      if (productContent.variantConfig.variants) {
+        productContent.variantConfig.variants.forEach((variant) => {
+          product.setVariant(this.createProduct(variant, options));
+        });
+      }
+      if (productContent.variantConfig.swatchColor) {
+        product.shade = productContent.variantConfig.swatchColor;
+      }
+      if (productContent.variantConfig.baseSku) {
+        product.baseSku = productContent.variantConfig.baseSku;
+      }
+    }
+
+    // set options
+    if (options.productStatus) {
+      product.setMarketAttributes(options.productStatus);
+      product.addPricingFromStatus(options.productStatus);
+    }
+
+    if (options.priceType) {
+      product.setPriceAndPvFromType(options.priceType);
+    }
+
+    return product;
+  }
+};
+
+function getLanguageData(languageDataArray, language) {
+  if (!Array.isArray(languageDataArray) || !languageDataArray.length) {
+    return null;
+  }
+
+  if (languageDataArray.length === 1) {
+    return languageDataArray[0];
+  }
+
+  const fallbackLanguageData = languageDataArray.find(md => md.languageCode === "en");
+
+  if (language) {
+    const nativeLanguageData = languageDataArray.find(md => md.languageCode === language);
+    return nativeLanguageData || fallbackLanguageData;
+  }
+
+  return fallbackLanguageData;
+}
+
+function getMarketData(marketDataArray, country) {
+  if (!Array.isArray(marketDataArray) || !marketDataArray.length) {
+    return null;
+  }
+
+  if (marketDataArray.length === 1) {
+    return marketDataArray[0];
+  }
+
+  const fallbackMarketData = marketDataArray.find(md => md.countryCode === "US");
+
+  if (country) {
+    const nativeMarketData = marketDataArray.find(md => md.countryCode === country);
+    return nativeMarketData || fallbackMarketData;
+  }
+
+  return fallbackMarketData;
+}
+
+module.exports = ProductContentMapper;

package/src/productStatus.js

@@ -0,0 +1,20 @@
+"use strict";
+
+const ProductStatus = {
+  Discontinued: "DISCONTINUED",
+  NotReleasedForSale: "NOT_RELEASED_FOR_SALE",
+  ReleasedForSale: "RELEASED_FOR_SALE",
+  NotFound: "NOT_FOUND",
+  StopStatus: "STOP_STATUS",
+
+  //properties allows you do do something like ProductStatus.properties['DISCONTINUED'].code to get the status code
+  properties: {
+    DISCONTINUED: { stringKey: "discontinued", code: 2 },
+    NOT_RELEASED_FOR_SALE: { stringKey: "notReleasedForSale", code: 9 },
+    RELEASED_FOR_SALE: { stringKey: "", code: 10 },
+    STOP_STATUS: { stringKey: "stopStatus", code: 5 },
+    NOT_FOUND: { stringKey: "", code: 0 }
+  }
+};
+
+module.exports = ProductStatus;

package/src/productStatusMapper.js

@@ -0,0 +1,190 @@
+"use strict";
+
+/**
+ * Contains functions to map Product Status responses to the object fit for
+ * Product (product.js) consumption in the addPricingFromStatus function.
+ */
+const ProductStatusMapper = {
+  /**
+   * Creates Product Status objects fit for Product (product.js) consumption from the V2 response
+   * @param {Object} productStatusV2Response
+   * @return {Array<object>}
+   * @private
+   */
+  createProductStatusesFromV2: function(productStatusV2Response) {
+    const productStatuses = [];
+    if (productStatusV2Response.items) {
+      for (const productStatusSku of Object.keys(productStatusV2Response.items)) {
+        const productStatusV2 = productStatusV2Response.items[productStatusSku];
+        productStatusV2.sku = productStatusSku;
+        const productStatus = this.createProductStatusFromV2(productStatusV2);
+        productStatuses.push(productStatus);
+      }
+    }
+    return productStatuses;
+  },
+
+  /**
+   * Creates Product Status object fit for Product (product.js) consumption from its V2 counterpart
+   * @param {Object} productStatusV2
+   * @return {object}
+   * @private
+   */
+  createProductStatusFromV2: function(productStatusV2) {
+    const productStatus = {
+      sku: productStatusV2.sku,
+      globalProductID: productStatusV2.globalProductID,
+      backordered: productStatusV2.backordered,
+      backorderedAvailableDate: productStatusV2.backorderedAvailableDate,
+      availableQuantity: productStatusV2.availableQuantity,
+      webEnabled: productStatusV2.webEnabled,
+      status: getStatusPartFromV2(productStatusV2),
+      orderType: productStatusV2.orderType,
+      marketAttributes: productStatusV2.marketAttributes,
+      childSkus: productStatusV2.childSkus != null ? productStatusV2.childSkus : []
+    };
+    addPricingFromV2(productStatusV2, productStatus);
+    return productStatus
+  }
+};
+
+/**
+* Gets the status value (productStatus.status) from V2
+* @param {Object} productStatusV2
+* @return {String}
+*/
+function getStatusPartFromV2(productStatusV2) {
+  const retailStatusIsReleased = productStatusV2.status.retail === 'RELEASED_FOR_SALE';
+  const wholesaleStatusIsReleased =
+  productStatusV2.status.wholesale === 'RELEASED_FOR_SALE';
+  const retailNotSet = productStatusV2.status.retail === 'NOT_SET_FOR_DIST_TYPE';
+  const wholesaleNotSet = productStatusV2.status.wholesale === 'NOT_SET_FOR_DIST_TYPE';
+  if (retailStatusIsReleased || wholesaleStatusIsReleased) {
+    return 'RELEASED_FOR_SALE';
+  }
+
+  if (retailNotSet || wholesaleNotSet) {
+    if (retailNotSet && wholesaleNotSet) {
+      return 'NOT_RELEASED_FOR_SALE';
+    }
+    if (retailNotSet) {
+      return productStatusV2.status.wholesale;
+    }
+    if (wholesaleNotSet) {
+      return productStatusV2.status.retail;
+    }
+  }
+
+  return productStatusV2.status.retail;
+}
+
+/**
+* Adds Product Status Pricing from V2
+* @param {Object} productStatusV2
+* @param {Object} productStatus
+*/
+function addPricingFromV2(productStatusV2, productStatus) {
+  if (productStatusV2 && productStatusV2.pricing) {
+    const pricing = productStatusV2.pricing;
+    Object.keys(pricing).forEach((channelKey) => {
+      Object.keys(pricing[channelKey]).forEach((contextKey) => {
+        Object.keys(pricing[channelKey][contextKey]).forEach((priceTypeKey) => {
+          const priceValue = pricing[channelKey][contextKey][priceTypeKey];
+          switch (channelKey) {
+            case 'wholesale':
+              switch (contextKey) {
+                case 'webOrder':
+                  addPrice(productStatus, priceTypeKey, 'WWHL', priceValue);
+                  break;
+                case 'webAdr':
+                case 'WADW':
+                case 'ADR5':
+                  addPrice(productStatus, priceTypeKey, 'WADW', priceValue);
+                  break;
+                case 'order':
+                case 'WHL':
+                  addPrice(productStatus, priceTypeKey, 'WHL', priceValue);
+                  break;
+                case 'adr':
+                  addPrice(productStatus, priceTypeKey, 'ADW', priceValue);
+                  break;
+                case 'ADR10':
+                case 'WADWD':
+                  addPrice(productStatus, priceTypeKey, 'WADWD', priceValue);
+                  break;
+                default:
+                  addPrice(
+                    productStatus,
+                    priceTypeKey,
+                    `${contextKey}-WWHL`,
+                    priceValue
+                  );
+                  break;
+              }
+              break;
+            case 'retail':
+              switch (contextKey) {
+                case 'webOrder':
+                  addPrice(productStatus, priceTypeKey, 'WRTL', priceValue);
+                  break;
+                case 'webAdr':
+                  addPrice(productStatus, priceTypeKey, 'WADR', priceValue);
+                  break;
+                case 'order':
+                case 'RTL':
+                  addPrice(productStatus, priceTypeKey, 'RTL', priceValue);
+                  break;
+                case 'adr':
+                  addPrice(productStatus, priceTypeKey, 'ADR', priceValue);
+                  break;
+                default:
+                  addPrice(
+                    productStatus,
+                    priceTypeKey,
+                    `${contextKey}-WRTL`,
+                    priceValue
+                  );
+                  break;
+              }
+              break;
+          }
+        });
+      });
+    });
+  }
+}
+
+/**
+* Adds a price tp the Product Status
+* @param {Object} productStatus
+* @param {String} priceTypeKey
+* @param {String} subKey
+* @param {number} priceValue
+*/
+function addPrice(productStatus, priceTypeKey, subKey, priceValue) {
+  if (!['Points', 'cv', 'price', 'pv'].includes(priceTypeKey)) {
+    // if the priceTypeKey is not one of these, then we don't want it to show.
+    return;
+  }
+  if (priceTypeKey === 'pv') {
+    priceTypeKey = 'psv';
+  }
+  if (priceTypeKey === 'cv') {
+    priceTypeKey = 'csv';
+  }
+
+  if (productStatus[priceTypeKey] === undefined) {
+    if (priceTypeKey === 'Points') {
+      if (!productStatus.price) {
+        productStatus.price = {};
+      }
+      productStatus.price.PTS = priceValue;
+      return;
+    } else {
+      productStatus[priceTypeKey] = {};
+    }
+  }
+  productStatus[priceTypeKey][subKey] = priceValue;
+}
+
+module.exports = ProductStatusMapper;

package/src/productUtils.js

@@ -0,0 +1,83 @@
+/* eslint-disable max-len */
+
+"use strict";
+
+const { isNullOrEmpty, getFullUrl } = require("@nuskin/ns-common-lib");
+
+const ProductUtils = {
+  /**
+   * Returns string needed for getting product data from PMD
+   * Example full url where this is used: "https://test.nuskin.com/content/products/01/16/08/01160862/en.service.US.json"
+   * @param {string} sku - ex. "01160862"
+   * @returns tokenized sku - ex. "01/16/08/01160862"
+   */
+  getTokenizedSku: function(sku) {
+    let { part1, part2, part3 } = this.getTokenizedSkuParts(sku);
+    return `${part1}/${part2}/${part3}/${sku}`;
+  },
+
+  /**
+   * Returns string parts needed for getting product data from PMD
+   * @param {string} sku - ex. "01160862"
+   * @returns {{ part1, part2, part3 }} tokenized sku parts - ex. { "part1": "01", "part2": "16", "part3": "08" }
+   */
+  getTokenizedSkuParts: function(sku) {
+    let part1 = sku.substring(0, 2); // "01"
+    let part2 = sku.substring(2, 4); // "11"
+    let part3 = sku.substring(4, 6); // "11"
+    return {
+      part1,
+      part2,
+      part3
+    };
+  },
+
+  /**
+   * Applies a Base URL by prepending it to an existing URL when applicable
+   * @param {string} url - ex. "content/..." or "http://test.nuskin.com/content/..."
+   * @param {string} baseUrl - ex. "http://test.nuskin.com"
+   * @returns {string} full url
+   */
+  applyBaseUrl: function(url, baseUrl) {
+    const fullUrl = getFullUrl(baseUrl, url);
+    return fullUrl.replace("http://", "https://");
+  },
+
+  mergeOrderTypes: function(previousOrderTypes, newOrderTypes) {
+    // untrust previous order types, override them to false
+    const previousOrderTypesMapping = this.getOrderTypesMapping(previousOrderTypes, true);
+
+    // trust new order types
+    const newOrderTypesMapping = this.getOrderTypesMapping(newOrderTypes);
+
+    return {
+      ...previousOrderTypesMapping,
+      ...newOrderTypesMapping
+    };
+  },
+  
+  /**
+   * Gets the order types as a dictionary/mapping of order type to value
+   * @param {string[] | object[]} orderTypes - ex. ["adr", "order"] or { adr: false, order: true }
+   * @param {boolean} override - used to force the value of each orderType to false
+   * @returns {object} order types dictionary/mapping
+   */
+  getOrderTypesMapping: function(orderTypes, override = false) {
+    if (isNullOrEmpty(orderTypes)) {
+      return {};
+    }
+    const orderTypesMapping = {};
+    if (Array.isArray(orderTypes)) {
+      for (const orderType of orderTypes) {
+        orderTypesMapping[orderType.toLowerCase()] = !override;
+      }
+    } else {
+      for (const orderType in orderTypes) {
+        orderTypesMapping[orderType.toLowerCase()] = !override && !!orderTypes[orderType];
+      }
+    }
+    return orderTypesMapping;
+  }
+};
+
+module.exports = ProductUtils;