vtlab-generic-functions 1.0.23 → 1.0.25

package/ftp/ftp-promise-wrapper.js

@@ -1,21 +1,5 @@
 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);
-    }
-  });
-};
 
 /**
  *
@@ -23,52 +7,53 @@ const streamToBuffer = (stream) => {
  */
 //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;
-    });
+	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,
+	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;
-  }
+	/**
+	 * 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;
+	}
 };
 
 /**
@@ -78,12 +63,12 @@ const uploadFileToFTP = async (
  * @returns {Promise<boolean>}
  */
 const isFileExistsInFTP = async (ftp, filePath) => {
-  try {
-    let exists = await ftp.list(filePath);
-    return exists.length > 0;
-  } catch (e) {
-    throw e;
-  }
+	try {
+		let exists = await ftp.list(filePath);
+		return exists.length > 0;
+	} catch (e) {
+		throw e;
+	}
 };
 
 /**
@@ -93,17 +78,20 @@ const isFileExistsInFTP = async (ftp, filePath) => {
  * @returns {Promise<void>}
  */
 const deleteFileFromFTP = async (ftp, filePath) => {
-  try {
-    await ftp.delete(filePath);
-  } catch (e) {
-    throw e;
-  }
+	try {
+		await ftp.delete(filePath);
+	} catch (e) {
+		throw e;
+	}
 };
 
 
+
+
+
 module.exports = {
-  uploadFileToFTP,
-  downloadFromFTP,
-  isFileExistsInFTP,
-  deleteFileFromFTP
+	uploadFileToFTP,
+	downloadFromFTP,
+	isFileExistsInFTP,
+	deleteFileFromFTP
 };

package/ftp/ftpClientClass.js

