Java KewApiServiceLocator.getWorkflowDocumentActionsService方法代码示例

import org.kuali.rice.kew.api.KewApiServiceLocator; //导入方法依赖的package包/类
/**
 * Helper method to get the correct {@link WorkflowDocumentActionsService} from the {@code applicationId} of the
 * document type.
 *
 * @param documentTypeId the document type to get the application id from
 *
 * @return the correct {@link WorkflowDocumentActionsService} from the {@code applicationId} of the document type
 */
protected WorkflowDocumentActionsService getWorkflowDocumentActionsService(String documentTypeId) {
    DocumentType documentType = KewApiServiceLocator.getDocumentTypeService().getDocumentTypeById(documentTypeId);
    String applicationId = documentType.getApplicationId();
    QName serviceName = new QName(KewApiConstants.Namespaces.KEW_NAMESPACE_2_0,
            KewApiConstants.ServiceNames.WORKFLOW_DOCUMENT_ACTIONS_SERVICE_SOAP);

    WorkflowDocumentActionsService service = (WorkflowDocumentActionsService) KsbApiServiceLocator.getServiceBus()
            .getService(serviceName, applicationId);

    if (service == null) {
        service = KewApiServiceLocator.getWorkflowDocumentActionsService();
    }

    return service;
}
 

import org.kuali.rice.kew.api.KewApiServiceLocator; //导入方法依赖的package包/类
private WorkflowDocumentActionsService getWorkflowDocumentActionsService(String documentTypeId) {
    DocumentType documentType = KewApiServiceLocator.getDocumentTypeService().getDocumentTypeById(documentTypeId);
    String applicationId = documentType.getApplicationId();
    QName serviceName = new QName(KewApiConstants.Namespaces.KEW_NAMESPACE_2_0,
            KewApiConstants.ServiceNames.WORKFLOW_DOCUMENT_ACTIONS_SERVICE_SOAP);
    WorkflowDocumentActionsService service = (WorkflowDocumentActionsService) KsbApiServiceLocator.getServiceBus()
            .getService(serviceName, applicationId);
    if (service == null) {
        service = KewApiServiceLocator.getWorkflowDocumentActionsService();
    }
    return service;
}
 

import org.kuali.rice.kew.api.KewApiServiceLocator; //导入方法依赖的package包/类
private WorkflowDocumentActionsService getWorkflowDocumentActionsService(String documentId) {
    DocumentType documentType = KEWServiceLocator.getDocumentTypeService().findByDocumentId(documentId);
    String applicationId = documentType.getApplicationId();
    QName serviceName = new QName(KewApiConstants.Namespaces.KEW_NAMESPACE_2_0,
            KewApiConstants.ServiceNames.WORKFLOW_DOCUMENT_ACTIONS_SERVICE_SOAP);
    WorkflowDocumentActionsService service = (WorkflowDocumentActionsService) KsbApiServiceLocator.getServiceBus()
            .getService(serviceName, applicationId);
    if (service == null) {
        service = KewApiServiceLocator.getWorkflowDocumentActionsService();
    }
    return service;
}
 

import org.kuali.rice.kew.api.KewApiServiceLocator; //导入方法依赖的package包/类
@Test
public void testIsUserInRouteLog() throws Exception {
    WorkflowDocument document = WorkflowDocumentFactory.createDocument(getPrincipalIdForName("ewestfal"), SeqSetup.DOCUMENT_TYPE_NAME);
    document.route("");
    assertTrue(document.isEnroute());
    WorkflowDocumentActionsService wdas = KewApiServiceLocator.getWorkflowDocumentActionsService();
    assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("ewestfal"), false));
    assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("bmcgough"), false));
    assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("rkirkend"), false));
    assertFalse("User should not be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("pmckown"), false));
    assertFalse("User should not be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("temay"), false));
    assertFalse("User should not be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("jhopf"), false));
    assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("pmckown"), true));
    assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("temay"), true));
    assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("jhopf"), true));

    // test that we can run isUserInRouteLog on a SAVED document
    document = WorkflowDocumentFactory.createDocument(getPrincipalIdForName("ewestfal"), SeqSetup.DOCUMENT_TYPE_NAME);
    document.saveDocument("");
    assertTrue(document.isSaved());
    assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("ewestfal"), false));
    assertFalse("User should not be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("bmcgough"), false));
    assertFalse("User should not be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("rkirkend"), false));
    assertFalse("User should not be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("pmckown"), false));
    assertFalse("User should not be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("temay"), false));
    assertFalse("User should not be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("jhopf"), false));

    // now look all up in the future of this saved document
    assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("bmcgough"), true));
    assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("rkirkend"), true));
    assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("pmckown"), true));
    assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("temay"), true));
    assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("jhopf"), true));
}
 

