Package org.hippoecm.repository.api

Interface HippoSession

  • All Superinterfaces:
    Session
    public interface HippoSession
extends Session
    An extension of a plain Session based session. Any JCR Session obtained from the Hippo Repository also implements HippoSession allowing access to the extensions to the JCR API.

    • Method Detail

      • copy

        Node copy​(Node srcNode,
          String destAbsNodePath)
   throws RepositoryException
        Deprecated.
        Use JcrUtils.copy(javax.jcr.Session, String, String) instead
        Convenience function to copy a node to a destination path in the same workspace. Unlike the copy method in the javax.jcr.Workspace class, this copy method does not immediately persist (i.e. requires a save operation on the session, or ancestor node of the destination path) and it does return the produced copy. The latter makes this the preferred method to copy a node as the method on the Workspace makes it impossible to know for sure which node is produced in case of same-name siblings. It also provides a save method for copying node types that are extensions of the Hippo repository.
        Parameters:
        srcNode - the node to copy
        destAbsNodePath - the absolute path of the to be created target node which will be a copy of srcNode
        Returns:
        the resulting copy
        Throws:
        RepositoryException - a generic error while accessing the repository

      • pendingChanges

        NodeIterator pendingChanges​(Node node,
                            String nodeType,
                            boolean prune)
                     throws NamespaceException,
                            NoSuchNodeTypeException,
                            RepositoryException
        Obtains an iterator over the set of nodes that potentially contain changes, starting (and not including) the indicated node. Only nodes for which Node.isNodeType(nodeType) returns true are included in the resulting set. If the prune boolean value is true, then the nodes matching in the hierarchy first are returned. If matching modified node exists beneath the nodes, these are not included.
        Parameters:
        node - The starting node for which to look for changes, will not be included in result, may be null to indicate to search whole tree
        nodeType - Only nodes that are (derived) of this nodeType are included in the result, may be null to indicate no filtering on nodeType
        prune - Wheter only to return the first matching modified node in a subtree (true), or provide a depth search for all modified nodes (false)
        Returns:
        A NodeIterator instance which iterates over all modified nodes, not including the passed node
        Throws:
        NamespaceException - an invalid nodeType was passed
        RepositoryException - a generic error while accessing the repository
        NoSuchNodeTypeException - an invalid nodeType was passed

      • getXAResource

        XAResource getXAResource()
        Retrieves an XAResource object that the transaction manager will use to manage this XASession object's participation in a distributed transaction.
        Returns:
        the XAResource object.

      • getSessionClassLoader

        ClassLoader getSessionClassLoader()
                           throws RepositoryException
        This call is not (yet) part of the API, but under evaluation. Probably it will change into getSessionClassLoader(Node) or similar. Get a classloader which uses the JCR repository to load the classes from.
        Returns:
        a classloader instance that will load class definitions stored in the JCR repository
        Throws:
        RepositoryException - a generic error while accessing the repository

      • isSystemSession

        boolean isSystemSession()
        If this is a JCR System Session, having all privileges everywhere.

        For a JCR System Session isUserInRole(String) and Session.hasPermission(String, String) will always return true!

        This should NOT be confused with User.isSystemUser() which indicates a required and non-human type of user necessary for the running system itself.

        A JCR System Session also does NOT have a User representation and calling getUser() for a JCR Session Session will result in a ItemNotFoundException!

        Returns:
        true if this a JCR System Session, having all privileges everywhere.

      • isUserInRole

        boolean isUserInRole​(String userRoleName)
        Check if a user has the specified userRole assigned, or is implied by one of the userRoles assigned.

        For a isSystemSession() this always returns true.

        Parameters:
        userRoleName - the user role name to check
        Returns:
        true if the user has the specified directly or indirectly assigned

      • createSecurityDelegate

        Session createSecurityDelegate​(Session session,
                               DomainRuleExtension... domainExtensions)
                        throws RepositoryException
        Create a new Session that contains the union of access control rules of this Session and the provided session, with the optional addition of custom domain rules. Those rules will be added to existing domain rules, imposing additional restrictions on the session.
        Throws:
        RepositoryException

      • localRefresh

        void localRefresh()
        This method discards all pending changes currently recorded in this Session, including the built-up virtual node states. The difference with Session.refresh(boolean) is that after this method returns, the state of the items is not guaranteed to reflect the current persistent storage because in a clustered environment, the cluster node is not synced as a result of this call.

      • disableVirtualLayers

        void disableVirtualLayers()
        Disable virtual layers.

      • getWorkspace

        HippoWorkspace getWorkspace()
        Convenient return type override for getting the HippoWorkspace without needing to typecast
        Specified by:
        getWorkspace in interface Session
        Returns:
        HippoWorkspace