Java DocumentRouteHeaderValue类代码示例

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入依赖的package包/类
public org.kuali.rice.kew.api.action.ValidActions getValidActions(PrincipalContract principal, DocumentRouteHeaderValue document) {
	try {
		org.kuali.rice.kew.api.action.ValidActions.Builder builder = org.kuali.rice.kew.api.action.ValidActions.Builder.create();
		List<ActionRequestValue> activeRequests = new ArrayList<ActionRequestValue>();
        // this looks like ActionRequestServiceImpl.findAllPendingRequests
		for ( ActionRequestValue ar : document.getActionRequests() ) {
			if ( (ar.getCurrentIndicator() != null && ar.getCurrentIndicator()) && StringUtils.equals( ar.getStatus(), ActionRequestStatus.ACTIVATED.getCode() ) ) {
				activeRequests.add(ar);
			}
		}
		for (String actionTakenCode : actionMap.keySet())
		{
			List<DataDefinition> parameters = new ArrayList<DataDefinition>();
			parameters.add(new DataDefinition(document));
			parameters.add(new DataDefinition(principal));
			ActionTakenEvent actionEvent = createAction(actionTakenCode, parameters);
			if (StringUtils.isEmpty(actionEvent.validateActionRules(activeRequests)))
			{
				builder.addValidAction(ActionType.fromCode(actionTakenCode));
			}
		}
		return builder.build();
	} catch (ResourceUnavailableException e) {
		throw new WorkflowRuntimeException(e);
	}
}
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入依赖的package包/类
@Test
public void testDocumentStatusTransition() throws Exception{
    DocumentRouteHeaderValue documentRouteHeaderValue = setupDocumentRouteHeaderValueWithRouteHeaderAssigned();
    DocumentStatusTransition documentStatusTransition = setupDocumentStatusTransition();
    //Modify status
    documentRouteHeaderValue.getAppDocStatusHistory().add(documentStatusTransition);
    documentStatusTransition.setOldAppDocStatus("R");


    assertTrue("Document Status Transition saved and persisted",
            documentStatusTransition != null && StringUtils.isNotEmpty(
                    documentStatusTransition.getStatusTransitionId()));

    DocumentStatusTransition fetchedVal = KRADServiceLocator.getDataObjectService().
            find(DocumentStatusTransition.class, documentStatusTransition.getStatusTransitionId());
    assertTrue("DocumentStatusTransition fetched after save",fetchedVal != null &&
            StringUtils.equals(fetchedVal.getDocumentId(),fetchedVal.getDocumentId()));

    KRADServiceLocator.getDataObjectService().save(documentRouteHeaderValue);
    DocumentRouteHeaderValue newHeaderVal = KRADServiceLocator.getDataObjectService().find(
            DocumentRouteHeaderValue.class,documentRouteHeaderValue.getDocumentId());

            assertTrue("On fetch app doc history updated", newHeaderVal != null &&
            StringUtils.equals(newHeaderVal.getAppDocStatusHistory().get(0).getOldAppDocStatus(),"R"));
}
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入依赖的package包/类
protected DocumentRouteHeaderValue setupDocumentRouteHeaderValueWithRouteHeaderAssigned(String documentTypeId) {
    DocumentRouteHeaderValue routeHeader = new DocumentRouteHeaderValue();
    routeHeader.setDocumentId(KewDocumentTypeJpaTest.TEST_DOC_ID);
    routeHeader.setAppDocId("Test");
    routeHeader.setApprovedDate(null);
    routeHeader.setCreateDate(new Timestamp(new Date().getTime()));
    routeHeader.setDocContent("test");
    routeHeader.setDocRouteLevel(1);
    routeHeader.setDocRouteStatus(KewApiConstants.ROUTE_HEADER_ENROUTE_CD);
    routeHeader.setDocTitle("Test");
    routeHeader.setDocumentTypeId(documentTypeId);
    routeHeader.setDocVersion(KewApiConstants.DocumentContentVersions.CURRENT);
    routeHeader.setRouteStatusDate(new Timestamp(new Date().getTime()));
    routeHeader.setDateModified(new Timestamp(new Date().getTime()));
    routeHeader.setInitiatorWorkflowId("someone");

    return getDataObjectService().save(routeHeader, PersistenceOption.FLUSH);
}
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入依赖的package包/类
private boolean isDuplicateActionRequestDetected(DocumentRouteHeaderValue routeHeader, RouteNodeInstance nodeInstance, org.kuali.rice.kew.api.rule.RuleResponsibility resp, String qualifiedRoleName) {
	List<ActionRequestValue> requests = getActionRequestService().findByStatusAndDocId(ActionRequestStatus.DONE.getCode(), routeHeader.getDocumentId());
       for (ActionRequestValue request : requests)
       {
           if (((nodeInstance != null
                   && request.getNodeInstance() != null
                   && request.getNodeInstance().getRouteNodeInstanceId().equals(nodeInstance.getRouteNodeInstanceId())
                ) || request.getRouteLevel().equals(routeHeader.getDocRouteLevel())
               )
                   && request.getResponsibilityId().equals(resp.getResponsibilityId())
                       && ObjectUtils.equals(request.getQualifiedRoleName(), qualifiedRoleName)) {
               return true;
           }
       }
	return false;
}
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入依赖的package包/类
private ActionTakenValue createDummyActionTaken(DocumentRouteHeaderValue routeHeader, Person userToPerformAction, String actionToPerform, Recipient delegator) {
      ActionTakenValue val = new ActionTakenValue();
      val.setActionTaken(actionToPerform);
      if (KewApiConstants.ACTION_TAKEN_ROUTED_CD.equals(actionToPerform)) {
          val.setActionTaken(KewApiConstants.ACTION_TAKEN_COMPLETED_CD);
      }
val.setAnnotation("");
val.setDocVersion(routeHeader.getDocVersion());
val.setDocumentId(routeHeader.getDocumentId());
val.setPrincipalId(userToPerformAction.getPrincipalId());

if (delegator != null) {
	if (delegator instanceof KimPrincipalRecipient) {
		val.setDelegatorPrincipalId(((KimPrincipalRecipient) delegator).getPrincipalId());
	} else if (delegator instanceof KimGroupRecipient) {
		Group group = ((KimGroupRecipient) delegator).getGroup();
		val.setDelegatorGroupId(group.getId());
	} else{
		throw new IllegalArgumentException("Invalid Recipient type received: " + delegator.getClass().getName());
	}
}
val.setCurrentIndicator(Boolean.TRUE);
return val;
  }
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入依赖的package包/类
@Test
public void testRouteHeaderInitJoinTable() throws Exception{
    DocumentRouteHeaderValue dv = setupDocumentRouteHeaderValueWithRouteHeaderAssigned();
    DocumentType documentType = setupDocumentType();
    RouteNode rn = setupRouteNode(documentType);
    RouteNodeInstance rni = setupRouteNodeInstance(rn);
    setupInitialRouteNodeInstancesJoinTable(rni.getRouteNodeInstanceId());
    dv = KradDataServiceLocator.getDataObjectService().find(DocumentRouteHeaderValue.class,
            TEST_DOC_ID);

    dv.getInitialRouteNodeInstances().add(rni);


    assertTrue("DocumentRouteHeaderValue fetched correctly with joined instance",dv!= null
            && dv.getInitialRouteNodeInstances() != null && dv.getInitialRouteNodeInstances().get(0)!= null
            && StringUtils.equals(dv.getInitialRouteNodeInstances().get(0).getRouteNodeInstanceId(),
            rni.getRouteNodeInstanceId()));

}
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入依赖的package包/类
/**
 * Applies policies that should get checked prior to transitioning out of this node.  The default implementation of
 * this method checks the "mandatory" policy.
 *
 * @param requestsGenerated the requests generated on the current iteration of the route module
 * @param routeContext the current route context
 */