import org.kuali.rice.kew.api.KewApiServiceLocator; //导入方法依赖的package包/类
@Test public void testRoutingReportOnDocumentType() throws Exception {
      RoutingReportCriteria.Builder criteria = RoutingReportCriteria.Builder.createByDocumentTypeName("SeqDocType");
  	criteria.setRuleTemplateNames(Collections.singletonList("WorkflowDocumentTemplate"));
      WorkflowDocumentActionsService wdas = KewApiServiceLocator.getWorkflowDocumentActionsService();
  	DocumentDetail documentDetail = wdas.executeSimulation(criteria.build());
  	assertNotNull(documentDetail);
  	assertEquals("Should have been 2 requests generated.", 2, documentDetail.getActionRequests().size());

  	// let's try doing both WorkflowDocumentTemplate and WorkflowDocumentTemplate2 together
  	criteria.setRuleTemplateNames(Arrays.asList(new String[] {"WorkflowDocumentTemplate", "WorkflowDocument2Template"}));
  	documentDetail = wdas.executeSimulation(criteria.build());
  	assertEquals("Should have been 3 requests generated.", 3, documentDetail.getActionRequests().size());

  	boolean foundRkirkend = false;
  	boolean foundBmcgough = false;
  	boolean foundPmckown = false;
  	for (ActionRequest actionRequest : documentDetail.getActionRequests()) {
	String netId = getPrincipalNameForId(actionRequest.getPrincipalId());
	if (netId.equals("rkirkend")) {
		foundRkirkend = true;
		assertEquals(SeqSetup.WORKFLOW_DOCUMENT_NODE, actionRequest.getNodeName());
	} else if (netId.equals("bmcgough")) {
		foundBmcgough = true;
		assertEquals(SeqSetup.WORKFLOW_DOCUMENT_NODE, actionRequest.getNodeName());
	} else if (netId.equals("pmckown")) {
		foundPmckown = true;
		assertEquals(SeqSetup.WORKFLOW_DOCUMENT_2_NODE, actionRequest.getNodeName());
	}
}
  	assertTrue("Did not find request for rkirkend", foundRkirkend);
  	assertTrue("Did not find request for bmcgough", foundBmcgough);
  	assertTrue("Did not find request for pmckown", foundPmckown);

  }
 

import org.kuali.rice.kew.api.KewApiServiceLocator; //导入方法依赖的package包/类
@Test public void testRoutingReportOnDocumentId() throws Exception {
    WorkflowDocument doc = WorkflowDocumentFactory.createDocument(getPrincipalIdForName("user1"), "SeqDocType");

    WorkflowDocumentActionsService wdas = KewApiServiceLocator.getWorkflowDocumentActionsService();
    RoutingReportCriteria.Builder criteria = RoutingReportCriteria.Builder.createByDocumentId(doc.getDocumentId());
    criteria.setRuleTemplateNames(Collections.singletonList("WorkflowDocumentTemplate"));
    DocumentDetail documentDetail = wdas.executeSimulation(criteria.build());
    assertNotNull(documentDetail);
    assertEquals("Document id returned should be the same as the one passed in", doc.getDocumentId(),
            documentDetail.getDocument().getDocumentId());
    assertEquals("Wrong number of action requests generated", 2, documentDetail.getActionRequests().size());

    // let's try doing both WorkflowDocumentTemplate and WorkflowDocumentTemplate2 together
    criteria.setRuleTemplateNames(Arrays.asList(new String[] { "WorkflowDocumentTemplate", "WorkflowDocument2Template" }));
    documentDetail = wdas.executeSimulation(criteria.build());
    assertEquals("Should have been 3 requests generated.", 3, documentDetail.getActionRequests().size());

    boolean foundRkirkend = false;
    boolean foundBmcgough = false;
    boolean foundPmckown = false;
    for (ActionRequest actionRequest : documentDetail.getActionRequests()) {
        String netId = getPrincipalNameForId(actionRequest.getPrincipalId());
        if (netId.equals("rkirkend")) {
            foundRkirkend = true;
            assertEquals(SeqSetup.WORKFLOW_DOCUMENT_NODE, actionRequest.getNodeName());
        } else if (netId.equals("bmcgough")) {
            foundBmcgough = true;
            assertEquals(SeqSetup.WORKFLOW_DOCUMENT_NODE, actionRequest.getNodeName());
        } else if (netId.equals("pmckown")) {
            foundPmckown = true;
            assertEquals(SeqSetup.WORKFLOW_DOCUMENT_2_NODE, actionRequest.getNodeName());
        }
    }
    assertTrue("Did not find request for rkirkend", foundRkirkend);
    assertTrue("Did not find request for bmcgough", foundBmcgough);
    assertTrue("Did not find request for pmckown", foundPmckown);

}
 

import org.kuali.rice.kew.api.KewApiServiceLocator; //导入方法依赖的package包/类
public WorkflowDocumentActionsService getWorkflowDocumentActionsService() {
    if (workflowDocumentActionsService == null) {
        workflowDocumentActionsService = KewApiServiceLocator.getWorkflowDocumentActionsService();
    }
    return workflowDocumentActionsService;
}
 

