Java DocumentRouteHeaderValue.getDocumentId方法代码示例

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入方法依赖的package包/类
@Override
@SuppressWarnings("unchecked")
   public List<WatchedDocument> getWatchedDocuments(final String principalId) {
       try {
           List<DocumentRouteHeaderValue> documentRouteHeaderValues =  getEntityManager().createNamedQuery(
                   QuickLinksDAOJpa.FIND_WATCHED_DOCUMENTS_BY_INITIATOR_WORKFLOW_ID_NAME).
                   setParameter("initiatorWorkflowId", principalId).getResultList();
           List<WatchedDocument> watchedDocuments = new ArrayList<WatchedDocument>();
           for(DocumentRouteHeaderValue documentRouteHeader : documentRouteHeaderValues){
               WatchedDocument watchedDocument = new WatchedDocument(documentRouteHeader.getDocumentId(),
                       documentRouteHeader.getDocRouteStatusLabel(),documentRouteHeader.getDocTitle());
               watchedDocuments.add(watchedDocument);
           }
           return watchedDocuments;
       } catch (Exception e) {
           throw new WorkflowRuntimeException("Error getting watched documents for user: " + principalId, e);
       }
   }
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入方法依赖的package包/类
public static EDLController createEDLController(EDocLiteAssociation edlAssociation, EDLGlobalConfig edlGlobalConfig, DocumentRouteHeaderValue document) {
	EDLController edlController = createEDLController(edlAssociation, edlGlobalConfig);
	try {
		Document defaultDom = edlController.getDefaultDOM();
		Document documentDom = XmlHelper.readXml(document.getDocContent());
		// get the data node and import it into our default DOM
		Element documentData = (Element) documentDom.getElementsByTagName(EDLXmlUtils.DATA_E).item(0);
		if (documentData != null) {
			Element defaultDomEDL = EDLXmlUtils.getEDLContent(defaultDom, false);
			Element defaultDomData = (Element) defaultDomEDL.getElementsByTagName(EDLXmlUtils.DATA_E).item(0);
			defaultDomEDL.replaceChild(defaultDom.importNode(documentData, true), defaultDomData);
		}
		if (LOG.isDebugEnabled()) {
			LOG.debug("Created default Node from document id " + document.getDocumentId() + " content " + XmlJotter.jotNode(defaultDom));
		}
	} catch (Exception e) {
		throw new WorkflowRuntimeException("Problems creating controller for EDL " + edlAssociation.getEdlName() + " document " + document.getDocumentId(), e);
	}
	return edlController;
}
 

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 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.routeheader.DocumentRouteHeaderValue; //导入方法依赖的package包/类
/**
 * Activates the action requests that are pending at this routelevel of the
 * document. The requests are processed by priority and then request ID. It
 * is implicit in the access that the requests are activated according to
 * the route level above all.
 * <p>
 * FYI and acknowledgment requests do not cause the processing to stop. Only
 * action requests for approval or completion cause the processing to stop
 * and then only for route level with a serialized activation policy. Only
 * requests at the current document's current route level are activated.
 * Inactive requests at a lower level cause a routing exception.
 * <p>
 * Exception routing and adhoc routing are processed slightly differently.
 *
 * @return True if the any approval actions were activated.
 * @throws org.kuali.rice.kew.api.exception.ResourceUnavailableException
 * @throws WorkflowException
 */
