dcos-core-monalisav2-latam 1.0.0

package/src/functions/nodeflow/nodeflow-cron.js

@@ -0,0 +1,200 @@
+const AWSServices = require("../../common/utils/aws-services");
+const AccountData = require("../../entities/account");
+const Crons = require("../../entities/cron");
+const ApiResponse = require("../../common/utils/api-response");
+const Logger = require("../../common/utils/logger");
+
+const SQS_NODEFLOW_QUEUE_URL = process?.env?.SQS_NODEFLOW_QUEUE_URL;
+const CronIdFlowsActions= process?.env?.CRON_ID ?? null;
+const BRUNO_LOCAL = process?.env?.DB_CONNECTION == 'bruno_local' ? true : false;
+
+const nodeCron = require('node-cron');
+const parser = require('cron-parser');
+
+module.exports.run = async (event, context) => {
+  Logger.debug(`Your cron function "${context?.functionName ?? 'main'}" ran`);
+  const { httpMethod } = event;
+  // Se consulta la lista de cron jobs registrada en base de datos
+  const promises = [], cronJobs = await getCronJobs();
+  for (let cronJob of cronJobs) {
+    const { Name, Actived, Cron, Values, SourcesName, AccountName, AppToken, AppKey, Offset } = cronJob;
+    // Se valida si el cron job está activo
+    const currentDate= new Date()
+    try{
+      if(Offset){
+        // Fecha actual del sistema
+        if(Offset > 0){
+          currentDate.setHours(currentDate.getHours()+parseFloat(Offset));
+        }else{
+          currentDate.setHours(currentDate.getHours()-(parseFloat(Offset)*-1));
+        }
+      }
+    } catch (eee){
+      Logger.error("error set Offset", eee);
+    }
+    Logger.debug(`Query date: ${currentDate.toString()}`);
+    
+    if (Actived && SourcesName) {
+      Logger.debug(`Validating cron: ${Name}`);
+      // Se valida si el valor del cron corresponde al formato requerido
+      if (nodeCron.validate(Cron)) {
+        // Se verifica si la fecha y hora de sistema corresponde al cron
+        if (timeMatch(Cron, currentDate)) {
+          Logger.debug(`Adding cron: ${Name}`);
+          // Se inserta la ejecución del flujo como una Promise
+          promises.push(new Promise((resolve, reject) => {
+            let valuesNode = Values ? Values : {}
+
+            let request= {
+              body: valuesNode,
+              queryStringParameters:{
+                an: AccountName
+              },
+              pathParameters: {
+                sourceName: SourcesName
+              },
+              headers:{
+                "x-app-key": AppKey,
+                "x-app-token": AppToken
+              }
+            };
+
+            sendSqs(request, AccountName, (err, res) => {
+              err ? reject(err) : resolve(res);
+            });
+          }));
+        }
+      } else {
+        Logger.debug(`Cron value is not valid: ${cron}`);
+      }
+    }
+  }
+
+  // Se ejecuta cada una de las promises indicadas (si aplica)
+  if (promises.length) {
+    await Promise.allSettled(promises);
+  }
+
+  Logger.debug('End loop');
+  if(httpMethod){ 
+    return ApiResponse.response(200, "Message accepted!");;
+  }
+};
+
+/**
+ * Obtiene las posibles combinaciones de un cron job para una determinada fecha.
+ * @param {Date} date Fecha a partir de la cual se desea obtener las posibles combinaciones de cron.
+ * @returns Lista de cron asociados a la fecha.
+ */
+const getCronJobs = async () => {
+  return new Promise(async function (resolve, reject) {
+    let list= [];
+
+    try{
+      const listcrons= await Crons.getPerId(CronIdFlowsActions);
+
+      if(listcrons && listcrons?.Crons){
+        list= listcrons?.Crons;
+      }
+
+    } catch (e) {
+      Logger.error(e);
+    }
+
+    let listProcess= list.map(i=>({
+      Name: i?.Name, 
+      Actived: i?.Actived ?? false, 
+      Cron: i?.Cron ?? "* * * * *", 
+      Values: i?.Values ?? {}, 
+      SourcesName: i?.SourcesName, 
+      AccountName: i?.AccountName, 
+      AppToken: i?.AppToken, 
+      AppKey: i?.AppKey, 
+      Offset: i?.Offset ?? -5
+    }));
+
+    Logger.debug('Crons list', listProcess);
+    resolve(listProcess);
+  });
+}
+
+/**
+ * Valida si una fecha corresponde a un cron job.
+ * @param {string} cron Valor del cron.
+ * @param {Date} date Fecha a validar.
+ * @return Valor de verdad que indica si la fecha corresponde o no al cron (TRUE o FALSE).
+ */
+const timeMatch = (cron, date) => {
+  let interval = parser.parseExpression(cron);
+
+  const { minute, hour, dayOfMonth, month, dayOfWeek } = interval.fields;
+
+  return minute.includes(date.getMinutes()) &&
+    hour.includes(date.getHours()) &&
+    dayOfMonth.includes(date.getDate()) &&
+    month.includes(date.getMonth() + 1) &&
+    dayOfWeek.includes(date.getDay());
+}
+
+/**
+ * Funcion para el seteo de credendiales para asignacion de flujo
+ **/
+const setCredentialsSQS = async function(accountName) {
+  if(accountName){
+    const account = await AccountData.getAccountDataByAccountName(accountName);
+    if(!account || !account?.Credentials || !account?.Credentials?.key || !account?.Credentials?.token ){
+      return null;
+    }
+    if(BRUNO_LOCAL===true){
+      return {
+        DB_PATH: account?.NodeFlow?.DB_PATH || 'endpoints',
+        DB_PATH_ENV: account?.NodeFlow?.DB_PATH_ENV || 'environments/local',
+        DB_EXTENSION_BRU: account?.NodeFlow?.DB_EXTENSION_BRU || 'bru',
+        DB_MODULES_LOCAL: account?.NodeFlow?.DB_MODULES_LOCAL || 'sources,actions_types,settings',
+        ACTIONS_TYPES: [
+          "action_type_http_request",
+          "action_type_process_data",
+          "action_type_emails",
+          "action_type_database_rds",
+          "action_type_jwt",
+          "action_type_md5",
+          "action_type_ssh2"
+        ],
+        DB_PATHNAME_SETTINGS: account?.NodeFlow?.DB_PATHNAME_SETTINGS || 'settings', 
+        ENV: account?.NodeFlow?.ENV || null
+      };
+    }else {
+      return {
+        key: account?.Credentials?.key,
+        token: account?.Credentials?.token,
+        url: `https://${accountName}.vtexcommercestable.com.br`
+      };
+    }
+  }else{
+    return null;
+  }
+}
+
+/**
+ * Funcion para el envio de a la cola 
+ **/
+const sendSqs= async (req, accountName, callback)=>{
+  if(!accountName){
+    return null;
+  }
+  let setC= await setCredentialsSQS(accountName);
+  if(!setC){
+    callback("accountName not found", null);
+  }
+
+  await AWSServices.sendSQSMessage(SQS_NODEFLOW_QUEUE_URL, {
+    request:req,
+    account: setC,
+    sourcesProcess: "app cron job"
+  });
+
+  if(typeof callback === 'function'){
+    callback(null, 'success');
+  }
+  
+}

