Application: gvSIG desktop

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

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

import java.io.ByteArrayInputStream;

import java.io.InputStream;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import javax.json.Json;

import javax.json.JsonObject;

import javax.json.JsonReader;

import org.apache.commons.collections4.MapUtils;

import org.gvsig.expressionevaluator.Expression;

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

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

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

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

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.swing.searchpanel.SearchParameters;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

 *

 * @author jjdelcerro

 */

public class DefaultSearchParameters implements SearchParameters, Cloneable {

    private List<String> resultColumnNames;

    private FeatureQuery query;

    private String name;

    private Map<String, JsonObject> values;

    private int searchMode;

    public DefaultSearchParameters() {

        this.resultColumnNames = new ArrayList<>();

        this.query = null;

        this.values = new HashMap<>();

        this.searchMode = DefaultSearchPanel.PANEL_SIMPLIFIED;

    }

    @Override

    public List<String> getResultColumnNames() {

        return this.resultColumnNames;

    }

    public List<String> getGroupByColumns() {

        return this.query.getGroupByColumns();

    }

    public Map<String, String> getAggregateFunctions() {

        return this.query.getAggregateFunctions();

    }

    public void setQuery(FeatureQuery query) {

        this.query = query;

    }

    public void setFilter(Expression exp) {

        this.query.setFilter(exp);

    }

    public FeatureQuery getQuery() {

        return this.query;

    }

    void setResultColumnNames(List<String> selectedNames) {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public Map<String, JsonObject> getValues() {

        return this.values;

    }

    public static void registerPersistence() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if (manager.getDefinition("SearchParameters") == null) {

            DynStruct definition = manager.addDefinition(DefaultSearchParameters.class,

                    "DefaultSearchParameters", "DefaultSearchParameters persistence definition", null, null);

            definition.addDynFieldList("resultColumnNames").setClassOfItems(String.class);

            definition.addDynFieldMap("values").setClassOfItems(String.class);

            definition.addDynFieldObject("query").setClassOfValue(FeatureQuery.class).setMandatory(false);

            definition.addDynFieldString("name").setClassOfValue(String.class);

            definition.addDynFieldInt("searchMode").setClassOfValue(Integer.class);

        }

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set("resultColumnNames", this.resultColumnNames);

        HashMap<String, String> valuesMap = new HashMap<>();

        for (String key : this.values.keySet()) {

            JsonObject value = this.values.get(key);

            valuesMap.put(key, value.toString());

        }

        state.set("values", valuesMap);

        state.set("query", this.query);

        state.set("name", this.name);

        state.set("searchMode", this.searchMode);

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        this.resultColumnNames = new ArrayList<>(state.getList("resultColumnNames"));

        Map<String, String> valuesState = state.getMap("values");

        HashMap<String, JsonObject> valuesMap = new HashMap<>();

        for (String key : valuesState.keySet()) {

            String value = valuesState.get(key);

            InputStream targetStream = new ByteArrayInputStream(value.getBytes());

            JsonReader reader = Json.createReader(targetStream);

            JsonObject jsonObject = reader.readObject();

            valuesMap.put(key, jsonObject);

        }

        this.values = valuesMap;

        this.query = (FeatureQuery) state.get("query");

        this.name = state.getString("name");

        try {

            this.searchMode = state.getInt("searchMode");

        } catch(Exception ex) {

            this.searchMode = DefaultSearchPanel.PANEL_SIMPLIFIED;

        }

    }

    @Override

