graphsession.java

workflow first jbpm

  /**
   * loads a token from the database by the identifier.
   * @return the token.
   * @throws JbpmException in case the referenced token doesn't exist.
   */
  public Token loadToken(long tokenId) {
    try {
//    	Query query = session.createQuery("from org.jbpm.graph.exe.Token as pd " );
//    	List list = query.list();
////    	query.setMaxResults(1);
//    	Token token = (Token) list.get(0);
      Token token = (Token) session.load(Token.class, new Long(tokenId));
      return token;
    } catch (Exception e) {
      e.printStackTrace(); log.error(e);
      jbpmSession.handleException();
      throw new JbpmException("couldn't load token '" + tokenId + "'", e);
    } 
  }

  /**
   * gets a token from the database by the identifier.
   * @return the token or null in case the token doesn't exist. 
   */
  public Token getToken(long tokenId) {
    try {
      Token token = (Token) session.get(Token.class, new Long(tokenId));
      return token;
    } catch (Exception e) {
      e.printStackTrace(); log.error(e);
      jbpmSession.handleException();
      throw new JbpmException("couldn't get token '" + tokenId + "'", e);
    } 
  }

  /**
   * locks a process instance in the database.
   */
  public void lockProcessInstance(long processInstanceId) {
    lockProcessInstance(loadProcessInstance(processInstanceId)); 
  }

  /**
   * locks a process instance in the database.
   */
  public void lockProcessInstance(ProcessInstance processInstance) {
    try {
      session.lock( processInstance, LockMode.UPGRADE );
    } catch (Exception e) {
      e.printStackTrace(); log.error(e);
      jbpmSession.handleException();
      throw new JbpmException("couldn't lock process instance '" + processInstance.getId() + "'", e);
    } 
  }

  /**
   * fetches all processInstances for the given process definition from the database.
   * The returned list of process instances is sorted start date, youngest first.
   */
  public List findProcessInstances(long processDefinitionId) {
    List processInstances = null;
    try {
      Query query = session.getNamedQuery("GraphSession.findAllProcessInstancesForADefinition");
      query.setLong("processDefinitionId", processDefinitionId);
      processInstances = query.list();

    } catch (Exception e) {
      e.printStackTrace(); log.error(e);
      jbpmSession.handleException();
      throw new JbpmException("couldn't load process instances for process definition '" + processDefinitionId + "'", e);
    } 
    return processInstances;
  }

  public void deleteProcessInstance(long processInstanceId) {
    deleteProcessInstance(loadProcessInstance(processInstanceId)); 
  }

  public void deleteProcessInstance(ProcessInstance processInstance) {
    deleteProcessInstance(processInstance, true, true);
  }

  public void deleteProcessInstance(ProcessInstance processInstance, boolean includeTasks, boolean includeJobs) {
    if (processInstance==null) throw new JbpmException("processInstance is null in JbpmSession.deleteProcessInstance()");
    try {
      // find the tokens
      Query query = session.getNamedQuery("GraphSession.findTokensForProcessInstance");
      query.setEntity("processInstance", processInstance);
      List tokens = query.list();
      
      // deleteSubProcesses
      Iterator iter = tokens.iterator();
      while (iter.hasNext()) {
        Token token = (Token) iter.next();
        deleteSubProcesses(token);
      }

      // jobs
      if (includeJobs) {
        query = session.getNamedQuery("GraphSession.deleteJobsForProcessInstance");
        query.setEntity("processInstance", processInstance);
        query.executeUpdate();
      }
      
      // tasks
      if (includeTasks) {
        query = session.getNamedQuery("GraphSession.findTaskInstanceIdsForProcessInstance");
        query.setEntity("processInstance", processInstance);
        List taskInstanceIds = query.list();
        
        query = session.getNamedQuery("GraphSession.deleteTaskInstancesById");
        query.setParameterList("taskInstanceIds", taskInstanceIds);
      }
       
      // delete the logs for all the process instance's tokens
      query = session.getNamedQuery("GraphSession.selectLogsForTokens");
      query.setParameterList("tokens", tokens);
      List logs = query.list();
      iter = logs.iterator();
      while (iter.hasNext()) {
        session.delete(iter.next());
      }

      // then delete the process instance
      session.delete(processInstance);
      
    } catch (Exception e) {
      e.printStackTrace(); log.error(e);
      jbpmSession.handleException();
      throw new JbpmException("couldn't delete process instance '" + processInstance.getId() + "'", e);
    } 
  }

  void deleteSubProcesses(Token token) {
    Query query = session.getNamedQuery("GraphSession.findSubProcessInstances");
    query.setEntity("processInstance", token.getProcessInstance());
    List processInstances = query.list();

    if (processInstances == null || processInstances.isEmpty()) {
      return; 
    }
    
    Iterator iter = processInstances.iterator();
    while (iter.hasNext()) {
      ProcessInstance subProcessInstance = (ProcessInstance) iter.next();
      subProcessInstance.setSuperProcessToken(null);
      token.setSubProcessInstance(null);
      deleteProcessInstance(subProcessInstance);
    }
    
    if (token.getChildren()!=null) {
      iter = token.getChildren().values().iterator();
      while (iter.hasNext()) {
        Token child = (Token) iter.next();
        deleteSubProcesses(child);
      }
    }
  }

  public static class AverageNodeTimeEntry {
    private long nodeId;
    private String nodeName;
    private int count;
    private long averageDuration;
    private long minDuration;
    private long maxDuration;

    public long getNodeId() {
      return nodeId;
    }

    public void setNodeId(final long nodeId) {
      this.nodeId = nodeId;
    }

    public String getNodeName() {
      return nodeName;
    }

    public void setNodeName(final String nodeName) {
      this.nodeName = nodeName;
    }

    public int getCount() {
      return count;
    }

    public void setCount(final int count) {
      this.count = count;
    }

    public long getAverageDuration() {
      return averageDuration;
    }

    public void setAverageDuration(final long averageDuration) {
      this.averageDuration = averageDuration;
    }

    public long getMinDuration() {
      return minDuration;
    }

    public void setMinDuration(final long minDuration) {
      this.minDuration = minDuration;
    }

    public long getMaxDuration() {
      return maxDuration;
    }

    public void setMaxDuration(final long maxDuration) {
      this.maxDuration = maxDuration;
    }
  }

  public List calculateAverageTimeByNode(final long processDefinitionId, final long minumumDurationMillis) {
    List results = null;
    try {
      Query query = session.getNamedQuery("GraphSession.calculateAverageTimeByNode");
      query.setLong("processDefinitionId", processDefinitionId);
      query.setDouble("minimumDuration", minumumDurationMillis);
      List listResults = query.list();
      
      if (listResults!=null) {
        results = new ArrayList();
        Iterator iter = listResults.iterator();
        while (iter.hasNext()) {
          Object[] values = (Object[]) iter.next();

          AverageNodeTimeEntry averageNodeTimeEntry = new AverageNodeTimeEntry();
          averageNodeTimeEntry.setNodeId(((Number)values[0]).longValue());
          averageNodeTimeEntry.setNodeName((String)values[1]);
          averageNodeTimeEntry.setCount(((Number)values[2]).intValue());
          averageNodeTimeEntry.setAverageDuration(((Number)values[3]).longValue());
          averageNodeTimeEntry.setMinDuration(((Number)values[4]).longValue());
          averageNodeTimeEntry.setMaxDuration(((Number)values[5]).longValue());

          results.add(averageNodeTimeEntry);
        }
      }
    } catch (Exception e) {
      e.printStackTrace(); log.error(e);
      jbpmSession.handleException();
      throw new JbpmException("couldn't load process instances for process definition '" + processDefinitionId + "'", e);
    }
    return results;
  }


  public List findActiveNodesByProcessInstance(ProcessInstance processInstance) {
    List results = null;
    try {
      Query query = session.getNamedQuery("GraphSession.findActiveNodesByProcessInstance");
      query.setEntity("processInstance", processInstance);
      results = query.list();

    } catch (Exception e) {
      e.printStackTrace(); log.error(e);
      jbpmSession.handleException();
      throw new JbpmException("couldn't active nodes for process instance '" + processInstance + "'", e);
    }
    return results;
  }

  public ProcessInstance getProcessInstance(ProcessDefinition processDefinition, String key) {
    ProcessInstance processInstance = null;
    try {
      Query query = session.getNamedQuery("GraphSession.findProcessInstanceByKey");
      query.setEntity("processDefinition", processDefinition);
      query.setString("key", key);
      processInstance = (ProcessInstance) query.uniqueResult();

    } catch (Exception e) {
      e.printStackTrace(); log.error(e);
      jbpmSession.handleException();
      throw new JbpmException("couldn't get process instance with key '" + key + "'", e);
    }
    return processInstance;
  }

  public ProcessInstance loadProcessInstance(ProcessDefinition processDefinition, String key) {
    ProcessInstance processInstance = null;
    try {
      Query query = session.getNamedQuery("GraphSession.findProcessInstanceByKey");
      query.setEntity("processDefinition", processDefinition);
      query.setString("key", key);
      processInstance = (ProcessInstance) query.uniqueResult();
      if (processInstance==null) {
        throw new JbpmException("no process instance was found with key "+key);
      }

    } catch (Exception e) {
      e.printStackTrace(); log.error(e);
      jbpmSession.handleException();
      throw new JbpmException("couldn't load process instance with key '" + key + "'", e);
    }
    return processInstance;
  }
  
  private static final Log log = LogFactory.getLog(GraphSession.class);
}