# Uses of Class
com.logicaldoc.core.PersistenceException

Packages that use PersistenceException
Package
Description
com.logicaldoc.core
Core plug-in that contains the most important domain objects
com.logicaldoc.core.automation
Automation subsystem that allows you to program your own logic inside the platform.
The automation engine can be accessed through the class `Automation`
Please note the special annotation `AutomationDictionary` that is used to automatically put in the Dictionary whatever bean you need.
com.logicaldoc.core.communication
Classes that model emails and messages and the machinery to work with them.
com.logicaldoc.core.contact
com.logicaldoc.core.conversion
Machinery for converting documents to different formats.
com.logicaldoc.core.dashlet
com.logicaldoc.core.document
Contains the definitions of `Document` and `Version` as well as other related objects
com.logicaldoc.core.filler
Package with the API for implementing the autofill of `ExtensibleObject`s
com.logicaldoc.core.folder
Contains the definitions of `Folder` as well as other related objects
com.logicaldoc.core.generic
Contains the definitions of `Generic` that is a persistent object used as a general way to store informations in the database
com.logicaldoc.core.history
com.logicaldoc.core.lock
com.logicaldoc.core.metadata
Package that collects the template and attribute sets definitions.
Many objects of the LogicalDOC platform are extensible and can store your custom metadata, they are all those that extends the `ExtensibleObject`.
com.logicaldoc.core.metadata.validation
Package that contains classes used to validate extensible objects metadata, `ExtensibleObject`.
com.logicaldoc.core.searchengine.saved
Classes related to saved searches
com.logicaldoc.core.security
Container of the security-related interfaces and classes
com.logicaldoc.core.security.apikey
APIKey is another way to authenticate when using an API like Webservices
com.logicaldoc.core.security.authentication
The pluggable authentication mechanism.
com.logicaldoc.core.security.menu
Package for the Menu, a menu represent a graphical element of the user interface
com.logicaldoc.core.security.user
Definition of the User object and ancillary objects
com.logicaldoc.core.sequence
com.logicaldoc.core.store
The store sub-system responsible for persisting the binaries of the documents.
com.logicaldoc.core.ticket
com.logicaldoc.core.transfer
com.logicaldoc.core.util

## Uses of PersistenceException in com.logicaldoc.core

Methods in com.logicaldoc.core that throw PersistenceException
Modifier and Type
Method
Description
`int`
HibernatePersistentObjectDAO.`bulkUpdate(String expression, Map<String,Object> parameters)`
`int`
PersistentObjectDAO.`bulkUpdate(String expression, Map<String,Object> parameters)`
Executes a bulk update as specified by the given HQL expression
`long`
HibernatePersistentObjectDAO.`count(Long tenantId, boolean includeDeleted)`
`default long`
PersistentObjectDAO.`count()`
Counts the total number of not-deleted entities
`default long`
PersistentObjectDAO.`count(Long tenantId)`
Counts the total number of not-deleted entities
`long`
PersistentObjectDAO.`count(Long tenantId, boolean includeDeleted)`
Counts the total number of entities
`void`
HibernatePersistentObjectDAO.`delete(long id, int code)`
`default void`
PersistentObjectDAO.`delete(long id)`
This method deletes an entity.
`void`
PersistentObjectDAO.`delete(long id, int code)`
This method deletes an entity and you can give a deletion code
`void`
HibernatePersistentObjectDAO.`deleteAll(Collection<T> entities, int code)`
`default void`
PersistentObjectDAO.`deleteAll(Collection<T> entities)`
Deletes all entries form the database.
`void`
PersistentObjectDAO.`deleteAll(Collection<T> entities, int code)`
Deletes all entries form the database giving a specific deletion code
`default List<T>`
PersistentObjectDAO.`findAll()`
Finds all entities in the database
`default List<T>`
PersistentObjectDAO.`findAll(long tenantId)`
Finds all entities in a specific tenant.
`default List<Long>`
PersistentObjectDAO.`findAllIds()`
Finds all entities ids
`default List<Long>`
PersistentObjectDAO.`findAllIds(long tenantId)`
Finds all entities ids in a specific tenant.
`T`
HibernatePersistentObjectDAO.`findById(long id)`
`T`
PersistentObjectDAO.`findById(long id)`
This method finds an entity by ID
`default T`
PersistentObjectDAO.`findById(long id, boolean initialize)`
This method finds an entity by ID
`List<T>`
HibernatePersistentObjectDAO.`findByObjectQuery(String query, Map<String,Object> parameters, Integer max)`
`List<T>`
PersistentObjectDAO.`findByObjectQuery(String query, Map<String,Object> parameters, Integer max)`
Finds all entities by the given object query.
`<R> List<R>`
HibernatePersistentObjectDAO.`findByQuery(String query, Map<String,Object> parameters, Class<R> requiredType, Integer max)`
`List<Object[]>`
HibernatePersistentObjectDAO.`findByQuery(String query, Map<String,Object> parameters, Integer max)`
`<R> List<R>`
PersistentObjectDAO.`findByQuery(String query, Map<String,Object> parameters, Class<R> requiredType, Integer max)`
Find everything you want from the DB using the ORM query language
`List<Object[]>`
PersistentObjectDAO.`findByQuery(String query, Map<String,Object> parameters, Integer max)`
Find everything you want from the DB using the ORM query language
`List<T>`
HibernatePersistentObjectDAO.`findByWhere(String where, Map<String,Object> parameters, String order, Integer max)`
`default List<T>`
PersistentObjectDAO.`findByWhere(String where, String order, Integer max)`
Finds all entities by the given expression.
`List<T>`
PersistentObjectDAO.`findByWhere(String where, Map<String,Object> parameters, String order, Integer max)`
Finds all entities by the given expression.
`List<Long>`
HibernatePersistentObjectDAO.`findIdsByWhere(String where, Map<String,Object> parameters, String order, Integer max)`
`default List<Long>`
PersistentObjectDAO.`findIdsByWhere(String where, String order, Integer max)`
Finds all entities ids by the given expression.
`List<Long>`
PersistentObjectDAO.`findIdsByWhere(String where, Map<String,Object> parameters, String order, Integer max)`
Finds all entities ids by the given expression.
`void`
HibernatePersistentObjectDAO.`initialize(T entity)`
Doesn't do anything by default
`default void`
PersistentObjectDAO.`initialize(Collection<T> entities)`
Initialises lazy loaded data such as collections of all specified entities
`void`
PersistentObjectDAO.`initialize(T entity)`
Initialises lazy loaded data such as collections
`int`
HibernatePersistentObjectDAO.`jdbcUpdate(String sql)`
`int`
HibernatePersistentObjectDAO.`jdbcUpdate(String sql, Map<String,Object> parameters)`
`int`
PersistentObjectDAO.`jdbcUpdate(String sql)`
Executes the given SQL update statement
`int`
PersistentObjectDAO.`jdbcUpdate(String sql, Map<String,Object> parameters)`
Issue a single SQL update operation (such as an insert, update or delete statement) via a prepared statement, binding the given arguments
`<P> List<P>`
HibernatePersistentObjectDAO.`query(String sql, Map<String,Object> parameters, org.springframework.jdbc.core.RowMapper<P> rowMapper, Integer maxRows)`
`<P> List<P>`
PersistentObjectDAO.`query(String sql, Map<String,Object> parameters, org.springframework.jdbc.core.RowMapper<P> rowMapper, Integer maxRows)`
Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, mapping each row to a Java object via a RowMapper.
`default <P> List<P>`
PersistentObjectDAO.`query(String sql, org.springframework.jdbc.core.RowMapper<P> rowMapper, Integer maxRows)`
Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, mapping each row to a Java object via a RowMapper.
`double`
HibernatePersistentObjectDAO.`queryForDouble(String sql)`
`double`
HibernatePersistentObjectDAO.`queryForDouble(String sql, Map<String,Object> parameters)`
`double`
PersistentObjectDAO.`queryForDouble(String sql)`
Execute a query that results in a double value, given static SQL.
`double`
PersistentObjectDAO.`queryForDouble(String sql, Map<String,Object> parameters)`
Execute a query that results in a double value, given static SQL.
`int`
HibernatePersistentObjectDAO.`queryForInt(String sql)`
`int`
HibernatePersistentObjectDAO.`queryForInt(String sql, Map<String,Object> parameters)`
`int`
PersistentObjectDAO.`queryForInt(String sql)`
Execute a query that results in an int value, given static SQL.
`int`
PersistentObjectDAO.`queryForInt(String sql, Map<String,Object> parameters)`
Execute a query that results in an int value, given static SQL.
`<R> List<R>`
HibernatePersistentObjectDAO.`queryForList(String sql, Class<R> requiredType)`
`<R> List<R>`
HibernatePersistentObjectDAO.`queryForList(String sql, Class<R> requiredType, Integer maxRows)`
`<R> List<R>`
HibernatePersistentObjectDAO.`queryForList(String sql, Map<String,Object> parameters, Class<R> requiredType, Integer maxRows)`
`<R> List<R>`
PersistentObjectDAO.`queryForList(String sql, Class<R> requiredType)`
Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, expecting a result list.
`<R> List<R>`
PersistentObjectDAO.`queryForList(String sql, Class<R> requiredType, Integer maxRows)`
Execute a query for a result list, given static SQL.
`<R> List<R>`
PersistentObjectDAO.`queryForList(String sql, Map<String,Object> parameters, Class<R> requiredType, Integer maxRows)`
Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, expecting a result list.
`long`
HibernatePersistentObjectDAO.`queryForLong(String sql)`
`long`
HibernatePersistentObjectDAO.`queryForLong(String sql, Map<String,Object> parameters)`
`long`
PersistentObjectDAO.`queryForLong(String sql)`
Execute a query that results in an long value, given static SQL.
`long`
PersistentObjectDAO.`queryForLong(String sql, Map<String,Object> parameters)`
Execute a query that results in an long value, given static SQL.
`<R> R`
HibernatePersistentObjectDAO.`queryForObject(String sql, Class<R> requiredType)`
`<R> R`
HibernatePersistentObjectDAO.`queryForObject(String sql, Map<String,Object> parameters, Class<R> requiredType)`
`<R> R`
PersistentObjectDAO.`queryForObject(String sql, Class<R> requiredType)`
Execute a query that results in a Object value, given static SQL.
`<R> R`
PersistentObjectDAO.`queryForObject(String sql, Map<String,Object> parameters, Class<R> requiredType)`
Execute a query that results in a Object value, given static SQL.
`void`
HibernatePersistentObjectDAO.`queryForResultSet(String sql, Map<String,Object> parameters, Integer maxRows, ResultSetWalker walker)`
`void`
PersistentObjectDAO.`queryForResultSet(String sql, Map<String,Object> parameters, Integer maxRows, ResultSetWalker worker)`
Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, you can give your own worker to iterate the `ResultSet`.
`String`
HibernatePersistentObjectDAO.`queryForString(String sql)`
`String`
HibernatePersistentObjectDAO.`queryForString(String sql, Map<String,Object> parameters)`
`String`
PersistentObjectDAO.`queryForString(String sql)`
Execute a query that results in an string value, given static SQL.
`String`
PersistentObjectDAO.`queryForString(String sql, Map<String,Object> parameters)`
Execute a query that results in an string value, given static SQL.
`void`
HibernatePersistentObjectDAO.`store(T entity)`
`void`
PersistentObjectDAO.`store(T entity)`
This method persists the entity object