import org.kuali.rice.kew.api.KewApiServiceLocator; //导入方法依赖的package包/类
/**
 * Tests future requests operation
 *
 * @throws Exception
 */
@Test
public void testFutureRequestsWithRoutingAndWorkflowInfoActionRequestCheck() throws Exception {
    this.loadXmlFile(this.getClass(), "FutureRequestsConfig.xml");

    String user1PrincipalId = getPrincipalIdForName("user1");
    String user2PrincipalId = getPrincipalIdForName("user2");

    WorkflowDocument document = WorkflowDocumentFactory.createDocument(user1PrincipalId, "FutureRequestsDoc");
    document.route("");

    // Node1
    //user1 should have approval requested
    document = WorkflowDocumentFactory.loadDocument(user1PrincipalId, document.getDocumentId());
    WorkflowDocumentActionsService actionService = KewApiServiceLocator.getWorkflowDocumentActionsService();
    RoutingReportCriteria.Builder reportCriteria = RoutingReportCriteria.Builder.createByDocumentId(document.getDocumentId());
    reportCriteria.setTargetPrincipalIds(Collections.singletonList(user1PrincipalId));
    String actionToTakeNode = "Node1";
    reportCriteria.setActionsToTake(Collections.singletonList(RoutingReportActionToTake.Builder.create(
            KewApiConstants.ACTION_TAKEN_APPROVED_CD, user1PrincipalId, actionToTakeNode)));
    assertTrue("User " + user1PrincipalId + " should have approval requests on the document",
            actionService.documentWillHaveAtLeastOneActionRequest(reportCriteria.build(),
                    Collections.singletonList(KewApiConstants.ACTION_REQUEST_APPROVE_REQ), false));

    reportCriteria = RoutingReportCriteria.Builder.createByDocumentId(document.getDocumentId());
    reportCriteria.setTargetPrincipalIds(Collections.singletonList(user1PrincipalId));
    actionToTakeNode = "Node1";
    reportCriteria.setActionsToTake(Collections.singletonList(RoutingReportActionToTake.Builder.create(KewApiConstants.ACTION_TAKEN_APPROVED_CD, user1PrincipalId, actionToTakeNode)));
    DocumentDetail documentVO = KewApiServiceLocator.getWorkflowDocumentActionsService().executeSimulation(reportCriteria.build());
    assertTrue("User " + user1PrincipalId + " should have one or more approval requests on the document", documentVO.getActionRequests().size() > 0);

    reportCriteria = RoutingReportCriteria.Builder.createByDocumentId(document.getDocumentId());
    String delyeaPrincipalId = getPrincipalIdForName("delyea");
    reportCriteria.setTargetPrincipalIds(Collections.singletonList(user1PrincipalId));
    actionToTakeNode = "Node1";
    reportCriteria.setActionsToTake(Collections.singletonList(RoutingReportActionToTake.Builder.create(KewApiConstants.ACTION_TAKEN_APPROVED_CD, user1PrincipalId, actionToTakeNode)));
    documentVO = actionService.executeSimulation(reportCriteria.build());
    assertTrue("User " + delyeaPrincipalId + " should not have any requests on the document but executeSimulation() method should return all action requests anyway", documentVO.getActionRequests().size() > 0);

    document = WorkflowDocumentFactory.createDocument(user1PrincipalId, "FutureRequestsDoc");
    document.setDoNotReceiveFutureRequests();
    document.route("");

    document = WorkflowDocumentFactory.loadDocument(user1PrincipalId, document.getDocumentId());
    assertFalse(document.isApprovalRequested());

    // user1 should not have approval requested
    reportCriteria = RoutingReportCriteria.Builder.createByDocumentId(document.getDocumentId());
    reportCriteria.setTargetPrincipalIds(Collections.singletonList(user1PrincipalId));
    assertFalse("User " + user1PrincipalId + " should not have any approval request on the document", actionService.documentWillHaveAtLeastOneActionRequest(reportCriteria.build(), Collections.singletonList(KewApiConstants.ACTION_REQUEST_APPROVE_REQ), false));

    // user2 should have approval requested
    reportCriteria = RoutingReportCriteria.Builder.createByDocumentId(document.getDocumentId());
    reportCriteria.setTargetPrincipalIds(Collections.singletonList(user2PrincipalId));
    assertTrue("User " + user2PrincipalId + " should have any approval request on the document", actionService.documentWillHaveAtLeastOneActionRequest(reportCriteria.build(), Collections.singletonList(KewApiConstants.ACTION_REQUEST_APPROVE_REQ), false));

}
 

