ContentIndexQuery.java

/*
 * Copyright 2000-2013 Enonic AS
 * http://www.enonic.com/license
 */
package com.enonic.cms.core.content.index;

import java.util.Collection;
import java.util.Date;

import org.apache.commons.lang.builder.ToStringBuilder;
import org.apache.commons.lang.builder.ToStringStyle;
import org.joda.time.DateTime;

import com.enonic.cms.core.content.ContentKey;
import com.enonic.cms.core.content.category.CategoryAccessType;
import com.enonic.cms.core.search.ContentIndexServiceImpl;
import com.enonic.cms.core.search.query.AbstractQuery;
import com.enonic.cms.core.structure.menuitem.MenuItemEntity;
import com.enonic.cms.core.structure.menuitem.MenuItemKey;

/**
 * This class implements the content query.
 */
public final class ContentIndexQuery
    extends AbstractQuery
{
    // Set the default count to the threshold value for optimizing the count to be shure to get all content
    public static final int DEFAULT_COUNT = ContentIndexServiceImpl.COUNT_OPTIMIZER_THRESHOULD_VALUE;

    private String facets;

    public enum SectionFilterStatus
    {
        ANY,
        APPROVED_ONLY,
        UNAPPROVED_ONLY
    }

    public enum CategoryAccessTypeFilterPolicy
    {
        AND,
        OR
    }

    private SectionFilterStatus sectionFilterStatus;

    private CategoryAccessTypeFilterPolicy categoryAccessTypeFilterPolicy;

    private final String query;

    /**
     * Content key filter.
     */
    private Collection<ContentKey> contentFilter;

    /**
     * Section key filter
     */
    private Collection<MenuItemEntity> sectionFilter;

//    private boolean approvedSectionContentOnly = true;
//    private boolean unapprovedSectionContentOnly = false;

    private int index = 0;

    private int count = DEFAULT_COUNT;

    private boolean returnAllHits = false;

    private Integer contentStatusFilter;

    private DateTime contentOnlineAtFilter;

    private Collection<CategoryAccessType> categoryAccessTypeFilter;

    private MenuItemKey orderBySection;

    /**
     * Construct the query.
     *
     * @param queryWithoutOrderBy A user defined query, similar to the WHERE part of an SQL query.
     * @param orderBy             A user defined order by cluase, similar to the ORDER BY part of an SQL query.
     * @throws IllegalQueryException If the query can not be parsed.
     */
    public ContentIndexQuery( String queryWithoutOrderBy, String orderBy )
    {
        if ( queryWithoutOrderBy == null )
        {
            queryWithoutOrderBy = "";
        }

        if ( ( orderBy != null ) && ( orderBy.length() > 0 ) )
        {
            queryWithoutOrderBy = queryWithoutOrderBy + " ORDER BY " + orderBy;
        }

        this.query = queryWithoutOrderBy.trim();
    }

    public ContentIndexQuery( String query )
    {
        this.query = query;
    }

    /**
     * Return the query.
     *
     * @return The query supplied query.
     */
    public String getQuery()
    {
        return this.query;
    }

    public int getIndex()
    {
        return this.index;
    }

    public void setIndex( int index )
    {
        this.index = index;
    }

    public int getCount()
    {
        return this.count;
    }

    public void setCount( int count )
    {
        this.count = count;
    }

    public Collection<ContentKey> getContentFilter()
    {
        return contentFilter;
    }

    public void setContentFilter( Collection<ContentKey> filter )
    {

        contentFilter = filter;
    }

    public boolean hasSectionFilter()
    {
        return sectionFilter != null && !sectionFilter.isEmpty();
    }


    public Collection<MenuItemEntity> getSectionFilter()
    {
        return sectionFilter;
    }

    public boolean isSectionFilter()
    {
//        return sectionFilter != null && sectionFilter.size() > 0;
        return ( sectionFilterStatus != null );
    }

    public void setSectionFilter( Collection<MenuItemEntity> filter, final SectionFilterStatus filterStatus )
    {

        this.sectionFilter = filter;
        this.sectionFilterStatus = filterStatus;

//        if ( approvedSectionContentOnly == true && unapprovedSectionContentOnly == true )
//        {
//            throw new IllegalArgumentException (
//        "Illegal section filter. approvedSectionContentOnly and unapprovedSectionContentOnly cannot both be true" );
//        }
//
//        this.approvedSectionContentOnly = approvedSectionContentOnly;
//        this.unapprovedSectionContentOnly = unapprovedSectionContentOnly;
    }

    public boolean isApprovedSectionContentOnly()
    {
        if ( sectionFilterStatus == SectionFilterStatus.APPROVED_ONLY )
        {
            return true;
        }
        return false;
    }

    public boolean isUnapprovedSectionContentOnly()
    {
        if ( sectionFilterStatus == SectionFilterStatus.UNAPPROVED_ONLY )
        {
            return true;
        }
        return false;
    }

    public boolean hasContentStatusFilter()
    {
        return this.contentStatusFilter != null;
    }

    public void setContentStatusFilter( Integer contentStatus )
    {
        this.contentStatusFilter = contentStatus;
    }

    public Integer getContentStatusFilter()
    {
        return this.contentStatusFilter;
    }

    public DateTime getContentOnlineAtFilter()
    {
        return contentOnlineAtFilter;
    }

    public void setContentOnlineAtFilter( Date value )
    {
        this.contentOnlineAtFilter = new DateTime( value );
    }

    public Collection<CategoryAccessType> getCategoryAccessTypeFilter()
    {
        return categoryAccessTypeFilter;
    }

    public void setCategoryAccessTypeFilter( Collection<CategoryAccessType> value, CategoryAccessTypeFilterPolicy policy )
    {
        if ( value != null && policy == null )
        {
            throw new IllegalArgumentException( "categoryAccessTypeFilter requries a valid policy, and cannot be NULL " );
        }

        this.categoryAccessTypeFilter = value;
        this.categoryAccessTypeFilterPolicy = policy;
    }

    @Override
    public String toString()
    {
        ToStringBuilder s = new ToStringBuilder( this, ToStringStyle.MULTI_LINE_STYLE );
        s.append( "index", index );
        s.append( "count", count );
        s.append( "query", query );
        s.append( "categoryAccessTypeFilter", categoryAccessTypeFilter );
        s.append( "approvedSectionContentOnly", sectionFilterStatus );
        s.append( "contentStatusFilter", contentStatusFilter );
        s.append( "contentOnlineAtFilter", contentOnlineAtFilter );
        s.append( "contentFilter", contentFilter );
        s.append( "sectionFilter", sectionFilter );
        s.append( "categoryFilter", getCategoryFilter() );
        s.append( "contentTypeFilter", getContentTypeFilter() );
        s.append( "securityFilter", getSecurityFilter() );
        s.append( "orderBySection", orderBySection );
        s.append( "facetDefinition", facets );
        return s.toString();
    }

    public CategoryAccessTypeFilterPolicy getCategoryAccessTypeFilterPolicy()
    {
        return categoryAccessTypeFilterPolicy;
    }

    public MenuItemKey getOrderBySection()
    {
        return orderBySection;
    }

    public void setOrderBySection( MenuItemKey orderBySection )
    {
        this.orderBySection = orderBySection;
    }

    public String getFacets()
    {
        return facets;
    }

    public void setFacets( final String facets )
    {
        this.facets = facets;
    }

    public boolean doReturnAllHits()
    {
        return returnAllHits;
    }

    public void setReturnAllHits( final boolean returnAllHits )
    {
        this.returnAllHits = returnAllHits;
    }
}