Java ItemIterable类代码示例

import org.apache.chemistry.opencmis.client.api.ItemIterable; //导入依赖的package包/类
public void checkChildren(ItemIterable<CmisObject> expectedChildren)
{
	Map<String, FolderNode> expectedFolderNodes = new HashMap<String, FolderNode>();
	Map<String, CMISNode> expectedDocumentNodes = new HashMap<String, CMISNode>();
	for(CmisObject child : expectedChildren)
	{
		CMISNode dn = CMISNode.createNode(child);
		if(dn instanceof FolderNode)
		{
			expectedFolderNodes.put(getBareObjectId(dn.getNodeId()), (FolderNode)dn);
		}
		else
		{
			expectedDocumentNodes.put(getBareObjectId(dn.getNodeId()), dn);
		}
	}
	checkChildrenImpl(expectedFolderNodes, expectedDocumentNodes);
}
 

import org.apache.chemistry.opencmis.client.api.ItemIterable; //导入依赖的package包/类
public static List<Document> searchDocuments(Session pSession, String pTypeId, String pWhereClause) {
	mLog.debug("START searchDocuments(String, String");

	// per evitare il problema dei documenti duplicati
	LinkedHashMap<String, Document> lHashMapResults = new LinkedHashMap<String, Document>();

	// Temporanea disabilitazione della cache
	OperationContext lOperationContext = pSession.createOperationContext();
	lOperationContext.setCacheEnabled(false);

	ItemIterable<CmisObject> lResult = pSession.queryObjects(pTypeId, pWhereClause, false, lOperationContext);
	for (CmisObject cmisObject : lResult) {
		// TODO (Alessio) gestione paginazione (in entrata e in uscita, anche se probabilmente è
		// già gestita internamente in queryObjects)
		lHashMapResults.put(cmisObject.getId(), (Document) cmisObject);
	}

	mLog.debug("END searchDocuments(String, String");
	return new ArrayList<Document>(lHashMapResults.values());
}
 

import org.apache.chemistry.opencmis.client.api.ItemIterable; //导入依赖的package包/类
public static List<String> fullTextQuery(Session lSession, String pStrText) {

		List<String> lListResults = null;
		int lIntDocumentsFound = 0;

		mLog.debug("Start fullTextQuery(String) - ", pStrText);

		ItemIterable<QueryResult> lItemIterableQueryResult =
		        lSession.query("SELECT cmis:objectId FROM cmis:document where CONTAINS('" + pStrText + "')", false);

		lListResults = new ArrayList<String>();
		for (QueryResult lQueryResult : lItemIterableQueryResult) {
			for (PropertyData<?> lPropertyData : lQueryResult.getProperties()) {
				lListResults.add((String) lPropertyData.getFirstValue());
			}
		}

		if (lListResults != null) {
			lIntDocumentsFound = lListResults.size();
		}

		mLog.debug("End fullTextQuery(String) - ", pStrText, " - found ", lIntDocumentsFound, " documents.");

		return lListResults;
	}
 

import org.apache.chemistry.opencmis.client.api.ItemIterable; //导入依赖的package包/类
protected void deleteAllContent() {
    Session session = createSession();
    Folder rootFolder = session.getRootFolder();
    ItemIterable<CmisObject> children = rootFolder.getChildren();
    for (CmisObject cmisObject : children) {
        if ("cmis:folder".equals(cmisObject.getPropertyValue(PropertyIds.OBJECT_TYPE_ID))) {
            List<String> notDeltedIdList = ((Folder)cmisObject)
                    .deleteTree(true, UnfileObject.DELETE, true);
            if (notDeltedIdList != null && notDeltedIdList.size() > 0) {
                throw new RuntimeException("Cannot empty repo");
            }
        } else {
            cmisObject.delete(true);
        }
    }
    session.getBinding().close();
}
 

