Application: gvSIG desktop

package org.gvsig.fmap.dal.swing.impl.searchpanel;

import java.awt.Cursor;

import java.awt.event.ActionEvent;

import java.awt.event.ItemEvent;

import java.awt.event.ItemListener;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import javax.json.Json;

import javax.json.JsonArray;

import javax.json.JsonArrayBuilder;

import javax.json.JsonObject;

import javax.json.JsonObjectBuilder;

import javax.swing.ComboBoxModel;

import javax.swing.DefaultComboBoxModel;

import javax.swing.ImageIcon;

import javax.swing.JComboBox;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.SwingUtilities;

import javax.swing.text.JTextComponent;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.complements.Search;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.expressionevaluator.DALExpressionBuilder;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.FeatureQuery;

import org.gvsig.fmap.dal.feature.FeatureSet;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.fmap.dal.feature.ForeingKey;

import org.gvsig.fmap.dal.swing.impl.featuretype.DefaultFeatureAttributeSelectionPanel;

import static org.gvsig.fmap.dal.swing.impl.searchpanel.DefaultSearchPanel.getAttributeDescriptorLabel;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.Coercion;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataTypeUtils;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.swing.api.DropDown;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.swing.api.ToolsSwingManager;

import org.gvsig.tools.swing.api.pickercontroller.DatePickerController;

import org.gvsig.tools.swing.api.threadsafedialogs.ThreadSafeDialogsManager;

import org.gvsig.tools.swing.api.windowmanager.Dialog;

import org.gvsig.tools.swing.api.windowmanager.WindowManager;

import org.gvsig.tools.swing.api.windowmanager.WindowManager_v2;

import org.gvsig.tools.swing.icontheme.IconTheme;

import org.gvsig.tools.util.LabeledValue;

