import org.kuali.rice.kew.api.document.DocumentContent; //导入依赖的package包/类
@Override
public void indexDocument(String documentId) {
    if (StringUtils.isBlank(documentId)) {
        throw new RiceIllegalArgumentException("documentId was null or blank");
    }
    MDC.put("docId", documentId);
    try {
        long t1 = System.currentTimeMillis();
        LOG.info("Indexing document attributes for document " + documentId);
        Document document = getWorkflowDocumentService().getDocument(documentId);
        if (document == null) {
            throw new RiceIllegalArgumentException("Failed to locate document with the given id: " + documentId);
        }
        DocumentContent documentContent =
                KewApiServiceLocator.getWorkflowDocumentService().getDocumentContent(documentId);
        List<SearchableAttributeValue> attributes = buildSearchableAttributeValues(document, documentContent);
        KEWServiceLocator.getRouteHeaderService().updateRouteHeaderSearchValues(documentId, attributes);
        long t2 = System.currentTimeMillis();
        LOG.info("...finished indexing document " + documentId + " for document search, total time = " + (t2 - t1) +
                " ms.");
    } finally {
        MDC.remove("docId");
    }
}
 

import org.kuali.rice.kew.api.document.DocumentContent; //导入依赖的package包/类
/**
 * Tests modification of the DocumentContentVO object directly.
 */
@Test public void testManualDocumentContentModification() throws Exception {
	WorkflowDocument document = WorkflowDocumentFactory.createDocument(getPrincipalIdForName("ewestfal"), "TestDocumentType");
	document.saveDocumentData();
	
	// fetch it from WorkflowInfo
	DocumentContent content = KewApiServiceLocator.getWorkflowDocumentService().getDocumentContent(document.getDocumentId());
	assertTrue("Should contain default content, was " + content.getFullContent(), KewApiConstants.DEFAULT_DOCUMENT_CONTENT.equals(content.getFullContent()) ||
			KewApiConstants.DEFAULT_DOCUMENT_CONTENT2.equals(content.getFullContent()));
	
	String appContent = "<abcdefg>hijklm n o p</abcdefg>";
	DocumentContentUpdate.Builder contentUpdate = DocumentContentUpdate.Builder.create(content);
	contentUpdate.setApplicationContent(appContent);
	document.updateDocumentContent(contentUpdate.build());
    document.saveDocumentData();
	
	// test that the content on the document is the same as the content we just set
	XMLAssert.assertXMLEqual(appContent, document.getApplicationContent());
	
	// fetch the document fresh and make sure the content is correct
	document = WorkflowDocumentFactory.loadDocument(getPrincipalIdForName("ewestfal"), document.getDocumentId());
	XMLAssert.assertXMLEqual(appContent, document.getApplicationContent());
	
}
 

import org.kuali.rice.kew.api.document.DocumentContent; //导入依赖的package包/类
@Override
public List<Map<String, String>> resolveMultipleRoleQualifiers(
        @WebParam(name = "kewTypeId") String kewTypeId,
        @WebParam(name = "roleId") String roleId,
        @WebParam(name = "document") Document document,
        @WebParam(name = "documentContent") DocumentContent documentContent) {
    List<Map<String, String>> qualifiers = new ArrayList<Map<String, String>>();

        //try to get values from maintainable object
        try {
            org.kuali.rice.krad.document.Document doc = KRADServiceLocatorWeb.getDocumentService().getByDocumentHeaderId(document.getDocumentId());
            if (doc instanceof MaintenanceDocument) {
                MaintenanceDocument md = (MaintenanceDocument) doc;

                            qualifiers.add(
                                    Collections.singletonMap(KimConstants.AttributeConstants.DOCUMENT_NUMBER, String.valueOf(md.getDocumentNumber())));

            }
        } catch (WorkflowException e) {
            LOG.error("Unable to retrieve document with documemnt ID: " + document.getDocumentId());
        }

    return qualifiers;

}
 

