dcos-core-monalisav2-latam 1.0.0

package/src/common/utils/constants.js

@@ -0,0 +1,37 @@
+class Constants {
+  static REGISTER_CHANGE_ON_ORDER = "/oms/pvt/orders/{orderId}/changes";
+  static START_HANDLING_ORDER = "/oms/pvt/orders/{orderId}/start-handling";
+  static INVOICE_NOTIFICATION_ORDER = "/oms/pvt/orders/{orderId}/invoice";
+  static APPROVE_PAYMENT = "/payments/pvt/payments/{paymentId}/payment-notification";
+  static GET_ORDER = `/oms/pvt/orders/{orderId}`;
+
+  static SAFETY_STOCK_TYPE_PERCENTAGE = "percentage";
+  static SAFETY_STOCK_TYPE_NOMINAL = "nominal";
+
+  static SFTP_STATUS_PENDING = "pending";
+  static SFTP_STATUS_IN_PROCESS = "inProcess";
+  static SFTP_STATUS_PROCESSED = "processed";
+  static SFTP_LOG = "log";
+  static SFTP_LOG_FILE_TYPE = ".log";
+  static SFTP_TXT_FILE_TYPE = ".txt";
+  static SFTP_CSV_FILE_TYPE = ".csv";
+  static SFTP_PROCESS_PRICES = "prices";
+  static SFTP_PROCESS_CANCEL = "cancel";
+  static SFTP_PROCESS_INVENTORY = "inventory";
+  static SFTP_PROCESS_CLIENTS = "clients";
+  static SFTP_PROCESS_ORDER = "order";
+  static SFTP_PROCESS_STATUS = "status";
+
+  static SAFETY_STOCK_TYPE_PERCENTAGE = "percentage";
+  static SAFETY_STOCK_TYPE_NOMINAL = "nominal";
+
+  static SFTP_ALL_PROCESSES_CONSUMED = [
+    this.SFTP_PROCESS_PRICES,
+    this.SFTP_PROCESS_CANCEL,
+    this.SFTP_PROCESS_INVENTORY,
+    this.SFTP_PROCESS_CLIENTS,
+    this.SFTP_PROCESS_STATUS,
+  ];
+}
+
+module.exports = Constants;

package/src/common/utils/convert/MondelezClientsItemsCast.js

@@ -0,0 +1,52 @@
+
+const clientsItemsCSVToJson = (dataCSV) => {
+    
+    const mondelezClientsItem = {
+      email: dataCSV.email,
+      firstName: dataCSV.firstName,
+      lastName: dataCSV.lastName,
+      documentType: dataCSV.documentType,
+      document: dataCSV.document,
+      homePhone: dataCSV.homePhone,
+      phone: dataCSV.phone,
+      customerClass: dataCSV.customerClass,
+      customerClassTwo: dataCSV.customerClassTwo,
+      approved: (dataCSV.approved === "true" ? true : dataCSV.approved === "false" ? false : -1),
+      status: dataCSV.status,
+      address: {
+        receiverName: dataCSV.address_receiverName,
+        street: dataCSV.address_street,
+        number: Number(dataCSV.address_number),
+        complement: dataCSV.address_complement,
+        postalCode: dataCSV.address_postalCode,
+        neighborhood: dataCSV.address_neighborhood,
+        city: dataCSV.address_city,
+        state: dataCSV.address_state,
+        country: dataCSV.address_country,
+        reference: dataCSV.address_reference,
+        geoCoordinates: {
+          latitude: dataCSV.address_latitude,
+          longitude: dataCSV.address_longitude
+        }
+      },
+      additional_information: {
+        deliveryDay: dataCSV.info_deliveryDay,
+        visitDay: dataCSV.info_visitDay,
+        frequency: dataCSV.info_frequency,
+        salesmanName: dataCSV.info_salesmanName,
+        distributorCode: dataCSV.info_distributorCode,
+        distributorName: dataCSV.info_distributorName,
+        clientCode: dataCSV.info_clientCode,
+        priceTable: dataCSV.info_priceTable,
+        pdvname: dataCSV.info_pdvname,
+        pdv: dataCSV.info_pdv
+      }
+    };
+    return mondelezClientsItem;
+
+  };
+
+  module.exports = {
+    clientsItemsCSVToJson,
+  };
+  

