idosell 0.4.13 → 0.4.17

package/dist/utils.d.ts

@@ -1,31 +1,30 @@
+import type { PRODUCT_SIZE_COUNTABLE, PRODUCT_SIZE_LOCATIONS, PRODUCT_SIZE_CODES } from "./enums.d";
 import type { SearchProductsResponse } from "./responses.d.ts"
 
-export enum QunatityType {
-    ProductSizeQuantityOwnStock = "productSizeQuantityOwnStock",
-    ProductSizeQuantityOutsideStock = "productSizeQuantityOutsideStock",
-    ProductSizeQuantityAllStocks = "productSizeQuantityAllStocks",
-    ProductStocksQuantities = "productStocksQuantities",
-    ProductOrdersUnfinishedQuantities = "productOrdersUnfinishedQuantities",
-    ProductSizesDeliveries = "productSizesDeliveries",
-    ProductSizesDispositionsInAuctions = "productSizesDispositionsInAuctions",
-}
-
 export type IdosellProduct = SearchProductsResponse['results'][0];
 
 export type GetIaICodeFunction = (productId: number|string, sizeId: string) => string;
 
-export type SumProductQuantitiesFunction = (productStocksData: IdosellProduct['productStocksData'], stockType?: QunatityType) => number;
+export type SumProductQuantitiesFunction = (productStocksData: IdosellProduct['productStocksData'], stockType?: PRODUCT_SIZE_COUNTABLE | `${PRODUCT_SIZE_COUNTABLE}`) => number;
+
+export type MapSizeQuantitesFunction = (product: IdosellProduct, stockType?: `${PRODUCT_SIZE_COUNTABLE}`) => Record<string,number>;
+
+export type MapProductCodesFunction = (product: IdosellProduct, codeType?: `${PRODUCT_SIZE_CODES}`) => Record<string,string>;
+
+export type MapProductLocationsFunction = (product: IdosellProduct, stockId?: number, codeType?: `${PRODUCT_SIZE_LOCATIONS}`) => Record<string,string[]>;
 
-export type MapSizeQuantitesFunction = (product: IdosellProduct, stockType?: QunatityType) => Record<string,number>;
+export type GetLangDataFunction = <T extends { langId: string}>(array: T[], langId?: string) => T|undefined;
 
-export type MapProductCodesFunction = (product: IdosellProduct, codeType?: 'productSizeCodeExternal'|'productSizeCodeProducer'|'sizePanelName') => Record<string,string>;
+export type ClearParametersLangDataFunction = (products: SearchProductsResponse['results'], langId: string = 'pol') => SearchProductsResponse['results'];
 
 declare namespace utils {
-    const QUANTITY_TYPE_ENUM: typeof QunatityType;
     const getIaiCode: GetIaICodeFunction;
     const sumProductQuantities: SumProductQuantitiesFunction;
     const mapSizeQuantites: MapSizeQuantitesFunction;
     const mapProductCodes: MapProductCodesFunction;
+    const getLangData: GetLangDataFunction;
+    const clearParametersLangData: ClearParametersLangDataFunction;
+    const mapProductLocations: MapProductLocationsFunction;
 }
 
 export default utils;

package/dist/utils.js

