@nuskin/ns-shop 7.1.0-cx24-6991.1 → 7.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuskin/ns-shop",
-  "version": "7.1.0-cx24-6991.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,
@@ -223,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;
 }
 
 /**
@@ -269,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;
         }
     }
@@ -401,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)
                 ? {
@@ -421,6 +425,7 @@ function _assembleChildSkus(requestData, options) {
 
             return childSku;
         });
+        requestData.skus = requestData.skus.filter(n => n)
     }
 
     return requestData;
@@ -466,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);

package/src/order/orderAdapter.js

@@ -5,6 +5,7 @@ import {RunConfigService, events, util, PersonalOfferStorageService, BrowserDete
 import {getCachedConfigField} from '@nuskin/configuration-sdk';
 import {UserService} from "@nuskin/ns-account";
 import PaymentAdapter from '../payment/PaymentAdapter';
+import pickupUtil from '../shipping/pickupUtil';
 
 let splitLineItems = [];
 
@@ -600,6 +601,7 @@ const syncProductItems = async (order, sapProducts, adr, includeSapItems) => {
                 newItem.priceType = ShopContextService.getPriceType(isAdrItem);
                 newItem.pv = sapItem.PSV;
                 newItem.backOrderDate = sapItem.BackorderAvailableDate;
+                newItem.eventName = sapItem.LineItem.Event;
 
                 if (sapItem.LineItem.Custom) {
                     let code = null, name = null, label = null;
@@ -634,7 +636,7 @@ const syncProductItems = async (order, sapProducts, adr, includeSapItems) => {
                     newItem.isBusinessPortfolio = matchedItem.isBusinessPortfolio;
                     newItem.redeem = matchedItem.redeem;
                     newItem.qtyRedeemWithPoints = matchedItem.qtyRedeemWithPoints;
-                    newItem.eventName = matchedItem.eventName;
+                    newItem.eventName = !newItem.eventName ? matchedItem.eventName : newItem.eventName;
                 }
                 if (existingItem) {
                     newItem.thumbnail = existingItem.thumbnail;
@@ -864,13 +866,14 @@ let setSelectedShipMethod = function(order, matchMethod = {}) {
 
 /**
  * Parses pickup points from SAP response, in case shipping method is set to pickup points!
- * @param {Object[]} custom The Custom array on the salesorderrequest
+ * @param {Object[]} oldPup The Custom array on the salesorderrequest
+ * @param {Object[]} newPup The Custom array on the salesorderrequest
  * @param {Object} order
  */