package/src/common/utils/convert/MondelezInventoryItemsCast.js

@@ -0,0 +1,15 @@
+
+const inventoryItemsCSVToJson = (dataCSV) => {
+    
+    const mondelezInventoryItem = {
+      sku: dataCSV.sku,
+      quantity: Number(dataCSV.quantity)  
+    };
+    return mondelezInventoryItem;
+
+  };
+
+  module.exports = {
+    inventoryItemsCSVToJson,
+  };
+  

package/src/common/utils/convert/MondelezOrderStatusCast.js

@@ -0,0 +1,34 @@
+const orderStatusItemsCSVToJson = (itemDataCSV) => {
+  let itemRemovedCustom = {};
+  let listItemsRemoved = [];
+
+  for (let itemRemoved of itemDataCSV.changesItemsRemoved) {
+    itemRemovedCustom = {
+      sku: itemRemoved.changesItemsRemovedSku,
+      price: Number(itemRemoved.changesItemsRemovedPrice),
+      quantity: Number(itemRemoved.changesItemsRemovedQuantity),
+    };
+    listItemsRemoved.push(itemRemovedCustom);
+  }
+
+  const mdlzOrderStatusItem = {
+    changes: {
+      reason: itemDataCSV.changesReason,
+      discountValue: Number(itemDataCSV.changesDiscountValue),
+      itemsRemoved: listItemsRemoved,
+    },
+    documents: {
+      type: itemDataCSV.documentsType,
+      issuanceDate: itemDataCSV.documentsIssuanceDate,
+      invoiceNumber: itemDataCSV.documentsInvoiceNumber,
+      invoiceValue: Number(itemDataCSV.documentsInvoiceValue),
+      invoiceUrl: itemDataCSV.documentsInvoiceUrl,
+    },
+  };
+
+  return mdlzOrderStatusItem;
+};
+
+module.exports = {
+  orderStatusItemsCSVToJson,
+};

package/src/common/utils/convert/MondelezPricesItemsCast.js

@@ -0,0 +1,37 @@
+const pricesItemsCSVToJson = (itemDataCSV) => {
+  let listFixedPrices = [];
+
+  for (let itemFixedPrices of itemDataCSV.fixedPrices) {
+    let itemFixedPricesCustom = {
+      listId: itemFixedPrices.listId,
+      value: Number(itemFixedPrices.value),
+      listPrice: Number(itemFixedPrices.listPrice),
+      minQuantity: Number(itemFixedPrices.minQuantity),
+    };
+    if (
+      (itemFixedPrices.dateRangeFrom && itemFixedPrices.dateRangeFrom.length > 0) ||
+      (itemFixedPrices.dateRangeTo && itemFixedPrices.dateRangeTo.length > 0)
+    ) {
+      itemFixedPrices.dateRangeFrom = itemFixedPrices.dateRangeFrom ? itemFixedPrices.dateRangeFrom : null;
+      itemFixedPrices.dateRangeTo = itemFixedPrices.dateRangeTo ? itemFixedPrices.dateRangeTo : null;
+      itemFixedPricesCustom.dateRange = {
+        from: itemFixedPrices.dateRangeFrom,
+        to: itemFixedPrices.dateRangeTo,
+      };
+    }
+    listFixedPrices.push(itemFixedPricesCustom);
+  }
+
+  const mondelezPricesItem = {
+    sku: itemDataCSV.sku,
+    listPrice: Number(itemDataCSV.listPrice),
+    basePrice: Number(itemDataCSV.basePrice),
+    fixedPrices: listFixedPrices,
+  };
+
+  return mondelezPricesItem;
+};
+
+module.exports = {
+  pricesItemsCSVToJson,
+};

package/src/common/utils/cron-ftp-get.js

