protected void validate(
      ClientContext cs, TXTransactionDataContainer dtc, TXProcesoDAO process, TXFaseDAO stage)
      throws ISPACException {

    IBPMAPI bpmAPI = dtc.getBPMAPI();
    TXProcedure procedure = TXProcedureMgr.getInstance().getProcedure(cs, process.getIdProcedure());
    // PFaseDAO pStage = procedure.getStageDAO(stage.getInt("ID_FASE"));
    PNodoDAO pNode = procedure.getNode(cs.getConnection(), stage.getInt("ID_FASE"));

    String previousStageUID =
        bpmAPI.getPreviousStage(
            process.getString("ID_PROCESO_BPM"), pNode.getString("ID_NODO_BPM"));
    if (StringUtils.isEmpty(previousStageUID)) {
      if (stage.getInt("TIPO") == IStage.STAGE_TYPE)
        throw new ISPACInfo("exception.expedients.previousStage.noStage");
      else throw new ISPACInfo("exception.subprocess.previousActivitiy.noActivity");
    }
  }
 /**
  * Libera la transacción
  *
  * @throws ISPACException si ocurre algún error.
  */
 public void release() throws ISPACException {
   try {
     if (!previoustx) {
       context.releaseTX();
     }
     if (error && (bpmAPI != null)) {
       bpmAPI.closeBPMSession(false);
     }
   } catch (ISPACException e) {
     throw e;
   } catch (Exception e) {
     throw new ISPACException("Error en TransactionContainer.release() ", e);
   }
 }
 /**
  * Realiza un commit de la transacción.
  *
  * @throws ISPACException si ocurre algún error.
  */
 public void commit() throws ISPACException {
   try {
     if (bpmAPI != null) {
       bpmAPI.closeBPMSession(true);
     }
     if (!previoustx) {
       context.endTX(true);
     }
   } catch (ISPACException e) {
     throw e;
   } catch (Exception e) {
     throw new ISPACException("Error en TransactionContainer.commit()", e);
   }
 }
 /**
  * Inicia una transacción
  *
  * @throws ISPACException si ocurre algún error.
  */
 public void begin() throws ISPACException {
   try {
     previoustx = context.ongoingTX();
     if (!previoustx) {
       context.beginTX();
     }
     if (bpmAPI != null) {
       bpmAPI.initBPMSession();
     }
   } catch (ISPACException e) {
     throw e;
   } catch (Exception e) {
     throw new ISPACException("Error en TransactionContainer.begin() ", e);
   }
 }
