tuain-bpm-lib/lib/model/process-controller/controller-base.js

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

/* eslint-disable no-unused-vars */

/**
 * Interfaz para facilitar desarrollo en la clase Controller
 */
class ProcessControllerBase {
  /**
   * Método Virtual para que las subclases definan como parametrizar el flujo del proceso
   */
  customizeBehaviour() {
    //
    this.logger.log({
      level: 'error',
      message: 'Clase de gestión de proceso sin personalización de comportamiento',
    });
  }

  /**
   * Operaciones básicas de las instancias de proceso
   */

  /**
   * Crea una nueva instancia del proceso
   * @param {*} inputVars Variables de entrada para el evento start del proceso
   * @param {*} users Usuarios iniciales relacionados con roles de usuarios
   * @param {*} groups Grupos iniciales relacionados con roles de grupo
   */
  async newInstance(inputVars, users, groups) {}

  /**
   * Localiza una instancia del proceso que contenga ciertas variables de entrada
   * @param {*} inputVars Variables de entrada
   */
  async findInstance(inputVars) {}

  /**
   * Asinación de valor a una variable del proceso
   * @param {*} procId Código de la instancia del proceso
   * @param {*} name Nombre de la variable
   * @param {*} value Valor de la variable a asignar
   */
  async setVar(procId, name, value) {}

  /**
   * Obtención del valor de una variable del proceso
   * @param {*} procId Código de la instancia del proceso
   * @param {*} name Nombre de la variable
   */
  async getVar(procId, name) {}

  /**
   * Asignación de un usuario a un rol del proceso
   * @param {*} procId Código de la instancia del proceso
   * @param {*} roleName Nombre del rol de usuario a asignar
   * @param {*} user Usuario que se quiere asignar al rol
   */
  async assignUser(procId, roleName, user) {}

  /**
   * Obtiene el usuario asignado a un rol en el proceso
   * @param {*} procId Código de la instancia del proceso
   * @param {*} roleName Nombre del rol de usuario
   */
  async getUser(procId, roleName) {}

  /**
   * Asignación de un grupo a un rol del proceso
   * @param {*} procId Código de la instancia del proceso
   * @param {*} roleName Nombre del rol de grupo a asignar
   * @param {*} group Grupo que se quiere asignar al rol
   */
  async assignGroup(procId, roleName, group) {}

  /**
   * Obtiene el grupo asignado a un rol en el proceso
   * @param {*} procId Código de la instancia del proceso
   * @param {*} roleName Nombre del rol de grupo
   */
  async getGroup(procId, roleName) {}

  /**
   * Registra un evento de tipo timer tal que dispare el evento en wakeupDate
   * @param {*} procId Código de la instancia del proceso
   * @param {*} name Nombre del evento
   * @param {*} eventVars Variables de entrada para ejecutar el evento
   */
  registerTimerEvent(procId, name, eventVars) {}

  /**
   * Inicia la ejecución de una nueva instancia de un evento
   * @param {*} procId Código de la instancia del proceso
   * @param {*} name Nombre del evento
   * @param {*} eventVars Variables de entrada frente al evento
   */
  async triggerEvent(procId, name, eventVars) {}

  /**
   * Permite definir una función a ejecutar al momento de dispararse un evento
   * @param {*} name Nombre del evento del proceso
   * @param {*} callback Función a ejecutar cuando se dispare un evento específico
   */
  onEventComplete(name, callback) {}

  /**
   * Permite definir la función que cierra un evento actualizando el proceso
   * @param {*} name Nombre del evento del proceso
   * @param {*} callback Función a ejecutar cuando se cierre cada instancia del evento
   */
  onEventClose(name, callback) {}

  /**
   * Obtiene todo el historial de eventos ejecutados en un proceso
   * @param {*} procId
   */
  async getProcessEventsHistory(procId) {}

  /**
   * Métodos relativos al manejo de las tareas de los procesos
   */

  /**
   * Inicia una nueva tarea en una instancia de proceso
   * @param {*} procId Código de la instancia del proceso
   * @param {*} name nombre de la tarea a iniciar una instancia
   * @param {*} origin Nodo anterior de donde proviene la ejecución de la tarea
   * @param {*} userRole Role de usuario asignado a la tarea
   * @param {*} groupRole Role de usuario asignado a la tarea
   * @param {*} userId Usuario asignado directamente a la tarea
   * @param {*} groupId Grupo de usuarios asignado directamente a la tarea
   */
  async startNewTask(procId, name, origin, userRole, groupRole, userId, groupId) {}

