dcos-core-monalisav2-latam 1.0.0

package/src/functions/multiPresentation/multipres.js

@@ -0,0 +1,459 @@
+const VtexApi = require('../../vtex/clients/VtexApi');
+const ApiResponse = require("../../common/utils/api-response");
+const AWSServices = require("../../common/utils/aws-services");
+const ClientData = require("../../entities/clients");
+const Logger = require("../../common/utils/logger");
+const SQS_MULTIPRE_PRODUCT_QUEUE_URL = process.env.SQS_MULTIPRE_PRODUCT_QUEUE_URL;
+
+/**
+ * Método para habilitar e inhabilitar presentaciones de producto.
+ *
+ * @param {object} account - Configuraciones de la cuenta de VTEX.
+ * @param {string} skuIdS - ID del SKU de VTEX.
+ * @param {object} dataExternal - Objeto con información externa del producto.
+ * @param {string} TradePolicyId - ID de la política comercial (opcional).
+ * @returns {Promise<boolean>} - Promesa que resuelve con un booleano que indica el éxito de la operación.
+ **/
+const setPresentationsSellers = async (account, skuIdS, dataExternal, TradePolicyId = null) => {
+    if (!account?.ProductMultiPresentation || !account?.ProductMultiPresentation?.isActive) {
+        Logger.error("El proceso de presentación de productos no está habilitado.");
+        return false;
+    }
+
+    const accountName = account.AccountName;
+    const ParentAccountName = account.ParentAccountName;
+
+    try {
+        if (account?.ProductMultiPresentation?.WhiteListProductId?.length > 0 && !account?.ProductMultiPresentation?.WhiteListProductId?.includes(dataExternal?.productId)) {
+            // producto restingido por lista blanca
+            Logger.error('producto restingido por lista blanca:', dataExternal);
+            return false;
+        }
+
+        const products = await getProductBySkuId(ParentAccountName, account.Credentials.key, account.Credentials.token, skuIdS, TradePolicyId);
+
+        if (products.length > 0) {
+
+            for (let p = 0; p < products.length; p++) {
+                const product = products[p];
+                const rejectedSkus = [];
+                const availablePresentations = [];
+
+                for (const skuinfo of product.items) {
+                    const item = skuinfo;
+                    if (item && item?.isKit === true && item?.kitItems?.length === 1 && item?.itemId == skuIdS) {
+                        const amountItem = item?.kitItems[0]?.amount ?? 1;
+                        // Verificar si el producto está en la lista negra (WL_BlackList)
+                        try {
+                            const fieldBL = account?.ProductMultiPresentation?.WL_BlackList ?? "WL_BlackList";
+                            const WL_BlackList = product[fieldBL] && product[fieldBL].length > 0 ? product[fieldBL][0] : null;
+                            const BlackListCharacterSeparate = account?.ProductMultiPresentation?.BlackListCharacterSeparate ?? ";";
+                            const BlackListCharacterType = account?.ProductMultiPresentation?.BlackListCharacterType ?? "@";
+
+                            if (WL_BlackList) {
+
+                                const listSkuInactive = WL_BlackList.split(BlackListCharacterSeparate);
+                                for (var i = 0; i < listSkuInactive.length; i++) {
+                                    const whiteLabelData = listSkuInactive[i].split(BlackListCharacterType);
+
+                                    if (whiteLabelData.length == 2) {
+                                        const whiteLabel = whiteLabelData[0];
+                                        const skuIdInactive = whiteLabelData[1];
+                                        const itemBKL = product.items.find(i => (i.itemId == skuIdInactive && i.isKit === true));
+
+                                        if (itemBKL && !rejectedSkus?.find(i => i.itemId == itemBKL.itemId) && whiteLabel == account?.AccountName) {
+                                            rejectedSkus.push(itemBKL);
+                                        }
+
+                                    } else {
+                                        Logger.error('No se encontró contenido después de @');
+                                    }
+                                }
+                            } else {
+                                Logger.error('No se encontró la propiedad WL_BlackList');
+                            }
+                        } catch (e_bkl) {
+                            Logger.error("error en restriccion blacklist", e_bkl)
+                        }
+
+                        // Obtener el multiplicador de unidades desde "Unidades por display"
+                        const unitDefaultValue = account?.ProductMultiPresentation?.UnitDefaultValue ?? 1;
+                        const unitFormat = account?.ProductMultiPresentation?.UnitFormat && product[account?.ProductMultiPresentation?.UnitFormat] ? product[account?.ProductMultiPresentation?.UnitFormat][0] : unitDefaultValue;
+                        const unitMultiplier = account?.ProductMultiPresentation?.UnitMultiplier ? item[account?.ProductMultiPresentation?.UnitMultiplier] : item?.unitMultiplier;
+
+                        const multiplierFormat = parseInt(unitMultiplier, 10) * parseInt(unitFormat, 10) * parseInt(amountItem);
+                        const exactUnit = account?.ProductMultiPresentation?.ExactUnit ?? false;
+                        const fomulaPresentacion = account?.ProductMultiPresentation?.Formula ?? null;;
+                        const isValidMultiple = !rejectedSkus?.find(i => i.itemId == item.itemId) ? validateMultiple(multiplierFormat, dataExternal, exactUnit, fomulaPresentacion) : false;
+
+                        const valuesConsole = {
+                            unitDefaultValue,
+                            unitFormat,
+                            unitMultiplier,
+                            multiplierFormat,
+                            exactUnit,
+                            fomulaPresentacion,
+                            isValidMultiple
+                        };
+
+                        if (!isValidMultiple && !rejectedSkus?.find(i => i.itemId == item.itemId) && item.isKit === true) {
+                            rejectedSkus.push(item);
+                        } else if (!availablePresentations?.find(i => i.itemId == item.itemId) && item.isKit === true) {
+                            let tmpItem = item;
+                            tmpItem.amount = amountItem;
+                            availablePresentations.push(tmpItem);
+                        }
+                    }
+                }
+
+                const getItemComponent = product?.items?.filter(it => (it?.isKit === true));
+                const SkuIdMain = getItemComponent[0] && getItemComponent[0]?.kitItems?.length === 1 ? getItemComponent[0]?.kitItems[0]?.itemId : null;
+
+                if (SkuIdMain) {
+                    const mainPrice = await getSellerPrice(
+                        accountName,
+                        account.Credentials.key,
+                        account.Credentials.token,
+                        SkuIdMain
+                    );
+
+                    if (mainPrice) {
+                        for (const SkuId of availablePresentations) {
+                            await updatePriceByProduct(accountName,
+                                account.Credentials.key,
+                                account.Credentials.token,
+                                SkuId.itemId,
+                                mainPrice,
+                                (SkuId?.amount ?? 1)
+                            );
+                        }
+                        for (const skuId of rejectedSkus) {
+                            await deletePriceByProductRejected(accountName, account.Credentials.key, account.Credentials.token, skuId.itemId);
+                        }
+                    }
+
+                    return true;
+                } else {
+                    Logger.error('skuId main not found');
+                    return false;
+                }
+            }
+        } else {
+            Logger.error('No se encontraron items en el producto:', skuIdS);
+            return false;
+        }
+
+    } catch (error) {
+        Logger.error('Error al obtener el producto:', error);
+        throw error;
+    }
+};
+
+//////////////////// ALL GET FUNCTIONS ////////////////////
+/**
+ * Obtiene la información detallada de un producto por su productId utilizando la API de VTEX.
+ *
+ * @param {string} accountName - Nombre de la cuenta de VTEX.
+ * @param {string} key - Clave de la aplicación.
+ * @param {string} token - Token de la aplicación.
+ * @param {string} productId - ID del producto.
+ * @param {string} TradePolicyId - ID de la política comercial (opcional).
+ * @returns {Promise<Object[]>} - Promesa que resuelve con un array de objetos que representan los productos.
+ * @throws {Error} - Si ocurre un error al obtener el producto.
+ */
+async function getProductByProductId(accountName, key, token, productId, TradePolicyId = null) {
+    try {
+        const vtexApi = new VtexApi(accountName, key, token);
+        const url = `/catalog_system/pub/products/search/?fq=productId:${productId}${(!TradePolicyId ? "" : `&sc=${TradePolicyId}`)}`;
+        const result = await vtexApi.fetch(url, { method: 'GET' });
+        //Verificar si la respuesta fue exitosa
+        if (result.status >= 200 && result.status < 300) {
+            // La respuesta fue exitosa
+            if (result.data && result.data.length > 0) {
+                return result.data;
+            } else {
+                Logger.error(`Error al obtener el producto: , ${productId}, Status: ${result.status}`);
+                return [];
+            }
+        } else {
+            // La respuesta no fue exitosa
+            Logger.error(`Error al obtener el producto: , ${productId}, Status: ${result.status}`);
+            return [];
+        }
+    } catch (error) {
+        Logger.error('Error al obtener el producto');
+        return [];
+    }
+}
+
+/**
+ * Obtiene la información detallada de un producto por su SKU ID utilizando la API de VTEX.
+ *
+ * @param {string} accountName - Nombre de la cuenta de VTEX.
+ * @param {string} key - Clave de la aplicación.
+ * @param {string} token - Token de la aplicación.
+ * @param {string} skuId - ID del SKU.
+ * @param {string} TradePolicyId - ID de la política comercial (opcional).
+ * @returns {Promise<Object[]>} - Promesa que resuelve con un array de objetos que representan los productos.
+ * @throws {Error} - Si ocurre un error al obtener el producto.
+ */
+async function getProductBySkuId(accountName, key, token, skuId, TradePolicyId = null) {
+    try {
+        const vtexApi = new VtexApi(accountName, key, token);
+        const url = `/catalog_system/pub/products/search/?fq=skuId:${skuId}${(!TradePolicyId && TradePolicyId > 1 ? "" : `&sc=${TradePolicyId}`)}`;
+        const result = await vtexApi.fetch(url, { method: 'GET' });
+        //Verificar si la respuesta fue exitosa
+        if (result.status >= 200 && result.status < 300) {
+            // La respuesta fue exitosa
+            if (result.data && result.data.length > 0) {
+                return result.data;
+            } else {
+                Logger.error(`Error al obtener el producto: , ${skuId}, Status: ${result.status}`);
+                return [];
+            }
+        } else {
+            // La respuesta no fue exitosa
+            Logger.error(`Error al obtener el producto: , ${skuId}, Status: ${result.status}`);
+            return [];
+        }
+    } catch (error) {
+        Logger.error('Error al obtener el producto');
+        return [];
+    }
+}
+
+/**
+ * Obtiene el precio del vendedor para un SKU ID utilizando la API de VTEX.
+ *
+ * @param {string} accountName - Nombre de la cuenta de VTEX.
+ * @param {string} key - Clave de la aplicación.
+ * @param {string} token - Token de la aplicación.
+ * @param {string} skuId - ID del SKU.
+ * @returns {Promise<number>} - Promesa que resuelve con el precio del vendedor.
+ * @throws {Error} - Si ocurre un error al obtener el precio del vendedor.
+ */
+async function getSellerPrice(accountName, appKey, appToken, skuId) {
+    const url = `/pricing/prices/${skuId}`;
+
+    try {
+        const vtexApi = new VtexApi(accountName, appKey, appToken);
+        const response = await vtexApi.fetchApiURL(url, { method: 'GET' });
+        const priceData = response.data;
+        // Formatear la respuesta
+        const formattedPriceData = {
+            listPrice: priceData?.listPrice,
+            costPrice: priceData?.costPrice,
+            basePrice: priceData?.basePrice,
+            fixedPrices: priceData?.fixedPrices ?? []
+        };
+
+        return formattedPriceData;
+    } catch (error) {
+        Logger.error('Error al obtener el precio del vendedor', error);
+        return null;
+    }
+}
+
+/**
+ * Obtiene todos los skuIds asociados a un productId utilizando la API de VTEX.
+ *
+ * @param {string} accountName - Nombre de la cuenta de VTEX.
+ * @param {string} appKey - Clave de la aplicación.
+ * @param {string} appToken - Token de la aplicación.
+ * @param {string} productId - ID del producto.
+ * @returns {Promise<string[]>} - Promesa que resuelve con un arreglo de skuIds.
+ * @throws {Error} - Si ocurre un error al obtener los skuIds.
+ */
+async function getSkuIds(accountName, appKey, appToken, productId) {
+    const url = `/catalog_system/pub/products/variations/${productId}`;
+
+    try {
+        const vtexApi = new VtexApi(accountName, appKey, appToken);
+        const response = await vtexApi.fetch(url, { method: 'GET' });
+        const product = response.data;
+
+        const skuIds = product.skus.map(sku => ({
+            sku: sku.sku,
+            skuname: sku.skuname,
+            sellerId: sku.sellerId,
+            unitMultiplier: sku.unitMultiplier
+        }));
+
+        return skuIds;
+    } catch (error) {
+        Logger.error('Error al obtener los skuIds');
+        return [];
+    }
+}
+
+//////////////////// UPDATE AND DELETE PRICES ////////////////////
+
+/**
+ * Elimina el precio de un producto rechazado por su SKU ID utilizando la API de VTEX.
+ *
+ * @param {string} accountName - Nombre de la cuenta de VTEX.
+ * @param {string} key - Clave de la aplicación.
+ * @param {string} token - Token de la aplicación.
+ * @param {string} skuId - ID del SKU.
+ * @returns {Promise<Object>} - Promesa que resuelve con el objeto de respuesta de la API.
+ * @throws {Error} - Si ocurre un error al eliminar el precio.
+ */
+async function deletePriceByProductRejected(accountName, appKey, appToken, skuId) {
+    try {
+        const vtexApi = new VtexApi(accountName, appKey, appToken);
+        const url = `/pricing/prices/${skuId}`;
+        await vtexApi.fetchApiURL(url, { method: 'DELETE' });
+
+        return true;
+    } catch (error) {
+        Logger.error('Error al eliminar el precio:', error);
+        return false;
+    }
+}
+
+/**
+ * Actualiza el precio de un producto por su SKU ID utilizando la API de VTEX.
+ *
+ * @param {string} accountName - Nombre de la cuenta de VTEX.
+ * @param {string} key - Clave de la aplicación.
+ * @param {string} token - Token de la aplicación.
+ * @param {string} skuId - ID del SKU.
+ * @param {number} newPrice - Nuevo precio del producto.
+ * @returns {Promise<Object>} - Promesa que resuelve con el objeto de respuesta de la API.
+ * @throws {Error} - Si ocurre un error al actualizar el precio.
+ */
+async function updatePriceByProduct(accountName, appKey, appToken, skuId, pricesData, amount) {
+    try {
+        pricesData.listPrice = pricesData?.listPrice ? (parseFloat(pricesData?.listPrice) * parseFloat(amount)) : null;
+        pricesData.costPrice = pricesData?.costPrice ? (parseFloat(pricesData?.costPrice) * parseFloat(amount)) : null;
+        pricesData.basePrice = pricesData?.basePrice ? (parseFloat(pricesData?.basePrice) * parseFloat(amount)) : null;
+        pricesData.fixedPrices = pricesData?.fixedPrices?.length > 0 ? formatFixesPrice(pricesData?.fixedPrices, amount) : [];
+
+        const vtexApi = new VtexApi(accountName, appKey, appToken);
+        const url = `/pricing/prices/${skuId}`;
+        const response = await vtexApi.fetchApiURL(url, {
+            method: 'PUT',
+            data: pricesData
+        });
+
+        return response.data;
+    } catch (error) {
+        Logger.error('Error al actualizar el precio:', error);
+        return false;
+    }
+}
+
+/**
+ * Set prices fixed 
+ **/
+const formatFixesPrice = (fixedPrices, amount) => {
+
+    for (let i = 0; i < fixedPrices.length; i++) {
+        fixedPrices[i].value = (parseFloat(fixedPrices[i].value) * parseFloat(amount));
+
+        if (fixedPrices[i]?.listPrice) {
+            fixedPrices[i].listPrice = (parseFloat(fixedPrices[i].listPrice) * parseFloat(amount));
+        }
+    }
+
+    return fixedPrices;
+}
+
+/**
+ * Valida si un múltiplo es válido basándose en la cantidad de unidades.
+ *
+ * @param {number} multiplierFormat - Formato del múltiplo.
+ * @param {object} dataExternal - Información externa del producto.
+ * @param {boolean} exactUnit - Si se debe validar unidades exactas.
+ * @returns {boolean} - True si el múltiplo es válido, false en caso contrario.
+ */
+function validateMultiple(unitMultiplier, dataExternal, exactUnit = false, fomulaPresentacion = null) {
+    if (dataExternal?.isActive === false || dataExternal?.isActive == 0 || dataExternal?.isActive == '0') {
+        return false;
+    } else if (exactUnit === true && dataExternal?.boxUnit) {
+        if (fomulaPresentacion && fomulaPresentacion != '') {
+            let resValid = false;
+            try {
+                // response only boolean
+                eval(`resValid=${fomulaPresentacion}`);
+            } catch (err) {
+                Logger.error('Error formula', err);
+            }
+            return resValid;
+        } else {
+            return parseFloat(unitMultiplier) === parseFloat(dataExternal?.boxUnit) ? true : false;
+        }
+    } else if (dataExternal?.boxUnit) {
+        if (fomulaPresentacion && fomulaPresentacion != '') {
+            let resValid = false;
+            try {
+                // response only boolean
+                eval(`resValid=${fomulaPresentacion}`);
+            } catch (err) {
+                Logger.error('Error formula', err);
+            }
+            return resValid;
+        } else {
+            return parseFloat(unitMultiplier) % parseFloat(dataExternal?.boxUnit) == 0;
+        }
+    } else {
+        return false;
+    }
+}
+
+const handleExecute = async (accountName) => {
+    await AWSServices.sendSQSMessage(SQS_MULTIPRE_PRODUCT_QUEUE_URL, { accountName: accountName });
+}
+
+/**
+ * Función para iniciar el proceso manual de multi presentación.
+ *
+ * @param {object} event - Evento recibido que contiene la información necesaria para procesar la solicitud.
+ * @param {object} event.requestContext - Contexto de la solicitud que incluye información del autor.
+ * @param {object} event.requestContext.authorizer - Autor de la solicitud.
+ * @param {object} event.requestContext.authorizer.claims - Reclamaciones del autor.
+ * @param {string} event.requestContext.authorizer.claims.client_id - ID del cliente.
+ * @param {string} event.requestContext.authorizer.claims.scope - Alcance de la solicitud.
+ * @param {object} event.pathParameters - Parámetros de la ruta.
+ * @param {string} event.pathParameters.accountName - Nombre de la cuenta.
+ * @returns {Promise<object>} - Promesa que resuelve con un objeto de respuesta de la API.
+ *
+ **/
+const producer = async (event) => {
+    let statusCode = 200;
+    let message;
+
+    try {
+        const clientId = event?.requestContext?.authorizer?.claims?.client_id;
+        const scope = event?.requestContext?.authorizer?.claims?.scope;
+        const accountName = event?.pathParameters?.accountName ?? null;
+
+        if (!accountName) {
+            return errorResponse(404, "AccountName not found");
+        }
+        if (!scope.includes("admin")) {
+            const validateAccount = await ClientData.validateAccount(clientId, accountName);
+            if (!validateAccount) {
+                Logger.error("Account not found: ", accountName, ". ClientId: ", clientId);
+                return ApiResponse.response(404, "Account not found");
+            }
+        }
+
+        // Se ejecuta el proceso de insertar en la cola SQS los datos del proceso de Multipresentation a ejecutar
+        await handleExecute(accountName);
+
+        message = "Message accepted!";
+
+    } catch (error) {
+        Logger.error("Error clients producer: ", error);
+        statusCode = 500;
+    }
+
+    return ApiResponse.response(statusCode, message);
+};
+
+module.exports = {
+    setPresentationsSellers,
+    handleExecute,
+    producer
+};