import org.apache.chemistry.opencmis.client.api.ItemIterable; //导入依赖的package包/类
private CmisObject getTargetFolder(final Session session, final BatchClassCmisConfiguration batchClassCmisConfiguration) {
	CmisObject targetFolder = null;
	LOGGER.info("Acquiring Root Folder.");
	final Folder root = session.getRootFolder();
	final ItemIterable<CmisObject> children = root.getChildren();
	LOGGER.info("Looping through Root Folder children.");
	for (final CmisObject cmisObject : children) {
		if (cmisObject != null && cmisObject.getName() != null
				&& cmisObject.getName().equalsIgnoreCase(batchClassCmisConfiguration.getFolderName())
				&& isObjectFolder(cmisObject)) {
			LOGGER.info("Verified that the target is of type cmis:folder.");
			LOGGER.info("Target folder, " + batchClassCmisConfiguration.getFolderName() + ", found.");
			targetFolder = cmisObject;
			break;
		}
	}
	return targetFolder;
}
 

import org.apache.chemistry.opencmis.client.api.ItemIterable; //导入依赖的package包/类
private void addVfsOnlyFolderTreeToSyncList(OpenCmsModule ocmsModule, String vfsPath, CmisObject vfsObject, boolean replaceExistingEntity) {
	LOG.info("Adding VFS only folder " + vfsPath);

	SyncAction syncAction = getVfsOnlySyncAction(ocmsModule.getSyncMode());
	SyncFolder syncFolder = new SyncFolder(ocmsModule, vfsPath, null, vfsObject, syncAction, replaceExistingEntity);
	syncList.add(syncFolder);

	if (syncAction != SyncAction.DELETE_VFS) {
		// traverse folder, add children to the SyncJob
		LOG.info("Get children of VFS folder " + vfsPath);
		ItemIterable<CmisObject> vfsChildren = ((Folder) vfsObject).getChildren();
		for (CmisObject child : vfsChildren) {
			String childVfsPath = vfsPath + "/" + child.getName();

			// files
			if (child.getBaseTypeId().equals(BaseTypeId.CMIS_DOCUMENT)) {
				addVfsOnlyFileToSyncList(ocmsModule, childVfsPath, child, false);
			}
			// folders
			else if (child.getBaseTypeId().equals(BaseTypeId.CMIS_FOLDER)) {
				addVfsOnlyFolderTreeToSyncList(ocmsModule, childVfsPath, child, false);
			}
		}
	}
}
 

import org.apache.chemistry.opencmis.client.api.ItemIterable; //导入依赖的package包/类
private void addModuleResourceFolderTreeToSyncList(OpenCmsModule ocmsModule, String vfsPath, CmisObject vfsObject) {
	LOG.info("Adding VFS module resource folder " + vfsPath);

	SyncFolder syncFolder = new SyncFolder(ocmsModule, vfsPath, null, vfsObject, SyncAction.PULL, false);
	syncList.add(syncFolder);

	// traverse folder, add children to the SyncJob
	LOG.info("Get children of VFS folder " + vfsPath);
	ItemIterable<CmisObject> vfsChildren = ((Folder) vfsObject).getChildren();
	for (CmisObject child : vfsChildren) {
		if (progressIndicator.isCanceled()) {
			executeSync = false;
			return;
		}
		String childVfsPath = vfsPath + "/" + child.getName();

		// files
		if (child.getBaseTypeId().equals(BaseTypeId.CMIS_DOCUMENT)) {
			addModuleResourceFileToSyncList(ocmsModule, childVfsPath, child);
		}
		// folders
		else if (child.getBaseTypeId().equals(BaseTypeId.CMIS_FOLDER)) {
			addModuleResourceFolderTreeToSyncList(ocmsModule, childVfsPath, child);
		}
	}
}
 

import org.apache.chemistry.opencmis.client.api.ItemIterable; //导入依赖的package包/类
/**
 * Build the root folders 
 * 
 * @param folderFrontLocation
 * @param docLibTree
 */
private void buildRootFolders(Location start, ItemIterable<CmisObject> items)
{
	Location startLocation = start.clone().add(VectorUtil.NORTH.clone().multiply(10));
			
	for (CmisObject item : items) 
	{
		if (item instanceof AlfrescoFolder)
		{
			// build root folder				
			buildRootFolder(startLocation, (AlfrescoFolder)item);			
			
			// move to the next folder location
			startLocation.add(VectorUtil.UP.clone().multiply(5));
		}
	}		
}
 

