Java RouteContext.setNodeInstance方法代码示例

import org.kuali.rice.kew.engine.RouteContext; //导入方法依赖的package包/类
protected RouteContext establishRouteContext(DocumentRouteHeaderValue document, Throwable throwable) {
	RouteContext routeContext = new RouteContext();
    if (throwable instanceof RouteManagerException) {
        RouteManagerException rmException = (RouteManagerException) throwable;
        routeContext = rmException.getRouteContext();
    } else {
    	routeContext.setDocument(document);
        List<RouteNodeInstance> activeNodeInstances = KEWServiceLocator.getRouteNodeService().getActiveNodeInstances(document.getDocumentId());
        if (!activeNodeInstances.isEmpty()) {
            // take the first active nodeInstance found.
            RouteNodeInstance nodeInstance = (RouteNodeInstance) activeNodeInstances.get(0);
            routeContext.setNodeInstance(nodeInstance);
        }
    }
    if (routeContext.getNodeInstance() == null) {
        // get the initial node instance
        routeContext.setNodeInstance((RouteNodeInstance) document.getInitialRouteNodeInstances().get(0));
    }
    return routeContext;
}
 

import org.kuali.rice.kew.engine.RouteContext; //导入方法依赖的package包/类
/**
 *
 * route level and then filters in the approriate ones.
 */
public void reResolveQualifiedRole(DocumentRouteHeaderValue routeHeader, String roleName, String qualifiedRoleNameLabel) {
    String infoString = "routeHeader="+(routeHeader == null ? null : routeHeader.getDocumentId())+", role="+roleName+", qualifiedRole="+qualifiedRoleNameLabel;
    if (routeHeader == null ||
            org.apache.commons.lang.StringUtils.isEmpty(roleName) ||
            org.apache.commons.lang.StringUtils.isEmpty(qualifiedRoleNameLabel)) {
        throw new IllegalArgumentException("Cannot pass null arguments to reResolveQualifiedRole: "+infoString);
    }
    LOG.debug("Re-resolving qualified role synchronously for "+infoString);
    List<RouteNodeInstance> nodeInstances = findNodeInstances(routeHeader, roleName);
    int requestsGenerated = 0;
    if (!nodeInstances.isEmpty()) {
        deletePendingRoleRequests(routeHeader.getDocumentId(), roleName, qualifiedRoleNameLabel);
        for (RouteNodeInstance nodeInstance : nodeInstances) {
            RuleTemplateBo ruleTemplate = nodeInstance.getRouteNode().getRuleTemplate();
            FlexRM flexRM = new FlexRM();
    		RouteContext context = RouteContext.getCurrentRouteContext();
    		context.setDocument(routeHeader);
    		context.setNodeInstance(nodeInstance);
    		try {
    			List<ActionRequestValue> actionRequests = flexRM.getActionRequests(routeHeader, nodeInstance, ruleTemplate.getName());
                for (ActionRequestValue actionRequest : actionRequests) {
    				if (roleName.equals(actionRequest.getRoleName()) && qualifiedRoleNameLabel.equals(actionRequest.getQualifiedRoleNameLabel())) {
    					actionRequest = KEWServiceLocator.getActionRequestService().initializeActionRequestGraph(actionRequest, routeHeader, nodeInstance);
    					KEWServiceLocator.getActionRequestService().saveActionRequest(actionRequest);
    					requestsGenerated++;
    				}
    			}
    		} catch (Exception e) {
    			RouteContext.clearCurrentRouteContext();
    		}

        }
    }
    LOG.debug("Generated "+requestsGenerated+" action requests after re-resolve: "+infoString);
    requeueDocument(routeHeader);
}
 

