Java ProcessResult类代码示例

import org.kuali.rice.kew.engine.node.ProcessResult; //导入依赖的package包/类
public Transition transitionFrom(RouteContext context, ProcessResult processResult) throws Exception {
	RouteNodeInstance processInstance = context.getNodeInstance().getProcess();
       processInstance.setComplete(true);
	SubProcessNode node = (SubProcessNode)getNode(processInstance.getRouteNode(), SubProcessNode.class);
	SubProcessResult result = node.process(context);
	List<RouteNodeInstance> nextNodeInstances = new ArrayList<RouteNodeInstance>();
	if (result.isComplete()) {
		List<RouteNode> nextNodes = processInstance.getRouteNode().getNextNodes();
           for (RouteNode nextNode : nextNodes)
           {
               RouteNodeInstance nextNodeInstance = getRouteHelper().getNodeFactory().createRouteNodeInstance(processInstance.getDocumentId(), nextNode);
               nextNodeInstance.setBranch(processInstance.getBranch());
               nextNodeInstance.setProcess(processInstance.getProcess());
               nextNodeInstances.add(nextNodeInstance);
           }
	}
	return new Transition(nextNodeInstances);
}
 

import org.kuali.rice.kew.engine.node.ProcessResult; //导入依赖的package包/类
/**
 * Invokes the transition and returns the next node instances to transition
 * to from the current node instance on the route context.
 *
 * This is a 3-step process:
 *
 * <pre>
 *  1) If the node instance already has next nodes, return those,
 *  2) otherwise, invoke the transition engine for the node, if the resulting node instances are not empty, return those,
 *  3) lastly, if our node is in a process and no next nodes were returned from it's transition engine, invoke the
 *     transition engine of the process node and return the resulting node instances.
 * </pre>
 */
private List<RouteNodeInstance> invokeTransition(RouteContext context, RouteNodeInstance nodeInstance, ProcessResult processResult, TransitionEngine transitionEngine) throws Exception {
	List<RouteNodeInstance> nextNodeInstances = nodeInstance.getNextNodeInstances();
	if (nextNodeInstances.isEmpty()) {
		Transition result = transitionEngine.transitionFrom(context, processResult);
		nextNodeInstances = result.getNextNodeInstances();
		if (nextNodeInstances.isEmpty() && nodeInstance.isInProcess()) {
			transitionEngine = TransitionEngineFactory.createTransitionEngine(nodeInstance.getProcess());
			context.setNodeInstance(nodeInstance);
			nextNodeInstances = invokeTransition(context, nodeInstance.getProcess(), processResult, transitionEngine);
		}
	}
       // if this nodeInstance already has next node instance we can just return them
       return nextNodeInstances;
}
 

import org.kuali.rice.kew.engine.node.ProcessResult; //导入依赖的package包/类
/**
 * Invokes the transition and returns the next node instances to transition
 * to from the current node instance on the route context.
 *
 * This is a 3-step process:
 *
 * <pre>
 *  1) If the node instance already has next nodes, return those,
 *  2) otherwise, invoke the transition engine for the node, if the resulting node instances are not empty, return those,
 *  3) lastly, if our node is in a process and no next nodes were returned from it's transition engine, invoke the
 *     transition engine of the process node and return the resulting node instances.
 * </pre>
 */
/*
 * private List invokeTransition(RouteContext context, RouteNodeInstance
 * nodeInstance, ProcessResult processResult, TransitionEngine
 * transitionEngine) throws Exception { List nextNodeInstances =
 * nodeInstance.getNextNodeInstances(); if (nextNodeInstances.isEmpty()) {
 * Transition result = transitionEngine.transitionFrom(context,
 * processResult); nextNodeInstances = result.getNextNodeInstances(); if
 * (nextNodeInstances.isEmpty() && nodeInstance.isInProcess()) {
 * transitionEngine =
 * TransitionEngineFactory.createTransitionEngine(nodeInstance.getProcess());
 * nextNodeInstances = invokeTransition(context, nodeInstance.getProcess(),
 * processResult, transitionEngine); } } return nextNodeInstances; }
 */

private List invokeTransition(RouteContext context, RouteNodeInstance nodeInstance, ProcessResult processResult, TransitionEngine transitionEngine) throws Exception {
	List nextNodeInstances = nodeInstance.getNextNodeInstances();
	if (nextNodeInstances.isEmpty()) {
		Transition result = transitionEngine.transitionFrom(context, processResult);
		nextNodeInstances = result.getNextNodeInstances();
		if (nextNodeInstances.isEmpty() && nodeInstance.isInProcess()) {
			transitionEngine = TransitionEngineFactory.createTransitionEngine(nodeInstance.getProcess());
			context.setNodeInstance(nodeInstance);
			nextNodeInstances = invokeTransition(context, nodeInstance.getProcess(), processResult, transitionEngine);
		}
	}
	return nextNodeInstances;
}
 

import org.kuali.rice.kew.engine.node.ProcessResult; //导入依赖的package包/类
public ProcessResult isComplete(RouteContext context) throws Exception {
      RouteNodeInstance nodeInstance = context.getNodeInstance();
      SimpleNode node = (SimpleNode)getNode(nodeInstance.getRouteNode(), SimpleNode.class);
return node.process(context, getRouteHelper());
  }
 