import org.kuali.rice.kew.api.document.DocumentContent; //导入依赖的package包/类
private void assertContent(DocumentContent contentVO, String attributeContent, String searchableContent, String applicationContent) throws Exception{
    /*if (org.apache.commons.lang.StringUtils.isEmpty(attributeContent)) {
    	attributeContent = "";
    } else {
        attributeContent = "<"+ATTRIBUTE_CONTENT+">"+attributeContent+"</"+ATTRIBUTE_CONTENT+">";
    }
    if (org.apache.commons.lang.StringUtils.isEmpty(searchableContent)) {
    	searchableContent = "";
    } else {
        searchableContent = "<"+SEARCHABLE_CONTENT+">"+searchableContent+"</"+SEARCHABLE_CONTENT+">";
    }*/
    assertFalse("Content cannot be empty.", org.apache.commons.lang.StringUtils.isEmpty(contentVO.getFullContent()));
    assertEquals("Attribute content is invalid.", attributeContent.replaceAll("\n", ""),
            contentVO.getAttributeContent().replaceAll("\n", ""));
    assertEquals("Searchable content is invalid.", searchableContent.replaceAll("\n", ""), contentVO.getSearchableContent().replaceAll(
            "\n", ""));
    assertEquals("Application content is invalid.", applicationContent.replaceAll("\n", ""), contentVO.getApplicationContent().replaceAll(
            "\n", ""));
    /*assertEquals("Incorrect number of attribute definitions.", 0, contentVO.get.getAttributeDefinitions().length);
    assertEquals("Incorrect number of searchable attribute definitions.", 0, contentVO.getSearchableDefinitions().length);*/
}
 

import org.kuali.rice.kew.api.document.DocumentContent; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public Map<String, String> resolveRoleQualifiers(@WebParam(name = "kewTypeId") String kewTypeId,
        @WebParam(name = "roleId") String roleId, @WebParam(name = "document") Document document,
        @WebParam(name = "documentContent") DocumentContent documentContent) {
    return new HashMap<String, String>();
}
 

import org.kuali.rice.kew.api.document.DocumentContent; //导入依赖的package包/类
/**
 * Uses the appropriate {@link PeopleFlowTypeService} to get the role qualifier maps for the given document and
 * role.
 *
 * <p>Note that the PeopleFlowTypeService is selected based on the type id of the PeopleFlow.</p>
 *
 * @param context the context for request generation
 * @param roleId the ID of the role for whom qualifiers are being loaded
 * @return the qualifier maps, or an empty list if there are none
 */
protected List<Map<String, String>> loadRoleQualifiers(Context context, String roleId) {
    PeopleFlowTypeService peopleFlowTypeService = context.getPeopleFlowTypeService();
    List<Map<String, String>> roleQualifierList = new ArrayList<Map<String, String>>();

    if (peopleFlowTypeService != null) {
        Document document = DocumentRouteHeaderValue.to(context.getRouteContext().getDocument());
        DocumentRouteHeaderValueContent content = new DocumentRouteHeaderValueContent(document.getDocumentId());
        content.setDocumentContent(context.getRouteContext().getDocumentContent().getDocContent());
        DocumentContent documentContent = DocumentRouteHeaderValueContent.to(content);

        Map<String, String> roleQualifiers = peopleFlowTypeService.resolveRoleQualifiers(
                context.getPeopleFlow().getTypeId(), roleId, document, documentContent
        );

        if (roleQualifiers != null) {
            roleQualifierList.add(roleQualifiers);
        }

        boolean versionOk = VersionHelper.compareVersion(context.getPeopleFlowTypeServiceVersion(), CoreConstants.Versions.VERSION_2_3_0) != -1;
        if(versionOk) {
            List<Map<String, String>> multipleRoleQualifiers = peopleFlowTypeService.resolveMultipleRoleQualifiers(
                    context.getPeopleFlow().getTypeId(), roleId, document, documentContent);

            if (multipleRoleQualifiers != null) {
                roleQualifierList.addAll(multipleRoleQualifiers);
            }
        }

    }

    return roleQualifierList;
}
 

import org.kuali.rice.kew.api.document.DocumentContent; //导入依赖的package包/类
protected ModifiableDocumentContent getModifiableDocumentContent() {
    if (this.modifiableDocumentContent == null) {
        DocumentContent documentContent = getWorkflowDocumentService().getDocumentContent(getDocumentId());
        if (documentContent == null) {
            throw new IllegalStateException("Failed to load document content for documentId: " + getDocumentId());
        }
        this.modifiableDocumentContent = new ModifiableDocumentContent(documentContent);
    }
    return this.modifiableDocumentContent;
}
 

import org.kuali.rice.kew.api.document.DocumentContent; //导入依赖的package包/类
protected DocumentContent getDocumentContent() {
    if (!dirty) {
        return originalDocumentContent;
    }
    DocumentContent.Builder documentContentBuilder = DocumentContent.Builder.create(originalDocumentContent);
    documentContentBuilder.setApplicationContent(builder.getApplicationContent());
    documentContentBuilder.setAttributeContent(builder.getAttributeContent());
    documentContentBuilder.setSearchableContent(builder.getSearchableContent());
    return documentContentBuilder.build();
}
 

