tuain-bpm-lib/lib/model/process-controller/vars-and-roles.js

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

const yn = require('yn');
const merge = require('lodash.merge');

const {
  collections: {
    execution: { processes: processColl },
  },
  dbQueries: {
    execution: { process: processQueries },
  },
  process: {
    varTypes: { boolean: BOOLEAN, string: STRING, integer: INTEGER, float: FLOAT, object: OBJECT },
  },
} = require('../../../config');

const modErrs = {
  obtainVariable: {
    notDefined: ['01', 'Variable no está definida en el proceso'],
  },
  touchUser: {
    notDefined: ['01', 'Rol de usuario no está definida en el proceso'],
  },
  touchGroup: {
    notDefined: ['01', 'Rol de grupo no está definida en el proceso'],
  },
  updateProc: {
    notFound: ['01', 'No fue posible encontrar'],
  },
};

async function setVar(procId, name, value) {
  const varDef = this.processDefinition?.variables?.[name];
  if (!varDef) {
    const message = `La variable ${name} no se encuentra en la definición del proceso`;
    this.logger.log({
      level: 'error',
      label: 'processInstance',
      action: 'setVar',
      message,
    });
    const errorObj = this.errMgr.get(modErrs.obtainVariable.notDefined, message);
    return [errorObj, null];
  }
  let varValue;
  if (varDef.type === BOOLEAN) {
    varValue = yn(value) ?? false;
  } else if (varDef.type === INTEGER) {
    varValue = parseInt(value);
  } else if (varDef.type === FLOAT) {
    varValue = parseFloat(value);
  } else if (varDef.type === STRING) {
    varValue = value.toString().trim();
  } else if (varDef.type === OBJECT) {
    const currentValue = this.getVar(procId, name);
    varValue = currentValue && typeof currentValue === 'object' ? merge(currentValue, value) : null;
  } else {
    varValue = value?.toString().trim() ?? null;
  }
  const procCol = this.rwPool.collection(processColl);
  const procDetail = await procCol.findOne(processQueries.findProcess(procId));
  if (!procDetail) {
    const errorDetail = `Instancia ${procId} del proceso ${this.name} no existe`;
    const errorObj = this.errMgr.get(modErrs.updateProc.notFound, errorDetail);
    return [errorObj, null];
  }
  const actionResult = await procCol.updateOne(...processQueries.updateProcVar(procId, name, varValue));
  const result = actionResult?.result?.nModified > 0;
  if (!result) {
    this.logger.log({
      level: 'warn',
      label: 'processInstance',
      action: 'setVarDB',
      message: `No se pudo efectuar modificación de la variable ${name} de la instancia de proceso ${procId}`,
    });
  }
  return [null, { result }];
}

async function setVars(procId, varsAndValues) {
  const varNames = Object.keys(varsAndValues);
  const setPromises = [];
  for (let index = 0; index < varNames.length; index++) {
    const name = varNames[index];
    const value = varsAndValues[name];
    setPromises.push(this.setVar(procId, name, value));
  }
  const setResult = Promise.all(setPromises);
  return setResult;
}

async function getVar(procId, name, procDetailInput = null) {
  const varDef = this.processDefinition?.variables?.[name];
  if (!varDef) {
    const message = `La variable ${name} no se encuentra en la definición del proceso`;
    this.logger.log({
      level: 'error',
      label: 'processInstance',
      action: 'setVar',
      message,
    });
    const errorObj = this.errMgr.get(modErrs.obtainVariable.notDefined, message);
    return [errorObj, null];
  }
  let procDetail;
  if (!procDetailInput) {
    const procCol = this.roPool.collection(processColl);
    procDetail = await procCol.findOne(processQueries.findProcess(procId));
    if (!procDetail) {
      const errorDetail = `Instancia ${procId} del proceso ${this.name} no existe`;
      const errorObj = this.errMgr.get(modErrs.updateProc.notFound, errorDetail);
      return [errorObj, null];
    }
  } else {
    procDetail = procDetailInput;
  }
  let varValue = procDetail?.variables?.[name] ?? null;
  if (varDef.type === BOOLEAN) {
    varValue = yn(varValue) ?? false;
  } else if (varDef.type === INTEGER) {
    varValue = parseInt(varValue);
  } else if (varDef.type === FLOAT) {
    varValue = parseFloat(varValue);
  } else if (varDef.type === OBJECT) {
    varValue = varValue ? structuredClone({ ...varValue }) : null;
  } else {
    varValue = varValue?.toString().trim() ?? null;
  }
  return varValue;
}

async function getVars(procId, varNames) {
  const procCol = this.roPool.collection(processColl);
  const procDetail = await procCol.findOne(processQueries.findProcess(procId));
  if (!procDetail) {
    const errorDetail = `Instancia ${procId} del proceso ${this.name} no existe`;
    const errorObj = this.errMgr.get(modErrs.updateProc.notFound, errorDetail);
    return [errorObj, null];
  }
  const getPromises = [];
  for (let index = 0; index < varNames.length; index++) {
    const name = varNames[index];
    getPromises.push(this.getVar(procId, name, procDetail));
  }
  const varValues = await Promise.all(getPromises);
  return varValues;
}