import org.kuali.rice.kew.engine.node.ProcessResult; //导入依赖的package包/类
public ProcessResult isComplete(RouteContext context) throws Exception {
      RouteNodeInstance nodeInstance = context.getNodeInstance();
JoinNode node = (JoinNode)getNode(nodeInstance.getRouteNode(), JoinNode.class);
return node.process(context, getRouteHelper());
  }
 

import org.kuali.rice.kew.engine.node.ProcessResult; //导入依赖的package包/类
public ProcessResult isComplete(RouteContext context) throws Exception {
    throw new UnsupportedOperationException("isComplete() should not be invoked on a SubProcess!");
}
 

import org.kuali.rice.kew.engine.node.ProcessResult; //导入依赖的package包/类
public Transition transitionFrom(RouteContext context, ProcessResult processResult) throws Exception {
    return new Transition(resolveNextNodeInstances(context.getNodeInstance()));
}
 

import org.kuali.rice.kew.engine.node.ProcessResult; //导入依赖的package包/类
protected ProcessContext processNodeInstance(RouteContext context, RouteHelper helper) throws Exception {
	RouteNodeInstance nodeInstance = context.getNodeInstance();
       // first, let's make sure this node instance is "managed" in our persistence context
       nodeInstance = saveNode(context, nodeInstance);
	if ( LOG.isDebugEnabled() ) {
		LOG.debug("Processing node instance: " + nodeInstance.getRouteNode().getRouteNodeName());
	}
	if (checkAssertions(context)) {
		// returning an empty context causes the outer loop to terminate
		return new ProcessContext();
	}
	TransitionEngine transitionEngine = TransitionEngineFactory.createTransitionEngine(nodeInstance);
	ProcessResult processResult = transitionEngine.isComplete(context);

       // we've executed the node at least once now, if the initial flag has not already been cleared, do so now
       if (nodeInstance.isInitial()) {
           nodeInstance.setInitial(false);
       }

       // if the node is complete, let's transition
	if (processResult.isComplete()) {
		if ( LOG.isDebugEnabled() ) {
			LOG.debug("Routing node has completed: " + nodeInstance.getRouteNode().getRouteNodeName());
		}

           // route node instance id could be null if a flush didn't happen properly, let's verify
           if (nodeInstance.getRouteNodeInstanceId() == null) {
               throw new IllegalStateException("Encountered a node instance in the engine with no id: " + nodeInstance);
           }
		context.getEngineState().getCompleteNodeInstances().add(nodeInstance.getRouteNodeInstanceId());
		List<RouteNodeInstance> nextNodeCandidates =
                   invokeTransition(context, nodeInstance, processResult, transitionEngine);

		// iterate over the next node candidates sending them through the
		// transition engine's transitionTo method
		// one at a time for a potential switch. Place the transition
		// engines result back in the 'actual' next node
		// list which we put in the next node before doing work.
		List<RouteNodeInstance> nodesToActivate = new ArrayList<RouteNodeInstance>();
           if (!nextNodeCandidates.isEmpty()) {
               for (RouteNodeInstance nextNodeInstance : nextNodeCandidates) {
				transitionEngine = TransitionEngineFactory.createTransitionEngine(nextNodeInstance);
				RouteNodeInstance currentNextNodeInstance = nextNodeInstance;
				nextNodeInstance = transitionEngine.transitionTo(nextNodeInstance, context);
				// if the next node has changed, we need to remove our
				// current node as a next node of the original node
				if (!currentNextNodeInstance.equals(nextNodeInstance)) {
                       nodeInstance.getNextNodeInstances().remove(currentNextNodeInstance);
					currentNextNodeInstance.getPreviousNodeInstances().remove(nodeInstance);
				}
                   RouteNodeInstance savedNextNodeInstance = saveNode(context, nextNodeInstance);
                   if (savedNextNodeInstance != nextNodeInstance) {
                       nodeInstance.getNextNodeInstances().remove(nextNodeInstance);
                   }
                   if (!nodeInstance.getNextNodeInstances().contains(savedNextNodeInstance)) {
                       nodeInstance.addNextNodeInstance(savedNextNodeInstance);
                   }
				handleBackwardCompatibility(context, savedNextNodeInstance);
				// call the post processor
				notifyNodeChange(context, savedNextNodeInstance);
				nodesToActivate.add(savedNextNodeInstance);
				}
			}

			// deactive the current active node
		nodeInstance.setComplete(true);
		nodeInstance.setActive(false);
		// active the nodes we're transitioning into
		for (RouteNodeInstance nodeToActivate : nodesToActivate) {
			nodeToActivate.setActive(true);
		}
	} else {
	    nodeInstance.setComplete(false);
       }

	nodeInstance = saveNode(context, nodeInstance);
       // always be sure that we are changes are flushed with the database after every node instance processing
       flushDatabaseWork(context);
	return new ProcessContext(nodeInstance.isComplete(), nodeInstance.getNextNodeInstances());
}
 

import org.kuali.rice.kew.engine.node.ProcessResult; //导入依赖的package包/类
/**
 * Tell the WorkflowEngine processing the activeNodeInstance if the node is complete and transitionFrom can 
 * be called.
 *
 * @return boolean
 * @param context for routing
 * @throws Exception
 */
public abstract ProcessResult isComplete(RouteContext context) throws Exception;