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 {
  methods: { registerTimerEvent, triggerTimerEvent },
} = require('./timers');

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 = {
  triggerBoundaryEvent: {
    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,
    procName: this.name,
    name,
    creation: new Date(),
    variables: {},
  };
  for (let index = 0; index < eventVarNames.length; index++) {
    const eventVarName = eventVarNames[index];
    newEventInstance.variables[eventVarName] = eventVars[eventVarName] ?? null;
  }
  let message = `[BPM] Se crea  nueva instancia de evento ${name} para la instacia ${procId} del proceso ${this.name} con ${JSON.stringify(newEventInstance, null, 2)}`;
  this.logger.log({ level: 'silly', label: 'eventInstance', action: 'createEventInstanceDB', message });
  const actionResult = await eventCol.insertOne(newEventInstance);
  const eventId = actionResult?.insertedId.toString();
  if (!eventId) {
    message = `[BPM] No fue posible la creación de una instancia del evento ${name} para el proceso ${this.name}`;
    this.logger.log({ level: 'error', label: 'eventInstance', action: 'createEventInstanceDB', message });
    const errorObj = this.errorObj.get(modErrs.newEventInstance.saveFailure);
    return [errorObj, null];
  }
  return [null, eventId];
}

async function triggerBoundaryEvent(procId, name, eventVars) {
  const eventDef = this.processDefinition?.events?.[name];
  let message;
  if (!eventDef) {
    message = `[BPM] : El evento ${name} no se encuentra en la definición del proceso`;
    this.logger.log({ level: 'error', label: 'instanceEvent', action: 'triggerBoundaryEvent', message });
    const errorObj = this.errMgr.get(modErrs.triggerBoundaryEvent.notDefined, message);
    return [errorObj, null];
  }
  const { type, 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]) {
      message = `[BPM] : Variable ${variableName} requerida para disparar el evento ${name}`;
      this.logger.log({ level: 'error', label: 'instanceEvent', action: 'triggerBoundaryEvent', message });
      const errorObj = this.errMgr.get(modErrs.triggerBoundaryEvent.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];
  }
  message = `[BPM] Nuevo evento ${name}/${eventId} en proceso ${this.name}/${procId}`;
  this.logger.log({ level: 'info', label: 'instanceEvent', action: 'triggerBoundaryEvent', message });
  const processEvent = new InstanceEventData(this.name, procId, eventId, name, eventVars);
  await this.execCustomCallback(EVENTCOMPLETE, name, processEvent);
  await this.execCustomCallback(EVENTCLOSE, name, processEvent);
  if (type == 'end') {
    this.updateBasicInfoInstance({ procId, completed: true });
    this.cancelActiveTasks(procId);
  } else if (eventDef.next) {
    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}` });
}

async function triggerEvent(procId, name, eventVars) {
  const eventDef = this.processDefinition?.events?.[name];
  let message;
  if (!eventDef) {
    message = `[BPM] : El evento ${name} no se encuentra en la definición del proceso`;
    this.logger.log({ level: 'error', label: 'instanceEvent', action: 'triggerBoundaryEvent', message });
    const errorObj = this.errMgr.get(modErrs.triggerBoundaryEvent.notDefined, message);
    return [errorObj, null];
  }
  if (eventDef?.type === 'intermediate') {
    // Evento de tipo intermediate son temporizadores en la actual versión
    return this.registerTimerEvent(procId, name, eventVars);
  } else {
    return this.triggerBoundaryEvent(procId, name, eventVars);
  }
}

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