alfresco-community-repo/source/java/org/alfresco/cmis/changelog/CMISChangeLogServiceImpl.java

/*
 * Copyright (C) 2005-2010 Alfresco Software Limited.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 * As a special exception to the terms and conditions of version 2.0 of 
 * the GPL, you may redistribute this Program in connection with Free/Libre 
 * and Open Source Software ("FLOSS") applications as described in Alfresco's 
 * FLOSS exception.  You should have received a copy of the text describing 
 * the FLOSS exception, and it is also available here: 
 * http://www.alfresco.com/legal/licensing"
 */
package org.alfresco.cmis.changelog;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.alfresco.cmis.CMISBaseObjectTypeIds;
import org.alfresco.cmis.CMISCapabilityChanges;
import org.alfresco.cmis.CMISChangeEvent;
import org.alfresco.cmis.CMISChangeLog;
import org.alfresco.cmis.CMISChangeLogService;
import org.alfresco.cmis.CMISChangeType;
import org.alfresco.error.AlfrescoRuntimeException;
import org.alfresco.service.cmr.audit.AuditQueryParameters;
import org.alfresco.service.cmr.audit.AuditService;
import org.alfresco.service.cmr.audit.AuditService.AuditQueryCallback;
import org.alfresco.service.cmr.repository.NodeRef;

/**
 * ChangeLog Service Implementation
 * 
 * @author Dmitry Velichkevich
 */
public class CMISChangeLogServiceImpl implements CMISChangeLogService
{
    private AuditService auditService;
    private String cmisAuditApplicationName;
    private List<CMISBaseObjectTypeIds> changesOnTypeCapability;

    private static final String PATH_DELIMITER = "/";
    private static final int DEFAULT_RETURN_SIZE = 100;

    /**
     * @see org.alfresco.cmis.CMISChangeLogService#getCapability()
     */
    public CMISCapabilityChanges getCapability()
    {
        return (auditService.isAuditEnabled(cmisAuditApplicationName, PATH_DELIMITER + cmisAuditApplicationName)) ? (CMISCapabilityChanges.OBJECTIDSONLY)
                : (CMISCapabilityChanges.NONE);
    }

    /**
     * @see org.alfresco.cmis.CMISChangeLogService#getChangeLogEvents(java.lang.String, java.lang.Integer)
     */
    public CMISChangeLog getChangeLogEvents(String changeLogToken, Integer maxItems)
    {
        if (!auditService.isAuditEnabled(cmisAuditApplicationName, ("/" + cmisAuditApplicationName)))
        {
            throw new AlfrescoRuntimeException("Auditing for " + cmisAuditApplicationName + " is disabled!");
        }
        CMISChangeLogImpl result = new CMISChangeLogImpl();
        final List<CMISChangeEvent> changeEvents = result.getChangeEvents();
        EntryIdCallback changeLogCollectingCallback = new EntryIdCallback(true)
        {
            @Override
            public boolean handleAuditEntry(Long entryId, String user, long time, Map<String, Serializable> values)
            {
                List<CMISChangeEvent> changeLogEvents = convertValuesMapToChangeLogEvents(values, time);
                changeEvents.addAll(changeLogEvents);
                return super.handleAuditEntry(entryId, user, time, values);
            }
        };
        Long from = changeLogToken != null ? Long.parseLong(changeLogToken) : null;
        AuditQueryParameters params = new AuditQueryParameters();
        params.setApplicationName(cmisAuditApplicationName);
        params.setForward(true);
        params.setFromId(from);

        // Query one past the last item, so that we know what the next ID is
        int maxAmount = ((null == maxItems) || (0 == maxItems)) ? (0) : (maxItems + 1);
        auditService.auditQuery(changeLogCollectingCallback, params, maxAmount);

        if ((0 != maxAmount) && (changeEvents.size() > maxItems))
        {
            changeEvents.remove(changeEvents.size() - 1);
            result.setNextChangeToken(changeLogCollectingCallback.getEntryId().toString());
            result.setHasMoreItems(true);
        }
        return result;
    }

    /**
     * @see org.alfresco.cmis.CMISChangeLogService#getChangesIncomplete()
     */
    public boolean getChangesIncomplete()
    {
        return true;
    }

    /**
     * @see org.alfresco.cmis.CMISChangeLogService#getLastChangeLogToken()
     */
    public String getLastChangeLogToken()
    {
        EntryIdCallback auditQueryCallback = new EntryIdCallback(false);
        AuditQueryParameters params = new AuditQueryParameters();
        params.setApplicationName(cmisAuditApplicationName);
        params.setForward(false);
        auditService.auditQuery(auditQueryCallback, params, 1);
        return auditQueryCallback.getEntryId();
    }

    /**
     * @see org.alfresco.cmis.CMISChangeLogService#getPreviousPageChangeLogToken(java.lang.String, java.lang.Integer)
     */
    public String getPreviousPageChangeLogToken(String currentPageToken, Integer maxItems)
    {
        if (currentPageToken == null)
        {
            return null;
        }
        maxItems = maxItems == null ? DEFAULT_RETURN_SIZE : maxItems;
        EntryIdCallback auditQueryCallback = new EntryIdCallback(false);
        AuditQueryParameters params = new AuditQueryParameters();
        params.setApplicationName(cmisAuditApplicationName);
        params.setForward(false);
        params.setToId(Long.parseLong(currentPageToken));
        auditService.auditQuery(auditQueryCallback, params, maxItems);
        return auditQueryCallback.getEntryId();
    }

