vtlab-generic-functions 1.0.4

package/ftp/ssh2SFPTWrapper.js

@@ -0,0 +1,175 @@
+var Client = require('ssh2').Client
+
+/**
+ * List all files inside sftp for a certain path
+ * @param {object} config the configuration including host user port and password
+ * @param {string} path the path to retrieve the list from
+ */
+
+const listDirectory = (config, path = '.') => {
+  return new Promise((resolve, reject) => {
+    const conn = new Client();
+    const connSettings = {
+      host: config.host,
+      username: config.user,
+      tryKeyboard: true,
+      port: config.port,
+    };
+
+    conn.on('ready', function () {
+      conn.sftp(function (err, sftp) {
+        if (err) reject(err);
+        sftp.readdir(path, function (err, list) {
+          if (err) {
+            reject(err)
+          }
+          conn.end();
+          resolve(list)
+        })
+      });
+    })
+
+    conn.on('keyboard-interactive', function (name, instr, lang, prompts, cb) {
+      console.log("keyboard-interactive");
+      cb([config.password]);
+    }).connect(connSettings);
+  })
+}
+
+/**
+ * Writes a file in the desired path
+ * @param {object} config the configuration including host user port and password
+ * @param {string} path the path to save the file
+ * @param {object} content a buffer of the data to write
+ */
+
+const writeFile = (config, path, content) => {
+  return new Promise((resolve, reject) => {
+    const conn = new Client();
+    const connSettings = {
+      host: config.host,
+      username: config.user,
+      tryKeyboard: true,
+      port: config.port,
+    };
+
+    conn.on('ready', function () {
+      conn.sftp(function (err, sftp) {
+        if (err) reject(err);
+        const writeStream = sftp.createWriteStream(path);
+        const data = writeStream.end(content);
+        writeStream.on('close', function() {
+          console.log("- file transferred succesfully");
+          resolve(data);
+          conn.end();
+        });
+      });
+    })
+
+    conn.on('keyboard-interactive', function (name, instr, lang, prompts, cb) {
+      console.log("keyboard-interactive");
+      cb([config.password]);
+    }).connect(connSettings);
+  })
+}
+
+/**
+ * Deletes a file from the sftp
+ * @param {object} config the configuration including host user port and password
+ * @param {string} path the path to delete the file
+ */
+
+const deleteFile = (config, path) => {
+  return new Promise((resolve, reject) => {
+    const conn = new Client();
+    const connSettings = {
+      host: config.host,
+      username: config.user,
+      tryKeyboard: true,
+      port: config.port,
+    };
+
+    conn.on('ready', function () {
+      conn.sftp(function (err, sftp) {
+        if (err) reject(err);
+        sftp.unlink(path, function(err) {
+          if (err) {
+            console.log("Error in removing directory", err);
+            conn.end();
+            reject(err);
+          } else {
+            console.log("Directory remove from server");
+            conn.end();
+            resolve("deleted");
+          }
+        });
+
+      });
+    })
+
+    conn.on('keyboard-interactive', function (name, instr, lang, prompts, cb) {
+      console.log("keyboard-interactive");
+      cb([config.password]);
+    }).connect(connSettings);
+  })
+}
+
+/**
+ * Retrieves a file in the desired path. Returns a buffer, use toString
+ * @param {object} config the configuration including host user port and password
+ * @param {string} path the path to get the file
+ */
+
+const getFile = (config, path) => {
+  return new Promise((resolve, reject) => {
+    const conn = new Client();
+    const connSettings = {
+      host: config.host,
+      username: config.user,
+      tryKeyboard: true,
+      port: config.port,
+    };
+
+    let localFile;
+
+    conn.on('ready', function () {
+      conn.sftp(function (err, sftp) {
+        if (err) reject(err);
+        sftp.readFile(path, function(err, file) {
+          if (err) {
+            console.log("Error on listing directory", err);
+            reject(err);
+          } else {
+            localFile = file;
+            conn.end();
+          }
+        });
+
+      });
+    })
+
+    conn.on('close', function() {
+      if (localFile) {
+        resolve(localFile);
+      }
+      reject("Error on retrieving single file");
+    })
+
+    conn.on('error', function() {
+      reject("Error on retrieving single file");
+    })
+
+    conn.on('keyboard-interactive', function (name, instr, lang, prompts, cb) {
+      console.log("keyboard-interactive");
+      cb([config.password]);
+    }).connect(connSettings);
+  })
+}
+
+
+module.exports = {
+  listDirectory,
+  writeFile,
+  deleteFile,
+  getFile
+}

package/geocode/README.md

