MagnoliaTemplate

/**
 * This file Copyright (c) 2008-2012 Magnolia International
 * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
 *
 *
 * This file is dual-licensed under both the Magnolia
 * Network Agreement and the GNU General Public License.
 * You may elect to use one or the other of these licenses.
 *
 * This file is distributed in the hope that it will be
 * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
 * implied warranty of MERCHANTABILITY or FITNESS FOR A
 * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
 * Redistribution, except as permitted by whichever of the GPL
 * or MNA you select, is prohibited.
 *
 * 1. For the GPL license (GPL), you can redistribute and/or
 * modify this file under the terms of the GNU General
 * Public License, Version 3, as published by the Free Software
 * Foundation.  You should have received a copy of the GNU
 * General Public License, Version 3 along with this program;
 * if not, write to the Free Software Foundation, Inc., 51
 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * 2. For the Magnolia Network Agreement (MNA), this file
 * and the accompanying materials are made available under the
 * terms of the MNA which accompanies this distribution, and
 * is available at http://www.magnolia-cms.com/mna.html
 *
 * Any modifications to this file must keep this entire header
 * intact.
 *
 */
package info.magnolia.module.rssaggregator.util;

import static java.util.Collections.emptyList;

import info.magnolia.cms.core.Content;
import info.magnolia.cms.core.search.Query;
import info.magnolia.cms.util.QueryUtil;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import javax.jcr.Node;
import javax.jcr.RepositoryException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Convenience class to simplify use of Magnolia queries and the mapping of their results to types. <p/> Note that all
 * queries performed by this class are logged at DEBUG level for convenient debugging when necessary.
 *
 * @author Rob van der Linden Vooren
 * @see ContentMapper
 */
public class MagnoliaTemplate implements MagnoliaQueryOperations {

    /** Logger for this instance. */
    protected Logger logger = LoggerFactory.getLogger(getClass());

    /** {@inheritDoc} */
    @Override
    public <T> List<T> queryForList(String repository, String query, String language, String type, ContentMapper<T> mapper) {
        return query(repository, query, language, type, mapper);
    }

    /** {@inheritDoc} */
    @Override
    public <T> T queryForObject(String repository, String query, String language, String type, ContentMapper<T> mapper) {
        List<T> results = query(repository, query, language, type, mapper);
        return singleResult(results);
    }

    /** {@inheritDoc} */
    @Override
    public <T> List<T> xpathQueryForList(String repository, String query, String type, ContentMapper<T> mapper) throws DataAccessException {
        return queryForList(repository, query, Query.XPATH, type, mapper);
    }

    /** {@inheritDoc} */
    @Override
    public <T> T xpathQueryForObject(String repository, String query, String type, ContentMapper<T> mapper) throws DataAccessException {
        return queryForObject(repository, query, Query.XPATH, type, mapper);
    }

    /** {@inheritDoc} */
    @Override
    public Node xpathQueryForContent(String repository, String query, String type) throws DataAccessException {
        return queryForObject(repository, query, Query.XPATH, type, new ContentMapper<Node>() {
            @Override
            public Node map(Node content) throws RepositoryException {
                return content;
            }
        });
    }

    // Helper methods

    protected <T> List<T> query(String repository, String query, String language, String type, ContentMapper<T> mapper) throws DataAccessException {
        Collection<Content> contents = queryInternal(repository, query, language, type);
        if (contents.isEmpty()) {
            return emptyList();
        }
        List<T> result = new ArrayList<T>(contents.size());
        for (Content content : contents) {
            try {
                result.add(mapper.map(content.getJCRNode()));
            } catch (RepositoryException re) {
                logger.error(String.format("Failed to map content '%s' using mapper '%s'", content, mapper.getClass()), re);
            }
        }
        return result;
    }

    /**
     * Performs the actual query execution. Purposely delegates to {@link QueryUtil#exceptionThrowingQuery(String, String, String, String) QueryUtil.exceptionThrowingQuery(..)} in order to provide flexibility with regards to
     * error handling, by translating any {@link RepositoryException} into an unchecked {@link DataAccessException}.
     * This allows for optional exception handling and logging, making it a better alternative then using {@link QueryUtil#query(String, String) QueryUtil.query(..)} directly, which logs the error and then directly swallows
     * the {@link RepositoryException exception}. Execute a query for a result list of type T, for the given query.
     *
     * @param repository the repository to execute query against
     * @param query query to execute
     * @param language query language (either {@value Query#XPATH} or {@value Query#SQL}).
     * @param type the type of the item to query for
     * @return the result object of the required type, or {@code null} in case of a {@code null} query
     * @throws DataAccessException if there is any problem executing the query
     */
    protected <T> Collection<T> queryInternal(String repository, String query, String language, String type) {
        try {
            return doExceptionThrowingQuery(repository, query, language, type);
        } catch (RepositoryException re) {
            throw new DataAccessException("A repository exception occurred", re);

        }
    }

    @SuppressWarnings("unchecked")
    protected <T> Collection<T> doExceptionThrowingQuery(String repository, String query, String language, String type) throws RepositoryException {
        logger.debug("Executing {} query for '{}' in repository '{}': \"{}\"", new Object[] {language,
                type, repository, query}
                );
        Collection<T> results = (Collection<T>) QueryUtil.exceptionThrowingQuery(repository, query, language, type);
        logger.debug("Query returned %s result(s)", (results == null) ? null : results.size());
        return results;
    }

    /**
     * Return a single result object from the given collection or {@code null} if the collection is empty or null.
     *
     * @param results the result collection (may be {@code null})
     * @return the single result object, or {@code null} when no result
     * @throws IncorrectResultSizeDataAccessException
     *          if collection contains more than one element
     */
    protected static <T> T singleResult(Collection<T> results) throws IncorrectResultSizeDataAccessException {
        int size = (results == null ? 0 : results.size());
        if (size == 0) {
            return null;
        }
        if (results.size() > 1) {
            throw new IncorrectResultSizeDataAccessException(1, size);
        }
        return results.iterator().next();
    }

}