tuain-bpm-lib/lib/model/process-manager/process-events.js

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

const {
  collections: { definition: { events: eventColl } },
  dbQueries: { process: processQueries },
  schemas: { process: processSchemas },
} = require('../../../config');

const START = 'start';

const modErrs = {
  getEvent: {
    notExist: ['01', 'Evento no encontrada'],
  },
  addProcessEvent: {
    alreadyExist: ['01', 'Ya existe una evento con el mismo nombre dentro del proceso'],
  },
  addEventVariable: {
    varExist: ['01', 'Ya existe una variable con el mismo nombre dentro de la evento'],
  },
  removeEventVariable: {
    notExist: ['01', 'No existe una variable con tal nombre dentro de la evento'],
  },
};

async function locateEvent(procName, name) {
  const eventCol = this.roPool.collection(eventColl);
  const eventDetail = await eventCol.findOne(processQueries.findEvent(this.findEvent(procName, name)));
  if (!eventDetail) {
    const errorDetail = `No se encontró una evento con nombre ${name} para el proceso ${procName} en el ecosistema ${this._ecosystem}`;
    const errorObj = this.errMgr.get(modErrs.getEvent.notExist, errorDetail);
    return [errorObj, null];
  }
  return [null, eventDetail];
}

async function addProcessEvent(reqData) {
  const inputErr = this.validateObjectStructure(processSchemas.addProcessEvent, reqData);
  if (inputErr) { return [inputErr, null]; }
  const { procName, name } = reqData;
  const [procErr] = this.locateProcess(procName);
  if (procErr) { return [procErr, null]; }
  const eventCol = this.rwPool.collection(eventColl);
  const eventDetail = await eventCol.findOne(processQueries.findEvent(this.findEvent(procName, name)));
  if (eventDetail) {
    const errorDetail = `Ya existe una evento con nombre ${name} en el proceso ${procName}`;
    const errorObj = this.errMgr.get(modErrs.addProcessEvent.alreadyExist, errorDetail);
    return [errorObj, null];
  }
  const newEventData = {
    ecosystem: this._ecosystem,
    ...reqData,
    creation: new Date(),
  };
  const actionResult = await eventCol.insertOne(newEventData);
  this.logger.log({
    level: 'debug',
    label: 'processEvents',
    action: 'addProcessEvent',
    message: `Creación de un nueva evento ${newEventData} con resultado ${actionResult?.insertedId}`,
  });
  return [null, { eventInternalId: actionResult?.insertedId }];
}

function findEvents(procName, attributes = null) {
  const searchObject = { ecosystem: this._ecosystem, procName };
  const attributeNames = Object.keys(attributes);
  for (let index = 0; index < attributeNames.length; index++) {
    const attrName = attributeNames[index];
    if (attributes[attrName]) {
      searchObject[attrName] = attributes[attrName];
    }
  }
  return searchObject;
}

async function getStartEvent(reqData) {
  const inputErr = this.validateObjectStructure(processSchemas.getStartEvent, reqData);
  if (inputErr) { return [inputErr, null]; }
  const { procName } = reqData;
  const eventCol = this.roPool.collection(eventColl);
  const eventDetail = await eventCol
    .findOne(processQueries.findEvent(this.findEvents(procName, { type: START })));
  if (!eventDetail) {
    const errorDetail = `No se encontró un evento de tipo start para el proceso ${procName} en el ecosistema ${this._ecosystem}`;
    const errorObj = this.errMgr.get(modErrs.getEvent.notExist, errorDetail);
    return [errorObj, null];
  }
  return [null, eventDetail];
}

async function addEventVariable(reqData) {
  const inputErr = this.validateObjectStructure(processSchemas.addEventVariable, reqData);
  if (inputErr) { return [inputErr, null]; }
  const { procName, eventName, name, type, detail } = reqData;
  const [eventErr, eventDetail] = this.locateEvent(procName, eventName);
  if (eventErr) { return [eventErr, null]; }
  const currentVar = eventDetail.variables.find(varDef => varDef.name === name);
  if (currentVar) {
    const errorDetail = `La evento ${eventName} del proceso ${procName} ya cuenta con una variable llamada ${name}`;
    const errorObj = this.errMgr.get(modErrs.addEventVariable.varExist, errorDetail);
    return [errorObj, null];
  }
  const eventCol = this.rwPool.collection(eventColl);
  const actionResult = await eventCol.updateOne(
    processQueries.findEvent(this.findEvent(procName, eventName)),
    processQueries.addVariable({ name, type, detail }),
  );
  const result = actionResult?.result?.nModified > 0;
  if (!result) {
    this.logger.log({
      level: 'warn',
      label: 'processInstance',
      action: 'assignGroupDB',
      message: `No se pudo efectuar Adición de variable ${name} sobre la evento ${eventName} en el proceso ${procName}`,
    });
  }
  return [null, { result }];
}

async function removeEventVariable(reqData) {
  const inputErr = this.validateObjectStructure(processSchemas.removeEventVariable, reqData);
  if (inputErr) { return [inputErr, null]; }
  const { procName, eventName, name } = reqData;
  const [eventErr, eventDetail] = this.locateEvent(procName, eventName);
  if (eventErr) { return [eventErr, null]; }
  const currentVar = eventDetail.variables.find(varDef => varDef.name === name);
  if (!currentVar) {
    const errorDetail = `La evento ${eventName} del proceso ${procName} no cuenta con una variable llamada ${name}`;
    const errorObj = this.errMgr.get(modErrs.removeEventVariable.notExist, errorDetail);
    return [errorObj, null];
  }
  const eventCol = this.rwPool.collection(eventColl);
  const actionResult = await eventCol.updateOne(
    processQueries.findEvent(this.findEvent(procName, eventName)),
    processQueries.removeVariable(name),
  );
  const result = actionResult?.result?.nModified > 0;
  if (!result) {
    this.logger.log({
      level: 'warn',
      label: 'processEvents',
      action: 'removeEventVariable',
      message: `No se pudo efectuar Eliminación de la variable ${name} de evento ${eventName} en el proceso ${procName}`,
    });
  }
  return [null, { result }];
}

module.exports = {
  methods: {
    findEvents,
    locateEvent,
    getStartEvent,
    addProcessEvent,
    addEventVariable,
    removeEventVariable,
  },
  errors: modErrs,
};