Java Branch类代码示例

import org.kuali.rice.kew.engine.node.Branch; //导入依赖的package包/类
@Override
public Map<String, String> getVariables() {
    Map<String, String> documentVariables = new HashMap<String, String>();
    /* populate the routeHeaderVO with the document variables */
    // FIXME: we assume there is only one for now
    Branch routeNodeInstanceBranch = getRootBranch();
    // Ok, we are using the "branch state" as the arbitrary convenient repository for flow/process/edoc variables
    // so we need to stuff them into the VO
    if (routeNodeInstanceBranch != null) {
        List<BranchState> listOfBranchStates = routeNodeInstanceBranch.getBranchState();
        for (BranchState bs : listOfBranchStates) {
            if (bs.getKey() != null && bs.getKey().startsWith(BranchState.VARIABLE_PREFIX)) {
                if ( LOG.isDebugEnabled() ) {
                    if ( LOG.isDebugEnabled() ) {
                        LOG.debug("Setting branch state variable on vo: " + bs.getKey() + "=" + bs.getValue());
                    }
                }
                documentVariables.put(bs.getKey().substring(BranchState.VARIABLE_PREFIX.length()), bs.getValue());
            }
        }
    }
    return documentVariables;
}
 

import org.kuali.rice.kew.engine.node.Branch; //导入依赖的package包/类
public DynamicResult transitioningInto(RouteContext context, RouteNodeInstance process, RouteHelper helper) throws Exception {
    List<RouteNodeInstance> nextNodeInstances = new ArrayList<RouteNodeInstance>();
    for (int index = 0; index < ROLES.length; index++) {
        String roleName = ROLES[index];
        RouteNode node = helper.getNodeFactory().getRouteNode(context, NEXT_NODE_NAME);
        if (node == null) {
            throw new WorkflowException("Couldn't locate node for name: " + NEXT_NODE_NAME);
        }
        RouteNodeInstance nextNodeInstance = helper.getNodeFactory().createRouteNodeInstance(context.getDocument().getDocumentId(), node);
        Branch branch = helper.getNodeFactory().createBranch(roleName, context.getNodeInstance().getBranch(), nextNodeInstance);
        branch.addBranchState(new BranchState("role", roleName));
        branch.setSplitNode(context.getNodeInstance());
        nextNodeInstances.add(nextNodeInstance);
    }
    //return new DynamicResult(true, nextNodeInstances);
    throw new UnsupportedOperationException("No!!!!");
}
 

import org.kuali.rice.kew.engine.node.Branch; //导入依赖的package包/类
/**
 * Tests that the proper state is set up on the root branch in the document
 * to indicate that both PROCESSED and FINAL callbacks have been made into
 * the post processor.
 */
@Test public void testSystemBranchState() throws Exception {
	// route the document to final
	WorkflowDocument document = WorkflowDocumentFactory.createDocument(getPrincipalIdForName("ewestfal"), "SimpleDocType");
	document.route("");
	assertTrue("Document should be final.", document.isFinal());

	// now look at the branch state
	DocumentRouteHeaderValue routeHeader = KEWServiceLocator.getRouteHeaderService().getRouteHeader(document.getDocumentId());
	Branch rootBranch = routeHeader.getRootBranch();
	assertNotNull(rootBranch);
	BranchState processedBranchState = rootBranch.getBranchState(KewApiConstants.POST_PROCESSOR_PROCESSED_KEY);
	BranchState finalBranchState = rootBranch.getBranchState(KewApiConstants.POST_PROCESSOR_FINAL_KEY);
	assertNotNull(processedBranchState);
	assertNotNull(finalBranchState);
	assertEquals("true", processedBranchState.getValue());
	assertEquals("true", finalBranchState.getValue());
	assertEquals(1, TestPostProcessor.processedCount);
	assertEquals(1, TestPostProcessor.finalCount);
}
 

import org.kuali.rice.kew.engine.node.Branch; //导入依赖的package包/类
@Override
public Map<String, String> getVariables() {
    Map<String, String> documentVariables = new HashMap<String, String>();
    /* populate the routeHeaderVO with the document variables */
    // FIXME: we assume there is only one for now
    Branch routeNodeInstanceBranch = getRootBranch();
    // Ok, we are using the "branch state" as the arbitrary convenient repository for flow/process/edoc variables
    // so we need to stuff them into the VO
    if (routeNodeInstanceBranch != null) {
        List<BranchState> listOfBranchStates = routeNodeInstanceBranch.getBranchState();
        for (BranchState bs : listOfBranchStates) {
            if (bs.getKey() != null && bs.getKey().startsWith(BranchState.VARIABLE_PREFIX)) {
                LOG.debug("Setting branch state variable on vo: " + bs.getKey() + "=" + bs.getValue());
                documentVariables.put(bs.getKey().substring(BranchState.VARIABLE_PREFIX.length()), bs.getValue());
            }
        }
    }
    return documentVariables;
}
 

