dcos-core-monalisav2-latam 1.0.0

package/src/functions/sftpIntegrations/processes/validateFileSchema.js

@@ -0,0 +1,226 @@
+const csv = require('csv-parser')
+const xml2js = require('xml2js')
+const { Validator } = require('jsonschema')
+const { Readable } = require('node:stream')
+const Logger = require("../../../common/utils/logger");
+
+class ValidFile {
+  constructor(schema) {
+    this.schema = schema // Esquema proporcionado durante la creación de la instancia
+  }
+
+  extractContentFile = async (file, contentType = null) => {
+    if (!file) {
+      return {
+        valid: false,
+        errors: ['No se proporcionó un archivo'],
+      }
+    }
+
+    if (!this.schema) {
+      throw new Error('Esquema no inicializado.')
+    }
+
+    const firstExecution = !contentType;
+
+    if (!contentType) {
+      contentType = this.schema.ContentType;
+    }
+    contentType = contentType?.toLowerCase();
+
+    let parsedData
+
+    try {
+      switch (contentType) {
+        case 'csv':
+          parsedData = await this.parseCSV(file.content, firstExecution)
+          break
+        case 'json':
+          parsedData = this.parseJson(file.content, firstExecution)
+          break
+        case 'xml':
+          parsedData = await this.parseXML(file.content, firstExecution)
+          break
+        default:
+          return { valid: false, errors: [`ContentType no soportado o no definido`] }
+      }
+    } catch (error) {
+      return { valid: false, errors: [`Error al procesar el archivo: ${error.message}`] }
+    }
+
+    return {
+      valid: parsedData !== undefined,
+      data: parsedData,
+    }
+  }
+
+
+  // validador de esquema
+  validateRecordSchema = (data) => {
+    const { Schema } = this.schema
+
+    if (!Schema?.properties) {
+      throw new Error("El esquema no está definido correctamente.")
+    }
+
+    const validator = new Validator()
+    const record = data
+
+    if (!record) {
+      return {
+        valid: false,
+        errors: ["No se encontró ningún registro en los datos parseados."],
+        record: null,
+      }
+    }
+
+    // validacion de datos contra el esquema
+    const validationResult = validator.validate(record, Schema)
+
+    if (validationResult.errors.length > 0) {
+      return {
+        valid: false,
+        errors: validationResult.errors.map(error => error.stack),
+        record: null,
+      }
+    }
+
+    return {
+      valid: true,
+      errors: [],
+      record,
+    }
+  }
+
+  // -------------------------
+  standardizeData = (data) => {
+    const standardized = {}
+    const { Standardization: standardizationRules } = this.schema
+    this.callbackStandarize(standardized, standardizationRules, data);
+    return standardized
+  }
+
+  callbackStandarize = (standardized, standardizationRules, data) => {
+    for (const [key, rule] of Object.entries(standardizationRules)) {
+      try {
+        let ruleType = Object.prototype.toString.call(rule);
+        if (ruleType == '[object Object]') {
+          // Si los datos de conversión son de tipo Object se ejecuta la actualización de manera recursiva
+          standardized[key] = {};
+          this.callbackStandarize(standardized[key], standardizationRules[key], data);
+        } else {
+          standardized[key] = eval(rule)
+        }
+      } catch (ex) {
+        Logger.error(`Error procesando la regla: ${rule}`, ex)
+        standardized[key] = null;
+      }
+    }
+  }
+
+  parseCSV = async (content, firstExecution) => {
+    const { Separator, Headers = null, Conditional, GroupRecord } = this.schema;
+
+    const csvStream = new Readable()
+    csvStream.push(content)
+    csvStream.push(null)
+
+    let records = firstExecution ? {} : [], index = 0;
+    return new Promise((resolve, reject) => {
+      csvStream
+        .pipe(csv({ separator: Separator, headers: Headers }))
+        .on('data', item => {
+          if (firstExecution) {
+            let isValid = !Conditional;
+            if (Conditional) {
+              try {
+                eval(`isValid=${Conditional}`)
+              } catch (ex) { }
+            }
+            if (isValid) {
+              if (GroupRecord) {
+                try {
+                  eval(GroupRecord);
+                } catch (ex) { }
+              } else {
+                records[index] = item;
+              }
+            }
+            index++;
+          } else {
+            records.push(item);
+          }
+        })
+        .on('end', () => resolve(firstExecution ? Object.values(records) : records))
+        .on('error', (error) => reject(error))
+    })
+  }
+
+  parseXML = async (content, firstExecution) => {
+    const { RootElement, RecordElement, Conditional, GroupRecord } = this.schema;
+
+    const parser = new xml2js.Parser({
+      // Hace que el valor de cada key se retorne como un texto y no como array
+      explicitArray: false
+    });
+    const result = await parser.parseStringPromise(content);
+    if (!firstExecution) {
+      return result?.[RootElement]?.[RecordElement] ?? [];
+    }
+    if (result?.[RootElement]?.[RecordElement]?.length) {
+      let records = {};
+      result[RootElement][RecordElement].forEach((item, index) => {
+        let isValid = !Conditional;
+        if (Conditional) {
+          try {
+            eval(`isValid=${Conditional}`)
+          } catch (ex) { }
+        }
+        if (isValid) {
+          if (GroupRecord) {
+            try {
+              eval(GroupRecord);
+            } catch (ex) { }
+          } else {
+            records[index] = item;
+          }
+        }
+      })
+      return Object.values(records);
+    }
+    return [];
+  }
+
+  parseJson = (content, firstExecution) => {
+    const { Conditional, GroupRecord } = this.schema;
+
+    const dataFile = JSON.parse(content);
+    if (!firstExecution) {
+      return dataFile;
+    }
+    if (dataFile.length) {
+      let records = {};
+      dataFile.forEach((item, index) => {
+        let isValid = !Conditional;
+        if (Conditional) {
+          try {
+            eval(`isValid=${Conditional}`)
+          } catch (ex) { }
+        }
+        if (isValid) {
+          if (GroupRecord) {
+            try {
+              eval(GroupRecord);
+            } catch (ex) { }
+          } else {
+            records[index] = item;
+          }
+        }
+      });
+      return Object.values(records);
+    }
+    return [];
+  }
+}
+
+module.exports = ValidFile