import org.kuali.rice.kew.api.KewApiServiceLocator; //导入方法依赖的package包/类
@Test public void testIsUserInRouteLogAfterReturnToPrevious() throws Exception {
WorkflowDocument document = WorkflowDocumentFactory.createDocument(getPrincipalIdForName("ewestfal"), SeqSetup.DOCUMENT_TYPE_NAME);
       document.route("");
       assertTrue(document.isEnroute());

       document = WorkflowDocumentFactory.loadDocument(getPrincipalIdForName("bmcgough"), document.getDocumentId());
       assertTrue(document.isApprovalRequested());
       document = WorkflowDocumentFactory.loadDocument(getPrincipalIdForName("rkirkend"), document.getDocumentId());
       assertTrue(document.isApprovalRequested());

       // bmcgough and rkirkend should be in route log
       WorkflowDocumentActionsService wdas = KewApiServiceLocator.getWorkflowDocumentActionsService();
       assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("bmcgough"), false));
       assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("rkirkend"), false));
       assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("bmcgough"), true));
       assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("rkirkend"), true));
       assertFalse("User should NOT be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("pmckown"), false));
       // Phil of the future
       assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("pmckown"), true));
       TestUtilities.assertAtNode(document, "WorkflowDocument");

       document.returnToPreviousNode("", "AdHoc");
       TestUtilities.assertAtNode(document, "AdHoc");
       document = WorkflowDocumentFactory.loadDocument(getPrincipalIdForName("ewestfal"), document.getDocumentId());
       assertTrue(document.isApprovalRequested());

       document.approve("");

       // we should be back where we were
       document = WorkflowDocumentFactory.loadDocument(getPrincipalIdForName("bmcgough"), document.getDocumentId());
       assertTrue(document.isApprovalRequested());
       document = WorkflowDocumentFactory.loadDocument(getPrincipalIdForName("rkirkend"), document.getDocumentId());
       assertTrue(document.isApprovalRequested());
       TestUtilities.assertAtNode(document, "WorkflowDocument");

       // now verify that is route log authenticated still works
       assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("bmcgough"), false));
       assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("rkirkend"), false));
       assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("bmcgough"), true));
       assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("rkirkend"), true));
       assertFalse("User should NOT be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("pmckown"), false));
       assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("pmckown"), true));

       // let's look at the revoked node instances

       List revokedNodeInstances = KEWServiceLocator.getRouteNodeService().getRevokedNodeInstances(KEWServiceLocator.getRouteHeaderService().getRouteHeader(document.getDocumentId()));
       assertNotNull(revokedNodeInstances);
       assertEquals(2, revokedNodeInstances.size());

       // let's approve past this node and another
       document = WorkflowDocumentFactory.loadDocument(getPrincipalIdForName("bmcgough"), document.getDocumentId());
       document.approve("");
       document = WorkflowDocumentFactory.loadDocument(getPrincipalIdForName("rkirkend"), document.getDocumentId());
       document.approve("");

       // should be at WorkflowDocument2
       document = WorkflowDocumentFactory.loadDocument(getPrincipalIdForName("pmckown"), document.getDocumentId());
       TestUtilities.assertAtNode(document, "WorkflowDocument2");
       assertTrue(document.isApprovalRequested());
       assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("bmcgough"), false));
       assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("rkirkend"), false));
       assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("bmcgough"), true));
       assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("rkirkend"), true));
       assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("pmckown"), false));
       assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("pmckown"), true));

       // now return back to WorkflowDocument
       document.returnToPreviousNode("", "WorkflowDocument");
       document = WorkflowDocumentFactory.loadDocument(getPrincipalIdForName("bmcgough"), document.getDocumentId());
       assertTrue(document.isApprovalRequested());
       // Phil should no longer be non-future route log authenticated
       assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("bmcgough"), false));
       assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("rkirkend"), false));
       assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("bmcgough"), true));
       assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("rkirkend"), true));
       assertFalse("User should NOT be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("pmckown"), false));
       assertTrue("User should be authenticated.", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("pmckown"), true));
   }
 