-function setPickupPoints(custom, order) {
-    const pupLocations = custom || [];
+function setPickupPoints(oldPup, newPup, order) {
+    const pupLocations = oldPup || [];
     if (order.selectedShippingMethod && PickupUtil.supports(order.selectedShippingMethod.Code)) {
-        order.pickupPoints = PickupUtil.parse(pupLocations);
+        order.pickupPoints = newPup ? newPup : PickupUtil.parse(pupLocations);
         if (order.selectedPickupPoint) {
             order.selectedPickupPoint = order.pickupPoints.find(pickupPoint => order.selectedPickupPoint.id === pickupPoint.id);
         }
@@ -1089,13 +1092,19 @@ const toOrder = async (salesOrderDetail, adr, createResponse) => {
     }
 
     if (salesOrderDetail.ShippingAvailableMethods && salesOrderDetail.ShippingAvailableMethods.length > 0) {
-        order.shippingAvailableMethods = sortShippingAvailableMethods(salesOrderDetail.ShippingAvailableMethods);
+        const useShipMethodsApi = getCachedConfigField('useShipMethodsApi');
+        const shipMethods = useShipMethodsApi ? await pickupUtil.getShipMethods() : salesOrderDetail.ShippingAvailableMethods;
+        order.shippingAvailableMethods = sortShippingAvailableMethods(shipMethods);
         setShippingAvailableMethodsPickupInfo(order.shippingAvailableMethods);
         setSelectedShipMethod(order, salesOrderDetail.Shipping.ShippingMethod);
         // When an order or ADR is created.  The response from the create call is missing the list of pickup locations
         // The list isn't needed in this case since the user has already created the order so we don't need to update the pickup points
         if (!createResponse) {
-            setPickupPoints(salesOrderDetail.Custom, order);
+            let oldPup = null;
+            if (!useShipMethodsApi) oldPup = salesOrderDetail.Custom;
+            let newPup = null;
+            if (useShipMethodsApi) newPup = await pickupUtil.getPickupPoints();
+            setPickupPoints(oldPup, newPup, order);
         }
     }
     shippingHack(order, salesOrderDetail.OrderTotals.Shipping, salesOrderDetail.Currency);
@@ -1107,6 +1116,7 @@ const toOrder = async (salesOrderDetail, adr, createResponse) => {
     await syncProductItems(order, salesOrderDetail.LineItemDetails, order.adr ? adr : null);
     syncOrderTotals(salesOrderDetail.OrderTotals, order.orderTotals);
     syncPayment(salesOrderDetail.Payment, order.selectedPayment);
+    OrderManager.saveOrders();
     return order;
 };
 

package/src/payment/externalPaymentService.js

@@ -142,15 +142,21 @@ const getAdrOverrideId = () => {
 const _doNewExternalPaymentProcess = (order) => {
     // We only redirect if there is a redirect Url.
     if (order.redirectUrl) {
+        const redirectUrl = new URL(order.redirectUrl);
         // The landing page should be the checkout page.
         const protocol = window.location.href.split('://')[0];
         const domain = UrlService.extractDomain();
         const path = encodeURIComponent(CartService.getCheckoutPage({route: 'orderSummary'}));
 
+        // If we are on mynuskin.com we want to keep external payment on mynuskin.com.  For developing localhost we don't want to stay on localhost
+        if (!domain.includes('localhost')) {
+            redirectUrl.hostname = window.location.hostname;
+        }
+
         // Append the landing page URL
         // Example of order.redirectUrl: "redirectUrl":
         //  "https://test.nuskin.com/external-payment/api/v1/redirect?orderId=NS002761827&verify=null&ofsOrderId=0149707745"
-        window.location = `${order.redirectUrl}&landingUrl=${protocol}://${domain}${path}`;
+        window.location = `${redirectUrl.toString()}&landingUrl=${protocol}://${domain}${path}`;
     }
 };
 

package/src/salesEventService.js

@@ -139,69 +139,32 @@ function getActiveTicketEvents() {
     return events;
 }
 
-async function getEventStatus(eventsToCheck = [], externalId = 'none') {
+async function getEventStatus(eventsToCheck = []) {
     const eventStatus = {};
     const promises = [];
 
     eventsToCheck.forEach((toCheck) => {
-        promises.push(_getTempTicket(toCheck, externalId));
+        promises.push(_checkForMissingTicket(toCheck));
     });
 
-    const responses = await Promise.allSettled(promises);
+    await Promise.allSettled(promises);
 
-    responses.forEach((response) => {
+    eventsToCheck.forEach((eventName) => {
         let activeStatus = false;
-        if (response.status === 'fulfilled' && response.value) {
-            const status = _decodeStatus(response.value.status);
+        const ticketInfo = eventTicketInfoMap[eventName];
+        if (ticketInfo && ticketInfo.ticket) {
+            const status = _decodeStatus(ticketInfo.ticket.status);
             if ((status.eventStatus === PRE_EVENT && status.preWaitTime <= 30000) ||
                 status.eventStatus === IN_EVENT) {
                 activeStatus = true;
             }
-            eventStatus[response.value.eventName] = activeStatus;
         }
+        eventStatus[eventName] = activeStatus;
     });
 
     return eventStatus;
 }
 
-/**
- * Either requests a new ticket or an updated event ticket from the AWS service
- *
- * @param eventTicketInfo - contains informatino about the ticket.
- *
- * @returns {Promise<*>} a new or updated ticket for the specified event
- * @private
- */
-async function _getTempTicket(eventName, externalId) {
-    let ticket;
-
-    try {
-        let method = 'POST',
-            seParams = _getSeParams(eventName, false),
-            response = await axios({
-                method: method,
-                url: `${_getAwsUrl(eventName, null)}?orderEventCheck=${externalId}${seParams}`,
-                headers: _getHeaders(),
-                timeout: 7000
-            });
-
-        ticket = response.data.salesEventResponse;
-    } catch (err) {
-        if (err.response && err.response.data.status === 404) {
-            console.error(`getTempTicket - unable to get a temporary ticket for ${eventName}`);
-            throw err;
-        } else {
-            console.error(`getTempTicket error or timeout - waiting to try again for ${eventName}`);
-            // Timed out or some other error
-            // Wait and then call again.
-            await _wait(3000);
-            ticket = await _getTempTicket(eventName);
-        }
-    }
-
-    return ticket;
-}
-
 function logAnalyticInfo(tag, eventName, data = {}) {
     const user = UserService.getUser();
     const eventTicketInfo = eventTicketInfoMap[eventName];
@@ -297,7 +260,7 @@ function _checkStatus(eventTicketInfo, useServerWaitTime) {
                     [ticket.eventName, eventTicketInfo.paused, {fromServer: useServerWaitTime, waitTime: actualWait}]
                 );
 
-                eventInfo.timerId = setTimeout(() => _timerCallback(ticket.eventName), timerWait);
+                eventInfo.timerId = setTimeout(_timerCallback(ticket.eventName), timerWait);
                 if (useServerWaitTime && timerWait < 30000) {
                     // if the wait time is base off of what the server passed back then
                     //  don't call the server to update the ticket at the end of this timer
@@ -317,7 +280,7 @@ function _checkStatus(eventTicketInfo, useServerWaitTime) {
                         [ticket.eventName, eventTicketInfo.paused, {fromServer: useServerWaitTime, waitTime: actualWait}]
                     );
                     logAnalyticInfo('in-event', ticket.eventName);
-                    eventInfo.timerId = setTimeout(() => _timerCallback(ticket.eventName), timerWait);
+                    eventInfo.timerId = setTimeout(_timerCallback(ticket.eventName), timerWait);
                 } else {
                     _changeStatus(eventTicketInfo, POST_EVENT);
                     _checkStatus(eventTicketInfo, false); // to send post event and clear ticket.
@@ -563,7 +526,7 @@ async function _getRemoteTicket(eventTicketInfo) {
             response = await axios({
                 method: method,
                 url: `${_getAwsUrl(eventName, ticketId)}${seParams}`,
-                headers: _getHeaders(),
+                headers: _getHeaders(method === 'GET' ? true : false),
                 timeout: 7000
             });
 
@@ -678,14 +641,26 @@ function _getAwsUrl(eventName, ticketId) {
  * @returns {{Accept: string, "Content-Type": string, client_id: *}}
  * @private
  */
-function _getHeaders() {
+function _getHeaders(noCache = false) {
     return {
         'Accept': 'application/json',
         'Content-Type': 'application/json',
-        'client_id': RunConfigService.getRunConfig().clientId
+        'client_id': RunConfigService.getRunConfig().clientId,
+        ...(noCache && {'Cache-Control': 'no-cache'}),
+        ...(noCache && {'Pragma': 'no-cache'}),
+        ...(noCache && {'Expires': '0'})
     };
 }
 
+async function _getActiveEvents() {
+    let response = await axios({
+        method: 'GET',
+        url: `${_getAwsUrl()}?activeWithin=${ACTIVE_EVENT_WITHIN}`,
+        headers: _getHeaders(true)
+    });
+    return response.data.salesEventResponse
+}
+
 //=========================================================================================================//
 //
 //  Misc functions
@@ -762,7 +737,7 @@ async function _loadMarketEventConfig(force, country=undefined) {
             const response = await axios({
                 method: 'GET',
                 url: `${_getAwsUrl()}`,
-                headers: _getHeaders()
+                headers: _getHeaders(true)
             });
             const salesEvents = response.data.salesEventResponse || [];
             mktEventConfigMap = {};
@@ -804,6 +779,12 @@ function getStorageItem(key) {
     return item;
 }
 
+async function _checkForMissingTicket(eventName) {
+    if (mktEventConfigMap[eventName] && !eventTicketInfoMap[eventName]) {
+        await _initEventTicketInfo(eventName);
+    }
+}
+
 /**
  * This initializes an interval timer which checks to see if the browser (computer)
  *  went to sleep.  It's intention is to update the wait timer if it has.
@@ -815,17 +796,18 @@ async function _initializePolling() {
             intervalCnt = 1;
 
         intervalId = setInterval(async () => {
-            let now = Date.now();
+            const now = Date.now();
+            const slept = now > (lastTime + TIMEOUT + 3000)
 
             // if polling market config, only reload it every 30 seconds
-            if (pollMarketConfig && intervalCnt % 3 === 0) {
+            if (slept || pollMarketConfig && intervalCnt % 6 === 0) {
                 await _loadMarketEventConfig(true);
                 _marketStatusCheck();
             }
             intervalCnt++;
 
             // if been to sleep for more then 3 seconds then check all ticket statuses.
-            if (now > (lastTime + TIMEOUT + 3000)) {
+            if (slept) {
                 // Went to sleep for 3 seconds or more
                 Object.values(eventTicketInfoMap).forEach(eventTicketInfo => {
                     // A new timer needs to be set, clear current one if exists
@@ -838,6 +820,17 @@ async function _initializePolling() {
                 _checkStatus(eventTicketInfo, false);
             });
 
+            if (window.location.pathname === '/static/checkout/checkout.html' ||
+                window.location.pathname === '/static/cart/cart.html'
+            ) {
+                // check for missing tickets. Only perform on checkout screen
+                const activeEvents = await _getActiveEvents();
+
+                for (const eventInfo of activeEvents) {
+                    await _checkForMissingTicket(eventInfo.eventName);
+                }
+            }
+
             lastTime = now;
         }, TIMEOUT);
     }
@@ -963,7 +956,7 @@ function _removeWaitCheck(value) {
  */
 async function _loadAwsActiveEvents(country) {
     let activeEventsName = `${ACTIVE_EVENTS}-${country? country: RunConfigService.getRunConfig().country}`,
-        storageObj = getStorageItem(activeEventsName),
+        storageObj = null,
         ttl = storageObj ? storageObj.ttl - Date.now() : ACTIVE_EVENT_TTL,
         eventInfos = {},
         ok = true;
@@ -989,12 +982,7 @@ async function _loadAwsActiveEvents(country) {
         storageObj = {events: []};
         storage.setItem(activeEventsName, storageObj, {ttl: 250}); // to prevent multiple calls.
         try {
-            let response = await axios({
-                method: 'GET',
-                url: `${_getAwsUrl()}?activeWithin=${ACTIVE_EVENT_WITHIN}`,
-                headers: _getHeaders()
-            });
-            addEvents(response.data.salesEventResponse);
+            addEvents(await _getActiveEvents());
         } catch (e) {
             // an error occurred with the call, clear active events
             //  so it won't wait 30 minutes to try again
@@ -1027,6 +1015,14 @@ async function initActiveEvents(country = undefined) {
     if (Object.values(mktEventConfigMap).find(mktEvent => {return mktEvent.status !== 'off'})) {
         let awsEvents = await _loadAwsActiveEvents(country);
 
+        // if a ticket exists in localStorage for an event the is not active, remove it.
+        Object.keys(eventTicketInfoMap).forEach((key) => {
+            if (!awsEvents[key]) {
+                storage.removeItem(_getTicketName(key));
+                delete eventTicketInfoMap[key];
+            }
+        })
+
         eventTicketInfoMap = Object.assign({}, awsEvents, eventTicketInfoMap);
         Object.keys(eventTicketInfoMap).forEach(eventName => {
             if (mktEventConfigMap[eventName] && eventTicketInfoMap[eventName].eventName) {
@@ -1036,12 +1032,10 @@ async function initActiveEvents(country = undefined) {
     }
 
     return Promise.all(promises).then(async () => {
+
         events.setValue(events.salesevent.INITIAL_ACTIVE_EVENTS, [Object.keys(activeEventMap)]);
 
-        // If there are event tickets then initialize polling
-        if (Object.keys(eventTicketInfoMap).length > 0 && !country) {
-            await _initializePolling();
-        }
+        await _initializePolling();
         _removeWaitCheck(INITIALIZING);
     });
 }
@@ -1097,13 +1091,7 @@ async function _init(force = true) {
  *  If there are, make sure polling is happening, otherwise, stop polling.
  */
 events.subscribe(events.salesevent.ACTIVE_EVENTS, (/*activeEvents*/) => {
-    if (eventTicketInfoMap) {
-        if (Object.keys(eventTicketInfoMap).length > 0) {
-            _initializePolling().then(() => console.log('Polling initialized'));
-        } else {
-            _clearPollingInterval();
-        }
-    }
+    _initializePolling().then(() => console.log('Polling initialized'));
 });
 
 // persistentCartService needs to wait until the following configMaps are loaded

package/src/shipping/pickupUtil.js

@@ -1,3 +1,9 @@
+import {getCachedConfiguration} from '@nuskin/configuration-sdk';
+import {Order} from '@nuskin/order-model';
+import {RunConfigService} from '@nuskin/ns-util';
+import {OrderManager, CartService, OrderType, OrderAdapter} from '../shop';
+import axios from 'axios';
+
 let PickupUtil = function() {
     'use strict';
     const SERVICE_GROUP = 'SERVICE_GROUP',
@@ -15,6 +21,10 @@ let PickupUtil = function() {
         UNIT = 'UNIT',
         CARRIER_CODE = 'CARRIER_CODE';
 
+    let promise = Promise.resolve();
+    let shipMethods = [];
+    let pickupPoints = [];
+
     /**
      * Pickup Point shipping methods.
      * Values are shipping method codes.
@@ -69,7 +79,7 @@ let PickupUtil = function() {
                 distance: distances && distances[i] ? distances[i].Value : undefined,
                 locker: lockers && lockers[i] ? lockers[i].Value : undefined,
                 unit: units && units[i] ? units[i].Value : undefined,
-                openingHours: openHours && openHours[i] ? openHours[i].Value.split(/\s*;\s*/) : undefined,
+                openingHours: openHours && openHours[i] ? openHours[i].Value : undefined,
                 latitude: latitudes && latitudes[i] ? parseFloat(latitudes[i].Value) : undefined,
                 longitude: longitudes && longitudes[i] ? parseFloat(longitudes[i].Value) : undefined,
                 carrierCode: carrierCodes && carrierCodes[i] ? carrierCodes[i].Value : undefined
@@ -130,12 +140,96 @@ 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':
+                return 'https://ship-methods.api.dev.nuskin.com/v1';
+            case 'test':
+                return 'https://ship-methods.api.test.nuskin.com/v1';
+            case 'stage':
+                return 'https://ship-methods.api.dev.nuskin.com/v1';
+            case 'prod':
+                return 'https://ship-methods.api.nuskin.com/v1';
+            default:
+                return 'https://ship-methods.api.test.nuskin.com/v1';
+        }
+    }
+
+    function loadShipMethods() {
+        const order = Order.fromSalesOrderRequest(OrderAdapter.populateSalesOrder('SIMULATE'));
+
+        const postalCode = order.shippingPostalCode;
+        const {metapackMarket, metapackZipExclusions} = getCachedConfiguration('Checkout');
+
+        if (metapackMarket) {
+            let includePickupPoints = true;
+            for (const zipRegEx of metapackZipExclusions || []) {
+                const regEx = new RegExp(zipRegEx);
+                includePickupPoints = includePickupPoints && !postalCode.match(regEx);
+            }
+
+            const runConfig = RunConfigService.getRunConfig();
+            promise = axios.post(
+                getUrl(),
+                {
+                    order,
+                    pudo: includePickupPoints,
+                    orderValue: getOrderValue(),
+                    dangerousGoods: CartService.hasDangerousGoods(),
+                    language: runConfig.language,
+                    country: runConfig.country
+                },
+                {
+                    headers: {
+                        'Content-Type': 'application/json; charset=UTF-8'
+                    }
+                }
+            ).then((results) => {
+                shipMethods = results.data.shipMethods;
+                pickupPoints = results.data.pickupPoints;
+            }).catch((err) => {
+                console.log(err);
+                shipMethods = [];
+                pickupPoints = [];
+            });
+        }
+    }
+
+    async function getShipMethods() {
+        await promise;
+
+        return shipMethods;
+    }
+
+    async function getPickupPoints() {
+        await promise;
+
+        return pickupPoints;
+    }
+
     return {
         allMethods: shippingMethods,
         supports: isPickupPointShippingMethod,
         parse: parsePickupPoints,
         bounds: getBounds,
-        markers: generateMarkers
+        markers: generateMarkers,
+        loadShipMethods,
+        getShipMethods,
+        getPickupPoints
     }
 }();