public boolean activateRequests(RouteContext context, DocumentRouteHeaderValue document,
        RouteNodeInstance nodeInstance) throws WorkflowException {
    MDC.put("docId", document.getDocumentId());
    PerformanceLogger performanceLogger = new PerformanceLogger(document.getDocumentId());
    List<ActionItem> generatedActionItems = new ArrayList<ActionItem>();
    List<ActionRequestValue> requests = new ArrayList<ActionRequestValue>();
    if (context.isSimulation()) {
        for (ActionRequestValue ar : context.getDocument().getActionRequests()) {
            // TODO logic check below duplicates behavior of the ActionRequestService.findPendingRootRequestsByDocIdAtRouteNode(documentId, routeNodeInstanceId) method
            if (ar.getCurrentIndicator()
                    && (ActionRequestStatus.INITIALIZED.getCode().equals(ar.getStatus())
                    || ActionRequestStatus.ACTIVATED.getCode().equals(ar.getStatus()))
                    && ar.getNodeInstance().getRouteNodeInstanceId().equals(nodeInstance.getRouteNodeInstanceId())
                    && ar.getParentActionRequest() == null) {
                requests.add(ar);
            }
        }
        requests.addAll(context.getEngineState().getGeneratedRequests());
    } else {
        requests = KEWServiceLocator.getActionRequestService().findPendingRootRequestsByDocIdAtRouteNode(
                document.getDocumentId(), nodeInstance.getRouteNodeInstanceId());
    }
    if (LOG.isDebugEnabled()) {
        LOG.debug("Pending Root Requests " + requests.size());
    }
    boolean activatedApproveRequest = activateRequestsCustom(context, requests, generatedActionItems, document,
            nodeInstance);

    // now let's send notifications, since this code needs to be able to activate each request individually, we need
    // to collection all action items and then notify after all have been generated
    notify(context, generatedActionItems, nodeInstance);

    performanceLogger.log("Time to activate requests.");
    return activatedApproveRequest;
}
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入方法依赖的package包/类
public void deleteDocument(String principalId, DocumentRouteHeaderValue routeHeader) throws WorkflowException {
	if (routeHeader.getDocumentId() == null) {
		LOG.debug("Null Document id passed.");
		throw new WorkflowException("Document id must not be null.");
	}
	KEWServiceLocator.getRouteHeaderService().deleteRouteHeader(routeHeader);
}
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入方法依赖的package包/类
/**
 * Implements {@link org.kuali.rice.kew.doctype.service.DocumentTypePermissionService#canRoute(String, org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue)}
 */
public boolean canRoute(String principalId, DocumentRouteHeaderValue document) {
    validatePrincipalId(principalId);
    validateDocument(document);
    String documentId = document.getDocumentId();
    DocumentType documentType = document.getDocumentType();
    String documentStatus = document.getDocRouteStatus();
    String initiatorPrincipalId = document.getInitiatorWorkflowId();
    validateDocumentType(documentType);
    validateDocumentStatus(documentStatus);
    validatePrincipalId(initiatorPrincipalId);

    if (!documentType.isPolicyDefined(org.kuali.rice.kew.api.doctype.DocumentTypePolicy.INITIATOR_MUST_ROUTE)) {
        Map<String, String> permissionDetails = buildDocumentTypePermissionDetails(documentType, documentStatus, null, null);
        Map<String, String> roleQualifiers = buildDocumentRoleQualifiers(document, permissionDetails.get(KewApiConstants.ROUTE_NODE_NAME_DETAIL));

        if (LOG.isDebugEnabled()) {
            LOG.debug("Permission details values: " + permissionDetails);
            LOG.debug("Role qualifiers values: " + roleQualifiers);
        }
        if (useKimPermission(KewApiConstants.KEW_NAMESPACE, KewApiConstants.ROUTE_PERMISSION, permissionDetails, true)) {
            return getPermissionService().isAuthorizedByTemplate(principalId, KewApiConstants.KEW_NAMESPACE,
                    KewApiConstants.ROUTE_PERMISSION, permissionDetails, roleQualifiers);
        }
    }

    if (documentType.getInitiatorMustRoutePolicy().getPolicyValue()) {
        return executeInitiatorPolicyCheck(principalId, initiatorPrincipalId, documentStatus);
    }
    return true;
}
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入方法依赖的package包/类
/**
 * Implements {@link org.kuali.rice.kew.doctype.service.DocumentTypePermissionService#canSave(String, org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue)}
 */
