Package com.logicaldoc.core.document.dao

Interface DocumentDAO

    • Method Detail

      • findDocument

        Document findDocument​(long docId)
        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.

      • findByCustomId

        Document findByCustomId​(String customId,
                        long tenantId)
        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.

      • findByUserId

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

      • findDocIdByFolder

        List<Long> findDocIdByFolder​(long folderId,
                             Integer max)
        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.

      • findByFolder

        List<Document> findByFolder​(long folderId,
                            Integer max)
        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.

      • findByLockUserAndStatus

        List<Document> findByLockUserAndStatus​(Long userId,
                                       Integer status)
        Finds all document of 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)
        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.

      • findLastDownloadsByUserId

        List<Document> findLastDownloadsByUserId​(long userId,
                                         int max)
        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

      • 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

      • findDocIdByTag

        List<Long> findDocIdByTag​(String tag)
        This method finds all Doc Ids by a tag.
        Parameters:
        tag - Tag of the document.
        Returns:
        Document with specified tag.

      • findTags

        Map<String,​Long> findTags​(String firstLetter,
                                Long tenantId)
        Selects all tags and counts the occurrences.
        Parameters:
        firstLetter - the first letter
        tenantId - identifier of the tenant
        Returns:
        the map tag - count

      • findAllTags

        List<String> findAllTags​(String firstLetter,
                         Long tenantId)
        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

      • findByUserIdAndTag

        List<Document> findByUserIdAndTag​(long userId,
                                  String tag,
                                  Integer max)
        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

      • findDocIdByUserIdAndTag

        List<Long> findDocIdByUserIdAndTag​(long userId,
                                   String tag)
        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.

      • findLinkedDocuments

        List<Document> findLinkedDocuments​(long docId,
                                   String linkType,
                                   Integer direction)
        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

      • findByFileNameAndParentFolderId

        List<Document> 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)
        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.

      • findByPath

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

      • computeTotalSize

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

      • findDeletedDocIds

        List<Long> findDeletedDocIds()
        Gets the collection of deleted document ids
        Returns:
        collection of document identifiers

      • findDeletedDocs

        List<Document> findDeletedDocs()
        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

      • count

        long count​(Long tenantId,
           boolean computeDeleted,
           boolean computeArchived)
        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

      • findByIndexed

        List<Document> findByIndexed​(int indexed)
        Finds all documents by the indexed state. Order by ascending lastModifed
        Parameters:
        indexed - the indexed property
        Returns:
        Collection of all documents

      • countByIndexed

        long countByIndexed​(int indexed)
        Counts the number of documents in a given indexation status(@see AbstractDocument.getIndexed()
        Parameters:
        indexed - the indexation status to check
        Returns:
        number of documents

      • 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 - raised in case of database errors

      • 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 - raised in case of database errors

      • 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 - raised in case of database errors

      • 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 - raised in case of database errors

      • store

        boolean store​(Document doc,
              DocumentHistory transaction)
       throws PersistenceException
        This method persists the document object and insert a new document history entry
        Parameters:
        doc - the document
        transaction - entry to log the event
        Returns:
        True if successfully stored in a database
        Throws:
        PersistenceException - raised in case of database errors

      • delete

        boolean 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
        Returns:
        True if successfully deleted from the database.
        Throws:
        PersistenceException - raised in case of database errors

      • delete

        boolean delete​(long docId,
               DocumentHistory transaction)
        throws PersistenceException
        Shortcut for delete(docId, 1, transaction)
        Parameters:
        docId - identifier of the document
        transaction - entry to log the event
        Returns:
        True if successfully deleted from the database.
        Throws:
        PersistenceException - raised in case of database errors

      • archive

        boolean archive​(long docId,
                DocumentHistory transaction)
         throws PersistenceException
        Archives a document
        Parameters:
        docId - identifier of the document
        transaction - entry to log the event
        Returns:
        true if document has been archived
        Throws:
        PersistenceException - raised in case of database errors

      • findArchivedByFolder

        List<Document> findArchivedByFolder​(long folderId)
        Finds archived documents in a folder (direct childeren only)
        Parameters:
        folderId - identifier of the folder
        Returns:
        list of documents

      • findAliasIds

        List<Long> findAliasIds​(long docId)
        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

      • findDeleted

        List<Document> findDeleted​(long userId,
                           Integer max)
        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

      • deleteOrphaned

        boolean deleteOrphaned​(long deleteUserId)
                throws PersistenceException
        This method deletes the documents into deleted folders.
        Parameters:
        deleteUserId - The id of the user that performs the deleting.
        Returns:
        True if successfully deleted from the database.
        Throws:
        PersistenceException - raised in case of database errors

      • findPublishedIds

        Collection<Long> findPublishedIds​(Collection<Long> folderIds)
        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

      • 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 - raised in case of database errors

      • saveDocumentHistory

        void saveDocumentHistory​(Document doc,
                         DocumentHistory transaction)
        Saves a document's history
        Parameters:
        doc - the document
        transaction - the current session

      • cleanUnexistingUniqueTags

        void cleanUnexistingUniqueTags()
        Cleans the ld_uniquetag table removing no more used tags

      • insertNewUniqueTags

        void insertNewUniqueTags()
        Puts into ld_uniquetag the new unique tags

      • updateCountUniqueTags

        void updateCountUniqueTags()
        Updates the count of the unique tags

      • getTagCloud

        List<TagCloud> getTagCloud​(long tenantId,
                           int max)
        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

      • getTagCloud

        List<TagCloud> getTagCloud​(String sid)
        Gets the tag cloud for the given tenant
        Parameters:
        sid - identifier of the session
        Returns:
        list of tag clouds

      • getWorkspace

        Folder getWorkspace​(long docId)
        Retrieves, the workspace where the document(or alias) is stored
        Parameters:
        docId - identifier of a document
        Returns:
        the parent workspace

      • 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 - raised in case of database errors

      • 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 - raised in case of database errors

      • findDuplicatedDigests

        List<String> findDuplicatedDigests​(Long tenantId,
                                   Long folderId)
        Retrieves the list of duplicated checksums
        Parameters:
        tenantId - identifier of the tenant
        folderId - identifier of the folder
        Returns:
        list of duplicated digests

      • findTags

        List<String> findTags​(long docId)
        Retrieves the alphabetically ordered list of all the document's tags
        Parameters:
        docId - identifier of the document
        Returns:
        list of the document's tags