dcos-core-monalisav2-latam 1.0.0

package/src/functions/inventory/inventory-producer.js

@@ -0,0 +1,197 @@
+const ApiResponse = require("../../common/utils/api-response");
+const AWSServices = require("../../common/utils/aws-services");
+const ClientData = require("../../entities/clients");
+const AccountData = require("../../entities/account");
+const SkuData = require("../../entities/sku");
+const Constants = require("../../common/utils/constants");
+const DistributorData = require("../distributors/distributor");
+const LIMIT_ITEMS_TO_PROCESS = process?.env?.LIMIT_ITEMS_TO_PROCESS || 150;
+const SQS_INVENTORY_QUEUE_URL = process?.env?.SQS_INVENTORY_QUEUE_URL;
+const Logger = require("../../common/utils/logger");
+
+/**
+ *
+ * @param {import("aws-lambda").APIGatewayProxyEvent} event
+ * @returns
+ */
+const producer = async (event) => {
+  let statusCode = 200;
+  let message;
+
+  if (!event.body) {
+    return ApiResponse.response(400, "No body was found");
+  }
+
+  const clientId = event?.requestContext?.authorizer?.claims?.client_id;
+  Logger.log(JSON.stringify(JSON.parse(event.body)), clientId);
+
+  try {
+    const request = validateRequestBody(JSON.parse(event.body));
+    const scope = event?.requestContext?.authorizer?.claims?.scope;
+    const accountName = request?.an;
+    const inventory = request?.inventory;
+
+    if (!inventory || inventory?.length > LIMIT_ITEMS_TO_PROCESS) {
+      Logger.error("Inventory QTY INVALID: ", inventory?.length);
+      return ApiResponse.response(404, "Inventory limit of items exceeded");
+    }
+
+    if (!event?.internalService) {
+      if (!scope?.includes("admin")) {
+        const isValid = await ClientData.validateAccount(clientId, accountName);
+        if (!isValid) {
+          Logger.error("Account not found: ", accountName, ". ClientId: ", clientId);
+          return ApiResponse.response(404, "Account not found");
+        }
+      }
+    }
+    const account = event?.accountData && event?.internalService === true ? event?.accountData : await AccountData.getAccountDataByAccountName(accountName);
+    Logger.setAccount(account);
+    if (!account) {
+      Logger.error("Account not found: ", accountName, ". ClientId: ", clientId);
+      return ApiResponse.response(404, "Account not found");
+    }
+
+    Logger.debug("JSON account: ", JSON.stringify(account));
+    const allWarehouses = Object.values(account?.ChannelWarehouse);
+    const warehouse = request?.warehouse;
+    Logger.debug("Warehouse: ", warehouse);
+    Logger.debug("count: ", allWarehouses.length);
+    Logger.debug("if: ", allWarehouses.length < 1);
+
+    if (allWarehouses.length < 1) {
+      Logger.error("Warehouse INVALID: ", warehouse);
+      return ApiResponse.response(404, "Warehouse not found");
+    }
+
+    var warehouseExists = allWarehouses[0];
+    if (warehouse && warehouse !== "") {
+      warehouseExists = account?.ChannelWarehouse?.[warehouse];
+      if (!warehouseExists) {
+        Logger.error("Warehouse INVALID: ", warehouse);
+        return ApiResponse.response(404, "Warehouse not found");
+      }
+    }
+
+    let skuRefUsed = account?.SkuRefUsed;
+    if (typeof skuRefUsed !== "boolean") {
+      Logger.warn("Sku or ReferenceCode filter not defined, use default: ", skuRefUsed);
+      skuRefUsed = true;
+    }
+
+    const safetyStockType = account?.SafetyStockType || Constants.SAFETY_STOCK_TYPE_NOMINAL;
+    const safetyStock = account?.SafetyStock || 0;
+
+    var notProcessed = [];
+
+    for (let item of inventory) {
+      try {
+        let notFoundByEan = false;
+        let skuData = null;
+        //Si esta activado el manejo de sku por código de distribuidor 
+        try {
+          const skuDistributorManagement = account?.SkuDistributorManagement || false;
+          item.sku = await DistributorData.getDistributorByErpCode(accountName, item?.sku, skuDistributorManagement);
+        } catch (error) {
+          Logger.error("Error al obtener distribuidor por sku:", error);
+        }
+        if (skuRefUsed) {
+          skuData = account?.ValidateSkuPriceInventoryInProcess === true ? { SkuId: item?.sku } : await SkuData.getSkuByParentAccountNameAndSku(account?.ParentAccountName, item?.sku);
+        } else {
+          skuData = account?.ValidateSkuPriceInventoryInProcess === true ? [{ SkuId: item?.sku }] : await SkuData.getSkuByParentAccountNameAndEan(account?.ParentAccountName, item?.sku);
+          if (!skuData || skuData.length < 1) {
+            Logger.debug("Not found by Ean: ", skuData);
+            notFoundByEan = true;
+          } else {
+            skuData = skuData?.[0];
+          }
+        }
+        Logger.debug("SKU Data: ", skuData, ". SKU Ref Used: ", skuRefUsed);
+        if ((!skuData || !skuData?.SkuId) && !notFoundByEan) {
+          Logger.debug("SKU Data INVALID: ", skuData);
+          item.message = "SKU not found";
+          notProcessed.push(item);
+        } else if (notFoundByEan && !skuRefUsed) {
+          Logger.debug("SKU Data INVALID: ", skuData);
+          item.message = "SKU not found by Ean";
+          notProcessed.push(item);
+        } else {
+          let quantityCustom = 0;
+          if (item?.quantity >= 0) {
+            if (safetyStockType === Constants.SAFETY_STOCK_TYPE_NOMINAL) {
+              quantityCustom = item?.quantity - safetyStock;
+            } else if (safetyStockType === Constants.SAFETY_STOCK_TYPE_PERCENTAGE) {
+              quantityCustom = Math.floor((item?.quantity * (100 - safetyStock)) / 100);
+            }
+            if (quantityCustom < 0) {
+              quantityCustom = 0;
+            }
+            const dataSend = {
+              an: accountName,
+              skuRefId: item.sku,
+              hoursValidStockPrice: account?.HoursValidStockPrice ?? 24,
+              ValidateSkuPriceInventoryInProcess: account?.ValidateSkuPriceInventoryInProcess ?? false,
+              ParentAccountName: account?.ParentAccountName,
+              SkuRefUsed: skuRefUsed,
+              key: account?.Credentials?.key,
+              token: account?.Credentials?.token,
+              warehouse: warehouseExists,
+              sku: skuData?.SkuId,
+              quantity: quantityCustom,
+              accountConfig: account,
+              individualUnits: typeof item?.individualUnits === "number" ? item.individualUnits : 1
+            };
+            await AWSServices.sendSQSMessage(SQS_INVENTORY_QUEUE_URL, dataSend);
+          } else {
+            Logger.debug("Quantity INVALID: ", item?.quantity);
+            item.message = "Quantity invalid";
+            notProcessed.push(item);
+          }
+        }
+      } catch (error) {
+        Logger.debug(error);
+        item.message = error.message;
+        notProcessed.push(item);
+      }
+    }
+    if (notProcessed.length > 0) {
+      Logger.debug("Not Processed: ", notProcessed);
+      const message = {
+        message: "Not all items were processed.",
+        notProcessedItems: notProcessed,
+      };
+      return ApiResponse.response(207, message);
+    }
+    message = "Message accepted!";
+  } catch (error) {
+    Logger.error(error);
+    message = error;
+    statusCode = 500;
+  }
+  return ApiResponse.response(statusCode, message);
+};
+
+function validateRequestBody(body) {
+  if (!body) {
+    throw new Error("El cuerpo de la solicitud es nulo o no está definido.");
+  }
+
+  const { an, warehouse, inventory } = body;
+
+  if (typeof an !== "string" || typeof warehouse !== "string" || !Array.isArray(inventory)) {
+    throw new Error("El cuerpo de la solicitud no tiene el formato esperado.");
+  }
+
+  const invalidInventoryItem = inventory.find((item) => {
+    return typeof item.sku !== "string" || typeof item.quantity !== "number";
+  });
+
+  if (invalidInventoryItem) {
+    throw new Error("El cuerpo de la solicitud no tiene el formato esperado.");
+  }
+  return body;
+}
+
+module.exports = {
+  producer,
+};