    /**
     * @see org.alfresco.cmis.CMISChangeLogService#getLastPageChangeLogToken(java.lang.String, java.lang.Integer)
     */
    public String getLastPageChangeLogToken(String currentPageToken, Integer maxItems)
    {
        maxItems = maxItems == null ? DEFAULT_RETURN_SIZE : maxItems;
        EntryIdCallback auditQueryCallback = new PageStartEntryIdCallback(maxItems);
        AuditQueryParameters params = new AuditQueryParameters();
        params.setApplicationName(cmisAuditApplicationName);
        if (currentPageToken != null)
        {
            params.setFromId(Long.parseLong(currentPageToken));
        }
        auditService.auditQuery(auditQueryCallback, params, -1);
        return auditQueryCallback.getEntryId();
    }

    /**
     * @see org.alfresco.cmis.CMISChangeLogService#getChangesOnTypeCapability()
     */
    public List<CMISBaseObjectTypeIds> getChangesOnTypeCapability()
    {
        if (null == changesOnTypeCapability)
        {
            changesOnTypeCapability = new LinkedList<CMISBaseObjectTypeIds>();
        }
        return changesOnTypeCapability;
    }

    /**
     * Set the AuditService.
     * 
     * @param auditService AuditService
     */
    public void setAuditService(AuditService auditService)
    {
        this.auditService = auditService;
    }

    /**
     * Set the Audit Application Name.
     * 
     * @param cmisAuditApplicationName Audit Application Name
     */
    public void setCmisAuditApplicationName(String cmisAuditApplicationName)
    {
        this.cmisAuditApplicationName = cmisAuditApplicationName;
    }

    /**
     * Set the ChangesOnTypeCapability.
     * 
     * @param changesOnTypeCapability list of CMISBaseObjectTypeIds
     */
    public void setChangesOnTypeCapability(List<CMISBaseObjectTypeIds> changesOnTypeCapability)
    {
        this.changesOnTypeCapability = changesOnTypeCapability;
    }

    /**
     * Converts audit values map to list of CMISChangeEvents.
     * 
     * @param values audit values map
     * @param time audit event time
     * @return list of CMISChangeEvent
     */
    private List<CMISChangeEvent> convertValuesMapToChangeLogEvents(Map<String, Serializable> values, long time)
    {
        List<CMISChangeEvent> result = new ArrayList<CMISChangeEvent>();
        if (values != null && values.size() > 0)
        {
            for (Entry<String, Serializable> entry : values.entrySet())
            {
                if (entry.getKey() != null && entry.getValue() != null)
                {
                    String path = entry.getKey();
                    CMISChangeType changeType = getCMISChangeType(path);
                    NodeRef nodeRef = entry.getValue() instanceof NodeRef ? (NodeRef) entry.getValue() : null;
                    if (changeType != null && nodeRef != null)
                    {
                        result.add(new CMISChangeEventImpl(changeType, nodeRef, new Date(time)));
                    }
                }
            }
        }
        return result;
    }

    /**
     * Gets CMISChangeType by audit path.
     * 
     * @param auditPath audit path
     * @return CMISChangeType
     */
    private CMISChangeType getCMISChangeType(String auditPath)
    {
        CMISChangeType result = null;
        if (auditPath != null)
        {
            if (auditPath.startsWith(PATH_DELIMITER))
            {
                auditPath = auditPath.substring(PATH_DELIMITER.length());
            }
            if (auditPath.startsWith(cmisAuditApplicationName))
            {
                auditPath = auditPath.substring(cmisAuditApplicationName.length());
            }
            if (auditPath.startsWith(PATH_DELIMITER))
            {
                auditPath = auditPath.substring(PATH_DELIMITER.length());
            }
            auditPath = auditPath.toLowerCase();
            for (CMISChangeType changeType : CMISChangeType.values())
            {
                if (auditPath.startsWith(changeType.getLabel()))
                {
                    result = changeType;
                    break;
                }
            }
        }
        return result;
    }

    private class EntryIdCallback implements AuditQueryCallback
    {
        private final boolean valuesRequired;
        private Long entryId;

        public EntryIdCallback(boolean valuesRequired)
        {
            this.valuesRequired = valuesRequired;
        }

        public String getEntryId()
        {
            return entryId == null ? null : entryId.toString();
        }

        public boolean valuesRequired()
        {
            return this.valuesRequired;
        }

        public final boolean handleAuditEntry(Long entryId, String applicationName, String user, long time, Map<String, Serializable> values)
        {
            if (applicationName.equals(CMISChangeLogServiceImpl.this.cmisAuditApplicationName))
            {
                return handleAuditEntry(entryId, user, time, values);
            }
            return true;
        }

        public boolean handleAuditEntry(Long entryId, String user, long time, Map<String, Serializable> values)
        {
            this.entryId = entryId;
            return true;
        }

        public boolean handleAuditEntryError(Long entryId, String errorMsg, Throwable error)
        {
            throw new AlfrescoRuntimeException(errorMsg, error);
        }
    };

    private class PageStartEntryIdCallback extends EntryIdCallback
    {
        private final int pageSize;
        private int indexWithinPage;

        public PageStartEntryIdCallback(int pageSize)
        {
            super(false);
            this.pageSize = pageSize;
            this.indexWithinPage = -1;
        }

        @Override
        public boolean handleAuditEntry(Long entryId, String user, long time, Map<String, Serializable> values)
        {
            if (++this.indexWithinPage == this.pageSize)
            {
                this.indexWithinPage = 0;
                return super.handleAuditEntry(entryId, user, time, values);
            }
            return true;
        }
    }
}