public boolean canSave(String principalId, DocumentRouteHeaderValue document) {
    validatePrincipalId(principalId);
    validateDocument(document);
    String documentId = document.getDocumentId();
    DocumentType documentType = document.getDocumentType();
    String documentStatus = document.getDocRouteStatus();
    String initiatorPrincipalId = document.getInitiatorWorkflowId();
    List<String> routeNodeNames = document.getCurrentNodeNames();
    validateDocumentType(documentType);
    validateRouteNodeNames(routeNodeNames);
    validateDocumentStatus(documentStatus);
    validatePrincipalId(initiatorPrincipalId);

    if (!documentType.isPolicyDefined(org.kuali.rice.kew.api.doctype.DocumentTypePolicy.INITIATOR_MUST_SAVE)) {
        List<Map<String, String>> permissionDetailList = buildDocumentTypePermissionDetailsForNodes(documentType, routeNodeNames, documentStatus, null);

        boolean foundAtLeastOnePermission = false;
        // loop over permission details, only one of them needs to be authorized
        for (Map<String, String> permissionDetails : permissionDetailList) {
            Map<String, String> roleQualifiers = buildDocumentRoleQualifiers(document, permissionDetails.get(KewApiConstants.ROUTE_NODE_NAME_DETAIL));
            if (useKimPermission(KewApiConstants.KEW_NAMESPACE, KewApiConstants.SAVE_PERMISSION, permissionDetails, true)) {
                foundAtLeastOnePermission = true;
                if (getPermissionService().isAuthorizedByTemplate(principalId, KewApiConstants.KEW_NAMESPACE,
                        KewApiConstants.SAVE_PERMISSION, permissionDetails, roleQualifiers)) {
                    return true;
                }
            }
        }
        // if we found defined KIM permissions, but not of them have authorized this user, return false
        if (foundAtLeastOnePermission) {
            return false;
        }
    }

    if (documentType.getInitiatorMustSavePolicy().getPolicyValue()) {
        return executeInitiatorPolicyCheck(principalId, initiatorPrincipalId, documentStatus);
    }
    return true;
}
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入方法依赖的package包/类
@Override
public boolean canAddRouteLogMessage(String principalId, DocumentRouteHeaderValue document) {
    validatePrincipalId(principalId);
    validateDocument(document);
    String documentId = document.getDocumentId();
    DocumentType documentType = document.getDocumentType();
    String documentStatus = document.getDocRouteStatus();
    String initiatorPrincipalId = document.getInitiatorWorkflowId();
    validateDocumentType(documentType);
    validateDocumentStatus(documentStatus);
    validatePrincipalId(initiatorPrincipalId);

    Map<String, String> permissionDetails = buildDocumentTypePermissionDetails(documentType, documentStatus, null, null);
    Map<String, String> roleQualifiers = buildDocumentRoleQualifiers(document, permissionDetails.get(KewApiConstants.ROUTE_NODE_NAME_DETAIL));

    if (LOG.isDebugEnabled()) {
        LOG.debug("Permission details values: " + permissionDetails);
        LOG.debug("Role qualifiers values: " + roleQualifiers);
    }

    if (useKimPermission(KewApiConstants.KEW_NAMESPACE, KewApiConstants.ADD_MESSAGE_TO_ROUTE_LOG, permissionDetails, false)) {
        return getPermissionService().isAuthorizedByTemplate(principalId, KewApiConstants.KEW_NAMESPACE,
                KewApiConstants.ADD_MESSAGE_TO_ROUTE_LOG, permissionDetails, roleQualifiers);
    }

    return false;
}
 

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包/类
@Override
	public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
        DocHandlerForm docHandlerForm = (DocHandlerForm) form;

        String docHandler = null;

        if (request.getParameter(KewApiConstants.DOCUMENT_ID_PARAMETER) != null) {
            RouteHeaderService rhSrv = (RouteHeaderService) KEWServiceLocator.getService(KEWServiceLocator.DOC_ROUTE_HEADER_SRV);
            DocumentRouteHeaderValue routeHeader = rhSrv.getRouteHeader(docHandlerForm.getDocId());

            if (!KEWServiceLocator.getDocumentSecurityService().routeLogAuthorized(GlobalVariables.getUserSession().getPrincipalId(), routeHeader, new SecuritySession(GlobalVariables.getUserSession().getPrincipalId()))) {
            	return mapping.findForward("NotAuthorized");
            }
            docHandler = routeHeader.getDocumentType().getResolvedDocumentHandlerUrl();
            if (StringUtils.isBlank(docHandler)) {
                throw new WorkflowRuntimeException("Document Type '" + routeHeader.getDocumentType().getName() + "' does not have a document handler url set (attempted to open document handler url for document id " + routeHeader.getDocumentId() + ")");
            }
            if (!docHandler.contains("?")) {
                docHandler += "?";
            } else {
                docHandler += "&";
            }
            docHandler += KewApiConstants.DOCUMENT_ID_PARAMETER + "=" + docHandlerForm.getDocId();
            if (StringUtils.isNotBlank(routeHeader.getAppDocId())) {
                docHandler += "&" + KewApiConstants.APP_DOC_ID_PARAMETER + "=" + URLEncoder.encode(routeHeader.getAppDocId(), "UTF-8");
            }
        } else if (request.getParameter(KewApiConstants.DOCTYPE_PARAMETER) != null) {
            DocumentTypeService documentTypeService = (DocumentTypeService) KEWServiceLocator.getService(KEWServiceLocator.DOCUMENT_TYPE_SERVICE);
            DocumentType documentType = documentTypeService.findByName(docHandlerForm.getDocTypeName());
            docHandler = documentType.getResolvedDocumentHandlerUrl();
            if (StringUtils.isBlank(docHandler)) {
                throw new WorkflowRuntimeException("Cannot find document handler url for document type '" + documentType.getName() + "'");
            }
            if (!docHandler.contains("?")) {
                docHandler += "?";
            } else {
                docHandler += "&";
            }
            docHandler += KewApiConstants.DOCTYPE_PARAMETER + "=" + docHandlerForm.getDocTypeName();
        } else {
//TODO what should happen here if parms are missing; no proper ActionForward from here
            throw new RuntimeException ("Cannot determine document handler");
        }

        docHandler += "&" + KewApiConstants.COMMAND_PARAMETER + "=" + docHandlerForm.getCommand();
        if (getUserSession(request).isBackdoorInUse()) {
            docHandler += "&" + KewApiConstants.BACKDOOR_ID_PARAMETER + "=" + getUserSession(request).getPrincipalName();
        }
        return new ActionForward(docHandler, true);
    }
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入方法依赖的package包/类
/**
	 * @see org.kuali.rice.kew.engine.node.RequestsNode#processCustom(org.kuali.rice.kew.engine.RouteContext, org.kuali.rice.kew.engine.RouteHelper)
	 */
	@Override
	protected boolean processCustom(RouteContext routeContext, RouteHelper routeHelper) throws Exception {
		DocumentRouteHeaderValue document = routeContext.getDocument();
		RouteNodeInstance nodeInstance = routeContext.getNodeInstance();
		RouteNode node = nodeInstance.getRouteNode();
		// while no routable actions are activated and there are more
		// routeLevels to process
		if ( nodeInstance.isInitial() ) {
			if ( LOG.isDebugEnabled() ) {
				LOG.debug( "RouteHeader info inside routing loop\n"
						+ ClassDumper.dumpFields( routeContext.getDocument() ) );
				LOG.debug( "Looking for new actionRequests - routeLevel: "
						+ node.getRouteNodeName() );
			}
			boolean suppressPolicyErrors = isSuppressingPolicyErrors(routeContext);
			List<ActionRequestValue> requests = getNewActionRequests( routeContext );
// Debugging code to force an empty action request				
//				if ( document.getDocumentType().getName().equals( "SACC" ) ) {
//					LOG.fatal( "DEBUGGING CODE IN PLACE - SACC DOCUMENT ACTION REQUESTS CLEARED" );
//					requests.clear();
//				}
			// for mandatory routes, requests must be generated
			if ( requests.isEmpty() && !suppressPolicyErrors) {
				Responsibility resp = getFirstResponsibilityWithMandatoryRouteFlag( document, node );
				if ( resp != null ) {
					throw new RouteManagerException( "No requests generated for KIM Responsibility-based mandatory route.\n" +
							"Document Id:    " + document.getDocumentId() + "\n" +
							"DocumentType:   " + document.getDocumentType().getName() + "\n" +
							"Route Node:     " + node.getRouteNodeName() + "\n" + 
							"Responsibility: " + resp,
							routeContext );
				}
			}
			// determine if we have any approve requests for FinalApprover
			// checks
			if ( !suppressPolicyErrors ) {				
				verifyFinalApprovalRequest( document, requests, nodeInstance, routeContext );
			}
		}
		return true; // to indicate custom processing performed
	}
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入方法依赖的package包/类
/**
 * Activates the action requests that are pending at this routelevel of the document. The requests are processed by priority and then request ID.
 * It is implicit in the access that the requests are activated according to the route level above all.
 * <p>
 * FYI and acknowledgement requests do not cause the processing to stop. Only action requests for approval or completion cause the processing to
 * stop and then only for route level with a serialized activation policy. Only requests at the current document's current route level are activated.
 * Inactive requests at a lower level cause a routing exception.
 * <p>
 * Exception routing and adhoc routing are processed slightly differently.
 * 
 * 
 * @param context the RouteContext
 * @param document the document we are processing
 * @param nodeInstance the node instance we are processing
 * @return True if the any blocking actions requests (approve or complete) were activated.
 * @throws org.kuali.rice.kew.api.exception.ResourceUnavailableException
 * @throws org.kuali.rice.kew.api.exception.WorkflowException
 */
