Package com.logicaldoc.core.document.dao

Interface DocumentDAO

    • Method Detail

      • findDocument

        Document findDocument​(long docId)
               throws PersistenceException
        This method finds a document by the ID and if it is an alias the referenced document is returned instead.
        Parameters:
        docId - ID of the document(or the alias)
        Returns:
        Document with given ID
        Throws:
        PersistenceException - an error happened in the database

      • findByCustomId

        Document findByCustomId​(String customId,
                        long tenantId)
                 throws PersistenceException
        This method finds a document by the custom ID.
        Parameters:
        customId - custom ID of the document.
        tenantId - ID of the contained tenant.
        Returns:
        Document with given ID.
        Throws:
        PersistenceException - error at data layer

      • findByUserId

        List<Long> findByUserId​(long userId)
                 throws PersistenceException
        Finds all documents for an user.
        Parameters:
        userId - ID of the user.
        Returns:
        Collection of all documentId required for the specified user.
        Throws:
        PersistenceException - error at data layer

      • findDocIdByFolder

        List<Long> findDocIdByFolder​(long folderId,
                             Integer max)
                      throws PersistenceException
        Finds all document ids inside the given folder.
        Parameters:
        folderId - Folder identifier
        max - Optional, maximum number of returned elements
        Returns:
        Collection of all document id in the folder.
        Throws:
        PersistenceException - error at data layer

      • findByFolder

        List<Document> findByFolder​(long folderId,
                            Integer max)
                     throws PersistenceException
        Finds all documents direct children of the given folder.
        Parameters:
        folderId - Folder identifier
        max - Optional, defines the maximum records number
        Returns:
        Collection of all documents in the folder
        Throws:
        PersistenceException - error at data layer

      • findByLockUserAndStatus

        List<Document> findByLockUserAndStatus​(Long userId,
                                       Integer status)
        Finds all document of0 the specified status and locked by the specified user
        Parameters:
        userId - The user id(optional)
        status - The status code(optional)
        Returns:
        Collection of all Documents locked by the specified user and of the specified status.

      • findLastModifiedByUserId

        List<Document> findLastModifiedByUserId​(long userId,
                                        int max)
                                 throws PersistenceException
        Finds a max number of documents last modified by an user.
        Parameters:
        userId - ID of the user.
        max - maximum number of returned elements
        Returns:
        Collection of the last documents changed by the specified user.
        Throws:
        PersistenceException - error at data layer

      • findLastDownloadsByUserId

        List<Document> findLastDownloadsByUserId​(long userId,
                                         int max)
                                  throws PersistenceException
        Finds the last downloaded documents by the given user
        Parameters:
        userId - id of the user
        max - maximum number of returned elements
        Returns:
        list of documents
        Throws:
        PersistenceException - error at data layer

      • findByIds

        List<Document> findByIds​(Long[] ids,
                         Integer max)
        Finds all documents whose id is included in the given pool of ids
        Parameters:
        ids - identifiers of the documents
        max - Optional, maximum number of returned elements
        Returns:
        list of documents

      • findAllTags

        List<String> findAllTags​(String firstLetter,
                         Long tenantId)
                  throws PersistenceException
        Searches for all tags,
        Parameters:
        firstLetter - Optional first letter hint
        tenantId - ID of the tenant to search in
        Returns:
        The list of all tags in the system
        Throws:
        PersistenceException - error at data layer

      • findByUserIdAndTag

        List<Document> findByUserIdAndTag​(long userId,
                                  String tag,
                                  Integer max)
                           throws PersistenceException
        Finds authorized documents for a user having a specified tag.
        Parameters:
        userId - ID of the user
        tag - Tag of the document
        max - Optional, defines the maximum records number
        Returns:
        Collection of found documents
        Throws:
        PersistenceException - error at data layer

      • findDocIdByUserIdAndTag

        List<Long> findDocIdByUserIdAndTag​(long userId,
                                   String tag)
                            throws PersistenceException
        Finds authorized documents ids for a user having a specified tag.
        Parameters:
        userId - ID of the user.
        tag - Tag of the document
        Returns:
        Set of found ids.
        Throws:
        PersistenceException - error at data layer

      • findLinkedDocuments

        List<Document> findLinkedDocuments​(long docId,
                                   String linkType,
                                   Integer direction)
                            throws PersistenceException
        This method enlists documents linked to the given document.

        Important: The attribute direction defines the search logic as follows:

        • 1: docId will be compared to link's document1
        • 2: docId will be compared to link's document2
        • null: docId will be compared to both document1 and document2
        Parameters:
        docId - All documents linked to this one will be searched
        linkType - Type of the link (optional)
        direction - if 1 docId will be compared to link's document1, id 2 docId will be compared to link's document2, if null docId will be compared to both document1 and document2 of the link.
        Returns:
        The collection of linked documents
        Throws:
        PersistenceException - error at data layer

      • findByFileNameAndParentFolderId

        List<Document> findByFileNameAndParentFolderId​(Long folderId,
                                               String fileName,
                                               Long excludeId,
                                               Long tenantId,
                                               Integer max)
                                        throws PersistenceException
        Finds that document that lies under a specific folder (given by the id) an with a given fileName(like operator is used)
        Parameters:
        folderId - The folder id (it can be null).
        fileName - name of the file or a part of it (you can use SQL % jolly chars, eg: contract.pdf, %ontrac%)
        excludeId - Optional id of a document that must not be considered
        tenantId - Optional id of the tenant
        max - Optional maximum number of returned elements
        Returns:
        The list of documents with the given fileName. If the folder id is null, the searched document can belong to any folder in the repository
        Throws:
        PersistenceException - error at data layer

      • findByPath

        Document findByPath​(String path,
                    long tenantId)
             throws PersistenceException
        Finds a document by it's full path
        Parameters:
        path - The path comprehensive of the file name
        tenantId - The tenant
        Returns:
        the found document
        Throws:
        PersistenceException - error at data layer

      • computeTotalSize

        long computeTotalSize​(Long tenantId,
                      Long publisherId,
                      boolean computeDeleted)
               throws PersistenceException
        Obtains the total size of the repository, that is the sum of sizes of all documents and their versions
        Parameters:
        tenantId - identifier of the tenant(optional)
        publisherId - identifier of the publisher user (optional)
        computeDeleted - If true, even deleted documents are considered
        Returns:
        the total size expressed in bytes
        Throws:
        PersistenceException - error at data layer

      • findDeletedDocs

        List<Document> findDeletedDocs()
                        throws PersistenceException
        Finds the list of deleted documents.

        Attention: The returned objects are not fully operative and are populated with a minimal set of data.

        Returns:
        the list of documents
        Throws:
        PersistenceException - error at data layer

      • count

        long count​(Long tenantId,
           boolean computeDeleted,
           boolean computeArchived)
    throws PersistenceException
        Counts the number of documents
        Parameters:
        tenantId - The tenant to search in
        computeDeleted - If true, even deleted documents are considered
        computeArchived - If true, even archived documents are considered
        Returns:
        number of documents
        Throws:
        PersistenceException - error at data layer

      • findByIndexed

        List<Document> findByIndexed​(int indexed)
                      throws PersistenceException
        Finds all documents by the indexed state. Order by ascending lastModifed
        Parameters:
        indexed - the indexed property
        Returns:
        Collection of all documents
        Throws:
        PersistenceException - error at data layer

      • restore

        void restore​(long docId,
             long folderId,
             DocumentHistory transaction)
      throws PersistenceException
        Restores a previously deleted document
        Parameters:
        docId - Id of the document to be restored
        folderId - Id of the folder the document will be restored into
        transaction - entry to log the event
        Throws:
        PersistenceException - error at data layer

      • unarchive

        void unarchive​(long docId,
               DocumentHistory transaction)
        throws PersistenceException
        Restores a previously archived document
        Parameters:
        docId - Ids of the document to be restored
        transaction - entry to log the event
        Throws:
        PersistenceException - error at data layer

      • makeImmutable

        void makeImmutable​(long docId,
                   DocumentHistory transaction)
            throws PersistenceException
        Marks the document, with the given docId, as immutable. Unlocks the document if it was locked.
        Parameters:
        docId - identifier of the document
        transaction - entry to log the event
        Throws:
        PersistenceException - error at data layer

      • deleteAll

        void deleteAll​(Collection<Document> documents,
               int delCode,
               DocumentHistory transaction)
        throws PersistenceException
        Deletes all documents form the database and modifies the custom ids of all documents
        Parameters:
        documents - The documents to be deleted
        delCode - The deletion code
        transaction - entry to log the event
        Throws:
        PersistenceException - error at data layer

      • delete

        void delete​(long docId,
            int delCode,
            DocumentHistory transaction)
     throws PersistenceException
        This method deletes the document object and insert a new document history entry.
        Parameters:
        docId - The id of the document to delete
        delCode - The deletion code
        transaction - entry to log the event
        Throws:
        PersistenceException - error at data layer

      • findArchivedByFolder

        List<Document> findArchivedByFolder​(long folderId)
                             throws PersistenceException
        Finds archived documents in a folder (direct childeren only)
        Parameters:
        folderId - identifier of the folder
        Returns:
        list of documents
        Throws:
        PersistenceException - error at data layer

      • findAliasIds

        List<Long> findAliasIds​(long docId)
                 throws PersistenceException
        Gets the ids of all aliases associated to the document with the given docId
        Parameters:
        docId - identifier of the document
        Returns:
        list of identifiers of aliases
        Throws:
        PersistenceException - error at data layer

      • findDeleted

        List<Document> findDeleted​(long userId,
                           Integer max)
                    throws PersistenceException
        Finds all deleted docs of a specific user.
        Parameters:
        userId - The user that performed the deletion
        max - Optional, defines the max number of returned elements
        Returns:
        The documents list
        Throws:
        PersistenceException - error at data layer

      • deleteOrphaned

        void deleteOrphaned​(long deleteUserId)
             throws PersistenceException
        This method deletes the documents into deleted folders.
        Parameters:
        deleteUserId - The id of the user that performs the deleting
        Throws:
        PersistenceException - error at data layer

      • findPublishedIds

        Collection<Long> findPublishedIds​(Collection<Long> folderIds)
                           throws PersistenceException
        Finds all document ids inside the specified folders that are published in the current date.
        Parameters:
        folderIds - Set of folder ids in which the method will search
        Returns:
        List of published document ids
        Throws:
        PersistenceException - error at data layer

      • cleanExpiredTransactions

        void cleanExpiredTransactions()
                       throws PersistenceException
        Cleans all references to expired transactions. If no lock is found for a document referencing a given transaction, the transactionId will be set to null.
        Throws:
        PersistenceException - error at data layer

      • cleanUnexistingUniqueTagsOneByOne

        void cleanUnexistingUniqueTagsOneByOne()
                                throws PersistenceException
        Cleans the ld_uniquetag table removing no more used tags programmatically one by one. This method is not as optimized as cleanUnexistingUniqueTags() and should not be invoked directly
        Throws:
        PersistenceException - error at data layer

      • getTagCloud

        List<TagCloud> getTagCloud​(long tenantId,
                           int max)
                    throws PersistenceException
        Gets the tag cloud for the given tenant
        Parameters:
        tenantId - identifier of the tenant
        max - maximum number of returned elements
        Returns:
        list of tag clouds
        Throws:
        PersistenceException - error at data layer

      • getWorkspace

        Folder getWorkspace​(long docId)
             throws PersistenceException
        Retrieves, the workspace where the document(or alias) is stored
        Parameters:
        docId - identifier of a document
        Returns:
        the parent workspace
        Throws:
        PersistenceException - error at data layer

      • setPassword

        void setPassword​(long docId,
                 String password,
                 DocumentHistory transaction)
          throws PersistenceException
        Protects the document with a password. The same password is replicated to all the versions
        Parameters:
        docId - ID of the document
        password - The new password in clear
        transaction - history informations
        Throws:
        PersistenceException - error at data layer

      • unsetPassword

        void unsetPassword​(long docId,
                   DocumentHistory transaction)
            throws PersistenceException
        Removes the password protection from the document. The same action is replicated to all the versions
        Parameters:
        docId - ID of the document
        transaction - session informations
        Throws:
        PersistenceException - error at data layer

      • findDuplicatedDigests

        List<String> findDuplicatedDigests​(Long tenantId,
                                   Long folderId)
                            throws PersistenceException
        Retrieves the list of duplicated checksums
        Parameters:
        tenantId - identifier of the tenant
        folderId - identifier of the folder
        Returns:
        list of duplicated digests
        Throws:
        PersistenceException - error at data layer

      • findTags

        List<String> findTags​(long docId)
               throws PersistenceException
        Retrieves the alphabetically ordered list of all the document's tags
        Parameters:
        docId - identifier of the document
        Returns:
        list of the document's tags
        Throws:
        PersistenceException - error at data layer