@@ -0,0 +1,18 @@
+### Example usage from Lambda JS:
+
+```javascript
+
+  try {
+
+    let result = await geocode.getCoordinates({
+      "logId": "apiGateway/microservices",
+      "payload": []
+    });
+
+
+    console.log(result.data);
+
+  } catch (error) {
+    console.log('ERROR', error);    
+  }
+```

package/geocode/index.js

@@ -0,0 +1,28 @@
+const request = require('../axios');
+const config = require('../config');
+
+/**
+ * Get coordinates from PEL backend
+ * @param params
+ * @returns {Promise<unknown>}
+ */
+exports.getCoordinates = async (params) => {
+  return new Promise(async (resolve, reject) => {
+    try {
+
+      let geoConfig = await config.get('geocode');
+      let url = `${geoConfig.url}`;
+      let result = await request.get(url, {
+        'auth': geoConfig.auth, // from secret manager
+        'logId': params.logId // from lambda function
+      });
+
+      // return result
+      resolve(result);
+    } catch (error) {
+
+      //return error
+      reject(error);
+    }
+  });
+};

package/lambda/index.js

@@ -0,0 +1,68 @@
+// Importing only the required client and commands from AWS SDK v3
+const { LambdaClient, InvokeCommand } = require("@aws-sdk/client-lambda");
+
+/**
+ * DEPRECATED: Invokes lambda function
+ * @param payload {Object} Input should be Object or JSON Stringified
+ * @param functionName {String} lambda function name
+ * @returns {Promise<unknown>} Returns the result of the lambda function
+ */
+const invoke = async (payload, functionName) => {
+    console.log("invoke function on shared layer its deprecated, use intead invokeLambda");
+    if (typeof payload === "object" && !Array.isArray(payload) && payload !== null) {
+        payload = JSON.stringify(payload);
+    }
+
+    const client = new LambdaClient({
+        maxAttempts: 3, // Max retries
+    });
+
+    const command = new InvokeCommand({
+        FunctionName: functionName,
+        Payload: Buffer.from(payload)
+    });
+
+    try {
+        const { Payload } = await client.send(command);
+        return JSON.parse(Payload.toString());
+    } catch (error) {
+        throw error;
+    }
+};
+
+/**
+ * Invokes a specified AWS Lambda function.
+ *
+ * @param {Object|string} payload - The payload to send to the Lambda function. If an object is provided, it will be stringified.
+ * @param {string} functionName - The name of the Lambda function to invoke.
+ * @param {Object} [options={}] - Optional parameters for the function invocation.
+ * @param {number} [options.timeout=900000] - The timeout in milliseconds for the Lambda function. Defaults to 900,000 (15 minutes).
+ * @param {number} [options.maxCount=2] - The maximum number of retry attempts for the Lambda function invocation. Defaults to 2.
+ * @returns {Promise<unknown>} A promise that resolves with the result of the Lambda function invocation.
+ * @throws {Error} Throws an error if the invocation fails and exceeds the maximum retry count.
+ *
+ */
+const invokeLambda = async (payload, functionName, options = {}) => {
+    let { timeout, maxCount } = options;
+    const client = new LambdaClient({
+        maxAttempts: maxCount || 3,
+    });
+
+    const command = new InvokeCommand({
+        FunctionName: functionName,
+        Payload: Buffer.from(payload)
+    });
+
+    try {
+        const { Payload } = await client.send(command);
+        return JSON.parse(Payload.toString());
+    } catch (error) {
+        throw error;
+    }
+};
+
+// Export
+module.exports = {
+    invoke, // deprecated
+    invokeLambda
+};

package/lambdaClass/index.js

