@nuskin/ns-shop 7.3.0-mdigi-897.8 → 7.3.0-pa-1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuskin/ns-shop",
-  "version": "7.3.0-mdigi-897.8",
+  "version": "7.3.0-pa-1.2",
   "description": "The description that will amaze and astound your audience when they read it",
   "main": "src/shop.js",
   "scripts": {
@@ -44,7 +44,7 @@
     "@nuskin/ns-account": "5.9.2",
     "@nuskin/ns-jsanalyzer": "1.0.1",
     "@nuskin/ns-product": "3.50.8",
-    "@nuskin/ns-util": "4.7.0",
+    "@nuskin/ns-util": "4.6.1",
     "axios-mock-adapter": "1.22.0",
     "babel-cli": "6.26.0",
     "babel-core": "6.26.3",

package/src/account/agreementService.js

@@ -0,0 +1,31 @@
+import {UrlService} from "@nuskin/ns-util";
+import axios from 'axios'
+
+const hasAgreedToTerms = async (sapId) => {
+    let retVal = false;
+
+    try {
+        const result = await axios.get(`${UrlService.getAwsUrl()}/account-renroll/agreement-terms/${sapId}`)
+        retVal = result.agreedTerms;
+    } catch (e) {
+        console.error('agreement-terms check failed', e)
+    }
+
+    return retVal
+}
+
+const setAgreedToTerms = async (sapId) => {
+    try {
+        await axios.post(`${UrlService.getAwsUrl()}/account-renroll/agreement-terms`, {
+            agreedTerms: true,
+            sapId
+        })
+    } catch (e) {
+        console.error('Failed setting agreement to terms', e);
+    }
+}
+
+export default {
+    hasAgreedToTerms,
+    setAgreedToTerms
+};

package/src/product/SolrQueryService.js

@@ -4,8 +4,7 @@ import {ProductResultsEnum} from "./productResultsEnum.js";
 import OrderType from "./orderType.js";
 import {SolrProductAdaptor} from "./solrProductAdaptor.js";
 import {SolrQueryUrlService} from "./solrQueryUrlService.js";
-import {getCachedConfigField, getCachedConfiguration} from '@nuskin/configuration-sdk';
-import {productSearchAPI} from "./productSearchAPIQueryService.js"
+import {getCachedConfigField} from '@nuskin/configuration-sdk';
 
 /**
  *
@@ -437,136 +436,119 @@ let SolrQueryService = function() {
             productResultType, searchTerm, productSearchFields, language, market, searchByOrderType ? rows*5 : rows, start
         );
 
-        const {MySite_search_API_Base_URLs} = getCachedConfiguration('Equinox_Markets');
-
-        if(MySite_search_API_Base_URLs !== '') {
-
-            productSearchAPI(deferred, {
-                searchTerm,
-                rows,
-                language,
-                market,
-                groupByVariant: true,
-                page: 1
-            })
+        // Search for language nodes for the given market that match the search term.
+        let queryResponsePromise = $.ajax({
+            url: solrUrl,
+            type: "GET",
+            contentType: 'application/json; charset=utf-8',
+            headers: {
+                "client_id": getCachedConfigField('solrClientId'),
+                "client_secret": getCachedConfigField('solrClientSecret')
+            },
+            timeout: SolrTimeout,
+            success: function () {
+                //console.log("Search success!");
+            },
+            error: function (xmlHttpRequest, textStatus) {
+                deferred.reject(textStatus);
+                //console.log('Search failed!');
+            }
+        });
 
-        } else {
-            // Search for language nodes for the given market that match the search term.
-            let queryResponsePromise = $.ajax({
-                url: solrUrl,
-                type: "GET",
-                contentType: 'application/json; charset=utf-8',
-                headers: {
-                    "client_id": getCachedConfigField('solrClientId'),
-                    "client_secret": getCachedConfigField('solrClientSecret')
-                },
-                timeout: SolrTimeout,
-                success: function () {
-                    //console.log("Search success!");
-                },
-                error: function (xmlHttpRequest, textStatus) {
-                    deferred.reject(textStatus);
-                    //console.log('Search failed!');
-                }
-            });
+        queryResponsePromise.then(function(responseData) {
+            let retValue;
+            let docs, totalNumFound/*, responseHeader*/;
 
-            queryResponsePromise.then(function(responseData) {
-                let retValue;
-                let docs, totalNumFound/*, responseHeader*/;
+            if (typeof(responseData) === "string") {
+                docs = $.parseJSON(responseData).response.docs;
+                totalNumFound = $.parseJSON(responseData).response.numFound;
+                // responseHeader = $.parseJSON(responseData).responseHeader;
+            } else {
+                docs = responseData.response.docs;
+                totalNumFound = responseData.response.numFound;
+                // responseHeader = responseData.responseHeader;
+            }
 
-                if (typeof(responseData) === "string") {
-                    docs = $.parseJSON(responseData).response.docs;
-                    totalNumFound = $.parseJSON(responseData).response.numFound;
-                    // responseHeader = $.parseJSON(responseData).responseHeader;
-                } else {
-                    docs = responseData.response.docs;
-                    totalNumFound = responseData.response.numFound;
-                    // responseHeader = responseData.responseHeader;
-                }
+            if (searchByOrderType) {
+                solrUrl = SolrQueryUrlService.getProductsByRoots(docs, language, market, rows, 0, orderTypes);
+                let _orderTypes = orderTypes;
+                if (solrUrl.url) {
+                    let productDocuments = [];
+                    queryResponsePromise = $.ajax({
+                        url: solrUrl.url,
+                        type: "POST",
+                        contentType: 'application/json; charset=utf-8',
+                        headers: {
+                            "client_id": getCachedConfigField('solrClientId'),
+                            "client_secret":getCachedConfigField('solrClientSecret')
+                        },
+                        timeout: SolrTimeout,
+                        data: JSON.stringify(solrUrl.postData),
+                        success: function (responseData) {
+                            if (typeof(responseData) === "string") {
+                                docs = $.parseJSON(responseData).response.docs;
+                                totalNumFound = $.parseJSON(responseData).response.numFound;
+                            }
+                            else {
+                                docs = responseData.response.docs;
+                                totalNumFound = responseData.response.numFound;
+                            }
 
-                if (searchByOrderType) {
-                    solrUrl = SolrQueryUrlService.getProductsByRoots(docs, language, market, rows, 0, orderTypes);
-                    let _orderTypes = orderTypes;
-                    if (solrUrl.url) {
-                        let productDocuments = [];
-                        queryResponsePromise = $.ajax({
-                            url: solrUrl.url,
-                            type: "POST",
-                            contentType: 'application/json; charset=utf-8',
-                            headers: {
-                                "client_id": getCachedConfigField('solrClientId'),
-                                "client_secret":getCachedConfigField('solrClientSecret')
-                            },
-                            timeout: SolrTimeout,
-                            data: JSON.stringify(solrUrl.postData),
-                            success: function (responseData) {
-                                if (typeof(responseData) === "string") {
-                                    docs = $.parseJSON(responseData).response.docs;
-                                    totalNumFound = $.parseJSON(responseData).response.numFound;
-                                }
-                                else {
-                                    docs = responseData.response.docs;
-                                    totalNumFound = responseData.response.numFound;
-                                }
+                            // Wrap the products in an adaptor for ease of use.
+                            for (let i = 0; i < docs.length; i++) {
+                                //ONLY RETURN PRODUCTS THAT HAVE A MARKET
+                                if (docs[i]._childDocuments_) {
+                                    for (let m = 0; m < docs[i]._childDocuments_.length; m++) {
+                                        if ((docs[i]._childDocuments_[m].path_exact === "product/" + docs[i].sku + '/' + market.toUpperCase()) &&
+                                            !docs[i]._childDocuments_[m].excludeFromSearch) {
 
-                                // Wrap the products in an adaptor for ease of use.
-                                for (let i = 0; i < docs.length; i++) {
-                                    //ONLY RETURN PRODUCTS THAT HAVE A MARKET
-                                    if (docs[i]._childDocuments_) {
-                                        for (let m = 0; m < docs[i]._childDocuments_.length; m++) {
-                                            if ((docs[i]._childDocuments_[m].path_exact === "product/" + docs[i].sku + '/' + market.toUpperCase()) &&
-                                                !docs[i]._childDocuments_[m].excludeFromSearch) {
-
-                                                if (!skuExistsInProductArray(productDocuments, docs[i].sku.toString())) {
-                                                    let prodAdaptor = new SolrProductAdaptor(docs[i]);
-                                                    let marketChild = prodAdaptor.getMarketChild(market);
-                                                    let languageChild = prodAdaptor.getLanguageChild(language);
-                                                    if (existsInArray(marketChild.getOrderType(), _orderTypes)) {
-                                                        productDocuments.push({
-                                                            sku: docs[i].sku,
-                                                            fullImage: marketChild.getFullImageUrl(),
-                                                            name: languageChild.getTitle(),
-                                                            _root_: "product/" + docs[i].sku,
-                                                            isExclusive: languageChild.getIsExclusive()
-                                                        });
-                                                    }
+                                            if (!skuExistsInProductArray(productDocuments, docs[i].sku.toString())) {
+                                                let prodAdaptor = new SolrProductAdaptor(docs[i]);
+                                                let marketChild = prodAdaptor.getMarketChild(market);
+                                                let languageChild = prodAdaptor.getLanguageChild(language);
+                                                if (existsInArray(marketChild.getOrderType(), _orderTypes)) {
+                                                    productDocuments.push({
+                                                        sku: docs[i].sku,
+                                                        fullImage: marketChild.getFullImageUrl(),
+                                                        name: languageChild.getTitle(),
+                                                        _root_: "product/" + docs[i].sku,
+                                                        isExclusive: languageChild.getIsExclusive()
+                                                    });
                                                 }
                                             }
                                         }
                                     }
                                 }
+                            }
 
-                                let retValue = {
-                                    products: productDocuments,
-                                    totalNumFound: totalNumFound
-                                };
+                            let retValue = {
+                                products: productDocuments,
+                                totalNumFound: totalNumFound
+                            };
 
-                                deferred.resolve(retValue);
-                            },
-                            error: function (xmlHttpRequest, textStatus) {
-                                deferred.reject(textStatus);
-                                //console.log('Search failed!');
-                            }
-                        });
-                    } else {
-                        retValue = {
-                            products: docs,
-                            totalNumFound: totalNumFound
-                        };
-                        deferred.resolve(retValue);
-                    }
+                            deferred.resolve(retValue);
+                        },
+                        error: function (xmlHttpRequest, textStatus) {
+                            deferred.reject(textStatus);
+                            //console.log('Search failed!');
+                        }
+                    });
                 } else {
                     retValue = {
                         products: docs,
                         totalNumFound: totalNumFound
                     };
-
                     deferred.resolve(retValue);
                 }
-            });
-        }
-        
-        
+            } else {
+                retValue = {
+                    products: docs,
+                    totalNumFound: totalNumFound
+                };
+
+                deferred.resolve(retValue);
+            }
+        });
 
         return deferred;
     }
@@ -591,132 +573,113 @@ let SolrQueryService = function() {
             productResultType, searchTerm, productSearchFields, language, market, rows, start
         );
 
-        const {MySite_search_API_Base_URLs} = getCachedConfiguration('Equinox_Markets');
-
-        if(MySite_search_API_Base_URLs !== '') {
-
-            productSearchAPI(deferred, {
-                searchTerm,
-                rows: 50,
-                language,
-                market,
-                page: 1
-            })
-
-        } else {
-
-            // Search for language nodes for the given market that match the search term.
-            let queryResponsePromise = $.ajax({
-                url: solrUrl,
-                type: "GET",
-                contentType: 'application/json; charset=utf-8',
-                headers: {
-                    "client_id": getCachedConfigField('solrClientId'),
-                    "client_secret": getCachedConfigField('solrClientSecret')
-                },
-                timeout: SolrTimeout,
-                success: function () {
+        // Search for language nodes for the given market that match the search term.
+        let queryResponsePromise = $.ajax({
+            url: solrUrl,
+            type: "GET",
+            contentType: 'application/json; charset=utf-8',
+            headers: {
+                "client_id": getCachedConfigField('solrClientId'),
+                "client_secret": getCachedConfigField('solrClientSecret')
+            },
+            timeout: SolrTimeout,
+            success: function () {
                 //console.log("Search success!");
-                },
-                error: function (xmlHttpRequest, textStatus) {
-                    deferred.reject(textStatus);
+            },
+            error: function (xmlHttpRequest, textStatus) {
+                deferred.reject(textStatus);
                 //console.log('Search failed!');
-                }
-            });
+            }
+        });
 
-            queryResponsePromise.then(function(responseData){
-                let matchingRootProducts, totalNumFound, responseHeader;
+        queryResponsePromise.then(function(responseData){
+            let matchingRootProducts, totalNumFound, responseHeader;
 
-                if (typeof(responseData) === "string") {
-                    matchingRootProducts = $.parseJSON(responseData).response.docs;
-                    totalNumFound = $.parseJSON(responseData).response.numFound;
-                    responseHeader = $.parseJSON(responseData).responseHeader;
-                } else {
-                    matchingRootProducts = responseData.response.docs;
-                    totalNumFound = responseData.response.numFound;
-                    responseHeader = responseData.responseHeader;
-                }
+            if (typeof(responseData) === "string") {
+                matchingRootProducts = $.parseJSON(responseData).response.docs;
+                totalNumFound = $.parseJSON(responseData).response.numFound;
+                responseHeader = $.parseJSON(responseData).responseHeader;
+            } else {
+                matchingRootProducts = responseData.response.docs;
+                totalNumFound = responseData.response.numFound;
+                responseHeader = responseData.responseHeader;
+            }
 
-                // If the zkConnected header is true, we count on the data returned from the query being accurate.
-                // If it's false, we will re-try the Solr query so that we are sure we have the most up-to-date information
-                // (We only try again once, which is what sets the retrySolrRequest variable)
-                if (responseHeader.zkConnected || !retrySolrRequest) {
+            // If the zkConnected header is true, we count on the data returned from the query being accurate.
+            // If it's false, we will re-try the Solr query so that we are sure we have the most up-to-date information
+            // (We only try again once, which is what sets the retrySolrRequest variable)
+            if (responseHeader.zkConnected || !retrySolrRequest) {
                 // eslint-disable-next-line
                 // Example solrUrl: http://dev-gateway-mulesoft-21:8080/mec/solr/oak/select?fl=*,[child%20parentFilter=path_exact:product/????????%20childFilter=path_exact:product/????????/en],[child%20parentFilter=path_exact:product/????????%20childFilter=path_exact:product/????????/US]&q=path_exact:product/01003611&rows=5&wt=json
                 // Always start at 0 so we get all the rows we are asking for.
-                    solrUrl = SolrQueryUrlService.getProductsByRoots(matchingRootProducts, language, market, rows, 0, orderTypes);
-
-                    if (solrUrl.url) {
-                        let productDocuments = [];
-
-                        // Return the complete records for the given matches
-                        queryResponsePromise = $.ajax({
-                            url: solrUrl.url,
-                            type: "POST",
-                            contentType: 'application/json; charset=utf-8',
-                            headers: {
-                                "client_id": getCachedConfigField('solrClientId'),
-                                "client_secret": getCachedConfigField('solrClientSecret')
-                            },
-                            data: JSON.stringify(solrUrl.postData),
-                            timeout: SolrTimeout,
-                            success: function (responseData) {
-                                let docs;
-
-                                if (typeof(responseData) === "string") {
-                                    docs = $.parseJSON(responseData).response.docs;
-                                }
-                                else {
-                                    docs = responseData.response.docs;
-                                }
+                solrUrl = SolrQueryUrlService.getProductsByRoots(matchingRootProducts, language, market, rows, 0, orderTypes);
+
+                if (solrUrl.url) {
+                    let productDocuments = [];
+
+                    // Return the complete records for the given matches
+                    queryResponsePromise = $.ajax({
+                        url: solrUrl.url,
+                        type: "POST",
+                        contentType: 'application/json; charset=utf-8',
+                        headers: {
+                            "client_id": getCachedConfigField('solrClientId'),
+                            "client_secret": getCachedConfigField('solrClientSecret')
+                        },
+                        data: JSON.stringify(solrUrl.postData),
+                        timeout: SolrTimeout,
+                        success: function (responseData) {
+                            let docs;
+
+                            if (typeof(responseData) === "string") {
+                                docs = $.parseJSON(responseData).response.docs;
+                            }
+                            else {
+                                docs = responseData.response.docs;
+                            }
 
-                                for (let i = 0; i < matchingRootProducts.length; i++) {
-                                    matchingRootProducts[i].path_exact = matchingRootProducts[i]._root_[0];
-                                }
+                            for (let i = 0; i < matchingRootProducts.length; i++) {
+                                matchingRootProducts[i].path_exact = matchingRootProducts[i]._root_[0];
+                            }
 
-                                // Wrap the products in an adaptor for ease of use.
-                                for (let i = 0; i < docs.length; i++) {
+                            // Wrap the products in an adaptor for ease of use.
+                            for (let i = 0; i < docs.length; i++) {
                                 //ONLY RETURN PRODUCTS THAT HAVE A MARKET
-                                    if (docs[i]._childDocuments_) {
-                                        for (let m = 0; m < docs[i]._childDocuments_.length; m++) {
-                                            if ((docs[i]._childDocuments_[m].path_exact === "product/" + docs[i].sku + '/' + market.toUpperCase()) &&
+                                if (docs[i]._childDocuments_) {
+                                    for (let m = 0; m < docs[i]._childDocuments_.length; m++) {
+                                        if ((docs[i]._childDocuments_[m].path_exact === "product/" + docs[i].sku + '/' + market.toUpperCase()) &&
                                             !docs[i]._childDocuments_[m].excludeFromSearch) {
 
-                                                if (!skuExistsInSolrProductAdaptorArray(productDocuments, docs[i].sku.toString())) {
-                                                    const match = matchingRootProducts.find(root => root.path_exact === docs[i].path_exact) || null;
-                                                    const score = match ? match.score : 0;
-                                                    productDocuments.push(new SolrProductAdaptor(docs[i], score));
-                                                }
+                                            if (!skuExistsInSolrProductAdaptorArray(productDocuments, docs[i].sku.toString())) {
+                                                const match = matchingRootProducts.find(root => root.path_exact === docs[i].path_exact) || null;
+                                                const score = match ? match.score : 0;
+                                                productDocuments.push(new SolrProductAdaptor(docs[i], score));
                                             }
                                         }
                                     }
                                 }
+                            }
 
-                                let retValue = {
-                                    products: productDocuments,
-                                    totalNumFound: totalNumFound
-                                };
+                            let retValue = {
+                                products: productDocuments,
+                                totalNumFound: totalNumFound
+                            };
 
-                                deferred.resolve(retValue);
-                            },
-                            error: function (xmlHttpRequest, textStatus) {
-                                deferred.reject(textStatus);
+                            deferred.resolve(retValue);
+                        },
+                        error: function (xmlHttpRequest, textStatus) {
+                            deferred.reject(textStatus);
                             //console.log('Search failed!');
-                            }
-                        });
-                    }
-                    else {
-                        deferred.resolve(undefined);
-                    }
-                } else {
-                    getProductsBySearchFields(productResultType, searchTerm, productSearchFields, language, market, rows, start, orderTypes, deferred)
+                        }
+                    });
                 }
-            });
-
-        }
-
-        
-       
+                else {
+                    deferred.resolve(undefined);
+                }
+            } else {
+                getProductsBySearchFields(productResultType, searchTerm, productSearchFields, language, market, rows, start, orderTypes, deferred)
+            }
+        });
 
         return deferred;
     }

package/src/product/productSearchService.js

@@ -1,7 +1,7 @@
 import {ProductSearchFieldsEnum, ProductSortOrderEnum, ProductSortTypeEnum} from "./productSearchFieldsEnum.js";
 import {ProductResultsEnum} from "./productResultsEnum.js";
 import {util, BrowserDetection, UrlService} from '@nuskin/ns-util';
-import {getCachedConfigField, getCachedConfiguration} from "@nuskin/configuration-sdk";
+import {getCachedConfigField} from "@nuskin/configuration-sdk";
 import {AccountManager} from '@nuskin/ns-account';
 import SolrQueryService from "./SolrQueryService.js";
 import SynonymService from "./synonymService";
@@ -604,7 +604,6 @@ let productSearchService = function() {
     const createProductFromBasicProduct = function(basicProduct) {
         let siteUrl = UrlService.getSiteUrl();
         let productData = {};
-        const {MySite_search_API_Base_URLs} = getCachedConfiguration('Equinox_Markets');
         if (basicProduct.sku) {
             if (typeof(basicProduct.sku) === 'object') {
                 productData.sku = basicProduct.sku[0];
@@ -613,11 +612,6 @@ let productSearchService = function() {
             }
             // eslint-disable-next-line
             productData.thumbnail = siteUrl + "/content/products/" + productData.sku.substring(0,2) +"/" + productData.sku.substring(2,4) + "/" + productData.sku.substring(4,6) +"/" + productData.sku +"/_jcr_content/fullImage.img.160.160.png"
-            //use equinox image when using product-search-api and market is active
-            if(MySite_search_API_Base_URLs !== '') {
-                productData.thumbnail = basicProduct.fullImage
-            }
-
         }
         if (basicProduct.name) {
             if (typeof(basicProduct.name) === 'object') {

package/src/shop.js

@@ -65,6 +65,7 @@ export {default as AccertifyFraudService} from './payment/accertifyFraudService.
 export {default as EquinoxCartService} from './cart/equinoxCartService.js';
 export {default as eidLogin} from './eidLogin';
 export {default as Receiver} from './receiver';
+export {default as AgreementService} from './account/agreementService.js'
 
 export {PriceType, Agelocme, Product, ProductStatus} from '@nuskin/ns-product-lib';
 

package/src/product/productSearchAPIQueryService.js

@@ -1,389 +0,0 @@
-import $ from '@nuskin/nuskinjquery';
-import { getCachedConfiguration } from '@nuskin/configuration-sdk';
-import { SolrProductAdaptor } from './solrProductAdaptor';
-import { CustomerTypes } from '@nuskin/ns-product-lib';
-
-/**
- * Checks if the input string follows a specific SKU format.
- * @param {string} str - The input string to be checked.
- * @returns {boolean} Returns true if the input string is a valid SKU format, otherwise false.
- */
-function isSkuFormat(str) {
-    return typeof str === 'string' && str.length === 8 && /^[a-zA-Z0-9]+$/.test(str);
-}
-
-/**
- * Performs a search in the Equinox catalog based on the provided options.
- * @param {Promise} deferred - A promise object that resolves when the search is complete.
- * @param {Object} options - The search options including searchTerm, rows, language, market.
- */
-function productSearchAPI(deferred, options) {
-
-    let allProducts = [];
-    let currentPage = 1;
-    let baseScore = 5;
-    const { MySite_search_API_Base_URLs } = getCachedConfiguration('Equinox_Markets');
-    
-    /**
-     * Sends a query to the Equinox catalog API.
-     * @returns {Promise} A promise that resolves with the query response.
-     */
-    function sendQuery(page) {
-
-        const query = `
-            query ProductSearch(
-                $sizeOpt: Int
-                $language: String!
-                $market: String!
-                $storeId: String
-                $searchTerm: String
-                $filterOpt: String
-                $sortOpt: String
-                $pageOpt: Int
-            ) {
-                productSearch(
-                    sizeOpt: $sizeOpt
-                    language: $language
-                    market: $market
-                    store_Id: $storeId
-                    searchTerm: $searchTerm
-                    filterOpt: $filterOpt
-                    sortOpt: $sortOpt
-                    pageOpt: $pageOpt
-                ) {
-                    ProductContent {
-                        products {
-                            error {
-                                errors
-                            }
-                            title
-                            productImages {
-                                url
-                            }
-                            variants {
-                                title
-                                sku
-                                productImages {
-                                    url
-                                    alt
-                                    thumbnail
-                                }
-                                isExclusive
-                                availableChannels
-                                customerTypes
-                                description
-                                searchKeywords
-                            }
-                            bundle {
-                                purchaseTypes {
-                                    buyOnce
-                                    subscription
-                                }
-                                customerTypes
-                            }
-                            id
-                        }
-                    }
-                    pageableInfo {
-                        Page
-                        Size
-                        Count
-                        TotalCount
-                    }
-                }
-            }
-        `;
-    
-        const variables = {
-            "language": options.language,
-            "market": options.market,
-            "sizeOpt": options.rows,
-            "pageOpt": page,
-            "searchTerm": options.searchTerm,
-            "filterOpt": null,
-            "sortOpt": null
-        };
-    
-        const data = JSON.stringify({
-            query: query,
-            variables: variables
-        });
-    
-        return $.ajax({
-            url: MySite_search_API_Base_URLs,
-            type: "POST",
-            contentType: 'application/json; charset=utf-8',
-            data: data
-        });
-    }
-
-    /**
-     * Extracts relevant information from the product response.
-     * @param {Object} response - The response from the Equinox catalog API.
-     * @returns {Object} An object containing products and total number found.
-     */
-    function processResponse(response) {
-        let retValue = {
-            products: [],
-            totalNumFound: 0
-        };
-    
-        const result = response.data.productSearch || {};
-    
-        if (result.ProductContent && result.ProductContent.products && result.ProductContent.products.length > 0) {
-            let products = result.ProductContent.products;
-    
-            if (options.groupByVariant) {
-                products = processGroupByVariant(products);
-            } else {
-                products = processGroupByParent(products);
-            }
-    
-            retValue = {
-                products,
-                totalNumFound: result.pageableInfo.TotalCount
-            };
-        }
-    
-        return retValue;
-    }
-
-    /**
-     * Processes a list of products to be grouped by parent, generating a mapped product structure.
-     *
-     * @param {Array} products - The list of products to process.
-     * @returns {Array} An array of mapped products with child documents for each variant.
-     */
-    function processGroupByParent(products) {
-        let mappedProducts = [];
-
-        //clean up null data (a lot exists in test environment)
-        products = products.filter((product) => {
-            if(product.error) {
-                console.log('Removed Products with error' , product.error)
-            }
-
-            return !product.error
-        })
-    
-        products.forEach((parentProduct) => {
-            let mappedParentProduct = parentProduct;
-    
-            if (!isSkuFormat(parentProduct.id) && parentProduct.variants && parentProduct.variants.length > 0) {
-                mappedParentProduct = parentProduct.variants[0];
-            } else {
-                mappedParentProduct.sku = parentProduct.id;
-                mappedParentProduct.variants = [];
-                mappedParentProduct.variants.push({ ...mappedParentProduct, sku: parentProduct.id });
-            }
-
-            let indexDocuments = parentProduct.variants.map((variant) => {
-
-                let orderTypes = mapOrderTypes(variant.availableChannels, variant.bundle ? variant.bundle.purchaseTypes : undefined);
-
-                return {
-                    path_exact: `product/${variant.sku}/${options.language}`,
-                    sku: [`${variant.sku}`],
-                    markets: [`${options.market}`],
-                    variantType: [""],
-                    name: [`${variant.title}`],
-                    shortDescription: variant.description,
-                    longDescription: variant.description,
-                    searchTerms: variant.searchKeywords,
-                    isExclusive: mappedParentProduct.isExclusive || "false",
-                    custType: mapCustomerTypes(variant.bundle ? variant.bundle.customerTypes : variant.customerTypes),
-                    statusCode: ["10"],
-                    orderType: Object.keys(orderTypes).filter(key => orderTypes[key]),
-                    _root_: [`product/${mappedParentProduct.sku}`]
-                };
-            });
-    
-            let mySiteIndexDocuments = parentProduct.variants.map((variant) => {
-
-                let orderTypes = mapOrderTypes(variant.availableChannels, variant.bundle ? variant.bundle.purchaseTypes : undefined);
-                
-                return {
-                    path_exact: `product/${variant.sku}/${options.market.toUpperCase()}`,
-                    sku: [`${variant.sku}`],
-                    searchTerms: variant.searchKeywords,
-                    orderType: Object.keys(orderTypes).filter(key => orderTypes[key]),
-                    custType: mapCustomerTypes(variant.bundle ? variant.bundle.customerTypes : variant.customerTypes),
-                    statusCode: ["10"],
-                    webEnabled: ["true"],
-                    _root_: [`product/${mappedParentProduct.sku}`]
-                };
-            });
-    
-            indexDocuments = indexDocuments.concat(mySiteIndexDocuments);
-    
-            if (indexDocuments.length > 0) {
-                mappedProducts.push({
-                    path_exact: `product/${mappedParentProduct.sku}`,
-                    languages: [`${options.language.toLowerCase()}`],
-                    markets: [`${options.market.toLowerCase()}`],
-                    sku: [`${mappedParentProduct.sku}`],
-                    _childDocuments_: indexDocuments
-                });
-            } else {
-                console.log('Invalid Product', mappedParentProduct);
-            }
-        });
-
-        // console.log('Products' , mappedProducts)
-    
-        return mappedProducts.map((product) => { 
-            baseScore -= 0.01;
-            return new SolrProductAdaptor(product, baseScore)
-        });
-    }
-    
-    /**
-     * Processes a list of products to be grouped by variant, generating a mapped product structure.
-     *
-     * @param {Array} products - The list of products to process.
-     * @returns {Array} An array of mapped products with a flattened structure.
-     */
-    function processGroupByVariant(products) {
-
-        //clean up null data (a lot exists in test environment)
-        products = products.filter((product) => {
-            if(product.error) {
-                console.log('Removed Products with error' , product.error)
-            }
-
-            return !product.error
-        })
-
-        let groupedProducts = products.map((v) => {
-            return v.variants && v.variants.length > 0 ? v.variants : [{ ...v, sku: v.id }];
-        }).flat();
-    
-        groupedProducts = groupedProducts.filter((v) => v !== undefined).map((product) => {
-            return {
-                sku: [product.sku],
-                fullImage: (product.productImages && product.productImages.length > 0) ? product.productImages[0].url : '',
-                name: product.title || '',
-                _root_: `product/${product.sku}`,
-                isExclusive: product.isExclusive || "false"
-            };
-        });
-    
-        let exactSkuResult = groupedProducts.filter((product) => product.sku[0].toLowerCase() === options.searchTerm.toLowerCase());
-        
-        if (isSkuFormat(options.searchTerm) && exactSkuResult.length > 0) {
-            groupedProducts = exactSkuResult
-        }
-    
-        return groupedProducts;
-    }
-
-
-    /**
-     * map EQ customer types to supported product card customer types
-     * @param {Array<string>} eqCustomerTypes
-     * @returns{string} customer types
-     */
-    function mapCustomerTypes(eqCustomerTypes) {
-        if (!eqCustomerTypes) {
-            return "";
-        }
-    
-        const custTypes = eqCustomerTypes.map(str => str.toLowerCase());
-    
-        let newCustType = [];
-        if (custTypes.includes(CustomerTypes.BrandAffiliate)) {
-            newCustType.push(CustomerTypes.properties.BRAND_AFFILIATE.code);
-        }
-    
-        if (custTypes.includes(CustomerTypes.Retail)) {
-            newCustType.push(CustomerTypes.properties.RETAIL.code);
-        }
-    
-        if (custTypes.includes(CustomerTypes.Preferred) || custTypes.includes(CustomerTypes.PreferredCustomer)) {
-            newCustType.push(CustomerTypes.properties.PREFERRED.code);
-        }
-    
-        return newCustType.toString().split(",")
-    }
-
-    /**
-     * Map Order Types
-     * @param {Array<string>} availableChannels
-     * @param {object} purchaseTypes
-     * @returns {object} orderTypes
-     */
-    function mapOrderTypes(availableChannels, purchaseTypes) {
-
-        let orderTypes = {
-            "adr": false,
-            "order": false,
-            "zpfc": false,
-            "zadp": false,
-            "ars": false,
-            "kiosk": false,
-            "mobile": false,
-            "preferred customer": false,
-            "retail": false,
-            "web": false,
-            "web display": false
-        };
-  
-        if (availableChannels) {
-            let availableChannelsArr = Array.isArray(availableChannels) ? availableChannels : availableChannels.split(',');
-  
-            availableChannelsArr.forEach(channel => {
-                if (channel == 'arsPhone')
-                    orderTypes.ars = true
-                if (channel == 'web') {
-                    orderTypes.order = true
-                    orderTypes.web = true
-                }
-                if (channel == 'kiosk')
-                    orderTypes.kiosk = true
-                if (channel == 'mobile')
-                    orderTypes.mobile = true
-                if (channel == 'subscription')
-                    orderTypes.adr = true
-            });
-        }
-  
-        if (purchaseTypes && purchaseTypes.buyOnce) {
-            orderTypes.web = true
-            orderTypes.order = true
-        }
-        if (purchaseTypes && purchaseTypes.subscription) {
-            orderTypes.adr = true
-        }
-  
-        return orderTypes;
-    }
-
-    
-    function fetchNextPage() {
-        sendQuery(currentPage)
-            .then(processResponse)
-            .then((result) => {
-                allProducts = allProducts.concat(result.products);
-                if ((currentPage * options.rows) < result.totalNumFound && !options.groupByVariant) {
-                    currentPage++;
-                    fetchNextPage();
-                } else {
-                    deferred.resolve({
-                        products: allProducts,
-                        totalNumFound: result.totalNumFound
-                    });
-                }
-            })
-            .catch((error) => {
-                console.error(error);
-                deferred.reject(error);
-            });
-    }
-
-    fetchNextPage();
-}
-
-export {
-    productSearchAPI,
-    isSkuFormat
-};