vtlab-generic-functions 1.0.4

package/dataMapper/index.js

@@ -0,0 +1,61 @@
+let dot = require('dot-object');
+
+
+/**
+ * This function will transform the incoming values received on data onto the outgoing mapped values, returning a JSON object.
+ * @param data Values required for transformations
+ * @param model Models required to say how the values need to be transformed. Property `transformation` and `originKey` is must
+ * @returns {{}|*}
+ */
+const parseFields = (data = {}, model = {}) => {
+
+  //validate the parameter
+  if (typeof data !== 'object' || typeof model !== 'object')
+    return {};
+
+  // declare the mapped value to return
+  let mappedData = {};
+
+  //transformation function
+  let makeTransformations = function (data, model, parent = '') {
+
+    if (typeof model !== 'object')
+      return null;
+
+    //loop all the keys in the model
+    for (let modelKey in model) {
+
+      //return if the key is the property of the model. eg: __proto__, [[Prototype]] etc.,
+      if (!model.hasOwnProperty(modelKey))
+        continue;
+
+      //each model
+      let currentModel = model[modelKey];
+
+      // if the model has sub model
+      if (typeof currentModel === 'object' && !currentModel.transformation && !currentModel.originKey) {
+        makeTransformations(data, currentModel, parent + modelKey + '.');
+      } else {
+
+        //if model doesn't has sub model
+        try {
+          mappedData[parent + modelKey] = currentModel.transformation(data);
+        } catch (e) {
+          // set `null` if transformation doesn't exist or error during the transformation
+          mappedData[parent + modelKey] = null;
+        }
+      }
+    }
+
+  };
+
+  // call transformation. return value is doted object eg: { 'depth0.depth1.depth2':valueOfDepth2 }
+  makeTransformations(data, model);
+
+  //make the proper object from the doted object. result is {depth0: {depth1: depth2: 'valueOfDepth2'}}
+  return dot.object(mappedData); //make it nested object
+};
+
+module.exports = {
+  parseFields
+};

package/emails/index.js

@@ -0,0 +1,153 @@
+const nodemailer = require("nodemailer");
+const MailComposer = require("nodemailer/lib/mail-composer");
+const { SESClient, SendRawEmailCommand } = require("@aws-sdk/client-ses");
+const config = require("../config");
+
+const CODES_TYPE = {
+    INPUT_DATA_ERROR : 'input_data_error',
+    SUCCESSFULL_OP :'successfull_op',
+    GENERIC_ERROR: 'generic_error'
+}
+
+/**
+ * Sends an email using a SMTP server.
+ *
+ * @param {Object} options - The email options.
+ * @param {string} options.host - The SMTP server host.
+ * @param {number} [options.port=587] - The SMTP server port.
+ * @param {string} options.user - The SMTP server username.
+ * @param {string} options.password - The SMTP server password.
+ * @param {string} options.from - The sender's email address.
+ * @param {string|string[]} options.to - The recipient's email address(es).
+ * @param {string} options.subject - The subject of the email.
+ * @param {string} [options.htmlBody] - The HTML body of the email.
+ * @param {string} [options.textBody] - The text body of the email.
+ * @returns {Promise<Object>} - A promise that resolves to the result of the email sending operation.
+ * @throws {Object} - An error object with detailed information if the operation fails.
+ */
+const sendMail = async ({host, port=587, user, password, from, to, subject, htmlBody, textBody}) =>{
+
+    if(isNaN(port)){
+        throw {
+            code : CODES_TYPE.INPUT_DATA_ERROR,
+            message : "El parámetro 'port' no es numérico",
+            alternative: "Asegúese de que el 'port' es númerico. Posiblemente adoptará el valor 587 o 465",
+            dataError: {}
+        };
+    }
+
+    try{
+
+        port = parseInt(port);
+        let secure = port === 465 ? true : false;
+
+
+        let transporter = nodemailer.createTransport({
+            host: host,
+            port: port,
+            secure: secure, // true for 465, false for other ports
+            auth: {
+                user: user, // generated ethereal user
+                pass: password, // generated ethereal password
+            },
+            tls: {
+                rejectUnauthorized: false
+            }
+        });
+
+        let info = await transporter.sendMail({
+            from: from,   //'"Fred Foo 👻" <foo@example.com>',
+            to: to,   // "bar@example.com, baz@example.com", // list of receivers
+            subject: subject,  //"Hello ✔", // Subject line
+            text: textBody ? textBody : '', //"Hello world?", // plain text body
+            html: htmlBody ? htmlBody : '' //"<b>Hello world?</b>", // html body
+          });
+
+        return {
+            code: CODES_TYPE.SUCCESSFULL_OP,
+            message: 'Mail enviado correctamente',
+            alternative:'',
+            data: info
+        }
+
+
+    }catch(err){
+        throw {
+            code: CODES_TYPE.GENERIC_ERROR,
+            message: 'Se ha producido un error en el envío de mail',
+            alternative: 'Consulte el error retornado',
+            dataError: err
+        }
+    }
+}
+
+
+/**
+ * Sends an email using AWS SES with optional file attachment.
+ *
+ * @param {Object} mailParameters - Parameters for the email.
+ * @param {Buffer|string} [mailParameters.file] - The file to attach in the email.
+ * @param {string} [mailParameters.subject="Default subject (subject not provided)"] - The subject of the email.
+ * @param {string} [mailParameters.text="Default text (text not provided)"] - The text body of the email.
+ * @param {string} [mailParameters.fileName=`${Date.now()}.txt`] - The name of the attached file.
+ * @param {string|string[]} [mailParameters.to="develop@tookane.com"] - The recipient's email address(es).
+ * @param {string} [mailParameters.contentType='text/plain'] - The content type of the file.
+ * @returns {Promise<void>} - A promise that resolves when the email is sent.
+ * @throws {Error} - An error if sending the email fails.
+ */
+const sendMailWithSES = async (mailParameters) => {
+    const {
+        file,
+        subject = "Default subject (subject not provided)",
+        text = "Default text (text not provided)",
+        fileName = `${Date.now()}.txt`,
+        to = "develop@tookane.com",
+        contentType = 'text/plain'
+    } = mailParameters;
+
+    let attachments = [];
+    if (file) {
+        attachments.push({
+            filename: fileName,
+            content: typeof file === 'string' ? Buffer.from(file, 'base64') : file,
+            contentType
+        });
+    }
+
+    let mail = new MailComposer({
+        to: Array.isArray(to) ? to.join(",") : to,
+        subject,
+        text,
+        attachments
+    });
+
+    let RawMessage = await mail.compile().build();
+    let params = {
+        RawMessage: {
+            Data: RawMessage
+        },
+        Destinations: Array.isArray(to) ? to : [to],
+        Source: "develop@tookane.com", // Replace with your verified SES email
+    };
+
+    const awsCredentials = await config.get('awsCredentials');
+
+
+    const sesClient = new SESClient({
+          region: awsCredentials.region,
+          credentials: {
+            accessKeyId: awsCredentials.accessKeyId,
+              secretAccessKey: awsCredentials.secretAccessKey
+        }
+    });
+
+    const command = new SendRawEmailCommand(params);
+    await sesClient.send(command);
+};
+
+
+
+module.exports = {
+    sendMail,
+    sendMailWithSES
+}

