dcos-core-monalisav2-latam 1.0.0

package/src/functions/clients_peru/splitfile.js

@@ -0,0 +1,357 @@
+const csv = require('csvtojson');
+const converter = require('json-2-csv');
+const path = require('node:path');
+const { sendSqsMessage } = require('./utils');
+const { connectToFtp } = require('../../common/utils/sftp-utils');
+const { FileSystem } = require('../../common/utils/ftp-sftp');
+const Logger = require('../../common/utils/logger');
+
+/**
+ * 
+ * @param {Object} ftpCredentials Credenciales de conexión al servidor FTP o SFTP
+ * @param {Object} fileParams 
+ * @param {string} sqsQueue URL de la cola SQS a donde se enviará el message del archivo a procesar.
+ */
+module.exports.splitFile = async (ftpCredentials, fileParams, sqsQueue, timestamp, additionalQueueData = {}) => {
+    let filesData = {};
+
+    let clientFTP, {
+        patternFile,
+        maxRows,
+        filesFolderPath,
+        processedFilesFolderPath,
+        splitFilesFolderPath,
+        splitProcessedFilesFolderPath,
+        logFilesFolderPath
+    } = fileParams;
+
+    try {
+        // Conexión al servidor FTP
+        clientFTP = await connectToFtp(ftpCredentials);
+
+        // Consulta de archivos en la carpeta
+        Logger.info(`Finding files in folder: ${filesFolderPath}`);
+        let files = await this.getFilesInFolder(clientFTP, filesFolderPath, file => {
+            return file.original.type == '-' && file.original.name.match(new RegExp(patternFile)) !== null;
+        });
+        Logger.info(`Files found: ${files?.length}`);
+        if (files?.length) {
+            for (let file of files) {
+                // Información del archivo a procesar
+                const fileData = path.parse(file.original.name);
+                // Ruta del archivo a procesar
+                const filePath = filesFolderPath + '/' + fileData.base;
+
+                try {
+                    // Se generan los archivos segmentado del archivo 'grande'
+                    const { rows, data } = await this.generateFiles(
+                        clientFTP,
+                        filePath,
+                        { maxRows, splitFilesFolderPath, splitProcessedFilesFolderPath, logFilesFolderPath },
+                        fileData,
+                        timestamp,
+                        sqsQueue,
+                        additionalQueueData
+                    );
+
+                    // Se mueve el archivo original a la carpeta determinada
+                    Logger.info(`Moving file: ${filePath}`);
+                    const newFileName = await this.moveProcessedFile(
+                        clientFTP,
+                        filePath,
+                        processedFilesFolderPath,
+                        fileData.name + '_' + timestamp + fileData.ext
+                    );
+                    Logger.info(`File ${filePath} moved at ${newFileName}`);
+
+                    // Se adiciona en el objeto de retorno la siguiente información
+                    filesData[fileData.name] = {
+                        // timestamp del momento en que se ejecuta el proceso
+                        timestamp,
+                        // N° de filas del archivo original
+                        rows,
+                        // Lista de archivos divididos
+                        data,
+                    };
+                } catch (ex) {
+                    filesData[fileData.name] = {
+                        timestamp,
+                        error: ex.message
+                    };
+                }
+            }
+        }
+
+        return filesData;
+    } catch (ex) {
+        throw (ex);
+    } finally {
+        // Se cierra la conexión al servidor FTP (si esta existe)
+        if (clientFTP?.client) {
+            clientFTP.client.end();
+        }
+    }
+};
+
+module.exports.handleProcessFile = async (clientFTP, splitData, csvOptions, callbackJsonData) => {
+    let { filePath, baseName, timestamp, splitProcessedFilesFolderPath, logFilesFolderPath, addToQueue = true } = splitData;
+
+    Logger.info('Input data: ' + JSON.stringify({ filePath, baseName, timestamp, addToQueue }));
+    // Se obtiene la información del archivo a procesar
+    const fileData = path.parse(filePath);
+
+    // Obtener los registros del archivo definido en 'filePath'
+    let { rows, errors, data, promises } = await this.processFileContent(clientFTP, filePath, csvOptions, callbackJsonData);
+    if (addToQueue && promises.length) {
+        let result = await Promise.allSettled(promises.map(queueRow => {
+            const { queueUrl, queueData } = queueRow;
+            return new Promise((resolve, reject) => {
+                sendSqsMessage(queueUrl, queueData).then(() => resolve(queueData)).catch(reject);
+            });
+        })).catch(Logger.error);
+        if (result) {
+            Logger.info(`Records to send: ${result.length ?? 0}`);
+            for (let item of result) {
+                if (item.status == 'rejected') {
+                    Logger.error(item);
+                }
+            }
+        }
+    }
+
+    // Se crea la respuesta de la petición
+    let response = { rows, errors };
+    if (data?.length) {
+        // Se genera el archivo de log
+        response.logFile = await this.generateLogFile(
+            clientFTP,
+            logFilesFolderPath + '/' + baseName,
+            fileData.name + '_logs.csv',
+            data
+        );
+    }
+
+    // Se mueve el archivo procesado previamente
+    await this.moveProcessedFile(
+        clientFTP,
+        filePath,
+        splitProcessedFilesFolderPath + '/' + baseName,
+        fileData.base
+    );
+
+    return response;
+};
+
+/**
+ * Genera el archivo de log con la información de los errores de validación al momento de procesar el archivo csv.
+ * @param {FileSystem} clientFTP Instancia de conexión al servidor FTP.
+ * @param {string} logsFolder Directorio donde se almacenará los archivos de log.
+ * @param {string} logFileName Nombre del archivo log.
+ * @param {array} errors Lista de errores.
+ * @returns 
+ */
+module.exports.generateLogFile = (clientFTP, logsFolder, logFileName, errors) => {
+    return new Promise((resolve, reject) => {
+        // Creación de la carpeta donde se almacenarán los archivos divididos
+        Logger.info(`Creating folder: ${logsFolder}`);
+        clientFTP.mkdir(logsFolder, true).then(() => {
+            let fileName = logsFolder + '/' + logFileName;
+            Logger.info(`Creating log file: ${fileName}`);
+            // Se convierte el listado de datos a un archivo CSV
+            const content = converter.json2csv(errors, { delimiter: ',' });
+            clientFTP.put(content, fileName).then(() => {
+                resolve(fileName);
+            }).catch(reject);
+        }).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
+        Logger.info(`Creating processed files folder: ${targetFolder}`);
+        clientFTP.mkdir(targetFolder, true).then(() => {
+            newFileName = targetFolder + '/' + newFileName;
+            clientFTP.rename(filePath, newFileName).then(() => {
+                resolve(newFileName);
+            }).catch(reject)
+        }).catch(reject);
+    });
+};
+
+/**
+ * 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) => {
+        clientFTP.list(filesFolderPath).then(list => {
+            if (callbackFilter) {
+                resolve(list.filter(callbackFilter));
+            } else {
+                resolve(list);
+            }
+        }).catch(reject);
+    });
+};
+
+module.exports.getFileStream = async (clientFTP, filePath) => {
+    return new Promise((resolve, reject) => {
+        // Obtener el contenido del archivo indicado
+        Logger.info(`Reading file: ${filePath}`);
+        clientFTP.get(filePath).then(resolve).catch(reject);
+    });
+};
+
+module.exports.getFileContent = async (clientFTP, filePath) => {
+    return new Promise((resolve, reject) => {
+        this.getFileStream(clientFTP, 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);
+    });
+};
+
+/**
+ * Extrae las filas de un archivo de teto plano
+ * @param {*} clientFTP Instancia de conexión al servidor FTP.
+ * @param {string} filePath Ruta del archivo a leer.
+ * @param {boolean} includeHeader Valor de verdad para indicar si existe una fila de encabezado.
+ * @returns Filas existentes en el archivo.
+ */
+module.exports.getRowsFromFile = async (clientFTP, filePath, includeHeader = true) => {
+    return new Promise((resolve, reject) => {
+        this.getFileContent(clientFTP, filePath).then(content => {
+            // Se obtiene cada una de las filas del archivo
+            let rows = content.trim().split(/\r?\n/);
+            // Se obtiene la fila de los títulos del archivo (si aplica)
+            let headerRow = includeHeader ? rows.shift() : '';
+            resolve({ rows, headerRow });
+        }).catch(reject);
+    });
+};
+
+/**
+ * Genera los archivos separados a partir de un archivo base.
+ * @param {*} clientFTP Instancia de conexión al servidor FTP.
+ * @param {string} filePath Ruta del archivo a dividir.
+ * @param {string} fileData Información extraida del archivo 'filePath'.
+ * @param {string} folderPath Ruta del directorio donde se insertarán los archivos generados.
+ * @param {string} timestamp Timestamp del inicio de ejecución del proceso.
+ * @param {*} seller 
+ * @param {boolean} addToQueue Valor que indica si se inserta el message a la cola.
+ * @returns 
+ */
+module.exports.generateFiles = async (clientFTP, filePath, fileParams, fileData, timestamp, sqsQueue, additionalQueueData = {}) => {
+    return new Promise((resolve, reject) => {
+        this.getRowsFromFile(clientFTP, filePath).then(rowsData => {
+            let { rows, headerRow } = rowsData;
+            // Respuesta de la promise
+            let response = { rows: rows.length, data: [] };
+            if (rows.length) {
+                let { maxRows, splitFilesFolderPath, splitProcessedFilesFolderPath, logFilesFolderPath } = fileParams;
+
+                // Se calcula el número estimado de archivos a generar, dividiendo el total de filas entre el número máximo configurado
+                let estimatedFiles = Math.trunc(rows.length / maxRows);
+                if (rows.length % maxRows != 0) {
+                    estimatedFiles += 1;
+                }
+                Logger.info(`Estimated files count: ${estimatedFiles}`);
+                // Se obtiene el número de dígitos de la cantidad estimada de archivos, para formatear el consecutivo llenando con ceros a la izquierda.
+                let digits = String(estimatedFiles).length;
+
+                // Nombre base de la carpeta y archivos generados a partir de la archivo original
+                let baseName = fileData.name + '_' + timestamp;
+
+                // Se crea la carpeta donde se almacenaran los archivos divididos
+                let targetFolder = splitFilesFolderPath + '/' + baseName;
+                Logger.info(`Creating target folder: ${targetFolder}`);
+                clientFTP.mkdir(targetFolder, true).then(() => {
+                    let filesPromises = [], count = 1;
+                    do {
+                        // Se extrae las primeras 'maxRows' filas de la lista
+                        let rowsData = rows.splice(0, maxRows);
+                        if (rowsData.length) {
+                            // Se define la rula del archivo generado, concatenando la carpeta destino y el nombre a establecer
+                            // Ejemplo: client_semifull_01.csv
+                            let filePath = targetFolder + '/' + (baseName + '_' + String(count).padStart(digits, '0') + fileData.ext);
+                            // Se concatena los datos de la Promise encargada de generar el archivo respectivo
+                            filesPromises.push({ filePath, rowsData });
+                            count++;
+                        }
+                    } while (rows.length);
+
+                    // Se ejecuta las promises
+                    Logger.info(`Promises count: ${filesPromises.length}`);
+                    if (filesPromises.length) {
+                        Promise.allSettled(filesPromises.map(fileData => {
+                            const { filePath, rowsData } = fileData;
+                            return new Promise((resolve, reject) => {
+                                Logger.info(`Creating file: ${filePath}`);
+                                clientFTP.put(
+                                    (headerRow ? [...[headerRow], ...rowsData] : rowsData).join('\n'),
+                                    filePath
+                                ).then(() => {
+                                    let queueData = { filePath, baseName, timestamp, splitProcessedFilesFolderPath, logFilesFolderPath, ...additionalQueueData };
+                                    if (sqsQueue) {
+                                        // Se inserta los datos en la cola definida
+                                        sendSqsMessage(sqsQueue, queueData).then(() => resolve(queueData)).catch(reject);
+                                    } else {
+                                        resolve(queueData);
+                                    }
+                                }).catch(reject);
+                            });
+                        })).then(result => {
+                            response.data = result;
+                            resolve(response);
+                        }).catch(reject);
+                    } else {
+                        resolve(response);
+                    }
+                }).catch(reject);
+            } else {
+                resolve(response);
+            }
+        }).catch(reject);
+    });
+}
+
+/**
+* Extrae el contenido del archivo .csv como valores JSON
+* @param {*} clientFTP Instancia de conexión al servidor FTP.
+* @param {*} filePath Ruta del archivo a leer.
+* @returns Información de la ejecución del proceso.
+*/
+module.exports.processFileContent = async (clientFTP, filePath, csvOptions, callbackJsonData) => {
+    return new Promise((resolve, reject) => {
+        // Obtener el contenido del archivo 'filePath'
+        Logger.info(`Reading file: ${filePath}`);
+        clientFTP.get(filePath).then(stream => {
+            let result = { rows: 0, errors: 0, data: [], promises: [] };
+            // Extraer el contenido de cada fila del archivo csv como objeto JSON
+            csv(csvOptions).fromStream(stream).subscribe(jsonData => {
+                // Se incrementa el contador de filas
+                result.rows++;
+                // Se ejecuta una validación de los datos extraidos del JSON
+                callbackJsonData(result, jsonData);
+            }, reject, () => { resolve(result) });
+        }).catch(reject);
+    });
+}