dcos-core-monalisav2-latam 1.0.0

package/src/common/utils/sftp-utils.js

@@ -0,0 +1,202 @@
+const fs = require('fs');
+
+const { FtpFileSystem, SftpFileSystem, FileSystem } = require('./ftp-sftp');
+const Logger = require('./logger');
+
+/**
+ * Permite establecer una conexión a un servidor FTP.
+ * @param {Object} settings Parámetros de conexión.
+ * @param {string} settings.type Tipo de conexión ('ftp' o 'sftp').
+ * @param {string} settings.host Dirección IP o dominio del servidor FTP.
+ * @param {string} settings.port Número de puerto.
+ * @param {string} settings.user Nombre del usuario FTP.
+ * @param {string} settings.password Contraseña del usuario FTP
+ * @returns {Promise<FileSystem>} Instancia de conexión al servidor FTP.
+ */
+module.exports.connectToFtp = settings => {
+  return new Promise((resolve, reject) => {
+    let { type = 'ftp', host, port = '21', username, user = username, password } = settings;
+    switch (type) {
+      case 'ftp':
+        Logger.info(`Connecting to ${user}@${host} using ${type}`);
+        FtpFileSystem.create(host, port, user, password).then(connection => {
+          // Eventos al cerrar la conexión
+          connection.client.on('end', () => {
+            Logger.debug('Connection ended ' + host);
+          });
+          connection.client.on('close', () => {
+            Logger.debug('Connection closed ' + host);
+          });
+          resolve(connection);
+        }).catch(reject);
+        break;
+      case 'sftp':
+        Logger.info(`Connecting to ${user}@${host} using ${type}`);
+        SftpFileSystem.create(host, port, user, password).then(connection => {
+          // Eventos al cerrar la conexión
+          connection.client.on('end', () => {
+            Logger.debug('Connection ended ' + host);
+          });
+          connection.client.on('close', () => {
+            Logger.debug('Connection closed ' + host);
+          });
+          resolve(connection);
+        }).catch(reject);
+        break;
+      default:
+        reject(new Error(`Value type '${type || ''}' isn't valid`));
+    }
+  });
+}
+
+/**
+ * Obtiene la lista de archivos existentes en la carpeta.
+ * @param {FileSystem} clientFTP Instancia de conexión al servidor FTP.
+ * @param {string} filesFolderPath Carpeta donde se buscan los archivos.
+ * @param {function} callbackFilter Expresión regular del archivo a obtener.
+ * @returns Lista de archivos asociados a la consulta.
+ */
+module.exports.getFilesInFolder = async (clientFTP, filesFolderPath, callbackFilter = null) => {
+  return new Promise((resolve, reject) => {
+    Logger.debug(`Finding files into folder: ${filesFolderPath}`);
+    clientFTP.list(filesFolderPath).then(list => {
+      if (callbackFilter) {
+        resolve(list.filter(callbackFilter));
+      } else {
+        resolve(list);
+      }
+    }).catch(reject);
+  });
+};
+
+/**
+ * Obtiene el contenido de un archivo del ftp.
+ * @param {FileSystem} clientFTP Instancia de conexión al servidor FTP.
+ * @param {string} filePath Ruta del archivo a leer.
+ * @returns Contenido del archivo.
+ */
+module.exports.getFileContent = async (clientFTP, filePath) => {
+  return new Promise((resolve, reject) => {
+    // Obtener el contenido del archivo indicado
+    Logger.debug(`Reading file: ${filePath}`);
+    clientFTP.get(filePath).then(stream => {
+      // Se extrae el contenido del archivo
+      let content = '';
+      stream.on('data', function (chunk) {
+        content += chunk.toString();
+      });
+      stream.on('end', function () {
+        resolve(content);
+      });
+    }).catch(reject);
+  });
+};
+
+/**
+ * Mueve el archivo procesado a una determinada carpeta
+ * @param {FileSystem} clientFTP Instancia de conexión al servidor FTP.
+ * @param {string} filePath Directorio del archivo que se va a mover
+ * @param {string} targetFolder Carpeta donde se moverán los archivos procesados
+ * @param {string} newFileName Nombre a asignar del archivo movido a 'targetFolder'.
+ * @returns 
+ */
+module.exports.moveProcessedFile = (clientFTP, filePath, targetFolder, newFileName) => {
+  return new Promise((resolve, reject) => {
+    // Creación de la carpeta donde se almacenarán los archivos divididos
+    this.createFolder(clientFTP, targetFolder).then(() => {
+      newFileName = targetFolder + '/' + newFileName;
+      Logger.debug(`Moving file '${newFileName}' to folder '${targetFolder}'`);
+      clientFTP.rename(filePath, newFileName).then(() => {
+        resolve(newFileName);
+      }).catch(reject)
+    }).catch(reject);
+  });
+};
+
+/**
+ * Crea un nuevo directorio en el servidor FTP.
+ * @param {FileSystem} clientFTP Instancia de conexión al servidor FTP.
+ * @param {string} folderPath Ruta de la carpeta a crear
+ * @returns 
+ */
+module.exports.createFolder = (clientFTP, folderPath) => {
+  return new Promise((resolve, reject) => {
+    Logger.debug(`Creating folder: ${folderPath}`);
+    clientFTP.mkdir(folderPath, true).then(() => {
+      resolve(folderPath);
+    }).catch(ex => {
+      if (ex.code == 4) {
+        resolve(folderPath);
+      } else {
+        reject(new Error(ex?.message ?? 'Error in createFolder'));
+      }
+    });
+  });
+}
+
+/**
+ * Descarga un archivo del servidor FTP/SFTP a un directorio local.
+ * @param {FileSystem} clientFTP Instancia de conexión al servidor FTP.
+ * @param {string} remotePath Directorio del archivo del servidor FTP/SFTP a descargar.
+ * @param {string} localPath Directorio del archivo en local donde se descargará el archivo.
+ * @param {string} type Valor que indica si el servidor es 'ftp' o 'sftp'.
+ * @returns 
+ */
+module.exports.downloadFile = async (clientFTP, remotePath, localPath, type = 'ftp') => {
+  return new Promise((resolve, reject) => {
+    switch (type) {
+      case 'ftp':
+        clientFTP.client.get(remotePath, (err, stream) => {
+          if (err) {
+            reject(err)
+          } else {
+            stream.once('close', function () {
+              resolve(true);
+            });
+            stream.pipe(fs.createWriteStream(localPath));
+          }
+        });
+        break;
+      case 'sftp':
+        clientFTP.client.get(remotePath, localPath).then(() => {
+          resolve(true);
+        }).catch(reject);
+        break;
+      default:
+        reject(new Error(`Type ${type} is not valid`));
+        break;
+    }
+  });
+}
+
+/**
+ * Sube un archivo de un directorio local a un servidor FTP/SFTP.
+ * @param {FileSystem} clientFTP Instancia de conexión al servidor FTP.
+ * @param {string} localPath Directorio del archivo en local a subir.
+ * @param {string} remotePath Directorio del archivo del servidor FTP/SFTP a donde se subirá el archivo.
+ * @param {string} type Valor que indica si el servidor es 'ftp' o 'sftp'.
+ * @returns 
+ */
+module.exports.uploadFile = async (clientFTP, localPath, remotePath, type = 'ftp') => {
+  return new Promise((resolve, reject) => {
+    switch (type) {
+      case 'ftp':
+        clientFTP.client.put(localPath, remotePath, err => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(true);
+          }
+        });
+        break;
+      case 'sftp':
+        clientFTP.client.fastPut(localPath, remotePath).then(() => {
+          resolve(true);
+        }).catch(reject);
+        break;
+      default:
+        reject(new Error(`Type ${type} is not valid`));
+        break;
+    }
+  });
+}