@@ -1,99 +1,222 @@
-export var QunatityType;
-(function (QunatityType) {
-    QunatityType["ProductSizeQuantityOwnStock"] = "productSizeQuantityOwnStock";
-    QunatityType["ProductSizeQuantityOutsideStock"] = "productSizeQuantityOutsideStock";
-    QunatityType["ProductSizeQuantityAllStocks"] = "productSizeQuantityAllStocks";
-    QunatityType["ProductStocksQuantities"] = "productStocksQuantities";
-    QunatityType["ProductOrdersUnfinishedQuantities"] = "productOrdersUnfinishedQuantities";
-    QunatityType["ProductSizesDeliveries"] = "productSizesDeliveries";
-    QunatityType["ProductSizesDispositionsInAuctions"] = "productSizesDispositionsInAuctions";
-})(QunatityType || (QunatityType = {}));
-const productQuantityPathMap = {
-    // ----- Product Dispositions -----
-    [QunatityType.ProductSizeQuantityOwnStock]: ["productSizesDispositions", "productSizesDispositionsInSales", "productSizeQuantityOwnStock"],
-    [QunatityType.ProductSizeQuantityOutsideStock]: ["productSizesDispositions", "productSizesDispositionsInSales", "productSizeQuantityOutsideStock"],
-    [QunatityType.ProductSizeQuantityAllStocks]: ["productSizesDispositions", "productSizesDispositionsInSales", "productSizeQuantityAllStocks"],
-    [QunatityType.ProductSizesDispositionsInAuctions]: ["productSizesDispositions", "productSizesDispositionsInAuctions", "productSizeQuantity"],
-    // ----- Stocks & related quantities -----
-    [QunatityType.ProductStocksQuantities]: ["productStocksQuantities", "productSizeQuantity"],
-    [QunatityType.ProductOrdersUnfinishedQuantities]: ["productOrdersUnfinishedQuantities", "productSizeQuantity"],
-    [QunatityType.ProductSizesDeliveries]: ["productSizesDeliveries", "productSizeQuantity"],
-};
-const getProductSizeArrayNode = (productStocksData, key) => {
-    const pathNode = productQuantityPathMap[key];
-    if (!pathNode)
-        throw new Error("Invalid stock type " + key);
-    const path = pathNode.slice(0, -1);
-    const node = pathNode[pathNode.length - 1];
-    const arr = getProductSizeArray(productStocksData, path);
-    return { arr, node };
+import ENUMS from "./enums.js";
+const getIaiCode = (productId, sizeId) => {
+    if (sizeId === 'uniw')
+        return productId.toString();
+    return [productId, sizeId].join('-');
 };
-const getProductSizeArray = (productStocksData, path) => {
-    let current = productStocksData;
-    for (const segment of path) {
-        if (current && typeof current === "object" && segment in current) {
-            current = current[segment];
-        }
-        else {
-            return [];
+const traverseNodes = (node, pathIndex, path, results = []) => {
+    if (!node) {
+        return;
+    }
+    if (pathIndex >= path.length) {
+        results.push(node);
+        return;
+    }
+    const key = path[pathIndex];
+    if (key === 'array') {
+        if (Array.isArray(node)) {
+            node.forEach(item => traverseNodes(item, pathIndex + 1, path, results));
         }
     }
-    if (Array.isArray(current)) {
-        if (current.length && current[0]?.productSizesData) {
-            return current.flatMap((s) => s.productSizesData);
+    else {
+        if (node[key] !== undefined) {
+            traverseNodes(node[key], pathIndex + 1, path, results);
         }
-        return current;
     }
-    return [];
 };
-const sumProductQuantities = (productStocksData, stockType = QunatityType.ProductSizeQuantityOwnStock) => {
-    const { arr, node } = getProductSizeArrayNode(productStocksData, stockType);
-    return arr.reduce((total, item) => {
-        const value = item[node];
-        if (typeof value === 'number')
-            total += value;
-        return total;
-    }, 0);
+const productSizesPathMap = {
+    [ENUMS.PRODUCT_SIZE_COUNTABLE.QUANTITY]: [
+        'productStocksData',
+        'productStocksQuantities',
+        'array',
+        'productSizesData',
+        'array'
+    ],
+    [ENUMS.PRODUCT_SIZE_COUNTABLE.QUANTITY_OWN]: [
+        'productStocksData',
+        'productSizesDispositions',
+        'productSizesDispositionsInSales',
+        'array'
+    ],
+    [ENUMS.PRODUCT_SIZE_COUNTABLE.QUANTITY_OUTSIDE]: [
+        'productStocksData',
+        'productSizesDispositions',
+        'productSizesDispositionsInSales',
+        'array'
+    ],
+    [ENUMS.PRODUCT_SIZE_COUNTABLE.QUANTITY_ALL]: [
+        'productStocksData',
+        'productSizesDispositions',
+        'productSizesDispositionsInSales',
+        'array'
+    ],
+    [ENUMS.PRODUCT_SIZE_COUNTABLE.QUANTITY_ORDERS_UNFINISHED]: [
+        'productStocksData',
+        'productOrdersUnfinishedQuantities',
+        'array',
+        'productSizesData',
+        'array'
+    ],
+    [ENUMS.PRODUCT_SIZE_COUNTABLE.DELIVERIES]: [
+        'productStocksData',
+        'productSizesDeliveries',
+        'array'
+    ],
+    [ENUMS.PRODUCT_SIZE_COUNTABLE.AUCTIONS]: [
+        'productStocksData',
+        'productSizesDispositions',
+        'productSizesDispositionsInAuctions',
+        'array'
+    ],
+    [ENUMS.PRODUCT_SIZE_CODES.NAME]: [
+        'productSizes',
+        'array'
+    ],
+    [ENUMS.PRODUCT_SIZE_CODES.CODE_PRODUCER]: [
+        'productSizesAttributes',
+        'array'
+    ],
+    [ENUMS.PRODUCT_SIZE_CODES.CODE_EXTERNAL]: [
+        'productStocksData',
+        'productStocksQuantities',
+        'array',
+        'productSizesData',
+        'array'
+    ],
+    [ENUMS.PRODUCT_SIZE_LOCATIONS.NAME]: [
+        'productStocksData',
+        'productSizesStocksLocations',
+        'array',
+        'productSizesLocation',
+        'array'
+    ],
+    [ENUMS.PRODUCT_SIZE_LOCATIONS.CODE]: [
+        'productStocksData',
+        'productSizesStocksLocations',
+        'array',
+        'productSizesLocation',
+        'array'
+    ],
+    [ENUMS.PRODUCT_SIZE_LOCATIONS.ID]: [
+        'productStocksData',
+        'productSizesStocksLocations',
+        'array',
+        'productSizesLocation',
+        'array'
+    ],
 };
-const getIaiCode = (productId, sizeId) => {
-    if (sizeId === 'uniw')
-        return productId.toString();
-    return [productId, sizeId].join('-');
+const getTraversedPathElements = (product, nodeName) => {
+    const path = productSizesPathMap[nodeName];
+    if (!path)
+        throw new Error(`Invalid path for ${nodeName}`);
+    const results = [];
+    traverseNodes(product, 0, path, results);
+    return results;
 };
-const mapSizeQuantites = (product, stockType = QunatityType.ProductSizeQuantityOwnStock) => {
-    const obj = {};
-    if (!product.productStocksData)
-        return obj;
-    const { arr, node } = getProductSizeArrayNode(product.productStocksData, stockType);
-    for (const item of arr) {
-        const value = item[node];
-        if (typeof value !== 'number')
-            continue;
-        const index = getIaiCode(product.productId, item.sizeId);
-        if (!obj[index])
-            obj[index] = value;
-        else
-            obj[index] += value;
+const sumProductQuantities = (productStocksData, nodeName = ENUMS.PRODUCT_SIZE_COUNTABLE.QUANTITY_OWN) => {
+    const results = getTraversedPathElements({ productStocksData, productId: 0 }, nodeName);
+    let sum = 0;
+    if (['productOrdersUnfinishedQuantities', 'productSizesDeliveries', 'productSizesDispositionsInAuctions'].includes(nodeName))
+        nodeName = 'productSizeQuantity';
+    results.forEach(item => {
+        if (item?.sizeId && item[nodeName] !== undefined) {
+            const value = Number(item[nodeName]) || 0;
+            sum += value;
+        }
+    });
+    return sum;
+};
+const mapSizeQuantites = (product, nodeName = ENUMS.PRODUCT_SIZE_COUNTABLE.QUANTITY_OWN) => {
+    const results = getTraversedPathElements(product, nodeName);
+    const aggregated = {};
+    if (['productOrdersUnfinishedQuantities', 'productSizesDeliveries', 'productSizesDispositionsInAuctions'].includes(nodeName))
+        nodeName = 'productSizeQuantity';
+    results.forEach(item => {
+        if (item?.sizeId && item[nodeName] !== undefined) {
+            const sizeId = String(item.sizeId);
+            const value = Number(item[nodeName]) || 0;
+            aggregated[sizeId] = (aggregated[sizeId] || 0) + value;
+        }
+    });
+    return aggregated;
+};
+const mapProductCodes = (product, codeType = ENUMS.PRODUCT_SIZE_CODES.NAME) => {
+    const results = getTraversedPathElements(product, codeType);
+    const mapped = {};
+    results.forEach(item => {
+        if (item?.sizeId && item[codeType] !== undefined) {
+            const sizeId = String(item.sizeId);
+            const value = String(item[codeType] || '');
+            if (!mapped[sizeId] || value) {
+                mapped[sizeId] = value;
+            }
+        }
+    });
+    return mapped;
+};
+const SUB_TYPE_NODES = {
+    stockLocationTextId: 'stockAdditionalLocationTextId',
+    stockLocationId: 'stockAdditionalLocationId',
+    stockLocationCode: 'stockAdditionalLocationCode'
+};
+const mapProductLocations = (product, stockId, locationType = ENUMS.PRODUCT_SIZE_LOCATIONS.NAME) => {
+    let results = getTraversedPathElements(product, locationType);
+    if (stockId) {
+        const prefix = 'M' + stockId;
+        results = results.filter((location) => location.stockLocationTextId.startsWith(prefix));
+    }
+    const mapped = {};
+    const subNode = SUB_TYPE_NODES[locationType];
+    for (const item of results) {
+        const { sizeId } = item;
+        if (!mapped[sizeId]) {
+            mapped[sizeId] = [];
+        }
+        // main location
+        const mainLocation = item[locationType];
+        if (mainLocation) {
+            mapped[sizeId].push(mainLocation.toString());
+        }
+        // additional locations
+        if (item.stockAdditionalLocations?.length) {
+            for (const additional of item.stockAdditionalLocations) {
+                const value = additional[subNode];
+                if (value) {
+                    mapped[sizeId].push(value.toString());
+                }
+            }
+        }
     }
-    return obj;
+    return mapped;
+};
+const getLangData = (arr, langId = 'pol') => {
+    if (!arr.length)
+        return undefined;
+    if (!arr[0].langId)
+        throw new Error('Array has no langId');
+    return arr.find(item => item.langId === langId);
 };
-const mapProductCodes = (product, codeType = 'productSizeCodeProducer') => {
-    const obj = {};
-    if (product.productSizesAttributes) {
-        for (const size of product.productSizesAttributes) {
-            const code = size[codeType];
-            if (!code)
+const clearParametersLangData = (products, langId = 'pol') => {
+    for (const product of products) {
+        if (!product.productParameters)
+            continue;
+        for (const parameter of product.productParameters) {
+            if (!parameter.parameterValues)
                 continue;
-            const sku = getIaiCode(product.productId, size.sizeId);
-            obj[sku] = code;
+            parameter.parameterDescriptionsLangData = parameter.parameterDescriptionsLangData.filter(lang => lang.langId === langId);
+            for (const value of parameter.parameterValues) {
+                value.parameterValueDescriptionsLangData = value.parameterValueDescriptionsLangData.filter(lang => lang.langId === langId).map((item) => { item.parameterValueShopsData = []; return item; });
+            }
         }
     }
-    return obj;
+    return products;
 };
 export default {
-    QUANTITY_TYPE_ENUM: QunatityType,
-    getIaiCode,
     sumProductQuantities,
+    getIaiCode,
     mapSizeQuantites,
-    mapProductCodes
+    mapProductCodes,
+    mapProductLocations,
+    getLangData,
+    clearParametersLangData
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "idosell",
-  "version": "0.4.13",
+  "version": "0.4.17",
   "description": "Idosell 3 REST connector",
   "main": "dist/index.js",
   "types": "dist/gateways.d.ts",