* 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.

*/

* File system back-end for CMIS server.

*/

    private static final String ROOT_ID = "@root@";

    private static final String SHADOW_EXT = ".cmis.xml";

    private static final String SHADOW_FOLDER = "cmis.xml";

    private static final String USER_UNKNOWN = "<unknown>";

    private static final String CMIS_READ = "cmis:read";

    private static final String CMIS_WRITE = "cmis:write";

    private static final String CMIS_ALL = "cmis:all";

    private static final int BUFFER_SIZE = 64 * 1024;

    private static final Log log = LogFactory.getLog(FileShareRepository.class);

    /** Repository id */

    private final String repositoryId;

    /** Root directory */

    private final File root;

    /** Types */

    private final TypeManager types;

    /** User table */

    private final Map<String, Boolean> userMap;

    /** Repository info */

    private final RepositoryInfoImpl repositoryInfo;

    /**

     * Constructor.

     *

     * @param repId

     *            CMIS repository id

     * @param rootPath

     *            root folder

     * @param types

     *            type manager object

     */

    public FileShareRepository(String repId, String rootPath, TypeManager types) {

        // check repository id

        if ((repId == null) || (repId.trim().length() == 0)) {

            throw new IllegalArgumentException("Invalid repository id!");

        }

        repositoryId = repId;

        // check root folder

        if ((rootPath == null) || (rootPath.trim().length() == 0)) {

            throw new IllegalArgumentException("Invalid root folder!");

        }

        root = new File(rootPath);

        if (!root.isDirectory()) {

            throw new IllegalArgumentException("Root is not a directory!");

        }

        // set types

        this.types = types;

        // set up user table

        userMap = new HashMap<String, Boolean>();

        // compile repository info

        repositoryInfo = new RepositoryInfoImpl();

        repositoryInfo.setId(repositoryId);

        repositoryInfo.setName(repositoryId);

        repositoryInfo.setDescription(repositoryId);

        repositoryInfo.setCmisVersionSupported("1.0");

        repositoryInfo.setProductName("OpenCMIS FileShare");

        repositoryInfo.setProductVersion("0.1");

        repositoryInfo.setVendorName("OpenCMIS");

        repositoryInfo.setRootFolder(ROOT_ID);

        repositoryInfo.setThinClientUri("");

        RepositoryCapabilitiesImpl capabilities = new RepositoryCapabilitiesImpl();

        capabilities.setCapabilityAcl(CapabilityAcl.DISCOVER);

        capabilities.setAllVersionsSearchable(false);

        capabilities.setCapabilityJoin(CapabilityJoin.NONE);

        capabilities.setSupportsMultifiling(false);

        capabilities.setSupportsUnfiling(false);

        capabilities.setSupportsVersionSpecificFiling(false);

        capabilities.setIsPwcSearchable(false);

        capabilities.setIsPwcUpdatable(false);

        capabilities.setCapabilityQuery(CapabilityQuery.NONE);

        capabilities.setCapabilityChanges(CapabilityChanges.NONE);

        capabilities.setCapabilityContentStreamUpdates(CapabilityContentStreamUpdates.ANYTIME);

        capabilities.setSupportsGetDescendants(true);

        capabilities.setSupportsGetFolderTree(true);

        capabilities.setCapabilityRendition(CapabilityRenditions.NONE);

        repositoryInfo.setCapabilities(capabilities);

        AclCapabilitiesDataImpl aclCapability = new AclCapabilitiesDataImpl();

        aclCapability.setSupportedPermissions(SupportedPermissions.BASIC);

        aclCapability.setAclPropagation(AclPropagation.OBJECTONLY);

        // permissions

        List<PermissionDefinition> permissions = new ArrayList<PermissionDefinition>();

        permissions.add(createPermission(CMIS_READ, "Read"));

        permissions.add(createPermission(CMIS_WRITE, "Write"));

        permissions.add(createPermission(CMIS_ALL, "All"));

        aclCapability.setPermissionDefinitionData(permissions);

        // mapping

        List<PermissionMapping> list = new ArrayList<PermissionMapping>();

        list.add(createMapping(PermissionMapping.CAN_CREATE_DOCUMENT_FOLDER, CMIS_READ));

        list.add(createMapping(PermissionMapping.CAN_CREATE_FOLDER_FOLDER, CMIS_READ));

        list.add(createMapping(PermissionMapping.CAN_DELETE_CONTENT_DOCUMENT, CMIS_WRITE));

        list.add(createMapping(PermissionMapping.CAN_DELETE_OBJECT, CMIS_ALL));

        list.add(createMapping(PermissionMapping.CAN_DELETE_TREE_FOLDER, CMIS_ALL));

        list.add(createMapping(PermissionMapping.CAN_GET_ACL_OBJECT, CMIS_READ));

        list.add(createMapping(PermissionMapping.CAN_GET_ALL_VERSIONS_VERSION_SERIES, CMIS_READ));

        list.add(createMapping(PermissionMapping.CAN_GET_CHILDREN_FOLDER, CMIS_READ));

        list.add(createMapping(PermissionMapping.CAN_GET_DESCENDENTS_FOLDER, CMIS_READ));

        list.add(createMapping(PermissionMapping.CAN_GET_FOLDER_PARENT_OBJECT, CMIS_READ));

        list.add(createMapping(PermissionMapping.CAN_GET_PARENTS_FOLDER, CMIS_READ));

        list.add(createMapping(PermissionMapping.CAN_GET_PROPERTIES_OBJECT, CMIS_READ));

        list.add(createMapping(PermissionMapping.CAN_MOVE_OBJECT, CMIS_WRITE));

        list.add(createMapping(PermissionMapping.CAN_MOVE_SOURCE, CMIS_READ));

        list.add(createMapping(PermissionMapping.CAN_MOVE_TARGET, CMIS_WRITE));

        list.add(createMapping(PermissionMapping.CAN_SET_CONTENT_DOCUMENT, CMIS_WRITE));

        list.add(createMapping(PermissionMapping.CAN_UPDATE_PROPERTIES_OBJECT, CMIS_WRITE));

        list.add(createMapping(PermissionMapping.CAN_VIEW_CONTENT_OBJECT, CMIS_READ));

        Map<String, PermissionMapping> map = new LinkedHashMap<String, PermissionMapping>();

        for (PermissionMapping pm : list) {

            map.put(pm.getKey(), pm);

        }

        aclCapability.setPermissionMappingData(map);

        repositoryInfo.setAclCapabilities(aclCapability);

    }

    private static PermissionDefinition createPermission(String permission, String description) {

        PermissionDefinitionDataImpl pd = new PermissionDefinitionDataImpl();

        pd.setPermission(permission);

        pd.setDescription(description);

        return pd;

    }

    private static PermissionMapping createMapping(String key, String permission) {

        PermissionMappingDataImpl pm = new PermissionMappingDataImpl();

        pm.setKey(key);

        pm.setPermissions(Collections.singletonList(permission));

        return pm;

    }

    /**

     * Adds a user to the repository.

     */

    public void addUser(String user, boolean readOnly) {

        if ((user == null) || (user.length() == 0)) {

            return;

        }

        userMap.put(user, readOnly);

    }

    // --- the public stuff ---

    /**

     * Returns the repository id.

     */

    public String getRepositoryId() {

        return repositoryId;

    }

    /**

     * CMIS getRepositoryInfo.

     */

    public RepositoryInfo getRepositoryInfo(CallContext context) {

        debug("getRepositoryInfo");

        checkUser(context, false);

        return repositoryInfo;

    }

    /**

     * CMIS getTypesChildren.

     */

    public TypeDefinitionList getTypesChildren(CallContext context, String typeId, boolean includePropertyDefinitions,

            BigInteger maxItems, BigInteger skipCount) {

        debug("getTypesChildren");

        checkUser(context, false);

        return types.getTypesChildren(context, typeId, includePropertyDefinitions, maxItems, skipCount);

    }

    /**

     * CMIS getTypeDefinition.

     */

    public TypeDefinition getTypeDefinition(CallContext context, String typeId) {

        debug("getTypeDefinition");

        checkUser(context, false);

        return types.getTypeDefinition(context, typeId);

    }

    /**

     * CMIS getTypesDescendants.

     */

    public List<TypeDefinitionContainer> getTypesDescendants(CallContext context, String typeId, BigInteger depth,

            Boolean includePropertyDefinitions) {

        debug("getTypesDescendants");

        checkUser(context, false);

        return types.getTypesDescendants(context, typeId, depth, includePropertyDefinitions);

    }

    /**

     * Create* dispatch for AtomPub.

     */

    public ObjectData create(CallContext context, Properties properties, String folderId, ContentStream contentStream,

            VersioningState versioningState, ObjectInfoHandler objectInfos) {

        debug("create");

        boolean userReadOnly = checkUser(context, true);

        String typeId = getTypeId(properties);

        TypeDefinition type = types.getType(typeId);

        if (type == null) {

            throw new CmisObjectNotFoundException("Type '" + typeId + "' is unknown!");

        }

        String objectId = null;

        if (type.getBaseTypeId() == BaseTypeId.CMIS_DOCUMENT) {

            objectId = createDocument(context, properties, folderId, contentStream, versioningState);

        } else if (type.getBaseTypeId() == BaseTypeId.CMIS_FOLDER) {

            objectId = createFolder(context, properties, folderId);

        } else {

            throw new CmisObjectNotFoundException("Cannot create object of type '" + typeId + "'!");

        }

        return compileObjectType(context, getFile(objectId), null, false, false, userReadOnly, objectInfos);

    }

    /**

     * CMIS createDocument.

     */

    public String createDocument(CallContext context, Properties properties, String folderId,

            ContentStream contentStream, VersioningState versioningState) {

        debug("createDocument");

        checkUser(context, true);

        // check properties

        if ((properties == null) || (properties.getProperties() == null)) {

            throw new CmisInvalidArgumentException("Properties must be set!");

        }

        // check versioning state

        if (VersioningState.NONE != versioningState) {

            throw new CmisConstraintException("Versioning not supported!");

        }

        // check type

        String typeId = getTypeId(properties);

        TypeDefinition type = types.getType(typeId);

        if (type == null) {

            throw new CmisObjectNotFoundException("Type '" + typeId + "' is unknown!");

        }

        // compile the properties

        Properties props = compileProperties(typeId, context.getUsername(),

                millisToCalendar(System.currentTimeMillis()), context.getUsername(), properties);

        // check the name

        String name = getStringProperty(properties, PropertyIds.NAME);

        if (!isValidName(name)) {

            throw new CmisNameConstraintViolationException("Name is not valid!");

        }

        // get parent File

        File parent = getFile(folderId);

        if (!parent.isDirectory()) {

            throw new CmisObjectNotFoundException("Parent is not a folder!");

        }

        // check the file

        File newFile = new File(parent, name);

        if (newFile.exists()) {

            throw new CmisNameConstraintViolationException("Document already exists!");

        }

        // create the file

        try {

            newFile.createNewFile();

        } catch (IOException e) {

            throw new CmisStorageException("Could not create file: " + e.getMessage());

        }

        // write content, if available

        if ((contentStream != null) && (contentStream.getStream() != null)) {

            try {

                OutputStream out = new BufferedOutputStream(new FileOutputStream(newFile), BUFFER_SIZE);

                InputStream in = new BufferedInputStream(contentStream.getStream(), BUFFER_SIZE);

                byte[] buffer = new byte[BUFFER_SIZE];

                int b;

                while ((b = in.read(buffer)) > -1) {

                    out.write(buffer, 0, b);

                }

                out.flush();

                out.close();

                in.close();

            } catch (Exception e) {

                throw new CmisStorageException("Could not write content: " + e.getMessage(), e);

            }

        }

        // write properties

        writePropertiesFile(newFile, props);

        return getId(newFile);

    }

    /**

     * CMIS createDocumentFromSource.

     */

    public String createDocumentFromSource(CallContext context, String sourceId, Properties properties,

            String folderId, VersioningState versioningState) {

        // check versioning state

        if (VersioningState.NONE != versioningState) {

            throw new CmisConstraintException("Versioning not supported!");

        }

        // get parent File

        File parent = getFile(folderId);

        if (!parent.isDirectory()) {

            throw new CmisObjectNotFoundException("Parent is not a folder!");

        }

        // get source File

        File source = getFile(sourceId);

        if (!source.isFile()) {

            throw new CmisObjectNotFoundException("Source is not a document!");

        }

        // file name

        String name = source.getName();

        // get properties

        PropertiesImpl sourceProperties = new PropertiesImpl();

        readCustomProperties(source, sourceProperties, null, new ObjectInfoImpl());

        // get the type id

        String typeId = getIdProperty(sourceProperties, PropertyIds.OBJECT_TYPE_ID);

        if (typeId == null) {

            typeId = TypeManager.DOCUMENT_TYPE_ID;

        }

        // copy properties

        PropertiesImpl newProperties = new PropertiesImpl();

        for (PropertyData<?> prop : sourceProperties.getProperties().values()) {

            if ((prop.getId().equals(PropertyIds.OBJECT_TYPE_ID)) || (prop.getId().equals(PropertyIds.CREATED_BY))

                    || (prop.getId().equals(PropertyIds.CREATION_DATE))

                    || (prop.getId().equals(PropertyIds.LAST_MODIFIED_BY))) {

                continue;

            }

            newProperties.addProperty(prop);

        }

        // replace properties

        if (properties != null) {

            // find new name

            String newName = getStringProperty(properties, PropertyIds.NAME);

            if (newName != null) {

                if (!isValidName(newName)) {

                    throw new CmisNameConstraintViolationException("Name is not valid!");

                }

                name = newName;

            }

            // get the property definitions

            TypeDefinition type = types.getType(typeId);

            if (type == null) {

                throw new CmisObjectNotFoundException("Type '" + typeId + "' is unknown!");

            }

            // replace with new values

            for (PropertyData<?> prop : properties.getProperties().values()) {

                PropertyDefinition<?> propType = type.getPropertyDefinitions().get(prop.getId());

                // do we know that property?

                if (propType == null) {

                    throw new CmisConstraintException("Property '" + prop.getId() + "' is unknown!");

                }

                // can it be set?

                if ((propType.getUpdatability() != Updatability.READWRITE)) {

                    throw new CmisConstraintException("Property '" + prop.getId() + "' cannot be updated!");

                }

                // empty properties are invalid

                if (isEmptyProperty(prop)) {

                    throw new CmisConstraintException("Property '" + prop.getId() + "' must not be empty!");

                }

                newProperties.addProperty(prop);

            }

        }

        addPropertyId(newProperties, typeId, null, PropertyIds.OBJECT_TYPE_ID, typeId);

        addPropertyString(newProperties, typeId, null, PropertyIds.CREATED_BY, context.getUsername());

        addPropertyDateTime(newProperties, typeId, null, PropertyIds.CREATION_DATE,

                millisToCalendar(System.currentTimeMillis()));

        addPropertyString(newProperties, typeId, null, PropertyIds.LAST_MODIFIED_BY, context.getUsername());

        // check the file

        File newFile = new File(parent, name);

        if (newFile.exists()) {

            throw new CmisNameConstraintViolationException("Document already exists.");

        }

        // create the file

        try {

            newFile.createNewFile();

        } catch (IOException e) {

            throw new CmisStorageException("Could not create file: " + e.getMessage(), e);

        }

        // copy content

        try {

            OutputStream out = new BufferedOutputStream(new FileOutputStream(newFile));

            InputStream in = new BufferedInputStream(new FileInputStream(source));

            byte[] buffer = new byte[BUFFER_SIZE];

            int b;

            while ((b = in.read(buffer)) > -1) {

                out.write(buffer, 0, b);

            }

            out.flush();

            out.close();

            in.close();

        } catch (Exception e) {

            throw new CmisStorageException("Could not roead or write content: " + e.getMessage(), e);

        }

        // write properties

        writePropertiesFile(newFile, newProperties);

        return getId(newFile);

    }

    /**

     * CMIS createFolder.

     */

    public String createFolder(CallContext context, Properties properties, String folderId) {

        debug("createFolder");

        checkUser(context, true);

        // check properties

        if ((properties == null) || (properties.getProperties() == null)) {

            throw new CmisInvalidArgumentException("Properties must be set!");

        }

        // check type

        String typeId = getTypeId(properties);

        TypeDefinition type = types.getType(typeId);

        if (type == null) {

            throw new CmisObjectNotFoundException("Type '" + typeId + "' is unknown!");

        }

        // compile the properties

        Properties props = compileProperties(typeId, context.getUsername(),

                millisToCalendar(System.currentTimeMillis()), context.getUsername(), properties);

        // check the name

        String name = getStringProperty(properties, PropertyIds.NAME);

        if (!isValidName(name)) {

            throw new CmisNameConstraintViolationException("Name is not valid.");

        }

        // get parent File

        File parent = getFile(folderId);

        if (!parent.isDirectory()) {

            throw new CmisObjectNotFoundException("Parent is not a folder!");

        }

        // create the folder

        File newFolder = new File(parent, name);

        if (!newFolder.mkdir()) {

            throw new CmisStorageException("Could not create folder!");

        }

        // write properties

        writePropertiesFile(newFolder, props);

        return getId(newFolder);

    }

    /**

     * CMIS moveObject.

     */

    public ObjectData moveObject(CallContext context, Holder<String> objectId, String targetFolderId,

            ObjectInfoHandler objectInfos) {

        debug("moveObject");

        boolean userReadOnly = checkUser(context, true);

        if (objectId == null) {

            throw new CmisInvalidArgumentException("Id is not valid!");

        }

        // get the file and parent

        File file = getFile(objectId.getValue());

        File parent = getFile(targetFolderId);

        // build new path

        File newFile = new File(parent, file.getName());

        if (newFile.exists()) {

            throw new CmisStorageException("Object already exists!");

        }

        // move it

        if (!file.renameTo(newFile)) {

            throw new CmisStorageException("Move failed!");

        } else {

            // set new id

            objectId.setValue(getId(newFile));

            // if it is a file, move properties file too

            if (newFile.isFile()) {

                File propFile = getPropertiesFile(file);

                if (propFile.exists()) {

                    File newPropFile = new File(parent, propFile.getName());

                    propFile.renameTo(newPropFile);

                }

            }

        }

        return compileObjectType(context, newFile, null, false, false, userReadOnly, objectInfos);

    }

    /**

     * CMIS setContentStream and deleteContentStream.

     */

    public void setContentStream(CallContext context, Holder<String> objectId, Boolean overwriteFlag,

            ContentStream contentStream) {

        debug("setContentStream or deleteContentStream");

        checkUser(context, true);

        if (objectId == null) {

            throw new CmisInvalidArgumentException("Id is not valid!");

        }

        // get the file

        File file = getFile(objectId.getValue());

        if (!file.isFile()) {

            throw new CmisStreamNotSupportedException("Not a file!");

        }

        // check overwrite

        boolean owf = (overwriteFlag == null ? true : overwriteFlag.booleanValue());

        if (!owf && file.length() > 0) {

            throw new CmisContentAlreadyExistsException("Content already exists!");

        }

        try {

            OutputStream out = new BufferedOutputStream(new FileOutputStream(file), BUFFER_SIZE);

            if ((contentStream == null) || (contentStream.getStream() == null)) {

                // delete content

                out.write(new byte[0]);

            } else {

                // set content

                InputStream in = new BufferedInputStream(contentStream.getStream(), BUFFER_SIZE);

                byte[] buffer = new byte[BUFFER_SIZE];

                int b;

                while ((b = in.read(buffer)) > -1) {

                    out.write(buffer, 0, b);

                }

                in.close();

            }

            out.close();

        } catch (Exception e) {

            throw new CmisStorageException("Could not write content: " + e.getMessage(), e);

        }

    }

    /**

     * CMIS deleteObject.

     */

    public void deleteObject(CallContext context, String objectId) {

        debug("deleteObject");

        checkUser(context, true);

        // get the file or folder

        File file = getFile(objectId);

        if (!file.exists()) {

            throw new CmisObjectNotFoundException("Object not found!");

        }

        // check if it is a folder and if it is empty

        if (!isFolderEmpty(file)) {

            throw new CmisConstraintException("Folder is not empty!");

        }

        // delete properties and actual file

        getPropertiesFile(file).delete();

        if (!file.delete()) {

            throw new CmisStorageException("Deletion failed!");

        }

    }

    /**

     * CMIS deleteTree.

     */

    public FailedToDeleteData deleteTree(CallContext context, String folderId, Boolean continueOnFailure) {

        debug("deleteTree");

        checkUser(context, true);

        boolean cof = (continueOnFailure == null ? false : continueOnFailure.booleanValue());

        // get the file or folder

        File file = getFile(folderId);

        FailedToDeleteDataImpl result = new FailedToDeleteDataImpl();

        result.setIds(new ArrayList<String>());

        // if it is a folder, remove it recursively

        if (file.isDirectory()) {

            deleteFolder(file, cof, result);

        } else {

            getPropertiesFile(file).delete();

            if (!file.delete()) {

                result.getIds().add(getId(file));

            }

        }

        return result;

    }

    /**

     * CMIS updateProperties.

     */

    public ObjectData updateProperties(CallContext context, Holder<String> objectId, Properties properties,

            ObjectInfoHandler objectInfos) {

        debug("updateProperties");

        boolean userReadOnly = checkUser(context, true);

        if (objectId == null) {

            throw new CmisInvalidArgumentException("Id is not valid!");

        }

        // get the file or folder

        File file = getFile(objectId.getValue());

        // get and check the new name

        String newName = getStringProperty(properties, PropertyIds.NAME);

        boolean isRename = (newName != null) && (!file.getName().equals(newName));

        if (isRename && !isValidName(newName)) {

            throw new CmisNameConstraintViolationException("Name is not valid!");

        }

        // get old properties

        PropertiesImpl oldProperties = new PropertiesImpl();

        readCustomProperties(file, oldProperties, null, new ObjectInfoImpl());

        // get the type id

        String typeId = getIdProperty(oldProperties, PropertyIds.OBJECT_TYPE_ID);

        if (typeId == null) {

            typeId = (file.isDirectory() ? TypeManager.FOLDER_TYPE_ID : TypeManager.DOCUMENT_TYPE_ID);

        }

        // get the creator

        String creator = getStringProperty(oldProperties, PropertyIds.CREATED_BY);

        if (creator == null) {

            creator = context.getUsername();

        }

        // get creation date

        GregorianCalendar creationDate = getDateTimeProperty(oldProperties, PropertyIds.CREATION_DATE);

        if (creationDate == null) {

            creationDate = millisToCalendar(file.lastModified());

        }

        // compile the properties

        Properties props = updateProperties(typeId, creator, creationDate, context.getUsername(), oldProperties,

                properties);

        // write properties

        writePropertiesFile(file, props);

        // rename file or folder if necessary

        File newFile = file;

        if (isRename) {

            File parent = file.getParentFile();

            File propFile = getPropertiesFile(file);

            newFile = new File(parent, newName);

            if (!file.renameTo(newFile)) {

                // if something went wrong, throw an exception

                throw new CmisUpdateConflictException("Could not rename object!");

            } else {

                // set new id

                objectId.setValue(getId(newFile));

                // if it is a file, rename properties file too

                if (newFile.isFile()) {

                    if (propFile.exists()) {

                        File newPropFile = new File(parent, newName + SHADOW_EXT);

                        propFile.renameTo(newPropFile);

                    }

                }

            }

        }

        return compileObjectType(context, newFile, null, false, false, userReadOnly, objectInfos);

    }

    /**

     * CMIS getObject.

     */

    public ObjectData getObject(CallContext context, String objectId, String versionServicesId, String filter,

            Boolean includeAllowableActions, Boolean includeAcl, ObjectInfoHandler objectInfos) {

        debug("getObject");

        boolean userReadOnly = checkUser(context, false);

        // check id

        if ((objectId == null) && (versionServicesId == null)) {

            throw new CmisInvalidArgumentException("Object Id must be set.");

        }

        if (objectId == null) {

            // this works only because there are no versions in a file system

            // and the object id and version series id are the same

            objectId = versionServicesId;

        }

        // get the file or folder

        File file = getFile(objectId);

        // set defaults if values not set

        boolean iaa = (includeAllowableActions == null ? false : includeAllowableActions.booleanValue());

        boolean iacl = (includeAcl == null ? false : includeAcl.booleanValue());

        // split filter

        Set<String> filterCollection = splitFilter(filter);

        // gather properties

        return compileObjectType(context, file, filterCollection, iaa, iacl, userReadOnly, objectInfos);

    }

    /**

     * CMIS getAllowableActions.

     */

    public AllowableActions getAllowableActions(CallContext context, String objectId) {

        debug("getAllowableActions");

        boolean userReadOnly = checkUser(context, false);

        File file = getFile(objectId);

        if (!file.exists()) {

            throw new CmisObjectNotFoundException("Object not found!");

        }

        return compileAllowableActions(file, userReadOnly);

    }

    /**

     * CMIS getACL.

     */

    public Acl getAcl(CallContext context, String objectId) {

        debug("getAcl");

        checkUser(context, false);

        // get the file or folder

        File file = getFile(objectId);

        if (!file.exists()) {

            throw new CmisObjectNotFoundException("Object not found!");

        }

        return compileAcl(file);

    }

    /**

     * CMIS getContentStream.

     */

    public ContentStream getContentStream(CallContext context, String objectId, BigInteger offset, BigInteger length) {

        debug("getContentStream");

        checkUser(context, false);

        if ((offset != null) || (length != null)) {

            throw new CmisInvalidArgumentException("Offset and Length are not supported!");

        }

        // get the file

        final File file = getFile(objectId);

        if (!file.isFile()) {

            throw new CmisStreamNotSupportedException("Not a file!");

        }

        if (file.length() == 0) {

            throw new CmisConstraintException("Document has no content!");

        }