Package com.logicaldoc.core.folder

Interface FolderDAO

All Superinterfaces:
PersistentObjectDAO<Folder>
All Known Implementing Classes:
HibernateFolderDAO
public interface FolderDAO extends PersistentObjectDAO<Folder>
Instances of this class is a DAO-service for folder objects.
Version:
6.0
Author:
Marco Meschieri - LogicalDOC

  • Method Details

    • 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

    • findByUserId

      List<Folder> findByUserId(long userId) throws PersistenceException
      Finds authorized folders for a user
      Parameters:
      userId - ID of the user
      Returns:
      List of found folders
      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:
      userId - identifier of the user
      parentId - ID of the folder which children are wanted
      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

    • isWriteAllowed

      boolean isWriteAllowed(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

    • hasWriteAccess

      boolean hasWriteAccess(Folder folder, long userId) throws PersistenceException
      Checks that the user has write 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

    • isReadAllowed

      boolean isReadAllowed(long folderId, long userId) throws PersistenceException
      Throws:
      PersistenceException

    • isPreviewAllowed

      boolean isPreviewAllowed(long folderId, long userId) throws PersistenceException
      Throws:
      PersistenceException

    • isPrintAllowed

      boolean isPrintAllowed(long folderId, long userId) throws PersistenceException
      Throws:
      PersistenceException

    • isDownloadllowed

      boolean isDownloadllowed(long folderId, long userId) throws PersistenceException
      Throws:
      PersistenceException

    • isMoveAllowed

      boolean isMoveAllowed(long folderId, long userId) throws PersistenceException
      Throws:
      PersistenceException

    • isPermissionAllowed

      boolean isPermissionAllowed(Permission permission, long folderId, long userId) throws PersistenceException
      This method checks if the given permission is allowed 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

    • getAllowedPermissions

      Set<Permission> getAllowedPermissions(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

    • 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

    • store

      void store(Folder folder, FolderHistory transaction) throws PersistenceException
      Same as store(Folder, boolean, FolderHistory)
      Parameters:
      folder - the folder to store
      transaction - current session informations
      Throws:
      PersistenceException - error at data layer

    • deleteAll

      void deleteAll(Collection<Folder> folders, FolderHistory transaction) throws PersistenceException
      Shortcut for deleteAll(folders, 1, transaction)
      Parameters:
      folders - the folders
      transaction - current session informations
      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, FolderHistory transaction) throws PersistenceException
      Shortcut for delete(id, 1, transaction)
      Parameters:
      id - the folder identifier
      transaction - the session informations
      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

    • move

      void move(Folder source, Folder target, FolderHistory transaction) throws PersistenceException
      Moves a folder into another folder
      Parameters:
      source - The folder to move
      target - The target folder
      transaction - entry to log the event (set the user)
      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

    • applySecurityToTree

      void applySecurityToTree(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

    • applyStoreToTree

      void applyStoreToTree(long id, FolderHistory transaction) throws PersistenceException
      Propagates the store 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

    • findWorkspaces

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

    • initialize

      void initialize(Folder folder)
      Initializes lazy loaded collections
      Specified by:
      initialize in interface PersistentObjectDAO<Folder>
      Parameters:
      folder - The folder to be initialized

    • 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