Java DocumentRouteHeaderValue.getDocumentType方法代码示例

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包/类
@Override
public boolean canReceiveAdHocRequest(String principalId, DocumentRouteHeaderValue document, String actionRequestType) {
    validatePrincipalId(principalId);
    validateDocument(document);
    DocumentType documentType = document.getDocumentType();
    validateDocumentType(documentType);
    validateActionRequestType(actionRequestType);
    final Boolean result;

    Map<String, String> permissionDetails = buildDocumentTypePermissionDetails(documentType, null, actionRequestType, null);
    if (useKimPermission(KewApiConstants.KEW_NAMESPACE, KewApiConstants.AD_HOC_REVIEW_PERMISSION, permissionDetails, true)) {
        result = getPermissionService().isAuthorizedByTemplate(principalId, KewApiConstants.KEW_NAMESPACE,
                KewApiConstants.AD_HOC_REVIEW_PERMISSION, permissionDetails, new HashMap<String, String>());
    } else {
        result = Boolean.TRUE;
    }
    return result;
}
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入方法依赖的package包/类
@Override
public boolean canGroupReceiveAdHocRequest(String groupId, DocumentRouteHeaderValue document, String actionRequestType) {
    validateGroupId(groupId);
    validateDocument(document);
    DocumentType documentType = document.getDocumentType();
    validateDocumentType(documentType);
    validateActionRequestType(actionRequestType);

    Boolean result = Boolean.TRUE;
    Map<String, String> permissionDetails = buildDocumentTypePermissionDetails(documentType, null, actionRequestType, null);
    if (useKimPermission(KewApiConstants.KEW_NAMESPACE, KewApiConstants.AD_HOC_REVIEW_PERMISSION, permissionDetails, true)) {
        List<String> principalIds = getGroupService().getMemberPrincipalIds(groupId);
        // if any member of the group is not allowed to receive the request, then the group may not receive it
        for (String principalId : principalIds) {
            if (!getPermissionService().isAuthorizedByTemplate(principalId, KewApiConstants.KEW_NAMESPACE,
                    KewApiConstants.AD_HOC_REVIEW_PERMISSION, permissionDetails, new HashMap<String, String>())) {
                result = Boolean.FALSE;
                break;
            }
        }
    }
    return result;
}
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入方法依赖的package包/类
public void establishVisibleActionRequestCds(){
    try {
        if(getWorkflowDocument() != null){
            String docId = workflowDocument.getDocumentId();
            DocumentRouteHeaderValue document = KEWServiceLocator.getRouteHeaderService().getRouteHeader(docId);
            DocumentType documentType = document.getDocumentType();
            boolean isSuperUser = KEWServiceLocator.getDocumentTypePermissionService().canAdministerRouting(workflowDocument.getPrincipalId(), documentType);
            if (isSuperUser){
            	if (workflowDocument.isInitiated() || workflowDocument.isSaved() || workflowDocument.isEnroute()) {
                    appSpecificRouteActionRequestCds.clear();
                    appSpecificRouteActionRequestCds.putAll(CodeTranslator.arLabels);
            	}
            	else if (workflowDocument.isProcessed() || workflowDocument.isApproved() || workflowDocument.isDisapproved()) {
                    appSpecificRouteActionRequestCds.clear();
                    appSpecificRouteActionRequestCds.put(KewApiConstants.ACTION_REQUEST_ACKNOWLEDGE_REQ, KewApiConstants.ACTION_REQUEST_ACKNOWLEDGE_REQ_LABEL);
                    appSpecificRouteActionRequestCds.put(KewApiConstants.ACTION_REQUEST_FYI_REQ, KewApiConstants.ACTION_REQUEST_FYI_REQ_LABEL);
            	}
            	else {
                    appSpecificRouteActionRequestCds.clear();
                    appSpecificRouteActionRequestCds.put(KewApiConstants.ACTION_REQUEST_FYI_REQ, KewApiConstants.ACTION_REQUEST_FYI_REQ_LABEL);
            	}
            } else if(workflowDocument.isFYIRequested()){
                appSpecificRouteActionRequestCds.clear();
                appSpecificRouteActionRequestCds.put(KewApiConstants.ACTION_REQUEST_FYI_REQ, KewApiConstants.ACTION_REQUEST_FYI_REQ_LABEL);
            } else if (workflowDocument.isAcknowledgeRequested()){
                appSpecificRouteActionRequestCds.clear();
                appSpecificRouteActionRequestCds.put(KewApiConstants.ACTION_REQUEST_ACKNOWLEDGE_REQ, KewApiConstants.ACTION_REQUEST_ACKNOWLEDGE_REQ_LABEL);
                appSpecificRouteActionRequestCds.put(KewApiConstants.ACTION_REQUEST_FYI_REQ, KewApiConstants.ACTION_REQUEST_FYI_REQ_LABEL);
            } else if(workflowDocument.isApprovalRequested() || workflowDocument.isCompletionRequested() || workflowDocument.isInitiated()){
                appSpecificRouteActionRequestCds.clear();
                appSpecificRouteActionRequestCds.putAll(CodeTranslator.arLabels);
            }
        }
    } catch (Exception e) {
        throw new RuntimeException("Caught exception building ad hoc action dropdown", e);
    }
}
 