import org.gvsig.tools.util.LabeledValueImpl;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class SearchConditionFieldController {

  private static final Logger LOGGER = LoggerFactory.getLogger(SearchConditionFieldController.class);

  private static class Field extends LabeledValueImpl<String> {

    FeatureAttributeDescriptor attrdesc;

    private final FeatureStore store;

    private final int presentationMode;

    private final boolean showStoreName;

    private final FeatureAttributeDescriptor[] path;

    public Field(FeatureAttributeDescriptor[] path, FeatureStore store, FeatureAttributeDescriptor attrdesc, int presentationMode) {

      this(path, store, attrdesc, presentationMode, false);

    }

    public Field(

            FeatureAttributeDescriptor[] path,

            FeatureStore store,

            FeatureAttributeDescriptor attrdesc,

            int presentationMode,

            boolean showStoreName

    ) {

      super(

              getAttributeDescriptorLabel(attrdesc, store.getName()),

              attrdesc.getName()

      );

      this.path = path;

      this.store = store;

      this.attrdesc = attrdesc;

      this.presentationMode = presentationMode;

      this.showStoreName = showStoreName;

    }

    public FeatureAttributeDescriptor[] getPath() {

      return this.path;

    }

    @Override

    public String getLabel() {

      String theLabel = getAttributeDescriptorLabel(attrdesc, showStoreName ? store.getName() : null);

      switch (this.presentationMode) {

        case Search.OrderedAttribute.TYPE_REGURAL:

          break;

        case Search.OrderedAttribute.TYPE_FAVORITE:

          theLabel = "<html><b>" + theLabel + "</b></html>";

          break;

        case Search.OrderedAttribute.TYPE_RECENT:

          theLabel = "<html><i><b>" + theLabel + "</b></i></html>";

          break;

      }

      return theLabel;

    }

    public FeatureAttributeDescriptor getParentDescriptor() {

      int l = this.path.length;

      if (l < 2) {

        return null;

      }

      return this.path[l - 2];

    }

    public FeatureAttributeDescriptor getDescriptor() {

      return this.attrdesc;

    }

    public FeatureStore getFeatureStore() {

      return this.store;

    }

  }

  private FeatureStore store;

  private final JLabel lblFields;

  private final JLabel lblExtraFields;

  private final JLabel lblLogicalOperators;

  private final JLabel lblRelationalOperators;

  private final JComboBox cboValue;

  private Object valueAssigned = null;

  private DropDown ddnFields;

  private DropDown ddnLogicalOperators;

  private DropDown ddnRelationalOperators;

  private LabeledValue[] relationalOperators;

  private LabeledValue[] logicalOperators;

  private final int SIZE_ORDERED_ATTRIBUTES = 20;

  private DatePickerController dateController = null;

  public SearchConditionFieldController(

          FeatureStore store,

          JLabel lblFields,

          JLabel lblExtraFields,

          JLabel lblRelationalOperators,

          JComboBox cboValue,

          JLabel lblLogicalOperators

  ) {

    this.store = store;

    this.lblFields = lblFields;

    this.lblExtraFields = lblExtraFields;

    this.lblRelationalOperators = lblRelationalOperators;

    this.cboValue = cboValue;

    this.lblLogicalOperators = lblLogicalOperators;

    this.initComponents();

  }

  public boolean isAValidRelationOperator(String name) {

    for (LabeledValue relationalOperator : relationalOperators) {

      if (StringUtils.equalsIgnoreCase(name, (CharSequence) relationalOperator.getValue())) {

        return true;

      }

    }

    return false;

  }

  private void initComponents() {

    try {

      I18nManager i18n = ToolsLocator.getI18nManager();

      ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

      relationalOperators = new LabeledValue[]{

        new LabeledValueImpl(i18n.getTranslation("_Equals_to"), ExpressionBuilder.OPERATOR_EQ),

        new LabeledValueImpl(i18n.getTranslation("_Like_to"), ExpressionBuilder.OPERATOR_ILIKE),

        new LabeledValueImpl(i18n.getTranslation("_Not_equals_to"), ExpressionBuilder.OPERATOR_NE),

        new LabeledValueImpl(i18n.getTranslation("_Greater_than"), ExpressionBuilder.OPERATOR_GT),

        new LabeledValueImpl(i18n.getTranslation("_Greater_or_equal_to"), ExpressionBuilder.OPERATOR_GE),

        new LabeledValueImpl(i18n.getTranslation("_Less_than"), ExpressionBuilder.OPERATOR_LT),

        new LabeledValueImpl(i18n.getTranslation("_Less_or_equal_to"), ExpressionBuilder.OPERATOR_LE)

      };

      logicalOperators = new LabeledValue[]{

        new LabeledValueImpl(i18n.getTranslation("_Or"), ExpressionBuilder.OPERATOR_OR),

        new LabeledValueImpl(i18n.getTranslation("_And"), ExpressionBuilder.OPERATOR_AND)

      };

      this.lblExtraFields.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

      this.ddnFields = toolsSwingManager.createDropDown(lblFields);

      this.ddnFields.setVisibleDropdownArrow(false);

      this.ddnRelationalOperators = toolsSwingManager.createDropDown(lblRelationalOperators);

      this.ddnRelationalOperators.setVisibleDropdownArrow(false);

      if (lblLogicalOperators != null) {

        this.ddnLogicalOperators = toolsSwingManager.createDropDown(lblLogicalOperators);

        this.ddnLogicalOperators.setVisibleDropdownArrow(false);

      }

      DefaultComboBoxModel modelRelationalOperators = new DefaultComboBoxModel();

      for (LabeledValue op : relationalOperators) {

        modelRelationalOperators.addElement(op);

      }

      this.ddnRelationalOperators.setModel(modelRelationalOperators);

      if (this.ddnLogicalOperators != null) {

        DefaultComboBoxModel modelLogicalOperators = new DefaultComboBoxModel();

        for (LabeledValue op : logicalOperators) {

          modelLogicalOperators.addElement(op);

        }

        this.ddnLogicalOperators.setModel(modelLogicalOperators);

      }

      FeatureType featureType = store.getDefaultFeatureType();

      Search search = (Search) ToolsLocator.getComplementsManager().get(

              Search.COMPLEMENT_MANE, featureType

      );

      List<Search.OrderedAttribute> orderedAttributes = search.getOrderedAttributes(

              Search.BASIC_TYPES_FILTER,

              Search.STR_INT_LONG_LABEL_ORDER,

              SIZE_ORDERED_ATTRIBUTES

      );

      List<ImageIcon> icons = new ArrayList<>();

//            DataTypesManager dataTypeManager = ToolsLocator.getDataTypesManager();

      IconTheme iconTheme = ToolsSwingLocator.getIconThemeManager().getCurrent();

      DefaultComboBoxModel model = new DefaultComboBoxModel();

      for (Search.OrderedAttribute attr : orderedAttributes) {

        FeatureAttributeDescriptor attrdesc = attr.getDescriptor();

        Field field = new Field(

                new FeatureAttributeDescriptor[]{attrdesc},

                this.store,

                attrdesc,

                attr.getType()

        );

        model.addElement(field);

        String iconName = attrdesc.getDataType().getIconName();

        if (iconTheme.exists(iconName)) {

          icons.add(iconTheme.get(iconName));

        } else {

          icons.add(null);

        }

      }

      this.ddnFields.setIcons(icons);

      this.ddnFields.setModel(model);

      this.ddnFields.addItemListener(new ItemListener() {

        @Override

        public void itemStateChanged(ItemEvent e) {

          if (e.getStateChange() == ItemEvent.SELECTED) {

            doUpdateValuesList();

          }

        }

      });

      this.lblExtraFields.addMouseListener(new MouseAdapter() {

        @Override

        public void mouseClicked(MouseEvent e) {

          doSelectMoreFields();

        }

      });

      clear();

    } catch (Exception ex) {

      throw new RuntimeException(ex);

    }

  }

  private FeatureType getFeatureType() {

    try {

      return this.store.getDefaultFeatureType();

    } catch (DataException ex) {

      return null;

    }

  }

  private void doSelectMoreFields() {

    DefaultFeatureAttributeSelectionPanel panel = new DefaultFeatureAttributeSelectionPanel(store);

    WindowManager_v2 winManager = (WindowManager_v2) ToolsSwingLocator.getWindowManager();

    final Dialog dialog = winManager.createDialog(

            panel,

            "Select attribute",

            null,

            WindowManager_v2.BUTTONS_OK_CANCEL

    );

    dialog.addActionListener((ActionEvent e) -> {

      if (dialog.getAction() == WindowManager_v2.BUTTONS_OK) {

        doAddAndSelect(

                panel.getSelectedStore(),

                panel.getSelectedAttributeDescriptor(),

                panel.getSelectedPath()

        );

      }

    });

    dialog.show(WindowManager.MODE.DIALOG);

  }

  private void doAddAndSelect(FeatureStore theStore, FeatureAttributeDescriptor attrdesc, FeatureAttributeDescriptor[] path) {

    DefaultComboBoxModel<Field> model = (DefaultComboBoxModel) this.ddnFields.getModel();

    for (int i = 0; i < model.getSize(); i++) {

      Field field = model.getElementAt(i);

      FeatureAttributeDescriptor attrdescN = field.getDescriptor();

      if (isTheSameStore(theStore, attrdescN.getStore())

              && StringUtils.equalsIgnoreCase(attrdesc.getName(), attrdescN.getName())) {

        this.setAttribute(i);

        return;

      }

    }

    Field field = new Field(

            path,

            theStore,

            attrdesc,

            Search.OrderedAttribute.TYPE_REGURAL,

            !isTheSameStore(store, theStore)

    );

    ThreadSafeDialogsManager dialogManager = ToolsSwingLocator.getThreadSafeDialogsManager();

    if (field.getPath().length > 2) {

      dialogManager.messageDialog(

              "It not supported to search through this field." + "\n"

              + "Too many links.",

              "_Warning",

              JOptionPane.WARNING_MESSAGE

      );

      return;

    }

    FeatureAttributeDescriptor parentDescriptor = field.getParentDescriptor();

    if( parentDescriptor!=null ) {

        switch (parentDescriptor.getRelationType()) {

          case DynField.RELATION_TYPE_AGGREGATE:

          case DynField.RELATION_TYPE_COMPOSITION:

            if (getForeingKeyName(field.getFeatureStore(), this.store) == null) {

              dialogManager.messageDialog(

                      "It not supported to search through this field." + "\n"

                      + "The link field was not found.",

                      "_Warning",

                      JOptionPane.WARNING_MESSAGE

              );

              return;

            }

            if (getPrimaryKeyName(this.store) == null) {

              dialogManager.messageDialog(

                      "It not supported to search through this field." + "\n"

                      + "A simple primary key was not found.",

                      "_Warning",

                      JOptionPane.WARNING_MESSAGE

              );

              return;

            }

        }

    }

    model.addElement(field);

    IconTheme iconTheme = ToolsSwingLocator.getIconThemeManager().getCurrent();

    this.ddnFields.getIcons().add(iconTheme.get(attrdesc.getDataType().getIconName()));

    this.setAttribute(model.getSize() - 1);

  }

  public void clear() {

    this.ddnRelationalOperators.setSelectedIndex(0);

    if (this.ddnLogicalOperators != null) {

      this.ddnLogicalOperators.setSelectedIndex(1);

    }

    this.cboValue.setSelectedIndex(-1);

  }

  private void doUpdateValuesList() {

    final Field field = (Field) this.ddnFields.getSelectedItem();

    if (field == null) {

      return;

    }

    FeatureAttributeDescriptor descriptor = field.getDescriptor();

    if( descriptor.getType()==DataTypes.DATE ) {

        if( this.dateController == null ) {

            this.dateController = ToolsSwingLocator.getToolsSwingManager().createDatePickerController(

                    (JTextComponent) this.cboValue.getEditor().getEditorComponent(), 

                    null

            );

        }

    } else {

        if( this.dateController != null ) {

            this.dateController.uninstall();

            this.dateController = null;

        }

    }

    final List<Object> values = new ArrayList<>();

    final int limit = 60;

    final long timeLimit = System.currentTimeMillis() + limit * 1000;

    final DefaultComboBoxModel model = new DefaultComboBoxModel();

    this.setEnabled(false);

    final FeatureStore theStore = field.getFeatureStore();

    final FeatureQuery query = theStore.createFeatureQuery();

    query.addAttributeName(field.getDescriptor().getName());

    query.setLimit(1000);

    Thread th = new Thread(new Runnable() {

      @Override

      public void run() {

        FeatureSet set = null;

        try {

          set = theStore.getFeatureSet(query);

          set.accept(new Visitor() {

            @Override

            public void visit(Object o) throws VisitCanceledException, BaseException {

              Object value = ((Feature) o).get(field.getDescriptor().getName());

              if (!values.contains(value)) {

                values.add(value);

              }

              if (System.currentTimeMillis() > timeLimit) {

                throw new VisitCanceledException();

              }

              if (values.size() > 1000) {

                throw new VisitCanceledException();

              }

            }

          });

        } catch (VisitCanceledException ex) {

        } catch (Exception ex) {

          LOGGER.warn("Can't update list of values of '" + field.getLabel() + "'.", ex);

        } finally {

            DisposeUtils.disposeQuietly(set);

        }

        List<LabeledValue> elements = new ArrayList<>();

        if (!values.isEmpty()) {

          LabeledValue[] availableValues = field.getDescriptor().getAvailableValues();

          Map<String, String> availableValuesMap = new HashMap<>();

          if (availableValues != null) {

            for (LabeledValue availableValue : availableValues) {

              availableValuesMap.put(

                      Objects.toString(availableValue.getValue()),

                      availableValue.getLabel()

              );

            }

          }

          elements.add(new LabeledValueImpl("", null));

          for (Object value : values) {

            String key = Objects.toString(value);

            String label = availableValuesMap.getOrDefault(key, key);

            elements.add(new LabeledValueImpl(label, value));

          }

          elements.sort(null);

        }

        for (LabeledValue element : elements) {

          model.addElement(element);

        }

        SwingUtilities.invokeLater(new Runnable() {

          @Override

          public void run() {

            cboValue.setModel(model);

            if (valueAssigned != null) {

              cboValue.setSelectedItem(valueAssigned);

              valueAssigned = null;

            }

            setEnabled(true);

          }

        });

      }

    });

    th.start();

  }

  public void setEnabled(boolean enabled) {

    this.ddnFields.setEnabled(enabled);

    if (this.ddnLogicalOperators != null) {

      this.ddnLogicalOperators.setEnabled(enabled);

    }

    this.ddnRelationalOperators.setEnabled(enabled);

    this.lblExtraFields.setEnabled(enabled);

  }

  public String getRelationalOperator() {

    LabeledValue<String> op = (LabeledValue) this.ddnRelationalOperators.getSelectedItem();

    if (op == null) {

      return null;

    }

    return op.getValue();

  }

  public int setRelationalOperator(String name) {

    int n = 0;

    for (LabeledValue relationalOperator : relationalOperators) {

      if (StringUtils.equalsIgnoreCase(name, (CharSequence) relationalOperator.getValue())) {

        break;

      }

      n++;

    }

    if (this.relationalOperators.length <= n) {

      return -1;

    }

    this.ddnRelationalOperators.setSelectedIndex(n);

    return n;

  }

  public String getLogicalOperator() {

    if (this.ddnLogicalOperators == null) {

      return null;

    }

    LabeledValue<String> rel = (LabeledValue) this.ddnLogicalOperators.getSelectedItem();

    if (rel == null) {

      return null;

    }

    return rel.getValue();

  }

  public void setLogicalOperator(String operator) {

    if (this.ddnLogicalOperators == null) {

      return;

    }

    ComboBoxModel model = this.ddnLogicalOperators.getModel();

    for (int i = 0; i < model.getSize(); i++) {

      LabeledValue modelValue = (LabeledValue) model.getElementAt(i);

      String value = (String) modelValue.getValue();

      if (StringUtils.equals(value, operator)) {

        this.ddnLogicalOperators.setSelectedIndex(i);

        break;

      }

    }

  }

  public Object getValue() {

    final Field field = (Field) this.ddnFields.getSelectedItem();

    if (field == null) {

      return null;

    }

    Object v;

    if( this.dateController==null ) {

        v = this.cboValue.getSelectedItem();

    } else {

        v = this.dateController.get();

    }

    if (v == null) {

      return null;

    }

    if (v instanceof LabeledValue) {

      v = ((LabeledValue) v).getValue();

      if (v == null) {

        return null;

      }

    }

    if (v instanceof CharSequence) {

      if (StringUtils.isBlank((CharSequence) v)) {

        return null;

      }

    }

    Coercion coercion = field.getDescriptor().getDataType().getCoercion();

    try {

      return coercion.coerce(v);

    } catch (CoercionException ex) {

      return null;

    }

  }

  public void setValue(Object value) {

    this.cboValue.setSelectedItem(value);

    this.valueAssigned = value;

  }

  private Field getCurrentField() {

    final Field field = (Field) this.ddnFields.getSelectedItem();

    return field;

  }

  public int setAttribute(String name) {

    ComboBoxModel<Field> model = this.ddnFields.getModel();

    for (int i = 0; i < model.getSize(); i++) {

      Field x = model.getElementAt(i);

      if (StringUtils.equalsIgnoreCase(name, x.getValue())) {

        this.setAttribute(i);

        return i;

      }

    }

    this.setAttribute(-1);

    return -1;

  }

  public void setAttribute(int index) {

    try {

      this.ddnFields.setSelectedIndex(index);

    } catch (Exception ex) {

      this.ddnFields.setSelectedIndex(-1);

    }

    doUpdateValuesList();

  }

  public int setAttributePath(String[][] pathNames) {

    // [[attributeName, storeName],...]

    try {

      if (pathNames.length == 1) {

        String[] path = pathNames[pathNames.length - 1];

        String name = path[0];

        int index = this.setAttribute(name);

        if (index == -1) {

          try {

            FeatureAttributeDescriptor attrDescriptor = store.getDefaultFeatureType().getAttributeDescriptor(name);

            FeatureAttributeDescriptor[] attributePath = new FeatureAttributeDescriptor[]{attrDescriptor};

            doAddAndSelect(store, store.getDefaultFeatureType().getAttributeDescriptor(name), attributePath);

          } catch (Exception ex) {

            LOGGER.warn("Not able to set single path into controller", ex);

            return -1;

          }

        }

        return index;

      } else {

        ComboBoxModel<Field> model = this.ddnFields.getModel();

        String[] singleArrayPathNameDescriptors = new String[pathNames.length];

        for (int i = 0; i < pathNames.length; i++) {

          singleArrayPathNameDescriptors[i] = pathNames[i][0];

        }

        // check the drop

        for (int i = 0; i < model.getSize(); i++) {

          Field x = model.getElementAt(i);

          String[] arrayDescriptors = new String[x.getPath().length];

          FeatureAttributeDescriptor[] path = x.getPath();

          for (int j = 0; j < path.length; j++) {

            arrayDescriptors[j] = path[j].getName();

          }

          if (Arrays.equals(singleArrayPathNameDescriptors, arrayDescriptors)) {

            this.setAttribute(i);

            return i;

          }

        }

        // if not, addit to the drop

        DataManager dataManager = DALLocator.getDataManager();

        String tableName = pathNames[pathNames.length - 1][1]; // del ultimo path, coger el nombre tabla

        FeatureStore theStore = (FeatureStore) dataManager.getStoresRepository().getStore(tableName);

        String attributeName = pathNames[pathNames.length - 1][0]; // del ultimo path, coger el nombre attribute

        if (theStore != null) {

          FeatureAttributeDescriptor attr;

          try {

            attr = theStore.getDefaultFeatureType().getAttributeDescriptor(attributeName);

            FeatureAttributeDescriptor[] attributePath = new FeatureAttributeDescriptor[2];

            String firstAttrName = pathNames[0][0];

            FeatureAttributeDescriptor firstAttr = store.getDefaultFeatureType().getAttributeDescriptor(firstAttrName);

            attributePath[0] = firstAttr;

            attributePath[1] = attr;

            doAddAndSelect(theStore, attr, attributePath);

            return SIZE_ORDERED_ATTRIBUTES - 1;

          } catch (Exception ex) {

            LOGGER.warn("Not able to set foreign path into controller", ex);

          }

        }

      }

    } catch (Exception ex) {

      LOGGER.warn("Controller not set.", ex);

    }

    this.setAttribute(-1);

    return -1;

  }

  private boolean isTheSameStore(DataStore store1, DataStore store2) {

    String store1FullName = store1.getFullName();

    String store2FullName = store2.getFullName();

    return StringUtils.equalsIgnoreCase(store1FullName, store2FullName);

  }

  private String getPrimaryKeyName(FeatureStore store) {

    try {

      FeatureAttributeDescriptor[] pk = store.getDefaultFeatureType().getPrimaryKey();

      if (pk == null || pk.length != 1) {

        return null;

      }

      return pk[0].getName();

    } catch (DataException ex) {

      return null;

    }

  }

  private String getForeingKeyName(FeatureStore store, FeatureStore foreingStore) {

    try {

      for (FeatureAttributeDescriptor descriptor : store.getDefaultFeatureType()) {

        if (descriptor.isForeingKey()) {

          ForeingKey foreingKey = descriptor.getForeingKey();

          if (isTheSameStore(foreingStore, foreingKey.getFeatureStore(null))) {

            return descriptor.getName();

          }

        }

      }

    } catch (DataException ex) {

      return null;

    }

    return null;

  }

  public boolean isValid(StringBuilder message) {

    Object value = this.getValue();

    if (value == null) {

      return true;

    }

    Field field = this.getCurrentField();

    if (field == null) {

      return true;

    }

    if (field.getPath().length > 2) {

      message.append("Invalid field '").append(field.getLabel()).append("'.\n");

      return false;

    }

    FeatureAttributeDescriptor descriptor = field.getDescriptor();

    switch (this.getRelationalOperator()) {

      case ExpressionBuilder.OPERATOR_EQ:

      case ExpressionBuilder.OPERATOR_NE:

      case ExpressionBuilder.OPERATOR_GT:

      case ExpressionBuilder.OPERATOR_GE:

      case ExpressionBuilder.OPERATOR_LT:

      case ExpressionBuilder.OPERATOR_LE:

        try {

        descriptor.getDataType().coerce(value);

      } catch (CoercionException ex) {

        message.append("Invalid value '")

                .append(Objects.toString(value))

                .append("' for field '")

                .append(descriptor.getLabel())

                .append("'.");

        message.append("\n");

        message.append(ex.getMessage());

        message.append("\n");

        return false;

      }

      break;

      default:

      case ExpressionBuilder.OPERATOR_ILIKE:

        break;

    }

    return true;

  }

  public ExpressionBuilder.Value getFilter() {

    ExpressionBuilder.Value filter = null;

    Object value = this.getValue();

    if (value == null) {

      return null;

    }

    Field field = this.getCurrentField();

    if (field == null) {

      return null;

    }

    if (field.getPath().length > 2) {

      // No soportado

      return null;

    }

    DataManager dataManager = DALLocator.getDataManager();

    DALExpressionBuilder builder = dataManager.createDALExpressionBuilder();

    FeatureAttributeDescriptor parentDescriptor = field.getParentDescriptor();

    FeatureAttributeDescriptor descriptor = field.getDescriptor();

    ExpressionBuilder.Constant value_constant = null;

    switch (this.getRelationalOperator()) {

      case ExpressionBuilder.OPERATOR_EQ:

      case ExpressionBuilder.OPERATOR_NE:

      case ExpressionBuilder.OPERATOR_GT:

      case ExpressionBuilder.OPERATOR_GE:

      case ExpressionBuilder.OPERATOR_LT:

      case ExpressionBuilder.OPERATOR_LE:

        try {

        value_constant = builder.expression().constant(

                descriptor.getDataType().coerce(value)

        );

      } catch (CoercionException ex) {

        return null;

      }

      break;

      default:

      case ExpressionBuilder.OPERATOR_ILIKE:

        value_constant = builder.expression().constant(value);

        break;

    }

    if (parentDescriptor == null) {

      // Se busca en campos de la misma tabla.

      filter = builder.expression().binaryOperator(

              this.getRelationalOperator(),

              builder.expression().column(this.store.getName(),descriptor.getName()),

              value_constant

      );

    } else {

      // Se busca en campos de una tabla relacionada.

      switch (parentDescriptor.getRelationType()) {

        case DynField.RELATION_TYPE_COLLABORATION:

        case DynField.RELATION_TYPE_IDENTITY:

          filter = builder.expression().binaryOperator(

                  this.getRelationalOperator(),

                  builder.foreing_value(

                          parentDescriptor.getName(),

                          descriptor.getName()

                  ),

                  value_constant

          );

          break;

        case DynField.RELATION_TYPE_AGGREGATE:

        case DynField.RELATION_TYPE_COMPOSITION:

          filter = builder.exists(builder.select()

                  .column(parentDescriptor.getFeatureType().getPrimaryKey()[0].getName())

                  .from(field.getFeatureStore().getName())

                  .limit(1)

                  .where(

                          builder.expression().and(

                                  builder.expression().eq(

                                          builder.expression().column(

                                                  field.getFeatureStore().getName(),

                                                  getForeingKeyName(field.getFeatureStore(), this.store)

                                          ),

                                          builder.expression().column(

                                                  this.store.getName(),

                                                  getPrimaryKeyName(this.store)

                                          )

                                  ),

                                  builder.expression().binaryOperator(

                                          this.getRelationalOperator(),

                                          builder.expression().column(

                                                  field.getFeatureStore().getName(),

                                                  descriptor.getName()

                                          ),

                                          value_constant

                                  )

                          )

                  )

                  .toValue()

          );

          break;

      }

    }

    return filter;

  }

  public JsonObject toJson() {

    JsonObjectBuilder fieldBuilder = Json.createObjectBuilder();

    JsonArrayBuilder arrayBuilder = Json.createArrayBuilder();

    for (FeatureAttributeDescriptor featureAttributeDescriptor : this.getCurrentField().getPath()) {

      JsonArrayBuilder pathArray = Json.createArrayBuilder();

      //first value: name field

      String fieldName = featureAttributeDescriptor.getName();

      pathArray.add(fieldName);

      //second value: name store

      String storeName = featureAttributeDescriptor.getFeatureType().getStore().getName();

      pathArray.add(storeName);

      arrayBuilder.add(pathArray.build());

    }

    String relational = this.getRelationalOperator();

    Object value = this.getValue();

    String strValue = DataTypeUtils.toString(value);

    String logical = this.getLogicalOperator();

    fieldBuilder.add("fieldPath", arrayBuilder.build());

    fieldBuilder.add("relational", relational);

    if (!StringUtils.isEmpty(strValue)) {

      fieldBuilder.add("strValue", strValue);

    }

    if (!StringUtils.isEmpty(logical)) {

      fieldBuilder.add("logical", logical);

    }

    return fieldBuilder.build();

  }

  public void fromJson(JsonObject jsonState) {

    if (jsonState == null) {

      return;

    }

    JsonArray fieldPath = jsonState.getJsonArray("fieldPath");

    // array of arrays

    String[][] arrayNew = new String[fieldPath.size()][2];

    for (int i = 0; i < fieldPath.size(); i++) {

      String[] arrayField = new String[2];

      arrayField[0] = fieldPath.getJsonArray(i).getString(0);

      arrayField[1] = fieldPath.getJsonArray(i).getString(1);

      arrayNew[i] = arrayField;

    }

    this.setAttributePath(arrayNew);  //usar el doAddAndSelect

    String relational = jsonState.getString("relational");

    this.setRelationalOperator(relational);

    if (jsonState.containsKey("strValue")) {

      String strValue = jsonState.getString("strValue");

      this.setValue(strValue);

    }

    if (jsonState.containsKey("logical")) {

      String logical = jsonState.getString("logical");

      this.setLogicalOperator(logical);

    }

  }

}