dcos-core-monalisav2-latam 1.0.0

package/src/functions/sftpIntegrations/sftp-consumer.js

@@ -0,0 +1,700 @@
+const AdmZip = require('adm-zip');
+const fs = require('node:fs');
+const moment = require('moment');
+const path = require('node:path');
+
+const { connectToFtp, getFilesInFolder, getFileContent, moveProcessedFile, createFolder, downloadFile, uploadFile } = require("../../common/utils/sftp-utils");
+const { getErrorData, getDateValues, setQueryParams } = require("../../common/utils/util");
+const AccountData = require("../../entities/account");
+const ValidFile = require('./processes/validateFileSchema');
+const { sendMessageToSqs } = require('../../common/utils/aws-services');
+const DynamoDBConnector = require('./utils/connect-dynamo');
+const ServicesRedirect = require('./processes/redirectServices');
+const VtexApi = require('../../vtex/clients/VtexApi');
+const Logger = require('../../common/utils/logger');
+const { delayStatusProcess } = require('../../common/utils/delay');
+
+const {
+    SFTP_DATA_SCHEMA_TABLE,
+    SFTP_CREDENTIALS_TABLE,
+    SFTP_JOBS_QUEUE_URL,
+    SFTP_JOBS_DLQ_QUEUE_URL,
+    SQS_CRON_JOBS_QUEUE_URL,
+    SFTP_MAX_ATTEMPS = 3
+} = process?.env ?? {};
+
+/**
+ * Función que ejecuta el proceso de consultar los archivos en el servidor FTP.
+ * @param {Object} objectData Objeto proveniente de la cola SQS donde se ejecuta el Cron Job.
+ */
+module.exports.callback = async (objectData) => {
+    const { AccountName, ActionProcess, attemps = 0 } = objectData;
+
+    const dateValues = getDateValues();
+    const { timestamp } = dateValues;
+
+    const logRecord = {
+        id: `cron_${AccountName}_${ActionProcess}`,
+        actionProcess: ActionProcess,
+        process: 'find_file',
+        timestamp,
+        success: true,
+        error: null,
+        notify: true
+    }
+
+    let clientFTP;
+    let vtexApiClient, entityName, schemaName;
+    try {
+        // Consulta los parámetros de la integración requeridos
+        const configAccount = await AccountData.getAccountDataByAccountName(AccountName);
+        const { ftpId, directoryProcess, ...integrationParameters } = await getIntegrationParameters(AccountName, ActionProcess, configAccount);
+
+        // Se obtiene la información 
+        vtexApiClient = integrationParameters.apiClient;
+        entityName = integrationParameters.entityName;
+        schemaName = integrationParameters.schemaName;
+
+        // Conexión al servidor FTP
+        Logger.info(`Connecting to FTP ${ftpId}`);
+        const ftpCredentials = await getFtpProperties(ftpId);
+        clientFTP = await connectToFtp(ftpCredentials);
+
+        // Se obtiene la carpeta de pending
+        const { pendingPath, schemaId } = directoryProcess[ActionProcess];
+
+        // Se obtiene los datos del schema, para validar el nombre del archivo
+        const { PatternName } = await getSchemaProperties(schemaId);
+        // Se aplica el replace, debido a que el valor puede ser una expresión regular
+        // que contiene "\\"
+        logRecord.filename = PatternName.replaceAll('\\', '\\\\');
+        logRecord.folderPath = pendingPath;
+
+        // Se consulta los archivos existentes en la carpeta
+        const files = await getFilesInFolder(clientFTP, pendingPath), promises = [];
+        if (files?.length) {
+            for (let file of files) {
+                const { original } = file;
+                const { name, type } = original;
+                // Se valida que el elemento corresponda a un archivo, y el nombre concuerde con la RegExp definida
+                if (type == '-' && name.match(new RegExp(PatternName)) !== null) {
+                    // Se agrega a la promise el path del archivo encontrado
+                    Logger.info(`File found ${name}`);
+                    promises.push(`${pendingPath}/${name}`);
+                }
+            }
+        }
+
+        // Se ejecutan las promises (si existen)
+        logRecord.countFiles = promises.length;
+        if (logRecord.countFiles) {
+            await Promise.allSettled(promises.map(filePath => {
+                return new Promise((resolve, reject) => {
+                    // Se inserta en la cola SQS el accountName, nombre del proceso y ruta del archivo a procesar
+                    sendMessageToSqs(SFTP_JOBS_QUEUE_URL, {
+                        accountName: AccountName,
+                        actionProcess: ActionProcess,
+                        filePath,
+                        timestamp
+                    }).then(() => resolve(filePath)).catch(reject);
+                });
+            }));
+        } else {
+            // Si no se encontró archivos, se procede a registrar el log indicando que no hubo archivos (logRecord.countFiles = 0).
+            // Esto hara que se envíe la notificación indicando que se ejecutó el job, pero no encontró archivo
+            await saveInLogEntity(vtexApiClient, entityName, schemaName, logRecord);
+        }
+    } catch (ex) {
+        // Se valida que el número de intentos no supere el valor máximo configurado
+        if (attemps < SFTP_MAX_ATTEMPS) {
+            await delayStatusProcess(5);
+            Logger.warn('Error in sftp callback', { AccountName, ActionProcess, attemps });
+
+            // Se encola el message en la cola de jobs para procesar nuevamente, aumentando el n° de reintentos
+            objectData.attemps = attemps + 1;
+            await sendMessageToSqs(SQS_CRON_JOBS_QUEUE_URL, objectData).catch(Logger.error);
+        } else {
+            // Se registra en la entidad de logs la información de error en el proceso.
+            // Este registro hará que se envíe el mensaje de error por correo electrónico a través del trigger configurado en la entidad.
+            logRecord.success = false;
+            logRecord.error = ex.message
+            await saveInLogEntity(vtexApiClient, entityName, schemaName, logRecord);
+            throw ex;
+        }
+    } finally {
+        // Se cierra la conexión al servidor FTP (si esta existe)
+        if (clientFTP?.client) {
+            clientFTP.client.end();
+        }
+    }
+};
+
+/**
+ * Función que ejecuta el proceso de procesar nuevamente los archivos que presentaron errores de ejecución.
+ * @param {Object} objectData Objeto proveniente de la cola SQS donde se ejecuta el Cron Job.
+ */
+module.exports.reprocessFailed = async (objectData) => {
+    const { AccountName, ActionProcess } = objectData;
+
+    try {
+        // Consulta los parámetros de la integración requeridos
+        const configAccount = await AccountData.getAccountDataByAccountName(AccountName);
+        const integrationParameters = await getIntegrationParameters(AccountName, ActionProcess, configAccount, false);
+
+        // Se obtiene la información para el consumo de la API de VTEX
+        const { apiClient, entityName, schemaName } = integrationParameters;
+
+        // Se consulta los registros cuyo archivo no fue procesado exitosamente
+        const urlSearch = setQueryParams(`/dataentities/${entityName}/search`, {
+            _schema: schemaName,
+            _fields: 'id,accountName,actionProcess,filename,folderPath,contentType,timestamp',
+            _where: '(success=false)'
+        });
+        const records = await apiClient.fetch(urlSearch, {
+            method: 'GET',
+            validateStatus: status => status >= 200 && status < 400
+        });
+        if (records?.status == 200) {
+            let { data } = records;
+            Logger.info(`Record for reprocess: ${data?.length}`);
+            if (data?.length) {
+                // Se encola nuevamente la información de los archivos cuyo proceso falló,
+                // para procesarlos nuevamente tal como se hizo originalmente.
+                do {
+                    // Se extrae las primeras 'maxRows' filas de la lista
+                    let rowsData = data.splice(0, 10);
+                    await Promise.allSettled(rowsData.map(item => {
+                        const { id, accountName, actionProcess, filename, folderPath, contentType, timestamp } = item;
+
+                        // Se define la ruta del archivo concatenando la carpeta donde se procesó,
+                        // el Id que corresponde al nombre final y la extensión del archivo original.
+                        const filePath = `${folderPath}/${filename}`;
+                        return new Promise((resolve, reject) => {
+                            // Se envia a la cola el Id del registro
+                            sendMessageToSqs(SFTP_JOBS_QUEUE_URL, {
+                                id, accountName, actionProcess, filePath, contentType, timestamp
+                            }).then(resolve).catch(reject);
+                        });
+                    })).catch(Logger.error);
+                } while (data.length);
+            }
+        }
+    } catch (ex) {
+        const { info } = getErrorData(ex);
+        Logger.error('Error in reprocessFailed', info);
+    }
+}
+
+/**
+ * Función que se invoca desde el trigger de la cola SQS definida en la propiedad 'sftpjobs-queue' del archivo 'constructs.yml'.
+ * @param {*} event Objeto que contiene información de una petición como: el body, path y método de una petición HTTP, o la lista de registros en una cola SQS.
+ * @param {*} context Objeto que contiene información sobre la invocación, la función y el entorno de ejecución.
+ */
+module.exports.processFile = async (event, context) => {
+    // ID de la petición en AWS
+    const { awsRequestId } = context;
+
+    for (const record of event.Records) {
+        // Se obtiene el contenido del cuerpo del mensaje de la cola SQS
+        let { body } = record;
+        body = JSON.parse(body);
+
+        // Se ejecuta el proceso de validar el archivo, con los valores enviados a la cola SQS
+        await handleProcessFile(awsRequestId, body);
+    }
+};
+
+/**
+ * Extrae la información del archivo,
+ * @param {string} awsRequestId Id de la petición de AWS.
+ * @param {object} sqsMessage Mensaje SQS con la información del archivo a procesar.
+ * @param {string} sqsMessage.accountName Nombre del accountName.
+ * @param {string} sqsMessage.actionProcess Nombre del proceso.
+ * @param {string} sqsMessage.filePath Ruta del archivo a procesar.
+ * @param {string} sqsMessage.contentType Tipo de dato del archivo a procesar (si aplica).
+ * @param {string} sqsMessage.timestamp Marca de tiempo de cuando se ejecuta el proceso.
+ */
+async function handleProcessFile(awsRequestId, sqsMessage) {
+    let { id, accountName, actionProcess, filePath, contentType = null, timestamp = null, attemps = 0 } = sqsMessage;
+
+    let clientFTP;
+
+    // Se establece el valor 
+    if (!timestamp) {
+        const dateValues = getDateValues();
+        timestamp = dateValues.timestamp;
+    }
+
+    // Se extrae el nombre y extensión del archivo
+    const fileData = path.parse(filePath);
+    const { base, name, dir } = fileData;
+
+    // Si se definió el Id, este valor será el nombre del archivo a procesar
+    const fileName = id ?? (contentType ? name : `${name}_${timestamp}`);
+
+    // Variables asociadas al nombre de la entidad, conexión a la API de VTEX y objeto JSON a insertar
+    let vtexApiClient, entityName, schemaName;
+    const logRecord = {
+        id: fileName,
+        filename: base,
+        folderPath: dir,
+        contentType,
+        actionProcess,
+        timestamp,
+        error: null
+    };
+
+    // Si se está procesando un archivo dividido, se define notify=false para que no envíe notificación;
+    // salvo que ocurra un error en el proceso.
+    logRecord.notify = contentType ? false : true;
+
+    try {
+        // Se consulta los datos de integración asociados a la cuenta
+        const configAccount = await AccountData.getAccountDataByAccountName(accountName);
+        const { maxRows, ftpId, directoryProcess, ...integrationParameters } = await getIntegrationParameters(accountName, actionProcess, configAccount);
+        vtexApiClient = integrationParameters.apiClient;
+        entityName = integrationParameters.entityName;
+        schemaName = integrationParameters.schemaName;
+
+        // Se obtiene la carpeta de pending
+        const { process: processName } = directoryProcess[actionProcess];
+        logRecord.process = processName;
+        Logger.info(`Executing process ${processName} in account ${accountName}`);
+
+        // Conexión al servidor FTP
+        Logger.info(`Connecting to FTP ${ftpId}`);
+        const ftpCredentials = await getFtpProperties(ftpId);
+        clientFTP = await connectToFtp(ftpCredentials);
+
+        // Si el proceso es de descomprimir archivo .zip
+        if (processName == 'unzip_file') {
+            await descompressZipFile(clientFTP, logRecord, directoryProcess, ftpCredentials, {
+                accountName, actionProcess, filePath, timestamp, fileName, fileData
+            })
+        } else {
+            await callbackProcessFile(clientFTP, logRecord, maxRows, directoryProcess, configAccount,
+                { accountName, actionProcess, filePath, contentType, timestamp, fileName, fileData }
+            );
+        }
+
+        await saveInLogEntity(vtexApiClient, entityName, schemaName, logRecord);
+    } catch (ex) {
+        const { message } = getErrorData(ex);
+
+        // Se valida que el número de intentos no supere el valor máximo configurado
+        if (attemps < SFTP_MAX_ATTEMPS) {
+            await delayStatusProcess(5);
+            Logger.warn('Error in handleProcessFile', { accountName, actionProcess, filePath, attemps, message });
+
+            // Se encola el message para procesar nuevamente, aumentando el n° de reintentos
+            sqsMessage.attemps = attemps + 1;
+            await sendMessageToSqs(SFTP_JOBS_QUEUE_URL, sqsMessage).catch(Logger.error);
+        } else {
+            Logger.error('Error in handleProcessFile', message);
+
+            logRecord.success = false;
+            logRecord.error = message;
+
+            await saveInLogEntity(vtexApiClient, entityName, schemaName, logRecord);
+            await sendMessageToSqs(SFTP_JOBS_DLQ_QUEUE_URL, {
+                accountName, actionProcess, filePath,
+                reason: message,
+                awsRequestId
+            }).catch(ex => {
+                Logger.error('Error in handleProcessFile', ex);
+            });
+        }
+    } finally {
+        // Se cierra la conexión al servidor FTP (si esta existe)
+        if (clientFTP?.client) {
+            clientFTP.client.end();
+        }
+    }
+}
+
+async function descompressZipFile(clientFTP, logRecord, directoryProcess, ftpCredentials, handleParams) {
+    // Se obtiene los parámetros de la función de donde se invoca esta
+    const { accountName, actionProcess, filePath, timestamp, fileName, fileData } = handleParams;
+
+    // Se extrae el nombre y extensión del archivo
+    const { base, ext } = fileData;
+
+    if (ext !== '.zip') {
+        throw new Error(`File extension '${ext}' is not valid`);
+    }
+
+    // Se obtiene la información del proceso a ejecutar con el archivo, así como las carpetas requeridas
+    const { schemaId, pendingPath, processedPath } = directoryProcess[actionProcess];
+    Logger.info(`Getting schema file ${schemaId}`);
+    const schema = await getSchemaProperties(schemaId);
+    const { ContentType, ExtractOptions, PatternName } = schema;
+    if (ContentType !== 'zip') {
+        throw new Error(`Content type '${ContentType}' is not valid`);
+    }
+
+    // Se define la propiedad que contiene información de los archivos del .zip
+    logRecord.zipData = {
+        count: 0, // Archivos existentes
+        extracted: 0, // Archivos extraidos
+        errors: {} // Errores en procesamiento de los archivos
+    };
+
+    // Se descarga el archivo .zip al directorio temporal de la Lambda
+    const targetFolder = '/tmp';
+    const localZipFile = `${targetFolder}/${fileName}.zip`;
+    Logger.info(`Downloading file ${filePath} to ${targetFolder}`);
+    const downloadedFile = await downloadFile(clientFTP, filePath, localZipFile, ftpCredentials?.type);
+    if (downloadedFile) {
+        // Si existen valores por extraer
+        Logger.info(`Options for extract files: ${ExtractOptions?.length}`);
+        if (ExtractOptions?.length) {
+            const zipFile = new AdmZip(localZipFile);
+            const zipEntries = zipFile.getEntries();
+
+            // Se define el N° de archivos existentes en el .zip
+            logRecord.zipData.count = zipEntries.length;
+
+            for (let zipEntry of zipEntries) {
+                const { entryName } = zipEntry;
+                const filteredFiles = ExtractOptions.filter(option => {
+                    const { PatternName } = option;
+                    return entryName.match(new RegExp(PatternName));
+                });
+                for (let filteredFile of filteredFiles) {
+                    const { ActionProcess, FolderPath = pendingPath } = filteredFile;
+                    logRecord.zipData.extracted++;
+
+                    // Se extrar el archivo del .zip
+                    Logger.info(`Extracting file ${entryName}`);
+                    const extractFile = zipFile.extractEntryTo(entryName, targetFolder, true, true);
+                    if (extractFile) {
+                        // Se referencia la ruta del archivo local extraido, y la ruta donde se subirá el archivo
+                        const localPath = `${targetFolder}/${entryName}`, remotePath = `${FolderPath}/${entryName}`;
+                        Logger.info(`Uploading file ${localPath} to ${remotePath}`);
+                        const uploadedFile = await uploadFile(clientFTP, localPath, remotePath, ftpCredentials?.type).catch(ex => {
+                            const { message, info } = getErrorData(ex);
+                            Logger.error(message, info);
+                            logRecord.zipData.errors[entryName] = message;
+                        });
+                        // Se valida si el archivo se subió al servidor FTP, y si se tiene definido una acción a ejecutar
+                        Logger.info(`Uploaded file: ${uploadedFile}`);
+                        if (uploadedFile && ActionProcess) {
+                            Logger.info(`Set action process ${ActionProcess}`);
+                            // Se envía el message a la cola SQS para procesar el archivo en cuestión
+                            sendMessageToSqs(
+                                SFTP_JOBS_QUEUE_URL,
+                                { accountName, actionProcess: ActionProcess, filePath: remotePath, timestamp }
+                            ).catch(ex => {
+                                const { info } = getErrorData(ex);
+                                Logger.error(filePath, info);
+                            });
+                        }
+                    } else {
+                        logRecord.zipData.errors[entryName] = 'File not extracted';
+                    }
+                }
+            }
+        }
+
+        // Se obtiene el folder final a donde se moverán los archivos
+        const targetFolderRender = getRenderValue(PatternName, base, processedPath);
+
+        // Se mueve el archivo .zip original
+        Logger.info(`Moving file ${filePath} to ${targetFolderRender}`);
+        await moveProcessedFile(clientFTP, filePath, targetFolderRender, `${fileName}${ext}`).then(() => {
+            logRecord.success = true;
+        }).catch(ex => {
+            Logger.error('Error with moveProcessedFile in descompressZipFile', ex);
+            logRecord.success = false;
+            logRecord.error = ex.message
+        });
+    } else {
+        logRecord.success = false;
+        logRecord.error = `File ${filePath} cannot be downloaded`;
+    }
+}
+
+async function callbackProcessFile(clientFTP, logRecord, maxRows, directoryProcess, configAccount, handleParams) {
+    // Se obtiene los parámetros de la función de donde se invoca esta
+    const { accountName, actionProcess, filePath, contentType, timestamp, fileName, fileData } = handleParams;
+
+    // Se extrae el nombre y extensión del archivo
+    const { base, ext } = fileData;
+
+    // Se obtiene la información del proceso a ejecutar con el archivo, así como las carpetas requeridas
+    const { schemaId, process, processingPath, processedPath, logsPath } = directoryProcess[actionProcess];
+    const schema = await getSchemaProperties(schemaId);
+    const { PatternName } = schema;
+
+    const fileValidator = new ValidFile(schema);
+
+    // Se obtiene el contenido del archivo
+    Logger.info(`Getting content of file ${filePath}`);
+    const fileContent = await getFileContent(clientFTP, filePath);
+
+    // Se procede a extraer los datos del archivo a formato JSON
+    let { valid: validFile, errors: errorsFile, data: dataFile } = await fileValidator.extractContentFile({ content: fileContent }, contentType);
+    if (validFile && dataFile?.length) {
+        // Se define el número de filas
+        Logger.info(`Records count: ${dataFile.length}`);
+        logRecord.rows = dataFile.length;
+
+        // Se valida si el número de registros es menor al valor máximo configurado, para en caso contrario proceder a dividir el archivo grande
+        // en archivos mas pequeños en formato JSON.
+        if (dataFile.length <= maxRows) {
+            // Uso de clase para configAccount
+            const servicesRedirect = new ServicesRedirect(configAccount);
+
+            // Array donde se consolida los errores de validación presentados
+            const errors = [];
+
+            // Se ejecuta el proceso dentro de una promise
+            await Promise.allSettled(dataFile.map(data => {
+                return new Promise(resolve => {
+                    // Se ejecuta la validación del registro con base a un Schema
+                    const { valid: validRecord, errors: errorsRecord } = fileValidator.validateRecordSchema(data);
+                    if (validRecord) {
+                        // Se obtiene la data normalizada, para enviar a la respectiva cola SQS, segun el proceso a ejecutar
+                        let newData = fileValidator.standardizeData(data);
+                        servicesRedirect.initSendData({ typeProcess: process, data: newData }).then(serviceResponse => {
+                            resolve(newData);
+                        }).catch(ex => {
+                            const { message } = getErrorData(ex);
+                            Logger.error(message);
+                            resolve(null);
+                        });
+                    } else {
+                        errors.push(JSON.stringify({ data, errorsRecord }))
+                        Logger.warn('Error in validation', { data, errorsRecord });
+                        resolve(null);
+                    }
+                });
+            }));
+
+            Logger.info(`Errors count: ${errors.length}`);
+            logRecord.errorRows = errors.length;
+
+            // Se genera el archivo de log con los datos de errores (si existieron)
+            if (errors.length) {
+                // Se crea la carpeta donde se moveran los archivos de log
+                await createFolder(clientFTP, logsPath);
+
+                // Se escribe el archivo de log
+                await createFile(clientFTP, `${fileName}.log`, errors.join('\n'), logsPath).catch(ex => { });
+            }
+        } else {
+            // Se obtiene el N° de archivos estimado, a partir de la división entre el N° de filas
+            // del archivo y el número de filas máximo configurado.
+            const estimatedFiles = Math.ceil(dataFile.length / maxRows);
+            const digits = String(estimatedFiles).length;
+            Logger.info(`Splitting file ${filePath} into ${estimatedFiles} files`);
+
+            // N° de archivos en que se divide el archivo original
+            logRecord.countFiles = estimatedFiles;
+
+            // Se concatena en la lista de promises los lotes de filas para generar
+            let promises = [], count = 1;
+            while (dataFile.length > 0) {
+                promises.push({ count, data: dataFile.splice(0, maxRows) });
+                count++;
+            }
+            if (promises.length) {
+                // Se crea la carpeta donde se moveran los archivos divididos (si aplica)
+                await createFolder(clientFTP, processingPath).catch(ex => {
+                    Logger.error('Error with createFolder in callbackProcessFile', ex);
+                });
+
+                // Se generan los archivos JSON
+                Logger.info(`Generating ${promises.length} splitted files`);
+                await Promise.allSettled(promises.map(item => {
+                    return new Promise((resolve, reject) => {
+                        const { count, data } = item;
+                        const jsonFileName = `${fileName}_${String(count).padStart(digits, '0')}.json`;
+
+                        // Se escribe el archivo en un directorio temporal
+                        createFile(clientFTP, jsonFileName, JSON.stringify(data), processingPath).then(filePath => {
+                            // Se envía el message a la cola SQS para procesar el archivo en cuestión
+                            Logger.info(`Sending message to SQS`);
+                            sendMessageToSqs(
+                                SFTP_JOBS_QUEUE_URL,
+                                { accountName, actionProcess, filePath, contentType: 'json', timestamp }
+                            ).then(() => {
+                                Logger.info(`File processed ${filePath}`);
+                                resolve(filePath)
+                            }).catch(ex => {
+                                const { info } = getErrorData(ex);
+                                Logger.error(filePath, info);
+                                reject(new Error('Error while send Data'));
+                            });
+                        }).catch(ex => {
+                            Logger.info(`Error sending message`, ex);
+                            reject(new Error('Error while upload FTP file'));
+                        });
+                    });
+                }));
+            }
+        }
+
+        // Se obtiene el folder final a donde se moverán los archivos
+        const targetFolderRender = getRenderValue(PatternName, base, processedPath);
+
+        // Se mueve el archivo a la carpeta de procesados
+        // Al nombre del archivo se le concatena una marca de tiempo "timestamp"
+        Logger.info(`Moving file ${filePath} to ${targetFolderRender}`);
+        await moveProcessedFile(clientFTP, filePath, targetFolderRender, `${fileName}${ext}`).then(() => {
+            logRecord.success = true;
+        }).catch(ex => {
+            Logger.error('Error with moveProcessedFile in callbackProcessFile', ex);
+            logRecord.success = false;
+            logRecord.error = ex.message
+        });
+    } else {
+        Logger.warn('Error validating file', errorsFile);
+        logRecord.success = false;
+        logRecord.error = errorsFile.join('|');
+    }
+}
+
+async function getIntegrationParameters(accountName, actionProcess, configAccount, includeDirectory = true) {
+    // Obtener datos de la integración SFTP
+    const { SftpIntegration, Credentials } = configAccount;
+    if (!SftpIntegration) {
+        throw new Error(`SftpIntegration not found for account ${accountName}`);
+    }
+
+    // Se define si se imprimen todos los mensajes de Logger.
+    Logger.setAccount(configAccount);
+
+    // Se establece una conexión a la API de VTEX
+    const { key, token } = Credentials;
+    const apiClient = new VtexApi(accountName, key, token);
+
+    // Se consulta las propiedades de la integración
+    let { isActive, maxRows, ftpId, directoryProcess, entityName, schemaName } = SftpIntegration;
+    if (!isActive) {
+        throw new Error(`SftpIntegration is not actived for account ${accountName}`);
+    }
+
+    const itemsData = { apiClient, maxRows, ftpId, entityName, schemaName };
+    if (includeDirectory) {
+        if (!directoryProcess?.[actionProcess]) {
+            throw new Error(`Directory options not found for actionProcess '${actionProcess}' in account ${accountName}`);
+        }
+
+        itemsData.directoryProcess = directoryProcess;
+
+        // Se establece el valor asociado al proceso (si este existe) dentro de las configuraciones
+        for (let prop of ['maxRows', 'ftpId', 'entityName', 'schemaName']) {
+            if (directoryProcess[actionProcess]?.[prop]) {
+                itemsData[prop] = directoryProcess[actionProcess][prop];
+            }
+        }
+    }
+
+    return itemsData;
+}
+
+/**
+ * Consulta los datos del schema
+ * @param {string} schemaId Id del schema
+ * @returns Datos del schema.
+ */
+async function getSchemaProperties(schemaId) {
+    // Se obtiene los datos del schema, para validar el nombre del archivo
+    const dynamoConnector = new DynamoDBConnector(SFTP_DATA_SCHEMA_TABLE);
+    const schema = await dynamoConnector.getItem({ SchemaId: schemaId });
+    return schema;
+}
+
+/**
+ * Consulta en DynamoDB las credenciales de servidor SFTP asociadas a un Id.
+ * @param {string} ftpId Id de la credencial FTP.
+ * @returns Objeto con los datos de conexión al servidor FTP.
+ */
+async function getFtpProperties(ftpId) {
+    // Se obtiene los datos del schema, para validar el nombre del archivo
+    const dynamoConnector = new DynamoDBConnector(SFTP_CREDENTIALS_TABLE);
+    const schema = await dynamoConnector.getItem({ FtpId: ftpId });
+    const { Type: type, Host: host, Port: port, User: user, Password: password } = schema;
+    return { type, host, port, user, password };
+}
+
+/**
+ * Crea un archivo en la carpeta "temp" y subirlo a un servidor FTP.
+ * @param {*} clientFTP Instancia de conexión al servidor FTP.
+ * @param {string} fileName Nombre del archivo.
+ * @param {string} data Contenido del archivo a crear.
+ * @param {string} targetFolder Carpeta del FTP donde se subirá el archivo.
+ * @return Path del archivo generado.
+ */
+async function createFile(clientFTP, fileName, data, targetFolder) {
+    return new Promise((resolve, reject) => {
+        const tempPath = `/tmp/${fileName}`;
+        Logger.info(`Creating file ${tempPath}`);
+        fs.writeFile(tempPath, data, 'utf-8', err => {
+            if (err) {
+                Logger.error('Error in createFile', err);
+                reject(err);
+            } else {
+                // Path del archivo JSON generado
+                const filePath = `${targetFolder}/${fileName}`;
+                Logger.info(`Uploading file ${filePath}`);
+                clientFTP.put(fs.createReadStream(tempPath), filePath).then(() => {
+                    Logger.info(`File uploaded ${filePath}`);
+                    resolve(filePath)
+                }).catch(ex => {
+                    const { info } = getErrorData(ex);
+                    Logger.error('Error in createFile.put', filePath, info);
+                    reject(new Error('Error while upload FTP file'));
+                });
+            }
+        });
+    });
+}
+
+/**
+ * Renderiza el valor de un texto a partir de una expresión regular, y/o valores de fecha del sistema.
+ * @param {*} patternName Expresión regular usada para la búsqueda del archivo.
+ * @param {*} fileName Nombre del archivo encontrado con la expresión regular.
+ * @param {*} processedPath Ruta del directorio a renderizar.
+ * @return Ruta del directorio con los comodines de RegExp sustituidos por los valores extraidos de la expresión regular,
+ * y/o valores de fecha sustituidos por los respectivos valores.
+ * @see {@link https://momentjs.com/|Moment.js Docs}
+ */
+function getRenderValue(patternName, fileName, processedPath) {
+    // Expresión regular del filename
+    const regex = new RegExp(patternName);
+
+    // Se valida valores agrupados de la expresión regular, para sustituir en el nombre del folder
+    const match = fileName.match(regex);
+    if (match?.length > 1) {
+        processedPath = fileName.replace(regex, processedPath);
+    }
+
+    // Se formatea el texto con las variables de moment.js a partir de la fecha y hora actual del sistema
+    const currentDate = new Date();
+    processedPath = moment(currentDate).format(processedPath);
+    return processedPath;
+}
+
+/**
+ * Registra los datos de log en la entidad de Master Data.
+ * @param {*} vtexApiClient Instancia de conexión a la API de VTEX.
+ * @param {string} entityName Nombre de la entidad de Master Data.
+ * @param {string} schemaName NOmbre del schema de la entidad de Master Data.
+ * @param {object} logRecord Objeto de datos del log.
+ */
+async function saveInLogEntity(vtexApiClient, entityName, schemaName, logRecord) {
+    if (vtexApiClient && entityName && schemaName) {
+        // Se inserta en la entidad de Master Data los datos de log
+        Logger.info(`Saving log data in entity ${entityName}:${schemaName}`);
+        await vtexApiClient.fetch(`/dataentities/${entityName}/documents?_schema=${schemaName}`, {
+            method: 'PATCH',
+            data: logRecord,
+            validateStatus: status => status >= 200 && status < 400
+        }).catch(ex => {
+            const { message } = getErrorData(ex);
+            Logger.error('Error with vtexApiClient.fetch', message);
+        });
+    }
+}