dcos-core-monalisav2-latam 1.0.0

package/src/functions/sftp/sftp-consumer.js

@@ -0,0 +1,453 @@
+"use strict";
+const AWS = require("aws-sdk");
+const s3 = new AWS.S3();
+const MdlzApi = require("../../mdlz/client/MdlzApi");
+const AuthSecurity = require("../../common/utils/AuthSecurity");
+const MondelezClientsItemsCast = require("../../common/utils/convert/MondelezClientsItemsCast");
+const MondelezInventoryItemsCast = require("../../common/utils/convert/MondelezInventoryItemsCast");
+const MondelezPricesItemsCast = require("../../common/utils/convert/MondelezPricesItemsCast");
+const MondelezOrderStatusItemsCast = require("../../common/utils/convert/MondelezOrderStatusCast");
+const SftpInbound = require("../../entities/sftp-inbound");
+const Constants = require("../../common/utils/constants");
+const AWSServices = require("../../common/utils/aws-services");
+const path = require("path");
+const csv = require("csv-parser");
+const Logger = require("../../common/utils/logger");
+
+const MAX_ITEMS_PROCESS_INVENTORY = process.env.MAX_ITEMS_PROCESS_INVENTORY;
+const MAX_ITEMS_PROCESS_PRICES = process.env.MAX_ITEMS_PROCESS_PRICES;
+const MAX_ITEMS_PROCESS_CLIENTS = process.env.MAX_ITEMS_PROCESS_CLIENTS;
+let AUTHORIZATION_MANAGER_KEY = process.env.AUTHORIZATION_MANAGER_KEY;
+
+module.exports.sftp = async (event) => {
+  Logger.debug("sftp-payload-request: ", event.Records);
+
+  for (const record of event.Records) {
+    const bucket = record.s3.bucket.name; //DO FOR EACH RECORD
+    const key = record.s3.object.key;
+    const inProcessKey = key
+      .replace(Constants.SFTP_STATUS_PENDING, Constants.SFTP_STATUS_IN_PROCESS)
+      .replace(Constants.SFTP_CSV_FILE_TYPE, Constants.SFTP_TXT_FILE_TYPE);
+    const newKey = key
+      .replace(Constants.SFTP_STATUS_PENDING, Constants.SFTP_STATUS_PROCESSED)
+      .replace(
+        Constants.SFTP_CSV_FILE_TYPE,
+        new Date().toISOString().slice(0, 19).replace(/-/g, "").replace("T", "").replace(/:/g, "")
+      )
+      .concat(Constants.SFTP_TXT_FILE_TYPE);
+    const logDirectory = newKey
+      .replace(Constants.SFTP_STATUS_PROCESSED, Constants.SFTP_LOG)
+      .replace(Constants.SFTP_TXT_FILE_TYPE, Constants.SFTP_LOG_FILE_TYPE);
+    var logData = [];
+
+    try {
+      const params = {
+        Bucket: bucket,
+        Key: key,
+      };
+
+      const inProcessParams = {
+        Bucket: bucket,
+        Key: `${inProcessKey}`,
+        CopySource: `${bucket}/${key}`,
+        ContentType: "application/json; charset=utf-8",
+      };
+      if (key.includes(Constants.SFTP_STATUS_PENDING)) {
+        const pathDirectory = path.dirname(key);
+        const sftpConfig = await SftpInbound.getItemsByDirectory(pathDirectory);
+        const data = await s3.getObject(params).promise();
+        await s3.copyObject(inProcessParams).promise();
+        await s3.deleteObject(params).promise();
+
+        if (!sftpConfig) {
+          const errorSftpMessage = "SFTP config not found: directory= " + key + ". ProcessExecute = not found";
+          Logger.error(errorSftpMessage);
+          logData.push(new Date().toISOString() + " -   ERROR - " + errorSftpMessage);
+          throw new Error(errorSftpMessage);
+        } else if (sftpConfig.length > 1) {
+          const errorSftpMessage =
+            "SFTP config duplicated: directory= " + key + ". ProcessExecute = " + sftpConfig[0].processExecute;
+            Logger.error("Duplicated error: " + errorSftpMessage, ". All SFTP config: ", sftpConfig);
+          logData.push(new Date().toISOString() + " -   ERROR - " + errorSftpMessage);
+          throw new Error(errorSftpMessage);
+        }
+        const csvData = data.Body.toString("utf-8");
+        if (!AUTHORIZATION_MANAGER_KEY) {
+          const errorAuthSftpMessage = "SFTP profile authorization not found";
+          Logger.error(errorAuthSftpMessage);
+          logData.push(new Date().toISOString() + " -   ERROR - " + errorAuthSftpMessage);
+          return;
+        }
+
+        let authSecret = await AWSServices.getSecretValue(AUTHORIZATION_MANAGER_KEY);
+
+        authSecret = JSON.parse(authSecret);
+
+        const APP_KEY_HEADER = authSecret?.appKey;
+        const APP_TOKEN_HEADER = authSecret?.appSecret;
+        const SCOPE_ADMIN_HEADER = authSecret?.scope;
+        const GRANT_TYPE_HEADER = authSecret?.grantType;
+
+        if (!APP_KEY_HEADER || !APP_TOKEN_HEADER || !SCOPE_ADMIN_HEADER || !GRANT_TYPE_HEADER) {
+          Logger.error({
+            "SFTP master profile authorization params not found: appKey= ":
+            APP_KEY_HEADER,
+            ". appSecret = ":
+            APP_TOKEN_HEADER,
+            ". scope = ":
+            SCOPE_ADMIN_HEADER,
+            ". grantType = ":
+            GRANT_TYPE_HEADER
+          });
+          logData.push(new Date().toISOString() + " -   ERROR - SFTP master profile authorization params not found.\n");
+          return;
+        }
+
+        const parsedData = await parseCSV(csvData);
+        const apiAuthSecurity = new AuthSecurity(
+          APP_KEY_HEADER,
+          APP_TOKEN_HEADER,
+          GRANT_TYPE_HEADER,
+          SCOPE_ADMIN_HEADER
+        );
+        const responseAuth = await apiAuthSecurity.fetchAuthToken("", {
+          method: "POST",
+        });
+
+        if (responseAuth.status >= 200 && responseAuth.status < 300) {
+          const { AccountName, ProcessExecute } = sftpConfig[0];
+          const { access_token } = responseAuth?.data;
+          const apiMdlzClient = new MdlzApi(`Bearer ${access_token}`, GRANT_TYPE_HEADER, SCOPE_ADMIN_HEADER);
+          if (ProcessExecute === Constants.SFTP_PROCESS_STATUS) {
+            if (parsedData) {
+              for (let item of parsedData) {
+                const orderId = item.orderId;
+                const dataStatusCasted = MondelezOrderStatusItemsCast.orderStatusItemsCSVToJson(item);
+                const responseMdlz = await apiMdlzClient.fetch(`orders/status/${orderId}`, {
+                  method: "POST",
+                  data: dataStatusCasted,
+                });
+                if (responseMdlz.status >= 200 && responseMdlz.status < 300) {
+                  const successMdlzMessage =
+                    "Process order status was successfully: " +
+                    orderId +
+                    ". Response: " +
+                    JSON.stringify(responseMdlz.data);
+                  logData.push(new Date().toISOString() + " - INFO - " + successMdlzMessage);
+                } else {
+                  const errorMdlzMessage =
+                    "Error while requesting MDLZ order status for: " +
+                    orderId +
+                    ". With body: " +
+                    JSON.stringify(dataStatusCasted) +
+                    ". Status: " +
+                    responseMdlz.status +
+                    ". Response: " +
+                    JSON.stringify(responseMdlz.data);
+                    Logger.error(errorMdlzMessage);
+                  logData.push(new Date().toISOString() + " -   ERROR - " + errorMdlzMessage);
+                }
+              }
+            }
+          } else if (ProcessExecute === Constants.SFTP_PROCESS_CANCEL) {
+            if (parsedData) {
+              for (let item of parsedData) {
+                const orderId = item.orderId;
+                const responseMdlz = await apiMdlzClient.fetch(`orders/cancel/${orderId}`, {
+                  method: "POST",
+                });
+                if (responseMdlz.status >= 200 && responseMdlz.status < 300) {
+                  const successMdlzMessage =
+                    "Process order cancel was successfully: " +
+                    orderId +
+                    ". Response: " +
+                    JSON.stringify(responseMdlz.data);
+                  logData.push(new Date().toISOString() + " - INFO - " + successMdlzMessage);
+                } else {
+                  const errorMdlzMessage =
+                    "Error while requesting MDLZ order cancel for: " +
+                    orderId +
+                    ". Status: " +
+                    responseMdlz.status +
+                    ". Response: " +
+                    JSON.stringify(responseMdlz.data);
+                    Logger.error(errorMdlzMessage);
+                  logData.push(new Date().toISOString() + " -   ERROR - " + errorMdlzMessage);
+                }
+              }
+            }
+          } else if (ProcessExecute === Constants.SFTP_PROCESS_INVENTORY) {
+            if (parsedData) {
+              let warehouse = "";
+              if (sftpConfig[0]?.Warehouse) {
+                warehouse = sftpConfig[0].Warehouse;
+              }
+              let hasCount = parsedData.length > MAX_ITEMS_PROCESS_INVENTORY;
+              let count = 1;
+              let dataToSend = [];
+              let dataProcessed = [];
+              for (let item of parsedData) {
+                let itemInventoryCasted = MondelezInventoryItemsCast.inventoryItemsCSVToJson(item);
+                dataProcessed.push(itemInventoryCasted);
+                if (hasCount) {
+                  count += 1;
+                }
+                if (hasCount && count >= MAX_ITEMS_PROCESS_INVENTORY) {
+                  dataToSend.push(dataProcessed);
+                  dataProcessed = [];
+                  count = 0;
+                }
+              }
+              if (dataProcessed.length > 0) {
+                dataToSend.push(dataProcessed);
+              }
+              for (let dataInventory of dataToSend) {
+                const dataInventoryValues = {
+                  an: AccountName,
+                  warehouse: warehouse,
+                  inventory: dataInventory,
+                };
+                const responseMdlz = await apiMdlzClient.fetch("inventory", {
+                  method: "POST",
+                  data: dataInventoryValues,
+                });
+                if (responseMdlz.status >= 200 && responseMdlz.status < 300) {
+                  const successMdlzMessage =
+                    "Process inventory was successfully. " +
+                    ". Status: " +
+                    responseMdlz.status +
+                    ". Response: " +
+                    JSON.stringify(responseMdlz.data);
+                  logData.push(new Date().toISOString() + " - INFO - " + successMdlzMessage);
+                } else {
+                  const errorMdlzMessage =
+                    "Error while requesting MDLZ inventory for: " +
+                    JSON.stringify(dataInventoryValues) +
+                    ". Status: " +
+                    responseMdlz.status +
+                    ". Response: " +
+                    JSON.stringify(responseMdlz.data);
+                    Logger.error(errorMdlzMessage);
+                  logData.push(new Date().toISOString() + " -   ERROR - " + errorMdlzMessage);
+                }
+              }
+            }
+          } else if (ProcessExecute === Constants.SFTP_PROCESS_PRICES) {
+            if (parsedData) {
+              let hasCount = parsedData.length > MAX_ITEMS_PROCESS_PRICES;
+              let count = 1;
+              let dataToSend = [];
+              let dataProcessed = [];
+              for (let item of parsedData) {
+                let itemPricesCasted = MondelezPricesItemsCast.pricesItemsCSVToJson(item);
+                dataProcessed.push(itemPricesCasted);
+                if (hasCount) {
+                  count += 1;
+                }
+                if (hasCount && count >= MAX_ITEMS_PROCESS_PRICES) {
+                  dataToSend.push(dataProcessed);
+                  dataProcessed = [];
+                  count = 0;
+                }
+              }
+              if (dataProcessed.length > 0) {
+                dataToSend.push(dataProcessed);
+              }
+              for (let dataPrices of dataToSend) {
+                const dataPricesValues = {
+                  an: AccountName,
+                  prices: dataPrices,
+                };
+                const responseMdlz = await apiMdlzClient.fetch("prices", {
+                  method: "POST",
+                  data: dataPricesValues,
+                });
+                if (responseMdlz.status >= 200 && responseMdlz.status < 300) {
+                  const successMdlzMessage =
+                    "Process prices was successfully. " +
+                    ". Status: " +
+                    responseMdlz.status +
+                    ". Response: " +
+                    JSON.stringify(responseMdlz.data);
+                  logData.push(new Date().toISOString() + " - INFO - " + successMdlzMessage);
+                } else {
+                  const errorMdlzMessage =
+                    "Error while requesting MDLZ prices for: " +
+                    JSON.stringify(dataPricesValues) +
+                    ". Status: " +
+                    responseMdlz.status +
+                    ". Response: " +
+                    JSON.stringify(responseMdlz.data);
+                    Logger.error(errorMdlzMessage);
+                  logData.push(new Date().toISOString() + " -   ERROR - " + errorMdlzMessage);
+                }
+              }
+            }
+          } else if (ProcessExecute === Constants.SFTP_PROCESS_CLIENTS) {
+            if (parsedData) {
+              let hasCount = parsedData.length > MAX_ITEMS_PROCESS_CLIENTS;
+              let count = 1;
+              let dataToSend = [];
+              let dataProcessed = [];
+              for (let item of parsedData) {
+                let itemClientCasted = MondelezClientsItemsCast.clientsItemsCSVToJson(item);
+                dataProcessed.push(itemClientCasted);
+                if (hasCount) {
+                  count += 1;
+                }
+                if (hasCount && count >= MAX_ITEMS_PROCESS_CLIENTS) {
+                  dataToSend.push(dataProcessed);
+                  dataProcessed = [];
+                  count = 0;
+                }
+              }
+              if (dataProcessed.length > 0) {
+                dataToSend.push(dataProcessed);
+              }
+              for (let dataClients of dataToSend) {
+                const dataClientsValues = {
+                  an: AccountName,
+                  clients: dataClients,
+                };
+                const responseMdlz = await apiMdlzClient.fetch("clients", {
+                  method: "POST",
+                  data: dataClientsValues,
+                });
+                if (responseMdlz.status >= 200 && responseMdlz.status < 300) {
+                  const successMdlzMessage =
+                    "Process clients was successfully. " +
+                    ". Status: " +
+                    responseMdlz.status +
+                    ". Response: " +
+                    JSON.stringify(responseMdlz.data);
+                  logData.push(new Date().toISOString() + " - INFO - " + successMdlzMessage);
+                } else {
+                  const errorMdlzMessage =
+                    "Error while requesting MDLZ clients for: " +
+                    JSON.stringify(dataClientsValues) +
+                    ". Status: " +
+                    responseMdlz.status +
+                    ". Response: " +
+                    JSON.stringify(responseMdlz.data);
+                    Logger.error(errorMdlzMessage);
+                  logData.push(new Date().toISOString() + " -   ERROR - " + errorMdlzMessage);
+                }
+              }
+            }
+          } else {
+            const errorProcessMessage = "Process not found: " + ProcessExecute + ". Check the process configs.";
+            Logger.error(errorProcessMessage);
+            logData.push(new Date().toISOString() + " -   ERROR - " + errorProcessMessage);
+          }
+        } else {
+          Logger.error("Error while requesting authorization");
+          logData.push(new Date().toISOString() + " -   ERROR - " + "Error while requesting authorization.");
+        }
+      }
+    } catch (error) {
+      Logger.error("Error process data: ", error);
+      logData.push(new Date().toISOString() + " - ERROR - " + error);
+    } finally {
+      const params = {
+        Bucket: bucket,
+        Key: inProcessKey,
+      };
+      const newParams = {
+        Bucket: bucket,
+        Key: `${newKey}`,
+        CopySource: `${bucket}/${inProcessKey}`,
+        ContentType: "application/json; charset=utf-8",
+      };
+      let logAllData = "";
+      for (let line of logData) {
+        logAllData += line + "\n";
+      }
+      const logParams = {
+        Bucket: bucket,
+        Key: logDirectory,
+        Body: logAllData,
+      };
+      try {
+        await s3.copyObject(newParams).promise();
+        await s3.deleteObject(params).promise();
+        await s3.putObject(logParams).promise();
+      } catch (error) {
+        Logger.error("Error while copying and deleting object. ", error);
+      }
+    }
+  }
+};
+
+function parseCSV(csvData) {
+  let isEvalOnFirst = false;
+  let fixedPricesProperty = "";
+  let changesItemsRemovedProperty = "";
+  return new Promise((resolve, reject) => {
+    const results = [];
+    const stream = csv({ header: true, separator: ";" })
+      .on("data", (data) => {
+        if (data) {
+          if (!isEvalOnFirst) {
+            fixedPricesProperty = Object.keys(data).find((key) => key.startsWith("fixedPrices"));
+            changesItemsRemovedProperty = Object.keys(data).find((key) => key.startsWith("changesItemsRemoved"));
+            isEvalOnFirst = true;
+          }
+          if (fixedPricesProperty) {
+            // Convert the field "fixedPrices" in an array of objects
+            const fixedPricesValue = data[fixedPricesProperty];
+            const fixedPricesArray = fixedPricesValue
+              .split("|")
+              .filter(Boolean)
+              .map((item) => {
+                let [listId, value, listPrice, minQuantity, dateRangeFrom, dateRangeTo] = item.split(",");
+                // if some of the values listId, value, listPrice, minQuantity, dateRangeFrom, dateRangeTo are empty, set them to null
+                listId = listId || null;
+                value = value || null;
+                listPrice = listPrice || null;
+                minQuantity = minQuantity || null;
+                dateRangeFrom = dateRangeFrom || null;
+                dateRangeTo = dateRangeTo || null;
+                return {
+                  listId,
+                  value,
+                  listPrice,
+                  minQuantity,
+                  dateRangeFrom,
+                  dateRangeTo,
+                };
+              });
+            // Replace the field "fixedPrices" with the new array of objects
+            data.fixedPrices = fixedPricesArray;
+            delete data[fixedPricesProperty];
+          }
+          if (changesItemsRemovedProperty) {
+            // Convert the field "changesItemsRemoved" in an array of objects
+            const changesItemsRemovedValue = data[changesItemsRemovedProperty];
+            const changesItemsRemovedArray = changesItemsRemovedValue
+              .split("|")
+              .filter(Boolean)
+              .map((item) => {
+                let [changesItemsRemovedSku, changesItemsRemovedPrice, changesItemsRemovedQuantity] = item.split(",");
+                // if some of the values changesItemsRemovedSku, changesItemsRemovedPrice, changesItemsRemovedQuantity are empty, set them to null
+                changesItemsRemovedSku = changesItemsRemovedSku || null;
+                changesItemsRemovedPrice = changesItemsRemovedPrice || null;
+                changesItemsRemovedQuantity = changesItemsRemovedQuantity || null;
+                return {
+                  changesItemsRemovedSku,
+                  changesItemsRemovedPrice,
+                  changesItemsRemovedQuantity,
+                };
+              });
+            // Replace the field "changesItemsRemoved" with the new array of objects
+            data.changesItemsRemoved = changesItemsRemovedArray;
+            delete data[changesItemsRemovedProperty];
+          }
+          results.push(data);
+        }
+      })
+      .on("end", () => resolve(results))
+      .on("error", (error) => reject(error));
+    stream.write(csvData);
+    stream.end();
+  });
+}