package/src/functions/nodeflow/nodeflow-pub.js

@@ -0,0 +1,203 @@
+const AWSServices = require("../../common/utils/aws-services");
+const ApiResponse = require("../../common/utils/api-response");
+const SQS_NODEFLOW_QUEUE_URL = process?.env?.SQS_NODEFLOW_QUEUE_URL;
+const SQS_NODEFLOW_DQL_QUEUE_URL = process?.env?.SQS_NODEFLOW_DQL_QUEUE_URL;
+const MAX_ATTEMPS = process?.env?.MAX_ATTEMPS;
+const BRUNO_LOCAL = process?.env?.DB_CONNECTION == 'bruno_local' ? true : false;
+
+/**
+ * Carga controladores
+ */
+const {InputsUpdatesController} = require('node-flow-br')
+const AccountData = require("../../entities/account");
+
+const setPerBrunoLocal= (account, envLocal=null, pathLocal=null) =>{
+  let replaceDir= new RegExp("--", 'g');
+  return {
+    config: {
+      DB_PATH: account?.NodeFlow?.DB_PATH ?? pathLocal?.replace(replaceDir, '/') ?? 'endpoints',
+      DB_PATH_ENV: account?.NodeFlow?.DB_PATH_ENV ?? envLocal?.replace(replaceDir, '/') ?? 'environments/local',
+      DB_EXTENSION_BRU: account?.NodeFlow?.DB_EXTENSION_BRU || 'bru',
+      DB_MODULES_LOCAL: account?.NodeFlow?.DB_MODULES_LOCAL || 'sources,actions_types,settings',
+      ACTIONS_TYPES: [
+        "action_type_http_request",
+        "action_type_process_data",
+        "action_type_emails",
+        "action_type_database_rds",
+        "action_type_jwt",
+        "action_type_md5",
+        "action_type_ssh2"
+      ],
+      DB_PATHNAME_SETTINGS: account?.NodeFlow?.DB_PATHNAME_SETTINGS || 'settings',
+      ENV: account?.NodeFlow?.ENV || null,
+    },
+    bruno: BRUNO_LOCAL
+  };
+};
+
+const setCredentials = async function(accountName, envLocal=null, pathLocal=null) {
+  if(accountName){
+    try {
+      const account = await AccountData.getAccountDataByAccountName(accountName);
+      if(!account || !account?.Credentials || !account?.Credentials?.key || !account?.Credentials?.token ){
+        throw "not account";
+      }
+
+      const setBruno= setPerBrunoLocal(account, envLocal, pathLocal);
+      if(setBruno?.bruno === true){
+        return setBruno?.config;
+      }else{
+        await InputsUpdatesController.setApiKey(account?.Credentials?.key);
+        await InputsUpdatesController.setApiToken(account?.Credentials?.token);
+        await InputsUpdatesController.setUrl(`https://${accountName}.vtexcommercestable.com.br`);
+        return true;
+      }    
+    } catch (e) {
+      console.error(e);
+      if(envLocal && pathLocal){
+        const setBruno= setPerBrunoLocal({}, envLocal, pathLocal);
+        if(setBruno?.bruno === true){
+          return setBruno?.config;
+        }else{
+          return false;
+        }
+      }else {
+        return false;
+      }
+      
+    }
+  }else{
+    return false;
+  }
+}
+
+const setCredentialsSQS = async function(accountName) {
+  if(accountName){
+    const account = await AccountData.getAccountDataByAccountName(accountName);
+    if(!account || !account?.Credentials || !account?.Credentials?.key || !account?.Credentials?.token ){
+      return null;
+    }
+    const setBruno= setPerBrunoLocal(account);
+    if(setBruno?.bruno === true){
+      return setBruno?.config;
+    }else{
+      return {
+        key: account?.Credentials?.key,
+        token: account?.Credentials?.token,
+        url: `https://${accountName}.vtexcommercestable.com.br`
+      };
+    }
+  }else{
+    return null;
+  }
+}
+
+module.exports.handler= async (req,res)=>{
+  req.params= req.pathParameters;
+  req.body= JSON.parse(req.body) ?? {};
+
+  let accountName= req.queryStringParameters.an ?? null;
+  let envLocal= req.queryStringParameters.envLocal ?? null;
+  let pathLocal= req.queryStringParameters.pathLocal ?? null;
+  if(!accountName){
+    return ApiResponse.response(400, "Bad request an is required ");
+  } 
+  let setC= await setCredentials(accountName, envLocal, pathLocal);
+  if(!setC || setC===false){
+    return ApiResponse.response(400, "Bad request in "+accountName);
+  }
+  let connetionLocal= typeof setC === 'object' ? await InputsUpdatesController.createConnection(setC) : null;
+  return new Promise(async (resolve, reject) =>{
+    InputsUpdatesController.insertSourceName(req, (res)=>{
+      if(res){
+        resolve(res);
+      }else{
+        resolve(null);
+      }
+    }, connetionLocal);
+  });
+  
+}
+
+module.exports.handlerSqs= async (req,res)=>{
+  req.params= req?.pathParameters;
+  req.body= JSON.parse(req?.body) ?? {};
+
+  let accountName= req?.queryStringParameters?.an ?? null;
+  if(!accountName){
+    return ApiResponse.response(400, "Bad request an is required ");
+  }
+  let setC= await setCredentialsSQS(accountName);
+  if(!setC){
+    return ApiResponse.response(400, "Bad request in "+accountName);
+  }
+
+  await AWSServices.sendSQSMessage(SQS_NODEFLOW_QUEUE_URL, {
+    request:req,
+    account: setC
+  });
+
+  return ApiResponse.response(200, "Message accepted!");
+  
+}
+
+module.exports.handlerSqsWorker= async (event)=>{
+  if(event?.Records && event?.Records.length > 0){
+    for (var i = 0; i < event.Records.length; i++) {
+      let data= JSON.parse(event.Records[i]?.body);  
+      let req= data?.request;
+      let account= data?.account;
+
+      if(!req || !account){
+        console.error("error account");
+        return;
+      }
+
+      const attemps = data?.attemps ?? -1;
+      data.attemps= (parseFloat(attemps)+1);
+      req.params= req?.pathParameters;
+
+      let accountName= req?.queryStringParameters?.an ?? null;
+      if(!accountName){
+        console.error("accountName not found");
+        return;
+      }
+      try{
+        let connetionLocal= null;
+        if(BRUNO_LOCAL){
+          connetionLocal= await InputsUpdatesController.createConnection(account);
+        }else{
+          InputsUpdatesController.setApiKey(account?.key);
+          InputsUpdatesController.setApiToken(account?.token);
+          InputsUpdatesController.setUrl(account?.url);
+        }
+
+        console.log("start action");
+        await new Promise(async(resolve, reject)=>{
+          InputsUpdatesController.insertSourceName(req, async (res)=>{
+            if(res && res.statusCode > 399 && attemps <= MAX_ATTEMPS){
+              console.log('response worker error',res);
+              setTimeout(async function() {
+                await AWSServices.sendSQSMessage(SQS_NODEFLOW_QUEUE_URL, data);
+                resolve(res);
+              }, 5000);
+            }else if(res){
+              console.log('response worker node',res);
+              resolve(res);
+            }
+          }, connetionLocal)
+        });
+      } catch (error) {
+        console.error(error);
+        if(attemps <= MAX_ATTEMPS){
+          setTimeout(async function() {
+            await AWSServices.sendSQSMessage(SQS_NODEFLOW_QUEUE_URL, data);
+          }, 5000);
+        }
+      }
+    }
+  }else{
+    console.error('not data record.');
+  }
+  
+}

