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

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

const InstanceEventData = require('./instance-event');
const {
  collections: { execution: { events: eventsColl } },
  // dbQueries: { execution: { process: processQueries } },
  process: {
    elements: { event: EVENT },
    // eventTypes: { start: START, intermediate: INTERMEDIATE, end: END },
    emmiterTypes: { eventClose: EVENTCLOSE, eventComplete: EVENTCOMPLETE },
  },
} = require('../../../config');

const modErrs = {
  triggerEvent: {
    notDefined: ['01', 'Evento no se encuentra en la definición del proceso'],
    missingRequiredVariable: ['02', 'Variable requerida para el evento no se recibió'],
  },
  newEventInstance: {
    saveFailure: ['01', 'Error registrando evento en base de datos'],
  },
};

async function createEventInstance(procId, name, eventVars) {
  const eventCol = this.rwPool.collection(eventsColl);
  const eventVarNames = Object.keys(this.processDefinition?.events?.[name]?.variables);
  const newEventInstance = {
    ecosystem: this._ecosystem,
    procId,
    name: this.name,
    creation: new Date(),
    variables: {},
  };
  for (let index = 0; index < eventVarNames.length; index++) {
    const eventVarName = eventVarNames[index];
    newEventInstance.variables[eventVarName] = eventVars[eventVarName] ?? null;
  }
  this.logger.log({
    level: 'debug',
    label: 'eventInstance',
    action: 'createEventInstanceDB',
    message: `Se crea  nueva instancia de evento ${name} para la instacia ${procId} del proceso ${this.name} con ${JSON.stringify(newEventInstance, null, 2)}`,
  });
  const actionResult = await eventCol.insertOne(newEventInstance);
  const eventId = actionResult?.insertedId.toString();
  if (!eventId) {
    this.logger.log({
      level: 'error',
      label: 'eventInstance',
      action: 'createEventInstanceDB',
      message: `No fue posible la creación de una instancia del evento ${name} para el proceso ${this.name}`,
    });
    const errorObj = this.errorObj.get(modErrs.newEventInstance.saveFailure);
    return [errorObj, null];
  }
  return [null, eventId];
}

async function triggerEvent(procId, name, eventVars) {
  const eventDef = this.processDefinition?.events?.[name];
  if (!eventDef) {
    const message = `El evento ${name} no se encuentra en la definición del proceso`;
    this.logger.log({
      level: 'error',
      label: 'instanceEvent',
      action: 'triggerEvent',
      message,
    });
    const errorObj = this.errMgr.get(modErrs.triggerEvent.notDefined, message);
    return [errorObj, null];
  }
  const { variables } = eventDef;
  const variableNames = Object.keys(variables);
  for (let index = 0; index < variableNames.length; index++) {
    const variableName = variableNames[index];
    const { required } = variables[variableName];
    if (required && !eventVars?.[variableName]) {
      const message = `Variable ${variableName} requerida para disparar el evento ${name}`;
      this.logger.log({
        level: 'error',
        label: 'instanceEvent',
        action: 'triggerEvent',
        message,
      });
      const errorObj = this.errMgr.get(modErrs.triggerEvent.missingRequiredVariable, message);
      return [errorObj, null];
    }
  }
  const inputVarNames = Object.keys(eventVars);
  for (let index = 0; index < inputVarNames.length; index++) {
    const inputVarName = inputVarNames[index];
    if (!variables[inputVarName]) {
      delete eventVars[inputVarName];
    }
  }
  const [eventErr, eventId] = await this.createEventInstance(procId, name, eventVars);
  if (eventErr) { return [eventErr, null]; }
  this.logger.log({
    level: 'info',
    label: 'instanceEvent',
    action: 'triggerEvent',
    message: `Se registra nueva instanca ${eventId} del evento ${name} en la instancia ${procId} del proceso ${this.name}`,
  });
  const processEvent = new InstanceEventData(this.name, procId, eventId, name, eventVars);
  await this.execCustomCallback(EVENTCOMPLETE, name, processEvent);
  await this.execCustomCallback(EVENTCLOSE, name, processEvent);
  this.goToNode(procId, eventDef.next.name, eventDef.next.type, EVENT, name, eventId);
  return [null, eventId];
}

async function getProcessEventsHistory(procName, name, origin) {
  this.logger.log({
    message: `${procName}${name}${origin}`,
  });
}

module.exports = {
  methods: {
    createEventInstance,
    triggerEvent,
    getProcessEventsHistory,
  },
  errors: modErrs,
};