@@ -0,0 +1,267 @@
+const cloudwatch = require("../cloudwatch");
+const utils = require("../utils");
+const axiosRequest = require("../axios");
+const axios = require("axios");
+const promiseFTPWrapper = require("../ftp/ftp-promise-wrapper");
+const promiseFTP = require("promise-ftp");
+const s3bucket = require("../s3bucket");
+
+module.exports = class Lambda {
+  event;
+  logGroupName;
+  logUuid;
+  jobs;
+  auth;
+  carrier;
+  configFTP = {};
+  ftpFolders = {};
+  ftpConnection;
+  jobsByTrackingId;
+  DEBUG;
+
+  results = {
+    totalError: 0, totalSuccess: 0, error: [], success: [],
+  };
+
+  constructor({carrier, event, DEBUG = false}) {
+    this.DEBUG = false;
+    this.carrier = carrier;
+    if (event.body) {
+      //Locally we receive event.body, event.body needs to be parsed. In AWS all fields are into event. (event={lodId:'...', payload:[]})
+      event = JSON.parse(event.body);
+    }
+    this.event = event.body ? event.body : event;
+
+    this.logGroupName = event.logId.split(" ")[0];
+    this.logUuid = event.logId.split(" ")[1] + ": Lambda(" + Math.round(Math.random() * 10000).toString(32) + ")- ";
+    this.logStreamName = event.logId.split(" ")[2];
+    global.LOG_STREAM_NAME = event.logId.split(" ")[2];
+
+    this.env = event.auth.env || event.auth.environment || event.auth.mainEnv || process.env.NODE_ENV;
+    this.credentialsEnv = event.auth.credentialsEnv;
+    if (event.auth.ftp) this.ftpSettings = event.auth.ftp;
+
+    process.env.NODE_ENV = this.env;
+
+    this.jobs = event.payload;
+    this.auth = event.auth;
+
+    this.configFTP.host = utils.getValueOrNullControl(this.auth, "ftp.host", false, "ftp.islgrupo.com");
+    this.configFTP.user = utils.getValueOrNullControl(this.auth, "ftp.user", false, "");
+    this.configFTP.password = utils.getValueOrNullControl(this.auth, "ftp.password", false, "");
+    this.ftpFolders.podFolder = utils.getValueOrNullControl(this.auth, "ftp.podFolder", false, "");
+
+    if (utils.getValueOrNull(this.auth, "ftp.port")) this.configFTP.port = this.auth.ftp.port;
+
+    this.DEBUG = DEBUG;
+  }
+
+  s3 = {
+    upload: async (data, path) => {
+      return await s3bucket.uploadToS3(path, data, {
+        ContentEncoding: "base64", ContentType: "image/png",
+      });
+    }, download: async (path) => {
+      return await s3bucket.downloadFileFromS3(path);
+    },
+  };
+  http = {
+    get: async (URL, params, headers = {}) => {
+      return await axiosRequest.get(URL, {
+        auth: {}, logId: this.logGroupName, headers: {...headers}, ...params
+      });
+    }, delete: async (URL, params, headers) => {
+      return await axiosRequest.deletion(URL, {
+        auth: {}, logId: this.logGroupName, headers: {...headers}, ...params
+      });
+    }, post: async (URL, params, headers) => {
+      return await axiosRequest.post(URL, {
+        auth: {}, logId: this.logGroupName, headers: {...headers}, ...params,
+      });
+    }, put: async (URL, params, headers) => {
+      return await axiosRequest.put(URL, {
+        auth: {}, logId: this.logGroupName, headers: {...headers}, ...params
+      });
+    }, downloadFile: async (method, URL, params, s3Path) => {
+      let response = await axiosRequest[method](URL, {
+        auth: {}, logId: this.logGroupName, headers: {}, config: {responseType: 'arraybuffer'}, ...params
+      });
+      let buff = Buffer.from(response.data, "binary");
+      let s3PathUploaded = await this.s3.upload(buff, s3Path);
+      return s3PathUploaded;
+    }, postForm: async (URL, {attachment, document}, _headers) => {
+      const formData = new FormData();
+      formData.append('document', JSON.stringify(document));
+      formData.append('attachment', attachment, "document.pdf");
+
+      const config = {
+        method: 'post', url: URL, headers: {
+          'Authorization': _headers.Authorization, ...formData.getHeaders(),
+        }, data: formData
+      };
+
+      try {
+        return await axios.request(config);
+      } catch (error) {
+        throw error;
+      }
+    },
+  };
+
+  ftp = {
+    connect: async () => {
+      try {
+        //Connect to FTP
+        this.ftpConnection = new promiseFTP();
+        await this.ftpConnection.connect(this.configFTP);
+        this.logMessage(`Correctly Connected To FTP`, true);
+      } catch (error) {
+        throw {message: "Error from FTP"};
+      }
+    }, listFolder: async (folderAndRegexp) => {
+      if (!this.ftpConnection) throw {message: "No connection was stablished"};
+      let files = await this.ftpConnection.list(folderAndRegexp);
+      if (!files || files.length < 1) throw {message: "No files were found"};
+      this.logMessage(`Files Found: ${files.map((f) => f.name)}`);
+      return files;
+    }, download: async ({folder, file}) => {
+      if (!this.ftpConnection) throw {message: "No connection was stablished"};
+      let downloadedFile = await promiseFTPWrapper.downloadFromFTP(this.ftpConnection, `${folder}${file}`);
+      return downloadedFile;
+    }, putFile: async ({path, file}) => {
+      await promiseFTPWrapper.uploadFileToFTP(this.configFTP, file, path);
+    }, downloadFiles: async ({folder, _files, removeFiles = false}) => {
+      const files = [..._files];
+      if (!this.ftpConnection) throw {message: "No connection was stablished"};
+      for (let i = 0; i < files.length; i++) {
+        let file = await this.ftp.download({folder, file: files[i].name});
+        if (file) {
+          files[i].file = file;
+          if (removeFiles) await this.ftp.deleteFile(folder, files[i]);
+        }
+      }
+      return files;
+    }, deleteFile: async (folder, file) => {
+      await promiseFTPWrapper.deleteFileFromFTP(this.ftpConnection, `${folder}/${file}`);
+    }, closeConnection: async () => {
+      if (!this.ftpConnection) throw {message: "No connection was stablished"};
+      this.ftpConnection.end();
+    }, sortFiles: (filesList) => {
+      return filesList.sort((a, b) => {
+        const dateA = a.date;
+        const dateB = b.date;
+        if (dateA < dateB) {
+          return -1;
+        }
+        if (dateA > dateB) {
+          return 1;
+        }
+        return 0;
+      });
+    }, getJobMatchingFile: (file) => {
+      if (!file) throw {message: "No file was sent"};
+      let jobFound = [...this.jobs].find((job) => {
+        return String(file.name).includes(utils.getValueOrNull(job, "externalCarrier.trackingId"));
+      });
+      return jobFound;
+    },
+  };
+
+  logMessage = async (message) => {
+    await cloudwatch.putLogEvents(`${this.logUuid} ${message}`, this.logGroupName, 2, this.logStreamName);
+  };
+
+  logError = async (error) => {
+    await this.logMessage("(Error) : " + error.message ? error.message : JSON.stringify(error));
+  };
+
+  logStartingProcess = async () => {
+    await this.logMessage("Starting Process: Data received >>>" + utils.dataToString(this.event, "data").res, true);
+  };
+
+  logSendingToCarrier = async (payload) => {
+    await this.logMessage(`Sending to ${this.carrier} ${utils.dataToString({...payload}, "data").res}`, true);
+  };
+
+  logReceivedFromCarrier = async (payload, status) => {
+    await this.logMessage(`Received from ${this.carrier} (${status}) ${utils.dataToString({...payload}, "data").res}`, true);
+  };
+
+  addSuccessResult = (payload) => {
+    this.results.totalSuccess++;
+    this.results.success.push(payload);
+  };
+
+  addErrorResult = (payload) => {
+    this.results.totalError++;
+    this.results.error.push(payload);
+  };
+
+  clearResults = () => {
+    this.results = {
+      totalError: 0, totalSuccess: 0, error: [], success: [],
+    };
+  };
+
+  bulkAddSuccessResult = (extra = {}) => {
+    this.clearResults();
+    this.jobs.forEach((job) => this.addSuccessResult({
+      _id: job._id, trackingId: job.externalCarrier.trackingId, ...extra,
+    }));
+  };
+
+  bulkAddErrorResult = (error) => {
+    this.clearResults();
+    this.jobs.forEach((job) => this.addErrorResult({
+      _id: job._id,
+      trackingId: job.externalCarrier.trackingId,
+      code: error.code || 417,
+      message: error.message || "Something Went Wrong",
+      carrierCode: error.carrierCode || "tookaneCode",
+      carrierMessage: error.carrierMessage || "Something Went Wrong",
+    }));
+  };
+
+  logFinishProcess = async ({error} = {}) => {
+    if (this.results.totalError || error) {
+      error = error && error.message ? error.message : error;
+      await this.logMessage("Finsish Process with errors: " + (error || "") + " " + JSON.stringify(this.results));
+    } else {
+      await this.logMessage("Finsish Process Sucessfully: " + JSON.stringify(this.results));
+    }
+  };
+
+  validatePayload = () => {
+    if (this.jobs.length < 1) throw {message: "No Jobs were sent"};
+  };
+
+  getJobsByTrackingId = () => {
+    let objToReturn = {};
+    this.jobs.forEach((job) => {
+      let valueFound = utils.getValueOrNull(job, "externalCarrier.trackingId");
+      if (valueFound) objToReturn[job._id] = {trackingId: valueFound};
+      objToReturn[job._id].jobOwner = {
+        account: {_id: job.jobOwner.account._id},
+      };
+    });
+    return objToReturn;
+  };
+
+  endSuccess = () => {
+    return {
+      isBase64Encoded: false, statusCode: 200, body: utils.dataToString(this.results, "data").res,
+    };
+  };
+  endError = (e) => {
+    let {code, res} = utils.dataToString(e);
+    let body = {
+      code, message: res, carrierCode: e.carrierCode, carrierMessage: e.carrierMessage,
+    };
+    return {isBase64Encoded: false, statusCode: code ? code : 417, body: res};
+  };
+  getToken = () => {
+    const token = `${this.auth.username}:${this.auth.password}`;
+    const encodedToken = Buffer.from(token).toString("base64");
+    return encodedToken;
+  };
+};

