@nuskin/ns-shop 7.1.0-brw-988.1 → 7.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuskin/ns-shop",
-  "version": "7.1.0-brw-988.1",
+  "version": "7.1.0",
   "description": "The description that will amaze and astound your audience when they read it",
   "main": "src/shop.js",
   "scripts": {
@@ -26,8 +26,10 @@
     "@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.0",
+    "@nuskin/ns-product-lib": "2.19.1",
     "@nuskin/nuskinjquery": "2.3.1",
+    "@nuskin/order-model": "3.1.3",
+    "@nuskin/product-lib": "2.2.1",
     "axios": "1.6.5",
     "decimal.js": "10.4.3",
     "jp-conversion": "0.0.7",
@@ -40,8 +42,8 @@
     "@nuskin/exclusive-offer-sdk": "1.2.4",
     "@nuskin/ns-account": "5.9.2",
     "@nuskin/ns-jsanalyzer": "1.0.1",
-    "@nuskin/ns-product": "3.50.0",
-    "@nuskin/ns-util": "4.5.4",
+    "@nuskin/ns-product": "3.50.5",
+    "@nuskin/ns-util": "4.6.1",
     "axios-mock-adapter": "1.22.0",
     "babel-cli": "6.26.0",
     "babel-core": "6.26.3",

package/src/cart/cart.js

@@ -832,9 +832,12 @@ export default function Cart(cartData) {
     };
 
     this.updateProductEventPrice = function(item, activeEvents) {
+        let eventNameAdded = false;
         const user = UserService.getUser();
         const priceType = ShopContext.getPriceType(item.isAdr(), user);
+        const eventName = item.product.eventName;
         if (item.product.setPriceAndPvFromType(priceType, activeEvents)) {
+            if (!eventName && item.product.eventName) eventNameAdded = true;
             SalesEventService.logAnalyticInfo(
                 'product-price-to-event-price',
                 item.product.eventName,
@@ -848,15 +851,20 @@ export default function Cart(cartData) {
                 }
             });
         }
+        return eventNameAdded;
     };
 
     this.updateEventPrices = function(activeEvents) {
+        let eventNameAdded = false;
         getCartItems({cartItems: true}).forEach(item => {
-            this.updateProductEventPrice(item, activeEvents);
+            if (this.updateProductEventPrice(item, activeEvents))
+                eventNameAdded = true;
         });
+        return eventNameAdded;
     };
 
     this.setMissingEventNames = async (order) => {
+        let cartUpdated = false;
         const orderItems = this.getItems({cartOrderItems: true});
         let nameSet = new Set();
         let itemsChecked = [];
@@ -875,6 +883,7 @@ export default function Cart(cartData) {
                     if (itemEvents.includes(ien)) {
                         // set this items eventName if another item already has it set.
                         item.product.eventName = ien;
+                        cartUpdated = true;
                     }
                     return !!item.product.eventName; // causes loop to stop if true
                 });
