Java DocumentContent类代码示例

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