package/mongodb/README.md

@@ -0,0 +1,16 @@
+#### models
+each file represents the collections/models name in the mongo database.
+
+#### index.js
+extend the export by including the models/{collections}
+
+### Example usage from Lambda JS:
+```
+  const db = await pelMongo.connectToDatabase({
+    MONGODB_URI: 'Connection String',
+    MONGODB_DATABASE: 'Database Name'
+  });
+
+  let users = pelMongo.findAllUsers(db);
+  console.log(users);
+```

package/mongodb/connect-to-mongodb.js

@@ -0,0 +1,57 @@
+'use strict';
+// Import dependency.
+const {MongoClient} = require('mongodb');
+
+// Function for connecting to MongoDB, returning a new or cached database connection
+module.exports.connectToDatabase = async function connectToDatabase(params) {
+
+
+// Connection string to the database
+  const uri = params.MONGODB_URI;
+  const database = params.MONGODB_DATABASE;
+
+// Cached connection promise
+  let cachedPromise = null;
+
+
+  if (!cachedPromise) {
+    // If no connection promise is cached, create a new one. We cache the promise instead
+    // of the connection itself to prevent race conditions where connect is called more than
+    // once. The promise will resolve only once.
+    // Node.js driver docs can be found at http://mongodb.github.io/node-mongodb-native/.
+    cachedPromise =
+      MongoClient.connect(uri, {useNewUrlParser: true, useUnifiedTopology: true});
+  }
+  // await on the promise. This resolves only once.
+  const client = await cachedPromise;
+
+  // Specify which database we want to use
+  const db = await client.db(database);
+
+  return db;
+};
+
+/**
+ * This function is similar to the above function `connectToDatabase`.
+ * The difference is that we don't need to pass the database name in the params.
+ * It works just with the connection string.
+ * @param MONGODB_URI
+ * @returns {Promise<null>}
+ */
+module.exports.connectToDatabaseWithURI = async function connectToDatabase(MONGODB_URI) {
+
+// Cached connection promise
+  let cachedPromise = null;
+
+  if (!cachedPromise) {
+    // If no connection promise is cached, create a new one. We cache the promise instead
+    // of the connection itself to prevent race conditions where connect is called more than
+    // once. The promise will resolve only once.
+    // Node.js driver docs can be found at http://mongodb.github.io/node-mongodb-native/.
+    cachedPromise = MongoClient.connect(MONGODB_URI, {useNewUrlParser: true, useUnifiedTopology: true});
+  }
+  // await on the promise. This resolves only once.
+  const client = await cachedPromise;
+  // Specify which database we want to use
+  return client;
+};

