| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.chemistry.opencmis.commons.impl.server; |
| |
| import static org.apache.chemistry.opencmis.commons.impl.CollectionsHelper.isNotEmpty; |
| |
| import java.math.BigInteger; |
| import java.util.ArrayList; |
| import java.util.GregorianCalendar; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.apache.chemistry.opencmis.commons.PropertyIds; |
| import org.apache.chemistry.opencmis.commons.data.Acl; |
| import org.apache.chemistry.opencmis.commons.data.AllowableActions; |
| import org.apache.chemistry.opencmis.commons.data.BulkUpdateObjectIdAndChangeToken; |
| import org.apache.chemistry.opencmis.commons.data.ContentStream; |
| import org.apache.chemistry.opencmis.commons.data.ExtensionsData; |
| import org.apache.chemistry.opencmis.commons.data.FailedToDeleteData; |
| import org.apache.chemistry.opencmis.commons.data.ObjectData; |
| import org.apache.chemistry.opencmis.commons.data.ObjectInFolderContainer; |
| import org.apache.chemistry.opencmis.commons.data.ObjectInFolderList; |
| import org.apache.chemistry.opencmis.commons.data.ObjectList; |
| import org.apache.chemistry.opencmis.commons.data.ObjectParentData; |
| import org.apache.chemistry.opencmis.commons.data.Properties; |
| import org.apache.chemistry.opencmis.commons.data.PropertyBoolean; |
| import org.apache.chemistry.opencmis.commons.data.PropertyData; |
| import org.apache.chemistry.opencmis.commons.data.PropertyDateTime; |
| import org.apache.chemistry.opencmis.commons.data.PropertyId; |
| import org.apache.chemistry.opencmis.commons.data.PropertyInteger; |
| import org.apache.chemistry.opencmis.commons.data.PropertyString; |
| import org.apache.chemistry.opencmis.commons.data.RenditionData; |
| import org.apache.chemistry.opencmis.commons.data.RepositoryCapabilities; |
| import org.apache.chemistry.opencmis.commons.data.RepositoryInfo; |
| import org.apache.chemistry.opencmis.commons.definitions.TypeDefinition; |
| import org.apache.chemistry.opencmis.commons.definitions.TypeDefinitionContainer; |
| import org.apache.chemistry.opencmis.commons.definitions.TypeDefinitionList; |
| import org.apache.chemistry.opencmis.commons.enums.AclPropagation; |
| import org.apache.chemistry.opencmis.commons.enums.BaseTypeId; |
| import org.apache.chemistry.opencmis.commons.enums.CapabilityAcl; |
| import org.apache.chemistry.opencmis.commons.enums.IncludeRelationships; |
| import org.apache.chemistry.opencmis.commons.enums.RelationshipDirection; |
| import org.apache.chemistry.opencmis.commons.enums.UnfileObject; |
| import org.apache.chemistry.opencmis.commons.enums.VersioningState; |
| import org.apache.chemistry.opencmis.commons.exceptions.CmisInvalidArgumentException; |
| import org.apache.chemistry.opencmis.commons.exceptions.CmisNotSupportedException; |
| import org.apache.chemistry.opencmis.commons.exceptions.CmisObjectNotFoundException; |
| import org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException; |
| import org.apache.chemistry.opencmis.commons.impl.dataobjects.TypeDefinitionContainerImpl; |
| import org.apache.chemistry.opencmis.commons.server.CmisService; |
| import org.apache.chemistry.opencmis.commons.server.ObjectInfo; |
| import org.apache.chemistry.opencmis.commons.server.ObjectInfoHandler; |
| import org.apache.chemistry.opencmis.commons.server.RenditionInfo; |
| import org.apache.chemistry.opencmis.commons.spi.Holder; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| public abstract class AbstractCmisService implements CmisService, ObjectInfoHandler { |
| |
| private static final Logger LOG = LoggerFactory.getLogger(AbstractCmisService.class); |
| |
| private Map<String, ObjectInfo> objectInfoMap; |
| private boolean addObjectInfos = true; |
| |
| // --- repository service --- |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is required. Convenience implementation is present.</li> |
| * </ul> |
| */ |
| @Override |
| public RepositoryInfo getRepositoryInfo(String repositoryId, ExtensionsData extension) { |
| RepositoryInfo result = null; |
| |
| List<RepositoryInfo> repositories = getRepositoryInfos(extension); |
| if (repositories != null) { |
| for (RepositoryInfo ri : repositories) { |
| if (ri.getId().equals(repositoryId)) { |
| result = ri; |
| break; |
| } |
| } |
| } |
| |
| if (result == null) { |
| throw new CmisObjectNotFoundException("Repository '" + repositoryId + "' does not exist!"); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is required.</li> |
| * </ul> |
| */ |
| @Override |
| public abstract List<RepositoryInfo> getRepositoryInfos(ExtensionsData extension); |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is required.</li> |
| * </ul> |
| */ |
| @Override |
| public abstract TypeDefinitionList getTypeChildren(String repositoryId, String typeId, |
| Boolean includePropertyDefinitions, BigInteger maxItems, BigInteger skipCount, ExtensionsData extension); |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional. Convenience implementation is present.</li> |
| * </ul> |
| */ |
| @Override |
| public List<TypeDefinitionContainer> getTypeDescendants(String repositoryId, String typeId, BigInteger depth, |
| Boolean includePropertyDefinitions, ExtensionsData extension) { |
| // check depth |
| int d = (depth == null ? -1 : depth.intValue()); |
| if (d == 0) { |
| throw new CmisInvalidArgumentException("Depth must not be 0!"); |
| } |
| if (typeId == null) { |
| d = -1; |
| } |
| |
| List<TypeDefinitionContainer> result = new ArrayList<TypeDefinitionContainer>(); |
| |
| TypeDefinitionList children = getTypeChildren(repositoryId, typeId, includePropertyDefinitions, |
| BigInteger.valueOf(Integer.MAX_VALUE), BigInteger.ZERO, null); |
| |
| if (children != null && isNotEmpty(children.getList())) { |
| for (TypeDefinition td : children.getList()) { |
| TypeDefinitionContainerImpl tdc = new TypeDefinitionContainerImpl(td); |
| addTypeChildren(repositoryId, includePropertyDefinitions, (d > 0 ? d - 1 : -1), tdc); |
| result.add(tdc); |
| } |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Helper method for |
| * {@link #getTypeDescendants(String, String, BigInteger, Boolean, ExtensionsData)} |
| * . |
| */ |
| private void addTypeChildren(String repositoryId, Boolean includePropertyDefinitions, int depth, |
| TypeDefinitionContainerImpl container) { |
| |
| if (depth == 0) { |
| return; |
| } |
| |
| TypeDefinitionList children = getTypeChildren(repositoryId, container.getTypeDefinition().getId(), |
| includePropertyDefinitions, BigInteger.valueOf(Integer.MAX_VALUE), BigInteger.ZERO, null); |
| |
| if (children != null && isNotEmpty(children.getList())) { |
| List<TypeDefinitionContainer> list = new ArrayList<TypeDefinitionContainer>(); |
| container.setChildren(list); |
| |
| for (TypeDefinition td : children.getList()) { |
| TypeDefinitionContainerImpl tdc = new TypeDefinitionContainerImpl(td); |
| addTypeChildren(repositoryId, includePropertyDefinitions, (depth > 0 ? depth - 1 : -1), tdc); |
| list.add(tdc); |
| } |
| } |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is required.</li> |
| * </ul> |
| */ |
| @Override |
| public abstract TypeDefinition getTypeDefinition(String repositoryId, String typeId, ExtensionsData extension); |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * <li>Introduced in CMIS 1.1</li> |
| * </ul> |
| */ |
| @Override |
| public TypeDefinition createType(String repositoryId, TypeDefinition type, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * <li>Introduced in CMIS 1.1</li> |
| * </ul> |
| */ |
| @Override |
| public TypeDefinition updateType(String repositoryId, TypeDefinition type, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * <li>Introduced in CMIS 1.1</li> |
| * </ul> |
| */ |
| @Override |
| public void deleteType(String repositoryId, String typeId, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| // --- navigation service --- |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is required.</li> |
| * <li>Object infos should contain the folder and all returned children.</li> |
| * </ul> |
| */ |
| @Override |
| public abstract ObjectInFolderList getChildren(String repositoryId, String folderId, String filter, String orderBy, |
| Boolean includeAllowableActions, IncludeRelationships includeRelationships, String renditionFilter, |
| Boolean includePathSegment, BigInteger maxItems, BigInteger skipCount, ExtensionsData extension); |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * <li>Object infos should contain the folder and all returned descendants.</li> |
| * </ul> |
| */ |
| @Override |
| public List<ObjectInFolderContainer> getDescendants(String repositoryId, String folderId, BigInteger depth, |
| String filter, Boolean includeAllowableActions, IncludeRelationships includeRelationships, |
| String renditionFilter, Boolean includePathSegment, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * <li>Object infos should contain the folder and all returned descendants.</li> |
| * </ul> |
| */ |
| @Override |
| public List<ObjectInFolderContainer> getFolderTree(String repositoryId, String folderId, BigInteger depth, |
| String filter, Boolean includeAllowableActions, IncludeRelationships includeRelationships, |
| String renditionFilter, Boolean includePathSegment, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is required.</li> |
| * <li>Object infos should contain the object and all returned parents.</li> |
| * </ul> |
| */ |
| @Override |
| public abstract List<ObjectParentData> getObjectParents(String repositoryId, String objectId, String filter, |
| Boolean includeAllowableActions, IncludeRelationships includeRelationships, String renditionFilter, |
| Boolean includeRelativePathSegment, ExtensionsData extension); |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * <li>Object infos should contain the returned parent folder.</li> |
| * </ul> |
| */ |
| @Override |
| public ObjectData getFolderParent(String repositoryId, String folderId, String filter, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * <li>Object infos should contain the folder and the returned objects.</li> |
| * </ul> |
| */ |
| @Override |
| public ObjectList getCheckedOutDocs(String repositoryId, String folderId, String filter, String orderBy, |
| Boolean includeAllowableActions, IncludeRelationships includeRelationships, String renditionFilter, |
| BigInteger maxItems, BigInteger skipCount, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| // --- object service --- |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub</li> |
| * <li>Implementation is optional. Convenience implementation is present.</li> |
| * <li>Object infos should contain the newly created object.</li> |
| * </ul> |
| */ |
| @Override |
| public String create(String repositoryId, Properties properties, String folderId, ContentStream contentStream, |
| VersioningState versioningState, List<String> policies, ExtensionsData extension) { |
| // check properties |
| if (properties == null || properties.getProperties() == null) { |
| throw new CmisInvalidArgumentException("Properties must be set!"); |
| } |
| |
| // check object type id |
| PropertyData<?> obbjectTypeIdProperty = properties.getProperties().get(PropertyIds.OBJECT_TYPE_ID); |
| if (obbjectTypeIdProperty == null || !(obbjectTypeIdProperty.getFirstValue() instanceof String)) { |
| throw new CmisInvalidArgumentException("Property '" + PropertyIds.OBJECT_TYPE_ID + "' must be set!"); |
| } |
| |
| // get the type |
| String objectTypeId = obbjectTypeIdProperty.getFirstValue().toString(); |
| TypeDefinition type = getTypeDefinition(repositoryId, objectTypeId, null); |
| |
| // create object |
| String newId; |
| switch (type.getBaseTypeId()) { |
| case CMIS_DOCUMENT: |
| newId = createDocument(repositoryId, properties, folderId, contentStream, versioningState, policies, null, |
| null, extension); |
| break; |
| case CMIS_FOLDER: |
| newId = createFolder(repositoryId, properties, folderId, policies, null, null, extension); |
| break; |
| case CMIS_POLICY: |
| newId = createPolicy(repositoryId, properties, folderId, policies, null, null, extension); |
| break; |
| case CMIS_ITEM: |
| newId = createItem(repositoryId, properties, folderId, policies, null, null, extension); |
| break; |
| default: |
| newId = null; |
| } |
| |
| // check new object id |
| if (newId == null) { |
| throw new CmisRuntimeException("Creation failed!"); |
| } |
| |
| // return the new object id |
| return newId; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * </ul> |
| */ |
| @Override |
| public String createDocument(String repositoryId, Properties properties, String folderId, |
| ContentStream contentStream, VersioningState versioningState, List<String> policies, Acl addAces, |
| Acl removeAces, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * </ul> |
| */ |
| @Override |
| public String createDocumentFromSource(String repositoryId, String sourceId, Properties properties, |
| String folderId, VersioningState versioningState, List<String> policies, Acl addAces, Acl removeAces, |
| ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * </ul> |
| */ |
| @Override |
| public String createFolder(String repositoryId, Properties properties, String folderId, List<String> policies, |
| Acl addAces, Acl removeAces, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * <li>Object infos should contain the newly created object.</li> |
| * </ul> |
| */ |
| @Override |
| public String createRelationship(String repositoryId, Properties properties, List<String> policies, Acl addAces, |
| Acl removeAces, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * </ul> |
| */ |
| @Override |
| public String createPolicy(String repositoryId, Properties properties, String folderId, List<String> policies, |
| Acl addAces, Acl removeAces, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * </ul> |
| */ |
| @Override |
| public String createItem(String repositoryId, Properties properties, String folderId, List<String> policies, |
| Acl addAces, Acl removeAces, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional. Convenience implementation is present.</li> |
| * </ul> |
| */ |
| @Override |
| public AllowableActions getAllowableActions(String repositoryId, String objectId, ExtensionsData extension) { |
| return getObject(repositoryId, objectId, "cmis:objectId", true, IncludeRelationships.NONE, "cmis:none", false, |
| false, extension).getAllowableActions(); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is required.</li> |
| * <li>Object infos should contain the returned object.</li> |
| * </ul> |
| */ |
| @Override |
| public abstract ObjectData getObject(String repositoryId, String objectId, String filter, |
| Boolean includeAllowableActions, IncludeRelationships includeRelationships, String renditionFilter, |
| Boolean includePolicyIds, Boolean includeAcl, ExtensionsData extension); |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: Web Services, Browser, Local</li> |
| * <li>Implementation is optional. Convenience implementation is present.</li> |
| * </ul> |
| */ |
| @Override |
| public Properties getProperties(String repositoryId, String objectId, String filter, ExtensionsData extension) { |
| return getObject(repositoryId, objectId, filter, false, IncludeRelationships.NONE, "cmis:none", false, false, |
| extension).getProperties(); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * </ul> |
| */ |
| @Override |
| public List<RenditionData> getRenditions(String repositoryId, String objectId, String renditionFilter, |
| BigInteger maxItems, BigInteger skipCount, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * <li>Object infos should contain the returned object.</li> |
| * </ul> |
| */ |
| @Override |
| public ObjectData getObjectByPath(String repositoryId, String path, String filter, Boolean includeAllowableActions, |
| IncludeRelationships includeRelationships, String renditionFilter, Boolean includePolicyIds, |
| Boolean includeAcl, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * </ul> |
| */ |
| @Override |
| public ContentStream getContentStream(String repositoryId, String objectId, String streamId, BigInteger offset, |
| BigInteger length, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * <li>Object infos should contain the updated object.</li> |
| * </ul> |
| */ |
| @Override |
| public void updateProperties(String repositoryId, Holder<String> objectId, Holder<String> changeToken, |
| Properties properties, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * <li>Introduced in CMIS 1.1</li> |
| * </ul> |
| */ |
| @Override |
| public List<BulkUpdateObjectIdAndChangeToken> bulkUpdateProperties(String repositoryId, |
| List<BulkUpdateObjectIdAndChangeToken> objectIdAndChangeToken, Properties properties, |
| List<String> addSecondaryTypeIds, List<String> removeSecondaryTypeIds, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * <li>Object infos should contain the moved object.</li> |
| * </ul> |
| */ |
| @Override |
| public void moveObject(String repositoryId, Holder<String> objectId, String targetFolderId, String sourceFolderId, |
| ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: Web Services, Browser, Local</li> |
| * <li>Implementation is optional. Convenience implementation is present |
| * (forwards to |
| * {@link #deleteObjectOrCancelCheckOut(String, String, Boolean, ExtensionsData)} |
| * ).</li> |
| * </ul> |
| */ |
| @Override |
| public void deleteObject(String repositoryId, String objectId, Boolean allVersions, ExtensionsData extension) { |
| deleteObjectOrCancelCheckOut(repositoryId, objectId, allVersions, extension); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub</li> |
| * <li>Implementation is optional.</li> |
| * </ul> |
| */ |
| @Override |
| public void deleteObjectOrCancelCheckOut(String repositoryId, String objectId, Boolean allVersions, |
| ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * </ul> |
| */ |
| @Override |
| public FailedToDeleteData deleteTree(String repositoryId, String folderId, Boolean allVersions, |
| UnfileObject unfileObjects, Boolean continueOnFailure, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * </ul> |
| */ |
| @Override |
| public void setContentStream(String repositoryId, Holder<String> objectId, Boolean overwriteFlag, |
| Holder<String> changeToken, ContentStream contentStream, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * <li>Introduced in CMIS 1.1</li> |
| * </ul> |
| */ |
| @Override |
| public void appendContentStream(String repositoryId, Holder<String> objectId, Holder<String> changeToken, |
| ContentStream contentStream, boolean isLastChunk, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * </ul> |
| */ |
| @Override |
| public void deleteContentStream(String repositoryId, Holder<String> objectId, Holder<String> changeToken, |
| ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| // --- versioning service --- |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * <li>Object infos should contain the checked out object.</li> |
| * </ul> |
| */ |
| @Override |
| public void checkOut(String repositoryId, Holder<String> objectId, ExtensionsData extension, |
| Holder<Boolean> contentCopied) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * </ul> |
| */ |
| @Override |
| public void cancelCheckOut(String repositoryId, String objectId, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * <li>Object infos should contain the checked in object.</li> |
| * </ul> |
| */ |
| @Override |
| public void checkIn(String repositoryId, Holder<String> objectId, Boolean major, Properties properties, |
| ContentStream contentStream, String checkinComment, List<String> policies, Acl addAces, Acl removeAces, |
| ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * <li>Object infos should contain the returned object.</li> |
| * </ul> |
| */ |
| @Override |
| public ObjectData getObjectOfLatestVersion(String repositoryId, String objectId, String versionSeriesId, |
| Boolean major, String filter, Boolean includeAllowableActions, IncludeRelationships includeRelationships, |
| String renditionFilter, Boolean includePolicyIds, Boolean includeAcl, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: Web Services, Local</li> |
| * <li>Implementation is optional. Convenience implementation is present, if |
| * {@link #getObjectOfLatestVersion(String, String, String, Boolean, String, Boolean, IncludeRelationships, String, Boolean, Boolean, ExtensionsData)} |
| * is implemented.</li> |
| * </ul> |
| */ |
| @Override |
| public Properties getPropertiesOfLatestVersion(String repositoryId, String objectId, String versionSeriesId, |
| Boolean major, String filter, ExtensionsData extension) { |
| return getObjectOfLatestVersion(repositoryId, objectId, versionSeriesId, major, filter, false, |
| IncludeRelationships.NONE, "cmis:none", false, false, extension).getProperties(); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * <li>Object infos should contain the returned objects.</li> |
| * </ul> |
| */ |
| @Override |
| public List<ObjectData> getAllVersions(String repositoryId, String objectId, String versionSeriesId, String filter, |
| Boolean includeAllowableActions, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| // --- discovery service --- |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * <li>Object infos should contain the returned objects.</li> |
| * </ul> |
| */ |
| @Override |
| public ObjectList getContentChanges(String repositoryId, Holder<String> changeLogToken, Boolean includeProperties, |
| String filter, Boolean includePolicyIds, Boolean includeAcl, BigInteger maxItems, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * </ul> |
| */ |
| @Override |
| public ObjectList query(String repositoryId, String statement, Boolean searchAllVersions, |
| Boolean includeAllowableActions, IncludeRelationships includeRelationships, String renditionFilter, |
| BigInteger maxItems, BigInteger skipCount, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| // --- multi filing service --- |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * <li>Object infos should contain the added object.</li> |
| * </ul> |
| */ |
| @Override |
| public void addObjectToFolder(String repositoryId, String objectId, String folderId, Boolean allVersions, |
| ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * <li>Object infos should contain the removed object.</li> |
| * </ul> |
| */ |
| @Override |
| public void removeObjectFromFolder(String repositoryId, String objectId, String folderId, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| // --- relationship service --- |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * <li>Object infos should contain the object and the returned relationship |
| * objects.</li> |
| * </ul> |
| */ |
| @Override |
| public ObjectList getObjectRelationships(String repositoryId, String objectId, Boolean includeSubRelationshipTypes, |
| RelationshipDirection relationshipDirection, String typeId, String filter, Boolean includeAllowableActions, |
| BigInteger maxItems, BigInteger skipCount, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| // --- ACL service --- |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * </ul> |
| */ |
| @Override |
| public Acl applyAcl(String repositoryId, String objectId, Acl addAces, Acl removeAces, |
| AclPropagation aclPropagation, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub</li> |
| * <li>Implementation is optional.</li> |
| * </ul> |
| */ |
| @Override |
| public Acl applyAcl(String repositoryId, String objectId, Acl aces, AclPropagation aclPropagation) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * </ul> |
| */ |
| @Override |
| public Acl getAcl(String repositoryId, String objectId, Boolean onlyBasicPermissions, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| // --- policy service --- |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * <li>Object infos should contain the applied policy object.</li> |
| * </ul> |
| */ |
| @Override |
| public void applyPolicy(String repositoryId, String policyId, String objectId, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * <li>Object infos should contain the returned policy objects.</li> |
| * </ul> |
| */ |
| @Override |
| public List<ObjectData> getAppliedPolicies(String repositoryId, String objectId, String filter, |
| ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub, Web Services, Browser, Local</li> |
| * <li>Implementation is optional.</li> |
| * </ul> |
| */ |
| @Override |
| public void removePolicy(String repositoryId, String policyId, String objectId, ExtensionsData extension) { |
| throw new CmisNotSupportedException("Not supported!"); |
| } |
| |
| // --- server specific --- |
| |
| /** |
| * Returns the object info map. |
| */ |
| private Map<String, ObjectInfo> getObjectInfoMap() { |
| if (objectInfoMap == null) { |
| objectInfoMap = new HashMap<String, ObjectInfo>(2); |
| } |
| |
| return objectInfoMap; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p> |
| * <b>Implementation Hints:</b> |
| * <ul> |
| * <li>Bindings: AtomPub</li> |
| * <li>If the object info is not found, the object info will be assembled. |
| * To do that the repository info, the object, the object parent, the object |
| * history and the base type definitions will be fetched. If you want to |
| * change this behavior, override this method.</li> |
| * </ul> |
| */ |
| @Override |
| public ObjectInfo getObjectInfo(String repositoryId, String objectId) { |
| Map<String, ObjectInfo> oim = getObjectInfoMap(); |
| ObjectInfo info = oim.get(objectId); |
| if (info == null) { |
| // object info has not been found -> create one |
| try { |
| // switch off object info collection to avoid side effects |
| addObjectInfos = false; |
| |
| // get the object and its info |
| ObjectData object = getObject(repositoryId, objectId, null, Boolean.TRUE, IncludeRelationships.BOTH, |
| "*", Boolean.TRUE, Boolean.FALSE, null); |
| info = getObjectInfoIntern(repositoryId, object); |
| |
| // switch on object info collection |
| addObjectInfos = true; |
| |
| // add object info |
| addObjectInfo(info); |
| } catch (Exception e) { |
| info = null; |
| |
| if (LOG.isTraceEnabled()) { |
| LOG.trace("Getting the object info for object {} in repository {} failed: {}", objectId, |
| repositoryId, e.toString(), e); |
| } |
| } finally { |
| addObjectInfos = true; |
| } |
| } |
| return info; |
| } |
| |
| /** |
| * Collects the {@link ObjectInfo} about an object. |
| * |
| * @param repositoryId |
| * the repository id |
| * @param object |
| * the object |
| * @return the collected object info |
| */ |
| protected ObjectInfo getObjectInfoIntern(String repositoryId, ObjectData object) { |
| // if the object has no properties, stop here |
| if (object.getProperties() == null || object.getProperties().getProperties() == null) { |
| throw new CmisRuntimeException("No properties!"); |
| } |
| |
| ObjectInfoImpl info = new ObjectInfoImpl(); |
| |
| // get the repository info |
| RepositoryInfo repositoryInfo = null; |
| try { |
| repositoryInfo = getRepositoryInfo(repositoryId, null); |
| } catch (CmisRuntimeException e) { |
| LOG.error("getRepositoryInfo returned an error while compiling object info for object {}.", object.getId(), |
| e); |
| throw e; |
| } |
| |
| // general properties |
| info.setObject(object); |
| info.setId(object.getId()); |
| info.setName(getStringProperty(object, PropertyIds.NAME)); |
| info.setCreatedBy(getStringProperty(object, PropertyIds.CREATED_BY)); |
| info.setCreationDate(getDateTimeProperty(object, PropertyIds.CREATION_DATE)); |
| info.setLastModificationDate(getDateTimeProperty(object, PropertyIds.LAST_MODIFICATION_DATE)); |
| info.setTypeId(getIdProperty(object, PropertyIds.OBJECT_TYPE_ID)); |
| info.setBaseType(object.getBaseTypeId()); |
| |
| // versioning |
| info.setIsCurrentVersion(object.getBaseTypeId() == BaseTypeId.CMIS_DOCUMENT); |
| info.setWorkingCopyId(null); |
| info.setWorkingCopyOriginalId(null); |
| |
| info.setVersionSeriesId(getIdProperty(object, PropertyIds.VERSION_SERIES_ID)); |
| if (info.getVersionSeriesId() != null) { |
| Boolean isLatest = getBooleanProperty(object, PropertyIds.IS_LATEST_VERSION); |
| info.setIsCurrentVersion(isLatest == null ? true : isLatest.booleanValue()); |
| |
| Boolean isCheckedOut = getBooleanProperty(object, PropertyIds.IS_VERSION_SERIES_CHECKED_OUT); |
| if (isCheckedOut != null && isCheckedOut.booleanValue()) { |
| info.setWorkingCopyId(getIdProperty(object, PropertyIds.VERSION_SERIES_CHECKED_OUT_ID)); |
| |
| // get latest version |
| try { |
| List<ObjectData> versions = getAllVersions(repositoryId, object.getId(), info.getVersionSeriesId(), |
| null, Boolean.FALSE, null); |
| if (isNotEmpty(versions)) { |
| info.setWorkingCopyOriginalId(versions.get(0).getId()); |
| } |
| } catch (CmisNotSupportedException nse) { |
| if (LOG.isWarnEnabled()) { |
| LOG.warn("getAllVersions is not implemented! Object info for object {} might be incorrect.", |
| info.getId(), nse); |
| } |
| } |
| } |
| } |
| |
| // content |
| String fileName = getStringProperty(object, PropertyIds.CONTENT_STREAM_FILE_NAME); |
| String mimeType = getStringProperty(object, PropertyIds.CONTENT_STREAM_MIME_TYPE); |
| String streamId = getIdProperty(object, PropertyIds.CONTENT_STREAM_ID); |
| BigInteger length = getIntegerProperty(object, PropertyIds.CONTENT_STREAM_LENGTH); |
| boolean hasContent = fileName != null || mimeType != null || streamId != null || length != null; |
| if (hasContent) { |
| info.setHasContent(hasContent); |
| info.setContentType(mimeType); |
| info.setFileName(fileName); |
| } else { |
| info.setHasContent(false); |
| info.setContentType(null); |
| info.setFileName(null); |
| } |
| |
| // parent |
| if (object.getBaseTypeId() == BaseTypeId.CMIS_RELATIONSHIP) { |
| info.setHasParent(false); |
| } else if (object.getBaseTypeId() == BaseTypeId.CMIS_FOLDER) { |
| info.setHasParent(!object.getId().equals(repositoryInfo.getRootFolderId())); |
| } else { |
| try { |
| List<ObjectParentData> parents = getObjectParents(repositoryId, object.getId(), null, Boolean.FALSE, |
| IncludeRelationships.NONE, "cmis:none", Boolean.FALSE, null); |
| info.setHasParent(isNotEmpty(parents)); |
| } catch (CmisInvalidArgumentException e) { |
| info.setHasParent(false); |
| } catch (CmisNotSupportedException nse) { |
| if (LOG.isWarnEnabled()) { |
| LOG.warn("getObjectParents is not implemented! Object info for object {} might be incorrect.", |
| info.getId(), nse); |
| } |
| } |
| } |
| |
| // policies and relationships |
| info.setSupportsRelationships(false); |
| info.setSupportsPolicies(false); |
| |
| try { |
| TypeDefinitionList baseTypesList = getTypeChildren(repositoryId, null, Boolean.FALSE, |
| BigInteger.valueOf(6), BigInteger.ZERO, null); |
| for (TypeDefinition type : baseTypesList.getList()) { |
| if (BaseTypeId.CMIS_RELATIONSHIP.value().equals(type.getId())) { |
| info.setSupportsRelationships(true); |
| } else if (BaseTypeId.CMIS_POLICY.value().equals(type.getId())) { |
| info.setSupportsPolicies(true); |
| } |
| } |
| } catch (CmisNotSupportedException nse) { |
| if (LOG.isWarnEnabled()) { |
| LOG.warn("getTypeChildren is not implemented! Object info for object {} might be incorrect.", |
| info.getId(), nse); |
| } |
| } |
| |
| // renditions |
| info.setRenditionInfos(null); |
| List<RenditionData> renditions = object.getRenditions(); |
| if (isNotEmpty(renditions)) { |
| List<RenditionInfo> renditionInfos = new ArrayList<RenditionInfo>(); |
| for (RenditionData rendition : renditions) { |
| RenditionInfoImpl renditionInfo = new RenditionInfoImpl(); |
| renditionInfo.setId(rendition.getStreamId()); |
| renditionInfo.setKind(rendition.getKind()); |
| renditionInfo.setContentType(rendition.getMimeType()); |
| renditionInfo.setTitle(rendition.getTitle()); |
| renditionInfo.setLength(rendition.getBigLength()); |
| renditionInfos.add(renditionInfo); |
| } |
| info.setRenditionInfos(renditionInfos); |
| } |
| |
| // relationships |
| info.setRelationshipSourceIds(null); |
| info.setRelationshipTargetIds(null); |
| List<ObjectData> relationships = object.getRelationships(); |
| if (isNotEmpty(relationships)) { |
| List<String> sourceIds = new ArrayList<String>(); |
| List<String> targetIds = new ArrayList<String>(); |
| for (ObjectData relationship : relationships) { |
| String sourceId = getIdProperty(relationship, PropertyIds.SOURCE_ID); |
| String targetId = getIdProperty(relationship, PropertyIds.TARGET_ID); |
| if (object.getId().equals(sourceId)) { |
| sourceIds.add(relationship.getId()); |
| } |
| if (object.getId().equals(targetId)) { |
| targetIds.add(relationship.getId()); |
| } |
| } |
| if (isNotEmpty(sourceIds)) { |
| info.setRelationshipSourceIds(sourceIds); |
| } |
| if (isNotEmpty(targetIds)) { |
| info.setRelationshipTargetIds(targetIds); |
| } |
| } |
| |
| // global settings |
| info.setHasAcl(false); |
| info.setSupportsDescendants(false); |
| info.setSupportsFolderTree(false); |
| |
| RepositoryCapabilities capabilities = repositoryInfo.getCapabilities(); |
| if (capabilities != null) { |
| info.setHasAcl(capabilities.getAclCapability() == CapabilityAcl.DISCOVER |
| || capabilities.getAclCapability() == CapabilityAcl.MANAGE); |
| if (object.getBaseTypeId() == BaseTypeId.CMIS_FOLDER) { |
| info.setSupportsDescendants(Boolean.TRUE.equals(capabilities.isGetDescendantsSupported())); |
| info.setSupportsFolderTree(Boolean.TRUE.equals(capabilities.isGetFolderTreeSupported())); |
| } |
| } |
| |
| return info; |
| } |
| |
| /** |
| * Adds an object info. |
| */ |
| @Override |
| public void addObjectInfo(ObjectInfo objectInfo) { |
| if (!addObjectInfos) { |
| return; |
| } |
| |
| if (objectInfo != null && objectInfo.getId() != null) { |
| getObjectInfoMap().put(objectInfo.getId(), objectInfo); |
| } |
| } |
| |
| /** |
| * Clears the object info map. |
| */ |
| public void clearObjectInfos() { |
| objectInfoMap = null; |
| } |
| |
| @Override |
| public void close() { |
| clearObjectInfos(); |
| } |
| |
| // --- helpers --- |
| |
| protected String getStringProperty(ObjectData object, String name) { |
| PropertyData<?> property = object.getProperties().getProperties().get(name); |
| if (property instanceof PropertyString) { |
| return ((PropertyString) property).getFirstValue(); |
| } |
| return null; |
| } |
| |
| protected String getIdProperty(ObjectData object, String name) { |
| PropertyData<?> property = object.getProperties().getProperties().get(name); |
| if (property instanceof PropertyId) { |
| return ((PropertyId) property).getFirstValue(); |
| } |
| return null; |
| } |
| |
| protected GregorianCalendar getDateTimeProperty(ObjectData object, String name) { |
| PropertyData<?> property = object.getProperties().getProperties().get(name); |
| if (property instanceof PropertyDateTime) { |
| return ((PropertyDateTime) property).getFirstValue(); |
| } |
| return null; |
| } |
| |
| protected Boolean getBooleanProperty(ObjectData object, String name) { |
| PropertyData<?> property = object.getProperties().getProperties().get(name); |
| if (property instanceof PropertyBoolean) { |
| return ((PropertyBoolean) property).getFirstValue(); |
| } |
| return null; |
| } |
| |
| protected BigInteger getIntegerProperty(ObjectData object, String name) { |
| PropertyData<?> property = object.getProperties().getProperties().get(name); |
| if (property instanceof PropertyInteger) { |
| return ((PropertyInteger) property).getFirstValue(); |
| } |
| return null; |
| } |
| } |