import org.kuali.rice.kew.engine.node.Branch; //导入依赖的package包/类
public Branch createBranch(String name, Branch parentBranch, RouteNodeInstance initialNodeInstance) {
    Branch branch = new Branch();
    branch.setName(name);
    branch.setParentBranch(parentBranch);
    branch.setInitialNode(initialNodeInstance);
    initialNodeInstance.setBranch(branch);
    return branch;
}
 

import org.kuali.rice.kew.engine.node.Branch; //导入依赖的package包/类
/**
    * Queries the list of revoked node instances from the root BranchState of the Document
    * and returns a List of revoked RouteNodeInstances.
    */
public List getRevokedNodeInstances(DocumentRouteHeaderValue document) {
	if (document == null) {
   		throw new IllegalArgumentException("Document must not be null.");
   	}
	List<RouteNodeInstance> revokedNodeInstances = new ArrayList<RouteNodeInstance>();

   	Branch rootBranch = document.getRootBranch();
   	BranchState state = null;
   	if (rootBranch != null) {
   	    state = rootBranch.getBranchState(REVOKED_NODE_INSTANCES_STATE_KEY);
   	}
   	if (state == null || org.apache.commons.lang.StringUtils.isEmpty(state.getValue())) {
   		return revokedNodeInstances;
   	}
   	String[] revokedNodes = state.getValue().split(",");
   	for (int index = 0; index < revokedNodes.length; index++) {
		String revokedNodeInstanceId = revokedNodes[index];
		RouteNodeInstance revokedNodeInstance = findRouteNodeInstanceById(revokedNodeInstanceId);
		if (revokedNodeInstance == null) {
			LOG.warn("Could not locate revoked RouteNodeInstance with the given id: " + revokedNodeInstanceId);
		} else {
			revokedNodeInstances.add(revokedNodeInstance);
		}
	}
   	return revokedNodeInstances;
}
 

import org.kuali.rice.kew.engine.node.Branch; //导入依赖的package包/类
/**
 * Convenience method that returns the branch of the first (and presumably only?) initial node
 * @return the branch of the first (and presumably only?) initial node
 */
public Branch getRootBranch() {
    if (!this.initialRouteNodeInstances.isEmpty()) {
        return getInitialRouteNodeInstance(0).getBranch();
    }
    return null;
}
 

import org.kuali.rice.kew.engine.node.Branch; //导入依赖的package包/类
/**
 * Looks up a variable (embodied in a "BranchState" key/value pair) in the
 * branch state table.
 */
private BranchState findVariable(String name) {
    Branch rootBranch = getRootBranch();
    if (rootBranch != null) {
        List<BranchState> branchState = rootBranch.getBranchState();
        Iterator<BranchState> it = branchState.iterator();
        while (it.hasNext()) {
            BranchState state = it.next();
            if (ObjectUtils.equals(state.getKey(), BranchState.VARIABLE_PREFIX + name)) {
                return state;
            }
        }
    }
    return null;
}
 

import org.kuali.rice.kew.engine.node.Branch; //导入依赖的package包/类
@Test
public void testBranchState() throws Exception {
    Branch branch = setupRouteBranch();
    branch = setupRouteBranchState(branch);
    assertTrue("BranchState persisted", branch != null &&
           branch.getBranchState() != null &&
                StringUtils.isNotBlank(branch.getBranchState().get(0).getBranchStateId()));
    branch= KradDataServiceLocator.getDataObjectService().find(
            Branch.class,branch.getBranchId());
    assertTrue("BranchState fetched",branch != null && branch.getBranchState().get(0) != null);

}
 

import org.kuali.rice.kew.engine.node.Branch; //导入依赖的package包/类
private Branch setupRouteBranchState(Branch branch){
    BranchState bs = new BranchState();
    bs.setKey("KEY");
    bs.setValue("VAL");
    bs.setBranch(branch);

    branch.getBranchState().add(bs);
    return KradDataServiceLocator.getDataObjectService().save(branch);
}
 

import org.kuali.rice.kew.engine.node.Branch; //导入依赖的package包/类
/**
 * This overridden method ...
 * 
 * @see org.kuali.rice.kew.engine.node.dao.BranchDAO#save(org.kuali.rice.kew.engine.node.Branch)
 */
public void save(Branch branch) {
	  if (branch.getBranchId() == null) {
            entityManager.persist(branch);
        } else {
            OrmUtils.merge(entityManager, branch);
        }

}
 

import org.kuali.rice.kew.engine.node.Branch; //导入依赖的package包/类
public void save(Branch branch) {   	
	if (branch.getBranchId() == null){
		entityManager.persist(branch);
	} else {
		OrmUtils.merge(entityManager, branch);
	}
}
 

import org.kuali.rice.kew.engine.node.Branch; //导入依赖的package包/类
/**
    * Queries the list of revoked node instances from the root BranchState of the Document
    * and returns a List of revoked RouteNodeInstances.
    */
