@nuskin/ns-shop 7.0.11-pur-813.1 → 7.0.11-pur-813.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuskin/ns-shop",
-  "version": "7.0.11-pur-813.1",
+  "version": "7.0.11-pur-813.2",
   "description": "The description that will amaze and astound your audience when they read it",
   "main": "src/shop.js",
   "scripts": {
@@ -26,7 +26,7 @@
     "@nuskin/ns-common-lib": "1.4.7",
     "@nuskin/ns-feature-flags": "1.4.7",
     "@nuskin/ns-loyalty-web": "1.5.6",
-    "@nuskin/ns-product-lib": "2.17.6",
+    "@nuskin/ns-product-lib": "2.19.1-pur-816.1",
     "@nuskin/nuskinjquery": "2.3.1",
     "@nuskin/order-model": "3.1.3",
     "@nuskin/product-lib": "2.2.1",

package/src/cart/csProductHelper.js

@@ -0,0 +1,318 @@
+import {productLib} from '@nuskin/product-lib';
+import {RunConfigService, events, UrlService, BrowserDetection} from '@nuskin/ns-util';
+import { getConfiguration } from '@nuskin/configuration-sdk';
+import {AccountManager} from '@nuskin/ns-account';
+import {PriceType, Product} from '@nuskin/ns-product-lib';
+
+const extractProductData = (data, sku) => {
+    let retVal;
+
+    if (Array.isArray(data.variants) && data.variants.length > 0) {
+        retVal = data.variants.find((variant) => variant.sku === sku);
+    } else if (data.bundle) {
+        retVal = data.bundle;
+        retVal.title = data.title;
+        retVal.productImages = data.productImages;
+    }
+
+    return retVal;
+}
+
+const addPrice = (productData, 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 (productData[priceTypeKey] === undefined) {
+        if (priceTypeKey === 'Points') {
+            if (!productData.price) {
+                productData.price = {};
+            }
+            productData.price.PTS = priceValue;
+            return;
+        } else {
+            productData[priceTypeKey] = {};
+        }
+    }
+    productData[priceTypeKey][subKey] = priceValue;
+}
+
+const convertPricing = (pricing, productData) => {
+    if (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(productData, priceTypeKey, 'WWHL', priceValue);
+                                    break;
+                                case 'webAdr':
+                                case 'WADW':
+                                case 'ADR5':
+                                    addPrice(productData, priceTypeKey, 'WADW', priceValue);
+                                    break;
+                                case 'order':
+                                case 'WHL':
+                                    addPrice(productData, priceTypeKey, 'WHL', priceValue);
+                                    break;
+                                case 'adr':
+                                    addPrice(productData, priceTypeKey, 'ADW', priceValue);
+                                    break;
+                                case 'ADR10':
+                                case 'WADWD':
+                                    addPrice(productData, priceTypeKey, 'WADWD', priceValue);
+                                    break;
+                                default:
+                                    addPrice(
+                                        productData,
+                                        priceTypeKey,
+                                        `${contextKey}-WWHL`,
+                                        priceValue
+                                    );
+                                    break;
+                            }
+                            break;
+                        case 'retail':
+                            switch (contextKey) {
+                                case 'webOrder':
+                                    addPrice(productData, priceTypeKey, 'WRTL', priceValue);
+                                    break;
+                                case 'webAdr':
+                                    addPrice(productData, priceTypeKey, 'WADR', priceValue);
+                                    break;
+                                case 'order':
+                                case 'RTL':
+                                    addPrice(productData, priceTypeKey, 'RTL', priceValue);
+                                    break;
+                                case 'adr':
+                                    addPrice(productData, priceTypeKey, 'ADR', priceValue);
+                                    break;
+                                default:
+                                    addPrice(
+                                        productData,
+                                        priceTypeKey,
+                                        `${contextKey}-WRTL`,
+                                        priceValue
+                                    );
+                                    break;
+                            }
+                            break;
+                    }
+                });
+            });
+        });
+    }
+}
+
+const createDataFromSkuSearch = (searchData, options) => {
+    if (!searchData) {
+        return new Product();
+    }
+    let product = new Product(),
+        langObj = null, //getLangObj(searchData['contents']['language'], options.language),
+        marketObj = null; //searchData['market'];
+    // if (Array.isArray(marketObj)) {
+    //     marketObj = getMarketObj(searchData['market'], options.country);
+    // }
+    let {orderType: mktOrderTypes, custType: mktCustTypes, restrictedMarket: restrictedMarkets, addOns} = {}; //marketObj;
+
+    if (searchData) {
+        product.sku = options.sku;
+        product.lang = options.language;
+        product.isExclusive = searchData.isExclusive;
+        if (Array.isArray(searchData.productImages) && searchData.productImages.length > 0) {
+            product.setFullImage(searchData.productImages[0].url);
+            product.setThumbnail(searchData.productImages[0].thumbnail);
+            // product.setProductCarouselImages(???searchData.contents.imageCarousel);
+        }
+        // product.productLabels = ???
+        product.title = searchData.title;
+        product.shortDescr = searchData.description;
+
+        const pricing = JSON.parse(searchData.pricingJson);
+        const orderTypes = [];
+        if (searchData.purchaseTypes.buyOnce) orderTypes.push('order');
+        if (searchData.purchaseTypes.subscription) orderTypes.push('adr');
+        let status = {
+            sku: options.sku,
+            globalProductId: searchData.globalId,
+            status: searchData.status.status === 'sellable' ? 'RELEASED_FOR_SALE' : 'NOT_RELEASED_FOR_SALE',
+            availableQuantity: searchData.availableQuantity,
+            maxQuantity: searchData.maxQuantity,
+            locallyProduced: searchData.locallyProduced,  // ???
+            backorderedAvailableDate: searchData.status.isBackordered > 0 ? searchData.status.backorderedAvailableDate : null,
+            orderType: orderTypes,  // searchData.channels.map((channel) => channel.toLowerCase()),
+            childSkus: null // ???
+        };
+        convertPricing(pricing, status);
+        product.addPricingFromStatus(status);
+    }
+
+
+    if (marketObj !== null) {
+        // product.sku = searchData.sku;
+        // product.isExclusive = Object.hasOwn(searchData, 'isExclusive') ? searchData.isExclusive : false;
+        if (Object.hasOwn(searchData, 'contents')) {
+            // product.setFullImage(searchData.contents.fullImage);
+            // product.setThumbnail(searchData.contents.fullImage.replace(/\.img\.[0-9]+\.[0-9]+\.png/i, '.img.160.160.png'));
+            // if (Object.hasOwn(searchData.contents, 'imageCarousel')) {
+            //     product.setProductCarouselImages(searchData.contents.imageCarousel);
+            // }
+        }
+        // AEM-8320 - it returns two BP (08007070 and 08129080), 08129080 does not have any translation yet.
+        // Note that langObj can be null (have a BP that does not have any translation)
+
+        // product.productLabels = marketObj['populateProductLabels'];
+        if (langObj) {
+            // product.lang = langObj['languageCode'];
+            // product.title = langObj['name'];
+            // product.shortDescr = langObj['shortDescription'];
+            product.longDescr = langObj['longDescription'];
+            product.ingredients = langObj['ingredients'];
+            product.benefits = langObj['benefits'];
+            product.usage = langObj['usage'];
+            product.resources = langObj['resources'];
+            product.videos = langObj['videos'];
+            product.contentSection = langObj['contentSection'];
+            product.sizeWeight = langObj['size_weight'];
+            product.nettoWeight = langObj['netto_weight'];
+            product.salesLabel = langObj['salesLabel'];
+            product.movie = langObj['movie'];
+            product.youtube = langObj['youtube'];
+            product.salesEventText = langObj['tdc_salesEventText'];
+            if (langObj.variantInfo) {
+                if (langObj.variantInfo.tdc_dropdownLabel) {
+                    product.variantDropdownLabel = langObj.variantInfo.tdc_dropdownLabel
+                }
+                if (langObj.variantInfo.tdc_dropdownPlaceholder) {
+                    product.variantDropdownPlaceholder = langObj.variantInfo.tdc_dropdownPlaceholder;
+                }
+                if (langObj.variantInfo.tdc_variantsLabel) {
+                    product.variantsLabel = langObj.variantInfo.tdc_variantsLabel;
+                }
+            }
+        }
+        product.setImageAltText(searchData['contents']['altText']);
+        product.country = marketObj['countryCode'];
+        product.scanQualified = marketObj['scanQualified'];
+        product.division = searchData['division'];
+
+        if (mktOrderTypes) {
+            product.orderTypes = mktOrderTypes;
+        }
+        if (mktCustTypes) {
+            product.custTypes = mktCustTypes;
+        }
+        if (restrictedMarkets) {
+            product.restrictedMarkets = restrictedMarkets;
+        }
+        if (addOns) {
+            product.addOns = addOns;
+        } else {
+            product.addOns = [];
+        }
+
+        if (options.isGroupOffer)
+            product.isGroupOffer = options.isGroupOffer;
+        if (options.isPersonalOffer)
+            product.isPersonalOffer = options.isPersonalOffer;
+    }
+
+    if (searchData.variantConfig) {
+        if (searchData.variantConfig.variantType) {
+            product.variantType = searchData.variantConfig.variantType;
+        }
+        if (searchData.variantConfig.variants) {
+            searchData.variantConfig.variants.forEach((variant) => {
+                product.setVariant(createDataFromSkuSearch(variant, options));
+            });
+        }
+        if (searchData.variantConfig.swatchColor) {
+            product.shade = searchData.variantConfig.swatchColor;
+        }
+        if (searchData.variantConfig.baseSku) {
+            product.baseSku = searchData.variantConfig.baseSku;
+        }
+    }
+
+    return product;
+}
+
+const handleDetailResponse = async (responseData, options) => {
+    let retVal = {success: true},
+        dataForProduct = createDataFromSkuSearch(responseData, options);
+
+    if (dataForProduct.sku) {
+        retVal.product = new Product(dataForProduct);
+
+        const siteUrl = UrlService.getSiteUrl();
+        const isEdge = BrowserDetection.isEdge();
+        const isFirefox = BrowserDetection.isFirefox();
+
+        // set the base url for images, etc
+        retVal.product.setBaseUrl(siteUrl);
+
+        // fix image paths for non-edge/firefox
+        if (!isEdge && !isFirefox) {
+            retVal.product.fullImage = retVal.product.fullImage
+                ? `${retVal.product.fullImage.split("?")[0]}?format=pjpg`
+                : undefined;
+            retVal.product.thumbnail = retVal.product.thumbnail
+                ? `${retVal.product.thumbnail.split("?")[0]}?format=pjpg`
+                : undefined;
+        }
+    } else {
+        retVal.success = false;
+        retVal.failedSku = options.sku;
+    }
+
+    if (retVal.product && options.priceType) {
+        const {Cart: cartCfg} = await getConfiguration(['Cart']);
+        const priceType = cartCfg.showWholeSalePricing && !AccountManager.isLoggedIn()
+            ? PriceType.WWHL
+            : options.priceType;
+        retVal.product.setPriceAndPvFromType(priceType);
+    }
+
+    return retVal;
+}
+
+const getProductDetail = async (options) => {
+    let response;
+
+    // Hit the PMD and get all the data for the product including the price information.
+    try {
+        response = await productLib.getProduct({
+            fromId: options.sku,
+            env: RunConfigService.getEnvironmentCode(),
+            market: options.country,
+            language: options.language
+        })
+    } catch (e) {
+        throw {error: e, failedSku: options.sku, type: events.errors.PRODUCT_LOOKUP};
+    }
+
+    return extractProductData(response.data, options.sku);
+}
+
+const getProductBySku = async (options) => {
+    const data = await getProductDetail(options);
+
+    let result = await handleDetailResponse(data, options);
+
+    return result;
+}
+
+export {
+    getProductBySku
+}