@@ -896,6 +905,7 @@ export default function Cart(cartData) {
                 itemEvents.some((ie) => {
                     if (eventStatuses[ie]) {
                         // set the status if event is active.
+                        cartUpdated = true;
                         item.product.eventName == ie;
                         SalesEventService.logAnalyticInfo(
                             'cart-eventname-fixed', ie,
@@ -906,6 +916,7 @@ export default function Cart(cartData) {
                 })
             });
         }
+        return cartUpdated;
     }
 
     this.getCartInfo = function(options) {

package/src/cart/cartService.js

@@ -34,6 +34,7 @@ export default {
     hasItems,
     hasEventItems,
     hasPreviewItems,
+    hasDangerousGoods,
     getItemCnt,
     addProductToCart,
     addSkuToCart,
@@ -229,10 +230,23 @@ function updateItemPrices() {
 }
 
 async function checkForMissingEventNames(order) {
+    let outOfSync = false;
     await awaitForConfig();
     const cart = _getCart();
-    await cart.setMissingEventNames(order);
+
+    // check to see if cart item has eventName but sapItem does not.
+    const orderItems = cart.getItems({cartOrderItems: true});
+    orderItems.map((item) => {
+        const sapItem = order.sapItems.find((sapItem) => (
+            sapItem.sku === item.product.sku && sapItem.isAdr === item.adr
+        ));
+        if (sapItem && item.product.eventName && !sapItem.eventName)
+            outOfSync = true;
+    });
+
+    let updated = await cart.setMissingEventNames(order);
     setCart(cart);
+    return updated || outOfSync;
 }
 
 function getCartProperty(key) {
@@ -285,6 +299,14 @@ function hasPreviewItems() {
     return _getCart().hasPreviewItems();
 }
 
+function hasDangerousGoods(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);
 }
@@ -354,10 +376,11 @@ async function addProductToCart(options) {
     }
 
     options.product.isBackOrdered = (options.product.inventory === "BACKORDER") ? true : false
-    
+
     const language = options.product.lang || options.product.language;
     options.product.lang = language;
     options.product.language = language;
+    const eventName = options.product.eventName;
 
     let itemKey = cart.addProduct({
         id: options.id,
@@ -377,6 +400,8 @@ async function addProductToCart(options) {
     });
 
     const item = itemKey ? cart.getItemByKey(itemKey) : null;
+    // eventName would get nulled out if sapItem
+    item.product.eventName = eventName;
     setCart(cart,  item ? !item.isSapLineItem() : true);
     return itemKey;
 }
@@ -489,7 +514,10 @@ async function getAddToCartQty(product) {
         retVal = product.maxQuantity - cartQty;
         if (product.isExclusive) {
             try {
-                const qual = await QualificationService.getQualification(product.sku)
+                const qual = await QualificationService.getQualification(product.sku);
+                if (!qual) {
+                    return 0;
+                }
                 const productIdentifier = qual.productId || qual.sku;
                 cartQty = await getBaseSkuCartQuantity(productIdentifier)
                 retVal = product.maxQuantity - cartQty;
@@ -1407,8 +1435,10 @@ const cartServiceConfigCallback = async (configs) => {
             if (_activeEvents != undefined) {
                 activeEvents = _activeEvents;
                 const cart = _getCart();
-                cart.updateEventPrices(activeEvents)
-                setCart(cart);
+                if (cart.updateEventPrices(activeEvents)) {
+                    events.setValue(events.shop.CART_EVENT_PRICE_UPDATED, [activeEvents]);
+                    setCart(cart);
+                }
             }
         }, true);
         events.publish(events.salesevent.POLL_MARKET_CONFIG);

package/src/cart/csProductHelper.js

@@ -0,0 +1,274 @@
+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) || data.variants[0];
+        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;
+}
+
+const getProductData = async (options) => {
+    const data = await getProductDetail(options);
+
+    return createDataFromSkuSearch(data, options);
+}
+
+export {
+    getProductBySku,
+    getProductData
+}

package/src/cart/equinoxCartService.js

@@ -20,7 +20,8 @@ const shoppingContextCartTypes = {
 
 const DEFAULT_CART_TYPE = 'USER';
 
-let cartContents = null;
+let requestStatus = 'idle';
+let cartPromise = null;
 
 export default {
     addProductToEquinoxCart,
@@ -46,8 +47,15 @@ function _getEquinoxSession() {
         method: 'GET',
         endpoint: 'customers'
     }
+    const customerSession = sessionStorage.getItem('customerSession') ? JSON.parse(sessionStorage.getItem('customerSession')) : ''
+    if (customerSession === '') {
+        sessionStorage.setItem('customerSession', true)
+        return _equinoxRequest(equinoxRequestOptions)
+    } else {
+        return null
+    }
+    
 
-    return _equinoxRequest(equinoxRequestOptions);
 }
 
 /**
@@ -216,22 +224,25 @@ function _getCartShoppingContext() {
 async function getEquinoxCart() {
 
     const cartType = _getCartShoppingContext();
-
+    
     const equinoxRequestOptions = {
         method: 'GET',
         endpoint: `carts/${cartType}`
     }
-    if (!cartContents){
-        cartContents = _equinoxRequest(equinoxRequestOptions).then(result => {
-            cartContents = result;
-        });
+    if(requestStatus === 'pending'){
+        return await resolveCartPromise();
     }
+    if (requestStatus === 'idle'){
+        requestStatus = 'pending';
+        cartPromise = _equinoxRequest(equinoxRequestOptions);
+        return await resolveCartPromise();
+    }
+}
 
-    await cartContents
-
-    // if this is a promise, this will resolve it
-    // otherwise, it won't do anything
-    return cartContents;
+async function resolveCartPromise () {
+    const response = await cartPromise;
+    requestStatus = 'idle';
+    return response;
 }
 
 /**
@@ -262,7 +273,6 @@ async function getAddToCartQty(product) {
             const qualification = await QualificationService.getQualification(product.sku)
             qualifiedQuantity = qualification.isConsumable ? qualification.quantity : 0
         } catch (err) {
-            console.error(err)
             qualifiedQuantity = 0;
         }
     }
@@ -394,6 +404,7 @@ function _assembleChildSkus(requestData, options) {
             if(personalOffer != null && productWithVariant.length > 0 && productWithVariant[0].variantSelected){
                 selectedVariants = productWithVariant[0].variantSelected;
             }
+            if (personalOffer != null && selectedVariants && cs.skuId != selectedVariants[cs.productId] && (cs.type !== "BUNDLE" && cs.type !== "OPTIONAL")) return null
             const childSku =
             (personalOffer != null && selectedVariants && selectedVariants[cs.productId] && config.MySite_graphql_active)
                 ? {
@@ -414,6 +425,7 @@ function _assembleChildSkus(requestData, options) {
 
             return childSku;
         });
+        requestData.skus = requestData.skus.filter(n => n)
     }
 
     return requestData;
@@ -459,7 +471,6 @@ const runConfigCallback = async (runConfig) => {
         const publishEquinoxCartCount = (options) => {
             getEquinoxCart().then((response) => {
                 const cart = response.data;
-                cartContents = null;
                 events.publish(events.shop.CART_UPDATED, { cartInfo: { qty: cart.value.count }, ...options });
             });
         }

package/src/cart/productService.js

@@ -1,10 +1,10 @@
-import $ from '@nuskin/nuskinjquery';
 import {PriceType, Product} from '@nuskin/ns-product-lib';
-import {RunConfigService, util, events, BrowserDetection, UrlService} from '@nuskin/ns-util';
+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 { getProductBySku as getCsProductBySku, getProductData as getCsProductData } from './csProductHelper.js';
 import axios from 'axios';
 
 let ProductService = function() {
@@ -21,24 +21,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;
         },
 
         /**
@@ -47,35 +36,34 @@ let ProductService = function() {
          * @param {string} sku - ex. 01111155
          * @returns {Promise}
          */
-        getProductData: function(sku, country, language) {
-            if(!sku) return;
-            let optionsData = country ? {country} : {};
-            if(language)
-                optionsData.language = language;
-
-            let tokenizedSku = tokenizeSku(sku),
-                url,
-                options = verifyLocaleFields(optionsData);
-
-            url = UrlService.getSiteUrl() + "/content/products/" + tokenizedSku + "/" +
-                options.language + ".service." + options.country + ".json";
-
-            return new Promise((resolve, reject) => {
-                $.ajax({
-                    type: 'GET',
-                    url: url,
-                    success: function(response) {
-                        resolve(createDataFromSkuSearch(response, options));
-                    },
-                    error: function(response) {
-                        console.error("There was a problem retrieving product data:", response);
-                        reject(response);
+        getProductData: async function(sku, country, language) {
+            let retVal;
+
+            if (sku) {
+                const optionsData = {
+                    country: country ? country : undefined,
+                    language: language ? language : undefined,
+                    sku
+                };
+                const options = verifyLocaleFields(optionsData);
+                const {Cart: cartCfg} = await getConfiguration(['Cart']);
+
+                try {
+
+                    if (cartCfg.useContentStackProductData) {
+                        retVal = await getCsProductData(options);
+                    } else {
+                        const tokenizedSku = tokenizeSku(sku);
+                        const url = UrlService.getSiteUrl() + "/content/products/" + tokenizedSku + "/" +
+                            options.language + ".service." + options.country + ".json";
+                        const response = await axios.get(url);
+                        retVal = createDataFromSkuSearch(response, options);
                     }
-                });
-            });
-
-
-
+                } catch (err) {
+                    console.error("There was a problem retrieving product data", err);
+                }
+            }
+            return retVal;
         }
     };
 
@@ -84,6 +72,26 @@ 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 url = await getSkuSearchUrl(options);