SessionWrapper.java

/**
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.brixcms.jcr.base.wrapper;

import org.brixcms.jcr.base.BrixSession;
import org.brixcms.jcr.base.action.AbstractActionHandler;
import org.brixcms.jcr.base.action.CompoundActionHandler;
import org.brixcms.jcr.base.event.ChangeLog;
import org.brixcms.jcr.base.event.ChangeLogActionHandler;
import org.brixcms.jcr.base.event.EventsListener;
import org.brixcms.jcr.base.filter.ValueFilter;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;

import javax.jcr.AccessDeniedException;
import javax.jcr.Credentials;
import javax.jcr.Item;
import javax.jcr.ItemNotFoundException;
import javax.jcr.Node;
import javax.jcr.PathNotFoundException;
import javax.jcr.Property;
import javax.jcr.Repository;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.UnsupportedRepositoryOperationException;
import javax.jcr.ValueFactory;
import javax.jcr.Workspace;
import javax.jcr.lock.LockException;
import javax.jcr.nodetype.ConstraintViolationException;
import javax.jcr.retention.RetentionManager;
import javax.jcr.security.AccessControlManager;
import javax.jcr.version.VersionException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.security.AccessControlException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

class SessionWrapper extends BaseWrapper<Session> implements BrixSession {
    final Set<Node> raisedSaveEvent = new HashSet<Node>();

    private final CompoundActionHandler actionHandler = new CompoundActionHandler();

    private final ChangeLogActionHandler changeLogActionHandler;

    private final Map<String, Object> attributesMap = new HashMap<String, Object>();

    private ValueFilter valueFilter = new ValueFilter();

    public static SessionWrapper wrap(Session session) {
        if (session == null) {
            return null;
        } else {
            return new SessionWrapper(session);
        }
    }

    private SessionWrapper(Session session) {
        super(session, null);

        changeLogActionHandler = new ChangeLogActionHandler(new ChangeLog(), this);
        actionHandler.addHandler(changeLogActionHandler);
    }

    public CompoundActionHandler getActionHandler() {
        return actionHandler;
    }

    public Map<String, Object> getAttributesMap() {
        return attributesMap;
    }

    public ValueFilter getValueFilter() {
        return valueFilter;
    }

    public void setValueFilter(ValueFilter valueFilter) {
        if (valueFilter == null) {
            throw new IllegalArgumentException("Argument 'valueFilter' may not be null.");
        }
        this.valueFilter = valueFilter;
    }



    public void addActionHandler(AbstractActionHandler handler) {
        actionHandler.addHandler(handler);
    }

    public void addEventsListener(EventsListener listener) {
        changeLogActionHandler.registerEventsListener(listener);
    }


    public Repository getRepository() {
        return getDelegate().getRepository();
    }

    public String getUserID() {
        return getDelegate().getUserID();
    }

    public String[] getAttributeNames() {
        return getDelegate().getAttributeNames();
    }

    public Object getAttribute(String name) {
        return getDelegate().getAttribute(name);
    }

    public Workspace getWorkspace() {
        return WorkspaceWrapper.wrap(getDelegate().getWorkspace(), this);
    }

    public Node getRootNode() throws RepositoryException {
        return NodeWrapper.wrap(getDelegate().getRootNode(), this);
    }

    public Session impersonate(Credentials credentials) throws RepositoryException {
        return SessionWrapper.wrap(getDelegate().impersonate(credentials));
    }

    /**
     * @deprecated
     */
    @Deprecated
    public Node getNodeByUUID(String uuid) throws RepositoryException {
        return NodeWrapper.wrap(getDelegate().getNodeByUUID(uuid), this);
    }

    public Node getNodeByIdentifier(String id) throws ItemNotFoundException, RepositoryException {
        return NodeWrapper.wrap(getDelegate().getNodeByIdentifier(id), this);
    }

    public Item getItem(String absPath) throws RepositoryException {
        return ItemWrapper.wrap(getDelegate().getItem(absPath), this);
    }

    public Node getNode(String absPath) throws PathNotFoundException, RepositoryException {
        return NodeWrapper.wrap(getDelegate().getNode(absPath), this);
    }

    public Property getProperty(String absPath) throws PathNotFoundException, RepositoryException {
        return PropertyWrapper.wrap(getDelegate().getProperty(absPath), this);
    }

    public boolean itemExists(String absPath) throws RepositoryException {
        return getDelegate().itemExists(absPath);
    }

    public boolean nodeExists(String absPath) throws RepositoryException {
        return getDelegate().nodeExists(absPath);
    }

    public boolean propertyExists(String absPath) throws RepositoryException {
        return getDelegate().propertyExists(absPath);
    }

    public void move(String srcAbsPath, String destAbsPath) throws RepositoryException {
        getActionHandler().beforeSessionNodeMove(srcAbsPath, destAbsPath);
        getDelegate().move(srcAbsPath, destAbsPath);
        getActionHandler().afterSessionNodeMove(srcAbsPath, destAbsPath);
    }

    public void removeItem(String absPath) throws VersionException, LockException,
            ConstraintViolationException, AccessDeniedException, RepositoryException {
        getDelegate().removeItem(absPath);
    }

    public void save() throws RepositoryException {
        getActionHandler().beforeSessionSave();
        getDelegate().save();
        getActionHandler().afterSessionSave();
    }

    public void refresh(boolean keepChanges) throws RepositoryException {
        getActionHandler().beforeSessionRefresh(keepChanges);
        getDelegate().refresh(keepChanges);
        getActionHandler().afterSessionRefresh(keepChanges);
    }

    public boolean hasPendingChanges() throws RepositoryException {
        return getDelegate().hasPendingChanges();
    }

    public ValueFactory getValueFactory() throws RepositoryException {
        return ValueFactoryWrapper.wrap(getDelegate().getValueFactory(), this);
    }

    public boolean hasPermission(String absPath, String actions) throws RepositoryException {
        return getDelegate().hasPermission(absPath, actions);
    }

    public void checkPermission(String absPath, String actions) throws AccessControlException,
            RepositoryException {
        getDelegate().checkPermission(absPath, actions);
    }

    public boolean hasCapability(String methodName, Object target, Object[] arguments)
            throws RepositoryException {
        return getDelegate().hasCapability(methodName, target, arguments);
    }

    public ContentHandler getImportContentHandler(String parentAbsPath, int uuidBehavior)
            throws RepositoryException {
        return getDelegate().getImportContentHandler(parentAbsPath, uuidBehavior);
    }

    public void importXML(String parentAbsPath, InputStream in, int uuidBehavior)
            throws IOException, RepositoryException {
        getActionHandler().beforeSessionImportXML(parentAbsPath);
        getDelegate().importXML(parentAbsPath, in, uuidBehavior);
        getActionHandler().afterSessionImportXML(parentAbsPath);
    }

    public void exportSystemView(String absPath, ContentHandler contentHandler, boolean skipBinary,
                                 boolean noRecurse) throws SAXException, RepositoryException {
        getDelegate().exportSystemView(absPath, contentHandler, skipBinary, noRecurse);
    }

    public void exportSystemView(String absPath, OutputStream out, boolean skipBinary,
                                 boolean noRecurse) throws IOException, RepositoryException {
        getDelegate().exportSystemView(absPath, out, skipBinary, noRecurse);
    }

    public void exportDocumentView(String absPath, ContentHandler contentHandler,
                                   boolean skipBinary, boolean noRecurse) throws SAXException, RepositoryException {
        getDelegate().exportDocumentView(absPath, contentHandler, skipBinary, noRecurse);
    }

    public void exportDocumentView(String absPath, OutputStream out, boolean skipBinary,
                                   boolean noRecurse) throws IOException, RepositoryException {
        getDelegate().exportDocumentView(absPath, out, skipBinary, noRecurse);
    }

    public void setNamespacePrefix(String prefix, String uri) throws RepositoryException {
        getDelegate().setNamespacePrefix(prefix, uri);
    }

    public String[] getNamespacePrefixes() throws RepositoryException {
        return getDelegate().getNamespacePrefixes();
    }

    public String getNamespaceURI(String prefix) throws RepositoryException {
        return getDelegate().getNamespaceURI(prefix);
    }

    public String getNamespacePrefix(String uri) throws RepositoryException {
        return getDelegate().getNamespacePrefix(uri);
    }

    public void logout() {
        getDelegate().logout();
    }

    public boolean isLive() {
        return getDelegate().isLive();
    }

    /**
     * @deprecated
     */
    @Deprecated
    public void addLockToken(String lt) {
        getDelegate().addLockToken(lt);
    }

    /**
     * @deprecated
     */
    @Deprecated
    public String[] getLockTokens() {
        return getDelegate().getLockTokens();
    }

    /**
     * @deprecated
     */
    @Deprecated
    public void removeLockToken(String lt) {
        getDelegate().removeLockToken(lt);
    }

    public AccessControlManager getAccessControlManager()
            throws UnsupportedRepositoryOperationException, RepositoryException {
        return getDelegate().getAccessControlManager();
    }

    public RetentionManager getRetentionManager() throws UnsupportedRepositoryOperationException,
            RepositoryException {
        return getDelegate().getRetentionManager();
    }

    @Override
    public SessionWrapper getSessionWrapper() {
        return this;
    }
}