FilterField.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2011 Lluis Turró Cutiller <http://www.turro.org/>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package org.turro.zkoss.filter;
 
import java.io.Serializable;
import java.util.Date;
import java.util.EnumSet;
import org.turro.string.Strings;
import org.turro.elephant.db.SQLHelper;
import org.turro.elephant.db.WhereClause;
import org.turro.elephant.impl.util.StringParser;
import org.turro.plugin.filter.IFilterValue;
import org.turro.zkoss.dialog.InputEnum;
import org.turro.zkoss.input.*;
import org.zkoss.zk.ui.HtmlBasedComponent;
import org.zkoss.zk.ui.ext.AfterCompose;
import org.zkoss.zul.*;
 
public abstract class FilterField implements Cloneable, Serializable, IFilterValue, AfterCompose {
 
  public final static String FIELD_SUBSTITUTION_REGEXP = "[\\.\\(\\) \\,\\:\\<\\>\\=]";
 
  protected EnumSet<FilterFieldOperator> operators;
  protected HtmlBasedComponent editor, operatorEditor;
  protected EnumListbox<ChainOperator> chainEditor;
  protected Object value;
  protected int scale;
  protected boolean fixed;
  protected String label, format;
  protected Enum[] choices;
  protected ChainOperator chain;
  protected FilterFieldOperator operator = FilterFieldOperator.FILTER_EQUAL;
 
  public FilterField(String label, String value) {
    this(label, value, FilterFieldOperator.FILTER_CONTAINS);
  }
 
  public FilterField(String label, Number value) {
    this(label, value, FilterFieldOperator.FILTER_EQUAL);
  }
 
  public FilterField(String label, Date value) {
    this(label, value, FilterFieldOperator.FILTER_BIG_OR_EQUAL);
  }
 
  public FilterField(String label, Boolean value) {
    this(label, value, FilterFieldOperator.FILTER_EQUAL);
  }
 
  public FilterField(String label, Enum value) {
    this(label, value, FilterFieldOperator.FILTER_EQUAL);
  }
 
  public FilterField(String label) {
    this(label, FilterFieldOperator.FILTER_EQUAL);
  }
 
  public FilterField(String label, String value, FilterFieldOperator operator) {
    this.label = label;
    this.value = value;
    this.operator = operator;
    operators = EnumSet.of(
            FilterFieldOperator.FILTER_CONTAINS,
            FilterFieldOperator.FILTER_EQUAL,
            FilterFieldOperator.FILTER_LESS,
            FilterFieldOperator.FILTER_LESS_OR_EQUAL,
            FilterFieldOperator.FILTER_BIG,
            FilterFieldOperator.FILTER_BIG_OR_EQUAL,
            FilterFieldOperator.FILTER_REGEXP,
            FilterFieldOperator.FILTER_NOT_EQUAL);
    chain = ChainOperator.AND;
  }
 
  public FilterField(String label, Number value, FilterFieldOperator operator) {
    this.label = label;
    this.value = value;
    this.operator = operator;
    this.scale = 2;
    operators = EnumSet.of(
            FilterFieldOperator.FILTER_EQUAL,
            FilterFieldOperator.FILTER_LESS,
            FilterFieldOperator.FILTER_LESS_OR_EQUAL,
            FilterFieldOperator.FILTER_BIG,
            FilterFieldOperator.FILTER_BIG_OR_EQUAL,
            FilterFieldOperator.FILTER_NOT_EQUAL);
    chain = ChainOperator.AND;
  }
 
  public FilterField(String label, Date value, FilterFieldOperator operator) {
    this.label = label;
    this.value = value;
    this.operator = operator;
    operators = EnumSet.of(
            FilterFieldOperator.FILTER_EQUAL,
            FilterFieldOperator.FILTER_LESS,
            FilterFieldOperator.FILTER_LESS_OR_EQUAL,
            FilterFieldOperator.FILTER_BIG,
            FilterFieldOperator.FILTER_BIG_OR_EQUAL,
            FilterFieldOperator.FILTER_NOT_EQUAL);
    chain = ChainOperator.AND;
  }
 
