dcos-core-monalisav2-latam 1.0.0

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

@@ -0,0 +1,320 @@
+const FtpClient = require('ftp')
+let SftpClient = require('ssh2-sftp-client');
+const fs = require('fs')
+
+class FileSystem {
+
+}
+
+class FileInfo {
+  constructor(original) {
+    this.original = original
+  }
+  getName() {
+    return this.original.name
+  }
+  getSize() {
+    return this.original.size
+  }
+}
+
+// credits going to https://geedew.com/remove-a-directory-that-is-not-empty-in-nodejs/
+var deleteFolderRecursive = function(path) {
+  if( fs.existsSync(path) ) {
+    fs.readdirSync(path).forEach(function(file,index){
+      var curPath = path + "/" + file;
+      if(fs.lstatSync(curPath).isDirectory()) { // recurse
+        deleteFolderRecursive(curPath);
+      } else { // delete file
+        fs.unlinkSync(curPath);
+      }
+    });
+    fs.rmdirSync(path);
+  }
+};
+
+class LocalFileSystem extends FileSystem {
+  constructor() {
+    super()
+  }
+  static create() {
+    return new Promise((resolve, reject) => {
+      return resolve(new LocalFileSystem())
+    })
+  }
+  async list(path) {
+    return new Promise((resolve, reject) => {
+      fs.readdir(path, async (err, files) => {
+        if (err) {
+          return reject(err)
+        }
+        await Promise.all(
+          files.map(fileName => new Promise((res, reject) => {
+            fs.stat(path + fileName, (err, stats) => {
+              if (err) {
+                return reject(err)
+              }
+              stats.name = fileName
+              res(new LocalFileInfo(stats))
+            })
+          }))
+        ).then(res => {
+          resolve(res)
+        }).catch(err => {
+          reject(err)
+        })
+      })
+    })
+  }
+  put(src, toPath) {
+    return new Promise((resolve, reject) => {
+      try {
+        const writeStream = fs.createWriteStream(toPath)
+        src.pipe(writeStream)
+        resolve(true)
+      } catch (e) {
+        reject(e)
+      }
+    })
+  }
+  get(path) {
+    return new Promise((resolve, reject) => {
+      try {
+        const readStream = fs.createReadStream(path)
+        resolve(readStream)
+      } catch (e) {
+        reject(e)
+      }
+    })
+  }
+  mkdir(path, recursive) {
+    return fs.mkdir(path, { recursive })
+  }
+  rmdir(path, recursive) {
+    if (!recursive)
+      return fs.rmdir(path)
+    return new Promise((resolve, reject) => {
+      try {
+        deleteFolderRecursive(path)
+        resolve(true)
+      } catch (e) {
+        reject(e)
+      }
+    })
+  }
+  delete(path) {
+    return new Promise((resolve, reject) => {
+      fs.unlink(path, err => {
+        if (err) {
+          return reject(err)
+        }
+        resolve(true)
+      })
+    })
+  }
+  rename(oldPath, newPath) {
+    return new Promise((resolve, reject) => {
+      fs.rename(oldPath, newPath, err => {
+        if (err) {
+          return reject(err)
+        }
+        resolve(true)
+      })
+    })
+  }
+  // stats cannot be used with the current FTP library... so this feature will be left out for now
+  // stat(path) {
+  //   return new Promise((resolve, reject) => {
+  //     fs.stat(path, (err, stats) => {
+  //       if (err) {
+  //         return reject(err)
+  //       }
+  //       resolve(new LocalFileInfo(stats))
+  //     })
+  //   })
+  // }
+}
+
+class LocalFileInfo extends FileInfo {
+  isDirectory() {
+    return this.original.isDirectory()
+  }
+}
+
+class FtpFileSystem extends FileSystem {
+  constructor(client) {
+    super()
+    this.client = client
+  }
+  static async create(host, port, user, password) {
+    const c = new FtpClient()
+    return new Promise((resolve, reject) => {
+      c.on('ready', () => {
+        resolve(new FtpFileSystem(c))
+      })
+      c.once('error', (err) => {
+        reject(err)
+      })
+      c.connect({
+        host,
+        port,
+        user,
+        password
+      })
+    })
+  }
+  list(path) {
+    return new Promise((resolve, reject) => {
+      this.client.list(path, (err, listing) => {
+        if (err) {
+          return reject(err)
+        }
+        resolve(listing.map(l => new FtpFileInfo(l)))
+      })
+    })
+  }
+  put(src, toPath) {
+    return new Promise((resolve, reject) => {
+      this.client.put(src, toPath, (err) => {
+        if (err) {
+          reject(err)
+        }
+        resolve(true)
+      })
+    })
+  }
+  get(path) {
+    return new Promise((resolve, reject) => {
+      this.client.get(path, (err, stream) => {
+        if (err) {
+          return reject(err)
+        }
+        resolve(stream)
+      })
+    })
+  }
+  mkdir(path, recursive) {
+    return new Promise((resolve, reject) => {
+      this.client.mkdir(path, recursive, err => {
+        if (err) {
+          return reject(err)
+        }
+        resolve(true)
+      })
+    })
+  }
+  rmdir(path, recursive) {
+    return new Promise((resolve, reject) => {
+      this.client.rmdir(path, recursive, err => {
+        if (err) {
+          return reject(err)
+        }
+        resolve(1)
+      })
+    })
+  }
+  delete(path) {
+    return new Promise((resolve, reject) => {
+      this.client.delete(path, err => {
+        if (err) {
+          return reject(err)
+        }
+        resolve(path)
+      })
+    })
+  }
+  rename(oldPath, newPath) {
+    return new Promise((resolve, reject) => {
+      this.client.rename(oldPath, newPath, (err) => {
+        if (err) {
+          return reject(err)
+        }
+        resolve(true)
+      })
+    })
+  }
+}
+
+class FtpFileInfo extends FileInfo {
+  constructor(original) {
+    super(original)
+  }
+  isDirectory() {
+    return this.original.type === 'd'
+  }
+}
+
+class SftpFileSystem extends FileSystem {
+  constructor(client) {
+    super()
+    this.client = client
+  }
+  static async create(host, port, user, password) {
+    const c = new SftpClient()
+    return new Promise((resolve, reject) => {
+      c.connect({
+        host,
+        port,
+        username: user,
+        password
+      }).then(() => {
+        resolve(new SftpFileSystem(c))
+      }).catch(err => {
+        reject(err)
+      })
+    })
+  }
+  async list(path) {
+    return new Promise((resolve, reject) => {
+      this.client.list(path)
+        .then(paths => {
+          resolve(paths.map(it => new SftpFileInfo(it)))
+        }).catch(err => {
+          reject(err)
+        })
+    })
+  }
+  put(src, toPath) {
+    return this.client.put(src, toPath)
+  }
+  get(path) {
+    return new Promise((resolve, reject) => {
+      try {
+        resolve(this.client.sftp.createReadStream(path))
+      } catch (e) {
+        reject(e)
+      }
+    })
+  }
+  mkdir(path, recursive) {
+    return this.client.mkdir(path, recursive)
+  }
+  rmdir(path, recursive) {
+    return this.client.rmdir(path, recursive)
+  }
+  delete(path) {
+    return this.client.delete(path)
+  }
+  rename(oldPath, newPath) {
+    return this.client.rename(oldPath, newPath)
+  }
+}
+
+class SftpFileInfo extends FileInfo {
+  constructor(original) {
+    super(original)
+  }
+  isDirectory() {
+    return this.original.type === 'd'
+  }
+}
+
+
+module.exports = {
+  FileSystem,
+  FileInfo,
+  LocalFileSystem,
+  FtpFileSystem,
+  SftpFileSystem,
+  SftpFileInfo
+}