package/src/functions/sftpIntegrations/schemas/credential-schema.js

@@ -0,0 +1,123 @@
+const AWS = require('aws-sdk')
+const dynamoDb = new AWS.DynamoDB.DocumentClient()
+// UTILS
+const Apiresponse = require('../../../common/utils/api-response');
+const { getErrorData } = require('../../../common/utils/util');
+const Logger = require("../../../common/utils/logger");
+// CONSTANTS
+const { SFTP_CREDENTIALS_TABLE } = process?.env ?? {};
+
+/**
+ * Función que se invoca desde la función 'sftp-credentiales' del archivo functions.xml
+ * @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.handler = async (event, context) => {
+    const { httpMethod = '', pathParameters } = event;
+    const { FtpId = null } = pathParameters ?? {};
+    // ID de la petición en AWS
+    const { awsRequestId } = context;
+    try {
+        switch (httpMethod.toUpperCase()) {
+            case 'GET':
+                return await handleGetRecord(FtpId)
+            case 'PUT': {
+                const body = event?.body ? JSON.parse(event.body) : {}
+                return await handlePutRecord(FtpId, body)
+            }
+            case 'DELETE':
+                return await handleDeleteRecord(FtpId)
+            default:
+                return Apiresponse.response(405, `Method ${httpMethod} not allowed`)
+        }
+    } catch (ex) {
+        const { message, info } = getErrorData(ex);
+        Logger.error(info);
+        return Apiresponse.response(500, { 'error': message, awsRequestId });
+    }
+}
+
+// Handler to GET (get a record)
+const handleGetRecord = async (ftpId) => {
+    let params = {
+        TableName: SFTP_CREDENTIALS_TABLE
+    }
+
+    try {
+        if (ftpId) {
+            params.Key = { FtpId: ftpId }
+            const result = await dynamoDb.get(params).promise()
+            if (!result.Item) {
+                return Apiresponse.response(404, `Schema not found, verify your FtpId or Get Schemas to see Schema Id`)
+            }
+
+            return {
+                statusCode: 200,
+                body: JSON.stringify(result.Item),
+            }
+
+        } else {
+            let result = await dynamoDb.scan(params).promise();
+            let items = result.Items;
+
+            while (result.LastEvaluatedKey) {
+                params.ExclusiveStartKey = result.LastEvaluatedKey;
+                result = await dynamoDb.query(params).promise();
+                items = items.concat(result.Items);
+            }
+
+            return {
+                statusCode: 200,
+                body: JSON.stringify(items),
+            }
+        }
+    } catch (error) {
+        return Apiresponse.response(500, `Error retrieving record: ${error}`)
+    }
+}
+
+// Handler to PUT (create or update record)
+const handlePutRecord = async (ftpId, data) => {
+
+    if (!data || Object.keys(data).length === 0) {
+        return Apiresponse.response(400, 'No data provided to create/update record schema')
+    }
+
+    try {
+        await dynamoDb.put({
+            TableName: SFTP_CREDENTIALS_TABLE,
+            Item: {
+                FtpId: ftpId,
+                ...data
+            }
+        }).promise()
+
+        return {
+            statusCode: 200,
+            body: JSON.stringify({ message: 'Record created/updated successfully', data }),
+        }
+
+    } catch (error) {
+        return Apiresponse.response(500, `Error creating/updating record: ${error}`)
+    }
+}
+
+// Handler to DELETE (delete a record)
+const handleDeleteRecord = async (ftpId) => {
+    if (!ftpId) {
+        return Apiresponse.response(400, 'The "FtpId" parameter is required for this request.')
+    }
+    try {
+        await dynamoDb.delete({
+            TableName: SFTP_CREDENTIALS_TABLE,
+            Key: { FtpId: ftpId }
+        }).promise();
+
+        return {
+            statusCode: 200,
+            body: JSON.stringify({ message: 'Record deleted successfully' }),
+        }
+    } catch (error) {
+        return Apiresponse.response(500, `Error deleting record: ${error}`)
+    }
+}

package/src/functions/sftpIntegrations/schemas/record-schema.js

@@ -0,0 +1,131 @@
+const AWS = require('aws-sdk')
+const dynamoDb = new AWS.DynamoDB.DocumentClient()
+// UTILS
+const Apiresponse = require('../../../common/utils/api-response')
+const Logger = require("../../../common/utils/logger");
+
+// CONSTANTS
+const SCHEMA_FILES_TABLE = process.env.SCHEMA_FILES_TABLE
+const sftpConfigProducer= require("../sftp-config-producer");
+
+module.exports.handler = async (event, res) => {
+  const id = event?.pathParameters?.SchemaId ?? ''
+  const method = event?.httpMethod?.toUpperCase()
+  const body = event?.body ? JSON.parse(event.body) : {}
+  Logger.debug('EVENT:', event);
+  try {
+
+    switch (method) {
+      case 'GET':
+        return await handleGetRecord({ id })
+      case 'PUT':{
+        return await handlePutRecord({ id, data:body })
+      }
+      case 'DELETE': 
+        return await handleDeleteRecord({ id })
+
+      case 'POST':
+        return await sftpConfigProducer.producer(event, res)
+
+      default:
+        return Apiresponse.response(405, `Method ${method} not allowed`)
+    }
+  
+  } catch (error) {
+    return Apiresponse.response(500, `Internal Server Error Handler ${error}`)
+  }
+}
+
+// Handler to GET (get a record)
+const handleGetRecord = async ({ id }) => {
+  let params = {
+    TableName: SCHEMA_FILES_TABLE,
+  }
+
+  try {
+    
+    if (id) {
+      params.Key = { SchemaId: id }
+      const result = await dynamoDb.get(params).promise()
+      if (!result.Item) {
+        return Apiresponse.response(404, `Schema not found, verify your schemaId or Get Schemas to see Schema Id`)
+      }
+
+      return {
+        statusCode: 200,
+        body: JSON.stringify(result.Item),
+      }
+      
+    } else {
+      result = await dynamoDb.scan(params).promise();
+      let items = result.Items;
+
+      while (result.LastEvaluatedKey) {
+          params.ExclusiveStartKey = result.LastEvaluatedKey;
+          result = await dynamoDb.query(params).promise();
+          items = items.concat(result.Items);
+      }
+      return {
+        statusCode: 200,
+        body: JSON.stringify(items),
+      }
+    }
+    
+
+  } catch (error) {
+    return Apiresponse.response(500, `Error retrieving record: ${error}`)
+  }
+}
+
+// Handler to PUT (create or update record)
+const handlePutRecord = async ({ id, data }) => {
+
+  if (!data || Object.keys(data).length === 0) {
+    return Apiresponse.response(400, 'No data provided to create/update record schema')
+  }
+  if (id === '') {
+    return  Apiresponse.response(400, 'The "SchemaId" parameter is required for create/update record schema')
+  }
+
+  try {
+    await dynamoDb.put({
+      TableName: SCHEMA_FILES_TABLE,
+      Item: {
+        SchemaId: id,
+        ...data
+      }
+    }).promise()
+
+    return {
+      statusCode: 200,
+      body: JSON.stringify({ message: 'Record created/updated successfully', data }),
+    }
+
+  } catch (error) {
+    return Apiresponse.response(500, `Error creating/updating record: ${error}`)
+  }
+}
+
+// Handler to DELETE (delete a record)
+const handleDeleteRecord = async ({ id }) => {
+  if (!id) {
+    return Apiresponse.response(400, 'The "SchemaId" parameter is required for this request.')
+  }
+  try {
+    await dynamoDb.delete({
+      TableName: SCHEMA_FILES_TABLE,
+      Key: { 
+        SchemaId: id
+      }
+    })
+    .promise()
+
+    return {
+      statusCode: 200,
+      body: JSON.stringify({ message: 'Record deleted successfully' }),
+    }
+
+  } catch (error) {
+    return  Apiresponse.response(500, `Error deleting record: ${error}`)
+  }
+}

package/src/functions/sftpIntegrations/schemas/sftp_required_fields.json

@@ -0,0 +1,3 @@
+{
+  "sftpConnectConfig": ["host", "port", "user", "password", "routeDirectory"]
+}

package/src/functions/sftpIntegrations/sftp-config-producer.js

@@ -0,0 +1,112 @@
+const ApiResponse = require('../../common/utils/api-response')
+const AWSServices = require('../../common/utils/aws-services')
+
+const { SftpFileSystem } = require('../../common/utils/ftp-sftp');
+const requiredFieldsConfig = require('./schemas/sftp_required_fields.json');
+const AccountData = require("../../entities/account");
+const ClientData = require("../../entities/clients");
+const Logger = require("../../common/utils/logger");
+
+const SQS_CONNECTION_SFTP_QUEUE_URL = process.env.SQS_CONNECTION_SFTP_QUEUE_URL
+
+module.exports.producer = async (event) => {
+  let statusCode = 200;
+  let message
+  let body = JSON.parse(event.body);
+
+  const { client_id: clientId } = event.requestContext.authorizer.claims || {};
+  Logger.log("EVENT:", event?.body, clientId);
+  // OBTENER LA CONFIGURACION DEL ACCOUNT ✅
+  try {
+    const listAccounts = await ClientData.getClient(clientId);
+    const accountName = listAccounts.AccountNames.values[0] || null;
+
+    if (!accountName) {
+      return ApiResponse.response(400, { approved: false, message: "AccountName is Required" });
+    }
+
+    const configAccount = await AccountData.getAccountDataByAccountName(accountName);
+
+    // VERIFICAR QUE EXISTE LA PROPIEDAD ESPECIFICADA SftpIntegration dentro de la configuracion del account
+    const sftpConfig = configAccount?.SftpIntegration ?? null
+
+    const isActive = isActiveServiceInConfiguration({ isActive: sftpConfig.isActive })
+
+    if (!isActive) {
+      return ApiResponse.response(400, { approved: false, message: "SftpIntegration service is not active" });
+    }
+
+
+    const isConfigSFTP = isValidConnectionSFTP({ sftpConnectConfig: sftpConfig?.sftpConnectConfig})
+
+    if (!isConfigSFTP.success) {
+      return ApiResponse.response(400, { approved: false, message: isConfigSFTP.message });
+    }
+    // Send info to SQS
+    await sendSftpConnectionToSQS({ sftpConfig })
+
+  
+  } catch (error) {
+    Logger.error(error)
+    return ApiResponse.response(500, { approved: false, message: "Error sending SFTP connection" })
+  }
+
+}
+
+const isActiveServiceInConfiguration = ({ isActive }) => {
+    if  (typeof isActive === 'boolean' && isActive !== '' && isActive) {
+      return true
+    }
+    return false
+}
+
+const isValidConnectionSFTP = async ({ sftpConnectConfig }) => {
+
+  const response = validateRequiredFields(sftpConnectConfig, requiredFieldsConfig)
+
+  if(!response.success){
+    return { success: response?.success, message: response?.message}
+  }
+
+  const { host, port, user, password } = sftpConnectConfig;
+
+  try {
+    const sftpFileSystem = SftpFileSystem.create(host, port, user, password);
+    
+    await sftpFileSystem.connect();
+    await sftpFileSystem.disconnect();
+  
+    return { success: true, message: 'Connection SFTP successfully.' };
+  
+  } catch (error) {
+    Logger.error('Error connecting to SFTP:', error);
+    return { success: false, message: `Error connecting to SFTP: ${error.message}` };
+  }
+}
+
+function validateRequiredFields(obj, requiredFields) {
+  const missingFields = requiredFields.filter(field => !obj[field]);
+
+  if (missingFields.length > 0) {
+    return {
+      success: false,
+      message: `Missing fields required: ${missingFields.join(', ')}`,
+    };
+  }
+
+  return { success: true };
+}
+
+
+const sendSftpConnectionToSQS = async ({ sftpConfig }) => {
+  if(!sftpConfig){
+    return ApiResponse.response(400, "Data account not found")
+  }
+
+  try {
+    await AWSServices.sendSQSMessage(SQS_CONNECTION_SFTP_QUEUE_URL, sftpConfig);
+  } catch (err) {
+    Logger.error('Failed to send message to SQS:', err);
+    return ApiResponse.response(500, 'Failed to process SFTP connection message.');
+  }
+}