protected void applyPoliciesOnExit(List<ActionRequestValue> requestsGenerated, RouteContext routeContext) {
    DocumentRouteHeaderValue document = routeContext.getDocument();
    RouteNodeInstance nodeInstance = routeContext.getNodeInstance();
    RouteNode node = nodeInstance.getRouteNode();
    // for mandatory routes, requests must be generated
    if (node.isMandatory() && !isSuppressingPolicyErrors(routeContext) && CollectionUtils.isEmpty(requestsGenerated)) {
        List<ActionRequestValue> actionRequests = KEWServiceLocator.getActionRequestService().findRootRequestsByDocIdAtRouteNode(document.getDocumentId(), nodeInstance.getRouteNodeInstanceId());
        if (actionRequests.isEmpty()) {
            LOG.warn("no requests generated for mandatory route - " + node.getRouteNodeName());
            throw new RouteManagerException(
                "No requests generated for mandatory route " + node.getRouteNodeName() + ":" + node
                        .getRouteMethodName(), routeContext);
        }
    }
}
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入依赖的package包/类
public DocumentRouteHeaderValue saveRoutingData(String principalId, DocumentRouteHeaderValue routeHeader) {
	KEWServiceLocator.getRouteHeaderService().saveRouteHeader(routeHeader);
	
	// save routing data should invoke the post processor doActionTaken for SAVE
	 	ActionTakenValue val = new ActionTakenValue();
	 	val.setActionTaken(KewApiConstants.ACTION_TAKEN_SAVED_CD);
	 	val.setDocumentId(routeHeader.getDocumentId());
       val.setPrincipalId(principalId);
	 	PostProcessor postProcessor = routeHeader.getDocumentType().getPostProcessor();
	 	try {
	 		postProcessor.doActionTaken(new org.kuali.rice.kew.framework.postprocessor.ActionTakenEvent(routeHeader.getDocumentId(), routeHeader.getAppDocId(), ActionTakenValue.to(val)));
	 	} catch (Exception e) {
	 		if (e instanceof RuntimeException) {
	 			throw (RuntimeException)e;
	 		}
	 		throw new WorkflowRuntimeException(e);
	 	}

	 	RouteContext routeContext = RouteContext.getCurrentRouteContext();
	 	if (routeHeader.getDocumentType().hasSearchableAttributes() && !routeContext.isSearchIndexingRequestedForContext()) {
	 		routeContext.requestSearchIndexingForContext();
           DocumentAttributeIndexingQueue queue = KewApiServiceLocator.getDocumentAttributeIndexingQueue(routeHeader.getDocumentType().getApplicationId());
           queue.indexDocument(routeHeader.getDocumentId());
	}
	return finish(routeHeader);
}
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入依赖的package包/类
@Override
public DocumentActionResult takeGroupAuthority(DocumentActionParameters parameters,
        final String groupId) {
    incomingParamCheck(parameters, "parameters");
    incomingParamCheck(groupId, "groupId");
    return executeActionInternal(parameters,
            new StandardDocumentActionCallback() {
                public DocumentRouteHeaderValue doInDocumentBo(DocumentRouteHeaderValue documentBo,
                        String principalId, String annotation) throws WorkflowException {
                    return KEWServiceLocator.getWorkflowDocumentService().takeGroupAuthority(principalId,
                            documentBo, groupId, annotation);
                }

                public String getActionName() {
                    return ActionType.TAKE_GROUP_AUTHORITY.getLabel();
                }
            });
}
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入依赖的package包/类
@Test public void testGetFlattenedNodeInstances() throws Exception {
    WorkflowDocument document = WorkflowDocumentFactory.createDocument(getPrincipalIdForName("ewestfal"), "SeqDocType");
    document.saveDocument("");
    
    DocumentRouteHeaderValue serverDocument = KEWServiceLocator.getRouteHeaderService().getRouteHeader(document.getDocumentId());
    List routeNodeInstances = routeNodeService.getFlattenedNodeInstances(serverDocument, true);
    assertEquals(1, routeNodeInstances.size());
    assertEquals("AdHoc", ((RouteNodeInstance)routeNodeInstances.get(0)).getName());
    
    document.blanketApprove("");
    assertTrue(document.isProcessed());
    
    serverDocument = KEWServiceLocator.getRouteHeaderService().getRouteHeader(document.getDocumentId());
    routeNodeInstances = routeNodeService.getFlattenedNodeInstances(serverDocument, true);
    assertEquals(4, routeNodeInstances.size());
    assertEquals("AdHoc", ((RouteNodeInstance)routeNodeInstances.get(0)).getName());
    assertEquals("WorkflowDocument", ((RouteNodeInstance)routeNodeInstances.get(1)).getName());
    assertEquals("Acknowledge1", ((RouteNodeInstance)routeNodeInstances.get(2)).getName());
    assertEquals("Acknowledge2", ((RouteNodeInstance)routeNodeInstances.get(3)).getName());
}
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入依赖的package包/类
private void buildDelegationGraph(ActionRequestFactory arFactory, RouteContext context, 
		org.kuali.rice.kew.api.rule.Rule delegationRule, DocumentRouteHeaderValue routeHeaderValue, ActionRequestValue parentRequest, RuleDelegation ruleDelegation) {
	context.setActionRequest(parentRequest);
       RuleBaseValues delRuleBo = KEWServiceLocator.getRuleService().getRuleByName(delegationRule.getName());
	if (delegationRule.isActive()) {
           for (org.kuali.rice.kew.api.rule.RuleResponsibility delegationResp : delegationRule.getRuleResponsibilities())
           {
               if (delegationResp.isUsingRole())
               {
                   makeRoleActionRequests(arFactory, context, delegationRule, delegationResp, routeHeaderValue, parentRequest, ruleDelegation);
               } else if (delRuleBo.isMatch(context.getDocumentContent()))
               {
                   makeActionRequest(arFactory, context, delegationRule, routeHeaderValue, delegationResp, parentRequest, ruleDelegation);
               }
           }
	}
}
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入依赖的package包/类
protected void notifyStatusChange(DocumentRouteHeaderValue routeHeader, String newStatusCode, String oldStatusCode) throws InvalidActionTakenException {
    DocumentRouteStatusChange statusChangeEvent = new DocumentRouteStatusChange(routeHeader.getDocumentId(), routeHeader.getAppDocId(), oldStatusCode, newStatusCode);
    try {
        LOG.debug("Notifying post processor of status change "+oldStatusCode+"->"+newStatusCode);
        PostProcessor postProcessor = routeHeader.getDocumentType().getPostProcessor();
        ProcessDocReport report = postProcessor.doRouteStatusChange(statusChangeEvent);
        if (!report.isSuccess()) {
            LOG.warn(report.getMessage(), report.getProcessException());
            throw new InvalidActionTakenException(report.getMessage());
        }
    } catch (Exception ex) {
        LOG.warn(ex, ex);
        throw new WorkflowRuntimeException(ex);
    }
}
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入依赖的package包/类
public DocumentRouteHeaderValue superUserApprove(String principalId, DocumentRouteHeaderValue routeHeader, String annotation, boolean runPostProcessor) throws InvalidActionTakenException {
	init(routeHeader);
	Principal principal = loadPrincipal(principalId);
	new SuperUserApproveEvent(routeHeader, principal, annotation, runPostProcessor).recordAction();
	RouteContext.getCurrentRouteContext().requestSearchIndexingForContext(); // make sure indexing is requested
	indexForSearchAfterActionIfNecessary(routeHeader);
	return finish(routeHeader);
}
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入依赖的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.routeheader.DocumentRouteHeaderValue; //导入依赖的package包/类
public ActionForward moveDocument(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
	try {
		DocumentOperationForm docForm = (DocumentOperationForm) form;
		String principalId = KEWServiceLocator.getIdentityHelperService().getIdForPrincipalName(docForm.getBlanketApproveUser());
		Set<String> nodeNames = new HashSet<String>();
		if (!StringUtils.isBlank(docForm.getBlanketApproveNodes())) {
			String[] nodeNameArray = docForm.getBlanketApproveNodes().split(",");
			for (String nodeName : nodeNameArray) {
				nodeNames.add(nodeName.trim());
			}
		}
           DocumentRouteHeaderValue document = docForm.getRouteHeader();
           String applicationId = document.getDocumentType().getApplicationId();
           DocumentOrchestrationQueue orchestrationQueue = KewApiServiceLocator.getDocumentOrchestrationQueue(
                   document.getDocumentId(), applicationId);
           OrchestrationConfig orchestrationConfig = OrchestrationConfig.create(docForm.getBlanketApproveActionTakenId(), nodeNames);
           DocumentProcessingOptions options = DocumentProcessingOptions.create(true, true, false);
           orchestrationQueue.orchestrateDocument(docForm.getDocumentId(), principalId, orchestrationConfig, options);

           ActionMessages messages = new ActionMessages();
		messages.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage("general.message", "Move Document Processor was successfully scheduled"));
		saveMessages(request, messages);
		return mapping.findForward("basic");
	} catch (Exception e) {
		throw new WorkflowRuntimeException(e);
	}
}