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

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

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

const modErrs = {
  getTask: {
    notExist: ['01', 'Tarea no encontrada'],
  },
  addProcessTask: {
    alreadyExist: ['01', 'Ya existe una tarea con el mismo nombre dentro del proceso'],
  },
  addTaskVariable: {
    varExist: ['01', 'Ya existe una variable con el mismo nombre dentro de la tarea'],
  },
  removeTaskVariable: {
    notExist: ['01', 'No existe una variable con tal nombre dentro de la tarea'],
  },
};

async function locateTask(procName, name) {
  const taskCol = this.roPool().collection(taskColl);
  const taskDetail = await taskCol.findOne(processQueries.findTask(this.findTask(procName, name)));
  if (!taskDetail) {
    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.getTask.notExist, errorDetail);
    return [errorObj, null];
  }
  return [null, taskDetail];
}

async function addProcessTask(reqData) {
  const inputErr = this.validateObjectStructure(processSchemas.addProcessTask, reqData);
  if (inputErr) {
    return [inputErr, null];
  }
  const { procName, name } = reqData;
  const [procErr] = this.locateProcess(procName);
  if (procErr) {
    return [procErr, null];
  }
  const taskCol = this.rwPool().collection(taskColl);
  const taskDetail = await taskCol.findOne(processQueries.findTask(this.findTask(procName, name)));
  if (taskDetail) {
    const errorDetail = `Ya existe una tarea con nombre ${name} en el proceso ${procName}`;
    const errorObj = this.errMgr.get(modErrs.addProcessTask.alreadyExist, errorDetail);
    return [errorObj, null];
  }
  const newTaskData = {
    ecosystem: this._ecosystem,
    ...reqData,
    creation: new Date(),
  };
  const actionResult = await taskCol.insertOne(newTaskData);
  this.logger.log({
    level: 'debug',
    label: 'processTasks',
    action: 'addProcessTask',
    message: `Creación de un nueva tarea ${newTaskData} con resultado ${actionResult?.insertedId}`,
  });
  return [null, { taskInternalId: actionResult?.insertedId }];
}

async function addTaskVariable(reqData) {
  const inputErr = this.validateObjectStructure(processSchemas.addTaskVariable, reqData);
  if (inputErr) {
    return [inputErr, null];
  }
  const { procName, taskName, name, type, detail } = reqData;
  const [taskErr, taskDetail] = this.locateTask(procName, taskName);
  if (taskErr) {
    return [taskErr, null];
  }
  const currentVar = taskDetail.variables.find((varDef) => varDef.name === name);
  if (currentVar) {
    const errorDetail = `La tarea ${taskName} del proceso ${procName} ya cuenta con una variable llamada ${name}`;
    const errorObj = this.errMgr.get(modErrs.addTaskVariable.varExist, errorDetail);
    return [errorObj, null];
  }
  const taskCol = this.rwPool().collection(taskColl);
  const actionResult = await taskCol.updateOne(
    processQueries.findTask(this.findTask(procName, taskName)),
    processQueries.addVariable({ name, type, detail }),
  );
  const result = actionResult?.result?.nModified > 0;
  if (!result) {
    this.logger.log({
      level: 'silly',
      label: 'processTasks',
      action: 'addTaskVariable',
      message: `No se pudo efectuar Adición de variable ${name} sobre la tarea ${taskName} en el proceso ${procName}`,
    });
  }
  return [null, { result }];
}

async function removeTaskVariable(reqData) {
  const inputErr = this.validateObjectStructure(processSchemas.removeTaskVariable, reqData);
  if (inputErr) {
    return [inputErr, null];
  }
  const { procName, taskName, name } = reqData;
  const [taskErr, taskDetail] = this.locateTask(procName, taskName);
  if (taskErr) {
    return [taskErr, null];
  }
  const currentVar = taskDetail.variables.find((varDef) => varDef.name === name);
  if (!currentVar) {
    const errorDetail = `La tarea ${taskName} del proceso ${procName} no cuenta con una variable llamada ${name}`;
    const errorObj = this.errMgr.get(modErrs.removeTaskVariable.notExist, errorDetail);
    return [errorObj, null];
  }
  const taskCol = this.rwPool().collection(taskColl);
  const actionResult = await taskCol.updateOne(
    processQueries.findTask(this.findTask(procName, taskName)),
    processQueries.removeVariable(name),
  );
  const result = actionResult?.result?.nModified > 0;
  if (!result) {
    this.logger.log({
      level: 'silly',
      label: 'processTasks',
      action: 'removeTaskVariable',
      message: `No se pudo efectuar Eliminación de la variable ${name} de tarea ${taskName} en el proceso ${procName}`,
    });
  }
  return [null, { result }];
}

module.exports = {
  methods: {
    locateTask,
    addProcessTask,
    addTaskVariable,
    removeTaskVariable,
  },
  errors: modErrs,
};