package/src/functions/nodeflow/index.js

@@ -0,0 +1,83 @@
+
+const ApiResponse = require("../../common/utils/api-response");
+const nodeFlowPrivate = require("./nodeflow-pvt");
+const nodeFlowPublic = require("./nodeflow-pub");
+
+module.exports.handler= async (req,res)=>{
+  const resource= req?.resource ?? null;
+  const method= req?.httpMethod ? String(req?.httpMethod).toUpperCase() : null;
+
+  if(resource && method){
+    switch(resource){
+      case "/pvt/nodeflow/settings":
+          switch(method){
+            case "GET":
+              return await nodeFlowPrivate?.getSettings(req,res);
+            case "PATCH":
+              return await nodeFlowPrivate?.createSettings(req,res);
+            default: 
+              return ApiResponse.response(400, {error: "error method!."});
+          }
+        break;
+      case "/pvt/nodeflow/actionstype":
+          switch(method){
+            case "GET":
+              return await nodeFlowPrivate?.getActionsType(req,res);
+            case "PATCH":
+              return await nodeFlowPrivate?.createActionsType(req,res);
+            default: 
+              return ApiResponse.response(400, {error: "error method!."});
+          }
+        break;
+      case "/pvt/nodeflow/create":
+          switch(method){
+            case "PATCH":
+              return await nodeFlowPrivate?.createNodeFlow(req,res);
+            default: 
+              return ApiResponse.response(400, {error: "error method!."});
+          }
+        break;
+      case "/pvt/nodeflow/tree/{sources_id}":
+          switch(method){
+            case "GET":
+              return await nodeFlowPrivate?.treeNodeFlow(req,res);
+            default: 
+              return ApiResponse.response(400, {error: "error method!."});
+          }
+        break;
+      case "/pvt/nodeflow/sources":
+          switch(method){
+            case "GET":
+              return await nodeFlowPrivate?.getSources(req,res);
+            case "PATCH":
+              return await nodeFlowPrivate?.createSources(req,res);
+            case "DELETE":
+              return await nodeFlowPrivate?.deleteSources(req,res);
+            default: 
+              return ApiResponse.response(400, {error: "error method!."});
+          }
+        break;
+      // routes publics
+      case "/pub/nodeflow/{sourceName}":
+          switch(method){
+            case "POST":
+              return await nodeFlowPublic?.handler(req,res);
+            default: 
+              return ApiResponse.response(400, {error: "error method!."});
+          }
+        break;
+      case "/pub/sqs/nodeflow/{sourceName}":
+          switch(method){
+            case "POST":
+              return await nodeFlowPublic?.handlerSqs(req,res);
+            default: 
+              return ApiResponse.response(400, {error: "error method!."});
+          }
+        break;  
+      default:
+        return ApiResponse.response(400, {error: "error resource!."}); 
+    }
+  }else{
+    return ApiResponse.response(400, {error: "error resource!."});
+  }  
+}