@@ -0,0 +1,214 @@
+
+const promiseFTP = require("promise-ftp");
+const promiseSFTP = require("ssh2-sftp-client");
+
+
+/**
+ * Represents an FTP client for connecting to an FTP server and performing file operations.
+ */
+class FTPClientV2 {
+	/**
+	 * Constructs a new FTPClientV2 instance.
+	 */
+	constructor() {
+		/**
+		 * FTP server credentials.
+		 * @type {Object}
+		 * @private
+		 */
+		this._ftpCredentials = null;
+
+		/**
+		 * Indicates whether the client is connected to the FTP server.
+		 * @type {boolean}
+		 * @private
+		 */
+		this._isConnected = false;
+
+		/**
+		 * The FTP client instance.
+		 * @type {Object}
+		 * @private
+		 */
+		this._ftpInstance = null;
+	}
+
+	/**
+	 * Connects to the FTP server.
+	 * @param {Object} config FTP server configuration.
+	 *  @param {string} config.host The FTP server host.
+	 *  @param {number} [config.port] The FTP server port.
+	 *  @param {string} [config.username] The FTP server username.
+	 *  @param {string} [config.password] The FTP server password.
+	 *  @param {boolean} [config.autoReconnect] Indicates whether to automatically reconnect to the server.
+	 *  @param {string} [config.privateKey] Buffer or string that contains a private key for either key-based or host-based user authentication
+	 * 
+	 * @throws {Error} If FTP credentials are not provided or connection fails.
+	 */
+	async connect(config) {
+		if (!config) {
+			throw new Error("FTP credentials not provided");
+		}
+
+		// normalize username/user
+		config.username = config.username || config.user;
+		config.user = config.user || config.username;
+
+		try {
+			switch (config.type) {
+				case "sftpWithKey":
+					this._ftpInstance = new promiseSFTP();
+					break;
+				case "ftp":
+				case "sftp":
+				default:
+					this._ftpInstance = new promiseFTP();
+					break;
+			}
+			await this._ftpInstance.connect(config);
+			this._isConnected = true;
+			this._ftpCredentials = config;
+		} catch (error) {
+			this._isConnected = false;
+			this._ftpInstance = null;
+			throw new Error(`Failed to connect to FTP server: ${error.message}`);
+		}
+	}
+
+	/**
+	 * Disconnects from the FTP server.
+	 * @throws {Error} If disconnection fails.
+	 */
+	async disconnect() {
+		if (this._isConnected && this._ftpInstance) {
+			try {
+				await this._ftpInstance.end();
+				this._isConnected = false;
+				this._ftpInstance = null;
+				this._ftpCredentials = null;
+			} catch (error) {
+				throw new Error(`Failed to disconnect from FTP server: ${error.message}`);
+			}
+		}
+	}
+
+	/**
+	 * Downloads a file from the FTP server.
+	 * @param {string} remotePathWithFile Remote path to the file.
+	 * @returns {Promise<Buffer>} A Promise resolving to the downloaded file content.
+	 * @throws {Error} If download fails.
+	 */
+	async downloadFile(remotePathWithFile) {
+		if (!this._isConnected) {
+			await this.connect(this._ftpCredentials);
+		}
+
+		switch (this._ftpCredentials.type) {
+			case 'sftpWithKey':
+				let file = await this._ftpInstance.get(remotePathWithFile);
+				return [file];
+			default:
+				let Stream = require("stream");
+				return new Promise((resolve, reject) => {
+					let _buf = [];
+					const writableStream = new Stream.Writable();
+					writableStream._write = (chunk, encoding, next) => {
+						_buf.push(chunk);
+						next();
+					};
+
+					this._ftpInstance.get(remotePathWithFile)
+						.then((stream) => {
+							return new Promise(function (resolve, reject) {
+								stream.once("close", resolve);
+								stream.once("error", reject);
+								stream.pipe(writableStream);
+							});
+						})
+						.then(() => {
+							return resolve(_buf);
+						})
+						.catch((err) => {
+							return reject(err);
+						});
+				});
+		}
+	}
+
+	/**
+	 * Uploads a file to the FTP server.
+	 * @param {string} localPathWithFile Local path to the file.
+	 * @param {string} remotePathWithFile Remote path to upload the file.
+	 * @returns {Promise<Object>} A Promise resolving to an object with upload status.
+	 * @throws {Error} If upload fails.
+	 */
+	async uploadFile(localPathWithFile, remotePathWithFile) {
+		try {
+			if (!this._isConnected) {
+				await this.connect(this._ftpCredentials);
+			}
+			await this._ftpInstance.put(localPathWithFile, remotePathWithFile);
+			return { code: 200, message: "FTP successful upload" };
+		} catch (error) {
+			throw new Error(`Failed to upload file to FTP server: ${error.message}`);
+		} finally {
+			await this.disconnect();
+		}
+	}
+
+	/**
+	 * Checks if a file exists on the FTP server.
+	 * @param {string} filePath Remote file path to check.
+	 * @returns {Promise<boolean>} A Promise resolving to true if the file exists, false otherwise.
+	 * @throws {Error} If the operation fails.
+	 */
+	async isFileExists(filePath) {
+		try {
+			if (!this._isConnected) {
+				await this.connect(this._ftpCredentials);
+			}
+			const exists = await this._ftpInstance.list(filePath);
+			return exists.length > 0;
+		} catch (error) {
+			throw new Error(`Failed to check file existence on FTP server: ${error.message}`);
+		}
+	}
+
+	/**
+	 * Deletes a file from the FTP server.
+	 * @param {string} filePath Remote file path to delete.
+	 * @throws {Error} If deletion fails.
+	 */
+	async deleteFile(filePath) {
+		try {
+			if (!this._isConnected) {
+				await this.connect(this._ftpCredentials);
+			}
+			await this._ftpInstance.delete(filePath);
+		} catch (error) {
+			throw new Error(`Failed to delete file from FTP server: ${error.message}`);
+		}
+	}
+
+	/**
+	* Lists files in a folder on the FTP server.
+	* @param {string} folderPath Remote folder path to list files.
+	* @returns {Promise<Array<string>>} A Pro∏”mise resolving to an array of file names in the folder.
+	* @throws {Error} If listing files fails.
+	*/
+	async listFilesInFolder(folderPath) {
+		try {
+			if (!this._isConnected) {
+				await this.connect(this._ftpCredentials);
+			}
+			const files = await this._ftpInstance.list(folderPath);
+			return files.map((file) => file.name);
+		} catch (error) {
+			throw new Error(`Failed to list files in folder on FTP server: ${error.message}`);
+		}
+	}
+}
+
+module.exports = {
+    FTPClientV2
+}

package/lambdaClass/index.js

