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

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