@@ -0,0 +1,143 @@
+const DynamoAWS = require("aws-sdk/clients/dynamodb");
+const ApiResponse = require("../../common/utils/api-response");
+const Logger = require("../../common/utils/logger");
+
+const CRONS_TABLE = process.env.CRONS_TABLE;
+const SFTP_CREDENTIALS_TABLE = process.env.SFTP_CREDENTIALS_TABLE;
+
+// ==================== CRONS ====================
+
+/**
+ * GET /crons - Obtiene TODOS los crons
+ */
+const getAllCrons = async (event) => {
+  try {
+    const dynamodb = new DynamoAWS.DocumentClient();
+    const params = {
+      TableName: CRONS_TABLE
+    };
+
+    const response = await dynamodb.scan(params).promise();
+    
+    return ApiResponse.response(200, {
+      message: "Crons retrieved successfully",
+      data: response.Items || [],
+      count: response.Items ? response.Items.length : 0
+    });
+  } catch (error) {
+    Logger.error("Error getting all crons:", error);
+    return ApiResponse.response(500, { error: "Internal server error" });
+  }
+};
+
+/**
+ * GET /crons/createorupdate/{cronId} - Obtiene UN cron específico
+ */
+const getCronById = async (event) => {
+  try {
+    const { cronId } = event.pathParameters || {};
+    
+    if (!cronId) {
+      return ApiResponse.response(400, { error: "cronId is required" });
+    }
+
+    const dynamodb = new DynamoAWS.DocumentClient();
+    const params = {
+      TableName: CRONS_TABLE,
+      Key: { "CronId": cronId }
+    };
+
+    const response = await dynamodb.get(params).promise();
+    
+    if (!response.Item) {
+      return ApiResponse.response(404, { error: "Cron not found" });
+    }
+
+    return ApiResponse.response(200, {
+      message: "Cron retrieved successfully",
+      data: response.Item
+    });
+  } catch (error) {
+    Logger.error("Error getting cron by ID:", error);
+    return ApiResponse.response(500, { error: "Internal server error" });
+  }
+};
+
+// ==================== SFTP ====================
+
+/**
+ * GET /account/sftp - Obtiene TODAS las credenciales SFTP
+ */
+const getAllSftpCredentials = async (event) => {
+  try {
+    const dynamodb = new DynamoAWS.DocumentClient();
+    const params = {
+      TableName: SFTP_CREDENTIALS_TABLE,
+      // Excluir passwords por seguridad
+      ProjectionExpression: "FtpId, #type, Host, Port, #user",
+      ExpressionAttributeNames: {
+        "#type": "Type",
+        "#user": "User"
+      }
+    };
+
+    const response = await dynamodb.scan(params).promise();
+    
+    return ApiResponse.response(200, {
+      message: "SFTP credentials retrieved successfully",
+      data: response.Items || [],
+      count: response.Items ? response.Items.length : 0
+    });
+  } catch (error) {
+    Logger.error("Error getting all SFTP credentials:", error);
+    return ApiResponse.response(500, { error: "Internal server error" });
+  }
+};
+
+/**
+ * GET /account/sftp/{ftpId} - Obtiene UNA credencial SFTP específica
+ */
+const getSftpCredentialById = async (event) => {
+  try {
+    const { ftpId } = event.pathParameters || {};
+    
+    if (!ftpId) {
+      return ApiResponse.response(400, { error: "ftpId is required" });
+    }
+
+    const dynamodb = new DynamoAWS.DocumentClient();
+    const params = {
+      TableName: SFTP_CREDENTIALS_TABLE,
+      Key: { "FtpId": ftpId },
+      // Excluir password por seguridad
+      ProjectionExpression: "FtpId, #type, Host, Port, #user",
+      ExpressionAttributeNames: {
+        "#type": "Type",
+        "#user": "User"
+      }
+    };
+
+    const response = await dynamodb.get(params).promise();
+    
+    if (!response.Item) {
+      return ApiResponse.response(404, { error: "SFTP credential not found" });
+    }
+
+    return ApiResponse.response(200, {
+      message: "SFTP credential retrieved successfully",
+      data: response.Item
+    });
+  } catch (error) {
+    Logger.error("Error getting SFTP credential by ID:", error);
+    return ApiResponse.response(500, { error: "Internal server error" });
+  }
+};
+
+module.exports = {
+  // Crons
+  getAllCrons,
+  getCronById,
+  // SFTP
+  getAllSftpCredentials,
+  getSftpCredentialById
+};

