@nuskin/product-components 3.17.0 → 3.17.2

package/docs/CHANGELOG.md

@@ -1 +1 @@
-# [3.17.0](https://code.tls.nuskin.io/ns-am/ux/product-components/compare/v3.16.1...v3.17.0) (2024-06-07)
+## [3.17.2](https://code.tls.nuskin.io/ns-am/ux/product-components/compare/v3.17.1...v3.17.2) (2024-06-17)

package/gl-sbom-npm-yarn.cdx.json

@@ -1,10 +1,10 @@
 {
   "bomFormat": "CycloneDX",
   "specVersion": "1.4",
-  "serialNumber": "urn:uuid:0c911df0-c46a-4f6b-8cea-c8df6a114fa2",
+  "serialNumber": "urn:uuid:d791f546-6b5a-47e2-b278-d5d586e7caee",
   "version": 1,
   "metadata": {
-    "timestamp": "2024-06-07T05:27:05Z",
+    "timestamp": "2024-06-17T16:53:01Z",
     "tools": [
       {
         "vendor": "GitLab",

package/mixins/NsProductMixin.js

@@ -21,45 +21,20 @@ import {
   AdrService,
   FavoritesService,
   ProductStatus,
-  QualificationService as OldQualificationService,
   Product as ShopProduct,
   EquinoxCartService
 } from "@nuskin/ns-shop";
-import { default as NewQualificationService } from "@nuskin/exclusive-offer-sdk";
-import { retrieveTogglesBasedOnEnvironment } from "@nuskin/ns-feature-flags";
+import QualificationService from "@nuskin/exclusive-offer-sdk";
 import webLoyalty from "@nuskin/ns-loyalty-web";
 import { getProp, getFullUrl } from "@nuskin/ns-common-lib";
 import { PriceType } from "@nuskin/ns-product-lib";
 import { ProductDataService } from "@nuskin/ns-product";
 import { waitForConfig } from "../services/configHelper";
+import { fetchPromotionalPrices } from "../services/EQPromotionService";
 
 const PENDING_FAVORITE = "pendingFavorite";
 const KEY_BREADCRUMB_BACK = "breadcrumbBack";
-
-let flagsPromise = null;
-let featureFlags = false;
-const checkFlag = async flag => {
-  if (!featureFlags && !flagsPromise) {
-    flagsPromise = retrieveTogglesBasedOnEnvironment().then(
-      flagsFromServer => (featureFlags = flagsFromServer)
-    );
-  }
-
-  if (!featureFlags) {
-    await flagsPromise;
-  }
-
-  return featureFlags.has(flag);
-};
-
-const getQualificationService = async () => {
-  const equinoxMarket = (await getConfiguration(["Equinox_Markets"]))
-    .Equinox_Markets;
-  return equinoxMarket.active ||
-    (await checkFlag("cx15_use_new_exclusive_offer_api"))
-    ? NewQualificationService
-    : OldQualificationService;
-};
+const BUNDLE = "BUNDLE";
 
 /**
  * NsProductMixin
@@ -216,6 +191,8 @@ const NsProductMixin = {
        * Active poduct data
        */
       product: undefined,
+      promotionPrice: null,
+      promotionOriginalPrice: null,
       /**
        * Quantity of product selected
        */
@@ -550,7 +527,7 @@ const NsProductMixin = {
     /**
      * Sets product to new selection
      */
-    setActiveProduct() {
+    async setActiveProduct() {
       if (this.baseProduct && this.baseProduct.isBase()) {
         let activeProduct = this.variants.find(
           variantProduct => variantProduct.sku === this.activeSku
@@ -619,6 +596,30 @@ const NsProductMixin = {
         //console.error(err);
       }
 
+      let isBundle = false;
+      if (this.product.childSkus && this.product.childSkus.length) {
+        this.product.childSkus.forEach(product => {
+          if (product.type === BUNDLE) {
+            isBundle = true;
+          }
+        });
+      }
+      if (isBundle) {
+        const promotion = await fetchPromotionalPrices(this.product);
+        if (promotion) {
+          if (promotion.price) {
+            this.promotionPrice = promotion.price;
+            this.price = promotion.price;
+            this.product.setPrice(promotion.price);
+          }
+          if (promotion.originalPrice) {
+            this.promotionOriginalPrice = promotion.originalPrice;
+            this.originalPrice = promotion.originalPrice;
+          }
+        }
+        //this.$emit("quantity-select", this.selectedQuantity);
+      }
+
       this.setProductPricingAndAvailability();
       this.$emit("product-update", this.product);
     },
@@ -644,25 +645,32 @@ const NsProductMixin = {
       if (this.product) {
         // WARNING: There's a instanceof check on CartService.getAddToCartQty for the ns-shop Product, previously different
         const shopProduct = new ShopProduct(this.product);
-        // check if a user is qualified to purchase the product
-        CartService.getAddToCartQty(shopProduct)
-          .then(productQuantity => {
-            // WARNING: this.product is volatile here. re-check is using this.product.
-            this.maxQuantity = Math.min(
-              shopProduct.maxQuantity,
-              shopProduct.availableQuantity,
-              productQuantity
-            );
-          })
-          .catch(error => {
-            this.maxQuantity = 0;
-            console.error("Failed to retrieve add to cart quantity.", error);
-          })
-          .finally(() => {
-            this.setStatus();
-            this.checkedQualifications = true;
-            this.emitAvailability();
-          });
+
+        getConfiguration(["Equinox_Markets"]).then(({ Equinox_Markets }) => {
+          const { active } = Equinox_Markets;
+
+          const cartService = active ? EquinoxCartService : CartService;
+          // check if a user is qualified to purchase the product
+          cartService
+            .getAddToCartQty(shopProduct)
+            .then(productQuantity => {
+              // WARNING: this.product is volatile here. re-check is using this.product.
+              this.maxQuantity = Math.min(
+                shopProduct.maxQuantity,
+                shopProduct.availableQuantity,
+                productQuantity
+              );
+            })
+            .catch(error => {
+              this.maxQuantity = 0;
+              console.error("Failed to retrieve add to cart quantity.", error);
+            })
+            .finally(() => {
+              this.setStatus();
+              this.checkedQualifications = true;
+              this.emitAvailability();
+            });
+        });
       }
     },
 
@@ -727,9 +735,9 @@ const NsProductMixin = {
       this.exclusiveOfferMessage = "";
       if (this.isExclusive) {
         if (this.isLoggedIn) {
-          const productQualification = await (
-            await getQualificationService()
-          ).getQualification(this.activeSku);
+          const productQualification = await QualificationService.getQualification(
+            this.activeSku
+          );
 
           let cartQuantity = 0;
 
@@ -759,10 +767,10 @@ const NsProductMixin = {
               cartQuantity = (cartItem || {}).qty || 0;
             } else {
               const cartData =
-                (await (
-                  await getQualificationService()
-                ).convertCartDataToBaseSkus(CartService.getItemData(), true)) ||
-                {};
+                (await QualificationService.convertCartDataToBaseSkus(
+                  CartService.getItemData(),
+                  true
+                )) || {};
               const cartItem = cartData[this.baseSku] || {};
               cartQuantity = cartItem.qty || 0;
             }
@@ -840,7 +848,7 @@ const NsProductMixin = {
     /**
      * Sets sales event pricing if there is an active event for this sku, or normal pricing if not
      */
-    setProductPricing() {
+    async setProductPricing() {
       const equinoxMarketsConfig = getCachedConfiguration("Equinox_Markets");
       const isEquinoxEnabled =
         equinoxLocalStorage.isEquinoxEnabled() && equinoxMarketsConfig.active;
@@ -934,6 +942,24 @@ const NsProductMixin = {
         this.isSale = false;
         this.setStandardPricing();
       }
+
+      let isBundle = false;
+      if (this.product.childSkus && this.product.childSkus.length) {
+        this.product.childSkus.forEach(product => {
+          if (product.type === BUNDLE) {
+            isBundle = true;
+          }
+        });
+      }
+      if (isBundle && isEquinoxEnabled) {
+        if (this.promotionPrice) {
+          this.price = this.promotionPrice;
+          this.product.setPrice(this.promotionPrice);
+        }
+        if (this.promotionOriginalPrice) {
+          this.originalPrice = this.promotionOriginalPrice;
+        }
+      }
     },
 
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuskin/product-components",
-  "version": "3.17.0",
+  "version": "3.17.2",
   "description": "Nu Skin Product Components",
   "main": "index.js",
   "scripts": {

package/services/EQPromotionService.js

@@ -0,0 +1,138 @@
+import axios from "axios";
+import { UrlService } from "@nuskin/ns-util";
+import { getConfiguration } from "@nuskin/configuration-sdk";
+
+/**
+ * To get the promontional prices from equinox storefront
+ *
+ */
+
+export const fetchPromotionalPrices = async product => {
+  try {
+    const payload = buildPayload(product);
+    const options = {
+      method: "POST",
+      endpoint: `catalogs/products/${product.sku}/promotions`,
+      data: payload
+    };
+
+    const { data } = await _equinoxRequest(options);
+    return {
+      price: data.unitValue.priceAfterDiscount,
+      originalPrice: data.unitValue.originalPrice
+    };
+  } catch (err) {
+    console.log("Error while fetching promotional prices");
+    return {};
+  }
+};
+
+const buildPayload = product => {
+  const payload = {
+    productId: product.sku,
+    categoryId: ["all_products"],
+    quantity: 1,
+    skus: [],
+    isSubscriptionIncludedInPromotion: false,
+    isFromBrowse: true
+  };
+
+  try {
+    let personalOffer = sessionStorage.getItem("personalOffer");
+    if (personalOffer !== null) {
+      personalOffer = JSON.parse(personalOffer);
+    }
+    const matchedProduct = personalOffer.products.filter(
+      offerProduct => offerProduct.sku === product.sku
+    );
+    const selectedVariants =
+      matchedProduct &&
+      matchedProduct.length > 0 &&
+      matchedProduct[0].variantSelected
+        ? matchedProduct[0].variantSelected
+        : null;
+
+    const skus = [];
+    if (product && product.childSkus) {
+      product.childSkus.forEach(childSku => {
+        if (childSku.type === "MANDATORY") {
+          skus.push({
+            skuId:
+              selectedVariants !== null && selectedVariants[childSku.productId]
+                ? selectedVariants[childSku.productId]
+                : childSku.skuId,
+            productId: childSku.productId,
+            quantity: childSku.skuQuantity,
+            type: "bundle"
+          });
+        }
+      });
+    }
+
+    payload.skus = skus;
+    payload.quantity =
+      matchedProduct && matchedProduct.qty ? matchedProduct.qty : 1;
+  } catch (err) {
+    console.log("Error while building payload");
+  }
+
+  return payload;
+};
+
+const _equinoxRequest = async options => {
+  const {
+    marketLocale,
+    storeId,
+    storefrontURL,
+    headers
+  } = await getEquinoxRequestConfiguration();
+  const equinoxParams = {
+    locale: marketLocale,
+    storeId: storeId
+  };
+
+  let axiosRequest = {
+    method: options.method,
+    url: `${storefrontURL}/orchestrationservices/storefront/${options.endpoint}`,
+    headers: headers,
+    withCredentials: options.method !== "DELETE",
+    params: equinoxParams
+  };
+
+  if (options.data) {
+    axiosRequest.data = options.data;
+  }
+
+  return axios(axiosRequest);
+};
+
+const getEquinoxRequestConfiguration = async () => {
+  const marketLocale = UrlService.getLocale();
+  const config = (await getConfiguration(["Equinox_Markets"])).Equinox_Markets;
+  const storefrontURL = config.API_Base_URLs;
+
+  const sessionData = sessionStorage.getItem("oktaTokens");
+  const parsedSessionData = JSON.parse(sessionData);
+  const sessionOktaToken =
+    parsedSessionData && parsedSessionData.accessToken
+      ? parsedSessionData.accessToken
+      : "";
+  const localStorageOktaToken = localStorage.getItem("equinox-okta-token");
+
+  let oktaToken = localStorageOktaToken
+    ? localStorageOktaToken
+    : sessionOktaToken;
+
+  const headers = {
+    Accept: "*",
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${oktaToken}`
+  };
+
+  return {
+    marketLocale,
+    storeId: config.store_id,
+    storefrontURL,
+    headers
+  };
+};

package/stories/NsProductMixinPreview.vue

@@ -200,40 +200,11 @@
 </template>
 
 <script>
-import {
-  QualificationService as OldQualificationService,
-  CartService
-} from "@nuskin/ns-shop";
-import { getConfiguration } from "@nuskin/configuration-sdk";
-import { default as NewQualificationService } from "@nuskin/exclusive-offer-sdk";
+import { CartService } from "@nuskin/ns-shop";
+import QualificationService from "@nuskin/exclusive-offer-sdk";
 import NsProductMixin from "../mixins/NsProductMixin";
 import "@nuskin/ns-core-styles/src/dist/main.css";
 
-let equinoxMarket = {
-  promise: getConfiguration(["Equinox_Markets"]).then(config => {
-    equinoxMarket = {
-      value:
-        config && config.Equinox_Markets
-          ? !!config.Equinox_Markets.active
-          : false,
-      promise: null,
-      loaded: true
-    };
-  }),
-  loaded: false,
-  value: undefined
-};
-
-const getQualificationService = async () => {
-  if (!equinoxMarket.loaded) {
-    await equinoxMarket.promise;
-  }
-  if (equinoxMarket.value) {
-    return NewQualificationService;
-  }
-  return OldQualificationService;
-};
-
 export default {
   name: "NsProductMixinPreview",
   filters: {
@@ -407,9 +378,9 @@ export default {
   async mounted() {
     if (this.isExclusive) {
       if (this.isLoggedIn) {
-        this.productQualification = await (
-          await getQualificationService()
-        ).getQualification(this.activeSku);
+        this.productQualification = await QualificationService.getQualification(
+          this.activeSku
+        );
 
         this.cartItem = await CartService.getFirstItemBySku(this.activeSku, {
           cartOrderItems: true