## Uses of PersistenceException in com.logicaldoc.core.automation

Methods in com.logicaldoc.core.automation that throw PersistenceException
Modifier and Type
Method
Description
`void`
FolderTool.`applyTemplate(long rootId, String templateName, boolean inheritSecurity, String username)`
Applies a folder template
`Folder`
FolderTool.`copy(Folder source, String targetPath, boolean foldersOnly, String securityOption, String username)`
Copies a folder into another folder
`Document`
DocTool.`createAlias(Document originalDoc, String targetPath, String type, String username)`
Creates an alias to a document
`void`
FolderTool.`delete(long folderId, String username)`
Delete a folder
`String`
FolderTool.`getPath(Long folderId)`
Calculates the full path of a folder
`void`
FolderTool.`merge(Folder source, Folder target, String username)`
Merges a folder into another folder
`void`
FolderTool.`move(Folder folder, String targetPath, String username)`
Moves a folder into a target folder
`void`
MailTool.`sendDocument(Document document, String from, String to, String subject, String message)`
Sends a document by email to a recipient
`void`
MailTool.`sendDocument(Document document, String from, Collection<String> to, String subject, String message)`
Sends a document by email to a selection of recipients
`void`
MailTool.`sendDocuments(Collection<Document> documents, String from, String to, String subject, String message)`
Sends some documents to a recipient
`void`
MailTool.`sendDocuments(Collection<Document> documents, String from, Collection<String> to, String subject, String message)`
Sends some documents to a selection of recipients
`void`
MailTool.`sendSystemMessage(String recipient, String message, String subject, int scope, int priority)`
Sends a system message to a user

## Uses of PersistenceException in com.logicaldoc.core.communication

Methods in com.logicaldoc.core.communication that throw PersistenceException
Modifier and Type
Method
Description
`void`
HibernateMessageTemplateDAO.`delete(long id, int code)`
`void`
HibernateSystemMessageDAO.`deleteExpiredMessages(int type)`
`void`
HibernateSystemMessageDAO.`deleteExpiredMessages(String recipient)`
`void`
SystemMessageDAO.`deleteExpiredMessages(int type)`
Removes all expired messages for the specified type
`void`
SystemMessageDAO.`deleteExpiredMessages(String recipient)`
Removes all system expired messages for the specified recipient
`List<MessageTemplate>`
HibernateMessageTemplateDAO.`findByLanguage(String language, long tenantId)`
`List<MessageTemplate>`
MessageTemplateDAO.`findByLanguage(String language, long tenantId)`
Finds the templates by given language
`List<SystemMessage>`
HibernateSystemMessageDAO.`findByMode(String mode)`
`List<SystemMessage>`
SystemMessageDAO.`findByMode(String mode)`
This method selects all the messages for the specified mode
`List<MessageTemplate>`
HibernateMessageTemplateDAO.`findByName(String name, long tenantId)`
`List<MessageTemplate>`
MessageTemplateDAO.`findByName(String name, long tenantId)`
Finds the templates by given name, you may have the same name but for different languages.
`MessageTemplate`
HibernateMessageTemplateDAO.`findByNameAndLanguage(String name, String language, long tenantId)`
`MessageTemplate`
MessageTemplateDAO.`findByNameAndLanguage(String name, String language, long tenantId)`
Finds the template by the alternate key.
`List<SystemMessage>`
HibernateSystemMessageDAO.`findByRecipient(String recipient, int type, Integer read)`
`List<SystemMessage>`
SystemMessageDAO.`findByRecipient(String recipient, int type, Integer read)`
This method selects all the messages for the specified recipient and type
`List<SystemMessage>`
HibernateSystemMessageDAO.`findByType(int type)`
`List<SystemMessage>`
SystemMessageDAO.`findByType(int type)`
This method selects all the messages for the specified type
`List<MessageTemplate>`
HibernateMessageTemplateDAO.`findByTypeAndLanguage(String type, String language, long tenantId)`
`List<MessageTemplate>`
MessageTemplateDAO.`findByTypeAndLanguage(String type, String language, long tenantId)`
Finds the templates by the type.
`List<SystemMessage>`
HibernateSystemMessageDAO.`findMessagesToBeSent(int type, int maxTrial)`
`List<SystemMessage>`
SystemMessageDAO.`findMessagesToBeSent(int type, int maxTrials)`
This method selects all the messages for the specified type that are not been already sent and for which the number of sending trials is less than the maximum number (parameter 'notifier.maxtrials')
`int`
HibernateSystemMessageDAO.`getUnreadCount(String recipient, int type)`
`int`
SystemMessageDAO.`getUnreadCount(String recipient, int type)`
This methods gets the number of unread messages for the specified recipient and type.
`void`
HibernateSystemMessageDAO.`store(SystemMessage message)`

## Uses of PersistenceException in com.logicaldoc.core.contact

Methods in com.logicaldoc.core.contact that throw PersistenceException
Modifier and Type
Method
Description
`List<Contact>`
ContactDAO.`findByUser(Long userId, String email)`
Finds the contacts of the specified user.
`List<Contact>`
HibernateContactDAO.`findByUser(Long userId, String email)`
`void`
HibernateContactDAO.`store(Contact contact)`

## Uses of PersistenceException in com.logicaldoc.core.conversion

Methods in com.logicaldoc.core.conversion that throw PersistenceException
Modifier and Type
Method
Description
`Document`
FormatConversionManager.`convert(Document document, String fileVersion, String format, DocumentHistory transaction)`
Converts a document into another format and saves the resulting file in the same folder
`void`
FormatConversionManager.`convertToFile(Document document, String fileVersion, File out, DocumentHistory transaction)`
Converts a document and writes the content of the conversion into a file.
`void`
FormatConversionManager.`convertToPdf(Document document, String sid)`
Shortcut for convertToPdf(document, null, transaction)
`void`
FormatConversionManager.`convertToPdf(Document document, String fileVersion, String sid)`
Creates the pdf for the specified document and file version (suffix PDF_CONVERSION_SUFFIX).
`byte[]`
FormatConversionManager.`getPdfContent(Document document, String fileVersion, String sid)`
Retrieves the content of the Pdf conversion.
`void`
FormatConversionManager.`writePdfToFile(Document document, String fileVersion, File out, String sid)`
Write the content of the Pdf conversion into a file.

## Uses of PersistenceException in com.logicaldoc.core.dashlet

Methods in com.logicaldoc.core.dashlet that throw PersistenceException
Modifier and Type
Method
Description
`void`
HibernateDashletDAO.`delete(long id, int code)`
`Dashlet`
DashletDAO.`findByName(String name, long tenantId)`
Finds the dashlet by it's name
`Dashlet`
HibernateDashletDAO.`findByName(String name, long tenantId)`

## Uses of PersistenceException in com.logicaldoc.core.document

