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

## Field Summary

### Fields inherited from interface com.logicaldoc.core.PersistentObjectDAO

`ENTITY`

## Method Summary

Modifier and Type
Method
Description
`void`
`applyCaptureToTree(long id, FolderHistory transaction)`
Propagates the automated capture settings to the whole subree
`void`
`applyGridToTree(long rootId, FolderHistory transaction)`
Propagates the grid layout of a node to the whole sub-tree
`void`
`applyMetadataToTree(long id, FolderHistory transaction)`
Propagates the template metadata to the whole subree
`void`
`applySecurityToTree(long rootId, FolderHistory transaction)`
Propagates the security policies of a node to the whole sub-tree
`void`
`applyStoreToTree(long id, FolderHistory transaction)`
Propagates the store setting to the whole subree
`void`
`applyTagsToTree(long id, FolderHistory transaction)`
Propagates the tags to the whole subree
`String`
`computePath(long folderId)`
Dynamically computes the path for the specified folder.
`String`
`computePath(Folder folder)`
Dynamically computes the path for the specified folder.
`String`
`computePathExtended(long folderId)`
Dynamically computes the path extended for the specified folder.
`String`
`computePathExtended(Folder folder)`
Dynamically computes the path extended for the specified folder.
`long`
`computeTreeSize(long rootId)`
Counts the number of documents inside a given folder's tree (direct and indirect children)
`Folder`
`copy(Folder source, Folder target, String newName, boolean foldersOnly, String securityOption, FolderHistory transaction)`
Copies a folder into another folder
`long`
`countDocs(long folderId)`
Counts the number of documents inside a given folder
`long`
`countDocsInTree(long rootId)`
Counts the number of documents inside a given folder's tree (direct and indirect children)
`Folder`
`create(Folder parent, Folder folderVO, boolean inheritSecurity, FolderHistory transaction)`
Creates a new folder in the parent Folder
`Folder`
`createAlias(long parentId, long foldRef, FolderHistory transaction)`
Creates a new folder folder alias
`Folder`
`createPath(Folder parent, String path, boolean inheritSecurity, FolderHistory transaction)`
Creates the folder for the specified path.
`void`
`delete(long id, int delCode, FolderHistory transaction)`
This method deletes the folder object and insert a new folder history entry
`void`
`delete(long id, FolderHistory transaction)`
Shortcut for delete(id, 1, transaction)
`void`
`deleteAll(Collection<Folder> folders, int delCode, FolderHistory transaction)`
For each folder, save the folder delete history entry for each folder and delete the folder
`void`
`deleteAll(Collection<Folder> folders, FolderHistory transaction)`
Shortcut for deleteAll(folders, 1, transaction)
`List<Folder>`
`deleteTree(long folderId, int delCode, FolderHistory transaction)`
Delete a folder and all its sub-folders that a user can delete.
`List<Folder>`
`deleteTree(long folderId, FolderHistory transaction)`
Shortcut for deleteTree(folderId, 1, transaction)
`List<Folder>`
`deleteTree(Folder folder, int delCode, FolderHistory transaction)`
Deletes a folder and all its sub-folders that a user can delete.
`List<Folder>`
`find(String name, Long tenantId)`
Useful method that allows to find all folders that contains the given name into their text.
`List<Folder>`
`findAliases(Long foldRef, long tenantId)`
Finds all the aliases
`List<Folder>`
`findByGroupId(long groupId)`
Finds all folders accessible by the passed group
`List<Folder>`
`findByName(Folder parent, String name, Long tenantId, boolean caseSensitive)`
Finds all folders by folder text, contained in the parent folder.
`List<Folder>`
`findByName(String name, Long tenantId)`
Finds all folders by folder name
`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)
`List<Folder>`
`findByParentId(long parentId)`
Finds all children(direct and indirect) by parentId
`Folder`
`findByPathExtended(String pathExtended, long tenantId)`
Retrieval of a folder by the extended path
`List<Folder>`
`findByUserId(long userId)`
Finds authorized folders for a user
`List<Folder>`
`findByUserId(long userId, long parentId)`
Finds direct children of a folder.
`List<Folder>`
`findByUserIdAndTag(long userId, String tag, Integer max)`
Finds authorized folders for a user having a specified tag.
`List<Folder>`
`findChildren(long parentId, long userId)`
Finds direct children of a folder accessible by the given user
`List<Folder>`
`findChildren(long parentId, Integer max)`
Finds direct children of a folder
`Folder`
`findDefaultWorkspace(long tenantId)`
Retrieves the Default workspace of the given tenant
`List<Folder>`
`findDeleted(long userId, Integer maxHits)`
Finds all deleted folders of a specific user.
`Folder`
`findFolder(long folderId)`
Gets a folder by a given ID if it is an alias, the referenced folder is returned.
`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.
`Collection<Long>`
`findFolderIdByUserIdAndPermission(long userId, Permission permission, Long parentId, boolean tree)`
Finds all folders ids with a specific permission enabled on the specifies user
`Collection<Long>`
`findFolderIdByUserIdInPath(long userId, long parentId)`
This method selects only the folder ID from the folders for which a user is authorized.
`Collection<Long>`
`findFolderIdInPath(long rootId, boolean includeDeleted)`
Retrieve all the ids of the folders in a given tree using the path attribute
`Collection<Long>`
`findFolderIdInTree(long rootId, boolean includeDeleted)`
Retrieve all the ids of the folders in a given tree
`List<Long>`
`findIdByUserId(long userId, long parentId)`
This method selects only the folder ID from the folders for which a user is authorized.
`List<Long>`
`findIdsByParentId(long parentId)`
Finds all children(direct and indirect) by parentId
`List<Folder>`
`findParents(long id)`
Returns a List of folders being a parent of the given folder.
`Folder`
`findRoot(long tenantId)`
Retrieves the root folder of the given tenant
`List<String>`
`findTags(long folderId)`
Retrieves the alphabetically ordered list of all the folder's tags
`Folder`
`findWorkspace(long folderId)`
Returns the workspace that contains the given folder
`List<Folder>`
`findWorkspaces(long tanantId)`
Retrieves all the workspaces in the system, that are the first-level folders of type `Folder.TYPE_WORKSPACE`
`static FolderDAO`
`get()`
Gets the object available in the application context
`Set<Permission>`
`getAllowedPermissions(long folderId, long userId)`
Finds all permissions of a user enabled on the specified folder
`boolean`
`hasWriteAccess(Folder folder, long userId)`
Checks that the user has write access to the folder and all its sub-items
`void`
`initialize(Folder folder)`
Initializes lazy loaded collections
`boolean`
`isDownloadllowed(long folderId, long userId)`
`boolean`
`isInPath(long parentId, long childId)`
Checks if a folder with the given folderId is parent of the folder with the given targetId
`boolean`
`isMoveAllowed(long folderId, long userId)`
`boolean`
`isPermissionAllowed(Permission permission, long folderId, long userId)`
This method checks if the given permission is allowed for a folder and an user.
`boolean`
`isPreviewAllowed(long folderId, long userId)`
`boolean`
`isPrintAllowed(long folderId, long userId)`
`boolean`
`isReadAllowed(long folderId, long userId)`
`boolean`
`isWriteAllowed(long folderId, long userId)`
This method is looking up for writing rights for a folder and an user.
`void`
`merge(Folder source, Folder target, FolderHistory transaction)`
Merges the contents of two folders
`void`
`move(Folder source, Folder target, FolderHistory transaction)`
Moves a folder into another folder
`void`
`restore(long folderId, long parentId, FolderHistory transaction)`
Restores a previously deleted folder
`void`
`saveFolderHistory(Folder folder, FolderHistory transaction)`
Utility method that logs into the DB the transaction that involved the passed folder.
`void`
`store(Folder folder, FolderHistory transaction)`
Same as store(Folder, boolean, FolderHistory)
`void`
`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.

### Methods inherited from interface com.logicaldoc.core.PersistentObjectDAO

`bulkUpdate, count, count, count, delete, delete, deleteAll, deleteAll, evict, evict, findAll, findAll, findAllIds, findAllIds, findById, findById, findByObjectQuery, findByQuery, findByQuery, findByWhere, findByWhere, findIdsByWhere, findIdsByWhere, getDatabaseMetadata, getDbms, initialize, isMariaDB, isMySQL, isOracle, isPostgreSQL, isSQLServer, jdbcUpdate, jdbcUpdate, query, query, queryForDouble, queryForDouble, queryForInt, queryForInt, queryForList, queryForList, queryForList, queryForLong, queryForLong, queryForObject, queryForObject, queryForResultSet, queryForString, queryForString, store`

## Method Details

### get

static FolderDAO get()
Gets the object available in the application context

Returns:
  the instance of this object in the application context

### 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) throws PersistenceException
Finds all the aliases

Parameters:
  `foldRef` - The referenced folder
  `tenantId` - The tenant
Returns:
  Collection of aliases
Throws:
  `PersistenceException` - error at data layer

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

### 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

### applyCaptureToTree

void applyCaptureToTree(long id, FolderHistory transaction) throws PersistenceException
Propagates the automated capture settings to the whole subree

Parameters:
  `id` - identifier of the folder
  `transaction` - session informations
Throws:
  `PersistenceException` - error at data layer

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

### countDocs

long countDocs(long folderId) throws PersistenceException
Counts the number of documents inside a given folder

Parameters:
  `folderId` - identifier of the folder
Returns:
  the number of documents contained in the folder
Throws:
  `PersistenceException` - error at data layer

### computeTreeSize

long computeTreeSize(long rootId) throws PersistenceException
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
Throws:
  `PersistenceException` - error at data layer

### findTags

List<String> findTags(long folderId) throws PersistenceException
Retrieves the alphabetically ordered list of all the folder's tags

Parameters:
  `folderId` - identifier of the folder
Returns:
  list of tags
Throws:
  `PersistenceException` - error at data layer

### 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