@nuskin/ns-shop 7.0.11-CodeFix.1 → 7.0.11-pur-813.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuskin/ns-shop",
-  "version": "7.0.11-CodeFix.1",
+  "version": "7.0.11-pur-813.2",
   "description": "The description that will amaze and astound your audience when they read it",
   "main": "src/shop.js",
   "scripts": {
@@ -26,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.6",
+    "@nuskin/ns-product-lib": "2.19.1-pur-816.1",
     "@nuskin/nuskinjquery": "2.3.1",
+    "@nuskin/order-model": "3.1.3",
+    "@nuskin/product-lib": "2.2.1",
     "axios": "1.6.5",
     "decimal.js": "10.4.3",
     "jp-conversion": "0.0.7",

package/src/cart/csProductHelper.js

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

package/src/cart/equinoxCartService.js

@@ -404,7 +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" && cs.type !== "SKUKIT")) return null
+            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)
                 ? {

package/src/cart/productService.js

@@ -1,10 +1,11 @@
 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 } 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,6 +74,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 = [];
 
@@ -865,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);
         }
@@ -1090,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);

package/src/shipping/pickupUtil.js

@@ -1,3 +1,11 @@
+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 axios from 'axios';
+import { OrderManager } from '../shop';
+
 let PickupUtil = function() {
     'use strict';
     const SERVICE_GROUP = 'SERVICE_GROUP',
@@ -15,6 +23,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.
@@ -130,12 +142,75 @@ let PickupUtil = function() {
         return markers;
     }
 
+    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.dev.nuskin.com/v1';
+            default:
+                return 'https://ship-methods.api.dev.nuskin.com/v1';
+        }
+    }
+
+    function loadShipMethods() {
+        const order = Order.fromSalesOrderRequest(OrderAdapter.populateSalesOrder('SIMULATE'));
+
+        const postalCode = order.shippingPostalCode;
+        const {metapackMarket, metapackZipExclusions} = getCachedConfiguration('Checkout');
+
+        if (metapackMarket) {
+            const order = OrderManager.getOrder();
+            let includePickupPoints = true;
+            for (const zipRegEx of metapackZipExclusions || []) {
+                const regEx = new RegExp(zipRegEx);
+                includePickupPoints = includePickupPoints && !postalCode.match(regEx);
+            }
+
+            promise = axios.post(
+                getUrl(),
+                {
+                    order,
+                    pudo: includePickupPoints,
+                    orderValue: order && order.orderTotals && order.orderTotals.grandTotal || 0.0
+                },
+                {
+                    headers: {
+                        'Content-Type': 'application/json; charset=UTF-8'
+                    }
+                }
+            ).then((results) => {
+                shipMethods = results.data.shipMethods;
+                pickupPoints = results.data.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
     }
 }();