containerfilterbean.java

java 写的一个新闻发布系统

//
//                                   ____.
//                       __/\ ______|    |__/\.     _______
//            __   .____|    |       \   |    +----+       \
//    _______|  /--|    |    |    -   \  _    |    :    -   \_________
//   \\______: :---|    :    :           |    :    |         \________>
//           |__\---\_____________:______:    :____|____:_____\
//                                      /_____|
//
//                 . . . i n   j a h i a   w e   t r u s t . . .
//
//
//
//
//
// 27.05.2002 NK Creation


package org.jahia.data.containers;


import java.sql.*;
import java.util.BitSet;
import java.util.Vector;
import java.util.Hashtable;
import java.util.Enumeration;
import java.util.Date;
import java.util.TimeZone;
import java.util.Calendar;

import org.jahia.utils.JahiaConsole;
import org.jahia.utils.JahiaTools;
import org.jahia.data.*;
import org.jahia.data.fields.FieldTypes;
import org.jahia.registries.ServicesRegistry;
import org.jahia.utils.JahiaConsole;
import org.jahia.exceptions.JahiaException;
import org.jahia.exceptions.database.JahiaDatabaseException;



/**
 * Jahia Standard container filtering for a given container list. 
 *
 * @see FilterClause
 * @see ContainerFilters
 * @see JahiaContainerSet
 * @author Khue Nguyen <a href="mailto:[e-mail]">[e-mail]</a>
 */
public final class ContainerFilterBean {

	public static final String COMP_EQUAL 				= "=";
	public static final String COMP_SMALLER 			= "<";
	public static final String COMP_SMALLER_OR_EQUAL 	= "<=";
	public static final String COMP_BIGGER_OR_EQUAL 	= ">=";
	public static final String COMP_BIGGER		 		= ">";

	private static final String CLASS_NAME		= ContainerFilterBean.class.getName();
	

	private static final String FIELD_VALUE		= "b.value_jahia_fields_data";
	
	private String fieldName;

	private boolean numberFiltering = false;
	
	/** The list of FilterClause bean **/	
	private Vector clauses = new Vector();
	
	
	
	//--------------------------------------------------------------------------
	/**
	 * Constructor
	 *
	 * @param String fieldName, the field name of the field on which to apply filtering.
	 */
	public ContainerFilterBean(String fieldName){
		this.fieldName = fieldName;
		JahiaConsole.println("ContainerFilterBean","Created with field name : " + fieldName);
	}

	//--------------------------------------------------------------------------
	/**
	 * Constructor
	 *
	 * @param String fieldName, the field name of the field on which to apply filtering.
	 * @param boolean numberFiltering, if true force to convert filed value to long representation
	 */
	public ContainerFilterBean(String fieldName, boolean numberFiltering){
		this.fieldName = fieldName;
		this.numberFiltering = numberFiltering;
		JahiaConsole.println("ContainerFilterBean","Created with field name : " + fieldName);
	}

	//--------------------------------------------------------------------------
	/**
	 * Add a simple comparison clause with a single value
	 *
	 * <pre>
	 * 		I.E : comparator = ContainerFilterBean.COMP_BIGGER (>)
	 *		 	  value	   	 = '1'
	 *			
	 *			  will be used to generate the WHERE clause :
	 *			
	 *				WHERE (fieldvalue>'1')
	 *
	 * </pre>
	 *
	 * @param String comparator, the comparator used to compare the field value with each value of the values array.
	 * @param String value, a single value
	 */
	public void addClause(String comparator, String value){
		
		if ( (value == null) || !checkComparator(comparator) )
			return;
		
		FilterClause fClause = new FilterClause(comparator,value);
		
		if ( fClause.isValid() ){	
			clauses.add(fClause);
		}
	}

	//--------------------------------------------------------------------------
	/**
	 * Add a simple comparison clause with multiple values
	 *
	 * An OR comparison is added between each clause.
	 *
	 * <pre>
	 * 		I.E : comparator = ContainerFilterBean.COMP_EQUAL (=)
	 *		 	  values	   = {'1','3','1000'}
	 *			
	 *			  will be used to generate the WHERE clause :
	 *			
	 *				WHERE (fieldvalue='1' OR fieldvalue='3' OR fieldvalue='1000')
	 *
	 * </pre>
	 *
	 * @param String comparator, the comparator used to compare the field value with each value of the values array.
	 * @param String[] values, an array of values as String
	 */
	public void addClause(String comparator, String[] values){
		
		if ( values == null || (values.length == 0) || !checkComparator(comparator) )
			return;
		
		FilterClause fClause = new FilterClause(comparator,values);
		
		if ( fClause.isValid() ){	
			clauses.add(fClause);
		}
	}