import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue; //导入方法依赖的package包/类
/**
 * Checks for any mandatory route responsibilities for the given document type and node.
 * 
 * Stops once it finds a responsibility for the document and node.
 */	
protected Responsibility getFirstResponsibilityWithMandatoryRouteFlag( DocumentRouteHeaderValue document, RouteNode node ) {
	// iterate over the document hierarchy
	// gather responsibilities - merge based on route level
       Predicate p = and(
               equal("template.namespaceCode", KRADConstants.KUALI_RICE_WORKFLOW_NAMESPACE),
               equal("template.name", KewApiConstants.DEFAULT_RESPONSIBILITY_TEMPLATE_NAME),
               equal("active", Boolean.TRUE),
               equal("attributes[routeNodeName]", node.getRouteNodeName())
               // KULRICE-8538 -- Check the document type while we're looping through the results below.  If it is added
               // into the predicate, no rows are ever returned.
               // equal("attributes[documentTypeName]", docType.getName())
       );
       QueryByCriteria.Builder builder = QueryByCriteria.Builder.create();
       builder.setPredicates(p);
       List<Responsibility> responsibilities = KimApiServiceLocator.getResponsibilityService().findResponsibilities(builder.build()).getResults();


       DocumentType docType = document.getDocumentType();
       while ( docType != null ) {
           // once we find a responsibility, stop, since this overrides any parent
           // responsibilities for this node
           if ( !responsibilities.isEmpty() ) {
               // if any has required=true - return true
               for ( Responsibility resp : responsibilities ) {
                   String documentTypeName = resp.getAttributes().get( KimConstants.AttributeConstants.DOCUMENT_TYPE_NAME);
                   if (StringUtils.isNotEmpty(documentTypeName) && StringUtils.equals(documentTypeName, docType.getName())){
                       if ( Boolean.parseBoolean( resp.getAttributes().get( KimConstants.AttributeConstants.REQUIRED ) ) ) {
                           return resp;
                       }
                   }
               }
           }
		docType = docType.getParentDocType();
	}
	return null;
}
 

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包/类
@Override
public ActionItem createActionItemForActionRequest(ActionRequestValue actionRequest) {
    ActionItem actionItem = new ActionItem();

    DocumentRouteHeaderValue routeHeader = actionRequest.getRouteHeader();
    DocumentType docType = routeHeader.getDocumentType();

    actionItem.setActionRequestCd(actionRequest.getActionRequested());
    actionItem.setActionRequestId(actionRequest.getActionRequestId());
    actionItem.setDocName(docType.getName());
    actionItem.setRoleName(actionRequest.getQualifiedRoleName());
    actionItem.setPrincipalId(actionRequest.getPrincipalId());
    actionItem.setDocumentId(actionRequest.getDocumentId());
    actionItem.setDateAssigned(new Timestamp(new Date().getTime()));
    actionItem.setDocHandlerURL(docType.getResolvedDocumentHandlerUrl());
    actionItem.setDocLabel(docType.getLabel());
    actionItem.setDocTitle(routeHeader.getDocTitle());
    actionItem.setGroupId(actionRequest.getGroupId());
    actionItem.setResponsibilityId(actionRequest.getResponsibilityId());
    actionItem.setDelegationType(actionRequest.getDelegationType());
    actionItem.setRequestLabel(actionRequest.getRequestLabel());

    ActionRequestValue delegatorActionRequest = actionRequestService.findDelegatorRequest(actionRequest);
    if (delegatorActionRequest != null) {
        actionItem.setDelegatorPrincipalId(delegatorActionRequest.getPrincipalId());
        actionItem.setDelegatorGroupId(delegatorActionRequest.getGroupId());
    }

    return actionItem;
}
 

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