import org.apache.chemistry.opencmis.client.api.ItemIterable; //导入依赖的package包/类
public FolderNode getChildren(String folderId, int skipCount, int maxItems)
{
    CmisObject o = session.getObject(folderId);
    if(o instanceof Folder)
    {
        Folder f = (Folder)o;
        FolderNode ret = (FolderNode)CMISNode.createNode(f);

        OperationContextImpl ctx = new OperationContextImpl();
        ItemIterable<CmisObject> res = f.getChildren(ctx);
        res.skipTo(skipCount);
        ItemIterable<CmisObject> l = res.getPage(maxItems);
        for(CmisObject c : l)
        {
            CMISNode child = null;
            if(c.getBaseType() instanceof FolderTypeDefinition)
            {
                child = (FolderNode)CMISNode.createNode(c);
                ret.addFolder((FolderNode)child);
            }
            else
            {
                child = CMISNode.createNode(c);
                ret.addNode(child);
            }
        }

        return ret;
    }
    else
    {
        throw new IllegalArgumentException("Folder does not exist or is not a folder");
    }
}
 

import org.apache.chemistry.opencmis.client.api.ItemIterable; //导入依赖的package包/类
private List<Map<String, Object>> executeQuery(Exchange exchange) throws Exception {
    String query = exchange.getIn().getMandatoryBody(String.class);
    Boolean retrieveContent = getRetrieveContent(exchange);
    Integer readSize = getReadSize(exchange);

    ItemIterable<QueryResult> itemIterable = getSessionFacade().executeQuery(query);
    return getSessionFacade().retrieveResult(retrieveContent, readSize, itemIterable);
}
 

import org.apache.chemistry.opencmis.client.api.ItemIterable; //导入依赖的package包/类
private int pollWithQuery(CMISConsumer cmisConsumer) throws Exception {
    int count = 0;
    int pageNumber = 0;
    boolean finished = false;
    ItemIterable<QueryResult> itemIterable = executeQuery(query);
    while (!finished) {
        ItemIterable<QueryResult> currentPage = itemIterable.skipTo(count).getPage();
        LOG.debug("Processing page {}", pageNumber);
        for (QueryResult item : currentPage) {
            Map<String, Object> properties = CMISHelper.propertyDataToMap(item.getProperties());
            Object objectTypeId = item.getPropertyValueById(PropertyIds.OBJECT_TYPE_ID);
            InputStream inputStream = null;
            if (readContent && CamelCMISConstants.CMIS_DOCUMENT.equals(objectTypeId)) {
                inputStream = getContentStreamFor(item);
            }

            cmisConsumer.sendExchangeWithPropsAndBody(properties, inputStream);
            count++;
            if (count == readCount) {
                finished = true;
                break;
            }
        }
        pageNumber++;
        if (!currentPage.getHasMoreItems()) {
            finished = true;
        }
    }
    return count;
}
 

import org.apache.chemistry.opencmis.client.api.ItemIterable; //导入依赖的package包/类
public List<Map<String, Object>> retrieveResult(Boolean retrieveContent, Integer readSize,
                                                ItemIterable<QueryResult> itemIterable) {
    List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
    boolean queryForContent = retrieveContent != null ? retrieveContent : readContent;
    int documentsToRead = readSize != null ? readSize : readCount;
    int count = 0;
    int pageNumber = 0;
    boolean finished = false;
    while (!finished) {
        ItemIterable<QueryResult> currentPage = itemIterable.skipTo(count).getPage();
        LOG.debug("Processing page {}", pageNumber);
        for (QueryResult item : currentPage) {
            Map<String, Object> properties = CMISHelper.propertyDataToMap(item.getProperties());
            if (queryForContent) {
                InputStream inputStream = getContentStreamFor(item);
                properties.put(CamelCMISConstants.CAMEL_CMIS_CONTENT_STREAM, inputStream);
            }

            result.add(properties);
            count++;
            if (count == documentsToRead) {
                finished = true;
                break;
            }
        }
        pageNumber++;
        if (!currentPage.getHasMoreItems()) {
            finished = true;
        }
    }
    return result;
}
 