package/src/common/utils/logger.js

@@ -0,0 +1,126 @@
+class Logger {
+  static config = {
+    DebuggerOn: false,
+    AccountName: 'System',
+    showTimestamps: false,
+    showAccount: true,
+    showType: false
+  };
+
+  static _originalConsole = {
+    log: console.log,
+    info: console.info,
+    warn: console.warn,
+    error: console.error,
+    debug: console.debug,
+    dir: console.dir
+  };
+
+  // Objeto de configuración asociado a la instancia de la clase
+  config = { ...Logger.config };
+
+  constructor(configAccount = null) {
+    if (configAccount) {
+      this.setAccount(configAccount);
+    }
+  }
+
+  setAccount(configAccount) {
+    const { DebuggerOn = false, ...remain } = configAccount;
+    this.config = { ...this.config, DebuggerOn, ...remain };
+  }
+
+  log(...args) {
+    Logger._handleMessage(this, 'log', ...args);
+  }
+
+  info(...args) {
+    Logger._handleMessage(this, 'info', ...args);
+  }
+
+  warn(...args) {
+    Logger._handleMessage(this, 'warn', ...args);
+  }
+
+  error(...args) {
+    Logger._handleMessage(this, 'error', ...args);
+  }
+
+  debug(...args) {
+    Logger._handleMessage(this, 'debug', ...args);
+  }
+
+  /**
+   * Establece las opciones de configuración.
+   * @param {object} configAccount Objeto JSON del account en Monalisa V2.
+   */
+  static setAccount(configAccount) {
+    if (configAccount) {
+      const { DebuggerOn = false, ...remain } = configAccount;
+      Logger.config = { ...Logger.config, DebuggerOn, ...remain };
+    }
+  }
+
+  // Métodos públicos (sin cambios para mantener compatibilidad)
+  static log(...args) {
+    Logger._handleMessage(Logger, 'log', ...args);
+  }
+
+  static info(...args) {
+    Logger._handleMessage(Logger, 'info', ...args);
+  }
+
+  static warn(...args) {
+    Logger._handleMessage(Logger, 'warn', ...args);
+  }
+
+  static error(...args) {
+    Logger._handleMessage(Logger, 'error', ...args);
+  }
+
+  static debug(...args) {
+    Logger._handleMessage(Logger, 'debug', ...args);
+  }
+
+  static _handleMessage(thisRef, type, ...args) {
+    if (thisRef?.config?.DebuggerOn || ['log', 'error'].includes(type)) {
+      Logger._originalConsole[type](...Logger._format(thisRef, type, ...args));
+    }
+  }
+
+  static _format(thisRef, type, ...args) {
+    const header = [];
+
+    if (thisRef?.config?.showTimestamps) {
+      header.push(`[${new Date().toISOString()}]`);
+    }
+    if (thisRef?.config?.showAccount) {
+      header.push(`[${thisRef.config.AccountName}]`);
+    }
+    if (thisRef?.config?.showType) {
+      header.push(`[${type.toUpperCase()}]`);
+    }
+
+    const logsData = [];
+    if (header.length) {
+      logsData.push(header.join(''))
+    }
+    for (let arg of args) {
+      if (arg instanceof Error) {
+        logsData.push(arg.stack);
+      } else {
+        logsData.push(arg);
+      }
+    }
+    return logsData;
+  }
+}
+
+// Overloading de las funciones de console
+console.log = Logger.log
+console.info = Logger.info
+console.warn = Logger.warn
+console.error = Logger.error
+console.debug = Logger.debug
+
+module.exports = Logger;