package/src/functions/nodeflow/nodeflow-pvt.js

@@ -0,0 +1,266 @@
+
+/**
+ * Carga controladores
+ */
+const {SettingsController, ActionsTypesController, NodesFlowsController, SourcesController} = require('node-flow-br');
+const AccountData = require("../../entities/account");
+const BRUNO_LOCAL = process?.env?.DB_CONNECTION == 'bruno_local' ? true : false;
+
+const setPerBrunoLocal= (account) =>{
+  return {
+    config: {
+      DB_PATH: account?.NodeFlow?.DB_PATH || 'endpoints',
+      DB_PATH_ENV: account?.NodeFlow?.DB_PATH_ENV || 'environments/local',
+      DB_EXTENSION_BRU: account?.NodeFlow?.DB_EXTENSION_BRU || 'bru',
+      DB_MODULES_LOCAL: account?.NodeFlow?.DB_MODULES_LOCAL || 'sources,actions_types,settings',
+      ACTIONS_TYPES: [
+        "action_type_http_request",
+        "action_type_process_data",
+        "action_type_emails",
+        "action_type_database_rds",
+        "action_type_jwt",
+        "action_type_md5",
+        "action_type_ssh2"
+      ],
+      DB_PATHNAME_SETTINGS: account?.NodeFlow?.DB_PATHNAME_SETTINGS || 'settings',
+    },
+    bruno: BRUNO_LOCAL
+  };
+};
+
+const setCredentials = async function(accountName) {
+  if(accountName){
+    const account = await AccountData.getAccountDataByAccountName(accountName);
+    if(!account || !account?.Credentials || !account?.Credentials?.key || !account?.Credentials?.token ){
+      return false;
+    }
+
+    const setBruno= setPerBrunoLocal(account);
+    if(setBruno?.bruno === true){
+      return setBruno?.config;
+    }else{
+      await SettingsController.setApiKey(account?.Credentials?.key);
+      await SettingsController.setApiToken(account?.Credentials?.token);
+      await SettingsController.setUrl(`https://${accountName}.vtexcommercestable.com.br`);
+
+      await ActionsTypesController.setApiKey(account?.Credentials?.key);
+      await ActionsTypesController.setApiToken(account?.Credentials?.token);
+      await ActionsTypesController.setUrl(`https://${accountName}.vtexcommercestable.com.br`);
+
+      await NodesFlowsController.setApiKey(account?.Credentials?.key);
+      await NodesFlowsController.setApiToken(account?.Credentials?.token);
+      await NodesFlowsController.setUrl(`https://${accountName}.vtexcommercestable.com.br`);
+
+      await SourcesController.setApiKey(account?.Credentials?.key);
+      await SourcesController.setApiToken(account?.Credentials?.token);
+      await SourcesController.setUrl(`https://${accountName}.vtexcommercestable.com.br`);
+
+      return true;
+    }
+  }else{
+    return false;
+  }
+}
+
+module.exports.getSettings= async (req,res)=>{
+  req.params= req.pathParameters;
+  
+  let accountName= req.queryStringParameters.an ?? null;
+  if(!accountName){
+    return null;
+  }
+  let setC= await setCredentials(accountName);
+  if(!setC || setC===false){return null;}
+
+  let connetionLocal= typeof setC === 'object' ? await SettingsController.createConnection(setC) : null;
+  return new Promise((resolve, reject) =>{
+    SettingsController.findAll(req, (res)=>{
+      if(res){
+        resolve(res);
+      }else{
+        resolve(null);
+      }
+    }, connetionLocal);
+  });
+}
+
+module.exports.createSettings= async (req,res)=>{
+  req.params= req.pathParameters;
+  req.body= JSON.parse(req.body) ?? {};
+
+  let accountName= req.queryStringParameters.an ?? null;
+  if(!accountName){
+    return null;
+  }
+  let setC= await setCredentials(accountName);
+  if(!setC || setC===false){return null;}
+  
+  let connetionLocal= typeof setC === 'object' ? await SettingsController.createConnection(setC) : null;
+  return new Promise((resolve, reject) =>{
+    SettingsController.save(req, (res)=>{
+      if(res){
+        resolve(res);
+      }else{
+        resolve(null);
+      }
+    }, connetionLocal);
+  });
+}
+
+module.exports.getActionsType= async (req,res)=>{
+  req.params= req.pathParameters;
+  
+  let accountName= req.queryStringParameters.an ?? null;
+  if(!accountName){
+    return null;
+  }
+  let setC= await setCredentials(accountName);
+  if(!setC || setC===false){return null;}
+
+  let connetionLocal= typeof setC === 'object' ? await ActionsTypesController.createConnection(setC) : null;
+  return new Promise((resolve, reject) =>{
+    ActionsTypesController.findAll(req, (res)=>{
+      if(res){
+        resolve(res);
+      }else{
+        resolve(null);
+      }
+    }, connetionLocal);
+  });
+}
+
+module.exports.createActionsType= async (req,res)=>{
+  req.params= req.pathParameters;
+  req.body= JSON.parse(req.body) ?? {};
+  
+  let accountName= req.queryStringParameters.an ?? null;
+  if(!accountName){
+    return null;
+  }
+  let setC= await setCredentials(accountName);
+  if(!setC || setC===false){return null;}
+
+  let connetionLocal= typeof setC === 'object' ? await ActionsTypesController.createConnection(setC) : null;
+  return new Promise((resolve, reject) =>{
+    ActionsTypesController.create(req, (res)=>{
+      if(res){
+        resolve(res);
+      }else{
+        resolve(null);
+      }
+    }, connetionLocal);
+  });
+}
+
+module.exports.createNodeFlow= async (req,res)=>{
+  req.params= req.pathParameters;
+  req.body= JSON.parse(req.body) ?? {};
+  
+  let accountName= req.queryStringParameters.an ?? null;
+  if(!accountName){
+    return null;
+  }
+  let setC= await setCredentials(accountName);
+  if(!setC || setC===false){return null;}
+
+  let connetionLocal= typeof setC === 'object' ? await NodesFlowsController.createConnection(setC) : null;
+  return new Promise((resolve, reject) =>{
+    NodesFlowsController.create(req, (res)=>{
+      if(res){
+        resolve(res);
+      }else{
+        resolve(null);
+      }
+    }, connetionLocal);
+  });
+}
+
+
+module.exports.treeNodeFlow= async (req,res)=>{
+  req.params= req.pathParameters;
+  
+  let accountName= req.queryStringParameters.an ?? null;
+  if(!accountName){
+    return null;
+  }
+  let setC= await setCredentials(accountName);
+  if(!setC || setC===false){return null;}
+
+  let connetionLocal= typeof setC === 'object' ? await NodesFlowsController.createConnection(setC) : null;
+  return new Promise((resolve, reject) =>{
+    NodesFlowsController.getTreeNode(req, (res)=>{
+      if(res){
+        resolve(res);
+      }else{
+        resolve(null);
+      }
+    }, connetionLocal);
+  });
+}
+
+module.exports.getSources= async (req,res)=>{
+  req.params= req.pathParameters;
+  
+  let accountName= req.queryStringParameters.an ?? null;
+  if(!accountName){
+    return null;
+  }
+  let setC= await setCredentials(accountName);
+  if(!setC || setC===false){return null;}
+
+  let connetionLocal= typeof setC === 'object' ? await SourcesController.createConnection(setC) : null;
+  return new Promise((resolve, reject) =>{
+    SourcesController.findAll(req, (res)=>{
+      if(res){
+        resolve(res);
+      }else{
+        resolve(null);
+      }
+    }, connetionLocal);
+  });
+}
+
+module.exports.createSources= async (req,res)=>{
+  req.params= req.pathParameters;
+  req.body= JSON.parse(req.body) ?? {};
+  
+  let accountName= req.queryStringParameters.an ?? null;
+  if(!accountName){
+    return null;
+  }
+  let setC= await setCredentials(accountName);
+  if(!setC || setC===false){return null;}
+
+  let connetionLocal= typeof setC === 'object' ? await SourcesController.createConnection(setC) : null;
+  return new Promise((resolve, reject) =>{
+    SourcesController.create(req, (res)=>{
+      if(res){
+        resolve(res);
+      }else{
+        resolve(null);
+      }
+    }, connetionLocal);
+  });
+}
+
+module.exports.deleteSources= async (req,res)=>{
+  req.params= req.pathParameters;
+  
+  let accountName= req.queryStringParameters.an ?? null;
+  if(!accountName){
+    return null;
+  }
+  let setC= await setCredentials(accountName);
+  if(!setC || setC===false){return null;}
+
+  let connetionLocal= typeof setC === 'object' ? await SourcesController.createConnection(setC) : null;
+  return new Promise((resolve, reject) =>{
+    SourcesController.delete(req, (res)=>{
+      if(res){
+        resolve(res);
+      }else{
+        resolve(null);
+      }
+    }, connetionLocal);
+  });
+}