import org.kuali.rice.kew.api.KewApiServiceLocator; //导入方法依赖的package包/类
@Test
public void testIsUserInRouteLogWithSplits() throws Exception {
	loadXmlFile("WorkflowUtilitySplitConfig.xml");

	// initialize the split node to both branches
	TestSplitNode.setLeftBranch(true);
	TestSplitNode.setRightBranch(true);

	WorkflowDocument document = WorkflowDocumentFactory.createDocument(getPrincipalIdForName("admin"), "UserInRouteLog_Split");
    document.route("");

    // document should be in ewestfal action list
    document = TestUtilities.switchByPrincipalName("ewestfal", document);
    assertTrue("should have approve", document.isApprovalRequested());
    TestUtilities.assertAtNode(document, "BeforeSplit");

    // now let's run some simulations
    WorkflowDocumentActionsService wdas = KewApiServiceLocator.getWorkflowDocumentActionsService();
    assertTrue("should be in route log", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("ewestfal"), true));
    assertTrue("should be in route log", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("rkirkend"), true));
    assertTrue("should be in route log", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("bmcgough"), true));
    assertTrue("should be in route log", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("jhopf"), true));
    assertTrue("should be in route log", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("natjohns"), true));
    assertFalse("should NOT be in route log", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("user1"), true));

    // now let's activate only the left branch and make sure the split is properly executed
    TestSplitNode.setRightBranch(false);
    assertTrue("should be in route log", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("rkirkend"), true));
    assertTrue("should be in route log", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("bmcgough"), true));
    assertFalse("should NOT be in route log because right branch is not active", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("jhopf"), true));
    assertTrue("should be in route log", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("natjohns"), true));

    // now let's do a flattened evaluation, it should hit both branches
    assertTrue("should be in route log", wdas.isUserInRouteLogWithOptionalFlattening(document.getDocumentId(), getPrincipalIdForName("rkirkend"), true, true));
    assertTrue("should be in route log", wdas.isUserInRouteLogWithOptionalFlattening(document.getDocumentId(), getPrincipalIdForName("bmcgough"), true, true));
    assertTrue("should be in route log because we've flattened nodes", wdas.isUserInRouteLogWithOptionalFlattening(document.getDocumentId(), getPrincipalIdForName("jhopf"), true, true));
    assertTrue("should be in route log", wdas.isUserInRouteLogWithOptionalFlattening(document.getDocumentId(), getPrincipalIdForName("natjohns"), true, true));

    // now let's switch to the right branch
    TestSplitNode.setRightBranch(true);
    TestSplitNode.setLeftBranch(false);

    assertFalse("should NOT be in route log", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("rkirkend"), true));
    assertFalse("should NOT be in route log", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("bmcgough"), true));
    assertTrue("should be in route log", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("jhopf"), true));
    assertTrue("should be in route log", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("natjohns"), true));

    // now let's switch back to the left branch and approve it
    TestSplitNode.setLeftBranch(true);
    TestSplitNode.setRightBranch(false);

    // now let's approve it so that we're inside the right branch of the split
    document.approve("");
    // shoudl be at SplitLeft1 node
    TestUtilities.assertAtNode(document, "SplitLeft1");

    document = TestUtilities.switchByPrincipalName("rkirkend", document);
    assertTrue("should have an approve request", document.isApprovalRequested());

    // now let's run the simulation so we can test running from inside a split branch
    assertTrue("should be in route log", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("rkirkend"), true));
    assertTrue("should be in route log", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("bmcgough"), true));
    assertFalse("should NOT be in route log because right branch is not active", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("jhopf"), true));
    assertTrue("should be in route log", wdas.isUserInRouteLog(document.getDocumentId(), getPrincipalIdForName("natjohns"), true));
}
 