package/ftp/ftp-promise-wrapper.js

@@ -0,0 +1,109 @@
+const promiseFTP = require("promise-ftp");
+/**
+ *
+ * Internal functions
+ */
+
+const streamToBuffer = (stream) => {
+  let _buf = [];
+  return new Promise((resolve, reject) => {
+    try {
+      stream.once("close", resolve);
+      stream.once("error", reject);
+      stream.pipe((chunk) => Buffer.concat(chunk));
+    } catch (err) {
+      reject(err);
+    }
+  });
+};
+
+/**
+ *
+ * EXTERNAL FUNCTIONS
+ */
+//downloadFromFTP
+const downloadFromFTP = async (ftp, remotePathWithFile) => {
+  let _buf = [];
+  let Stream = require("stream");
+  const writableStream = new Stream.Writable();
+  writableStream._write = (chunk, encoding, next) => {
+    _buf.push(chunk);
+    next();
+  };
+  return ftp
+    .get(remotePathWithFile)
+    .then((stream) => {
+      return new Promise(function (resolve, reject) {
+        stream.once("close", resolve);
+        stream.once("error", reject);
+        stream.pipe(writableStream);
+      });
+    })
+    .then(() => {
+      return _buf;
+    })
+    .catch((err) => {
+      throw err;
+    });
+};
+
+//uploadFileToFTP
+const uploadFileToFTP = async (
+  config,
+  localPathWithFile,
+  remotePathWithFile
+) => {
+  /**
+   * config ={
+      host: 'ftp.islgrupo.com',
+      user: 'testpelikane',
+      password: 'Pelikane2021+',
+      port: <OPtional>
+    }
+   */
+  let ftp = new promiseFTP();
+  try {
+    await ftp.connect(config);
+    await ftp.put(localPathWithFile, remotePathWithFile);
+    return { code: 200, message: "FTP successfull ulpload" };
+  } catch (err) {
+    throw err;
+  }
+};
+
+/**
+ * To check the file existence in the FTP
+ * @param ftp
+ * @param filePath
+ * @returns {Promise<boolean>}
+ */
+const isFileExistsInFTP = async (ftp, filePath) => {
+  try {
+    let exists = await ftp.list(filePath);
+    return exists.length > 0;
+  } catch (e) {
+    throw e;
+  }
+};
+
+/**
+ * to delete a file
+ * @param ftp
+ * @param filePath
+ * @returns {Promise<void>}
+ */
+const deleteFileFromFTP = async (ftp, filePath) => {
+  try {
+    await ftp.delete(filePath);
+  } catch (e) {
+    throw e;
+  }
+};
+
+
+module.exports = {
+  uploadFileToFTP,
+  downloadFromFTP,
+  isFileExistsInFTP,
+  deleteFileFromFTP
+};

