Java DocumentRouteHeaderValue.getDocRouteStatus方法代码示例

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入方法依赖的package包/类
/**
 * Implements {@link org.kuali.rice.kew.doctype.service.DocumentTypePermissionService#canBlanketApprove(String, org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue)}
 */
public boolean canBlanketApprove(String principalId, DocumentRouteHeaderValue document) {
    validatePrincipalId(principalId);
    validateDocument(document);
    DocumentType documentType = document.getDocumentType();
    String initiatorPrincipalId = document.getInitiatorWorkflowId();
    String documentStatus = document.getDocRouteStatus();
    validateDocumentType(documentType);
    validateDocumentStatus(documentStatus);
    validatePrincipalId(initiatorPrincipalId);
    final Boolean result;
    if (documentType.isBlanketApproveGroupDefined()) {
        boolean initiatorAuthorized = true;
        if (documentType.getInitiatorMustBlanketApprovePolicy().getPolicyValue()) {
            initiatorAuthorized = executeInitiatorPolicyCheck(principalId, initiatorPrincipalId, documentStatus);
        }
        result = initiatorAuthorized && documentType.isBlanketApprover(principalId);
    } else {
        Map<String, String> permissionDetails = buildDocumentTypePermissionDetails(documentType, documentStatus, null, null);
        result = getPermissionService().isAuthorizedByTemplate(principalId, KewApiConstants.KEW_NAMESPACE,
                KewApiConstants.BLANKET_APPROVE_PERMISSION, permissionDetails, new HashMap<String, String>());
    }
    return result;
}
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入方法依赖的package包/类
/**
 * End IU Customization
 * @param routeContext
 * @param exceptionRequests
 * @param exceptionMessage
 * @throws Exception
 */

protected DocumentRouteHeaderValue activateExceptionRequests(RouteContext routeContext, List<ActionRequestValue> exceptionRequests, String exceptionMessage, boolean invokePostProcessor) throws Exception {
	setExceptionAnnotations(exceptionRequests, exceptionMessage);
	// TODO is there a reason we reload the document here?
	DocumentRouteHeaderValue rh = KEWServiceLocator.getRouteHeaderService().getRouteHeader(routeContext.getDocument().getDocumentId());
	String oldStatus = rh.getDocRouteStatus();
	rh.setDocRouteStatus(KewApiConstants.ROUTE_HEADER_EXCEPTION_CD);
	if (invokePostProcessor) {
		notifyStatusChange(rh, KewApiConstants.ROUTE_HEADER_EXCEPTION_CD, oldStatus);
	}
	DocumentRouteHeaderValue documentRouteHeaderValue = KEWServiceLocator.getRouteHeaderService().
                                                    saveRouteHeader(rh);
	KEWServiceLocator.getActionRequestService().activateRequests(exceptionRequests);
    return documentRouteHeaderValue;
}
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入方法依赖的package包/类
protected void markDocumentEnroute(DocumentRouteHeaderValue routeHeader) throws InvalidActionTakenException {
    String oldStatus = routeHeader.getDocRouteStatus();
    routeHeader.markDocumentEnroute();

    String newStatus = routeHeader.getDocRouteStatus();
    notifyStatusChange(newStatus, oldStatus);
    DocumentRouteHeaderValue routeHeaderValue = KEWServiceLocator.getRouteHeaderService().
            saveRouteHeader(routeHeader);
    setRouteHeader(routeHeaderValue);
}
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入方法依赖的package包/类
protected void markDocumentEnroute(DocumentRouteHeaderValue routeHeader) throws InvalidActionTakenException {
    String oldStatus = routeHeader.getDocRouteStatus();
    routeHeader.markDocumentEnroute();
    String newStatus = routeHeader.getDocRouteStatus();
    notifyStatusChange(newStatus, oldStatus);
    KEWServiceLocator.getRouteHeaderService().saveRouteHeader(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包/类
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包/类
public void validateRouteHeader(DocumentRouteHeaderValue routeHeader){
    LOG.debug("Enter validateRouteHeader(..)");
    List errors = new ArrayList();

    if (routeHeader.getDocRouteStatus() == null || routeHeader.getDocRouteStatus().trim().equals("")) {
        errors.add(new WorkflowServiceErrorImpl("RouteHeader route status null.", "routeheader.routestatus.empty"));
    } else if (!KewApiConstants.DOCUMENT_STATUSES.containsKey(routeHeader.getDocRouteStatus())){
        errors.add(new WorkflowServiceErrorImpl("RouteHeader route status invalid.", "routeheader.routestatus.invalid"));
    }

    if(routeHeader.getDocRouteLevel() == null || routeHeader.getDocRouteLevel().intValue() < 0){
        errors.add(new WorkflowServiceErrorImpl("RouteHeader route level invalid.", "routeheader.routelevel.invalid"));
    }

    if(routeHeader.getDateLastModified() == null){
        errors.add(new WorkflowServiceErrorImpl("RouteHeader status modification date empty.", "routeheader.statusmoddate.empty"));
    }

    if(routeHeader.getCreateDate() == null){
        errors.add(new WorkflowServiceErrorImpl("RouteHeader status create date empty.", "routeheader.createdate.empty"));
    }
    if(routeHeader.getDocVersion() == null || routeHeader.getDocVersion().intValue() < 0){
        errors.add(new WorkflowServiceErrorImpl("RouteHeader doc version invalid.", "routeheader.docversion.invalid"));
    }

    if (routeHeader.getInitiatorWorkflowId () == null || routeHeader.getInitiatorWorkflowId().trim().equals("")) {
        errors.add(new WorkflowServiceErrorImpl("RouteHeader initiator null.", "routeheader.initiator.empty"));
    }
    else
    {
       	Principal principal = KimApiServiceLocator.getIdentityService().getPrincipal(routeHeader.getInitiatorWorkflowId());
        if(principal == null)
        {
           	errors.add(new WorkflowServiceErrorImpl("RouteHeader initiator id invalid.", "routeheader.initiator.invalid"));
        }
    }

    if(!StringUtils.isBlank(routeHeader.getDocumentTypeId())){
        DocumentType docType = KEWServiceLocator.getDocumentTypeService().findById(routeHeader.getDocumentTypeId());
        if(docType == null){
            errors.add(new WorkflowServiceErrorImpl("RouteHeader document type id invalid.", "routeheader.doctypeid.invalid"));
        }
    }

    LOG.debug("Exit validateRouteHeader(..) ");
    if (!errors.isEmpty()) {
        throw new WorkflowServiceErrorException("RouteHeader Validation Error", errors);
    }
}
 

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;
    }
}
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入方法依赖的package包/类
/**
 * Implements {@link org.kuali.rice.kew.doctype.service.DocumentTypePermissionService#canRecall(String, org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue)}
 */