import org.kuali.rice.kew.api.KewApiServiceLocator; //导入方法依赖的package包/类
private void runDocumentWillHaveApproveOrCompleteRequestAtNode(String documentType,ReportCriteriaGenerator generator) throws Exception {
      /*
        name="WorkflowDocument"
          -  bmcgough - Approve - false
          -  rkirkend - Approve - false
        name="WorkflowDocument2"
          -  pmckown - Approve - false
        name="Acknowledge1"
          -  temay - Ack - false
        name="Acknowledge2"
          -  jhopf - Ack - false
      */
        WorkflowDocumentActionsService wdas = KewApiServiceLocator.getWorkflowDocumentActionsService();

        WorkflowDocument document = WorkflowDocumentFactory.createDocument(getPrincipalIdForName("ewestfal"), documentType);
        RoutingReportCriteria.Builder builder = RoutingReportCriteria.Builder.createByDocumentId(document.getDocumentId());
        builder.setXmlContent(document.getDocumentContent().getApplicationContent());
        builder.setTargetNodeName("WorkflowDocument2");
        builder.setRoutingPrincipalId(getPrincipalIdForName("bmcgough"));
        assertTrue("Document should have one unfulfilled approve/complete request", wdas.documentWillHaveAtLeastOneActionRequest(builder.build(), Arrays.asList(new String[]{KewApiConstants.ACTION_REQUEST_APPROVE_REQ,KewApiConstants.ACTION_REQUEST_COMPLETE_REQ}), false));
        builder.setTargetPrincipalIds(Collections.singletonList(getPrincipalIdForName("bmcgough")));
        assertFalse("Document should not have any unfulfilled approve/complete requests", wdas.documentWillHaveAtLeastOneActionRequest(builder.build(), Arrays.asList(new String[]{KewApiConstants.ACTION_REQUEST_APPROVE_REQ,KewApiConstants.ACTION_REQUEST_COMPLETE_REQ}), false));

        builder = RoutingReportCriteria.Builder.createByDocumentId(document.getDocumentId());
        builder.setXmlContent(document.getDocumentContent().getApplicationContent());
        builder.setTargetNodeName("WorkflowDocument2");
        builder.setRoutingPrincipalId(getPrincipalIdForName("bmcgough"));
        List<RoutingReportActionToTake.Builder> actionsToTake = new ArrayList<RoutingReportActionToTake.Builder>();
//        actionsToTake[0] = new ReportActionToTakeDTO(KewApiConstants.ACTION_TAKEN_APPROVED_CD,getPrincipalIdForName("rkirkend"),"WorkflowDocument");
        actionsToTake.add(RoutingReportActionToTake.Builder.create(KewApiConstants.ACTION_TAKEN_APPROVED_CD,getPrincipalIdForName("pmckown"),"WorkflowDocument2"));
        builder.setActionsToTake(actionsToTake);
        assertFalse("Document should not have any unfulfilled approve/complete requests", wdas.documentWillHaveAtLeastOneActionRequest(builder.build(), Arrays.asList(new String[]{KewApiConstants.ACTION_REQUEST_APPROVE_REQ,KewApiConstants.ACTION_REQUEST_COMPLETE_REQ}), false));

        builder = RoutingReportCriteria.Builder.createByDocumentId(document.getDocumentId());
        builder.setXmlContent(document.getDocumentContent().getApplicationContent());
        builder.setTargetNodeName("WorkflowDocument2");
        actionsToTake = new ArrayList<RoutingReportActionToTake.Builder>();
        actionsToTake.add(RoutingReportActionToTake.Builder.create(KewApiConstants.ACTION_TAKEN_APPROVED_CD,getPrincipalIdForName("bmcgough"),"WorkflowDocument"));
        actionsToTake.add(RoutingReportActionToTake.Builder.create(KewApiConstants.ACTION_TAKEN_APPROVED_CD,getPrincipalIdForName("rkirkend"),"WorkflowDocument"));
        builder.setActionsToTake(actionsToTake);
        builder.setRoutingPrincipalId(getPrincipalIdForName("pmckown"));
        assertFalse("Document should not have any unfulfilled approve/complete requests", wdas.documentWillHaveAtLeastOneActionRequest(builder.build(), Arrays.asList(new String[]{KewApiConstants.ACTION_REQUEST_APPROVE_REQ,KewApiConstants.ACTION_REQUEST_COMPLETE_REQ}), false));

        document = WorkflowDocumentFactory.createDocument(getPrincipalIdForName("ewestfal"), documentType);
        document.route("");
        assertTrue(document.isEnroute());

        document = WorkflowDocumentFactory.loadDocument(getPrincipalIdForName("bmcgough"), document.getDocumentId());
        document.approve("");

        document = WorkflowDocumentFactory.loadDocument(getPrincipalIdForName("rkirkend"), document.getDocumentId());
        document.approve("");

        builder = RoutingReportCriteria.Builder.createByDocumentId(document.getDocumentId());
        builder.setXmlContent(document.getDocumentContent().getApplicationContent());
        builder.setTargetNodeName("WorkflowDocument2");
        assertTrue("Document should have one unfulfilled approve/complete request", wdas.documentWillHaveAtLeastOneActionRequest(builder.build(), Arrays.asList(new String[]{KewApiConstants.ACTION_REQUEST_APPROVE_REQ,KewApiConstants.ACTION_REQUEST_COMPLETE_REQ}), false));

        document = WorkflowDocumentFactory.loadDocument(getPrincipalIdForName("pmckown"), document.getDocumentId());
        document.approve("");
        assertTrue(document.isProcessed());

        builder = RoutingReportCriteria.Builder.createByDocumentId(document.getDocumentId());
        builder.setXmlContent(document.getDocumentContent().getApplicationContent());
        builder.setTargetNodeName("Acknowledge1");
        assertFalse("Document should not have any unfulfilled approve/complete requests when in processed status", wdas.documentWillHaveAtLeastOneActionRequest(builder.build(), Arrays.asList(new String[]{KewApiConstants.ACTION_REQUEST_APPROVE_REQ,KewApiConstants.ACTION_REQUEST_COMPLETE_REQ}), false));

        builder = RoutingReportCriteria.Builder.createByDocumentId(document.getDocumentId());
        builder.setXmlContent(document.getDocumentContent().getApplicationContent());
        builder.setTargetNodeName("Acknowledge1");
        assertTrue("Document should have one unfulfilled Ack request when in final status", wdas.documentWillHaveAtLeastOneActionRequest(builder.build(), Arrays.asList(new String[]{KewApiConstants.ACTION_REQUEST_ACKNOWLEDGE_REQ}), false));
        if (generator.isCriteriaRouteHeaderBased()) {
            assertFalse("Document should have no unfulfilled Ack request generated when in final status", wdas.documentWillHaveAtLeastOneActionRequest(builder.build(), Arrays.asList(new String[]{KewApiConstants.ACTION_REQUEST_ACKNOWLEDGE_REQ}), true));
        }

        // if temay acknowledges the document here it will move to processed and no more simulations would need to be tested
        document = WorkflowDocumentFactory.loadDocument(getPrincipalIdForName("temay"), document.getDocumentId());
        document.acknowledge("");
        assertTrue(document.isProcessed());
    }
 