  public FilterField(String label, Boolean value, FilterFieldOperator operator) {
    this.label = label;
    this.value = value;
    this.operator = operator;
    operators = EnumSet.of(
            FilterFieldOperator.FILTER_EQUAL,
            FilterFieldOperator.FILTER_NOT_EQUAL);
    chain = ChainOperator.AND;
  }
 
  public FilterField(String label, Enum value, FilterFieldOperator operator) {
    this.label = label;
    this.value = value;
    this.operator = operator;
    operators = EnumSet.of(
            FilterFieldOperator.FILTER_EQUAL,
            FilterFieldOperator.FILTER_NOT_EQUAL);
    chain = ChainOperator.AND;
  }
 
  public FilterField(String label, FilterFieldOperator operator) {
    this.label = label;
    this.value = null;
    this.editor = null;
    this.operator = operator;
    operators = EnumSet.of(
            FilterFieldOperator.FILTER_EQUAL,
            FilterFieldOperator.FILTER_NOT_EQUAL);
    chain = ChainOperator.AND;
  }
 
  public ChainOperator getChain() {
    if(chainEditor != null) {
      return (ChainOperator) ((EnumListbox) chainEditor).getObjectValue();
    }
    return chain;
  }
 
  public void setChain(ChainOperator chain) {
    this.chain = chain;
  }
 
  public Enum[] getChoices() {
    return choices;
  }
 
  public void setChoices(Enum[] choices) {
    this.choices = choices;
  }
 
  public boolean isFixed() {
    return fixed;
  }
 
  public void setFixed(boolean fixed) {
    this.fixed = fixed;
  }
 
  public String getFormat() {
    return format;
  }
 
  public void setFormat(String format) {
    this.format = format;
  }
 
  @Override
  public String getLabel() {
    return label;
  }
 
  public void setLabel(String label) {
    this.label = label;
  }
 
  public EnumSet<FilterFieldOperator> getOperators() {
    return operators;
  }
 
  public void setOperators(EnumSet<FilterFieldOperator> operators) {
    this.operators = operators;
  }
 
  public FilterFieldOperator getOperator() {
    if(operatorEditor != null) {
      return (FilterFieldOperator) ((EnumListbox) operatorEditor).getObjectValue();
    }
    return operator;
  }
 
  public void setOperator(FilterFieldOperator operator) {
    this.operator = operator;
  }
 
  public int getScale() {
    return scale;
  }
 
  public void setScale(int scale) {
    this.scale = scale;
  }
 
  public Object getObjectValue() {
    return getEditorValue();
  }
 
  @Override
  public boolean hasValue() {
    Object v = getObjectValue();
    if(v instanceof String) {
      if(Strings.isBlank((String) v)) {
        return false;
      }
    }
    return v != null;
  }
 
  public HtmlBasedComponent getEditor() {
    if(editor == null) {
      editor = createEditor();
      editor.setHflex("1");
    }
//    if(editor instanceof Decimalbox) {
//      editor.setWidth("100%");
//    } else if(editor instanceof Datebox) {
//      editor.setWidth("80px");
//    } else if(editor instanceof Combobox) {
//      editor.setWidth("95%");
//    } else if(editor instanceof Textbox) {
//      editor.setWidth("100%");
//    }
    return editor;
  }
 
  public HtmlBasedComponent getOperatorEditor() {
    if(operatorEditor == null) {
      operatorEditor = createOperatorEditor();
      operatorEditor.setHflex("1");
  }
    return operatorEditor;
  }
 
  public EnumListbox<ChainOperator> getChainEditor() {
    if(chainEditor == null) {
      chainEditor = createChainEditor();
      chainEditor.setHflex("1");
    }
    return chainEditor;
  }
 