package/src/functions/sftpIntegrations/processes/redirectServices.js

@@ -0,0 +1,184 @@
+const { producer: producerPrices } = require('../../prices/prices-producer.js');
+const { producer: producerInventory } = require('../../inventory/inventory-producer.js');
+const { producer: producerClients } = require('../../clients/clients-producer.js');
+const { cancel: orderCancel } = require('../../orders/orders-cancel-handler.js');
+const { splitData } = require('../utils/split-data.js')
+
+const Logger = require("../../../common/utils/logger");
+
+class ServicesRedirect {
+  constructor(accountConfig) {
+    this.config = accountConfig;
+    const { AccountName = '' } = this.config;
+  }
+
+  async initSendData({ typeProcess, data }) {
+    try {
+      switch (typeProcess) {
+        case 'clients':
+          return await this.sendDataClients(data)
+        case 'price':
+          return await this.sendDataPrices(data)
+        case 'stock':
+          return await this.sendDataStock(data)
+        case 'order-status':
+          return await this.sendDataOrderStatus(data)
+        case 'order-cancel':
+          return await this.sendDataOrderCancel(data)
+        default:
+          throw new Error(`Unsupported typeProcess: ${typeProcess}`)
+      }
+    } catch (error) {
+      Logger.error('Error in initSendData:', error.message)
+      throw error
+    }
+  }
+
+  async sendDataClients(data) {
+    if (!data) return false
+
+    try {
+      const event = {
+        internalService: true,
+        accountData: this.config,
+        body: JSON.stringify({
+          an: this.config?.AccountName,
+          clients: [data],
+        })
+      }
+      const response = await producerClients(event);
+
+      if (response.statusCode >= 200 && response.statusCode < 300) {
+        return true;
+      } else {
+        Logger.error('Failed to send data via producer:', response);
+        return false;
+      }
+      
+    } catch (error) {
+      Logger.error('Error in sendDataPrices:', error);
+      return false;
+    }
+  }
+
+  async sendDataPrices(data) {
+    if (!data) return false
+
+    try {
+
+      const event = {
+        internalService: true,
+        accountData: this.config,
+        body: JSON.stringify({
+          an: this.config?.AccountName,
+          prices: [data],
+        })
+      }
+      const response = await producerPrices(event);
+
+      if (response.statusCode >= 200 && response.statusCode < 300) {
+        return true;
+      } else {
+        Logger.error('Failed to send data via producer:', response);
+        return false;
+      }
+
+    } catch (error) {
+      Logger.error('Error in sendDataPrices:', error);
+      return false;
+    }
+
+  }
+
+  async sendDataStock(data) {
+    if (!data) return false
+
+    try {
+      const warehouse = data?.warehouse ?? null
+      delete data?.warehouse
+
+      const event = {
+        internalService: true,
+        accountData: this.config,
+        body: JSON.stringify({
+          an: this.config?.AccountName,
+          warehouse,
+          inventory: [data],
+        })
+      }
+      const response = await producerInventory(event);
+
+      if (response.statusCode >= 200 && response.statusCode < 300) {
+        return true;
+      } else {
+        Logger.error('Failed to send data via producer:', response);
+        return false;
+      }
+
+    } catch (error) {
+      Logger.error('Error in sendDataPrices:', error);
+      return false;
+    }
+  }
+
+  async sendDataOrderStatus(data) {
+    if (!data) return false
+
+    try {
+
+      const { documents, changes } = splitData(data);
+
+      const event = {
+        internalService: true,
+        accountData: this.config,
+        body: JSON.stringify({
+          changes,
+          documents,
+        })
+      }
+      const response = await producerPrices(event);
+
+      if (response.statusCode >= 200 && response.statusCode < 300) {
+        return true;
+      } else {
+        Logger.error('Failed to send data via producer:', response);
+        return false;
+      }
+      
+    } catch (error) {
+      Logger.error('Error in sendDataPrices:', error);
+      return false;
+    }
+  }
+
+  async sendDataOrderCancel(data) {
+    if (!data) return false
+
+    try {
+
+      const event = {
+        internalService: true,
+        accountData: this.config,
+        pathParameters: data?.orderId,
+        body: JSON.stringify({
+          reason: data?.reason,
+        })
+      }
+      const response = await orderCancel(event);
+
+      if (response.statusCode >= 200 && response.statusCode < 300) {
+        return true;
+      } else {
+        Logger.error('Failed to send data via producer:', response);
+        return false;
+      }
+      
+    } catch (error) {
+      Logger.error('Error in sendDataPrices:', error);
+      return false;
+    }
+  }
+
+}
+
+module.exports = ServicesRedirect