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

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

const {
  collections: {
    definition: { processes: processesColl },
  },
  dbQueries: { process: processQueries },
  schemas: { process: processSchemas },
} = require('../../../config');
const { methods: processMethods, errors: processErrors } = require('./process-methods');
const { methods: taskMethods, errors: taskErrors } = require('./process-tasks');
const { methods: gatewayMethods, errors: gatewayErrors } = require('./process-gateways');

const modErrs = {
  newProcess: {
    alreadyExist: ['01', 'Proceso ya existe'],
  },
  getProcess: {
    notExist: ['01', 'Proceso no encontrado'],
  },
  validation: {
    invalidObject: ['01', 'Objeto no cuenta con la estructura esperada'],
  },
};

class ProcessManager {
  constructor(ecosystem, readOnlyDbPool, readWriteDbPool, logger, errMgr) {
    this._ecosystem = ecosystem;
    this.roPool = readOnlyDbPool;
    this.rwPool = readWriteDbPool;
    this.logger = logger;
    this.errMgr = errMgr;

    this.errMgr.addModuleSet('ProcessManager', modErrs);
    this.errMgr.addModuleSet('ProcessManager-process', processErrors);
    this.errMgr.addModuleSet('ProcessManager-task', taskErrors);
    this.errMgr.addModuleSet('ProcessManager-gateway', gatewayErrors);
    // Funcione básicas
    this.findAllProcesses = () => ({ ecosystem: this._ecosystem });
    this.findProcess = (name) => ({ ecosystem: this._ecosystem, name });
    this.findTask = (procName, name) => ({ ecosystem: this._ecosystem, procName, name });
    this.findGateway = (procName, name) => ({ ecosystem: this._ecosystem, procName, name });

    const externalMethods = [processMethods, taskMethods, gatewayMethods];
    for (let methodIdx = 0; methodIdx < externalMethods.length; methodIdx++) {
      const methodSet = externalMethods[methodIdx];
      const methodsNames = Object.keys(methodSet);
      for (let index = 0; index < methodsNames.length; index++) {
        const methodName = methodsNames[index];
        this[methodName] = methodSet[methodName].bind(this);
      }
    }
  }

  get ecosystem() {
    return this._ecosystem;
  }

  async initializeManager() {
    // Verifica la existencia de un ecosistema
    this.logger.log({
      level: 'debug',
      message: `Se inicializa el manejador de procesos para ${this._ecosystem}`,
    });
  }

  validateObjectStructure(schema, object) {
    const { error } = schema?.validate(object) ?? null;
    if (error) {
      const message = `Error validando información, ${error.details[0].message}`;
      const errorObj = this.errMgr.get(modErrs.validation.invalidObject, message);
      this.logger.log({
        level: 'info',
        message,
      });
      return errorObj;
    }
    return null;
  }

  async getDefinition(name) {
    // Retorna un objeto Json con la definición del proceso, sus tareas, gateways y eventos
    this.logger.log({
      level: 'debug',
      message: `Método getDefinition no implementado ${name}`,
    });
    return { name };
  }

  async locateProcess(name) {
    const procCol = this.roPool().collection(processesColl);
    const procDetail = await procCol.findOne(processQueries.findProcess(this.findProcess(name)));
    if (!procDetail) {
      const errorDetail = `No se encontró un proceso con nombre ${name} en el ecosistema ${this._ecosystem}`;
      const errorObj = this.errMgr.get(modErrs.getProcess.notExist, errorDetail);
      return [errorObj, null];
    }
    return [null, procDetail];
  }

  async newProcess(reqData) {
    let errorObj = this.validateObjectStructure(processSchemas.newProcess, reqData);
    if (errorObj) {
      return [errorObj, null];
    }
    const { name } = reqData;
    const procCol = this.rwPool().collection(processesColl);
    const procDetail = await procCol.findOne(processQueries.findProcess(this.findProcess(name)));
    if (procDetail) {
      const errorDetail = `Ya existe un proceso con nombre ${name} en el ecosistema ${this._ecosystem}`;
      errorObj = this.errMgr.get(modErrs.newProcess.alreadyExist, errorDetail);
      return [errorObj, null];
    }
    const newProcData = {
      ecosystem: this._ecosystem,
      ...reqData,
      creation: new Date(),
    };
    const actionResult = await procCol.insertOne(newProcData);
    this.logger.log({
      level: 'debug',
      label: 'ProcessManager',
      action: 'newProcess',
      message: `Creación de un nuevo proceso ${newProcData} con resultado ${actionResult?.insertedId}`,
    });
    return [null, { processInternalId: actionResult?.insertedId }];
  }

  async getAllProcesses(reqData) {
    const errorObj = this.validateObjectStructure(processSchemas.getProcesses, reqData);
    if (errorObj) {
      return [errorObj, null];
    }
    const procCol = this.roPool().collection(processesColl);
    const procList = await procCol.find(processQueries.findProcesses(this.findAllProcesses())).toArray();
    return [null, procList];
  }
}

module.exports = ProcessManager;