package/src/common/utils/nodemailerLib.js

@@ -0,0 +1,61 @@
+const nodemailer = require('nodemailer');
+const Logger = require("./logger");
+
+/**
+ * Obtiene la instancia del servicio para envío de correo electrónico.
+ * @param {object} mailSettings Parámetros de conexión.
+ * @returns Instancia de conexión al servidor de envío de correo.
+ * @see {@link https://nodemailer.com/smtp|NodeMailer SMTP TRANSPORT}
+ */
+exports.getEmailSender = async (mailSettings) => {
+    const { host, port = '2525', user, pass, encryption = 'tls' } = mailSettings;
+
+    const emailTransportOptions = { host, port, 'auth': { user, pass } };
+    switch (encryption) {
+        case 'tls':
+            emailTransportOptions.tls = { rejectUnauthorized: true }
+            break;
+        case 'ssl':
+            emailTransportOptions.secure = true
+            break;
+    }
+
+    // Se conecta al servidor de envío de correos
+    const transporter = nodemailer.createTransport(emailTransportOptions);
+    return new Promise((resolve, reject) => {
+        transporter.verify(err => {
+            if (err) {
+                Logger.error(err);
+                reject(err);
+            } else {
+                Logger.debug(`Connected to email server ${host}`);
+                resolve(transporter);
+            }
+        })
+    });
+};
+
+/**
+ * Realiza el envío del mensaje de correo electrónico.
+ * @param {*} mailSender Instancia de conexión al servidor de envío de correos.
+ * @param {*} emailOptions Objeto con las opciones de correo electrónico.
+ * @returns Respuesta del envío del mensaje.
+ */
+exports.sendEmail = async (mailSender, emailOptions, skipAttachment = true) => {
+    return new Promise((resolve, reject) => {
+        mailSender.sendMail(emailOptions).then(resolve).catch(err => {
+            if (skipAttachment && emailOptions?.attachments?.length) {
+                Logger.error("NodeMailer: Deleting attachments", {
+                    count: emailOptions.attachments.length,
+                    action: "cleanup",
+                    source: "emailService"
+                });
+                Logger.error(err);
+                delete emailOptions.attachments;
+                this.sendEmail(mailSender, emailOptions, false).then(resolve).catch(reject);
+            } else {
+                reject(err);
+            }
+        });
+    });
+}