package/mongodb/index.js

@@ -0,0 +1,8 @@
+const MongoClient = require('./connect-to-mongodb');
+const users = require('./models/users');
+
+module.exports = {
+    ...MongoClient,
+    ...users
+    // ...otherCollections,
+}

package/mongodb/models/users.js

@@ -0,0 +1,51 @@
+let GLOBAL_MONGO_LIMIT = 10;
+let GLOBAL_MONGO_OFFSET = 0;
+
+/**
+ * to find all the users in the DB
+ * @param db
+ * @param limit
+ * @param offset
+ * @returns {Promise<void>}
+ */
+const findAllUsers = async (db, limit = GLOBAL_MONGO_LIMIT, offset = GLOBAL_MONGO_OFFSET) => {
+    db.collection('users').find({}).limit(limit).skip(offset).toArray(function (err, result) {
+        if (err) {
+            console.log(err);
+        } else {
+            console.log(result);
+        }
+    });
+};
+
+
+/**
+ * to find user by ID
+ * @param db
+ * @param userId
+ * @returns {Promise<void>}
+ */
+const findByUserID = async (db, userId) => {
+    db.collection('users').findOne({
+        _id: new mongo.ObjectID(userId)
+    });
+};
+
+/**
+ * to find user by email
+ * @param db
+ * @param email
+ * @returns {Promise<void>}
+ */
+const findByEmail = async (db, email) => {
+    db.collection('users').findOne({
+        email: email
+    });
+}
+
+//export the methods
+module.exports = {
+    findAllUsers,
+    findByUserID,
+    findByEmail
+}