package/ftp/index.js

@@ -0,0 +1,194 @@
+const Client = require('ssh2-sftp-client');
+const fs = require ('fs');
+
+// THIS FILE ONLY WORKS WITH SFTP. FOR FTP USE THE INSTALLED NODE MODULE PROMISE-FTP
+
+const FTP_CODES = {
+    CONNECTION_FAILED : 'connection_failed',
+    DISCONNECTED_CLIENT: 'disconnected_client',
+    UPLOAD_FAILED: 'upload_failed',
+    UPLOAD_SUCCESFULLY: 'upload_succesfully',
+    DOWNLOAD_FAILED: 'download_failed',
+    DOWNLOAD_SUCCESFULLY: 'download_succesfully',
+    OPERATION_NOT_FOUND: 'operation_not_found',
+    GENERIC_ERROR:'generic_error'
+}
+
+const getFileFromFtp = async ({host, user, password, localPathWithFile, remotePathWithFile}) => {
+
+    try{
+        let dst = fs.createWriteStream(localPathWithFile);
+        //let dst = localPathWithFile;
+
+        let sftp = new Client();
+        await sftp.connect({
+            host: host,
+            username: user,
+            password: password
+        });
+
+        /*let listData = await sftp.list('/OUT/monto/');
+        sftp.end(); //BORRAR
+        return listData;*/
+
+        await sftp.get(remotePathWithFile,dst);
+
+        return {
+                code: FTP_CODES.DOWNLOAD_SUCCESFULLY,
+                message: 'La descarga del fichero se ha realizado correctamente',
+                alternative: '',
+                data:{}
+            };
+
+    }catch(err){
+        throw {
+            code: FTP_CODES.GENERIC_ERROR,
+            message: 'Se ha producido un error durante la descarga del fichero',
+            alternative: 'Consultar el detalle del error',
+            dataError: err
+        }
+    }finally{
+        try{
+            sftp.end();
+        }catch(e){
+
+        }
+    }
+
+}
+
+const uploadFileToFtp = async ({host, user, password, localPathWithFile, remotePathWithFile}) => {
+
+    try{
+        let sftp = new Client();
+        await sftp.connect({
+            host: host,
+            username: user,
+            password: password
+        });
+
+        sftp.put(localPathWithFile,remotePathWithFile);
+
+        return {
+                code: FTP_CODES.DOWNLOAD_SUCCESFULLY,
+                message: 'La subida del fichero al servidor se ha realizado correctamente',
+                alternative: '',
+                data:{}
+            };
+
+    }catch(err){
+        throw {
+            code: FTP_CODES.GENERIC_ERROR,
+            message: 'Se ha producido un error durante la descarga del fichero',
+            alternative: 'Consultar el detalle del error',
+            dataError: err
+        }
+    }finally{
+        try{
+            sftp.end();
+        }catch(e){
+
+        }
+    }
+
+}
+
+const uploadFileFtpWithClient = async ({client, pathFrom, pathTo}) =>{
+    /*if(client.closed) {
+        throw {
+            code: FTP_CODES.DISCONNECTED_CLIENT,
+            message: 'El cliente no está conectado',
+            alternative: 'Conéctese de nuevo al servidor.',
+            dataError: {}
+        }
+    }
+
+    try{
+
+        await client.uploadFrom(pathFrom, pathTo)
+        return  {
+            code: FTP_CODES.UPLOAD_SUCCESFULLY,
+            message: 'Se ha subido correctamente el fichero al servidor',
+            alternative: 'Recuerde cerrar la conexión si no va a hacer más operaciones sobre el servidor.',
+            data: {}
+        }
+
+    }catch(err){
+        throw {
+            code: FTP_CODES.UPLOAD_FAILED,
+            message: 'Error en la subida del fichero al servidor',
+            alternative: 'Ver error generado por el servidor e intentarlo de nuevo.',
+            dataError: err
+        }
+    }*/
+}
+
+const downloadFileFtpWithClient = async ({client, pathFrom, pathTo}) =>{
+    /*if(client.closed) {
+        throw {
+            code: FTP_CODES.DISCONNECTED_CLIENT,
+            message: 'El cliente no está conectado',
+            alternative: 'Conéctese de nuevo al servidor.',
+            dataError: {}
+        }
+    }
+
+    try{
+
+        await client.downloadTo(pathFrom, pathTo)
+        return  {
+            code: FTP_CODES.DOWNLOAD_SUCCESFULLY,
+            message: 'Se ha subido correctamente el fichero al servidor',
+            alternative: 'Recuerde cerrar la conexión si no va a hacer más operaciones sobre el servidor.',
+            data: {}
+        }
+
+    }catch(err){
+        throw {
+            code: FTP_CODES.DOWNLOAD_FAILED,
+            message: 'Error en la descarga del fichero al servidor',
+            alternative: 'Ver error generado por el servidor e intentarlo de nuevo.',
+            dataError: err
+        }
+    }*/
+}
+
+const uploadOrDownloadFileFtp = async ({host, user, password, secure=false, typeOp='upload', pathFrom, pathTo}) =>{
+   /* try{
+        let result ={};
+        let client = await getFtpClient({host, user, password, secure=false})
+        if(typeOp==='upload'){
+            let uploadRes = await uploadFileFtpWithClient ({client, pathFrom, pathTo});
+            result = uploadRes;
+        }else if( typeOp === 'download'){
+            let downloaddRes = await downloadFileFtpWithClient ({client, pathFrom, pathTo});
+            result = downloaddRes
+        }else{
+            throw {
+                code: FTP_CODES.OPERATION_NOT_FOUND,
+                message: 'La operación no está disponible',
+                alternative: 'Incluye sólo las operaciones disponibles',
+                dataError: {}
+            }
+        }
+        client.close()
+
+        return result;
+
+    }catch(err){
+        throw {
+            code: FTP_CODES.GENERIC_ERROR,
+            message: 'Error al intentar la operación FTP',
+            alternative: 'Revise los datos del error',
+            dataError: err
+        }
+    }*/
+}
+
+module.exports = {
+    getFileFromFtp,
+    uploadFileToFtp,
+    uploadFileFtpWithClient,
+    downloadFileFtpWithClient,
+    uploadOrDownloadFileFtp
+}