  protected HtmlBasedComponent createEditor() {
    if(value instanceof Boolean) {
      Checkbox cb = new Checkbox();
      cb.setChecked((Boolean) value);
      return cb;
    } else if(value instanceof Number) {
      ExpressionInput ei = new ExpressionInput();
      ei.setValue(value);
      return ei;
    } else if(value instanceof Date) {
      DateboxShort db = new DateboxShort((Date) value);
      db.setFormat(format);
      return db;
    } else if(value instanceof Enum) {
      InputEnum ie = new InputEnum(choices);
      ie.setObjectValue((Enum) value);
      return ie;
    } else {
      Textbox tb = new Textbox((String) value);
      return tb;
    }
  }
 
  protected HtmlBasedComponent createOperatorEditor() {
    EnumListbox<FilterFieldOperator> col = new EnumListbox<FilterFieldOperator>(operators.toArray(new FilterFieldOperator[0]));
    col.setObjectValue(operator);
    col.setMold("select");
    //col.afterCompose();
    return col;
  }
 
  protected EnumListbox<ChainOperator> createChainEditor() {
    EnumListbox<ChainOperator> col = new EnumListbox<ChainOperator>(ChainOperator.values());
    col.setObjectValue(chain);
    col.setMold("select");
    //col.afterCompose();
    return col;
  }
 
  protected Object getEditorValue() {
    if(editor instanceof Checkbox) {
      return ((Checkbox) editor).isChecked();
    } else if(editor instanceof Decimalbox) {
      return StringParser.convertToClass(value.getClass(), ((Decimalbox) editor).getValue());
    } else if(editor instanceof ExpressionInput) {
      return StringParser.convertToClass(value.getClass(), ((ExpressionInput) editor).getNumber(scale));
    } else if(editor instanceof Datebox) {
      return ((Datebox) editor).getValue();
    } else if(editor instanceof GenericListbox) {
      return ((GenericListbox) editor).getObjectValue();
    } else if(editor instanceof GenericCombobox) {
      return ((GenericCombobox) editor).getObjectValue();
    } else if(editor instanceof Listbox) {
      return ((Listbox) editor).getSelectedItem().getValue();
    } else if(editor instanceof InputEnum) {
      return ((InputEnum) editor).getObjectValue();
    } else {
      return ((Textbox) editor).getText();
    }
  }
 
  @Override
  public abstract void addConstraint(WhereClause wc);
  
  public void doAddConstraint(WhereClause wc, String field) {
    doAddConstraint(wc, new String[] { field });
  }
 
  public void doAddConstraint(WhereClause wc, String[] fields) {
    if(!hasValue()) return;
    Object obj = getObjectValue();
    if(FilterFieldOperator.FILTER_CONTAINS.equals(getOperator())) {
      if(obj instanceof String) {
        String prefix = wc.getPrefix();
        wc.setPrefix(getChain().getOpSQL());
        wc = SQLHelper.getWhereClause(wc, fields, ((String) obj).replaceAll("\\*", "%"));
        wc.setPrefix(prefix);
      }
    } else if(FilterFieldOperator.FILTER_REGEXP.equals(getOperator())) {
 
    } else {
      String param = fields[0].replaceAll(FIELD_SUBSTITUTION_REGEXP, "_") + wc.getUniqueSuffix();
      wc.addClause(getChain().getOpSQL() + " " + fields[0] + " " + getOperator().getOpSQL() + " :" + param);
      wc.addNamedValue(param, obj);
    }
  }
 
  public void doAddSubqueryConstraint(WhereClause wc, String collection, String field) {
    doAddSubqueryConstraint(wc, collection, new String[] { field });
  }
 