public boolean canRecall(String principalId, DocumentRouteHeaderValue document) {
    validatePrincipalId(principalId);
    validateDocument(document);
    String documentId = document.getDocumentId();
    DocumentType documentType = document.getDocumentType();
    String documentStatus = document.getDocRouteStatus();
    String appDocStatus = document.getAppDocStatus();
    String initiatorPrincipalId = document.getInitiatorWorkflowId();
    List<String> routeNodeNames = document.getCurrentNodeNames();
    validateDocumentType(documentType);
    validateRouteNodeNames(routeNodeNames);
    validateDocumentStatus(documentStatus);
    // no need to validate appdocstatus, this is a free-form application defined value

    // add appDocStatus to the details
    List<Map<String, String>> permissionDetailList = buildDocumentTypePermissionDetailsForNodes(documentType, routeNodeNames, documentStatus, null);
    if (!StringUtils.isBlank(appDocStatus)) {
        for (Map<String, String> details: permissionDetailList) {
            details.put(KewApiConstants.APP_DOC_STATUS_DETAIL, appDocStatus);
        }
    }

    boolean foundAtLeastOnePermission = false;
    boolean authorizedByPermission = false;
    boolean principalIsInitiator = StringUtils.equals(initiatorPrincipalId, principalId);

    // 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.RECALL_PERMISSION, permissionDetails, false)) {
            if (getPermissionService().isPermissionDefinedByTemplate(KewApiConstants.KEW_NAMESPACE, KewApiConstants.RECALL_PERMISSION, permissionDetails)) {
                foundAtLeastOnePermission = true;
                if (getPermissionService().isAuthorizedByTemplate(principalId, KewApiConstants.KEW_NAMESPACE,
                        KewApiConstants.RECALL_PERMISSION, permissionDetails, roleQualifiers)) {
                    return true;
                }
            }
        }
    }
    if (foundAtLeastOnePermission) {
        return false;
    }
    // alternative could be to only authorize initiator if the permission is omitted
    // (i.e. exclude initiator if the initiator does not have the recall permission)
    return authorizedByPermission;
}