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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuskin/ns-shop",
-  "version": "7.0.11-pur-813.1",
+  "version": "7.0.11-pur-813.3",
   "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",
     "@nuskin/nuskinjquery": "2.3.1",
     "@nuskin/order-model": "3.1.3",
     "@nuskin/product-lib": "2.2.1",

package/src/cart/cartService.js

@@ -34,6 +34,7 @@ export default {
     hasItems,
     hasEventItems,
     hasPreviewItems,
+    hasDanerousGoods,
     getItemCnt,
     addProductToCart,
     addSkuToCart,
@@ -298,6 +299,14 @@ function hasPreviewItems() {
     return _getCart().hasPreviewItems();
 }
 
+function hasDanerousGoods(options = {cartOrderItems: true}) {
+    let retVal = false;
+    _getCart().getItems(options).forEach((item) => {
+        retVal = retVal || item.product.dangerousGoods;
+    });
+    return retVal;
+}
+
 function getItemCnt(options) {
     return _getCart().getItemCnt(options);
 }

package/src/cart/csProductHelper.js

@@ -0,0 +1,267 @@
+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);
+        retVal.variantSelectLabel = data.variantSelectLabel;
+    } 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();
+
+    if (searchData) {
+        product.sku = options.sku;
+        product.country = options.country;
+        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.setImageAltText(searchData.productImages[0].altText);
+            // product.setProductCarouselImages(???searchData.contents.imageCarousel);
+        }
+        // product.productLabels = ???
+        product.title = searchData.title;
+        product.shortDescr = searchData.description;
+        // product.longDescr = langObj['longDescription']; looks like it is deprecated
+        product.dangerousGoods = searchData.dangerousGoods === true;
+        product.ingredients = searchData.ingredients;
+        product.benefits = searchData.benefits;
+        product.usage = searchData.usage;
+        product.resources = searchData.resources;
+        // product.videos = searchData.???;
+        // product.contentSection =searchData.???;
+        // product.sizeWeight = ???;
+        product.size = searchData.size;
+        product.nettoWeight = searchData.nettoWeight;
+        product.salesLabel = searchData.salesLabel;
+        // product.movie = searchData.???;
+        // product.youtube = searchData.???;
+        product.salesEventText = searchData.salesText;
+        product.scanQualified = searchData.scanQualifiedCount;
+        // product.division = searchData.???
+        product.custTypes = Array.isArray(searchData.customerTypes) && searchData.customerTypes.map((ct) => {
+            if (ct === 'Preferred') return '30';
+            else if (ct === 'Retail') return '20';
+            else if (ct === '') return '10';
+        });
+        product.restrictedMarkets = searchData.restrictedMarkets;
+        // if (addOns) {
+        //     product.addOns = addOns;
+        // } else {
+        //     product.addOns = [];
+        // }
+        if (options.isGroupOffer) product.isGroupOffer = options.isGroupOffer;
+        if (options.isPersonalOffer) product.isPersonalOffer = options.isPersonalOffer;
+
+        product.variantsLabel = searchData.variantLabel;
+        product.variantDropdownLabel = searchData.variantSelectLabel;
+        product.shade = searchData.variantColor;
+
+        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);
+    }
+
+    // Note: this mapping was originally created for the product data in AEM. This product
+    // data comes from content stack and is not identical to what is in AEM. There may
+    // need to be some tweaks in here. ESPECIALLY when the data gets moved to the
+    // bundle field (vs variants) in the product data.
+
+    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);

package/src/shipping/pickupUtil.js

@@ -1,10 +1,8 @@
-import OrderAdapter from '../order/orderAdapter';
 import {getCachedConfiguration} from '@nuskin/configuration-sdk';
 import {Order} from '@nuskin/order-model';
 import {RunConfigService} from '@nuskin/ns-util';
-// import {CartService} from '@nuskin/ns-shop';
+import {OrderManager, CartService, OrderType, OrderAdapter} from '../shop';
 import axios from 'axios';
-import { OrderManager } from '../shop';
 
 let PickupUtil = function() {
     'use strict';
@@ -142,6 +140,20 @@ let PickupUtil = function() {
         return markers;
     }
 
+    function getOrderValue() {
+        let value = 0;
+        const orderType = OrderManager.getOrder().orderType;
+        const cartInfo = CartService.getCartInfo();
+
+        if (orderType === OrderType.SINGLE_ORDER) {
+            value = cartInfo.totalOrderPrice;
+        } else {
+            value = cartInfo.totalOrderPrice + cartInfo.totalAdrPrice;
+        }
+
+        return value;
+    }
+
     function getUrl() {
         switch (RunConfigService.getEnvironmentCode()) {
             case 'dev':
@@ -164,7 +176,6 @@ let PickupUtil = function() {
         const {metapackMarket, metapackZipExclusions} = getCachedConfiguration('Checkout');
 
         if (metapackMarket) {
-            const order = OrderManager.getOrder();
             let includePickupPoints = true;
             for (const zipRegEx of metapackZipExclusions || []) {
                 const regEx = new RegExp(zipRegEx);
@@ -176,7 +187,8 @@ let PickupUtil = function() {
                 {
                     order,
                     pudo: includePickupPoints,
-                    orderValue: order && order.orderTotals && order.orderTotals.grandTotal || 0.0
+                    orderValue: getOrderValue(),
+                    dangerousGoods: CartService.hasDangerousGoods()
                 },
                 {
                     headers: {