private boolean activateRequests(RouteContext context, DocumentRouteHeaderValue document, RouteNodeInstance nodeInstance) throws WorkflowException {
    MDC.put("docId", document.getDocumentId());
    PerformanceLogger performanceLogger = new PerformanceLogger(document.getDocumentId());
    List generatedActionItems = new ArrayList();
    List<ActionRequestValue> requests = KEWServiceLocator.getActionRequestService().findPendingRootRequestsByDocIdAtRouteNode(document.getDocumentId(), nodeInstance.getRouteNodeInstanceId());
    if (context.isSimulation()) {
        requests.addAll(context.getEngineState().getGeneratedRequests());
    }
    // this will sort higher priority requests to the front
    // blocking requests are higher priority, so all blocking requests will be
    // activated before non-blocking requests
    Collections.sort(requests, new Utilities.PrioritySorter());
    LOG.info("Pending Root Requests " + requests.size());
    String activationType = nodeInstance.getRouteNode().getActivationType();
    boolean isParallel = KewApiConstants.ROUTE_LEVEL_PARALLEL.equals(activationType);
    boolean activatedApproveRequest = false;
    for (Iterator iter = requests.iterator(); iter.hasNext();) {
        if (activatedApproveRequest && !isParallel) {
            LOG.info("Already activated an apprve request and serial, so not activating any more");
            break;
        }
        ActionRequestValue request = (ActionRequestValue) iter.next();
        LOG.info("ActionRequestValue: " + request);
        if (request.getParentActionRequest() != null || request.getNodeInstance() == null) {
            // 1. disregard request if it's not a top-level request
            // 2. disregard request if it's a "future" request and hasn't been attached to a node instance yet
            continue; 
        }
        if (request.isActive()) {
            activatedApproveRequest = activatedApproveRequest || request.isApproveOrCompleteRequest();
            continue;
        }
        logProcessingMessage(request);   
        LOG.info("Activating request. " + request);
        activatedApproveRequest = activateRequest(context, request, nodeInstance, generatedActionItems) || activatedApproveRequest;
    }
    // now let's send notifications, since this code needs to be able to activate each request individually, we need
    // to collection all action items and then notify after all have been generated
    if (!context.isSimulation()) {
        KEWServiceLocator.getNotificationService().notify(generatedActionItems);
    }
    performanceLogger.log("Time to activate requests.");
    return activatedApproveRequest;
}
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入方法依赖的package包/类
public DocumentRouteHeaderValue createDocument(String principalId, DocumentRouteHeaderValue routeHeader) throws WorkflowException {

		if (routeHeader.getDocumentId() != null) { // this is a debateable
														// check - means the
														// client is off
			throw new InvalidActionTakenException("Document already has a Document id");
		}
		Principal principal = loadPrincipal(principalId);
		boolean canInitiate = KEWServiceLocator.getDocumentTypePermissionService().canInitiate(principalId, routeHeader.getDocumentType());

		if (!canInitiate) {
			throw new InvalidActionTakenException("Principal with name '" + principal.getPrincipalName() + "' is not authorized to initiate documents of type '" + routeHeader.getDocumentType().getName());
		}

        if (!routeHeader.getDocumentType().isDocTypeActive()) {
            // don't allow creation if document type is inactive
            throw new IllegalDocumentTypeException("Document type '" + routeHeader.getDocumentType().getName() + "' is inactive");
        }

		routeHeader.setInitiatorWorkflowId(principalId);
		if (routeHeader.getDocRouteStatus() == null) {
			routeHeader.setDocRouteStatus(KewApiConstants.ROUTE_HEADER_INITIATED_CD);
		}
		if (routeHeader.getDocRouteLevel() == null) {
			routeHeader.setDocRouteLevel(Integer.valueOf(KewApiConstants.ADHOC_ROUTE_LEVEL));
		}
		if (routeHeader.getCreateDate() == null) {
			routeHeader.setCreateDate(new Timestamp(new Date().getTime()));
		}
		if (routeHeader.getDocVersion() == null) {
			routeHeader.setDocVersion(Integer.valueOf(KewApiConstants.DocumentContentVersions.CURRENT));
		}
		if (routeHeader.getDocContent() == null) {
			routeHeader.setDocContent(KewApiConstants.DEFAULT_DOCUMENT_CONTENT);
		}
		routeHeader.setDateModified(new Timestamp(new Date().getTime()));
		routeHeader = KEWServiceLocator.getRouteHeaderService().saveRouteHeader(routeHeader);
		OrchestrationConfig config = new OrchestrationConfig(EngineCapability.STANDARD);
		KEWServiceLocator.getWorkflowEngineFactory().newEngine(config).initializeDocument(routeHeader);
		routeHeader = KEWServiceLocator.getRouteHeaderService().saveRouteHeader(routeHeader);
		return routeHeader;
	}
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入方法依赖的package包/类
/**
 * Implements {@link org.kuali.rice.kew.doctype.service.DocumentTypePermissionService#canCancel(String, org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue)}
 */