package/src/common/utils/data-tables-helper.js

@@ -0,0 +1,213 @@
+/**
+ * Detecta si los parámetros vienen en formato DataTables
+ */
+const isDataTablesFormat = (params) => {
+  return params.hasOwnProperty('draw') && 
+         params.hasOwnProperty('start') && 
+         params.hasOwnProperty('length');
+};
+
+/**
+ * Carga dinámicamente el schema de account desde el archivo JSON
+ */
+const loadAccountSchemaProperties = () => {
+  try {
+    const schema = require('../../../json/schema-valid-json-account.json');
+    
+    if (schema.properties) {
+      return Object.keys(schema.properties).sort();
+    }
+    
+    throw new Error('No properties found in schema');
+  } catch (error) {
+    console.error('Error loading account schema:', error);
+    return ['AccountName', 'ParentAccountName'];
+  }
+};
+
+/**
+ * Obtiene mapeo de columnas completamente dinámico
+ */
+const getColumnMapping = (dataTablesParams) => {
+  const paramsMapping = extractColumnMappingFromParams(dataTablesParams);
+  if (Object.keys(paramsMapping).length > 0) {
+    return paramsMapping;
+  }
+  
+  return generateSchemaBasedMapping();
+};
+
+/**
+ * Extrae mapeo desde parámetros DataTables (columns[N][data])
+ */
+const extractColumnMappingFromParams = (dataTablesParams) => {
+  const mapping = {};
+  
+  Object.keys(dataTablesParams).forEach(key => {
+    const columnMatch = key.match(/^columns\[(\d+)\]\[data\]$/);
+    if (columnMatch) {
+      const columnIndex = columnMatch[1];
+      const fieldName = dataTablesParams[key];
+      if (fieldName) {
+        mapping[columnIndex] = fieldName;
+      }
+    }
+  });
+  
+  return mapping;
+};
+
+/**
+ * Genera mapeo basado dinámicamente en el schema JSON
+ */
+const generateSchemaBasedMapping = () => {
+  const schemaProperties = loadAccountSchemaProperties();
+  const mapping = {};
+  
+  schemaProperties.forEach((property, index) => {
+    mapping[index] = property;
+  });
+  
+  return mapping;
+};
+
+/**
+ * Convierte parámetros DataTables a formato interno
+ */
+const parseDataTablesParams = (dataTablesParams) => {
+  const draw = parseInt(dataTablesParams.draw) || 1;
+  const start = parseInt(dataTablesParams.start) || 0;
+  const length = Math.min(parseInt(dataTablesParams.length) || 10, 100);
+  
+  const columnMapping = getColumnMapping(dataTablesParams);
+  
+  const orderColumnIndex = dataTablesParams["order[0][column]"] || "0";
+  const orderDir = dataTablesParams["order[0][dir]"] || "asc";
+  const orderField = columnMapping[orderColumnIndex] || "AccountName";
+  
+  const globalSearch = dataTablesParams["search[value]"] || "";
+  
+  const columnFilters = {};
+  Object.keys(dataTablesParams).forEach(key => {
+    const columnMatch = key.match(/^columns\[(\d+)\]\[search\]\[value\]$/);
+    if (columnMatch && dataTablesParams[key]) {
+      const columnIndex = columnMatch[1];
+      const fieldName = columnMapping[columnIndex];
+      if (fieldName) {
+        columnFilters[fieldName] = dataTablesParams[key];
+      }
+    }
+  });
+  
+  const accountNamesFilter = detectMultipleAccountNames(dataTablesParams, globalSearch);
+  
+  return {
+    draw,
+    start,
+    length,
+    orderField,
+    orderDir,
+    globalSearch,
+    columnFilters,
+    columnMapping,
+    accountNamesFilter,
+    _limit: length,
+    _sort: orderDir === "desc" ? "desc" : "asc",
+    _like: globalSearch,
+    _from: null
+  };
+};
+
+/**
+ * Detecta si se están buscando múltiples AccountNames
+ */
+const detectMultipleAccountNames = (dataTablesParams, globalSearch) => {
+  const accountNameColumnFilter = Object.keys(dataTablesParams).find(key => {
+    const match = key.match(/^columns\[(\d+)\]\[search\]\[value\]$/);
+    if (match) {
+      const columnIndex = match[1];
+      const columnDataKey = `columns[${columnIndex}][data]`;
+      return dataTablesParams[columnDataKey] === 'AccountName';
+    }
+    return false;
+  });
+  
+  let searchValue = '';
+  if (accountNameColumnFilter) {
+    searchValue = dataTablesParams[accountNameColumnFilter];
+  } else if (globalSearch) {
+    searchValue = globalSearch;
+  }
+  
+  if (searchValue && (searchValue.includes(',') || searchValue.includes(';'))) {
+    return searchValue
+      .split(/[,;]/)
+      .map(name => name.trim())
+      .filter(name => name.length > 0);
+  }
+  
+  return null;
+};
+
+/**
+ * Convierte parámetros legacy a formato DataTables interno
+ */
+const parseLegacyParams = (legacyParams) => {
+  return {
+    draw: 1,
+    start: 0,
+    length: Math.min(parseInt(legacyParams._limit) || 10, 100),
+    orderField: "AccountName",
+    orderDir: legacyParams._sort || "asc",
+    globalSearch: legacyParams._like || "",
+    columnFilters: {},
+    columnMapping: generateSchemaBasedMapping(),
+    accountNamesFilter: null,
+    _limit: legacyParams._limit,
+    _sort: legacyParams._sort,
+    _like: legacyParams._like,
+    _from: legacyParams._from,
+    _moduleActive: legacyParams._moduleActive,
+    _integration: legacyParams._integration,
+    _accountPattern: legacyParams._accountPattern
+  };
+};
+
+/**
+ * Formatea respuesta para DataTables
+ */
+const formatDataTablesResponse = (data, draw, recordsTotal, recordsFiltered) => {
+  return {
+    draw: parseInt(draw),
+    recordsTotal: parseInt(recordsTotal),
+    recordsFiltered: parseInt(recordsFiltered),
+    data: data
+  };
+};
+
+/**
+ * Formatea respuesta para formato legacy
+ */
+const formatLegacyResponse = (data, count, nextToken) => {
+  return {
+    message: "Accounts retrieved successfully",
+    data: data,
+    count: count,
+    pagination: {
+      nextToken: nextToken,
+      hasMore: nextToken !== null,
+      limit: data.length
+    }
+  };
+};
+
+module.exports = {
+  isDataTablesFormat,
+  parseDataTablesParams,
+  parseLegacyParams,
+  formatDataTablesResponse,
+  formatLegacyResponse,
+  getColumnMapping,
+  loadAccountSchemaProperties,
+  detectMultipleAccountNames
+};