Subclasses of PersistenceException in com.logicaldoc.core.document
Modifier and Type
Class
Description
`class`
`TooManyDocumentsException`
Exception raised when you try to add more documents than allowed in the same folder
Methods in com.logicaldoc.core.document that throw PersistenceException
Modifier and Type
Method
Description
`void`
DocumentInitializer.`afterCheckin(Document document, DocumentHistory transaction, Map<String,Object> dictionary)`
`void`
DocumentListener.`afterCheckin(Document document, DocumentHistory transaction, Map<String,Object> dictionary)`
Called after a document is checked in
`void`
DocumentValidator.`afterCheckin(Document document, DocumentHistory transaction, Map<String,Object> dictionary)`
`void`
DocumentInitializer.`afterFileStore(Document document, DocumentHistory transaction, Map<String,Object> dictionary)`
`void`
DocumentListener.`afterFileStore(Document document, DocumentHistory transaction, Map<String,Object> dictionary)`
Called after a document's file gets stored after a creation or checkin.
`void`
DocumentValidator.`afterFileStore(Document document, DocumentHistory transaction, Map<String,Object> dictionary)`
`void`
DocumentInitializer.`afterSaveHistory(Document document, DocumentHistory event, Map<String,Object> dictionary)`
`void`
DocumentListener.`afterSaveHistory(Document document, DocumentHistory event, Map<String,Object> dictionary)`
Called after an event has been stored
`void`
DocumentValidator.`afterSaveHistory(Document document, DocumentHistory event, Map<String,Object> dictionary)`
`void`
DocumentInitializer.`afterStore(Document document, DocumentHistory transaction, Map<String,Object> dictionary)`
`void`
DocumentListener.`afterStore(Document document, DocumentHistory transaction, Map<String,Object> dictionary)`
Called after a document is stored in the database
`void`
DocumentValidator.`afterStore(Document document, DocumentHistory transaction, Map<String,Object> dictionary)`
`void`
DocumentDAO.`applyParentFolderSecurity(long docId, DocumentHistory transaction)`
Replaces the document's security policies with those from the parent folder
`void`
HibernateDocumentDAO.`applyParentFolderSecurity(long docId, DocumentHistory transaction)`
`void`
DocumentDAO.`archive(long docId, DocumentHistory transaction)`
Archives a document
`void`
HibernateDocumentDAO.`archive(long docId, DocumentHistory transaction)`
`void`
DocumentManager.`archiveDocuments(Set<Long> docIds, DocumentHistory transaction)`
Archives all the documents in a folder's tree
`long`
DocumentManager.`archiveFolder(long folderId, DocumentHistory transaction)`
Archives all the documents in a folder's tree
`void`
DocumentInitializer.`beforeCheckin(Document document, DocumentHistory transaction, Map<String,Object> dictionary)`
`void`
DocumentListener.`beforeCheckin(Document document, DocumentHistory transaction, Map<String,Object> dictionary)`
Called before a document is checked in
`void`
DocumentValidator.`beforeCheckin(Document document, DocumentHistory transaction, Map<String,Object> dictionary)`
`void`
DocumentInitializer.`beforeStore(Document document, DocumentHistory transaction, Map<String,Object> dictionary)`
`void`
DocumentListener.`beforeStore(Document document, DocumentHistory transaction, Map<String,Object> dictionary)`
Called before a document is stored in the database
`void`
DocumentValidator.`beforeStore(Document document, DocumentHistory transaction, Map<String,Object> dictionary)`
`DocumentFuture`
DocumentManager.`checkin(long docId, File file, String filename, boolean release, Document docVO, DocumentHistory transaction)`
Checks in the given document
`DocumentFuture`
DocumentManager.`checkin(long docId, InputStream content, String filename, boolean release, Document docVO, DocumentHistory transaction)`
Checks in the given document
`void`
DocumentManager.`checkout(long docId, DocumentHistory transaction)`
Checks out the given document
`void`
DocumentManager.`checkout(Document document, DocumentHistory transaction)`
Checks out the given document
`void`
DocumentDAO.`cleanExpiredTransactions()`
Cleans all references to expired transactions.
`void`
HibernateDocumentDAO.`cleanExpiredTransactions()`
`void`
DocumentHistoryDAO.`cleanOldHistories(int ttl)`
This method deletes all the document history entries older than the given days from now.
`void`
HibernateDocumentHistoryDAO.`cleanOldHistories(int ttl)`
`void`
DocumentDAO.`cleanUnexistingUniqueTags()`
Cleans the ld_uniquetag table removing no more used tags, this method is optimized and uses a couple of prepared statements, in case of error it switches to `DocumentDAO.cleanUnexistingUniqueTagsOneByOne()`
`void`
HibernateDocumentDAO.`cleanUnexistingUniqueTags()`
`void`
DocumentDAO.`cleanUnexistingUniqueTagsOneByOne()`
Cleans the ld_uniquetag table removing no more used tags programmatically one by one.
`void`
HibernateDocumentDAO.`cleanUnexistingUniqueTagsOneByOne()`
`long`
DocumentDAO.`computeTotalSize(Long tenantId, Long publisherId, boolean computeDeleted)`
Obtains the total size of the repository, that is the sum of sizes of all documents and their versions
`long`
HibernateDocumentDAO.`computeTotalSize(Long tenantId, Long userId, boolean computeDeleted)`
`int`
DocumentNoteDAO.`copyAnnotations(long docId, String oldFileVersion, String newFileVersion)`
Copies all the notes not associated to a specific page from a given file version to another
`int`
HibernateDocumentNoteDAO.`copyAnnotations(long docId, String oldFileVersion, String newFileVersion)`
`DocumentFuture`
DocumentManager.`copyToFolder(Document doc, Folder folder, DocumentHistory transaction, boolean links, boolean notes, boolean security)`
Copy a document to the specified folder.
`long`
DocumentDAO.`count(Long tenantId, boolean computeDeleted, boolean computeArchived)`
Counts the number of documents
`long`
HibernateDocumentDAO.`count(Long tenantId, boolean computeDeleted, boolean computeArchived)`
`long`
DocumentDAO.`countByIndexed(IndexingStatus indexingStatus)`
Counts the number of documents in a given indexation status(@see `AbstractDocument.getIndexed()`
`long`
HibernateDocumentDAO.`countByIndexed(IndexingStatus indexingStatus)`
`DocumentFuture`
DocumentManager.`create(File file, Document docVO, DocumentHistory transaction)`
Creates a new Document.
`DocumentFuture`
DocumentManager.`create(InputStream content, Document docVO, DocumentHistory transaction)`
Creates a new Document.
`Document`
DocumentManager.`createAlias(Document doc, Folder folder, String aliasType, DocumentHistory transaction)`
Create an alias(shortcut) associated to the given doc to the specified folder.
`Ticket`
DocumentManager.`createTicket(Ticket ticket, DocumentHistory transaction)`
Creates a new ticket.
`void`
DocumentDAO.`delete(long docId, int delCode, DocumentHistory transaction)`
This method deletes the document object and insert a new document history entry.
`void`
DocumentDAO.`delete(long docId, DocumentHistory transaction)`
Shortcut for delete(docId, 1, transaction)
`void`
HibernateDocumentDAO.`delete(long docId, int delCode, DocumentHistory transaction)`
`void`
HibernateDocumentDAO.`delete(long docId, DocumentHistory transaction)`
`void`
HibernateDocumentLinkDAO.`delete(long id, int code)`
`void`
HibernateDocumentNoteDAO.`delete(long id, int code)`
`void`
HibernateRatingDAO.`delete(long id, int code)`
`void`
HibernateVersionDAO.`delete(long versionId, int delCode)`
`void`
DocumentDAO.`deleteAll(Collection<Document> documents, int delCode, DocumentHistory transaction)`
Deletes all documents form the database and modifies the custom ids of all documents
`void`
DocumentDAO.`deleteAll(Collection<Document> documents, DocumentHistory transaction)`
Shortcut for deleteAll(documents, 1, transaction)
`void`
HibernateDocumentDAO.`deleteAll(Collection<Document> documents, int delCode, DocumentHistory transaction)`
`void`
HibernateDocumentDAO.`deleteAll(Collection<Document> documents, DocumentHistory transaction)`
`void`
HibernateVersionDAO.`deleteAll(Collection<Version> entities, int code)`
`void`
DocumentDAO.`deleteOrphaned(long deleteUserId)`
This method deletes the documents into deleted folders.
`void`
HibernateDocumentDAO.`deleteOrphaned(long deleteUserId)`
`Version`
DocumentManager.`deleteVersion(long versionId, DocumentHistory transaction)`
Deletes a specific version.
`void`
DocumentManager.`destroyDocument(long docId, FolderHistory transaction)`
Permanently deletes a document from the system, the document and all the dependent resources will not be recoverable in the future.
`int`
DocumentManager.`enforceFilesIntoFolderStore(long rootFolderId, DocumentHistory transaction)`
Moves all the files of the documents in the given tree from it's original location to the store defined in the owning folder
`List<Long>`
DocumentDAO.`findAliasIds(long docId)`
Gets the ids of all aliases associated to the document with the given docId
`List<Long>`
HibernateDocumentDAO.`findAliasIds(long docId)`
`List<String>`
DocumentDAO.`findAllTags(String firstLetter, Long tenantId)`
Searches for all unique tags.
`List<String>`
HibernateDocumentDAO.`findAllTags(String firstLetter, Long tenantId)`
`List<Document>`
DocumentDAO.`findArchivedByFolder(long folderId)`
Finds archived documents in a folder (direct childeren only)
`List<Document>`
HibernateDocumentDAO.`findArchivedByFolder(long folderId)`
`List<Long>`
BookmarkDAO.`findBookmarkedDocs(long userId)`
Finds the identifiers of the docs bookmarked by the given user
`List<Long>`
HibernateBookmarkDAO.`findBookmarkedDocs(long userId)`
`Document`
DocumentDAO.`findByCustomId(String customId, long tenantId)`
This method finds a document by the custom ID.
`Document`
HibernateDocumentDAO.`findByCustomId(String customId, long tenantId)`
`List<DocumentHistory>`
DocumentHistoryDAO.`findByDocId(long docId)`
This method selects all histories of a given document.
`List<DocumentLink>`
DocumentLinkDAO.`findByDocId(long docId)`
This method finds the list of document link in which there is a document with the given ID
`List<DocumentLink>`
DocumentLinkDAO.`findByDocId(long docId, String type)`
This method finds the list of document link, filtered by the given link type, in which there is a document with the given ID
`List<DocumentNote>`
DocumentNoteDAO.`findByDocId(long docId, long userId, String fileVersion)`
This method finds the list of document notes regarding a document with the given ID
`List<DocumentHistory>`
HibernateDocumentHistoryDAO.`findByDocId(long docId)`
`List<DocumentLink>`
HibernateDocumentLinkDAO.`findByDocId(long docId)`
`List<DocumentLink>`
HibernateDocumentLinkDAO.`findByDocId(long docId, String type)`
`List<DocumentNote>`
HibernateDocumentNoteDAO.`findByDocId(long docId, long userId, String fileVersion)`
`List<Rating>`
HibernateRatingDAO.`findByDocId(long docId)`
`List<Version>`
HibernateVersionDAO.`findByDocId(long docId)`
`List<Rating>`
RatingDAO.`findByDocId(long docId)`
Finds the ratings stored for the given document id
`List<Version>`
VersionDAO.`findByDocId(long docId)`
Finds all versions of the given document
`List<DocumentHistory>`
DocumentHistoryDAO.`findByDocIdAndEvent(long docId, DocumentEvent event)`
This method selects all histories of a given document.
`List<DocumentHistory>`
HibernateDocumentHistoryDAO.`findByDocIdAndEvent(long docId, DocumentEvent event)`
`List<DocumentNote>`
DocumentNoteDAO.`findByDocIdAndType(long docId, long userId, String fileVersion, String type)`
This method finds the list of document notes regarding a document with the given ID and optionally filter on the type
`List<DocumentNote>`
HibernateDocumentNoteDAO.`findByDocIdAndType(long docId, long userId, String fileVersion, String type)`
`List<DocumentNote>`
DocumentNoteDAO.`findByDocIdAndTypes(long docId, long userId, String fileVersion, Collection<String> types)`
This method finds the list of document notes regarding a document with the given ID and optionally filter on a collection of types
`List<DocumentNote>`
HibernateDocumentNoteDAO.`findByDocIdAndTypes(long docId, long userId, String fileVersion, Collection<String> types)`
`Rating`
HibernateRatingDAO.`findByDocIdAndUserId(long docId, long userId)`
`Rating`
RatingDAO.`findByDocIdAndUserId(long docId, long userId)`
Finds the rating for the given user id and the given document id
`DocumentLink`
DocumentLinkDAO.`findByDocIdsAndType(long docId1, long docId2, String type)`
Find a document link using its alternate keys
`DocumentLink`
HibernateDocumentLinkDAO.`findByDocIdsAndType(long docId1, long docId2, String type)`
`List<Document>`
DocumentDAO.`findByFileNameAndParentFolderId(Long folderId, String fileName, Long excludeId, Long tenantId, Integer max)`
Finds that document that lies under a specific folder (given by the id) an with a given fileName(like operator is used)
`List<Document>`
HibernateDocumentDAO.`findByFileNameAndParentFolderId(Long folderId, String fileName, Long excludeId, Long tenantId, Integer max)`
`Version`
HibernateVersionDAO.`findByFileVersion(long docId, String fileVersion)`
`Version`
VersionDAO.`findByFileVersion(long docId, String fileVersion)`
This method finds a the first version with the given fileVersion
`List<Document>`
DocumentDAO.`findByFolder(long folderId, Integer max)`
Finds all documents direct children of the given folder.
`List<Document>`
HibernateDocumentDAO.`findByFolder(long folderId, Integer max)`
`List<DocumentHistory>`
DocumentHistoryDAO.`findByFolderId(long folderId)`
This method selects all histories of a given folder.
`List<DocumentHistory>`
HibernateDocumentHistoryDAO.`findByFolderId(long folderId)`
`List<Document>`
DocumentDAO.`findByIndexingStatus(IndexingStatus indexingStatus)`
Finds all documents by the indexing status.
`List<Document>`
HibernateDocumentDAO.`findByIndexingStatus(IndexingStatus indexingStatus)`
`Document`
DocumentDAO.`findByPath(String path, long tenantId)`
Finds a document by it's full path
`List<DocumentHistory>`
DocumentHistoryDAO.`findByPath(String pathExpression, Date oldestDate, Collection<String> events, Integer max)`
This method finds all histories about a path (you can use expression)
`Document`
HibernateDocumentDAO.`findByPath(String path, long tenantId)`
`List<DocumentHistory>`
HibernateDocumentHistoryDAO.`findByPath(String pathExpression, Date oldestDate, Collection<String> events, Integer max)`
`List<Bookmark>`
BookmarkDAO.`findByUserId(long userId)`
Finds all bookmarks for the given user id
`List<Long>`
DocumentDAO.`findByUserId(long userId)`
Finds all documents for a user.
`List<DocumentHistory>`
DocumentHistoryDAO.`findByUserId(long userId)`
This method selects all histories of a given user.
`List<DocumentNote>`
DocumentNoteDAO.`findByUserId(long userId)`
This method finds the list of document notes regarding posted by a specific user
`List<Bookmark>`
HibernateBookmarkDAO.`findByUserId(long userId)`
`List<Long>`
HibernateDocumentDAO.`findByUserId(long userId)`
`List<DocumentHistory>`
HibernateDocumentHistoryDAO.`findByUserId(long userId)`
`List<DocumentNote>`
HibernateDocumentNoteDAO.`findByUserId(long userId)`
`Bookmark`
BookmarkDAO.`findByUserIdAndDocId(long userId, long docId)`
Finds all bookmarks for the given user id and the given document's identifier
`Bookmark`
HibernateBookmarkDAO.`findByUserIdAndDocId(long userId, long docId)`
`List<DocumentHistory>`
DocumentHistoryDAO.`findByUserIdAndEvent(long userId, String event, String sessionId)`
This method selects all histories of a given user and related to the given event.
`List<DocumentHistory>`
HibernateDocumentHistoryDAO.`findByUserIdAndEvent(long userId, String event, String sessionId)`
`Bookmark`
BookmarkDAO.`findByUserIdAndFolderId(long userId, long folderId)`
Finds the bookmark for the given user id and the given folder id
`Bookmark`
HibernateBookmarkDAO.`findByUserIdAndFolderId(long userId, long folderId)`
`List<Document>`
DocumentDAO.`findByUserIdAndTag(long userId, String tag, Integer max)`
Finds authorized documents for a user having a specified tag.
`List<Document>`
HibernateDocumentDAO.`findByUserIdAndTag(long userId, String tag, Integer max)`
`Version`
HibernateVersionDAO.`findByVersion(long docId, String version)`
`Version`
VersionDAO.`findByVersion(long docId, String version)`
This method finds a version by the document's ID an the version code.
`List<Document>`
DocumentDAO.`findDeleted(long userId, Integer max)`
Finds all deleted docs of a specific user.
`List<Document>`
HibernateDocumentDAO.`findDeleted(long userId, Integer maxHits)`
`List<Long>`
DocumentDAO.`findDeletedDocIds()`
Gets the collection of deleted document ids
`List<Long>`
HibernateDocumentDAO.`findDeletedDocIds()`
`List<Document>`
DocumentDAO.`findDeletedDocs()`
Finds the list of deleted documents.
`List<Document>`
HibernateDocumentDAO.`findDeletedDocs()`
`List<Long>`
DocumentDAO.`findDocIdByFolder(long folderId, Integer max)`
Finds all document ids inside the given folder.
`List<Long>`
HibernateDocumentDAO.`findDocIdByFolder(long folderId, Integer max)`
`List<Long>`
DocumentDAO.`findDocIdByTag(String tag)`
This method finds all Doc Ids by a tag.
`List<Long>`
HibernateDocumentDAO.`findDocIdByTag(String tag)`
`List<Long>`
DocumentDAO.`findDocIdByUserIdAndTag(long userId, String tag)`
Finds authorized documents ids for a user having a specified tag.
`List<Long>`
HibernateDocumentDAO.`findDocIdByUserIdAndTag(long userId, String tag)`
`Document`
DocumentDAO.`findDocument(long docId)`
This method finds a document by the ID and if it is an alias the referenced document is returned instead.
`Document`
HibernateDocumentDAO.`findDocument(long docId)`
`List<String>`
DocumentDAO.`findDuplicatedDigests(Long tenantId, Long folderId)`
Retrieves the list of duplicated checksums
`List<String>`
HibernateDocumentDAO.`findDuplicatedDigests(Long tenantId, Long folderId)`
`List<Document>`
DocumentDAO.`findLastDownloadsByUserId(long userId, int max)`
Finds the last downloaded documents by the given user
`List<Document>`
HibernateDocumentDAO.`findLastDownloadsByUserId(long userId, int maxResults)`
`List<Document>`
DocumentDAO.`findLastModifiedByUserId(long userId, int max)`
Finds a max number of documents last modified by an user.
`List<Document>`
HibernateDocumentDAO.`findLastModifiedByUserId(long userId, int maxElements)`
`List<Document>`
DocumentDAO.`findLinkedDocuments(long docId, String linkType, Integer direction)`
This method enlists documents linked to the given document.
`List<Document>`
HibernateDocumentDAO.`findLinkedDocuments(long docId, String linkType, Integer direction)`
`List<DocumentHistory>`
DocumentHistoryDAO.`findNotNotified(Integer max)`
This method selects all histories not notified yet.
`List<DocumentHistory>`
HibernateDocumentHistoryDAO.`findNotNotified(Integer max)`
`Collection<Long>`
DocumentDAO.`findPublishedIds(Collection<Long> folderIds)`
Finds all document ids inside the specified folders that are published in the current date.
`Collection<Long>`
HibernateDocumentDAO.`findPublishedIds(Collection<Long> folderIds)`
`List<String>`
DocumentDAO.`findTags(long docId)`
Retrieves the alphabetically ordered list of all the document's tags
`Map<String,Long>`
DocumentDAO.`findTags(String firstLetter, Long tenantId)`
Selects all tags and counts the occurrences.
`List<String>`
HibernateDocumentDAO.`findTags(long docId)`
`Map<String,Long>`
HibernateDocumentDAO.`findTags(String firstLetter, Long tenantId)`
`Rating`
HibernateRatingDAO.`findVotesByDocId(long docId)`
`Rating`
RatingDAO.`findVotesByDocId(long docId)`
Returns a rating that contains count and average of vote on the given document
`Set<Permission>`
DocumentDAO.`getAllowedPermissions(long documentId, long userId)`
Finds all permissions of a user enabled on the specified document
`Set<Permission>`
DocumentNoteDAO.`getAllowedPermissions(long noteId, long userId)`
Finds all permissions of a user enabled on the specified note
`Set<Permission>`
HibernateDocumentDAO.`getAllowedPermissions(long docId, long userId)`
`Set<Permission>`
HibernateDocumentNoteDAO.`getAllowedPermissions(long noteId, long userId)`
`List<TagCloud>`
DocumentDAO.`getTagCloud(long tenantId, int max)`
Gets the tag cloud for the given tenant
`List<TagCloud>`
DocumentDAO.`getTagCloud(String sid)`
Gets the tag cloud for the given tenant
`List<TagCloud>`
HibernateDocumentDAO.`getTagCloud(long tenantId, int maxTags)`
`List<TagCloud>`
HibernateDocumentDAO.`getTagCloud(String sid)`
`Folder`
DocumentDAO.`getWorkspace(long docId)`
Retrieves, the workspace where the document(or alias) is stored
`Folder`
HibernateDocumentDAO.`getWorkspace(long docId)`
`long`
DocumentManager.`index(long docId, String content, DocumentHistory transaction)`
Re-indexes an existing document in the full-text index.
`void`
HibernateDocumentNoteDAO.`initialize(DocumentNote note)`
`void`
DocumentDAO.`insertNewUniqueTags()`
Puts into ld_uniquetag the new unique tags
`void`
HibernateDocumentDAO.`insertNewUniqueTags()`
`boolean`
BookmarkDAO.`isDocBookmarkedByUser(long docId, long userId)`
Checks if the document is bookmarked by a user
`boolean`
HibernateBookmarkDAO.`isDocBookmarkedByUser(long docId, long userId)`
`boolean`
DocumentDAO.`isDownloadAllowed(long documentId, long userId)`
`boolean`
HibernateDocumentDAO.`isDownloadAllowed(long id, long userId)`
`boolean`
DocumentDAO.`isMoveAllowed(long documentId, long userId)`
`boolean`
HibernateDocumentDAO.`isMoveAllowed(long id, long userId)`
`boolean`
DocumentDAO.`isPermissionAllowed(Permission permission, long documentId, long userId)`
This method checks if the given permission is enabled for a document and an user.
`boolean`
HibernateDocumentDAO.`isPermissionAllowed(Permission permission, long documentId, long userId)`
`boolean`
DocumentDAO.`isPreviewAllowed(long documentId, long userId)`
`boolean`
HibernateDocumentDAO.`isPreviewAllowed(long docId, long userId)`
`boolean`
DocumentDAO.`isPrintAllowed(long documentId, long userId)`
`boolean`
HibernateDocumentDAO.`isPrintAllowed(long id, long userId)`
`boolean`
DocumentDAO.`isReadAllowed(long documentId, long userId)`
`boolean`
DocumentNoteDAO.`isReadAllowed(long noteId, long userId)`
This method is looking up for read rights for a note and an user
`boolean`
HibernateDocumentDAO.`isReadAllowed(long docId, long userId)`
`boolean`
HibernateDocumentNoteDAO.`isReadAllowed(long noteId, long userId)`
`boolean`
DocumentDAO.`isWriteAllowed(long documentId, long userId)`
This method is looking up for writing rights for a document and an user.
`boolean`
DocumentNoteDAO.`isWriteAllowed(long noteId, long userId)`
This method is looking up for writing rights for a note and an user
`boolean`
HibernateDocumentDAO.`isWriteAllowed(long id, long userId)`
`boolean`
HibernateDocumentNoteDAO.`isWriteAllowed(long noteId, long userId)`
`void`
DocumentManager.`lock(long docId, DocumentStatus status, DocumentHistory transaction)`
Locks the given document
`void`
DocumentManager.`lock(Document document, DocumentStatus status, DocumentHistory transaction)`
Locks the given document, it is synchronized because under high-ferquency, Hibernate may fail
`void`
DocumentDAO.`makeImmutable(long docId, DocumentHistory transaction)`
Marks the document, with the given docId, as immutable.
`void`
DocumentManager.`makeImmutable(long docId, DocumentHistory transaction)`
Marks the document, with the given docId, as immutable and save the given document history
`void`
HibernateDocumentDAO.`makeImmutable(long docId, DocumentHistory transaction)`
`void`
DocumentHistoryDAO.`markHistoriesAsRead(String event, long userId)`
Marks all the histories of a specific event as read by the specified user.
`void`
HibernateDocumentHistoryDAO.`markHistoriesAsRead(String event, long userId)`
`DocumentFuture`
DocumentManager.`merge(Collection<Document> documents, long targetFolderId, String fileName, DocumentHistory transaction)`
Merges a set of documents into a single PDF file
`DocumentFuture`
DocumentManager.`moveToFolder(Document doc, Folder folder, DocumentHistory transaction)`
Moves a document to the specified folder.
`void`
DocumentManager.`promoteVersion(long docId, String version, DocumentHistory transaction)`
Promotes an old version to the current default one.
`DocumentFuture`
DocumentManager.`rename(long docId, String newName, DocumentHistory transaction)`
Rename an existing document filename.
`DocumentFuture`
DocumentManager.`replaceAlias(long aliasId, DocumentHistory transaction)`
Replaces an alias with a copy of the original file
`DocumentFuture`
DocumentManager.`replaceFile(long docId, String fileVersion, File newFile, DocumentHistory transaction)`
Replaces the file of a given version
`DocumentFuture`
DocumentManager.`replaceFile(long docId, String fileVersion, InputStream content, DocumentHistory transaction)`
Replaces the file of a given version
`void`
DocumentDAO.`restore(long docId, long folderId, DocumentHistory transaction)`
Restores a previously deleted document
`void`
HibernateDocumentDAO.`restore(long docId, long folderId, DocumentHistory transaction)`
`void`
DocumentDAO.`saveDocumentHistory(Document doc, DocumentHistory transaction)`
Saves a document's history
`void`
HibernateDocumentDAO.`saveDocumentHistory(Document doc, DocumentHistory transaction)`
`void`
DocumentDAO.`setPassword(long docId, String password, DocumentHistory transaction)`
Protects the document with a password.
`void`
HibernateDocumentDAO.`setPassword(long docId, String password, DocumentHistory transaction)`
`void`
DocumentDAO.`store(Document doc, DocumentHistory transaction)`
This method persists the document object and insert a new document history entry
`void`
DocumentNoteDAO.`store(DocumentNote note, DocumentHistory transaction)`
Stores a note and saves the document's history
`void`
HibernateDocumentDAO.`store(Document doc)`
`void`
HibernateDocumentDAO.`store(Document doc, DocumentHistory transaction)`
`void`
HibernateDocumentLinkDAO.`store(DocumentLink entity)`
`void`
HibernateDocumentNoteDAO.`store(DocumentNote note)`
`void`
HibernateDocumentNoteDAO.`store(DocumentNote note, DocumentHistory transaction)`
`void`
HibernateRatingDAO.`store(Rating rating, DocumentHistory transaction)`
`void`
HibernateVersionDAO.`store(Version version)`
This method persists the given version.
`void`
RatingDAO.`store(Rating rating, DocumentHistory transaction)`
Stores a rating and saves the document's history
`void`
DocumentDAO.`unarchive(long docId, DocumentHistory transaction)`
Restores a previously archived document
`void`
HibernateDocumentDAO.`unarchive(long docId, DocumentHistory transaction)`
`void`
DocumentManager.`unlock(long docId, DocumentHistory transaction)`
Unchecks out the given document
`void`
DocumentDAO.`unsetPassword(long docId, DocumentHistory transaction)`
Removes the password protection from the document.
`void`
HibernateDocumentDAO.`unsetPassword(long docId, DocumentHistory transaction)`
`void`
DocumentManager.`update(Document document, Document docVO, DocumentHistory transaction)`
Updates an existing document and marks it to be re-indexed
`void`
DocumentDAO.`updateCountUniqueTags()`
Updates the count of the unique tags
`void`
HibernateDocumentDAO.`updateCountUniqueTags()`
`void`
DocumentDAO.`updateDigest(Document doc)`
Updates the document's digest (SHA-1)
`void`
HibernateDocumentDAO.`updateDigest(Document doc)`
`void`
HibernateVersionDAO.`updateDigest(Version version)`
`void`
VersionDAO.`updateDigest(Version version)`
Updates the version's digest (SHA-1)
`int`
HibernateRatingDAO.`updateDocumentRating(long docId, DocumentHistory transaction)`
`int`
RatingDAO.`updateDocumentRating(long docId, DocumentHistory transaction)`
Updates the document's rating with the votes average

## Uses of PersistenceException in com.logicaldoc.core.filler

Methods in com.logicaldoc.core.filler that throw PersistenceException
Modifier and Type
Method
Description
`void`
HibernateFillerDAO.`delete(long id, int code)`
`void`
ChainFiller.`fill(Fillable fillable, String content, History transaction, Map<String,Object> dictionary)`
`void`
Filler.`fill(Document document, DocumentHistory transaction, Map<String,Object> dictionary)`
Fills a document using the body text as input
`abstract void`
Filler.`fill(Fillable fillable, String content, History transaction, Map<String,Object> dictionary)`
Fills an object instance
`Filler`
FillerDAO.`findByName(String name, long tenantId)`
Finds the filler by it's name
`Filler`
HibernateFillerDAO.`findByName(String name, long tenantId)`
`<S extends Filler>
List<S>`
FillerDAO.`findByType(Class<S> type, long tenantId)`
Finds the fillers by type
`<S extends Filler>
List<S>`
HibernateFillerDAO.`findByType(Class<S> type, long tenantId)`
`void`
HibernateFillerDAO.`initialize(Filler entity)`

## Uses of PersistenceException in com.logicaldoc.core.folder

Methods in com.logicaldoc.core.folder that throw PersistenceException
Modifier and Type
Method
Description
`void`
FolderInitializer.`afterStore(Folder document, FolderHistory transaction, Map<String,Object> dictionary)`
`void`
FolderListener.`afterStore(Folder folder, FolderHistory transaction, Map<String,Object> dictionary)`
Called after a folder is stored in the database
`void`
FolderValidator.`afterStore(Folder folder, FolderHistory transaction, Map<String,Object> dictionary)`
`void`
FolderDAO.`applyCaptureToTree(long id, FolderHistory transaction)`
Propagates the automated capture settings to the whole subree
`void`
HibernateFolderDAO.`applyCaptureToTree(long id, FolderHistory transaction)`
`void`
FolderDAO.`applyGridToTree(long rootId, FolderHistory transaction)`
Propagates the grid layout of a node to the whole sub-tree
`void`
HibernateFolderDAO.`applyGridToTree(long id, FolderHistory transaction)`
`void`
FolderDAO.`applyMetadataToTree(long id, FolderHistory transaction)`
Propagates the template metadata to the whole subree
`void`
HibernateFolderDAO.`applyMetadataToTree(long id, FolderHistory transaction)`
`void`
FolderDAO.`applySecurityToTree(long rootId, FolderHistory transaction)`
Propagates the security policies of a node to the whole sub-tree
`void`
HibernateFolderDAO.`applySecurityToTree(long rootId, FolderHistory transaction)`
`void`
FolderDAO.`applyStoreToTree(long id, FolderHistory transaction)`
Propagates the store setting to the whole subree
`void`
HibernateFolderDAO.`applyStoreToTree(long id, FolderHistory transaction)`
`void`
FolderDAO.`applyTagsToTree(long id, FolderHistory transaction)`
Propagates the tags to the whole subree
`void`
HibernateFolderDAO.`applyTagsToTree(long id, FolderHistory transaction)`
`void`
FolderInitializer.`beforeStore(Folder folder, FolderHistory transaction, Map<String,Object> dictionary)`
`void`
FolderListener.`beforeStore(Folder folder, FolderHistory transaction, Map<String,Object> dictionary)`
Called before a folder is stored in the database
`void`
FolderValidator.`beforeStore(Folder folder, FolderHistory transaction, Map<String,Object> dictionary)`
`void`
FolderHistoryDAO.`cleanOldHistories(int ttl)`
This method deletes all the user history entries oldest than the given days from now.
`void`
HibernateFolderHistoryDAO.`cleanOldHistories(int ttl)`
`String`
FolderDAO.`computePath(long folderId)`
Dynamically computes the path for the specified folder.
`String`
FolderDAO.`computePath(Folder folder)`
Dynamically computes the path for the specified folder.
`String`
HibernateFolderDAO.`computePath(long folderId)`
`String`
HibernateFolderDAO.`computePath(Folder folder)`
`String`
FolderDAO.`computePathExtended(long folderId)`
Dynamically computes the path extended for the specified folder.
`String`
FolderDAO.`computePathExtended(Folder folder)`
Dynamically computes the path extended for the specified folder.
`String`
HibernateFolderDAO.`computePathExtended(long folderId)`
`String`
HibernateFolderDAO.`computePathExtended(Folder folder)`
`long`
FolderDAO.`computeTreeSize(long rootId)`
Counts the number of documents inside a given folder's tree (direct and indirect children)
`Folder`
FolderDAO.`copy(Folder source, Folder target, String newName, boolean foldersOnly, String securityOption, FolderHistory transaction)`
Copies a folder into another folder
`Folder`
HibernateFolderDAO.`copy(Folder source, Folder target, String newName, boolean foldersOnly, String securityOption, FolderHistory transaction)`
`long`
FolderDAO.`countDocs(long folderId)`
Counts the number of documents inside a given folder
`long`
FolderDAO.`countDocsInTree(long rootId)`
Counts the number of documents inside a given folder's tree (direct and indirect children)
`Folder`
FolderDAO.`create(Folder parent, Folder folderVO, boolean inheritSecurity, FolderHistory transaction)`
Creates a new folder in the parent Folder
`Folder`
HibernateFolderDAO.`create(Folder parent, Folder folderVO, boolean inheritSecurity, FolderHistory transaction)`
`Folder`
FolderDAO.`createAlias(long parentId, long foldRef, FolderHistory transaction)`
Creates a new folder folder alias
`Folder`
HibernateFolderDAO.`createAlias(long parentId, long foldRef, FolderHistory transaction)`
`Folder`
FolderDAO.`createPath(Folder parent, String path, boolean inheritSecurity, FolderHistory transaction)`
Creates the folder for the specified path.
`Folder`
HibernateFolderDAO.`createPath(Folder parent, String path, boolean inheritSecurity, FolderHistory transaction)`
`void`
FolderDAO.`delete(long id, int delCode, FolderHistory transaction)`
This method deletes the folder object and insert a new folder history entry
`void`
FolderDAO.`delete(long id, FolderHistory transaction)`
Shortcut for delete(id, 1, transaction)
`void`
HibernateFolderDAO.`delete(long folderId, int code)`
`void`
HibernateFolderDAO.`delete(long folderId, int delCode, FolderHistory transaction)`
`void`
HibernateFolderDAO.`delete(long folderId, FolderHistory transaction)`
`void`
FolderDAO.`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`
FolderDAO.`deleteAll(Collection<Folder> folders, FolderHistory transaction)`
Shortcut for deleteAll(folders, 1, transaction)
`void`
HibernateFolderDAO.`deleteAll(Collection<Folder> folders, int code, FolderHistory transaction)`
`void`
HibernateFolderDAO.`deleteAll(Collection<Folder> folders, FolderHistory transaction)`
`List<Folder>`
FolderDAO.`deleteTree(long folderId, int delCode, FolderHistory transaction)`
Delete a folder and all its sub-folders that a user can delete.
`List<Folder>`
FolderDAO.`deleteTree(long folderId, FolderHistory transaction)`
Shortcut for deleteTree(folderId, 1, transaction)
`List<Folder>`
FolderDAO.`deleteTree(Folder folder, int delCode, FolderHistory transaction)`
Deletes a folder and all its sub-folders that a user can delete.
`List<Folder>`
HibernateFolderDAO.`deleteTree(long folderId, int delCode, FolderHistory transaction)`
`List<Folder>`
HibernateFolderDAO.`deleteTree(long folderId, FolderHistory transaction)`
`List<Folder>`
HibernateFolderDAO.`deleteTree(Folder folder, int delCode, FolderHistory transaction)`
`List<Folder>`
FolderDAO.`find(String name, Long tenantId)`
Useful method that allows to find all folders that contains the given name into their text.
`List<Folder>`
HibernateFolderDAO.`find(String name, Long tenantId)`
`List<Folder>`
FolderDAO.`findAliases(Long foldRef, long tenantId)`
Finds all the aliases
`List<FolderHistory>`
FolderHistoryDAO.`findByFolderId(long folderId)`
This method selects all histories of a given folder.
`List<FolderHistory>`
HibernateFolderHistoryDAO.`findByFolderId(long folderId)`
`List<FolderHistory>`
FolderHistoryDAO.`findByFolderIdAndEvent(long folderId, String event, Date oldestDate)`
This method selects all histories of a given folder and event occurred after a given date.
`List<FolderHistory>`
HibernateFolderHistoryDAO.`findByFolderIdAndEvent(long folderId, String event, Date oldestDate)`
`List<Folder>`
FolderDAO.`findByGroupId(long groupId)`
Finds all folders accessible by the passed group
`List<Folder>`
HibernateFolderDAO.`findByGroupId(long groupId)`
`List<Folder>`
FolderDAO.`findByName(Folder parent, String name, Long tenantId, boolean caseSensitive)`
Finds all folders by folder text, contained in the parent folder.
`List<Folder>`
FolderDAO.`findByName(String name, Long tenantId)`
Finds all folders by folder name
`List<Folder>`
HibernateFolderDAO.`findByName(Folder parent, String name, Long tenantId, boolean caseSensitive)`
`List<Folder>`
HibernateFolderDAO.`findByName(String name, Long tenantId)`
`List<Folder>`
FolderDAO.`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>`
HibernateFolderDAO.`findByNameAndParentId(String name, long parentId)`
`List<FolderHistory>`
FolderHistoryDAO.`findByPath(String pathExpression, Date oldestDate, Collection<String> events, Integer max)`
This method finds all histories about a path (you can use expression)
`List<FolderHistory>`
HibernateFolderHistoryDAO.`findByPath(String pathExpression, Date oldestDate, Collection<String> events, Integer max)`
`Folder`
FolderDAO.`findByPathExtended(String pathExtended, long tenantId)`
Retrieval of a folder by the extended path
`Folder`
HibernateFolderDAO.`findByPathExtended(String pathExtended, long tenantId)`
`List<Folder>`
FolderDAO.`findByUserId(long userId)`
Finds authorized folders for a user
`List<Folder>`
FolderDAO.`findByUserId(long userId, long parentId)`
Finds direct children of a folder.
`List<FolderHistory>`
FolderHistoryDAO.`findByUserId(long userId)`
This method selects all histories of a given user.
`List<Folder>`
HibernateFolderDAO.`findByUserId(long userId)`
`List<Folder>`
HibernateFolderDAO.`findByUserId(long userId, long parentId)`
`List<FolderHistory>`
HibernateFolderHistoryDAO.`findByUserId(long userId)`
`List<FolderHistory>`
FolderHistoryDAO.`findByUserIdAndEvent(long userId, String event)`
This method selects all histories of a given user and related to the given event.
`List<FolderHistory>`
HibernateFolderHistoryDAO.`findByUserIdAndEvent(long userId, String event)`
`List<Folder>`
FolderDAO.`findByUserIdAndTag(long userId, String tag, Integer max)`
Finds authorized folders for a user having a specified tag.
`List<Folder>`
HibernateFolderDAO.`findByUserIdAndTag(long userId, String tag, Integer max)`
`List<Folder>`
FolderDAO.`findChildren(long parentId, long userId)`
Finds direct children of a folder accessible by the given user
`List<Folder>`
FolderDAO.`findChildren(long parentId, Integer max)`
Finds direct children of a folder
`List<Folder>`
HibernateFolderDAO.`findChildren(long parentId, long userId)`
`List<Folder>`
HibernateFolderDAO.`findChildren(long parentId, Integer max)`
`Folder`
FolderDAO.`findDefaultWorkspace(long tenantId)`
Retrieves the Default workspace of the given tenant
`Folder`
HibernateFolderDAO.`findDefaultWorkspace(long tenantId)`
`List<Folder>`
FolderDAO.`findDeleted(long userId, Integer maxHits)`
Finds all deleted folders of a specific user.
`Folder`
FolderDAO.`findFolder(long folderId)`
Gets a folder by a given ID if it is an alias, the referenced folder is returned.
`Folder`
HibernateFolderDAO.`findFolder(long folderId)`
`Collection<Long>`
FolderDAO.`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>`
HibernateFolderDAO.`findFolderIdByUserId(long userId, Long parentId, boolean tree)`
`Collection<Long>`
FolderDAO.`findFolderIdByUserIdAndPermission(long userId, Permission permission, Long parentId, boolean tree)`
Finds all folders ids with a specific permission enabled on the specifies user
`Collection<Long>`
HibernateFolderDAO.`findFolderIdByUserIdAndPermission(long userId, Permission permission, Long parentId, boolean tree)`
`Collection<Long>`
FolderDAO.`findFolderIdByUserIdInPath(long userId, long parentId)`
This method selects only the folder ID from the folders for which a user is authorized.
`Collection<Long>`
HibernateFolderDAO.`findFolderIdByUserIdInPath(long userId, long parentId)`
`Collection<Long>`
FolderDAO.`findFolderIdInPath(long rootId, boolean includeDeleted)`
Retrieve all the ids of the folders in a given tree using the path attribute
`Set<Long>`
HibernateFolderDAO.`findFolderIdInPath(long rootId, boolean includeDeleted)`
`List<Long>`
FolderDAO.`findIdByUserId(long userId, long parentId)`
This method selects only the folder ID from the folders for which a user is authorized.
`List<Long>`
HibernateFolderDAO.`findIdByUserId(long userId, long parentId)`
`List<FolderHistory>`
FolderHistoryDAO.`findNotNotified(Integer max)`
This method selects all histories not notified yet.
`List<FolderHistory>`
HibernateFolderHistoryDAO.`findNotNotified(Integer max)`
`List<Folder>`
FolderDAO.`findParents(long id)`
Returns a List of folders being a parent of the given folder.
`List<Folder>`
HibernateFolderDAO.`findParents(long folderId)`
`Folder`
FolderDAO.`findRoot(long tenantId)`
Retrieves the root folder of the given tenant
`Folder`
HibernateFolderDAO.`findRoot(long tenantId)`
`List<String>`
FolderDAO.`findTags(long folderId)`
Retrieves the alphabetically ordered list of all the folder's tags
`Folder`
FolderDAO.`findWorkspace(long folderId)`
Returns the workspace that contains the given folder
`Folder`
HibernateFolderDAO.`findWorkspace(long folderId)`
`List<Folder>`
FolderDAO.`findWorkspaces(long tanantId)`
Retrieves all the workspaces in the system, that are the first-level folders of type `Folder.TYPE_WORKSPACE`
`List<Folder>`
HibernateFolderDAO.`findWorkspaces(long tenantId)`
`Set<Permission>`
FolderDAO.`getAllowedPermissions(long folderId, long userId)`
Finds all permissions of a user enabled on the specified folder
`Set<Permission>`
HibernateFolderDAO.`getAllowedPermissions(long folderId, long userId)`
`boolean`
FolderDAO.`hasWriteAccess(Folder folder, long userId)`
Checks that the user has write access to the folder and all its sub-items
`boolean`
HibernateFolderDAO.`hasWriteAccess(Folder folder, long userId)`
`boolean`
FolderDAO.`isDownloadllowed(long folderId, long userId)`
`boolean`
HibernateFolderDAO.`isDownloadllowed(long id, long userId)`
`boolean`
FolderDAO.`isInPath(long parentId, long childId)`
Checks if a folder with the given folderId is parent of the folder with the given targetId
`boolean`
HibernateFolderDAO.`isInPath(long folderId, long targetId)`
`boolean`
FolderDAO.`isMoveAllowed(long folderId, long userId)`
`boolean`
HibernateFolderDAO.`isMoveAllowed(long id, long userId)`
`boolean`
FolderDAO.`isPermissionAllowed(Permission permission, long folderId, long userId)`
This method checks if the given permission is allowed for a folder and an user.
`boolean`
HibernateFolderDAO.`isPermissionAllowed(Permission permission, long folderId, long userId)`
`boolean`
FolderDAO.`isPreviewAllowed(long folderId, long userId)`
`boolean`
HibernateFolderDAO.`isPreviewAllowed(long id, long userId)`
`boolean`
FolderDAO.`isPrintAllowed(long folderId, long userId)`
`boolean`
HibernateFolderDAO.`isPrintAllowed(long folderId, long userId)`
`boolean`
FolderDAO.`isReadAllowed(long folderId, long userId)`
`boolean`
HibernateFolderDAO.`isReadAllowed(long folderId, long userId)`
`boolean`
FolderDAO.`isWriteAllowed(long folderId, long userId)`
This method is looking up for writing rights for a folder and an user.
`boolean`
HibernateFolderDAO.`isWriteAllowed(long folderId, long userId)`
`void`
FolderDAO.`merge(Folder source, Folder target, FolderHistory transaction)`
Merges the contents of two folders
`void`
HibernateFolderDAO.`merge(Folder source, Folder target, FolderHistory transaction)`
`void`
FolderDAO.`move(Folder source, Folder target, FolderHistory transaction)`
Moves a folder into another folder
`void`
HibernateFolderDAO.`move(Folder source, Folder target, FolderHistory transaction)`
`void`
FolderDAO.`restore(long folderId, long parentId, FolderHistory transaction)`
Restores a previously deleted folder
`void`
HibernateFolderDAO.`restore(long folderId, long parentId, FolderHistory transaction)`
`void`
FolderDAO.`saveFolderHistory(Folder folder, FolderHistory transaction)`
Utility method that logs into the DB the transaction that involved the passed folder.
`void`
HibernateFolderDAO.`saveFolderHistory(Folder folder, FolderHistory transaction)`
Utility method that logs into the DB the transaction that involved the passed folder.
`void`
FolderDAO.`store(Folder folder, FolderHistory transaction)`
Same as store(Folder, boolean, FolderHistory)
`void`
HibernateFolderDAO.`store(Folder folder)`
`void`
HibernateFolderDAO.`store(Folder folder, FolderHistory transaction)`
`void`
FolderDAO.`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.
`void`
HibernateFolderDAO.`updateSecurityRef(long folderId, long rightsFolderId, FolderHistory transaction)`

## Uses of PersistenceException in com.logicaldoc.core.generic

Methods in com.logicaldoc.core.generic that throw PersistenceException
Modifier and Type
Method
Description
`void`
HibernateGenericDAO.`delete(long genericId, int code)`
`Generic`
GenericDAO.`findByAlternateKey(String type, String subtype, Long qualifier, long tenantId)`
Finds a Generic by it's alternate key
`Generic`
HibernateGenericDAO.`findByAlternateKey(String type, String subtype, Long qualifier, long tenantId)`
`List<Generic>`
GenericDAO.`findByTypeAndSubtype(String type, String subtype, Long qualifier, Long tenantId)`
Finds a Generic by it's alternate key.
`List<Generic>`
HibernateGenericDAO.`findByTypeAndSubtype(String type, String subtype, Long qualifier, Long tenantId)`
`void`
HibernateGenericDAO.`store(Generic entity)`

## Uses of PersistenceException in com.logicaldoc.core.history

Methods in com.logicaldoc.core.history that throw PersistenceException
Modifier and Type
Method
Description
`void`
HibernateHistoryDAO.`store(T history)`

## Uses of PersistenceException in com.logicaldoc.core.lock

Methods in com.logicaldoc.core.lock that throw PersistenceException
Modifier and Type
Method
Description
`void`
LockManager.`release(String lockName, String transactionId)`
Releases a previously acquired lock.

## Uses of PersistenceException in com.logicaldoc.core.metadata

Methods in com.logicaldoc.core.metadata that throw PersistenceException
Modifier and Type
Method
Description
`Template`
HibernateTemplateDAO.`clone(long id, String cloneName)`
`Template`
TemplateDAO.`clone(long id, String cloneName)`
Creates a clone of an existing template
`long`
HibernateTemplateDAO.`countDocs(long id)`
`long`
TemplateDAO.`countDocs(long id)`
Counts the total number of documents using this template
`long`
TemplateDAO.`countFolders(long id)`
Counts the total number of folders using this template
`void`
HibernateAttributeOptionDAO.`delete(long id, int code)`
`void`
HibernateAttributeSetDAO.`delete(long id, int code)`
`void`
HibernateTemplateDAO.`delete(long id, int code)`
`void`
AttributeOptionDAO.`deleteBySetIdAndAttribute(long setId, String attribute)`
This method deletes options.
`void`
HibernateAttributeOptionDAO.`deleteBySetIdAndAttribute(long setId, String attribute)`
`void`
AttributeOptionDAO.`deleteOrphaned(long setId, Collection<String> currentAttributes)`
This method deletes the orphaned options of a given template
`void`
HibernateAttributeOptionDAO.`deleteOrphaned(long setId, Collection<String> currentAttributes)`
`List<AttributeSet>`
HibernateAttributeSetDAO.`findAll()`
`List<AttributeSet>`
HibernateAttributeSetDAO.`findAll(long tenantId)`
`Map<String,Attribute>`
AttributeSetDAO.`findAttributes(long tenantId, Long setId)`
Gets the map of attributes defined in the given tenant or set
`Map<String,Attribute>`
HibernateAttributeSetDAO.`findAttributes(long tenantId, Long setId)`
`List<AttributeOption>`
AttributeOptionDAO.`findByAttribute(long setId, String attribute)`
This finds all the options for a given attribute.
`List<AttributeOption>`
HibernateAttributeOptionDAO.`findByAttribute(long setId, String attribute)`
`List<AttributeOption>`
AttributeOptionDAO.`findByAttributeAndCategory(long setId, String attribute, String category)`
This finds all the options for a given attribute.
`List<AttributeOption>`
HibernateAttributeOptionDAO.`findByAttributeAndCategory(long setId, String attribute, String category)`
`Map<String,List<AttributeOption>>`
AttributeOptionDAO.`findByAttributeAsMap(long setId, String attribute)`
This finds all the options for a given attribute and groups them by category.
`Map<String,List<AttributeOption>>`
HibernateAttributeOptionDAO.`findByAttributeAsMap(long setId, String attribute)`
`AttributeSet`
AttributeSetDAO.`findByName(String name, long tenantId)`
This method finds a attribute set by name
`AttributeSet`
HibernateAttributeSetDAO.`findByName(String name, long tenantId)`
`Template`
HibernateTemplateDAO.`findByName(String name, long tenantId)`
`Template`
TemplateDAO.`findByName(String name, long tenantId)`
This method finds a template by name
`List<AttributeSet>`
AttributeSetDAO.`findByType(int type, long tenantId)`
This method finds a attribute set by type
`List<AttributeSet>`
HibernateAttributeSetDAO.`findByType(int type, long tenantId)`
`List<Template>`
HibernateTemplateDAO.`findByType(int type, long tenantId)`
`List<Template>`
TemplateDAO.`findByType(int type, long tenantId)`
This method finds a template by type
`void`
HibernateAttributeSetDAO.`initialize(AttributeSet attributeSet)`
`Map<Long,AttributeSet>`
AttributeSetDAO.`load(long tenantId)`
Retrieves all the attribute sets in a tenant
`Map<Long,AttributeSet>`
HibernateAttributeSetDAO.`load(long tenantId)`
`void`
HibernateAttributeSetDAO.`store(AttributeSet set)`
`void`
HibernateTemplateDAO.`store(Template template)`

## Uses of PersistenceException in com.logicaldoc.core.metadata.validation

Subclasses of PersistenceException in com.logicaldoc.core.metadata.validation
Modifier and Type
Class
Description
`class`
`ValidationException`
Raised when the content being stored are not logically valid.

## Uses of PersistenceException in com.logicaldoc.core.searchengine.saved

Methods in com.logicaldoc.core.searchengine.saved that throw PersistenceException
Modifier and Type
Method
Description
`void`
HibernateSearchDAO.`delete(long id, int code)`
`List<SavedSearch>`
HibernateSearchDAO.`findByUserId(long userId)`
`List<SavedSearch>`
SearchDAO.`findByUserId(long userId)`
Gets all the searches of a given user ordered by name asc
`SavedSearch`
HibernateSearchDAO.`findByUserIdAndName(long userId, String name)`
`SavedSearch`
SearchDAO.`findByUserIdAndName(long userId, String name)`
Gets the search using the alternate key
`void`
SavedSearch.`saveOptions(SearchOptions opt)`
`void`
HibernateSearchDAO.`store(SavedSearch search)`

## Uses of PersistenceException in com.logicaldoc.core.security

Methods in com.logicaldoc.core.security that throw PersistenceException
Modifier and Type
Method
Description
`void`
HibernateDeviceDAO.`delete(long deviceId, int code)`
`Set<String>`
HibernateTenantDAO.`findAllNames()`
`Set<String>`
TenantDAO.`findAllNames()`
Retrieves all the tenant names
`Tenant`
TenantDAO.`findByName(String name)`
Finds a tenant by name
`String`
HibernateTenantDAO.`getTenantName(long tenantId)`
`String`
TenantDAO.`getTenantName(long tenantId)`
Retrieves the tenant's name
`boolean`
DeviceDAO.`isTrustedDevice(String username, jakarta.servlet.http.HttpServletRequest request)`
Checks if the current request's device is trusted by the user
`boolean`
HibernateDeviceDAO.`isTrustedDevice(String username, jakarta.servlet.http.HttpServletRequest request)`
`void`
HibernateDeviceDAO.`store(Device entity)`
`Device`
DeviceDAO.`trustDevice(User user, Device device)`
Trusts a device for a user
`Device`
HibernateDeviceDAO.`trustDevice(User user, Device requestDevice)`

## Uses of PersistenceException in com.logicaldoc.core.security.apikey

Methods in com.logicaldoc.core.security.apikey that throw PersistenceException
Modifier and Type
Method
Description
`void`
HibernateApiKeyDAO.`delete(long id, int code)`
`ApiKey`
ApiKeyDAO.`findByKey(String key)`
Finds the ApiKey by the unique key
`ApiKey`
HibernateApiKeyDAO.`findByKey(String key)`
`ApiKey`
ApiKeyDAO.`findByName(String name, long userId)`
Finds the user's ApiKey with a given name
`ApiKey`
HibernateApiKeyDAO.`findByName(String name, long userId)`
`List<ApiKey>`
ApiKeyDAO.`findByUser(long userId)`
Finds the user's ApiKeys for a given user
`List<ApiKey>`
HibernateApiKeyDAO.`findByUser(long userId)`
`void`
HibernateApiKeyDAO.`store(ApiKey apiKey)`

## Uses of PersistenceException in com.logicaldoc.core.security.authentication

Methods in com.logicaldoc.core.security.authentication that throw PersistenceException
Modifier and Type
Method
Description
`User`
Authenticator.`pickUser(String username)`
This method does not authenticate the user but just retrieves his details
`User`
DefaultAuthenticator.`pickUser(String username)`

## Uses of PersistenceException in com.logicaldoc.core.security.menu

Methods in com.logicaldoc.core.security.menu that throw PersistenceException
Modifier and Type
Method
Description
`Menu`
HibernateMenuDAO.`createPath(long parentId, long tenantId, int type, String path, boolean inheritSecurity)`
`Menu`
MenuDAO.`createPath(long parentId, long tenantId, int type, String path, boolean inheritSecurity)`
Creates the menu for the specified path.
`void`
HibernateMenuDAO.`delete(long menuId, int code)`
`void`
HibernateMenuDAO.`deleteAll(Collection<Menu> menus)`
`List<Menu>`
HibernateMenuDAO.`findByGroupId(long groupId)`
`List<Menu>`
MenuDAO.`findByGroupId(long groupId)`
Finds all menus accessible by the passed group
`void`
HibernateMenuDAO.`restore(long menuId, boolean parents)`
`void`
MenuDAO.`restore(long id, boolean parents)`
Restores a previously deleted menu
`void`
HibernateMenuDAO.`store(Menu menu)`

## Uses of PersistenceException in com.logicaldoc.core.security.user

Methods in com.logicaldoc.core.security.user that throw PersistenceException
Modifier and Type
Method
Description
`void`
UserListener.`afterStore(User user, UserHistory transaction, Map<String,Object> dictionary)`
Called after a user is stored in the database
`void`
UserListener.`beforeStore(User user, UserHistory transaction, Map<String,Object> dictionary)`
Called before a user is stored in the database
`void`
HibernateUserDAO.`checkPasswordCompliance(User user)`
`void`
UserDAO.`checkPasswordCompliance(User user)`
Checks if the user's password complies the current quality criteria
`long`
HibernateUserDAO.`countGuests(Long tenantId)`
`long`
UserDAO.`countGuests(Long tenantId)`
Counts the total number of guest users
`long`
HibernateUserDAO.`countRegulars(Long tenantId)`
`long`
UserDAO.`countRegulars(Long tenantId)`
Counts the total number of regular users
`void`
HibernateGroupDAO.`delete(long groupId, int code)`
`void`
HibernateUserDAO.`delete(long userId, int code)`
`void`
HibernateUserDAO.`delete(long userId, UserHistory transaction)`
`void`
UserDAO.`delete(long userId, UserHistory transaction)`
This method deletes the user object and insert a new user history entry.
`boolean`
HibernateGroupDAO.`exists(String groupname, long tenantId)`
`User`
HibernateUserDAO.`findAdminUser(String tenantName)`
`User`
UserDAO.`findAdminUser(String tenantName)`
Retrieve the administrator for the given tenant.
`Collection<String>`
GroupDAO.`findAllGroupNames(long tenantId)`
This method selects all group names
`Collection<String>`
HibernateGroupDAO.`findAllGroupNames(long tenantId)`
`Set<User>`
HibernateUserDAO.`findByGroup(long groupId)`
`Set<User>`
UserDAO.`findByGroup(long groupId)`
Retrieves the users belonging to a given group.
`User`
HibernateUserDAO.`findById(long id)`
`Collection<Group>`
GroupDAO.`findByLikeName(String name, long tenantId)`
This method finds a Group by name.
`Collection<Group>`
HibernateGroupDAO.`findByLikeName(String name, long tenantId)`
`List<User>`
HibernateUserDAO.`findByLikeUsername(String username)`
`List<User>`
UserDAO.`findByLikeUsername(String username)`
This method finds an User by username.
`Group`
GroupDAO.`findByName(String name, long tenantId)`
Finds a group by name.
`Group`
HibernateGroupDAO.`findByName(String name, long tenantId)`
`List<User>`
HibernateUserDAO.`findByName(String name)`
`List<User>`
UserDAO.`findByName(String name)`
This method finds an User by name.
`List<PasswordHistory>`
HibernatePasswordHistoryDAO.`findByUserId(long userId, Integer max)`
`List<PasswordHistory>`
PasswordHistoryDAO.`findByUserId(long userId, Integer max)`
Gets all the histories related to a given user ordered by date desc
`PasswordHistory`
HibernatePasswordHistoryDAO.`findByUserIdAndPassword(long userId, String password, int max)`
`PasswordHistory`
PasswordHistoryDAO.`findByUserIdAndPassword(long userId, String password, int max)`
Gets the password used by the user in last max times
`User`
HibernateUserDAO.`findByUsername(String username)`
`User`
UserDAO.`findByUsername(String username)`
This method finds an User by its username.
`List<User>`
HibernateUserDAO.`findByUsernameAndName(String username, String name)`
`List<User>`
UserDAO.`findByUsernameAndName(String username, String name)`
This method finds an User by username and name.
`User`
HibernateUserDAO.`findByUsernameIgnoreCase(String username)`
`User`
UserDAO.`findByUsernameIgnoreCase(String username)`
This method finds an User by its username.
`Map<String,Generic>`
HibernateUserDAO.`findUserSettings(long userId, String namePrefix)`
`Map<String,Generic>`
UserDAO.`findUserSettings(long userId, String namePrefix)`
Retrieves the settings for a user.
`void`
GroupDAO.`fixGuestPermissions(Group group)`
`void`
HibernateGroupDAO.`fixGuestPermissions(Group group)`
If the user is guest, we remove not admitted permissions
`User`
HibernateUserDAO.`getUser(String username)`
`User`
UserDAO.`getUser(String username)`
Depending on the global setting, it invokes findByUsername or findByUsernameIgnoreCase
`Group`
User.`getUserGroup()`
Retrieves this user's group
`void`
GroupDAO.`inheritACLs(Group group, long parentGroupId)`
This method replicates all ACLs of the parent group to another group.
`void`
HibernateGroupDAO.`inheritACLs(Group group, long parentGroupId)`
`void`
HibernateUserDAO.`initialize(User user)`
`void`
GroupDAO.`insert(Group group, long parentGroupId)`
This method persists a new group object.
`void`
HibernateGroupDAO.`insert(Group group, long parentGroupId)`
`boolean`
HibernateUserDAO.`isInactive(String username)`
`boolean`
UserDAO.`isInactive(String username)`
Checks if a user is inactive, that is a user without interactions in the last X days after it has last enabled.
`void`
HibernateGroupDAO.`store(Group group)`
`void`
HibernateUserDAO.`store(User user)`
`void`
HibernateUserDAO.`store(User user, UserHistory transaction)`
`void`
UserDAO.`store(User user)`
`void`
UserDAO.`store(User user, UserHistory transaction)`
This method persists the user object and insert a new user history entry.

## Uses of PersistenceException in com.logicaldoc.core.sequence

Methods in com.logicaldoc.core.sequence that throw PersistenceException
Modifier and Type
Method
Description
`void`
HibernateSequenceDAO.`delete(long id, int code)`
`void`
HibernateSequenceDAO.`delete(String name, long objectId, long tenantId)`
`void`
SequenceDAO.`delete(String name, long objectId, long tenantId)`
Deletes the sequence
`Sequence`
HibernateSequenceDAO.`findByAlternateKey(String name, long objectId, long tenantId)`
`Sequence`
SequenceDAO.`findByAlternateKey(String name, long objectId, long tenantId)`
Finds the sequence by the given alternate key
`List<Sequence>`
SequenceDAO.`findByName(String name, long tenantId)`
Finds all sequences whose name starts with the passed name
`long`
HibernateSequenceDAO.`getCurrentValue(String sequence, long objectId, long tenantId)`
`long`
SequenceDAO.`getCurrentValue(String name, long objectId, long tenantId)`
Gets the current value
`long`
HibernateSequenceDAO.`next(String sequence, long objectId, long tenantId)`
`long`
HibernateSequenceDAO.`next(String sequence, long objectId, long tenantId, long increment)`
`long`
SequenceDAO.`next(String name, long objectId, long tenantId)`
Returns the next value of the sequence
`long`
SequenceDAO.`next(String name, long objectId, long tenantId, long increment)`
Returns the next value of the sequence by incrementing by the given increment
`void`
HibernateSequenceDAO.`reset(String sequence, long objectId, long tenantId, long value)`
`void`
SequenceDAO.`reset(String name, long objectId, long tenantId, long value)`
Initializes the sequence value

## Uses of PersistenceException in com.logicaldoc.core.store

Methods in com.logicaldoc.core.store that throw PersistenceException
Modifier and Type
Method
Description
`StoreResource.Builder`
StoreResource.Builder.`document(AbstractDocument document)`
Takes the docId and fileVersion from the given `DocumentFormatException` or `Version`

## Uses of PersistenceException in com.logicaldoc.core.ticket

Methods in com.logicaldoc.core.ticket that throw PersistenceException
Modifier and Type
Method
Description
`void`
TicketListener.`afterStore(Ticket ticket, DocumentHistory transaction, Map<String,Object> dictionary)`
Called after a ticket is stored in the database
`void`
TicketListener.`beforeStore(Ticket ticket, DocumentHistory transaction, Map<String,Object> dictionary)`
Called before a ticket is stored in the database
`long`
HibernateTicketDAO.`countViewOrDownloadTickets(Long tenantId)`
`long`
TicketDAO.`countViewOrDownloadTickets(Long tenantId)`
Counts the DOWNLOAD or VIEW tickets
`Ticket`
HibernateTicketDAO.`findByTicketId(String ticketId)`
`Ticket`
TicketDAO.`findByTicketId(String ticketId)`
This finds a ticket by its identifier and runs the validation
`void`
HibernateTicketDAO.`store(Ticket entity)`
`void`
HibernateTicketDAO.`store(Ticket ticket, DocumentHistory transaction)`
`void`
TicketDAO.`store(Ticket ticket, DocumentHistory transaction)`
This method persists the download ticket object and insert a new document history entry
`void`
TicketListener.`validate(Ticket ticket, Map<String,Object> dictionary)`
Called to perform required validations on a ticket

## Uses of PersistenceException in com.logicaldoc.core.transfer

Methods in com.logicaldoc.core.transfer that throw PersistenceException
Modifier and Type
Method
Description
`ByteArrayOutputStream`
ZipExport.`process(FolderHistory transaction, boolean pdfConversion)`
Exports the specified folder content
`ByteArrayOutputStream`
ZipExport.`process(Long[] docIds, boolean pdfConversion, DocumentHistory transaction)`
Exports a selection of documents
`void`
ZipExport.`process(Long[] docIds, OutputStream out, boolean pdfConversion, DocumentHistory transaction)`
Exports a selection of documents
`void`
ZipImport.`process(File zipsource, Folder parent, long userId, String sessionId)`
`void`
ZipImport.`process(String zipsource, Folder parent, long userId, String sessionId)`

## Uses of PersistenceException in com.logicaldoc.core.util

Methods in com.logicaldoc.core.util that throw PersistenceException
Modifier and Type
Method
Description
`static String`
UserUtil.`getAvatarImage(String userIdOrName)`