import org.kuali.rice.kew.api.document.DocumentContent; //导入依赖的package包/类
@Override
public DocumentContent getDocumentContent(String documentId) {
	if (StringUtils.isBlank(documentId)) {
		throw new RiceIllegalArgumentException("documentId was blank or null");
	}
	DocumentRouteHeaderValueContent content = KEWServiceLocator.getRouteHeaderService().getContent(documentId);
	return DocumentRouteHeaderValueContent.to(content);
}
 

import org.kuali.rice.kew.api.document.DocumentContent; //导入依赖的package包/类
/**
 * Helper to create documentwithcontent with searchable content
 */
protected DocumentWithContent createDocumentWithSearchableContent(String docType, String content) {
    Document doc = Document.Builder.create("fakeDocId123", "fake initiator", docType, "fake doc type id").build();
    DocumentContent.Builder c = DocumentContent.Builder.create("fakeDocId123");
    c.setSearchableContent(content);
    return DocumentWithContent.create(doc, c.build());
}
 

import org.kuali.rice.kew.api.document.DocumentContent; //导入依赖的package包/类
private void assertContent(DocumentContent contentVO, String attributeContent, String searchableContent, String applicationContent) throws Exception{
    assertFalse("Content cannot be empty.", org.apache.commons.lang.StringUtils.isEmpty(contentVO.getFullContent()));
    assertEquals("Attribute content is invalid.", attributeContent.replaceAll("\n", ""),
            contentVO.getAttributeContent().replaceAll("\n", ""));
    assertEquals("Searchable content is invalid.", searchableContent.replaceAll("\n", ""), contentVO.getSearchableContent().replaceAll(
            "\n", ""));
    assertEquals("Application content is invalid.", applicationContent.replaceAll("\n", ""), contentVO.getApplicationContent().replaceAll(
            "\n", ""));
}
 

import org.kuali.rice.kew.api.document.DocumentContent; //导入依赖的package包/类
public static Document getEDLContent(String documentId) {
	try {
		DocumentContent documentContent = KewApiServiceLocator.getWorkflowDocumentService().getDocumentContent(documentId);
		String content = documentContent.getFullContent();
		Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new InputSource(new StringReader(content)));
		return doc;
	} catch (Exception e) {
		if (e instanceof RuntimeException) {
			throw (RuntimeException)e;
		}
		throw new RuntimeException(e);
	}
}
 

import org.kuali.rice.kew.api.document.DocumentContent; //导入依赖的package包/类
@Override
public List<Map<String, String>> resolveMultipleRoleQualifiers(
        @WebParam(name = "kewTypeId") String kewTypeId,
        @WebParam(name = "roleId") String roleId,
        @WebParam(name = "document") Document document,
        @WebParam(name = "documentContent") DocumentContent documentContent) {
    List<Map<String, String>> locationQualifiers = new ArrayList<Map<String, String>>();
    String location = getElementValue(documentContent.getApplicationContent(), "//document/newMaintainableObject/businessObject/location/@value");
    if (StringUtils.isNotEmpty(location)) {
            locationQualifiers.add(
                    Collections.singletonMap(KPMERoleMemberAttribute.LOCATION.getRoleMemberAttributeName(),
                            location));

    } else {
        //try to get values from maintainable object if instance of position
        try {
            org.kuali.rice.krad.document.Document doc = KRADServiceLocatorWeb.getDocumentService().getByDocumentHeaderId(document.getDocumentId());
            if (doc instanceof MaintenanceDocument) {
                MaintenanceDocument md =  (MaintenanceDocument)doc;
                if (md.getNewMaintainableObject().getDataObject() instanceof PositionBo) {
                    PositionBo position = (PositionBo)(md.getNewMaintainableObject().getDataObject());
                    locationQualifiers.add(
                        Collections.singletonMap(KPMERoleMemberAttribute.LOCATION.getRoleMemberAttributeName(), String.valueOf(position.getLocation())));

                }
            } else {
                // If doc itself is instance of position
                if (doc instanceof PositionBo) {
                    locationQualifiers.add(
                            Collections.singletonMap(KPMERoleMemberAttribute.LOCATION.getRoleMemberAttributeName(), String.valueOf(((PositionBo)doc).getLocation())));
                }
            }
        } catch (WorkflowException e) {
            LOG.error("Unable to retrieve document with documemnt ID: " + document.getDocumentId());
        }
    }

    return locationQualifiers;

}
 