package/src/common/utils/status.js

@@ -0,0 +1,15 @@
+class Status {
+  
+    static PAYMENT_PENDING = "payment-pending";
+    static PAYMENT_APPROVED = "payment-approved";
+    static INVOICED = "invoiced";
+    static HANDLING = "handling";
+    static READY_FOR_HANDLING = "ready-for-handling";
+    static WAITING_FFMTT_AUTHORIZATION = "waiting-ffmt-authorization";
+    static CANCEL = "cancel";
+    static CANCELED = "canceled";
+    
+  }
+  
+  module.exports = Status;
+

package/src/common/utils/util.js

@@ -0,0 +1,236 @@
+const { AxiosError } = require("axios");
+const Logger = require("./logger");
+
+/**
+ * 
+ * @param {receive price product} price 
+ * @param {receive amount round price decimal} roundUpDecimalPrice 
+ * 
+ * @returns 
+ */
+
+const roundPrice = (price, roundUpDecimalPrice) => {
+  const { roundUpAmountDecimal = 2, typeRounded = 'default' } = roundUpDecimalPrice;
+  
+  // Factor para determinar los decimales
+  const factor = Math.pow(10, roundUpAmountDecimal);
+  const scaledPrice = price * factor;
+
+  switch (typeRounded) {
+    case 'up':
+      // Redondear siempre hacia arriba y mantener los decimales
+      return Math.ceil(scaledPrice) / factor;
+
+    case 'down':
+      // Redondear siempre hacia abajo y mantener los decimales
+      return Math.floor(scaledPrice) / factor;
+
+    default:
+      // Redondeo normal al valor más cercano y mantener los decimales
+      return Math.round(scaledPrice) / factor;
+  }
+};
+
+/**
+ * 
+ * @param {Specify seconds delay time to process} time 
+ * @returns 
+ */
+function delayToProcess(time) {
+  if (!time || time < 1) {
+    return true;
+  }
+  return new Promise((resolve, reject) => {
+    setTimeout(function () {
+      resolve(true);
+    }, (time * 1000));
+  })
+};
+
+/**
+ * 
+ * @param {Specify a decimal value to rounded.} decimalValue 
+ * @returns A value rounded to two decimals
+ */
+function convertDecimal(decimalValue) {
+  const value = Math.round((parseFloat(decimalValue) + Number.EPSILON) * 100) / 100;
+  return value;
+};
+
+/**
+ * 
+ * @param {*} str 
+ * @param {*} quantityDecimal 
+ * @returns 
+ */
+function transformStringToDecimal(str, quantityDecimal) {
+  if (str.length < quantityDecimal) {
+    Logger.error('Decimal format incorrect: ', str);
+    return '0.0';
+  }
+  let newValue = str.substring(0, str.length - 2) + '.' + str.substring(str.length - 2, str.length);
+  return newValue;
+};
+
+const breakString = (str, limit) => {
+  let brokenString = '';
+  for (let i = 0, count = 0; i < str.length; i++) {
+    if (count >= limit && str[i] === ' ') {
+      count = 0;
+      brokenString += '\n';
+    } else {
+      count++;
+      brokenString += str[i];
+    }
+  }
+  return brokenString;
+}
+
+/**
+ * @param {Specify date value to check}
+ */
+function validateDate(date) {
+  const regex = /^\d{14}$/; // Expresión regular para validar que la cadena tenga exactamente 14 dígitos
+  return regex.test(date);
+}
+
+function getDateFromString(str) {
+  const year = parseInt(str.substring(0, 4));
+  const month = parseInt(str.substring(4, 6));
+  const day = parseInt(str.substring(6, 8));
+  const hora = parseInt(str.substring(8, 10));
+  const minute = parseInt(str.substring(10, 12));
+  const second = parseInt(str.substring(12, 14));
+  return new Date(year, month - 1, day, hora, minute, second);
+}
+
+const convertChar = (str) => {
+  return str.replace("<", "&lt;")
+    .replace(">", "&gt;")
+    .replace("&", "&amp;")
+    .replace('"', "&quot;")
+    .replace("'", "&apos;");
+};
+
+function stringDateVtexToDate(date) {
+  let dateValue = date;
+  try {
+    dateValue = new Date(date).toISOString();
+  } catch (error) {
+    Logger.error(error);
+  }
+  return dateValue;
+}
+
+const validateEmail = (email) => {
+  return String(email)
+    .toLowerCase()
+    .match(
+      /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|.(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/
+    );
+};
+
+const validatePhone = (phone) => { //    /[a-zA-Z0-9 ÑñÁÉÍÓÚáéíóú-]/
+  const formatPhone = /^[0-9-]+$/;
+  return formatPhone.test(phone)
+}
+
+const validateID = (id) => {
+  const formatId = /^[a-zA-Z0-9Ññ-]+$/;
+  return formatId.test(id)
+}
+
+const getErrorData = ex => {
+  let error = { message: '', status: 500, info: {} };
+  if (ex instanceof AxiosError) {
+    const { request = {}, response = {} } = ex;
+    const { path, method, host } = request;
+    const { status = 500, statusText = '', data = null } = response;
+
+    let message;
+    if (data?.Message) {
+      message = data.Message;
+    } else if (data) {
+      switch (Object.prototype.toString.call(data)) {
+        case '[object String]':
+          message = data;
+          break;
+        case '[object Object]':
+          message = JSON.stringify(data);
+          break;
+      }
+    } else if (statusText) {
+      message = statusText;
+    } else {
+      Logger.error(ex);
+      message = 'Error in Axios request';
+    }
+
+    error.status = status;
+    error.message = message;
+    error.info = { status, data, message, request: { path, method, host } };
+  } else {
+    const { message } = ex;
+    error.message = message;
+    error.info = { message };
+  }
+  return error;
+}
+
+/**
+ * Genera los valores basados en una determinada fecha para utilizarse en
+ * el nombre de archivos y/o carpetas.
+ * @param {Date} currentDate Fecha de la cual se extrae la información
+ * @returns Valores generados a partir de la fecha.
+ */
+const getDateValues = (currentDate = new Date()) => {
+  let year = currentDate.getFullYear(),
+    month = String(currentDate.getMonth() + 1).padStart(2, '0'),
+    day = String(currentDate.getDate()).padStart(2, '0'),
+    hour = String(currentDate.getHours()).padStart(2, '0'),
+    minute = String(currentDate.getMinutes()).padStart(2, '0'),
+    second = String(currentDate.getSeconds()).padStart(2, '0');
+
+  return {
+    // Marca de tiempo de la fecha y hora actual.
+    'timestamp': year + month + day + hour + minute + second,
+    // Marca de tiempo de la fecha actual.
+    'timestampMin': year + month + day,
+    // Subcarpeta donde se moveran los archivos grandes que ya fueron divididos
+    'processedSubfolder': `${year}/${month}`
+  };
+};
+
+const setQueryParams = (url, queryParams) => {
+  let queryText = ''
+  for (let key in queryParams) {
+    if (queryText) {
+      queryText += '&'
+    }
+    queryText += `${key}=${queryParams[key]}`
+  }
+
+  if (queryText) {
+    queryText = '?' + queryText
+  }
+
+  return url + queryText
+}
+
+module.exports = {
+  delayToProcess: delayToProcess,
+  convertDecimal: convertDecimal,
+  transformStringToDecimal: transformStringToDecimal,
+  breakString: breakString,
+  convertChar: convertChar,
+  validateDate: validateDate,
+  getDateFromString: getDateFromString,
+  stringDateVtexToDate: stringDateVtexToDate,
+  validateEmail: validateEmail,
+  validatePhone: validatePhone,
+  validateID: validateID,
+  getErrorData,
+  getDateValues,
+  setQueryParams,
+  roundPrice 
+}

package/src/common/utils/validate-state-order.js

@@ -0,0 +1,35 @@
+const Logger = require("./logger");
+
+const isStateInNotificationProviders = ( data = {} ) => {
+    const isActive = data?.isActiveNotifications === true ? true : false
+    if(isActive){
+        const isEmptyProviders = data?.notificationProviders.length === 0 ? true : false
+        if(isEmptyProviders){
+            Logger.error('NOTIFICATIONS Providers is empty')
+            return false
+        }
+        const isState = isStateInStatusProvider({ 
+                notificationProviders: data?.notificationProviders,
+                stateOrder: data?.stateOrder
+            })
+        return isState
+    }
+    return isActive
+}
+
+const isStateInStatusProvider = ( data = {} ) => {
+    const { notificationProviders, stateOrder } = data
+    let isStateFound = false;
+    notificationProviders.forEach(element => {
+        if(element.Status.hasOwnProperty(stateOrder)){
+            Logger.debug('STATE is Status Provider:', stateOrder)
+            isStateFound = true
+        }
+    });
+
+    return isStateFound
+}
+
+module.exports = {
+    isStateInNotificationProviders
+}

package/src/common/utils/validateProviders.js

@@ -0,0 +1,67 @@
+const Logger = require("./logger");
+
+/**
+ * Method to validate that an object contains at least one property
+ * @param object -- returns true if the object contains at least one property
+ **/
+const isObjectNotEmpty = (object) => {
+    return Object.keys(object).length > 0
+}
+
+/**
+ * Method to validate a valid url
+ * @param url -- returns true if the url is valid or false if the url is invalid
+ **/
+const validateURL = (url) => {
+    try {
+        new URL(url)
+        return url
+    } catch (error) {
+        Logger.error("URL invalid")
+        return false
+    }
+}
+
+/**
+ * Method to validate if the value of a property of an object is of type string and it contains an object inside the string.
+ * @param item -- object with assigned properties
+ * @param property -- name of the property to be converted or sanitized to make it a valid readable format 
+ **/
+const processStringOrObject = (item, property, order, client) => {
+    if (property in item) {
+        try {
+            return typeof item[property] === "string"
+                ? eval(`(${item[property]})`)
+                : item[property];
+        } catch (error) {
+            Logger.error(`Error evaluando '${property}' en '${item}':`, error);
+        }
+    }
+    return {};
+}
+
+/**
+ * Method to evaluate a condition, logic or methods, in string format as a parameter
+ * @param condition -- logic javascript that must be processing
+ * @param order -- 
+ **/
+
+function evaluateCondition(condition, order, client) {
+    try {
+        let result = null
+        eval(`result=${condition}`);
+        return typeof result === 'boolean' ? result : false;
+    } catch (error) {
+        Logger.error('Error evaluating condition:', error.message);
+        return false;
+    }
+}
+
+
+
+module.exports = {
+    isObjectNotEmpty,
+    validateURL,
+    processStringOrObject,
+    evaluateCondition
+}

package/src/common/utils/validation-data.js

@@ -0,0 +1,45 @@
+const Logger = require("./logger");
+
+const validateRequiredParam = (name, evaluate) => {
+  if (!evaluate) {
+    Logger.error(`${name} is required`);
+    return false;
+  }
+};
+
+const transformFirstKeysToUpperCaseValue = (originalObject) => {
+  const newObj = {};
+  for (const key in originalObject) {
+    const newKey = key.charAt(0).toUpperCase() + key.slice(1);
+    newObj[newKey] = originalObject[key];
+  }
+  return newObj;
+};
+
+const transformKeysToUpperCaseValue = (originalObject) => {
+  const newObj = {};
+  for (const key in originalObject) {
+    const newKey = key.charAt(0).toUpperCase() + key.slice(1);
+    newObj[newKey] =
+      typeof originalObject[key] === "object"
+        ? transformKeysToUpperCaseValue(originalObject[key])
+        : originalObject[key];
+  }
+  return newObj;
+};
+
+const transformFirstKeysToLowerCaseValue = (originalObject) => {
+  const newObj = {};
+  for (const key in originalObject) {
+    const newKey = key.charAt(0).toLowerCase() + key.slice(1);
+    newObj[newKey] = originalObject[key];
+  }
+  return newObj;
+};
+
+module.exports = {
+  validateRequiredParam,
+  transformKeysToUpperCaseValue,
+  transformFirstKeysToUpperCaseValue,
+  transformFirstKeysToLowerCaseValue
+};

package/src/common/utils/vtex/save-hooks.js

@@ -0,0 +1,65 @@
+const VtexApi = require("../../../vtex/clients/VtexApi");
+const Logger = require("../logger");
+
+const handlePostOperation = async (vtexApi, url, data) => {
+  const options = {
+    method: 'POST',
+    data,
+  };
+  const response = await vtexApi.fetch(url, options);
+  if ((response?.status >= 200 && response?.status < 400) || !response) {
+    return {
+      status: 200,
+      message: "Record created/updated successfully",
+    };
+  }
+  Logger.error("Failed PUT operation", response);
+  throw new Error("Failed POST operation");
+};
+
+const handleDeleteOperation = async (vtexApi, url) => {
+  const options = {
+    method: 'DELETE',
+  };
+  const response = await vtexApi.fetch(url, options);
+
+  if ((response?.status >= 200 && response?.status < 400) || !response) {
+    return {
+      status: 200,
+      message: "Record deleted successfully",
+    };
+  }
+  Logger.error("Failed DELETE operation", response);
+  throw new Error("Failed DELETE operation");
+};
+
+const handleHookVtexMD2 = async ({ id, data, origin, httpMethod }) => {
+  if (!id || !origin) {
+    Logger.error("Missing required parameters (id or origin).");
+    throw new Error("Missing required parameters (id or origin).");
+  }
+  const { AccountName, AppKey, AppToken } = origin;
+  if (!AccountName || !AppKey || !AppToken) {
+    Logger.error("Incomplete 'origin' object.");
+    throw new Error("Incomplete 'origin' object.");
+  }
+  const vtexApi = new VtexApi(AccountName, AppKey, AppToken);
+  const url = `/orders/hook/config/`;
+  try {
+    switch (httpMethod) {
+      case 'POST':
+        return await handlePostOperation(vtexApi, url, data);
+      case 'DELETE':
+        return await handleDeleteOperation(vtexApi, url);
+      default:
+        return { status: 405, message: `Method ${httpMethod} not allowed to VTEX` };
+    }
+  } catch (error) {
+    Logger.error(`Error during operation ${httpMethod}:`, error.message);
+    throw error;
+  }
+};
+
+module.exports = {
+  handleHookVtexMD2,
+};