async function assignUser(procId, roleName, user) {
  const userRole = this.processDefinition?.userRoles?.find((item) => item === roleName);
  if (!userRole) {
    const message = `El rol de usuario ${roleName} no se encuentra en la definición del proceso`;
    this.logger.log({
      level: 'error',
      label: 'processInstance',
      action: 'assignUser',
      message,
    });
    const errorObj = this.errMgr.get(modErrs.touchUser.notDefined, message);
    return [errorObj, null];
  }
  const procCol = this.rwPool.collection(processColl);
  const procDetail = await procCol.findOne(processQueries.findProcess(procId));
  if (!procDetail) {
    const errorDetail = `Instancia ${procId} del proceso ${this.name} no existe`;
    const errorObj = this.errMgr.get(modErrs.updateProc.notFound, errorDetail);
    return [errorObj, null];
  }
  console.log(processQueries.updateProcUser(procId, roleName, user));
  const actionResult = await procCol.updateOne(...processQueries.updateProcUser(procId, roleName, user));
  const result = actionResult?.result?.nModified > 0;
  if (!result) {
    this.logger.log({
      level: 'warn',
      label: 'processInstance',
      action: 'assignUserDB',
      message: `No se pudo efectuar modificación del rol de usuario ${roleName} de la instancia de proceso ${procId}`,
    });
  }
  return [null, { result }];
}

async function getUser(procId, roleName) {
  const userRole = this.processDefinition?.userRoles?.find((item) => item === roleName);
  if (!userRole) {
    const message = `El rol de usuario ${roleName} no se encuentra en la definición del proceso`;
    this.logger.log({
      level: 'error',
      label: 'processInstance',
      action: 'getUser',
      message,
    });
    const errorObj = this.errMgr.get(modErrs.touchUser.notDefined, message);
    return [errorObj, null];
  }
  const procCol = this.roPool.collection(processColl);
  const procDetail = await procCol.findOne(processQueries.findProcess(procId));
  if (!procDetail) {
    const errorDetail = `Instancia ${procId} del proceso ${this.name} no existe`;
    const errorObj = this.errMgr.get(modErrs.updateProc.notFound, errorDetail);
    return [errorObj, null];
  }
  return procDetail?.users?.[roleName] ?? null;
}

async function assignGroup(procId, roleName, group) {
  const groupRole = this.processDefinition?.groupRoles?.[roleName];
  if (!groupRole) {
    const message = `El rol de grupo ${roleName} no se encuentra en la definición del proceso`;
    this.logger.log({
      level: 'error',
      label: 'processInstance',
      action: 'assignGroup',
      message,
    });
    const errorObj = this.errMgr.get(modErrs.touchGroup.notDefined, message);
    return [errorObj, null];
  }
  const procCol = this.rwPool.collection(processColl);
  const procDetail = await procCol.findOne(processQueries.findProcess(procId));
  if (!procDetail) {
    const errorDetail = `Instancia ${procId} del proceso ${this.name} no existe`;
    const errorObj = this.errMgr.get(modErrs.updateProc.notFound, errorDetail);
    return [errorObj, null];
  }
  const actionResult = await procCol.updateOne(...processQueries.updateProcGroup(procId, roleName, group));
  const result = actionResult?.result?.nModified > 0;
  if (!result) {
    this.logger.log({
      level: 'warn',
      label: 'processInstance',
      action: 'assignGroupDB',
      message: `No se pudo efectuar modificación del rol de grupo ${roleName} de la instancia de proceso ${procId}`,
    });
  }
  return [null, { result }];
}

async function getGroup(procId, roleName) {
  const groupRole = this.processDefinition?.groupRoles?.[roleName];
  if (!groupRole) {
    const message = `El rol de grupo ${roleName} no se encuentra en la definición del proceso`;
    this.logger.log({
      level: 'error',
      label: 'processInstance',
      action: 'getGroup',
      message,
    });
    const errorObj = this.errMgr.get(modErrs.touchGroup.notDefined, message);
    return [errorObj, null];
  }
  const procCol = this.roPool.collection(processColl);
  const procDetail = await procCol.findOne(processQueries.findProcess(procId));
  if (!procDetail) {
    const errorDetail = `Instancia ${procId} del proceso ${this.name} no existe`;
    const errorObj = this.errMgr.get(modErrs.updateProc.notFound, errorDetail);
    return [errorObj, null];
  }
  return procDetail?.groupRoles?.[roleName] ?? null;
}

module.exports = {
  methods: {
    setVar,
    setVars,
    getVar,
    getVars,
    assignUser,
    getUser,
    assignGroup,
    getGroup,
  },
  errors: modErrs,
};