import org.kuali.rice.kew.api.document.DocumentContent; //导入依赖的package包/类
@Override
public List<Map<String, String>> resolveMultipleRoleQualifiers(
        @WebParam(name = "kewTypeId") String kewTypeId,
        @WebParam(name = "roleId") String roleId,
        @WebParam(name = "document") Document document,
        @WebParam(name = "documentContent") DocumentContent documentContent) {
    List<Map<String, String>> institutionQualifiers = new ArrayList<Map<String, String>>();
    String institution = getElementValue(documentContent.getApplicationContent(), "//document/newMaintainableObject/businessObject/institution/@value");
    if (StringUtils.isNotEmpty(institution)) {
           institutionQualifiers.add(
                    Collections.singletonMap(KPMERoleMemberAttribute.INSTITUION.getRoleMemberAttributeName(),
                            institution));

    } else {
        //try to get values from maintainable object if instance of position
        try {
            org.kuali.rice.krad.document.Document doc = KRADServiceLocatorWeb.getDocumentService().getByDocumentHeaderId(document.getDocumentId());
            if (doc instanceof MaintenanceDocument) {
                MaintenanceDocument md =  (MaintenanceDocument)doc;
                if (md.getNewMaintainableObject().getDataObject() instanceof PositionBo) {
                    PositionBo position = (PositionBo)(md.getNewMaintainableObject().getDataObject());
                    institutionQualifiers.add(
                        Collections.singletonMap(KPMERoleMemberAttribute.INSTITUION.getRoleMemberAttributeName(), String.valueOf(position.getInstitution())));

                }
            } else {
                // If doc itself is instance of position
                if (doc instanceof PositionBo) {
                    institutionQualifiers.add(
                            Collections.singletonMap(KPMERoleMemberAttribute.INSTITUION.getRoleMemberAttributeName(), String.valueOf(((PositionBo)doc).getInstitution())));
                }
            }
        } catch (WorkflowException e) {
            LOG.error("Unable to retrieve document with documemnt ID: " + document.getDocumentId());
        }
    }

    return institutionQualifiers;

}
 

import org.kuali.rice.kew.api.document.DocumentContent; //导入依赖的package包/类
protected Map<String, String> loadRoleQualifiers(Context context, PeopleFlowMember member) {
    PeopleFlowTypeService peopleFlowTypeService = context.getPeopleFlowTypeService();
    if (peopleFlowTypeService != null) {
        Document document = DocumentRouteHeaderValue.to(context.getRouteContext().getDocument());
        DocumentRouteHeaderValueContent content = new DocumentRouteHeaderValueContent(document.getDocumentId());
        content.setDocumentContent(context.getRouteContext().getDocumentContent().getDocContent());
        DocumentContent documentContent = DocumentRouteHeaderValueContent.to(content);
        Map<String, String> roleQualifiers = peopleFlowTypeService.resolveRoleQualifiers(
                context.getPeopleFlow().getTypeId(), member.getMemberId(), document, documentContent);
        if (roleQualifiers != null) {
            return roleQualifiers;
        }
    }
    return Collections.emptyMap();
}
 

import org.kuali.rice.kew.api.document.DocumentContent; //导入依赖的package包/类
/**
 * Tests the conversion of a DocumentContentVO object into an XML String.  Includes generating content
 * for any attributes which are on the DocumentContentVO object.
 *
 * TODO there is some crossover between this test and the DocumentContentTest, do we really need both of them???
 */