package/src/common/utils/product-unit-converter.js

@@ -0,0 +1,168 @@
+const VtexApi = require("../../vtex/clients/VtexApi");
+const Logger = require("./logger");
+const Account = require("../../entities/account");
+
+// VARIABLES ACCOUNT: unitProductValue (especificaciones de producto), componentsKitQuantity (cantidad de componentes del kit)
+
+const convertQuantity = async (skuVtex, skuRefId, quantity, accountConfig, individualUnits) => {
+
+  Logger.setAccount(accountConfig);
+  Logger.debug('ProductUnitConversion: Inicio conversión', { skuVtex, skuRefId, quantity, accountConfig });
+
+  try {
+    const config = accountConfig?.ProductUnitConversion;
+
+    if (!config || !config.isActive) {
+      return quantity;
+    }
+
+    const unitProductFieldName = config.unitProduct; // String del nombre del campo
+    const componentsKits = config.useComponentsKits; // Booleano que indica si se utilizan kits de componentes
+    let unitProductValue = 1; // Valor por defecto
+    let componentsKitsQuantity = 1; // Valor por defecto
+    let componentsKitsQuantityMain = 1; // Valor por defecto
+    let unitMultiplierProduct = 1; // Valor por defecto unidad multiplicadora
+    let individualUnitsQuantity = individualUnits || 1;
+
+    let targetSku = [];
+
+    const vtexApi = new VtexApi(
+      accountConfig.AccountName,
+      accountConfig.Credentials.key,
+      accountConfig.Credentials.token
+    );
+
+    const detailSkuVtexPrincipal = await vtexApi.getDetailSkuById(skuVtex);
+    Logger.debug('ProductUnitConversion: Detalle SKU VTEX principal', { detailSkuVtexPrincipal });
+
+    if (!detailSkuVtexPrincipal || !Array.isArray(detailSkuVtexPrincipal) || detailSkuVtexPrincipal.length === 0) {
+      return quantity;
+    }
+
+    const productDetailVtexPrincipal = detailSkuVtexPrincipal[0];
+
+    if (productDetailVtexPrincipal && productDetailVtexPrincipal?.UnitMultiplier) {
+      unitMultiplierProduct= productDetailVtexPrincipal?.UnitMultiplier;
+    }
+
+    if (productDetailVtexPrincipal?.KitItems && productDetailVtexPrincipal.KitItems.length > 0) {
+      componentsKitsQuantityMain = productDetailVtexPrincipal.KitItems[0]?.Amount || 1;
+    }
+    
+    if (componentsKits && config?.relationalProductPrefix?.length > 0) {
+      const relationSkuRef = buildKitSku(skuRefId, config.relationalProductPrefix);
+      targetSku = await vtexApi.getDetailSkuPerSkuRef(relationSkuRef);
+
+      for (let i = 0; i < targetSku.length; i++) {
+        const sku = targetSku[i];
+        if (sku.KitItems.length === 1) {
+          componentsKitsQuantity = sku.KitItems[0].Amount || 1;
+        }
+      }
+    }
+
+    if (unitProductFieldName && unitProductFieldName !== "" && accountConfig) {
+      const specificationProductVtex = await getProductSpecificationPerProductId(productDetailVtexPrincipal.ProductId, vtexApi);
+      if (specificationProductVtex && specificationProductVtex[unitProductFieldName]) {
+        unitProductValue = parseInt(specificationProductVtex[unitProductFieldName][0]) || 1;
+      }
+    }
+    
+    const expression = getExpression(skuRefId, config.rules);
+
+    let variables = {
+      quantity,
+      unitProductValue,
+      componentsKitsQuantity,
+      componentsKitsQuantityMain,
+      individualUnitsQuantity,
+      unitMultiplierProduct
+    };
+
+    Logger.debug('ProductUnitConversion: Evaluando expresión', { expression, variables });
+    const result = evaluateExpression(expression, variables);
+
+    Logger.debug('ProductUnitConversion: Resultado de conversión', { result });
+    return typeof result === 'number' ? result : quantity;
+
+  } catch (error) {
+    Logger.error('ProductUnitConversion: Error en conversión', { skuVtex, skuRefId, quantity, error: error.message });
+    return quantity;
+  }
+};
+
+const buildKitSku = (skuRefId, prefixes) => {
+  if (!prefixes || !Array.isArray(prefixes)) {
+    return skuRefId;
+  }
+
+  let kitSku = [];
+
+  prefixes.forEach(prefix => {
+    if (prefix && prefix.value) {
+      if (prefix.position === 'initial') {
+        if (!skuRefId.startsWith(prefix.value)) {
+          kitSku.push(`${prefix.value}${skuRefId}`);
+        }
+      } else if (prefix.position === 'end') {
+        if (!skuRefId.endsWith(prefix.value)) {
+          kitSku.push(`${skuRefId}${prefix.value}`);
+        }
+      }
+    }
+  });
+
+  return kitSku;
+};
+
+
+const getExpression = (sku, rules) => {
+  if (!rules) {
+    return 'quantity';
+  }
+
+  if (rules.items && rules.items[sku]) {
+    return rules.items[sku];
+  }
+
+  return rules.default || 'quantity';
+};
+
+const evaluateExpression = (expression, variables) => {
+  try {
+    const { quantity, unitProductValue, componentsKitsQuantity, componentsKitsQuantityMain, individualUnitsQuantity, unitMultiplierProduct } = variables;
+    const result = eval(expression);
+    return Math.round(parseFloat(result));
+  } catch (error) {
+    Logger.error('ProductUnitConversion: Error evaluando expresión', {
+      expression,
+      variables,
+      error: error.message
+    });
+    return variables.quantity;
+  }
+};
+
+const getProductSpecificationPerProductId = async (productId, vtexApi) => {
+  try {
+    const response = await vtexApi.fetch(`/catalog_system/pvt/products/${productId}/specification`, {
+      method: "GET",
+    });
+    if (response?.status < 200 || response?.status > 299) {
+      throw new Error("Error getting SKU in VTEX");
+    }
+
+    let specifications = {};
+    for (let i = 0; i < response.data.length; i++) {
+      const esp = response.data[i];
+      specifications[esp.Name] = esp.Value;
+    }
+    return specifications;
+
+  } catch (error) {
+    Logger.error("Error getting product specification", { productId, error: error.message });
+    return null;
+  }
+};
+
+module.exports = convertQuantity;