package/src/functions/multiPresentation/multipre-queue.js

@@ -0,0 +1,155 @@
+const ProductMultiPresentation = require("../../integrations/productmultipresentation/ProductMultiPresentation");
+const SkuData = require("../../entities/sku");
+const AWSServices = require("../../common/utils/aws-services");
+const AccountData = require("../../entities/account");
+const InventoryData = require("./multipres");
+const Logger = require("../../common/utils/logger");
+
+const SQS_MULTIPRE_PRODUCT_QUEUE_URL = process?.env?.SQS_MULTIPRE_PRODUCT_QUEUE_URL;
+const SQS_MULTIPRECOM_PRODUCT_QUEUE_URL = process?.env?.SQS_MULTIPRECOM_PRODUCT_QUEUE_URL;
+
+/**
+ * Handles the event triggered by the Lambda function.
+ *
+ * @param {Object} event - The event object containing the request details.
+ * @param {Array<Object>} event.Records - List of records from the event.
+ * @param {Object} event.Records[].body - The body of the record containing the message.
+ * @returns {Promise<boolean>} - A promise that resolves to a boolean indicating success or failure.
+ * @throws {Error} - If an error occurs during the execution.
+ */
+module.exports.handler= async (event)=>{
+    for (const record of event.Records) {
+        Logger.debug("Message Body: ", record.body);
+        const body = JSON.parse(record.body);
+        if (body) {
+            const accountName = body?.accountName;
+            const account = await AccountData.getAccountDataByAccountName(accountName);
+            const accountParent = await AccountData.getAccountDataByAccountName(account?.ParentAccountName);
+            Logger.setAccount(account);
+            if (!account || !accountParent) {
+                Logger.error("Account not found: ", accountName);
+                return false;
+            }
+            Logger.debug("JSON account: ", account);
+
+            try {
+                if (account?.ProductMultiPresentation && account?.ProductMultiPresentation?.isActive) {
+                    const geoSalesApi = new ProductMultiPresentation(
+                        accountParent.ParentAccountName,
+                        accountParent.Credentials.key,
+                        accountParent.Credentials.token,
+                        accountParent.AcronymDistributorVtex,
+                        account.ProductMultiPresentation
+                    );
+
+                    // Obtener la lista de productos de GeoSales
+                    const geoSalesProductList = await geoSalesApi.getProductList();
+                    const vtexProductList = await geoSalesApi.getAllProductsVTEX(); 
+                    const listProductProccess = getListProductProcess(geoSalesProductList, vtexProductList);
+                    const skuRefUsed = account?.SkuRefUsed ?? true;
+
+                    // Procesar la lista de productos de GeoSales
+                    for (const geoSalesProduct of listProductProccess) {
+                        try {
+                            // Verifica si el producto existe en DynamoDB
+                            if(account?.ProductMultiPresentation?.WhiteListProductId?.length === 0 || account?.ProductMultiPresentation?.WhiteListProductId?.includes(geoSalesProduct.productId)){
+                                if (geoSalesProduct && geoSalesProduct.itemId) {
+                                    // Envía el producto válido a la cola SQS
+                                    await AWSServices.sendSQSMessage(SQS_MULTIPRECOM_PRODUCT_QUEUE_URL, {
+                                        account: account,
+                                        SkuId: geoSalesProduct.itemId,
+                                        geoSalesProduct: geoSalesProduct, 
+                                        TradePolicyId: geoSalesProduct?.TradePolicyId
+                                    });
+                                    Logger.debug("Producto encontrado en DynamoDB y en procesamiento.", geoSalesProduct);
+                                } else {
+                                    Logger.debug("Producto no encontrado en DynamoDB: ", geoSalesProduct, 'skuData', skuData);
+                                }
+                            }
+                        } catch (error) {
+                            Logger.error("Error al procesar el producto de GeoSales: ", error);
+                        }
+                    }
+                }
+            } catch (error) {
+                Logger.error(error);
+            }     
+        }
+    }
+}
+
+/**
+ * Get the list of products to process by comparing external and VTEX lists.
+ *
+ * @param {Array<Object>} listExternal - List of products from the external system.
+ * @param {Array<Object>} listVtex - List of products from VTEX.
+ * @returns {Array<Object>} - A list of products to process.
+ */
+const getListProductProcess = (listExternal, listVtex)=>{
+    let listProcess= [];
+    let idsSku= [];
+
+    try{
+        for (var i = 0; i < listVtex.length; i++) {
+            let registerExternal= listExternal.find(it=>(it?.sku == listVtex[i]?.referenceId[0]?.Value || it?.sku == listVtex[i]?.ean));
+            if (registerExternal) {
+                if (!idsSku.includes(listVtex[i]?.itemId)) {
+                    idsSku.push(listVtex[i]?.itemId);
+                    listProcess.push({
+                        boxUnit: registerExternal?.boxUnit,
+                        infoUnit: registerExternal?.infoUnit,
+                        is_active: registerExternal?.is_active,
+                        sku: registerExternal?.sku,
+                        quantity_pmp: registerExternal?.quantity_pmp,
+                        itemId: listVtex[i]?.itemId, 
+                        productId: listVtex[i]?.productId, 
+                        TradePolicyId:listVtex[i]?.TradePolicyId
+                    });
+                }
+            }
+        }
+    } catch (error){
+        Logger.error("getListProductProcess", error);
+    }  
+
+    return listProcess;  
+};
+
+
+/**
+ * Complete the product presentation process.
+ *
+ * @param {Object} event - The event object containing the request details.
+ * @param {Array<Object>} event.Records - List of records from the event.
+ * @param {Object} event.Records[].body - The body of the record containing the message.
+ * @returns {Promise<boolean>} - A promise that resolves to a boolean indicating success or failure.
+ * @throws {Error} - If an error occurs during the execution.
+ */
+module.exports.completeProductPresentation= async (event)=>{
+    for (const record of event.Records) {
+        const body = JSON.parse(record.body);
+        if (body) {
+            const account = body?.account;
+            Logger.setAccount(account);
+            const SkuId = body?.SkuId;
+            const geoSalesProduct = body?.geoSalesProduct;
+            const TradePolicyId = body?.TradePolicyId;
+
+            if (!account || !SkuId || !geoSalesProduct) {
+                Logger.error("account or SkuId or geoSalesProduct  not found: ", body);
+                return false;
+            }
+            Logger.debug("JSON account: ", account);
+
+            try {
+                await InventoryData.setPresentationsSellers(account, SkuId, geoSalesProduct, TradePolicyId)
+                Logger.debug("process multi presentation complete");
+                return true;
+            } catch (error) {
+                Logger.error("process multi presentation error", error);
+                return false;
+            }     
+        }
+    }
+
+}