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 at data layer

      • findByName

        List<Folder> findByName​(String name,
                        Long tenantId)
                 throws PersistenceException
        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.
        Throws:
        PersistenceException - error at data layer

      • findByName

        List<Folder> findByName​(Folder parent,
                        String name,
                        Long tenantId,
                        boolean caseSensitive)
                 throws PersistenceException
        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
        Throws:
        PersistenceException - error at data layer

      • findRoot

        Folder findRoot​(long tenantId)
         throws PersistenceException
        Retrieves the root folder of the given tenant
        Parameters:
        tenantId - identifier of the tenant
        Returns:
        the root folder
        Throws:
        PersistenceException - error at data layer

      • findDefaultWorkspace

        Folder findDefaultWorkspace​(long tenantId)
                     throws PersistenceException
        Retrieves the Default workspace of the given tenant
        Parameters:
        tenantId - identifier of the tenant
        Returns:
        The default workspace
        Throws:
        PersistenceException - error at data layer

      • findByUserIdAndTag

        List<Folder> findByUserIdAndTag​(long userId,
                                String tag,
                                Integer max)
                         throws PersistenceException
        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
        Throws:
        PersistenceException - error at data layer

      • findFolderIdByUserIdAndPermission

        Collection<Long> findFolderIdByUserIdAndPermission​(long userId,
                                                   Permission permission,
                                                   Long parentId,
                                                   boolean tree)
                                            throws PersistenceException
        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.
        Throws:
        PersistenceException - error at data layer

      • findFolderIdByUserId

        Collection<Long> findFolderIdByUserId​(long userId,
                                      Long parentId,
                                      boolean tree)
                               throws PersistenceException
        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.
        Throws:
        PersistenceException - error at data layer

      • 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)
                             throws PersistenceException
        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
        Throws:
        PersistenceException - error at data layer

      • findFolderIdByUserIdInPath

        Collection<Long> findFolderIdByUserIdInPath​(long userId,
                                            long parentId)
                                     throws PersistenceException
        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
        Returns:
        List of selected folder IDs.
        Throws:
        PersistenceException - error at data layer

      • findByUserId

        List<Folder> findByUserId​(long userId,
                          long parentId)
                   throws PersistenceException
        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
        Throws:
        PersistenceException - error at data layer

      • 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)
                   throws PersistenceException
        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
        Throws:
        PersistenceException - Error in the database

      • findChildren

        List<Folder> findChildren​(long parentId,
                          long userId)
                   throws PersistenceException
        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
        Throws:
        PersistenceException - error at data layer

      • isWriteEnabled

        boolean isWriteEnabled​(long folderId,
                       long userId)
                throws PersistenceException
        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
        Throws:
        PersistenceException - error at data layer

      • isPermissionEnabled

        boolean isPermissionEnabled​(Permission permission,
                            long folderId,
                            long userId)
                     throws PersistenceException
        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
        Throws:
        PersistenceException - error at data layer

      • getEnabledPermissions

        Set<Permission> getEnabledPermissions​(long folderId,
                                      long userId)
                               throws PersistenceException
        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
        Throws:
        PersistenceException - error at data layer

      • findIdByUserId

        List<Long> findIdByUserId​(long userId,
                          long parentId)
                   throws PersistenceException
        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.
        Throws:
        PersistenceException - error at data layer

      • hasWriteAccess

        boolean hasWriteAccess​(Folder folder,
                       long userId)
                throws PersistenceException
        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
        Throws:
        PersistenceException - error at data layer

      • findByGroupId

        List<Folder> findByGroupId​(long groupId)
                    throws PersistenceException
        Finds all folders accessible by the passed group
        Parameters:
        groupId - The group id
        Returns:
        The List of folders
        Throws:
        PersistenceException - error at data layer

      • findParents

        List<Folder> findParents​(long id)
                  throws PersistenceException
        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
        Throws:
        PersistenceException - error at data layer

      • 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 at data layer

      • 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 - error at data layer

      • findByNameAndParentId

        List<Folder> findByNameAndParentId​(String name,
                                   long parentId)
                            throws PersistenceException
        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
        Throws:
        PersistenceException - error at data layer

      • 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 - error at data layer

      • delete

        void 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
        Throws:
        PersistenceException - error at data layer

      • 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 - error at data layer

      • 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 - error at data layer

      • 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 - error at data layer

      • 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 at data layer

      • 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 at data layer

      • 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 at data layer

      • 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 at data layer

      • findByPathExtended

        Folder findByPathExtended​(String pathExtended,
                          long tenantId)
                   throws PersistenceException
        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
        Throws:
        PersistenceException - error at data layer

      • 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 - error at data layer

      • 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 - error at data layer

      • deleteTree

        List<Folder> deleteTree​(long folderId,
                        int delCode,
                        FolderHistory transaction)
                 throws PersistenceException
        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:
        PersistenceException - error at data layer

      • deleteTree

        List<Folder> deleteTree​(long folderId,
                        FolderHistory transaction)
                 throws PersistenceException
        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:
        PersistenceException - error at data layer

      • find

        List<Folder> find​(String name,
                  Long tenantId)
           throws PersistenceException
        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.
        Throws:
        PersistenceException - error at data layer

      • 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)
          throws PersistenceException
        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
        Throws:
        PersistenceException - error at data layer

      • applyRightToTree

        void applyRightToTree​(long rootId,
                      FolderHistory transaction)
               throws PersistenceException
        Propagates the security policies of a node to the whole sub-tree
        Parameters:
        rootId - identifier of the root folder
        transaction - session informations
        Throws:
        PersistenceException - error at data layer

      • applyGridToTree

        void applyGridToTree​(long rootId,
                     FolderHistory transaction)
              throws PersistenceException
        Propagates the grid layout of a node to the whole sub-tree
        Parameters:
        rootId - identifier of the root folder
        transaction - session informations
        Throws:
        PersistenceException - error at data layer

      • updateSecurityRef

        void updateSecurityRef​(long folderId,
                       long rightsFolderId,
                       FolderHistory transaction)
                throws PersistenceException
        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
        Throws:
        PersistenceException - error at data layer

      • applyMetadataToTree

        void applyMetadataToTree​(long id,
                         FolderHistory transaction)
                  throws PersistenceException
        Propagates the template metadata to the whole subree
        Parameters:
        id - identifier of the folder
        transaction - session informations
        Throws:
        PersistenceException - error at data layer

      • applyTagsToTree

        void applyTagsToTree​(long id,
                     FolderHistory transaction)
              throws PersistenceException
        Propagates the tags to the whole subree
        Parameters:
        id - identifier of the folder
        transaction - session informations
        Throws:
        PersistenceException - error at data layer

      • applyStorageToTree

        void applyStorageToTree​(long id,
                        FolderHistory transaction)
                 throws PersistenceException
        Propagates the storage setting to the whole subree
        Parameters:
        id - identifier of the folder
        transaction - session informations
        Throws:
        PersistenceException - error at data layer

      • applyOCRToTree

        void applyOCRToTree​(long id,
                    FolderHistory transaction)
             throws PersistenceException
        Propagates the OCR settings to the whole subree
        Parameters:
        id - identifier of the folder
        transaction - session informations
        Throws:
        PersistenceException - error at data layer

      • 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

      • 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 - error at data layer

      • 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