Exemple #5
0
  public void run(ClientContext cs, TXTransactionDataContainer dtc, ITXTransaction itx)
      throws ISPACException {

    EventManager eventmgr = new EventManager(cs, mparams);
    TXDAOGen genDAO = new TXDAOGen(cs, eventmgr);

    TXFaseDAO stage = dtc.getStage(mnIdStage);
    int nIdProc = stage.getInt("ID_EXP");
    int nIdPCDStage = stage.getInt("ID_FASE");

    TXProcesoDAO process = dtc.getProcess(nIdProc);
    TXProcedure procedure = TXProcedureMgr.getInstance().getProcedure(cs, process.getIdProcedure());

    PTramiteDAO pcdtask = procedure.getTaskDAO(mnIdTaskPCD);

    if (process.getInt("ESTADO") == TXConstants.STATUS_CLOSED) {
      throw new ISPACInfo(
          "exception.expedients.createTask.statusClosed",
          new String[] {pcdtask.getString("NOMBRE"), process.getString("NUMEXP")});
    } else if (process.getInt("ESTADO") == TXConstants.STATUS_CANCELED) {
      throw new ISPACInfo(
          "exception.expedients.createTask.statusCanceled",
          new String[] {pcdtask.getString("NOMBRE"), process.getString("NUMEXP")});
    } else if (process.getInt("ESTADO") == TXConstants.STATUS_ARCHIVED) {
      throw new ISPACInfo(
          "exception.expedients.createTask.statusArchived",
          new String[] {pcdtask.getString("NOMBRE"), process.getString("NUMEXP")});
    }

    // -----
    // BPM
    // ----
    IBPMAPI bpmAPI = dtc.getBPMAPI();
    IInvesflowAPI invesFlowAPI = cs.getAPI();
    IRespManagerAPI respManagerAPI = invesFlowAPI.getRespManagerAPI();
    // Se calcula el responsable del trámite
    String taskRespId = ResponsibleHelper.calculateTaskResp(eventmgr, pcdtask, stage, process, cs);

    String nombreRespId = ((Responsible) respManagerAPI.getResp(taskRespId)).getName();
    String taskActivityRespId = null;

    // boolean isSubProcess = false;
    boolean isSubProcess = mnIdProcedure != 0;
    int taskType = ITask.SIMPLE_TASK_TYPE;
    String idSubPcdBPM = null;
    // Si el tramite es complejo se calcula el responsable a asignar a la actividad inicial del
    // subproceso
    // if (StringUtils.isNotEmpty(pcdtask.getString("ID_PCD_SUB")) &&
    // !StringUtils.equals(pcdtask.getString("ID_PCD_SUB"), "0")){
    if (isSubProcess) {
      taskType = ITask.COMPLEX_TASK_TYPE;

      TXProcedure subProcess = TXProcedureMgr.getInstance().getProcedure(cs, mnIdProcedure);
      Iterator it = subProcess.getStateTable().getStartStages().iterator();

      if (!it.hasNext())
        throw new ISPACException(
            "No se han encontrado actividades para el subproceso '"
                + pcdtask.getString("ID_PCD_SUB")
                + "'");
      int activityId = ((Integer) it.next()).intValue();
      PFaseDAO pActivity = subProcess.getStageDAO(activityId);
      taskActivityRespId =
          ResponsibleHelper.calculateTaskActivityResp(
              eventmgr, pActivity, pcdtask, process, cs, taskRespId);

      IItem itemSubprocedure = invesFlowAPI.getProcedure(pcdtask.getInt("ID_PCD_SUB"));
      idSubPcdBPM = itemSubprocedure.getString("ID_PCD_BPM");
    }

    // BpmUIDs bpmUIDs = bpmAPI.instanceTask(pcdtask.getString("ID_TRAMITE_BPM"),
    // pcdtask.getString("ID_PCD_SUB"), taskRespId,
    // taskActivityRespId,String.valueOf(stage.getKeyInt()));
    BpmUIDs bpmUIDs =
        bpmAPI.instanceTask(
            pcdtask.getString("ID_TRAMITE_BPM"),
            idSubPcdBPM,
            taskRespId,
            taskActivityRespId,
            stage.getString("ID_FASE_BPM"));

    // Identificador de tramite creado
    String taskUID = bpmUIDs.getTaskUID();
    // Identificador de subproceso instanciado
    String subProcessUID = bpmUIDs.getSubProcessUID();
    // Identificador de actividad creada
    String activityUID = bpmUIDs.getActivityUID();

    TXTramiteDAO task = dtc.newTask();
    genDAO.instance(pcdtask, task, stage, process);

    // Establecemos el UID del tramite instanciado retornado por el BPM
    if (taskUID == null) taskUID = "" + task.getKeyInt();
    task.set("ID_TRAMITE_BPM", taskUID);
    task.set("ID_RESP", taskRespId);
    task.set("RESP", nombreRespId);
    task.set("TIPO", taskType);
    // Si es un tramite complejo (subproceso) habrá que instanciar el subproceso
    if (isSubProcess) {
      int[] ids =
          itx.createSubProcess(
              pcdtask.getInt("ID_PCD_SUB"),
              mnumexp,
              subProcessUID,
              activityUID,
              taskRespId,
              taskActivityRespId);
      task.set("ID_SUBPROCESO", (int) ids[0]);
      mnIdActivity = (int) ids[1];
      //			//Obtenemos la actividad inicia
      //			Iterator it =dtc.getStages();
      //			while (it.hasNext()){
      //				TXFaseDAO _stage = (TXFaseDAO)((Map.Entry)it.next()).getValue();
      //				if (_stage.getInt("ID_EXP") == idSubProcess){
      //					mnIdActivity = _stage.getKeyInt();
      //					break;
      //				}

      eventmgr.getRuleContextBuilder().addContext(RuleProperties.RCTX_SUBPROCESS, "" + ids[0]);
    }

    // Guardar la información del trámite
    task.store(cs);

    dtc.createTaskEntity(task);

    mnIdTask = task.getKeyInt();

    // Insertar el hito
    TXHitoDAO hito =
        dtc.newMilestone(
            process.getKeyInt(), nIdPCDStage, mnIdTaskPCD, TXConstants.MILESTONE_TASK_START);
    hito.set("INFO", composeInfo());

    // Se construye el contexto de ejecución de scripts.
    eventmgr.getRuleContextBuilder().addContext(process);
    eventmgr.getRuleContextBuilder().addContext(task);

    // Ejecutar eventos de sistema de creación de trámite.
    eventmgr.processSystemEvents(EventsDefines.EVENT_OBJ_TASK, EventsDefines.EVENT_EXEC_START);

    // Ejecutar evento al cancelar trámite.
    eventmgr.processEvents(
        EventsDefines.EVENT_OBJ_TASK, mnIdTaskPCD, EventsDefines.EVENT_EXEC_START);
  }