package/src/cart/productService.js

@@ -1,11 +1,12 @@
 import $ from '@nuskin/nuskinjquery';
 import {PriceType, Product} from '@nuskin/ns-product-lib';
-import {RunConfigService, events, BrowserDetection, UrlService} from '@nuskin/ns-util';
-import {AccountManager} from '@nuskin/ns-account';
+import {RunConfigService, events, util, BrowserDetection, UrlService} from '@nuskin/ns-util';
+import {UserService, AccountManager} from '@nuskin/ns-account';
 import ProductStatusService from '../product/ProductStatusService.js';
 import _ from 'lodash';
 import { getConfiguration } from '@nuskin/configuration-sdk';
-import {productLib} from '@nuskin/product-lib';
+import { getProductBySku as getCsProductBySku } from './csProductHelper.js';
+import axios from 'axios';
 
 let ProductService = function() {
     // ---------------------------------------------
@@ -21,24 +22,13 @@ let ProductService = function() {
          * @returns {null}
          */
         getProductBySku: async function(_options) {
-            let options = verifyLocaleFields(_options),
-                promises = [getProductDetail(options)];
-
-            promises.push(getProductStatus(options));
-
-            let values = await Promise.all(promises);
-
-            let result = await handleDetailResponse(values[0], options);
-
-            if (values[1] && values[1][0]) {
-                handleStatusResponse(result.product, values[1][0], options);
+            const options = verifyLocaleFields(_options)
+            const {Cart: cartCfg} = await getConfiguration(['Cart']);
+            if (cartCfg.useContentStackProductData) {
+                return await getCsProductBySku(options)
             } else {
-                // Fallback for product quantity on a failed product status call.
-                // This is done to prevent the product detail component from locking up unnecessarily.
-                result.product.availableQuantity = 10000;
+                return await legacyGetProductBySku(options);
             }
-
-            return result;
         },
 
         /**
@@ -84,22 +74,42 @@ let ProductService = function() {
     //        Private Methods
     //
     // ---------------------------------------------
+    async function legacyGetProductBySku(options) {
+        const promises = [getProductDetail(options)];
+
+        promises.push(getProductStatus(options));
+
+        let values = await Promise.all(promises);
+
+        let result = await handleDetailResponse(values[0], options);
+
+        if (values[1] && values[1][0]) {
+            handleStatusResponse(result.product, values[1][0], options);
+        } else {
+            // Fallback for product quantity on a failed product status call.
+            // This is done to prevent the product detail component from locking up unnecessarily.
+            result.product.availableQuantity = 10000;
+        }
+
+        return result;
+    }
+
     async function getProductDetail(_options) {
         let options = _options;
-        let response;
+        let url = await getSkuSearchUrl(options);
+        let data;
 
         // Hit the PMD and get all the data for the product including the price information.
+        // Example url: https://test.nuskin.com/content/products/01/00/34/01003440.service.US.json
         try {
-            response = await productLib.getProduct({
-                fromId: options.sku,
-                env: RunConfigService.getEnvironmentCode(),
-                market: options.country,
-                language: options.language
+            data = await axios({
+                method: 'GET',
+                url
             })
         } catch (e) {
-            throw {error: e, failedSku: options.sku, type: events.errors.PRODUCT_LOOKUP};
+            throw {error: e, url: url, failedSku: options.sku, type: events.errors.PRODUCT_LOOKUP};
         }
-        return response.data;
+        return data.data;
     }
 
     function getProductStatus(_options) {
@@ -125,6 +135,36 @@ let ProductService = function() {
         );
     }
 
+    async function getSkuSearchUrl(options) {
+        let firstTwo = options.sku.substring(0, 2),
+            secondTwo = options.sku.substring(2, 4),
+            thirdTwo = options.sku.substring(4, 6),
+            runConfig = RunConfigService.getRunConfig(),
+            query = '',
+            skuSearchUrl;
+
+        const {Url: urlCfg} = await getConfiguration(['Url']);
+        skuSearchUrl = urlCfg.skuSearchUrl;
+
+        if (runConfig.baseUrl !== '' && !skuSearchUrl.startsWith('http')) {
+            query = runConfig.baseUrl;
+        }
+
+        if (UserService.isLTOSite()){
+            query += util.getSiteConfig().urls.skuSearchUrl[0].replace('{firstTwo}', firstTwo);
+        }
+        else{
+            query += skuSearchUrl.replace('{firstTwo}', firstTwo);
+        }
+
+        query = query.replace('{secondTwo}', secondTwo);
+        query = query.replace('{thirdTwo}', thirdTwo);
+        query = query.replace('{sku}', options.sku);
+        query = query.replace('{countryCd}', options.cntryCd ? options.cntryCd : options.country);
+
+        return query;
+    }
+
     async function handleDetailResponse(responseData, options) {
         let retVal = {success: true},
             dataForProduct = createDataFromSkuSearch(responseData, options);