import org.kuali.rice.kew.engine.RouteContext; //导入方法依赖的package包/类
public void reResolveRole(DocumentRouteHeaderValue routeHeader, String roleName) {
	String infoString = "routeHeader="+(routeHeader == null ? null : routeHeader.getDocumentId())+", role="+roleName;
    if (routeHeader == null ||
            org.apache.commons.lang.StringUtils.isEmpty(roleName)) {
        throw new RiceIllegalArgumentException("Cannot pass null arguments to reResolveQualifiedRole: "+infoString);
    }
    LOG.debug("Re-resolving role synchronously for "+infoString);
    List<RouteNodeInstance> nodeInstances = findNodeInstances(routeHeader, roleName);
    int requestsGenerated = 0;
    if (!nodeInstances.isEmpty()) {
        deletePendingRoleRequests(routeHeader.getDocumentId(), roleName, null);
        for (RouteNodeInstance nodeInstance : nodeInstances) {
            RuleTemplateBo ruleTemplate = nodeInstance.getRouteNode().getRuleTemplate();
            FlexRM flexRM = new FlexRM();
    		RouteContext context = RouteContext.getCurrentRouteContext();
    		context.setDocument(routeHeader);
    		context.setNodeInstance(nodeInstance);
    		try {
    			List<ActionRequestValue> actionRequests = flexRM.getActionRequests(routeHeader, nodeInstance, ruleTemplate.getName());
                for (ActionRequestValue actionRequest : actionRequests) {
    				if (roleName.equals(actionRequest.getRoleName())) {
    					actionRequest = KEWServiceLocator.getActionRequestService().initializeActionRequestGraph(actionRequest, routeHeader, nodeInstance);
    					KEWServiceLocator.getActionRequestService().saveActionRequest(actionRequest);
    					requestsGenerated++;
    				}
    			}
    		} finally {
    			RouteContext.clearCurrentRouteContext();
    		}
        }
    }
    LOG.debug("Generated "+requestsGenerated+" action requests after re-resolve: "+infoString);
    requeueDocument(routeHeader);
}
 

import org.kuali.rice.kew.engine.RouteContext; //导入方法依赖的package包/类
public List<Rule> selectRules(RouteContext context, DocumentRouteHeaderValue routeHeader, RouteNodeInstance nodeInstance, String selectionCriterion, Timestamp effectiveDate) {
    // for TemplateRuleSelector, the criterion is taken as a ruletemplate name
    final String ruleTemplateName = selectionCriterion;

    Set<MassRuleAttribute> massRules = new HashSet<MassRuleAttribute>();
    RuleTemplate template = KewApiServiceLocator.getRuleService().getRuleTemplateByName(ruleTemplateName);
    if (template == null) {
        throw new WorkflowRuntimeException("Could not locate the rule template with name " + ruleTemplateName + " on document " + routeHeader.getDocumentId());
    }
    for (RuleTemplateAttribute templateAttribute : template.getActiveRuleTemplateAttributes()) {
        String ruleAttributeName = templateAttribute.getRuleAttribute().getName();
        if (!RuleAttribute.isWorkflowAttribute(templateAttribute.getRuleAttribute().getType())) {
            continue;
        }
        ExtensionDefinition extensionDefinition = KewApiServiceLocator.getExtensionRepositoryService().getExtensionByName(ruleAttributeName);
        Object attribute = ExtensionUtils.loadExtension(extensionDefinition);
        if (attribute == null) {
            throw new RiceIllegalArgumentException("Failed to load WorkflowRuleAttribute for: " + extensionDefinition);
        }
        if (!WorkflowRuleAttribute.class.isAssignableFrom(attribute.getClass())) {
            throw new RiceIllegalArgumentException("Failed to locate a WorkflowRuleAttribute with the given name: " + ruleAttributeName);
        }
        if (attribute instanceof XmlConfiguredAttribute) {
            ((XmlConfiguredAttribute)attribute).setExtensionDefinition(extensionDefinition);
        }

        WorkflowRuleAttribute ruleAttribute = (WorkflowRuleAttribute)attribute;
        if (ruleAttribute instanceof MassRuleAttribute) {
            massRules.add((MassRuleAttribute) attribute);
        }

    }

    List<org.kuali.rice.kew.api.rule.Rule> rules;
    if (effectiveDate == null) {
        rules = KewApiServiceLocator.getRuleService()
                .getRulesByTemplateNameAndDocumentTypeName(ruleTemplateName,
                        routeHeader.getDocumentType().getName());
    } else {
        rules = KewApiServiceLocator.getRuleService()
                .getRulesByTemplateNameAndDocumentTypeNameAndEffectiveDate(ruleTemplateName,
                        routeHeader.getDocumentType().getName(), new DateTime(effectiveDate.getTime()));
    }
    numberOfSelectedRules = rules.size();

    // TODO really the route context just needs to be able to support nested create and clears
    // (i.e. a Stack model similar to transaction intercepting in Spring) and we wouldn't have to do this
    if (context.getDocument() == null) {
        context.setDocument(routeHeader);
    }
    if (context.getNodeInstance() == null) {
        context.setNodeInstance(nodeInstance);
    }
    DocumentContent documentContent = context.getDocumentContent();
    PerformanceLogger performanceLogger = new PerformanceLogger();
    // have all mass rule attributes filter the list of non applicable rules
    for (MassRuleAttribute massRuleAttribute : massRules) {
        rules = massRuleAttribute.filterNonMatchingRules(context, rules);
    }
    performanceLogger.log("Time to filter massRules for template " + template.getName());

    List<Rule> ruleList = new ArrayList<Rule>(rules.size());
    for (org.kuali.rice.kew.api.rule.Rule ruleDefinition: rules) {
        ruleList.add(new RuleImpl(ruleDefinition));
    }
    return ruleList;
}
 

