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,
      gateWayComplete: GATEWAYCOMPLETE,
    },
  },
} = require('../../../config');

async function defineEmmiters() {
  this.callbackSets = {
    [TASKSTART]: {},
    [TASKCOMPLETE]: {},
    [TASKCLOSE]: {},
    [GATEWAYCOMPLETE]: {},
    [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;
  let callbackResult;
  try {
    callbackResult = callbackFunction ? await callbackFunction(eventObject) : null;
  } catch (e) {
    callbackResult = { error: { message: e.message, stack: e.stack } };
  }
  return callbackResult;
}

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

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

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

function subscribeGatewayCompletion(name, callback) {
  const message = `[BPM] Se registra subscripción a la finalización del gateway ${name}`;
  this.logger.log({ level: 'silly', label: 'eventEmmiters', action: 'subscribeGatewayCompletion', message });
  this.callbackSets[GATEWAYCOMPLETE][name] = callback;
}

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

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

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

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

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

function eventClosure(name, callback) {
  const message = `[BPM] Se registra callback de acción de cierre del evento ${name}`;
  this.logger.log({ level: 'silly', label: 'eventEmmiters', action: 'eventClosure', message });
  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,
    subscribeGatewayCompletion,
    taskClosure,
    subscribeEvent,
    eventClosure,
    externalSubscribeTaskStart,
    externalSubscribeTaskCompletion,
    externalSubscribeEvent,
    defineGatewayDestinationCallback,
    getGatewayValudationFunction,
  },
};