	//--------------------------------------------------------------------------
	/**
	 * Add a simple equality comparison clause with a single value
	 *
	 * <pre>
	 * 		I.E : 
	 *		 	  value	   	 = '1'
	 *			
	 *			  will be used to generate the WHERE clause :
	 *			
	 *				WHERE (fieldvalue>'1')
	 *
	 * </pre>
	 *
	 * @param String value, a single value
	 */
	public void addEqualClause(String value){
		
		if ( (value == null) )
			return;

		FilterClause fClause = new FilterClause(COMP_EQUAL,value);
		
		if ( fClause.isValid() ){	
			clauses.add(fClause);
		}
	}

	//--------------------------------------------------------------------------
	/**
	 * Add a simple equality comparison clause with multiple value
	 *
	 * <pre>
	 * 		I.E : 
	 *		 	  values	   = {'1','3','1000'}
	 *			
	 *			  will be used to generate the WHERE clause :
	 *			
	 *				WHERE (fieldvalue='1' OR fieldvalue='3' OR fieldvalue='1000')
	 *
	 * </pre>
	 *
	 * @param String value, a single value
	 */
	public void addEqualClause(String[] values){
		
		if ( values == null || (values.length == 0) )
			return;

		FilterClause fClause = new FilterClause(COMP_EQUAL,values);
		
		if ( fClause.isValid() ){	
			clauses.add(fClause);
		}
	}

	//--------------------------------------------------------------------------
	/**
	 * Constructs a range clause matching values between
	 * <code>lowerVal</code> and <code>upperVal</code>. 
	 *
	 * <pre>
	 * 		I.E : lowerComp = ContainerFilterBean.COMP_BIGGER_OR_EQUAL (>=)
	 *		 	  upperComp = ContainerFilterBean.COMP_SMALLER (<)
	 *			  lowerVal	= '1'
	 *			  upperVal	= '1000'
	 *			
	 *			  will be used to generate the WHERE clause :
	 *			
	 *				WHERE (fieldvalue>='1' AND fielValue<'10001')
	 *
	 * </pre>
	 *
	 * @param String lowerComp, the lower comparator
	 * @param String upperComp, the upper comparator
	 * @param String lowerVal, 	the lower value
	 * @param String upperVal, 	the upper value
	 */
	public void addRangeClause(	String lowerComp, 
								String upperComp, 
								String lowerVal, 
								String upperVal) {
	 	
	 	if ( lowerVal == null 
	 			|| upperVal == null 
	 			|| !checkComparator(lowerComp)
	 			|| !checkComparator(upperComp) ){
	 				
			return;
		}

		FilterClause fClause = new FilterClause(lowerComp,
												upperComp,
												lowerVal,
												upperVal);
		
		if ( fClause.isValid() ){	
			clauses.add(fClause);
		}
	}

	//--------------------------------------------------------------------------
	/**
	 * Constructs a range clause matching date values between
	 * <code>lower</code> and <code>upper</code>. 
	 *
	 * Available only with field of type JahiaDateField ( date field ).
	 *
	 * <pre>
	 * 		I.E : lowerComp = ContainerFilterBean.COMP_SMALLER (<)
	 *		 	  upperComp = ContainerFilterBean.COMP_BIGGER_OR_EQUAL (>=)
	 *			  lowerVal	= '1020038400100' ( long representation )
	 *			  upperVal	= '1020038400000' ( long representation )
	 *			
	 *			  will be used to generate the WHERE clause :
	 *			
	 *				WHERE (fieldvalue<'1020038400100' AND fielValue>='1020038400000')
	 *
	 * </pre>
	 *
	 * @param String lowerComp, the lower comparator
	 * @param String upperComp, the upper comparator
	 * @param Date lowerVal,	the lower date
	 * @param Date upperVal, 	the upper date
	 */
	public void addDateClause(	String lowerComp, 
								String upperComp, 
								Date lowerVal, 
								Date upperVal) {
	 	
	 	if ( lowerVal == null 
	 			|| upperVal == null 
	 			|| !checkComparator(lowerComp)
	 			|| !checkComparator(upperComp) ){
			return;
		}
		
		addRangeClause(lowerComp, 
					   upperComp, 
					   String.valueOf(lowerVal.getTime()),
					   String.valueOf(upperVal.getTime())
					   );				
	}