import org.apache.chemistry.opencmis.client.api.ItemIterable; //导入依赖的package包/类
int processFolderRecursively(Folder folder) throws Exception {
    processFolderNode(folder);

    
    OperationContext operationContext = cmisConsumer.createOperationContext();
    operationContext.setMaxItemsPerPage(pageSize);

    int count = 0;
    int pageNumber = 0;
    boolean finished = false;
    ItemIterable<CmisObject> itemIterable = folder.getChildren(operationContext);
    while (!finished) {
        ItemIterable<CmisObject> currentPage = itemIterable.skipTo(count).getPage();
        LOG.debug("Processing page {}", pageNumber);
        for (CmisObject child : currentPage) {
            if (CMISHelper.isFolder(child)) {
                Folder childFolder = (Folder)child;
                processFolderRecursively(childFolder);
            } else {
                processNonFolderNode(child, folder);
            }

            count++;
            if (totalPolled == readCount) {
                finished = true;
                break;
            }
        }
        pageNumber++;
        if (!currentPage.getHasMoreItems()) {
            finished = true;
        }
    }

    return totalPolled;
}
 

import org.apache.chemistry.opencmis.client.api.ItemIterable; //导入依赖的package包/类
private void monitorTargetFolder(final CmisObject cmisFolder, final BatchClassCmisConfiguration batchClassCmisConfiguration) {
	final Folder targetFolder = (Folder) cmisFolder;
	final ItemIterable<CmisObject> folderChildren = targetFolder.getChildren();

	LOGGER.info("ImportFolder has children count of = " + folderChildren.getTotalNumItems());
	LOGGER.info("Looping through " + batchClassCmisConfiguration.getFolderName() + " children...");

	for (final CmisObject cmisObject : folderChildren) {
		LOGGER.info("Name = " + cmisObject.getName() + "\nId = " + cmisObject.getId());
		if (cmisObject instanceof Folder) {
			LOGGER.info("Found sub folder :" + cmisObject.getName());
			LOGGER.info("Skipping sub folder for processing");
			// Uncomment below line for supporting the subfolder.
			// monitorTargetFolder(cmisFolder);
		} else if (eligibleForImport(cmisObject, batchClassCmisConfiguration)) {
			LOGGER.info("Name = " + cmisObject.getName() + " HAS NOT BEEN IMPORTED TO EPHESOFT YET!");
			// GETTING OBJECT CONTENT
			String fileName = cmisObject.getName();
			final String destinationFolder = batchClassCmisConfiguration.getBatchClass().getUncFolder() + File.separator
					+ fileName.substring(0, fileName.indexOf('.')) + "_" + System.currentTimeMillis();
			final String destinationFile = destinationFolder + File.separator + fileName;
			copyObjectToLocation(getObjectContent(cmisObject), destinationFolder, destinationFile);

			outputToXml(generatePropertiesXml(cmisObject), destinationFolder + File.separator + fileName + "_PROPERTIES" + ".xml");
			setPropertyImportFlag(cmisObject, batchClassCmisConfiguration);
		}
	}
	LOGGER.info("***** Target Folder Monitor Service Scan END *****");
}
 

import org.apache.chemistry.opencmis.client.api.ItemIterable; //导入依赖的package包/类
public FolderNode getChildren(String folderId, int skipCount, int maxItems)
{
	CmisObject o = session.getObject(folderId);
	if(o instanceof Folder)
	{
		Folder f = (Folder)o;
		FolderNode ret = (FolderNode)CMISNode.createNode(f);

		OperationContextImpl ctx = new OperationContextImpl();
		ItemIterable<CmisObject> res = f.getChildren(ctx);
		res.skipTo(skipCount);
		ItemIterable<CmisObject> l = res.getPage(maxItems);
		for(CmisObject c : l)
		{
			CMISNode child = null;
			if(c.getBaseType() instanceof FolderTypeDefinition)
			{
				child = (FolderNode)CMISNode.createNode(c);
				ret.addFolder((FolderNode)child);
			}
			else
			{
				child = CMISNode.createNode(c);
				ret.addNode(child);
			}
		}

		return ret;
	}
	else
	{
		throw new IllegalArgumentException("Folder does not exist or is not a folder");
	}
}