import org.kuali.rice.kew.api.KewApiServiceLocator; //导入方法依赖的package包/类
@Test public void testIsLastApprover() throws Exception {
      // test the is last approver in route level against our sequential document type
      WorkflowDocument document = WorkflowDocumentFactory.createDocument(getPrincipalIdForName("ewestfal"), SeqSetup.DOCUMENT_TYPE_NAME);
      document.saveDocumentData();

      WorkflowDocumentActionsService wdas = KewApiServiceLocator.getWorkflowDocumentActionsService();

      // the initial "route level" should have no requests initially so it should return false
      assertFalse("Should not be last approver.", wdas.isLastApproverAtNode(document.getDocumentId(), getPrincipalIdForName("ewestfal"), SeqSetup.ADHOC_NODE));

      // app specific route a request to a workgroup at the initial node (TestWorkgroup)
String groupId = getGroupIdForName(KimConstants.KIM_GROUP_WORKFLOW_NAMESPACE_CODE, "TestWorkgroup");
      document.adHocToGroup(ActionRequestType.APPROVE, "AdHoc", "", groupId, "", false);

      assertTrue("Should be last approver.", wdas.isLastApproverAtNode(document.getDocumentId(), getPrincipalIdForName("ewestfal"), SeqSetup.ADHOC_NODE));

      // app specific route a request to a member of the workgroup (jitrue)
      document.adHocToPrincipal(ActionRequestType.APPROVE, "AdHoc", "", getPrincipalIdForName("jitrue"), "", false);
      // member of the workgroup with the user request should be last approver
      assertTrue("Should be last approver.", wdas.isLastApproverAtNode(document.getDocumentId(), getPrincipalIdForName("jitrue"), SeqSetup.ADHOC_NODE));
      // other members of the workgroup will not be last approvers because they don't satisfy the individuals request (ewestfal)
      assertFalse("Should not be last approver.", wdas.isLastApproverAtNode(document.getDocumentId(), getPrincipalIdForName("ewestfal"), SeqSetup.ADHOC_NODE));

      // route the document, should stay at the adhoc node until those requests have been completed
      document.route("");
      document = WorkflowDocumentFactory.loadDocument(getPrincipalIdForName("jitrue"), document.getDocumentId());
      assertEquals("Document should be at adhoc node.", SeqSetup.ADHOC_NODE, document.getNodeNames().iterator().next());
      assertTrue("Approve should be requested.", document.isApprovalRequested());
      document.approve("");

      // document should now be at the WorkflowDocument node with a request to bmcgough and rkirkend
      document = WorkflowDocumentFactory.loadDocument(getPrincipalIdForName("bmcgough"), document.getDocumentId());
      assertTrue("Approve should be requested.", document.isApprovalRequested());
      document = WorkflowDocumentFactory.loadDocument(getPrincipalIdForName("rkirkend"), document.getDocumentId());
      assertTrue("Approve should be requested.", document.isApprovalRequested());
      // since there are two requests, neither should be last approver
      assertFalse("Should not be last approver.", wdas.isLastApproverAtNode(document.getDocumentId(), getPrincipalIdForName("bmcgough"), SeqSetup.WORKFLOW_DOCUMENT_NODE));
      assertFalse("Should not be last approver.", wdas.isLastApproverAtNode(document.getDocumentId(), getPrincipalIdForName("rkirkend"), SeqSetup.WORKFLOW_DOCUMENT_NODE));
      document.approve("");

      // request to rirkend has been satisfied, now request to bmcgough is only request remaining at level so he should be last approver
      document = WorkflowDocumentFactory.loadDocument(getPrincipalIdForName("bmcgough"), document.getDocumentId());
      assertTrue("Approve should be requested.", document.isApprovalRequested());
      assertTrue("Should be last approver.", wdas.isLastApproverAtNode(document.getDocumentId(), getPrincipalIdForName("bmcgough"), SeqSetup.WORKFLOW_DOCUMENT_NODE));
      document.approve("");

  }
 

import org.kuali.rice.kew.api.KewApiServiceLocator; //导入方法依赖的package包/类
/**
 * Factored out so as not to duplicate a bunch of code between testIsFinalApprover and testIsFinalApproverChild.
 */
