tuain-bpm-lib/lib/model/process-controller/event-emmiters.js

Servicio de gestión de manejo de procesos de la plataforma Tuain

const axios = require('axios');
const {
  process: {
    emmiterTypes: {
      taskStart: TASKSTART, taskComplete: TASKCOMPLETE, taskClose: TASKCLOSE,
      eventClose: EVENTCLOSE, eventComplete: EVENTCOMPLETE,
    },
  },
} = require('../../../config');

async function defineEmmiters() {
  this.callbackSets = {
    [TASKSTART]: {},
    [TASKCOMPLETE]: {},
    [TASKCLOSE]: {},
    [EVENTCLOSE]: {},
    [EVENTCOMPLETE]: {},
  };
  // Funciones de evaluación de destinos de gateways
  this.gatewayDestinationValidations = {};
  // Control de temporizadores
  this.refreshTimer = null;
  this.currentTimers = [];
}

async function execCustomCallback(eventType, eventName, eventObject) {
  const callbackFunction = this.callbackSets?.[eventType]?.[eventName] ?? null;
  const callbackResult = (callbackFunction) ? await callbackFunction(eventObject) : null;
  return callbackResult;
}

async function callWebhook(webhook, eventData) {
  try {
    const response = await axios.post(webhook, {
      data: { ...eventData },
    });
    this.logger.log({
      level: 'info',
      label: 'procEventEmmiter',
      action: 'callWebHook',
      message: `Consumo webhook ${webhook}: ${response?.status ?? '200'}/${response?.data ?? ''}`,
    });
  } catch (error) {
    this.logger.log({
      level: 'error',
      label: 'procEventEmmiter',
      action: 'callWebHook',
      message: `Error consumiendo webhook ${error}`,
    });
  }
}

function subscribeTaskStart(name, callback) {
  this.logger.log({
    level: 'silly',
    label: 'eventEmmiters',
    action: 'subscribeTaskStart',
    message: `Se registra subscripción al inicio de la tarea ${name}`,
  });
  this.callbackSets[TASKSTART][name] = callback;
}

function subscribeTaskCompletion(name, callback) {
  this.logger.log({
    level: 'silly',
    label: 'eventEmmiters',
    action: 'subscribeTaskCompletion',
    message: `Se registra subscripción a la finalización de la tarea ${name}`,
  });
  this.callbackSets[TASKCOMPLETE][name] = callback;
}

function subscribeEvent(name, callback) {
  this.logger.log({
    level: 'silly',
    label: 'eventEmmiters',
    action: 'subscribeEvent',
    message: `Se registra subscripción a la ocurrencia del evento ${name}`,
  });
  this.callbackSets[EVENTCOMPLETE][name] = callback;
}

function externalSubscribeTaskStart(name, webhook) {
  this.logger.log({
    level: 'silly',
    label: 'eventEmmiters',
    action: 'externalSubscribeTaskStart',
    message: `Se registra subscripción externa al inicio de la tarea ${name}`,
  });
  this.subscribeTaskStart(name, eventData => callWebhook(webhook, eventData));
}

function externalSubscribeTaskCompletion(name, webhook) {
  this.logger.log({
    level: 'silly',
    label: 'eventEmmiters',
    action: 'externalSubscribeTaskCompletion',
    message: `Se registra subscripción externa a la finalizaciópn de la tarea ${name}`,
  });
  this.subscribeTaskCompletion(name, eventData => callWebhook(webhook, eventData));
}

function externalSubscribeEvent(name, webhook) {
  this.logger.log({
    level: 'silly',
    label: 'eventEmmiters',
    action: 'externalSubscribeEvent',
    message: `Se registra subscripción externa a la ocurrencia del evento ${name}`,
  });
  this.subscribeEvent(name, eventData => callWebhook(webhook, eventData));
}

function taskClosure(name, callback) {
  this.logger.log({
    level: 'silly',
    label: 'eventEmmiters',
    action: 'taskClosure',
    message: `Se registra callback de acción de cierre de la tarea ${name}`,
  });
  this.callbackSets[TASKCLOSE][name] = callback;
}

function eventClosure(name, callback) {
  this.logger.log({
    level: 'silly',
    label: 'eventEmmiters',
    action: 'eventClosure',
    message: `Se registra callback de acción de cierre del evento ${name}`,
  });
  this.callbackSets[EVENTCLOSE][name] = callback;
}

function defineGatewayDestinationCallback(name, destination, callback) {
  if (!this.gatewayDestinationValidations[name]) {
    this.gatewayDestinationValidations[name] = {};
  }
  const gatewayValidations = this.gatewayDestinationValidations[name];
  gatewayValidations[destination] = callback;
}

function getGatewayValudationFunction(name, destination) {
  return this.gatewayDestinationValidations?.[name]?.[destination] ?? null;
}

module.exports = {
  methods: {
    defineEmmiters,
    execCustomCallback,
    subscribeTaskStart,
    subscribeTaskCompletion,
    taskClosure,
    subscribeEvent,
    eventClosure,
    externalSubscribeTaskStart,
    externalSubscribeTaskCompletion,
    externalSubscribeEvent,
    defineGatewayDestinationCallback,
    getGatewayValudationFunction,
  },
};