package/ftp/jsftp-wrapper.js

@@ -0,0 +1,107 @@
+const jsFtp = require("jsftp");
+
+// create connection
+const connect = (config) => {
+  return new jsFtp({
+    host: config.host,
+    user: config.user, // defaults to "anonymous"
+    pass: config.password, // defaults to "@anonymous"
+  });
+}
+
+
+//uploadFileToFTP
+const uploadFileToFTP = async (
+  ftp,
+  localPathWithFile,
+  remotePathWithFile
+) => {
+  return new Promise((resolve, reject) => {
+    try {
+      if (!ftp) {
+        throw 'FTP not connected';
+      }
+      ftp.put(localPathWithFile, remotePathWithFile, (err) => {
+        if (!err) {
+          return { code: 200, message: "FTP successfull ulpload" };
+        }
+        reject(err);
+      });
+    } catch (err) {
+      throw err;
+    }
+  })
+};
+
+
+/**
+ *
+ * EXTERNAL FUNCTIONS
+ */
+//downloadFromFTP
+const downloadFromFTP = async (ftp, remotePathWithFile) => {
+  return new Promise((resolve, reject) => {
+    let file = [];
+    try {
+      if (!ftp) {
+        throw 'FTP not connected';
+      }
+      ftp.get(remotePathWithFile, (err, socket) => {
+        if (err) {
+          reject(err);
+        } else {
+          socket.on("data", d => {
+            file.push(d);
+          });
+
+          socket.on("close", err => {
+            if (err) {
+              throw err;
+            }
+            resolve(Buffer.concat(file));
+          });
+          socket.resume();
+        }
+      });
+    } catch (e) {
+      console.log(e);
+      reject('There was an error reading the file');
+    }
+  })
+};
+
+const listFilesFromFolder = async (ftp, folder) => {
+  return new Promise((resolve, reject) => {
+    if (!ftp) {
+      reject('FTP not connected');
+    }
+    ftp.ls(folder, (err, res) => {
+      if (err) {
+        reject(err);
+      }
+      resolve(res);
+    });
+  })
+}
+
+const deleteFromFTP = async (ftp, pathToFile) => {
+  return new Promise((resolve, reject) => {
+    if (!ftp) {
+      reject('FTP not connected');
+    }
+    ftp.raw("DELE", pathToFile, (err, res) => {
+      if (err) {
+        reject(err);
+      }
+      resolve(res);
+    });
+  })
+}
+
+module.exports = {
+  connect,
+  uploadFileToFTP,
+  downloadFromFTP,
+  listFilesFromFolder,
+  deleteFromFTP,
+};