    public String toString() {

        if (this.query != null) { // && this.query.getExpressionFilter() != null) {

            try {

                StringBuilder builder = new StringBuilder();

                if (this.query.getExpressionFilter() != null) {

                    builder.append(this.query.getExpressionFilter().getPhrase());

                }

                boolean has = true;

                for (EditableFeatureAttributeDescriptor col : this.query.getExtraColumn().getColumns()) {

                    if (has) {

                        builder.append("\n\n");

                        builder.append("ExtraColumn: ");

                        has=false;

                    } else {

                        builder.append(", ");

                    }

                    builder.append(col.getName());

                }

                has = true;

                for (String attributeName : this.getResultColumnNames()) {

                    if (has) {

                        builder.append("\n\n");

                        builder.append("ShowFields: ");

                        has=false;

                    } else {

                        builder.append(", ");

                    }

                    builder.append(attributeName);

                }

                has = true;

                for (String groupByColumn : this.getGroupByColumns()) {

                    if (has) {

                        builder.append("\n\n");

                        builder.append("GroupBy: ");

                        has=false;

                    } else {

                        builder.append(", ");

                    }

                    builder.append(groupByColumn);

                }

                has = true;

                for (String key : this.getAggregateFunctions().keySet()) {

                    if (has) {

                        builder.append("\n\n");

                        builder.append("AggregateFunctions: ");

                        has=false;

                    } else {

                        builder.append(", ");

                    }

                    builder.append(key);

                }

                has = true;

                for (FeatureQueryOrder.FeatureQueryOrderMember member : this.query.getOrder().members()) {

                    if (has) {

                        builder.append("\n\n");

                        builder.append("Order: ");

                        has=false;

                    } else {

                        builder.append(", ");

                    }

                    builder.append(member.getAttributeName());

                    builder.append("(");

                    builder.append(member.getAscending());

                    builder.append(")");

                }

                return builder.toString();

            } catch (Exception ex) {

                return this.getName();

            }

        } else {

            return this.getName();

        }

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

        DefaultSearchParameters clone = (DefaultSearchParameters) super.clone();

        clone.query = this.query.getCopy();

        clone.resultColumnNames = new ArrayList(this.resultColumnNames);

        HashMap<String, JsonObject> cloneValues = new HashMap<>(this.values);

        clone.values = cloneValues;

        return clone;

    }

    public DefaultSearchParameters getCopy() {

        try {

            return (DefaultSearchParameters) this.clone();

        } catch (CloneNotSupportedException ex) {

            return null;

        }

    }

    @Override

    public void copyFrom(SearchParameters params) {

        this.resultColumnNames = params.getResultColumnNames();

        this.query = params.getQuery().getCopy();

        this.name = params.getName();

        this.values = params.getValues();

    }

    @Override

    public String getName() {

        return this.name;

    }

    @Override

    public void setName(String name) {

        this.name = name;

    }

    @Override

    public FeatureType getFeatureType(FeatureStore store) {

        FeatureSet fset = null;

        try {

            fset = store.getFeatureSet(this.query);

            FeatureType ft = fset.getDefaultFeatureType();

            return ft;

        } catch (DataException ex) {

            return store.getDefaultFeatureTypeQuietly();

        } finally {

            DisposeUtils.disposeQuietly(fset);

        }

    }

    public int getSearchMode()  {

        return this.searchMode;

    }

    public void setSearchMode(int searchMode) {

        this.searchMode = searchMode;

    }

    void fix(FeatureType featureType) {

        List<String> toRemoveAggregateColumns = new ArrayList<>();

        Map<String, String> aggregateFunctions = this.query.getAggregateFunctions();

        for (Map.Entry<String, String> aggregate : aggregateFunctions.entrySet()) {

            String colname = aggregate.getKey();

            String funcname = aggregate.getValue();

            if( this.query.getExtraColumn().get(colname)==null && featureType.get(colname)==null ) {

                toRemoveAggregateColumns.add(colname);

            }

        }

        for (String toRemoveAggregateColumn : toRemoveAggregateColumns) {

            this.query.removeAggregateFunction(toRemoveAggregateColumn);

        }

        if( this.query.getLimit()==0 ) {

            // Esto es por compatibilidad con querys guardados con antelacion

            // al cambio para hacer valido el limit 0.

            this.query.clearLimit();

        }

    }

}