  public void doAddSubqueryConstraint(WhereClause wc, String collection, String[] fields) {
    if(!hasValue()) return;
    Object obj = getObjectValue();
    if(FilterFieldOperator.FILTER_CONTAINS.equals(getOperator())) {
      String param = fields[0].replaceAll(FIELD_SUBSTITUTION_REGEXP, "_") + wc.getUniqueSuffix();
      wc.addClause(getChain().getOpSQL() + " exists");
      wc.addClause("(");
      wc.addClause("select sqx from " + collection + " as sqx");
      wc.addClause("where sqx." + fields[0] + " " + getOperator().getOpSQL() + " :" + param);
      wc.addNamedValue(param, ((String) obj).replaceAll("\\*", "%"));
      wc.addClause(")");
    } else if(FilterFieldOperator.FILTER_REGEXP.equals(getOperator())) {
 
    } else {
      String param = fields[0].replaceAll(FIELD_SUBSTITUTION_REGEXP, "_") + wc.getUniqueSuffix();
      wc.addClause(getChain().getOpSQL() + " exists");
      wc.addClause("(");
      wc.addClause("select sqx from " + collection + " as sqx");
      wc.addClause("where sqx." + fields[0] + " " + getOperator().getOpSQL() + " :" + param);
      wc.addNamedValue(param, obj);
      wc.addClause(")");
    }
  }
 
  public void doAddSubqueryConstraint(WhereClause wc, String collection[], String field) {
    doAddSubqueryConstraint(wc, collection, new String[] { field });
  }
 
  public void doAddSubqueryConstraint(WhereClause wc, String collection[], String[] fields) {
    if(!hasValue()) return;
    Object obj = getObjectValue();
    if(FilterFieldOperator.FILTER_CONTAINS.equals(getOperator())) {
      addLikeSubqueries(wc, collection, fields, 0);
    } else if(FilterFieldOperator.FILTER_REGEXP.equals(getOperator())) {
 
    } else {
      addSubqueries(wc, collection, fields, 0);
    }
  }
 
  private void addSubqueries(WhereClause wc, String collection[], String[] fields, int count) {
    if(count >= collection.length) return;
    String param = fields[0].replaceAll(FIELD_SUBSTITUTION_REGEXP, "_") + wc.getUniqueSuffix();
    if(count == 0) {
      wc.addClause(getChain().getOpSQL() + " exists");
    } else {
      wc.addClause("where exists");
    }
    wc.addClause("(");
    wc.addClause("select sqx from " + collection[count] + " as sqx");
    if(count == collection.length - 1) {
      Object obj = getObjectValue();
      wc.addClause("where sqx." + fields[0] + " " + getOperator().getOpSQL() + " :" + param);
      wc.addNamedValue(param, obj);
    } else {
      addSubqueries(wc, collection, fields, count + 1);
    }
    wc.addClause(")");
  }
 
  private void addLikeSubqueries(WhereClause wc, String collection[], String[] fields, int count) {
    if(count >= collection.length) return;
    String param = fields[0].replaceAll(FIELD_SUBSTITUTION_REGEXP, "_") + wc.getUniqueSuffix();
    if(count == 0) {
      wc.addClause(getChain().getOpSQL() + " exists");
    } else {
      wc.addClause("where exists");
    }
    wc.addClause("(");
    wc.addClause("select sqx from " + collection[count] + " as sqx");
    if(count == collection.length - 1) {
      Object obj = getObjectValue();
      wc.addClause("where sqx." + fields[0] + " " + getOperator().getOpSQL() + " :" + param);
      wc.addNamedValue(param, ((String) obj).replaceAll("\\*", "%"));
    } else {
      addLikeSubqueries(wc, collection, fields, count + 1);
    }
    wc.addClause(")");
  }
 
  @Override
  public void afterCompose() {
    if(editor != null && editor instanceof AfterCompose) {
      ((AfterCompose) editor).afterCompose();
    }
    if(operatorEditor != null && operatorEditor instanceof AfterCompose) {
      ((AfterCompose) operatorEditor).afterCompose();
    }
    if(chainEditor != null && chainEditor instanceof AfterCompose) {
      ((AfterCompose) chainEditor).afterCompose();
    }
  }
 
  @Override
  public Object clone() {
    try {
      return super.clone();
    } catch (CloneNotSupportedException e) {
      return null;
    }
  }
  
}