	//--------------------------------------------------------------------------
	/**
	 * Constructs a range clause matching date values between
	 * <code>lower</code> and <code>upper</code>. 
	 *
	 * Available only with field of type JahiaDateField ( date field ).
	 *
	 * <pre>
	 * 		I.E : lowerComp = ContainerFilterBean.COMP_SMALLER (<)
	 *		 	  upperComp = ContainerFilterBean.COMP_BIGGER_OR_EQUAL (>=)
	 *			  lowerVal	= '1020038400100' ( long representation )
	 *			  upperVal	= '1020038400000' ( long representation )
	 *			
	 *			  will be used to generate the WHERE clause :
	 *			
	 *				WHERE (fieldvalue<'1020038400100' AND fielValue>='1020038400000')
	 *
	 * </pre>
	 *
	 * @param String lowerComp, the lower comparator
	 * @param String upperComp, the upper comparator
	 * @param long lowerVal,	the lower date
	 * @param long upperVal, 	the upper date
	 */
	public void addDateClause(	String lowerComp, 
								String upperComp, 
								long lowerVal, 
								long upperVal) {
	 	
		addRangeClause(lowerComp, 
					   upperComp, 
					   String.valueOf(lowerVal),
					   String.valueOf(upperVal)
					   );				
	}

	//--------------------------------------------------------------------------
	/**
	 * Constructs a range clause matching date for X day ago.
	 *
	 * Available only with field of type JahiaDateField ( date field ).
	 *
	 * @param int nbDays
	 */
	public void addXDayMaxDateClause(int nbDays){
	 	
	 	// Now
        TimeZone tz = TimeZone.getTimeZone("UTC");
        Calendar cal = Calendar.getInstance(tz);
	 	Date nowDate = cal.getTime();
		long nowLong = nowDate.getTime();
		
		addDateClause( COMP_SMALLER_OR_EQUAL, 
					   COMP_BIGGER_OR_EQUAL, 
					   nowLong,
					   nowLong-(nbDays*24*60*60*1000)
					   );				
	}

	//--------------------------------------------------------------------------
	/**
	 * Constructs a range clause matching date values that are in Today date.
	 *
	 * Available only with field of type JahiaDateField ( date field ).
	 *
	 */
	public void addTodayDateClause(){
	 	
	 	// Now
        TimeZone tz = TimeZone.getTimeZone("UTC");
        Calendar cal = Calendar.getInstance(tz);
	 	Date nowDate = cal.getTime();
		long nowLong = nowDate.getTime();
		
        int year = cal.get(Calendar.YEAR);
        int mon = cal.get(Calendar.MONTH);
        int date = cal.get(Calendar.DAY_OF_MONTH);
		cal.set(year,mon,date,0,0,0);
		cal.set(Calendar.MILLISECOND,0);

	 	Date todayDate = cal.getTime();
		long todayLong = todayDate.getTime();
				
		// Today 
		addDateClause( COMP_SMALLER_OR_EQUAL, 
					   COMP_BIGGER_OR_EQUAL, 
					   nowLong,
					   todayLong
					   );				
	}

	//--------------------------------------------------------------------------
	/**
	 * Return the field name
	 *
	 * @return String, the field name.
	 */
	public String getFieldName()
	{
		return this.fieldName;	
	}

	//--------------------------------------------------------------------------
	/**
	 * You can force field values to be corverted to long representation for filtering comparison
	 * Prefer String comparison when possible, because it is faster ( only one DB query needed ).
	 *
	 * @param boolean number filtering status value.
	 */
	public void setNumberFiltering(boolean val)
	{
		this.numberFiltering = val;	
	}

	//--------------------------------------------------------------------------
	/**
	 * Return the number filtering status.
	 * If true, field values are converted to long representation before filtering comparison
	 *
	 * @return boolean the number filtering status.