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

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

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

const modErrs = {
  getGateway: {
    notExist: ['01', 'Tarea no encontrada'],
  },
  addProcessGateway: {
    alreadyExist: ['01', 'Ya existe una tarea con el mismo nombre dentro del proceso'],
  },
  addGatewayPredecessor: {
    itemExist: ['01', 'Ya existe un predecesor en el gateway con el mismo nombre'],
  },
  removeGatewayPredecessor: {
    notExist: ['01', 'No existe un predecesor en el gateway con tal nombre'],
  },
};

async function locateGateway(procName, name) {
  const gatewayCol = this.roPool.collection(gatewayColl);
  const gatewayDetail = await gatewayCol
    .findOne(processQueries.findGateway(this.findGateway(procName, name)));
  if (!gatewayDetail) {
    const errorDetail = `No se encontró una tarea con nombre ${name} para el proceso ${procName} en el ecosistema ${this._ecosystem}`;
    const errorObj = this.errMgr.get(modErrs.getGateway.notExist, errorDetail);
    return [errorObj, null];
  }
  return [null, gatewayDetail];
}

async function addProcessGateway(reqData) {
  const inputErr = this.validateObjectStructure(processSchemas.addProcessGateway, reqData);
  if (inputErr) { return [inputErr, null]; }
  const { procName, name } = reqData;
  const [procErr] = this.locateProcess(procName);
  if (procErr) { return [procErr, null]; }
  const gatewayCol = this.rwPool.collection(gatewayColl);
  const gatewayDetail = await gatewayCol
    .findOne(processQueries.findGateway(this.findGateway(procName, name)));
  if (gatewayDetail) {
    const errorDetail = `Ya existe un gateway con nombre ${name} en el proceso ${procName}`;
    const errorObj = this.errMgr.get(modErrs.addProcessGateway.alreadyExist, errorDetail);
    return [errorObj, null];
  }
  const newGatewayData = {
    ecosystem: this._ecosystem,
    ...reqData,
    creation: new Date(),
  };
  const actionResult = await gatewayCol.insertOne(newGatewayData);
  this.logger.log({
    level: 'debug',
    label: 'processGateway',
    action: 'addProcessGateway',
    message: `Creación de un nueva tarea ${newGatewayData} con resultado ${actionResult?.insertedId}`,
  });
  return [null, { gatewayInternalId: actionResult?.insertedId }];
}

async function addGatewayPredecessor(reqData) {
  const inputErr = this.validateObjectStructure(processSchemas.addGatewayVariable, reqData);
  if (inputErr) { return [inputErr, null]; }
  const { procName, gatewayName, name, itemName, itemType, detail } = reqData;
  const [gatewayErr, gatewayDetail] = this.locateGateway(procName, gatewayName);
  if (gatewayErr) { return [gatewayErr, null]; }
  const currentPredecessor = gatewayDetail.predecessors.find(predDef => predDef.name === name);
  if (currentPredecessor) {
    const errorDetail = `El gateway ${gatewayName} del proceso ${procName} ya cuenta con un predecesor llamado ${name}`;
    const errorObj = this.errMgr.get(modErrs.addGatewayPredecessor.itemExist, errorDetail);
    return [errorObj, null];
  }
  const gatewayCol = this.rwPool.collection(gatewayColl);
  const actionResult = await gatewayCol
    .updateOne(
      processQueries.findGateway(this.findGateway(procName, gatewayName)),
      processQueries.addPredecessor({ name, itemName, itemType, detail }),
    );
  const result = actionResult?.result?.nModified > 0;
  if (!result) {
    this.logger.log({
      level: 'warn',
      label: 'processGateway',
      action: 'addGatewayPredecessor',
      message: `No se pudo efectuar Adición de variable ${name} sobre la tarea ${gatewayName} en el proceso ${procName}`,
    });
  }
  return [null, { result }];
}

async function removeGatewayPredecessor(reqData) {
  const inputErr = this.validateObjectStructure(processSchemas.removeGatewayVariable, reqData);
  if (inputErr) { return [inputErr, null]; }
  const { procName, gatewayName, name } = reqData;
  const [gatewayErr, gatewayDetail] = this.locateGateway(procName, gatewayName);
  if (gatewayErr) { return [gatewayErr, null]; }
  const currentVar = gatewayDetail.variables.find(varDef => varDef.name === name);
  if (!currentVar) {
    const errorDetail = `La tarea ${gatewayName} del proceso ${procName} no cuenta con una variable llamada ${name}`;
    const errorObj = this.errMgr.get(modErrs.removeGatewayVariable.notExist, errorDetail);
    return [errorObj, null];
  }
  const gatewayCol = this.rwPool.collection(gatewayColl);
  const actionResult = await gatewayCol.updateOne(
    processQueries.findGateway(this.findGateway(procName, gatewayName)),
    processQueries.removeVariable(name),
  );
  const result = actionResult?.result?.nModified > 0;
  if (!result) {
    this.logger.log({
      level: 'warn',
      label: 'processGateway',
      action: 'addGatewayPredecessor',
      message: `No se pudo efectuar Eliminación de la variable ${name} de tarea ${gatewayName} en el proceso ${procName}`,
    });
  }
  return [null, { result }];
}

async function addGatewaySuccessor(reqData) { this.logger.log({ level: 'debug', message: reqData }); }
async function removeGatewaySuccessor(reqData) { this.logger.log({ level: 'debug', message: reqData }); }

async function getGatewayPredecessors(reqData) {
  const errorObj = this.validateObjectStructure(processSchemas.getGatewayPredecessor, reqData);
  if (errorObj) { return [errorObj, null]; }
  const predecessors = [];
  return [null, predecessors];
}

async function getGatewaySuccessors(reqData) {
  const errorObj = this.validateObjectStructure(processSchemas.getGatewaySuccessor, reqData);
  if (errorObj) { return [errorObj, null]; }
  const successors = [];
  return [null, successors];
}

module.exports = {
  methods: {
    locateGateway,
    addProcessGateway,
    addGatewayPredecessor,
    removeGatewayPredecessor,
    addGatewaySuccessor,
    removeGatewaySuccessor,
    getGatewayPredecessors,
    getGatewaySuccessors,
  },
  errors: modErrs,
};