import org.kuali.rice.kew.engine.RouteContext; //导入方法依赖的package包/类
/**
 * Generates action requests
 * @param routeHeader the document route header
 * @param routeNodeDef the RouteNode definition of the route node instance
 * @param nodeInstance the route node instance; this may be null!
 * @param ruleTemplateName the rule template
 * @return list of action requests
 * @throws WorkflowException
 */
public List<ActionRequestValue> getActionRequests(DocumentRouteHeaderValue routeHeader, RouteNode routeNodeDef, RouteNodeInstance nodeInstance, String ruleTemplateName) {
	RouteContext context = RouteContext.getCurrentRouteContext();
	// TODO really the route context just needs to be able to support nested create and clears
	// (i.e. a Stack model similar to transaction intercepting in Spring) and we wouldn't have to do this
	if (context.getDocument() == null) {
		context.setDocument(routeHeader);
	}
	if (context.getNodeInstance() == null) {
		context.setNodeInstance(nodeInstance);
	}

	LOG.debug("Making action requests for document " + routeHeader.getDocumentId());

	RuleSelector ruleSelector = loadRuleSelector(routeNodeDef, nodeInstance);

	List<Rule> rules = ruleSelector.selectRules(context, routeHeader, nodeInstance, ruleTemplateName, effectiveDate);

	// XXX: FIXME: this is a special case hack to expose info from the default selection implementation
	// this is used in exactly one place, RoutingReportAction, to make a distinction between no rules being
	// selected, and no rules actually matching when evaluated
	// if (numberOfRules == 0) {
	//   errors.add(new WorkflowServiceErrorImpl("There are no rules.", "routereport.noRules"));
	// } else {
	//   errors.add(new WorkflowServiceErrorImpl("There are rules, but no matches.", "routereport.noMatchingRules"));
	// }
	if (ruleSelector instanceof TemplateRuleSelector) {
		selectedRules += ((TemplateRuleSelector) ruleSelector).getNumberOfSelectedRules();
	}

	PerformanceLogger performanceLogger = new PerformanceLogger();

	ActionRequestFactory arFactory = new ActionRequestFactory(routeHeader, context.getNodeInstance());

	List<ActionRequestValue> actionRequests = new ArrayList<ActionRequestValue>();
	if (rules != null) {
		LOG.info("Total number of rules selected by RuleSelector for documentType=" + routeHeader.getDocumentType().getName() + " and ruleTemplate=" + ruleTemplateName + ": " + rules.size());
		for (Rule rule: rules) {
			RuleExpressionResult result = rule.evaluate(rule, context);
			if (result.isSuccess() && result.getResponsibilities() != null) {
				// actionRequests.addAll(makeActionRequests(context, rule, routeHeader, null, null));
                   org.kuali.rice.kew.api.rule.Rule ruleDef = org.kuali.rice.kew.api.rule.Rule.Builder.create(rule.getDefinition()).build();
				makeActionRequests(arFactory, result.getResponsibilities(), context, ruleDef, routeHeader, null, null);
			}
		}
	}
	actionRequests = new ArrayList<ActionRequestValue>(arFactory.getRequestGraphs());
	performanceLogger.log("Time to make action request for template " + ruleTemplateName);

	return actionRequests;
}