package/src/common/utils/date-range-calculator.js

@@ -0,0 +1,113 @@
+const calculateDateRange = (rangeQuery, rangeValue) => {
+    const now = new Date();
+    let startDate = new Date();
+    let endDate = new Date();
+    
+    // Separar el tipo de consulta y el valor numérico (si existe)
+    const [queryType, queryValue] = rangeQuery.split('_');
+    const numericValue = rangeValue || parseInt(queryValue);
+
+    switch (queryType) {
+        case 'last':
+            switch (queryValue) {
+                case 'day':
+                    startDate.setDate(now.getDate() - 1);
+                    startDate.setHours(0, 0, 0, 0);
+                    endDate = new Date(startDate);
+                    endDate.setHours(23, 59, 59, 999);
+                    break;
+                    
+                case 'week':
+                    // Encontrar el lunes de la semana anterior
+                    startDate = new Date(now);
+                    startDate.setDate(now.getDate() - now.getDay() - 7);
+                    startDate.setHours(0, 0, 0, 0);
+                    endDate = new Date(startDate);
+                    endDate.setDate(startDate.getDate() + 6);
+                    endDate.setHours(23, 59, 59, 999);
+                    break;
+                    
+                case 'month':
+                    startDate = new Date(now.getFullYear(), now.getMonth() - 1, 1, 0, 0, 0, 0);
+                    endDate = new Date(now.getFullYear(), now.getMonth(), 0, 23, 59, 59, 999);
+                    break;
+                    
+                case 'days':
+                    if (!numericValue) throw new Error('Invalid days value');
+                    startDate.setDate(now.getDate() - numericValue);
+                    startDate.setHours(0, 0, 0, 0);
+                    endDate = new Date(now);
+                    endDate.setDate(now.getDate() - 1);
+                    endDate.setHours(23, 59, 59, 999);
+                    break;
+                    
+                case 'weeks':
+                    if (!numericValue) throw new Error('Invalid weeks value');
+                    startDate.setDate(now.getDate() - (numericValue * 7));
+                    startDate.setHours(0, 0, 0, 0);
+                    endDate = new Date(now);
+                    endDate.setDate(now.getDate() - now.getDay() - 1);
+                    endDate.setHours(23, 59, 59, 999);
+                    break;
+                    
+                case 'months':
+                    if (!numericValue) throw new Error('Invalid months value');
+                    startDate = new Date(now.getFullYear(), now.getMonth() - numericValue, 1, 0, 0, 0, 0);
+                    endDate = new Date(now.getFullYear(), now.getMonth(), 0, 23, 59, 59, 999);
+                    break;
+            }
+            break;
+
+        case 'now':
+            switch (queryValue) {
+                case 'days':
+                    if (!numericValue) throw new Error('Invalid days value');
+                    startDate.setDate(now.getDate() - numericValue + 1);
+                    startDate.setHours(0, 0, 0, 0);
+                    endDate = new Date(now);
+                    break;
+                    
+                case 'week':
+                    startDate.setDate(now.getDate() - now.getDay());
+                    startDate.setHours(0, 0, 0, 0);
+                    endDate = new Date(now);
+                    break;
+                    
+                case 'month':
+                    startDate = new Date(now.getFullYear(), now.getMonth(), 1, 0, 0, 0, 0);
+                    endDate = new Date(now);
+                    break;
+                    
+                case 'weeks':
+                    if (!numericValue) throw new Error('Invalid weeks value');
+                    startDate.setDate(now.getDate() - (numericValue * 7));
+                    startDate.setHours(0, 0, 0, 0);
+                    endDate = new Date(now);
+                    break;
+                    
+                case 'months':
+                    if (!numericValue) throw new Error('Invalid months value');
+                    startDate = new Date(now.getFullYear(), now.getMonth() - numericValue + 1, 1, 0, 0, 0, 0);
+                    endDate = new Date(now);
+                    break;
+                    
+                case 'days':
+                    startDate = new Date(now);
+                    startDate.setHours(0, 0, 0, 0);
+                    endDate = new Date(now);
+                    break;
+            }
+            break;
+
+        default:
+            throw new Error('Invalid range query format');
+    }
+
+    return {
+        startDate: startDate.toISOString(),
+        endDate: endDate.toISOString(),
+        period: `${queryType}_${queryValue}${numericValue ? `-${numericValue}` : ''}`
+    };
+};
+
+module.exports = { calculateDateRange };

package/src/common/utils/delay.js

@@ -0,0 +1,17 @@
+/**
+ * Establece un tiempo de espera
+ * @param {number} seconds Tiempo de espera en segundos
+ * @returns 
+ */
+module.exports.delayStatusProcess = (seconds) => {
+    return new Promise((resolve, reject) => {
+        if (!seconds || seconds > 1) {
+            // Se define un TimeOut
+            setTimeout(() => {
+                resolve(true);
+            }, (seconds * 1000));
+        } else {
+            resolve(true);
+        }
+    })
+};