  /**
   * Asignación de un usuario a un rol del proceso
   * @param {*} taskId Código de la instancia de la tarea
   * @param {*} procId Código de la instancia del proceso
   * @param {*} name Nombre del rol de usuario a asignar
   * @param {*} userId Usuario al que se quiere asignar la tarea
   */
  async assignTaskToUser(taskId, procId, name, userId) {}

  /**
   * Asignación de un usuario a un rol del proceso
   * @param {*} procId Código de la instancia del proceso
   * @param {*} roleName Nombre del rol de grupo a asignar
   * @param {*} groupId Grupo al que se quiere asignar la tarea
   */
  async assignTaskToGroup(procId, roleName, groupId) {}

  /**
   * Obtiene la instancia de una tarea de una instancia específica de un proceso
   * @param {*} taskId Identificador único de la instancia (en su ausencia se toma la primera)
   * @param {*} procId Código de la instancia del proceso
   * @param {*} name Nombre de la tarea (si no hay taskId se localiza la primera por nombre)
   * @param {*} status Estado de la tarea que se quiere encontrar
   */
  async getTaskInstance(taskId, procId, name, status) {}

  /**
   * Confirma la finalización de una tarea específica de un proceso
   * @param {*} inputTaskId Identificador único de la tarea
   * @param {*} procId Código de la instancia del proceso
   * @param {*} name Nombre de la tarea (si no hay taskId se localiza la primera por nombre)
   */
  async stopTask(inputTaskId, procId, name) {}

  /**
   * Confirma la finalización de una tarea específica de un proceso
   * @param {*} taskId Identificador único de la tarea
   * @param {*} inputVars Variables de entrada para la tarea
   */
  async completeTask(taskId, inputVars) {}

  /**
   * Permite definir una función a ejecutar al momento de iniciar una tarea
   * @param {*} name Nombre de la tarea
   * @param {*} callback Función a ejecutar cuando se inicie una instancia de la tarea
   */
  onTaskStart(name, callback) {}

  /**
   * Permite definir una función a ejecutar al momento de terminarse una tarea
   * @param {*} name Nombre de la tarea
   * @param {*} callback Función a ejecutar cuando se finalice cada instancia de la tarea
   */
  onTaskComplete(name, callback) {}

  /**
   * Permite definir la función que cierra una tarea actualizando el proceso
   * @param {*} name Nombre de la tarea
   * @param {*} callback Función a ejecutar cuando se cierre cada instancia de la tarea
   */
  onTaskClose(name, callback) {}

  /**
   * Obtiene todas las tareas de cierto tipo en un estado específico
   * @param {*} name Nombre de la tarea
   * @param {*} status Estado de la tarea
   * @param {*} pageNumber Número de página
   * @param {*} pageSize Tamaño de página
   */
  async getActiveTasks(name, pageNumber, pageSize, status) {}

  /**
   * Obtiene todas las tareas en cabeza de un usuario
   * @param {*} userId Usuario del que se quiere obtener las tareas
   */
  async getUserTasks(userId) {}

  /**
   * Obtiene todas las tareas asignadas a cualquiera de los grupos en un arreglo de ids
   * @param {*} groupIdArray Arreglo de grupos sobre los que se quiere obtener las tareas
   */
  async getGroupsTasks(groupIdArray) {}

  /**
   * Obtiene todo el historial de tareas ejecutadas en un proceso
   * @param {*} procId Código de la instancia del proceso
   */
  async getProcessTaskHistory(procId) {}

  /**
   * Obtiene las actividades actualmente activas en el proceso
   * @param {*} procId Código de la instancia del proceso
   */
  async getTasksInProgress(procId) {}

  /**
   * Métodos relativos al manejo de los gateways del proceso
   */

  /**
   * Inicia una nueva instancia de ejecución de un gateway del proceso
   * @param {*} procId Código de la instancia del proceso
   * @param {*} name Nombre del gateway a ejecutar
   * @param {*} origin Nodo que solicitió o de donde proviene la ejecución del gateway
   */
  async startNewGateway(procId, name, origin) {}

  /**
   * Obtiene todo el historial de gateways ejecutados en un proceso
   * @param {*} procId Código de la instancia del proceso
   */
  async getProcessGatewaysHistory(procId) {}

  /**
   * Registra una función callback para evaluar si un destino de un gateway se debe ejecutar
   * @param {*} name Nombre del gateway
   * @param {*} desination Nombre del destino
   * @param {*} callback Función de evaluación
   */
  defineGatewayDestinationCallback(name, desination, callback) {}

  /**
   * Métodos relativos a consultas y estadísticas de un proceso
   */

  /**
   * Obtiene todo el historial de actividades, eventos y gateway ejecutados en un proceso
   * @param {*} procId Código de la instancia del proceso
   */
  async getProcessHistory(procId) {}
}

module.exports = ProcessControllerBase;