@Test public void testBuildUpdatedDocumentContent() throws Exception {
    String startContent = "<"+DOCUMENT_CONTENT+">";
    String endContent = "</"+DOCUMENT_CONTENT+">";

    /*
     * 	// test no content, this should return null which indicates an unchanged document content VO
     * //RouteHeaderVO routeHeaderVO = new RouteHeaderVO();
     */

    // test no content, this should return empty document content
    DocumentContent contentVO = DocumentContent.Builder.create("1234").build();
    String content = contentVO.getFullContent();
    assertEquals("Invalid content conversion.", KewApiConstants.DEFAULT_DOCUMENT_CONTENT, content);

    // test simple case, no attributes
    String attributeContent = "<attribute1><id value=\"3\"/></attribute1>";
    String searchableContent = "<searchable1><data>hello</data></searchable1>";
    DocumentContent.Builder contentBuilder = DocumentContent.Builder.create("1234");
    contentBuilder.setAttributeContent(constructContent(ATTRIBUTE_CONTENT, attributeContent));
    contentBuilder.setSearchableContent(constructContent(SEARCHABLE_CONTENT, searchableContent));
    contentVO = contentBuilder.build();
    content = contentVO.getFullContent();
    String fullContent = startContent+constructContent(ATTRIBUTE_CONTENT, attributeContent)+constructContent(SEARCHABLE_CONTENT, searchableContent)+endContent;
    assertEquals("Invalid content conversion.", StringUtils.deleteWhitespace(fullContent), StringUtils.deleteWhitespace(content));

    // now, add an attribute
    String testAttributeContent = new TestRuleAttribute().getDocContent();
    WorkflowAttributeDefinition attributeDefinition = WorkflowAttributeDefinition.Builder.create(TestRuleAttribute.class.getName()).build();
    DocumentContentUpdate.Builder contentUpdate = DocumentContentUpdate.Builder.create();
    contentUpdate.getAttributeDefinitions().add(attributeDefinition);
    content = DTOConverter.buildUpdatedDocumentContent(KewApiConstants.DEFAULT_DOCUMENT_CONTENT, contentUpdate.build(), null);
    fullContent = startContent+
        constructContent(ATTRIBUTE_CONTENT, attributeContent+testAttributeContent)+
        constructContent(SEARCHABLE_CONTENT, searchableContent)+
        endContent;
    assertEquals("Invalid content conversion.", StringUtils.deleteWhitespace(fullContent), StringUtils.deleteWhitespace(content));
}
 

import org.kuali.rice.kew.api.document.DocumentContent; //导入依赖的package包/类
@Override
public DocumentContent getDocumentContent() {
    return null;
}
 

import org.kuali.rice.kew.api.document.DocumentContent; //导入依赖的package包/类
protected ModifiableDocumentContent(DocumentContent documentContent) {
    this.dirty = false;
    this.originalDocumentContent = documentContent;
    this.builder = DocumentContentUpdate.Builder.create(documentContent);
}
 

import org.kuali.rice.kew.api.document.DocumentContent; //导入依赖的package包/类
/**
 * Tests the conversion of a String into a DocumentContentVO object which should split the
 * String into it's 3 distinct components.
 */
@Test public void testConvertDocumentContent() throws Exception {

    // test null content
    String attributeContent = null;
    String searchableContent = null;
    String applicationContent = null;
    String xmlContent = constructContent(attributeContent, searchableContent, applicationContent);
    DocumentContent.Builder builder = DocumentContent.Builder.create("-1234");
    builder.setApplicationContent(applicationContent);
    builder.setAttributeContent(attributeContent);
    builder.setSearchableContent(searchableContent);

    DocumentContent content = builder.build();
    assertFalse("Content cannot be empty.", org.apache.commons.lang.StringUtils.isEmpty(content.getFullContent()));
    assertEquals("Attribute content is invalid.", null, content.getAttributeContent());
    assertEquals("Searchable content is invalid.", null, content.getSearchableContent());
    assertEquals("Application content is invalid.", null, content.getApplicationContent());
    assertEquals("Should have fake document id.", "-1234", content.getDocumentId());

    // test empty content
    attributeContent = "";
    searchableContent = "";
    applicationContent = "";
    builder = DocumentContent.Builder.create("testId");
    builder.setApplicationContent(applicationContent);
    builder.setAttributeContent(attributeContent);
    builder.setSearchableContent(searchableContent);
    content = builder.build();
    assertContent(content, attributeContent, searchableContent, applicationContent);

    // test fancy dancy content
    attributeContent = "<iEnjoyFlexContent><id>1234</id></iEnjoyFlexContent>";
    searchableContent = "<thisIdBeWarrenG>Warren G</thisIdBeWarrenG><whatsMyName>Snoop</whatsMyName>";
    applicationContent = "<thisIsTotallyRad><theCoolestContentInTheWorld qualify=\"iSaidSo\">it's marvelous!</theCoolestContentInTheWorld></thisIsTotallyRad>";
    builder = DocumentContent.Builder.create("testId");
    builder.setApplicationContent(applicationContent);
    builder.setAttributeContent(attributeContent);
    builder.setSearchableContent(searchableContent);
    content = builder.build();
    assertContent(content, attributeContent, searchableContent, applicationContent);
}
 

import org.kuali.rice.kew.api.document.DocumentContent; //导入依赖的package包/类
@Test public void testEmptyDocumentContent() throws Exception {
    DocumentContent content = DocumentContent.Builder.create("1234").build();
    assertEquals("<"+DOCUMENT_CONTENT + "></"+DOCUMENT_CONTENT+">", content.getFullContent());
}