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

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
     }
 }();