Examples of org.jbpm.api.ProcessEngine

org.jbpm.api.ProcessEngine
central starting point for all process engine API interactions. This is a thread safe object so it can be kept in a static member field or in JNDI or something similar from which all threads (requests) will fetch the same ProcessEngine object. @author Tom Baeyens

//    return processEngineQuery;
//     }


     protected ProcessEngine getProcessEngine(ProcessToolContext ctx) {
       if (ctx instanceof ProcessToolContextImpl) {
         ProcessEngine engine = ((ProcessToolContextImpl) ctx).getProcessEngine();
         if (user != null && user.getLogin() != null) {
           engine.setAuthenticatedUserId(user.getLogin());
         }
         return engine;
       }
       else {
         throw new IllegalArgumentException(ctx + " not an instance of " + ProcessToolContextImpl.class.getName());

View Full Code Here

        final List<String> names = keyFilter("name", configs);
        if (!names.contains(pq.getName())) {
            throw new ProcessToolSecurityException("queue.no.rights", pq.getName());
        }


        ProcessEngine processEngine = getProcessEngine(ctx);


        final String taskId = bpmTask != null ? bpmTask.getInternalTaskId() : null;
        Command<List<Task>> cmd = new Command<List<Task>>() {
            @Override
            public List<Task> execute(Environment environment) throws Exception {
                AbstractQuery q = new AbstractQuery() {
                    @Override
                    protected void applyPage(Query query) {
                        query.setFirstResult(0);
                        query.setFetchSize(1);
                    }


                    @Override
                    protected void applyParameters(Query query) {
                        query.setParameterList("groupIds", java.util.Collections.singleton(pq.getName()));
                        if (taskId != null) {
                            query.setParameter("taskId", new Long(taskId));
                        }
                    }


                    @Override
                    public String hql() {
                        StringBuilder hql = new StringBuilder();
                        hql.append("select task ");
                        hql.append("from ");
                        hql.append(TaskImpl.class.getName());
                        hql.append(" as task ");
                        hql.append(", ");
                        hql.append(ParticipationImpl.class.getName());
                        hql.append(" as participant ");
                        hql.append("where participant.task=task ");
                        hql.append("and participant.type = 'candidate' ");
                        hql.append("and participant.groupId IN (:groupIds) ");
                        hql.append("and task.assignee is null ");
                        if (taskId != null) {
                            hql.append("and task.id = :taskId");
                        }
                        return hql.toString();
                    }
                };
                return (List<Task>) q.execute(environment);
            }
        };
        List<Task> taskList = processEngine.execute(cmd);
        if (taskList.isEmpty()) {
            loger.warning("No tasks found in queue: " + pq.getName());
            return null;
        }
        Task task = taskList.get(0);
        Execution exec = processEngine.getExecutionService().findExecutionById(task.getExecutionId());
        String internalId = exec.getProcessInstance().getId();
        ProcessInstance pi = getProcessData(internalId, ctx);
        if (pi == null) {
            loger.warning("Process instance not found for instance id: " + internalId);
            return null;
        }


        Calendar snapshotDate = Calendar.getInstance();


        processEngine.getTaskService().assignTask(task.getId(), user.getLogin());
        task = processEngine.getTaskService().getTask(task.getId());
        if (!user.getLogin().equals(task.getAssignee())) {
            loger.warning("Task: + " + bpmTask.getExecutionId() + " not assigned to requesting user: " + user.getLogin());
            return null;
        }

View Full Code Here

           Map<String, Object> vars = new HashMap<String, Object>();
           vars.put("ACTION", action.getBpmName());
           processInstance.setSimpleAttribute("ACTION", action.getBpmName());
           List<String> outgoingTransitionNames = getOutgoingTransitionNames(task.getInternalTaskId(), ctx);


           ProcessEngine processEngine = getProcessEngine(ctx);


           Task bpmTaskInstance = processEngine.getTaskService().getTask(task.getInternalTaskId());
           String executionId = bpmTaskInstance.getExecutionId();




           Set<String> taskIdsBeforeCompletion = new HashSet<String>();


           pl.net.bluesoft.util.lang.Collections.collect(findProcessTasksWithUser(processInstance, ctx), new Transformer<BpmTask, String>() {


               @Override
               public String transform(BpmTask obj) {
                   return obj.getInternalTaskId();  
               }
           }, taskIdsBeforeCompletion);


           
           
          if (outgoingTransitionNames.size() == 1)
              processEngine.getTaskService().completeTask(task.getInternalTaskId(), outgoingTransitionNames.get(0), vars); //BPMN2.0 style, decision is taken on the XOR gateway
          else
              processEngine.getTaskService().completeTask(task.getInternalTaskId(), action.getBpmName(), vars);
          
          broadcastEvent(ctx, new BpmEvent(BpmEvent.Type.TASK_FINISHED, task, user));
          
       /* Inform queue manager about task finish and process state change */
       ctx.getUserProcessQueueManager().onTaskFinished(task);

View Full Code Here

     }


     @Override
     public void assignTaskToUser(ProcessToolContext ctx, String taskId, String userLogin) {
      long start = System.currentTimeMillis();
       ProcessEngine processEngine = getProcessEngine(ctx);
       processEngine.getTaskService().assignTask(taskId, userLogin);
       BpmTask taskData = getTaskData(taskId, ctx); 
       UserData newUser = new UserData();  
       newUser.setLogin(userLogin); 
       UserData loadOrCreateUser = loadOrCreateUser(ctx,newUser);
       broadcastEvent(ctx, new BpmEvent(BpmEvent.Type.ASSIGN_TASK, taskData, loadOrCreateUser));

View Full Code Here

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


    public List<String> getOutgoingTransitionNames(String internalId, ProcessToolContext ctx) {
        ProcessEngine engine = getProcessEngine(ctx);
        return new ArrayList<String>(engine.getTaskService().getOutcomes(internalId));
    }

View Full Code Here

        ProcessEngine engine = getProcessEngine(ctx);
        return new ArrayList<String>(engine.getTaskService().getOutcomes(internalId));
    }


    public boolean updateSubprocess(final ProcessInstance parentPi, String executionId, ProcessToolContext ctx) {
        ProcessEngine engine = getProcessEngine(ctx);
        ExecutionService executionService = engine.getExecutionService();
    Execution jbpmPi = executionService.findExecutionById(executionId);
        if(jbpmPi != null){
          Execution subprocess = jbpmPi.getSubProcessInstance();
          if(subprocess != null){
            ctx.getHibernateSession().refresh(subprocess);

View Full Code Here




  public List<String> getOutgoingTransitionDestinationNames(String internalId, ProcessToolContext ctx) {
      
      long start = System.currentTimeMillis();
        ProcessEngine engine = getProcessEngine(ctx);
        org.jbpm.api.ProcessInstance pi = engine.getExecutionService().findProcessInstanceById(internalId);
        final ExecutionImpl execution = (ExecutionImpl) pi.getProcessInstance();
        final List<String> transitionNames = new ArrayList<String>();
        engine.execute(new Command() {
            public Object execute(Environment env) {
                for (Transition transition : execution.getActivity().getOutgoingTransitions()) {
                    transitionNames.add(transition.getDestination().getName());
                }
                return null;

View Full Code Here

    public void adminCancelProcessInstance(ProcessInstance pi) {
        loger.severe("User: " + user.getLogin() + " attempting to cancel process: " + pi.getInternalId());
        long start = System.currentTimeMillis();
        ProcessToolContext ctx = ProcessToolContext.Util.getThreadProcessToolContext();
        pi = getProcessData(pi.getInternalId(), ctx);
        ProcessEngine processEngine = getProcessEngine(ctx);
        processEngine.getExecutionService().endProcessInstance(pi.getInternalId(), "admin-cancelled");
        fillProcessAssignmentData(processEngine, pi, ctx);
        pi.setRunning(false);
        pi.setState(null);
        ctx.getProcessInstanceDAO().saveProcessInstance(pi);
        long duration = System.currentTimeMillis() - start;

View Full Code Here

        public void adminReassignProcessTask(ProcessInstance pi, BpmTask bpmTask, String userLogin) {
            loger.severe("User: " + user.getLogin() + " attempting to reassign task " + bpmTask.getInternalTaskId() + " for process: " + pi.getInternalId() + " to user: " + userLogin);


            ProcessToolContext ctx = ProcessToolContext.Util.getThreadProcessToolContext();
            pi = getProcessData(pi.getInternalId(), ctx);
            ProcessEngine processEngine = getProcessEngine(ctx);
            TaskService ts = processEngine.getTaskService();
            Task task = ts.getTask(bpmTask.getInternalTaskId());
            if (nvl(userLogin,"").equals(nvl(task.getAssignee(),""))) {
                loger.severe("User: " + user.getLogin() + " has not reassigned task " + bpmTask.getInternalTaskId() + " for process: " + pi.getInternalId() + " as the user is the same: " + userLogin);
                return;
            }

View Full Code Here


        }  


        @Override
        public List<GraphElement> getProcessHistory(final ProcessInstance pi) {
            ProcessEngine processEngine = getProcessEngine(ProcessToolContext.Util.getThreadProcessToolContext());
            HistoryService service = processEngine.getHistoryService();
             
            HistoryActivityInstanceQuery createHistoryActivityInstanceQuery = service.createHistoryActivityInstanceQuery();
            HistoryActivityInstanceQuery activityInstanceQuery = createHistoryActivityInstanceQuery.processInstanceId(pi.getInternalId());
            List<HistoryActivityInstance> list = activityInstanceQuery.list();
            
            
            
            
   
            Map<String,GraphElement> processGraphElements = parseProcessDefinition(pi);


            
            
            List<GraphElement> transitionaArcsList = new ArrayList<GraphElement>();
            Collection<GraphElement> pge = processGraphElements.values() ;
            
            
            for (GraphElement ge : pge) {  
                if( ge instanceof TransitionArc){
                  TransitionArc ta = (TransitionArc)ge;
                    transitionaArcsList.add(ta);
                  
              }
            }
            
        
            
            ArrayList<GraphElement> res = new ArrayList<GraphElement>();
            for (HistoryActivityInstance hpi : list) {
                loger.fine("Handling: " + hpi.getActivityName());
                if (hpi instanceof HistoryActivityInstanceImpl) {
                    HistoryActivityInstanceImpl activity = (HistoryActivityInstanceImpl) hpi;
                    String activityName = activity.getActivityName();
                    if (res.isEmpty()) { //initialize start node and its transition
                        GraphElement startNode = processGraphElements.get("__AWF__start_node");
                        if (startNode != null) {
                            res.add(startNode);
                        }
                        GraphElement firstTransition = processGraphElements.get("__AWF__start_transition_to_" + activityName);
                        if (firstTransition != null) {
                            res.add(firstTransition);
                        }
                    }
                   
                    StateNode sn = (StateNode) processGraphElements.get(activityName);
                    
                   
                    
                    ArrayList<StateNode> arrayList = new ArrayList<StateNode>();
                    Collection<GraphElement> values = processGraphElements.values();
                    for (GraphElement graphElement : values) {
            if(graphElement instanceof StateNode){
              arrayList.add((StateNode) graphElement);
            }
                      
                      
          }
                    if (sn == null) continue;
                    sn = sn.cloneNode();
                    sn.setUnfinished(activity.getEndTime() == null);
                    sn.setLabel(activityName + ": " + hpi.getDuration() + "ms");
                    res.add(sn);
                    //look for transition
                    TransitionArc ta = (TransitionArc) processGraphElements.get(activityName + "_" + activity.getTransitionName());
                    if (ta == null) { //look for default!
                        ta = (TransitionArc) processGraphElements.get("__AWF__default_transition_" + activityName);
                    }
                    if (ta == null) {
                        continue;
                    }
                    
            
                    
                  
                    
                    res.add(ta.cloneNode());
                } else {
                    loger.severe("Unsupported entry: " + hpi);
                }
            }
            
           addJoinAndForkElements(res,processGraphElements);
            
            
            HistoryProcessInstanceQuery historyProcessInstanceQuery = processEngine.getHistoryService()
                    .createHistoryProcessInstanceQuery().processInstanceId(pi.getInternalId());
            HistoryProcessInstance historyProcessInstance = historyProcessInstanceQuery.uniqueResult();
            if (historyProcessInstance != null && historyProcessInstance.getEndActivityName() != null) {
                StateNode sn = (StateNode) processGraphElements.get(historyProcessInstance.getEndActivityName());
                if (sn != null) {

View Full Code Here

0 1 2

TOP

Related Classes of org.jbpm.api.ProcessEngine

cn.ctit.ruleworkflow.App

org.jbpm.db.Create

org.jbpm.db.Upgrade

org.jbpm.pvm.internal.ant.AntHelper

org.jbpm.pvm.internal.ant.JbpmDeployTask

org.jbpm.pvm.internal.wire.binding.ProcessEngineRefBinding

pl.net.bluesoft.rnd.pt.ext.jbpm.ProcessEngineQuery

pl.net.bluesoft.rnd.pt.ext.jbpm.ProcessToolContextFactoryImpl

pl.net.bluesoft.rnd.pt.ext.jbpm.ProcessToolJbpmSession

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.