Package com.logicaldoc.core.folder

Interface FolderDAO

    • Method Detail

      • findFolder

        Folder findFolder​(long folderId)
           throws PersistenceException
        Gets a folder by a given ID if it is an alias, the referenced folder is returned.
        Parameters:
        folderId - The ID
        Returns:
        A real folder that is referenced by the given ID
        Throws:
        PersistenceException - error in the database

      • findByName

        List<Folder> findByName​(String name,
                        Long tenantId)
        Finds all folders by folder name
        Parameters:
        name - name of the folder
        tenantId - Specification of the owning tenant (optional).
        Returns:
        List of folders with given folder name.

      • findByName

        List<Folder> findByName​(Folder parent,
                        String name,
                        Long tenantId,
                        boolean caseSensitive)
        Finds all folders by folder text, contained in the parent folder.
        Parameters:
        parent - The parent folder(optional)
        name - The folder name to search for
        tenantId - Specification of the owning tenant (optional). If not specified the tenant of parent is used instead
        caseSensitive - true if the search must be case sensitive
        Returns:
        List of folders with given name

      • findRoot

        Folder findRoot​(long tenantId)
        Retrieves the root folder of the given tenant
        Parameters:
        tenantId - identifier of the tenant
        Returns:
        the root folder

      • findDefaultWorkspace

        Folder findDefaultWorkspace​(long tenantId)
        Retrieves the Default workspace of the given tenant
        Parameters:
        tenantId - identifier of the tenant
        Returns:
        The default workspace

      • findByUserId

        List<Folder> findByUserId​(long userId)
        Finds authorized folders for a user
        Parameters:
        userId - ID of the user
        Returns:
        List of found folders

      • findByUserIdAndTag

        List<Folder> findByUserIdAndTag​(long userId,
                                String tag,
                                Integer max)
        Finds authorized folders for a user having a specified tag.
        Parameters:
        userId - ID of the user
        tag - Tag of the folder
        max - Optional, defines the maximum records number
        Returns:
        Collection of found folders

      • findFolderIdByUserIdAndPermission

        Collection<Long> findFolderIdByUserIdAndPermission​(long userId,
                                                   Permission permission,
                                                   Long parentId,
                                                   boolean tree)
        Finds all folders ids with a specific permission enabled on the specifies user
        Parameters:
        userId - The user identifier
        permission - The permission to check
        parentId - The id of the parent folder to inspect (optional)
        tree - If true, the parentId will be interpreted as the root of a tree
        Returns:
        List of selected folder IDs.

      • findFolderIdByUserId

        Collection<Long> findFolderIdByUserId​(long userId,
                                      Long parentId,
                                      boolean tree)
        This method selects only the folder ID from the folders for which a user is authorized.
        Parameters:
        userId - ID of the user.
        parentId - The id of the parent folder to inspect (optional)
        tree - If true, the parentId will be interpreted as the root of a tree
        Returns:
        List of selected folder IDs.

      • findFolderIdInTree

        Collection<Long> findFolderIdInTree​(long rootId,
                                    boolean includeDeleted)
        Retrieve all the ids of the folders in a given tree
        Parameters:
        rootId - Root of the tree
        includeDeleted - True if the deleted records need to be loaded
        Returns:
        List of selected folder IDs, rootId is included as well

      • findFolderIdInPath

        Collection<Long> findFolderIdInPath​(long rootId,
                                    boolean includeDeleted)
        Retrieve all the ids of the folders in a given tree using the path attribute
        Parameters:
        rootId - Root of the folder
        includeDeleted - True if the deleted records need to be loaded
        Returns:
        List of selected folder IDs, rootId is included as well

      • findFolderIdByUserIdInPath

        Collection<Long> findFolderIdByUserIdInPath​(long userId,
                                            Long parentId)
        This method selects only the folder ID from the folders for which a user is authorized.
        Parameters:
        userId - ID of the user.
        parentId - The id of the parent folder to inspect (optional)
        Returns:
        List of selected folder IDs.

      • findByUserId

        List<Folder> findByUserId​(long userId,
                          long parentId)
        Finds direct children of a folder.
        Parameters:
        parentId - ID of the folder which children are wanted
        userId - identifier of the user
        Returns:
        List of found folders sorted by text

      • findByParentId

        List<Folder> findByParentId​(long parentId)
        Finds all children(direct and indirect) by parentId
        Parameters:
        parentId - identifier of the parent folder
        Returns:
        List of found folders

      • findIdsByParentId

        List<Long> findIdsByParentId​(long parentId)
        Finds all children(direct and indirect) by parentId
        Parameters:
        parentId - identifier of the parent folder
        Returns:
        list of folder IDs

      • findChildren

        List<Folder> findChildren​(long parentId,
                          Integer max)
        Finds direct children of a folder
        Parameters:
        parentId - Folder ID of the folder which children are wanted
        max - Optional, maximum number of children
        Returns:
        List of found folders

      • findChildren

        List<Folder> findChildren​(long parentId,
                          long userId)
        Finds direct children of a folder accessible by the given user
        Parameters:
        parentId - Folder ID of the folder which children are wanted
        userId - Identifier of the user that must have read access
        Returns:
        List of found folders

      • isWriteEnabled

        boolean isWriteEnabled​(long folderId,
                       long userId)
        This method is looking up for writing rights for a folder and an user.
        Parameters:
        folderId - ID of the folder
        userId - ID of the user
        Returns:
        if the write permission is granted

      • isReadEnabled

        boolean isReadEnabled​(long folderId,
                      long userId)

      • isPrintEnabled

        boolean isPrintEnabled​(long folderId,
                       long userId)

      • isDownloadEnabled

        boolean isDownloadEnabled​(long folderId,
                          long userId)

      • isMoveEnabled

        boolean isMoveEnabled​(long folderId,
                      long userId)

      • isPermissionEnabled

        boolean isPermissionEnabled​(Permission permission,
                            long folderId,
                            long userId)
        This method checks if the given permission is enabled for a folder and an user.
        Parameters:
        permission - the permission to check
        folderId - ID of the folder
        userId - ID of the user
        Returns:
        if the permission is granted to the user

      • getEnabledPermissions

        Set<Permission> getEnabledPermissions​(long folderId,
                                      long userId)
        Finds all permissions of a user enabled on the specified folder
        Parameters:
        folderId - ID of the folder
        userId - ID of the user
        Returns:
        Collection of enabled permissions

      • findIdByUserId

        List<Long> findIdByUserId​(long userId,
                          long parentId)
        This method selects only the folder ID from the folders for which a user is authorized. Only folders direct child of the specified parent are returned.
        Parameters:
        userId - ID of the user
        parentId - Parent folder
        Returns:
        List of selected folder ID's.

      • hasWriteAccess

        boolean hasWriteAccess​(Folder folder,
                       long userId)
        Checks that the user has access to the folder and all its sub-items
        Parameters:
        folder - the folder
        userId - identifier of the document
        Returns:
        if the user has write permission

      • findByGroupId

        List<Folder> findByGroupId​(long groupId)
        Finds all folders accessible by the passed group
        Parameters:
        groupId - The group id
        Returns:
        The List of folders

      • findParents

        List<Folder> findParents​(long id)
        Returns a List of folders being a parent of the given folder. The list is ordered starting from the root of folders. The list doesn't include the given folder.
        Parameters:
        id - ID of the folder
        Returns:
        the hierarchy of parent folders

      • findWorkspace

        Folder findWorkspace​(long folderId)
              throws PersistenceException
        Returns the workspace that contains the given folder
        Parameters:
        folderId - ID of the folder
        Returns:
        the workspace containing the given folder
        Throws:
        PersistenceException - error in the database

      • restore

        void restore​(long folderId,
             long parentId,
             FolderHistory transaction)
      throws PersistenceException
        Restores a previously deleted folder
        Parameters:
        folderId - The folder identifier
        parentId - The parent folder to restore in
        transaction - Current session informations
        Throws:
        PersistenceException - in case of database error

      • findByNameAndParentId

        List<Folder> findByNameAndParentId​(String name,
                                   long parentId)
        Finds that folder that lies under a specific parent (given by the id) an with a given name(like operator is used)
        Parameters:
        name - name of the dolder
        parentId - identifier of the parent folder
        Returns:
        list of folders

      • store

        boolean store​(Folder folder,
              FolderHistory transaction)
       throws PersistenceException
        Same as store(Folder, boolean, FolderHistory)
        Parameters:
        folder - the folder to store
        transaction - current session informations
        Returns:
        true if the folder has been correctly stored
        Throws:
        PersistenceException - in case of database error

      • deleteAll

        void deleteAll​(Collection<Folder> folders,
               int delCode,
               FolderHistory transaction)
        throws PersistenceException
        For each folder, save the folder delete history entry for each folder and delete the folder
        Parameters:
        folders - List of folder to be delete
        delCode - The deletion code
        transaction - entry to log the event on each folder
        Throws:
        PersistenceException - in case of database error

      • delete

        boolean delete​(long id,
               FolderHistory transaction)
        throws PersistenceException
        Shortcut for delete(id, 1, transaction)
        Parameters:
        id - the folder identifier
        transaction - the session informations
        Returns:
        if the folde has been succesfully deleted
        Throws:
        PersistenceException - in case of database error

      • delete

        boolean delete​(long id,
               int delCode,
               FolderHistory transaction)
        throws PersistenceException
        This method deletes the folder object and insert a new folder history entry
        Parameters:
        id - The id of the folder to delete
        delCode - The deletion code
        transaction - entry to log the event
        Returns:
        True if successfully deleted from the database
        Throws:
        PersistenceException - in case of database error

      • create

        Folder create​(Folder parent,
              Folder folderVO,
              boolean inheritSecurity,
              FolderHistory transaction)
       throws PersistenceException
        Creates a new folder in the parent Folder
        Parameters:
        parent - The parent folder
        folderVO - The folder's metadata
        inheritSecurity - If true the new folder will 'point' to the parent for the security policies.
        transaction - optional transaction entry to log the event
        Returns:
        The newly created folder
        Throws:
        PersistenceException - in case of database error

      • createAlias

        Folder createAlias​(long parentId,
                   long foldRef,
                   FolderHistory transaction)
            throws PersistenceException
        Creates a new folder folder alias
        Parameters:
        parentId - The parent folder
        foldRef - The referenced folder
        transaction - optional transaction entry to log the event
        Returns:
        The newly created alias
        Throws:
        PersistenceException - in case of database error

      • findAliases

        List<Folder> findAliases​(Long foldRef,
                         long tenantId)
        Finds all the aliases
        Parameters:
        foldRef - The referenced folder
        tenantId - The tenant
        Returns:
        Collection of aliases

      • createPath

        Folder createPath​(Folder parent,
                  String path,
                  boolean inheritSecurity,
                  FolderHistory transaction)
           throws PersistenceException
        Creates the folder for the specified path. All unexisting nodes specified in the path will be created. The path must be in any case inside a workspace, if not, the Default one will be used.
        Parameters:
        parent - The parent folder
        path - The folder path(for example /dog/cat/mouse)
        inheritSecurity - If true the new folders will 'point' to the parent for the security policies.
        transaction - optional transaction entry to log the event
        Returns:
        The created folder
        Throws:
        PersistenceException - in case of database error

      • computePath

        String computePath​(long folderId)
            throws PersistenceException
        Dynamically computes the path for the specified folder. The path is a sequence of IDS in the form: /4/55897/99870
        Parameters:
        folderId - identifier of the folder
        Returns:
        the folder's path
        Throws:
        PersistenceException - error in the database

      • computePath

        String computePath​(Folder folder)
            throws PersistenceException
        Dynamically computes the path for the specified folder. The path is a sequence of IDS in the form: /4/55897/99870
        Parameters:
        folder - the folder to process
        Returns:
        the folder's path
        Throws:
        PersistenceException - error in the database

      • computePathExtended

        String computePathExtended​(Folder folder)
                    throws PersistenceException
        Dynamically computes the path extended for the specified folder. The path extended is a human readable path in the form: /folder1/folder2/folder3
        Parameters:
        folder - the folder to process
        Returns:
        The path extended
        Throws:
        PersistenceException - error in the database

      • computePathExtended

        String computePathExtended​(long folderId)
                    throws PersistenceException
        Dynamically computes the path extended for the specified folder. The path extended is a human readable path in the form: /folder1/folder2/folder3
        Parameters:
        folderId - the folder's identifier
        Returns:
        The path extended
        Throws:
        PersistenceException - error in the database

      • findByPathExtended

        Folder findByPathExtended​(String pathExtended,
                          long tenantId)
        Retrieval of a folder by the extended path
        Parameters:
        pathExtended - the path extended
        tenantId - identifier of the tenant
        Returns:
        The folder that matched the given path

      • copy

        Folder copy​(Folder source,
            Folder target,
            String newName,
            boolean foldersOnly,
            String securityOption,
            FolderHistory transaction)
     throws PersistenceException
        Copies a folder into another folder
        Parameters:
        source - The folder to copy
        target - The target folder
        newName - optional new name of the copied folder
        foldersOnly - True if only the folders tree has to be copied; if false, the documents will also be copied
        securityOption - How to assign the security policies to the newly created folders:
        • null or none: empty security policies
        • inherit: the new folder will point to the parent for the security policies
        • replicate: the new folder will have a copy of the security policies of the source folder
        transaction - entry to log the event (set the user)
        Returns:
        The new folder created
        Throws:
        PersistenceException - in case of database error

      • deleteTree

        List<Folder> deleteTree​(Folder folder,
                        int delCode,
                        FolderHistory transaction)
                 throws PersistenceException
        Deletes a folder and all its sub-folders that a user can delete. After recovering of all sub-folders inside the folder, will be canceled all folders for which the user has the delete permission or there isn't an immutable document inside it.
        Important: Remember to delete orphaned documents.
        Parameters:
        folder - Folder to delete
        delCode - The deletion code
        transaction - entry to log the event (set the user)
        Returns:
        List of folders that the user cannot delete(permissions, o immutable documents presents)
        Throws:
        PersistenceException - in case of database error

      • deleteTree

        List<Folder> deleteTree​(long folderId,
                        int delCode,
                        FolderHistory transaction)
                 throws Exception
        Delete a folder and all its sub-folders that a user can delete. After recovering of all sub-folders inside the folder, will be canceled all folders for which the user has the delete permission or there isn't an immutable document inside it.
        Important: All the contained documents will be deleted
        Parameters:
        folderId - Folder to delete
        delCode - The deletion code
        transaction - entry to log the event (set the user)
        Returns:
        List of folders that the user cannot delete(permissions, o immutable documents presents)
        Throws:
        Exception - in case of any error

      • deleteTree

        List<Folder> deleteTree​(long folderId,
                        FolderHistory transaction)
                 throws Exception
        Shortcut for deleteTree(folderId, 1, transaction)
        Parameters:
        folderId - Folder to delete
        transaction - entry to log the event (set the user)
        Returns:
        List of folders that the user cannot delete(permissions, o immutable documents presents)
        Throws:
        Exception - in case of any error

      • find

        List<Folder> find​(String name,
                  Long tenantId)
        Useful method that allows to find all folders that contains the given name into their text.
        Parameters:
        name - The name to be found
        tenantId - The tenant to search in
        Returns:
        List of folders that contains the given name into their text.

      • findDeleted

        List<Folder> findDeleted​(long userId,
                         Integer maxHits)
        Finds all deleted folders of a specific user.
        Parameters:
        userId - The user that performed the deletion
        maxHits - Optional defines the max number of returned hits
        Returns:
        The folders list

      • isInPath

        boolean isInPath​(long parentId,
                 long childId)
        Checks if a folder with the given folderId is parent of the folder with the given targetId
        Parameters:
        parentId - The folder to be checked
        childId - The target folder
        Returns:
        True if the folder with the given parentId is parent of the folder with the given childId

      • applyRightToTree

        boolean applyRightToTree​(long rootId,
                         FolderHistory transaction)
        Propagates the security policies of a node to the whole subtree
        Parameters:
        rootId - identifier of the root folder
        transaction - session informations
        Returns:
        if the rights have been correctly applied

      • applyGridToTree

        boolean applyGridToTree​(long rootId,
                        FolderHistory transaction)
        Propagates the grid layout of a node to the whole subtree
        Parameters:
        rootId - identifier of the root folder
        transaction - session informations
        Returns:
        if the grid layout has been correctly replicated

      • updateSecurityRef

        boolean updateSecurityRef​(long folderId,
                          long rightsFolderId,
                          FolderHistory transaction)
        Changes the securityRef of the given folder, all the other folders that inherits from this one will be changed accordingly.
        Parameters:
        folderId - identifier of the folder
        rightsFolderId - id of the folder to inherit from
        transaction - session informations
        Returns:
        is the update has been successful

      • applyMetadataToTree

        boolean applyMetadataToTree​(long id,
                            FolderHistory transaction)
                     throws PersistenceException
        Propagates the template metadata to the whole subree
        Parameters:
        id - identifier of the folder
        transaction - session informations
        Returns:
        is the update has been successful
        Throws:
        PersistenceException - in case of database error

      • applyTagsToTree

        boolean applyTagsToTree​(long id,
                        FolderHistory transaction)
                 throws PersistenceException
        Propagates the tags to the whole subree
        Parameters:
        id - identifier of the folder
        transaction - session informations
        Returns:
        is the update has been successful
        Throws:
        PersistenceException - in case of database error

      • applyStorageToTree

        boolean applyStorageToTree​(long id,
                           FolderHistory transaction)
                    throws PersistenceException
        Propagates the storage setting to the whole subree
        Parameters:
        id - identifier of the folder
        transaction - session informations
        Returns:
        is the update has been successful
        Throws:
        PersistenceException - in case of database error

      • applyOCRToTree

        boolean applyOCRToTree​(long id,
                       FolderHistory transaction)
                throws PersistenceException
        Propagates the OCR settings to the whole subree
        Parameters:
        id - identifier of the folder
        transaction - session informations
        Returns:
        is the update has been successful
        Throws:
        PersistenceException - in case of database error

      • count

        int count​(boolean computeDeleted)
        Counts the number of folders
        Parameters:
        computeDeleted - if the deleted folders have to be taken int account
        Returns:
        the number of folders

      • findWorkspaces

        List<Folder> findWorkspaces​(long tanantId)
        Retrieves all the workspaces in the system, that are the first-level folders of type Folder.TYPE_WORKSPACE
        Parameters:
        tanantId - identifier of the tenant
        Returns:
        list of folders

      • saveFolderHistory

        void saveFolderHistory​(Folder folder,
                       FolderHistory transaction)
                throws PersistenceException
        Utility method that logs into the DB the transaction that involved the passed folder. The transaction must be provided with userId and userName.
        Parameters:
        folder - the folder
        transaction - the session informations
        Throws:
        PersistenceException - database error

      • countDocsInTree

        long countDocsInTree​(long rootId)
        Counts the number of documents inside a given folder's tree (direct and indirect children)
        Parameters:
        rootId - identifier of the root folder
        Returns:
        the number of documents contained in the tree

      • computeTreeSize

        long computeTreeSize​(long rootId)
        Counts the number of documents inside a given folder's tree (direct and indirect children)
        Parameters:
        rootId - identifier of the root folder
        Returns:
        sum of the sizes of the documents contained in the tree expressed in bytes

      • findTags

        List<String> findTags​(long folderId)
        Retrieves the alphabetically ordered list of all the folder's tags
        Parameters:
        folderId - identifier of the folder
        Returns:
        list of tags

      • merge

        void merge​(Folder source,
           Folder target,
           FolderHistory transaction)
    throws PersistenceException
        Merges the contents of two folders
        Parameters:
        source - The folder whose contents must be merged inside folderA
        target - The main folder to use as container
        transaction - the session informations
        Throws:
        PersistenceException - in case of database or logical error