private void assertFinalApprover(WorkflowDocument document) throws Exception {
    document.route("");

    document = WorkflowDocumentFactory.loadDocument(getPrincipalIdForName("bmcgough"), document.getDocumentId());
    assertTrue("Document should be enroute.", document.isEnroute());
    assertTrue("Should have approve request.", document.isApprovalRequested());

    WorkflowDocumentActionsService wdas = KewApiServiceLocator.getWorkflowDocumentActionsService();
    // bmcgough is not the final approver
    assertFalse("Should not be final approver.", wdas.isFinalApprover(document.getDocumentId(), getPrincipalIdForName("bmcgough")));
    // approve as bmcgough
    document.approve("");

    // should be to Ryan now, who is also not the final approver on the document
    document = WorkflowDocumentFactory.loadDocument(getPrincipalIdForName("rkirkend"), document.getDocumentId());
    assertTrue("Document should be enroute.", document.isEnroute());
    assertTrue("Should have approve request.", document.isApprovalRequested());
    assertFalse("Should not be final approver.", wdas.isFinalApprover(document.getDocumentId(), getPrincipalIdForName("rkirkend")));
    document.approve("");

    // should be to Phil now, who *IS* the final approver on the document
    document = WorkflowDocumentFactory.loadDocument(getPrincipalIdForName("pmckown"), document.getDocumentId());
    assertTrue("Document should be enroute.", document.isEnroute());
    assertTrue("Should have approve request.", document.isApprovalRequested());
    assertTrue("Should be final approver.", wdas.isFinalApprover(document.getDocumentId(), getPrincipalIdForName("pmckown")));

    // now adhoc an approve to temay, phil should no longer be the final approver
    document.adHocToPrincipal(ActionRequestType.APPROVE, SeqSetup.WORKFLOW_DOCUMENT_2_NODE,
            "", getPrincipalIdForName("temay"), "", true);
    assertFalse("Should not be final approver.", wdas.isFinalApprover(document.getDocumentId(), getPrincipalIdForName("pmckown")));
    assertFalse("Should not be final approver.", wdas.isFinalApprover(document.getDocumentId(), getPrincipalIdForName("temay")));

    // now approve as temay and then adhoc an ack to jeremy
    document = WorkflowDocumentFactory.loadDocument(getPrincipalIdForName("temay"), document.getDocumentId());
    assertTrue("SHould have approve request.", document.isApprovalRequested());
    document.approve("");

    // phil should be final approver again
    assertTrue("Should be final approver.", wdas.isFinalApprover(document.getDocumentId(), getPrincipalIdForName("pmckown")));
    document.adHocToPrincipal(ActionRequestType.ACKNOWLEDGE, SeqSetup.WORKFLOW_DOCUMENT_2_NODE,
            "", getPrincipalIdForName("jhopf"), "", true);
    document = WorkflowDocumentFactory.loadDocument(getPrincipalIdForName("jhopf"), document.getDocumentId());
    assertTrue("Should have acknowledge request.", document.isAcknowledgeRequested());

    // now there should be an approve to phil and an ack to jeremy, so phil should be the final approver and jeremy should not
    assertTrue("Should be final approver.", wdas.isFinalApprover(document.getDocumentId(), getPrincipalIdForName("pmckown")));
    assertFalse("Should not be final approver.", wdas.isFinalApprover(document.getDocumentId(), getPrincipalIdForName("jhopf")));

    // after approving as phil, the document should go processed
    document = WorkflowDocumentFactory.loadDocument(getPrincipalIdForName("pmckown"), document.getDocumentId());
    document.approve("");
    assertTrue("Document should be processed.", document.isProcessed());
}
 

import org.kuali.rice.kew.api.KewApiServiceLocator; //导入方法依赖的package包/类
@Test public void testGetPrincipalIdsInRouteLog() throws Exception {
  	Set<String> NonSITMembers = new HashSet<String>(
  			Arrays.asList(
				new String[] {
						getPrincipalIdForName("user1"),
						getPrincipalIdForName("user2"),
						getPrincipalIdForName("user3"),
						getPrincipalIdForName("dewey")}
		)
  	);

  	Set<String> WorkflowAdminMembers = new HashSet<String>(
  			Arrays.asList(
  					new String[] {
  							getPrincipalIdForName("ewestfal"),
  							getPrincipalIdForName("rkirkend"),
  							getPrincipalIdForName("jhopf"),
  							getPrincipalIdForName("bmcgough"),
  							getPrincipalIdForName("shenl"),
  							getPrincipalIdForName("quickstart")
  					}
  			)
  	);

  	WorkflowDocument document = WorkflowDocumentFactory.createDocument(getPrincipalIdForName("rkirkend"), RouteLogTestSetup.DOCUMENT_TYPE_NAME);
document.route("");

      WorkflowDocumentActionsService wdas = KewApiServiceLocator.getWorkflowDocumentActionsService();
// just look at the current node
List<String> principalIds = wdas.getPrincipalIdsInRouteLog(document.getDocumentId(), false);
// should contain ewestfal and NonSIT group members
assertTrue(principalIds.contains(getPrincipalIdForName("ewestfal")));
assertTrue(principalIds.containsAll(NonSITMembers));

// should NOT contain jitrue and WorkflowAdmin group members as they are in the rule for the future node
assertFalse(principalIds.contains(getPrincipalIdForName("jitrue")));
assertFalse(principalIds.containsAll(WorkflowAdminMembers));

// this time look at future nodes too
principalIds = 	wdas.getPrincipalIdsInRouteLog(document.getDocumentId(), true);

// should contain ewestfal and NonSIT group members
assertTrue(principalIds.contains(getPrincipalIdForName("ewestfal")));
assertTrue(principalIds.containsAll(NonSITMembers));

// should also contain jitrue and WorkflowAdmin group members
assertTrue(principalIds.contains(getPrincipalIdForName("jitrue")));
assertTrue(principalIds.containsAll(WorkflowAdminMembers));
  }