@@ -57,9 +57,9 @@ module.exports = class Lambda {
   }
 
   s3 = {
-    upload: async (data, path) => {
+    upload: async (data, path, options = {}) => {
       return await s3bucket.uploadToS3(path, data, {
-        ContentEncoding: "base64", ContentType: "image/png",
+        ContentEncoding: options.contentEncoding || "base64", ContentType: options.ContentType ||  "image/png",
       });
     }, download: async (path) => {
       return await s3bucket.downloadFileFromS3(path);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vtlab-generic-functions",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "scripts": {
     "test": "jest"
   },

package/utils/index.js

@@ -303,7 +303,87 @@ const getValueOrNullControl = (
     throw new Error(`Failed trying to get value with path ${path}`);
   }
 };
+/**
+ * Retrieves a value from a nested object structure based on a given path, 
+ * with an option to fall back to a default value if the path does not yield a valid result.
+ *
+ * @param {Object} [value={}] - The object from which to retrieve the value. Defaults to an empty object if not provided.
+ * @param {Array<string>} [paths=[]] - An array of string paths, each representing a path to a nested value in the object. 
+ *                                     The function tries each path in sequence until a valid result is obtained.
+ * @param {*} [defaultFallback=null] - The default value to return if no valid value is found at any of the specified paths. 
+ *                                     Defaults to null if not provided.
+ * @returns {*} - Returns the value found at the first valid path, the default fallback value if none of the paths are valid,
+ *                or throws an error if no paths are provided or if no fallback is set when a required path yields null.
+ * @throws {Error} - Throws an error if the first path is null (indicating no paths were provided), if a required value 
+ *                   at a path is null and no more paths are left to check (without a valid defaultFallback), or if any 
+ *                   other unexpected error occurs during execution.
+ */
+const getValueOrNullControlWithFallback = (
+  value = {},
+  paths = [],
+  defaultFallback = null
+) => {
+  try {
+    const path = paths[0];
+    if(path == null) throw new Error(`Path is required`);
+    const result = getValueOrNull(value, path);
+    if(result == null && paths.length === 1 && defaultFallback != null) return defaultFallback;
+    if(result == null && paths.length === 1) throw new Error(`Value path ${path} is required`);
+    if (result) return result;
+    if(paths.length === 1) return defaultFallback;
+    return getValueOrNullControlWithFallback(value, paths.slice(1), defaultFallback);
+  } catch (e) {
+    throw e || new Error(`Failed trying to get value with paths ${paths}`);
+  }
+};
 
+/**
+ * Determines the MIME type of a file encoded in base64 format based on the file's signature.
+ *
+ * @param {string} base64 - The base64 encoded string of the file.
+ * @returns {string} - The MIME type of the file. Returns 'application/octet-stream' if the type cannot be determined.
+ */
+const getMimeTypeFromBase64 = (base64,defaultType = 'application/pdf') => {
+  const signatures = {
+    JVBERi0: 'application/pdf',
+    R0lGOD: 'image/gif',
+    iVBOR: 'image/png',
+    '/9j/': 'image/jpg',
+  };
+
+  for (const sign in signatures) {
+    if (base64.includes(sign)) return signatures[sign];
+  }
+  return defaultType;
+};
+
+
+/**
+ * Determines the type of freight charges based on the given INCOTERM.
+ *
+ * @param {string} incoterm - The INCOTERM code based on which the freight charge type is determined.
+ * @returns {string} - Returns "D" for direct charges or "P" for prepaid charges.
+ */
+const getTipoPortes = incoterm => {
+  switch (String(incoterm).toUpperCase()) {
+    case "EXW":
+    case "FAS":
+    case "FOB":
+      return "D";
+    case "FCA":
+    case "CPT":
+    case "CIP":
+    case "DPU":
+    case "DAP":
+    case "DDP":
+    case "CFR":
+    case "CIF":
+      return "P";
+    default:
+      return "P";
+  }
+}
+ 
 // use it to create safe fields for csv files writing
 const generateCSVField = (
   obj,
@@ -576,4 +656,7 @@ module.exports = {
   generateUuid,
   mergePDF,
   getMessageAndCodeFromError,
+  getValueOrNullControlWithFallback,
+  getMimeTypeFromBase64,
+  getTipoPortes,
 };