public List getRevokedNodeInstances(DocumentRouteHeaderValue document) {
	if (document == null) {
   		throw new IllegalArgumentException("Document must not be null.");
   	}
	List<RouteNodeInstance> revokedNodeInstances = new ArrayList<RouteNodeInstance>();
   	
   	Branch rootBranch = document.getRootBranch();
   	BranchState state = null;
   	if (rootBranch != null) {
   	    state = rootBranch.getBranchState(REVOKED_NODE_INSTANCES_STATE_KEY);
   	}
   	if (state == null || org.apache.commons.lang.StringUtils.isEmpty(state.getValue())) {
   		return revokedNodeInstances;
   	}
   	String[] revokedNodes = state.getValue().split(",");
   	for (int index = 0; index < revokedNodes.length; index++) {
		String revokedNodeInstanceId = revokedNodes[index];
		RouteNodeInstance revokedNodeInstance = findRouteNodeInstanceById(revokedNodeInstanceId);
		if (revokedNodeInstance == null) {
			LOG.warn("Could not locate revoked RouteNodeInstance with the given id: " + revokedNodeInstanceId);
		} else {
			revokedNodeInstances.add(revokedNodeInstance);
		}
	}
   	return revokedNodeInstances;
}
 

import org.kuali.rice.kew.engine.node.Branch; //导入依赖的package包/类
/**
 * Convenience method that returns the branch of the first (and presumably only?) initial node
 * @return the branch of the first (and presumably only?) initial node
 */
public Branch getRootBranch() {
    if (!this.initialRouteNodeInstances.isEmpty()) {
        return ((RouteNodeInstance) getInitialRouteNodeInstance(0)).getBranch();
    } 
    return null;
}
 

import org.kuali.rice.kew.engine.node.Branch; //导入依赖的package包/类
/**
* helper method for {@link #importRouteNodeInstanceDTO(org.kuali.rice.kew.api.document.node.RouteNodeInstance)} which does all
* the work.  The public method just wraps this one but hides the returned RouteNodeInstance,
* which is used for the recursive call to populate the nextNodeInstanceS inside our 
* RouteNodeInstanceS.
* 
* @param nodeInstanceDTO
* @return
*/
 	private RouteNodeInstance _importRouteNodeInstanceDTO(org.kuali.rice.kew.api.document.node.RouteNodeInstance nodeInstanceDTO) {
 		if (nodeInstanceDTO == null) {
 			return null;
 		}
 		RouteNodeInstance nodeInstance = new RouteNodeInstance();
 		nodeInstance.setActive(nodeInstanceDTO.isActive());

 		nodeInstance.setComplete(nodeInstanceDTO.isComplete());
 		nodeInstance.setDocumentId(nodeInstanceDTO.getDocumentId());
 		nodeInstance.setInitial(nodeInstanceDTO.isInitial());

 		Branch branch = getBranch(nodeInstanceDTO.getBranchId());
 		nodeInstance.setBranch(branch);

 		if (nodeInstanceDTO.getRouteNodeId() != null) {
 			RouteNode routeNode = routeNodeService.findRouteNodeById(nodeInstanceDTO.getRouteNodeId());

 			if (routeNode == null) {
 				routeNode = getRouteNode(nodeInstanceDTO.getRouteNodeId());
 				routeNode.setNodeType(nodeInstanceDTO.getName());
 			}

 			nodeInstance.setRouteNode(routeNode);

 			if (routeNode.getBranch() != null) {
     			branch.setName(routeNode.getBranch().getName());
     		} 
 		}

 		RouteNodeInstance process = getRouteNodeInstance(nodeInstanceDTO.getProcessId());
 		nodeInstance.setProcess(process);

 		nodeInstance.setRouteNodeInstanceId(nodeInstanceDTO.getId());

 		List<NodeState> nodeState = new ArrayList<NodeState>();
 		if (nodeInstanceDTO.getState() != null) {
	for (RouteNodeInstanceState stateDTO : nodeInstanceDTO.getState()) {
		NodeState state = getNodeState(stateDTO.getId());
		if (state != null) {
			state.setKey(stateDTO.getKey());
			state.setValue(stateDTO.getValue());
			state.setStateId(stateDTO.getId());
			state.setNodeInstance(nodeInstance);
			nodeState.add(state);
		}
	}
}
 		nodeInstance.setState(nodeState);

 		List<RouteNodeInstance> nextNodeInstances = new ArrayList<RouteNodeInstance>();


 		for (org.kuali.rice.kew.api.document.node.RouteNodeInstance nextNodeInstanceVO : nodeInstanceDTO.getNextNodeInstances()) {
 			// recurse to populate nextNodeInstances
 			nextNodeInstances.add(_importRouteNodeInstanceDTO(nextNodeInstanceVO));
 		}
         nodeInstance.setNextNodeInstances(nextNodeInstances);

 		routeNodeInstances.put(nodeInstance.getRouteNodeInstanceId(), nodeInstance);
 		return nodeInstance;
 	}