public boolean canCancel(String principalId, DocumentRouteHeaderValue document) {
    validatePrincipalId(principalId);
    validateDocument(document);
    String documentId = document.getDocumentId();
    DocumentType documentType = document.getDocumentType();
    String documentStatus = document.getDocRouteStatus();
    String initiatorPrincipalId = document.getInitiatorWorkflowId();
    List<String> routeNodeNames = document.getCurrentNodeNames();
    validateDocumentType(documentType);
    validateRouteNodeNames(routeNodeNames);
    validateDocumentStatus(documentStatus);
    validatePrincipalId(initiatorPrincipalId);

    if (!documentType.isPolicyDefined(org.kuali.rice.kew.api.doctype.DocumentTypePolicy.INITIATOR_MUST_CANCEL)) {
        List<Map<String, String>> permissionDetailList = buildDocumentTypePermissionDetailsForNodes(documentType, routeNodeNames, documentStatus, null);

        boolean foundAtLeastOnePermission = false;
        // loop over permission details, only one of them needs to be authorized
        for (Map<String, String> permissionDetails : permissionDetailList) {
            Map<String, String> roleQualifiers = buildDocumentRoleQualifiers(document, permissionDetails.get(KewApiConstants.ROUTE_NODE_NAME_DETAIL));
            if (useKimPermission(KewApiConstants.KEW_NAMESPACE, KewApiConstants.CANCEL_PERMISSION, permissionDetails, true)) {
                foundAtLeastOnePermission = true;
                if (getPermissionService().isAuthorizedByTemplate(principalId, KewApiConstants.KEW_NAMESPACE,
                        KewApiConstants.CANCEL_PERMISSION, permissionDetails, roleQualifiers)) {
                    return true;
                }
            }
        }
        // if we found defined KIM permissions, but not of them have authorized this user, return false
        if (foundAtLeastOnePermission) {
            return false;
        }
    }

    if (documentType.getInitiatorMustCancelPolicy().getPolicyValue()) {
        return executeInitiatorPolicyCheck(principalId, initiatorPrincipalId, documentStatus);
    } else {
        return true;
    }
}