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.searchPostProcess.distinctOn;

import java.util.ArrayList;

import java.util.List;

import java.util.UUID;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionUtils;

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.swing.DALSwingLocator;

import org.gvsig.fmap.dal.swing.DataSwingManager;

import org.gvsig.fmap.dal.swing.impl.searchPostProcess.distinctOn.AggregateOperation.AggregateOperationFactory;

import org.gvsig.fmap.dal.swing.impl.searchPostProcess.distinctOn.FirstAggregateOperation.FirstAggregateOperationFactory;

import org.gvsig.fmap.dal.swing.searchPostProcess.AbstractSearchPostProcessFactory;

import org.gvsig.fmap.dal.swing.searchPostProcess.SearchPostProcess;

import org.gvsig.fmap.dal.swing.searchPostProcess.SearchPostProcessFactory;

import org.gvsig.fmap.dal.swing.searchpanel.SearchParameters;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dynform.spi.DynFormSPIManager;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynClass_v2;

import org.gvsig.tools.dynobject.DynField_v2;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.dynobject.DynObjectValueItem;

import org.gvsig.tools.i18n.I18nManager;

import org.slf4j.LoggerFactory;

/**

 * i

 *

 * @author jovivas

 */

public class DistinctOnFactory extends AbstractSearchPostProcessFactory {

    private static final org.slf4j.Logger LOGGER = LoggerFactory.getLogger(DistinctOnFactory.class);

    public static final String NAME = "DistinctOn";

    public static final String LABEL = "DistinctOn";

    public static final String DESCRIPTION = "DistinctOn_description";

    public DistinctOnFactory() {

        super(

                NAME,

                LABEL,

                DESCRIPTION,

                null,

                null

        );

    }

    @Override

    public SearchPostProcess createProcess(SearchPostProcessFactory factory, FeatureStore input, FeatureQuery query, DynObject parameters) {

        SearchPostProcess process = new DistinctOn(this, input, query, parameters);

        return process;

    }

    @Override

    public boolean hasProcessParameters() {

        return true;

    }

    @Override

    public DynObject createProcessParameters(FeatureStore input, FeatureQuery query, SearchParameters searchParams) {

        I18nManager i18n = ToolsLocator.getI18nManager();

        DynObjectManager dynObjectManager = ToolsLocator.getDynObjectManager();

        DynClass_v2 dynClass = (DynClass_v2) dynObjectManager.createDynClass("distinctOn " + input.getName() +"_"+ UUID.randomUUID().toString(), null); 

        DynField_v2 dynField = (DynField_v2) dynClass.addDynFieldString("field");

        dynField.setLabel(i18n.getTranslation("_Distinct_on_field"));

        dynField.setDescription("");

        dynField.setGroup(i18n.getTranslation("_Field_to_group_by_unique_values"));

        dynField.setOrder(1);

        String operation = null;

        FeatureType ft = input.getDefaultFeatureTypeQuietly();

        List<DynObjectValueItem> attrs = getAtributeNames(input);

        if (query.getExtraColumn().size()>0) {

//        if (searchParams.getResultColumnNames().size()>0) {

////            DynObjectValueItem[] attrs = new DynObjectValueItem[size];

////            List<DynObjectValueItem> attrs = new ArrayList<DynObjectValueItem>();

            FeatureExtraColumns extraColumns = query.getExtraColumn();

//            int newSize = attrs.length+query.getExtraColumn().size();

//            DynObjectValueItem[] newAttrs = new DynObjectValueItem[newSize];

//            int j = 0;

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

//                newAttrs[i]=attrs[i];

//            }

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

                EditableFeatureAttributeDescriptor attr = extraColumns.get(i);

                DataType dataType = attr.getDataType();

                if (!dataType.isContainer()){

                    attrs.add( new DynObjectValueItem(attr.getName(), attr.getLabel()));

                } 

            }

//            for ( EditableFeatureAttributeDescriptor attr : query.getExtraColumn()) {

//                if (query.getExtraColumn().get(attrName) != null) {

//                    DynObjectValueItem attr = new DynObjectValueItem(query.getExtraColumn().get(attrName), query.getExtraColumn().get(attrName).toJson().getString(label));

//                    try{

//                        attrs.add(attr);

//                    }catch (Exception ex) {

//                        LOGGER.warn("Can't add "+ attr.toString(), ex);

//                    }

//                }

//            }

            dynField.setAvailableValues(attrs.toArray(new DynObjectValueItem[attrs.size()]));

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

                fillParameters( (String) attrs.get(i).getValue(), operation, dynClass, dynField, searchParams, i, ft, extraColumns);

            }

//            for (String attrName : query.getAttributeNames()) {

//                if (ft.get(attrName) != null) {

//                    FeatureAttributeDescriptor attr = (FeatureAttributeDescriptor) ft.get(attrName);

//                    fillParameters(attr, firstOperation, dynClass, dynField);

//                } else if (query.getExtraColumn().get(attrName) != null) {

//                    FeatureAttributeDescriptor attr = query.getExtraColumn().get(attrName);

//                    fillParameters(attr, firstOperation, dynClass, dynField);

//                }

//            }

        } else {

            dynField.setAvailableValues(attrs);

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

//            }

//            for (FeatureAttributeDescriptor attr : input.getDefaultFeatureTypeQuietly()) {

                fillParameters( (String) attrs.get(i).getValue(), operation, dynClass, dynField, searchParams, i, ft, null);

            }

        }

        dynClass.getTags().set(DynFormSPIManager.TAG_DYNFORM_HEIGHT, 250);

        dynClass.getTags().set(DynFormSPIManager.TAG_DYNFORM_WIDTH, 350);

        DynObject params = dynObjectManager.createDynObject(dynClass);

        return params;

    }

    private void fillParameters(String attr,

            String operation,

            DynClass_v2 dynClass,

            DynField_v2 dynField,

            SearchParameters searchParams,

            int n,

            FeatureType ft,

            FeatureExtraColumns extraColumns

            ) {

        I18nManager i18n = ToolsLocator.getI18nManager();

        // dynField = (DynField_v2) dynClass.addDynFieldString(attr.getName());

        for (FeatureAttributeDescriptor featureAttributeDescriptor : ft) {

            if (StringUtils.equals(featureAttributeDescriptor.getName(), attr)) {

                Class attrClass = featureAttributeDescriptor.getDataType().getDefaultClass();

                List<DynObjectValueItem> availableOperations = fillAggregateOperations (attrClass);

                String newOperation = getOperation(attrClass, operation);

                if (availableOperations.size() > 0) {

                    if(searchParams.getResultColumnNames().contains(attr)){

                        dynField = (DynField_v2) dynClass.addDynFieldString(attr);

                        dynField.setAvailableValues(availableOperations);

                        dynField.setDefaultFieldValue(newOperation);

                        dynField.setGroup(i18n.getTranslation("_Visible_columns"));

                        dynField.setOrder(2000+n);

                    } else {

                        dynField = (DynField_v2) dynClass.addDynFieldString(attr);

                        dynField.setAvailableValues(availableOperations);

                        dynField.setDefaultFieldValue(newOperation);

                        dynField.setGroup(i18n.getTranslation("_Hidden_columns"));

                        dynField.setOrder(3000+n);

                    }

                }

            }   

        }

        if (extraColumns != null){

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

                if (StringUtils.equals(extraColumns.get(i).getName(), attr)) {

                    Class attrClass = ((FeatureAttributeDescriptor) extraColumns.get(i)).getDataType().getDefaultClass();;

                    List<DynObjectValueItem> availableOperations = fillAggregateOperations (attrClass);

                    String newOperation = getOperation(attrClass, operation);

                    if (availableOperations.size() > 0) {

                        if(searchParams.getResultColumnNames().contains(attr)){

                            dynField = (DynField_v2) dynClass.addDynFieldString(attr);

                            dynField.setAvailableValues(availableOperations);

                            dynField.setDefaultFieldValue(newOperation);

                            dynField.setGroup(i18n.getTranslation("_Visible_columns"));

                            dynField.setOrder(2000+n);

                        } else {

                            dynField = (DynField_v2) dynClass.addDynFieldString(attr);

                            dynField.setAvailableValues(availableOperations);

                            dynField.setDefaultFieldValue(newOperation);

                            dynField.setGroup(i18n.getTranslation("_Hidden_columns"));

                            dynField.setOrder(3000+n);

                        }

                    }

                }            

            }

        }

//        List<DynObjectValueItem> availableOperations = new ArrayList<>();

//        for (AggregateOperationFactory factory : DistinctOn.getAggregatesOperationFactories()) {

//            if (factory == null) {

//                continue;

//            }

//            if (Comparable.class.isAssignableFrom((Class<?>) attrClass)){

//                if (operation == null && factory instanceof FirstAggregateOperationFactory) {

//                    operation = factory.getName();

//                }

//            } else {

//                if (operation == null && factory instanceof NothingAggregateOperationFactory) {

//                    operation = factory.getName();

//                }

//            }

////            if (firstOperation == null && factory instanceof FirstAggregateOperationFactory) {

////                firstOperation = factory.getName();

////            }

//            if (factory.isApplicable(attrClass)) {

//                availableOperations.add(new DynObjectValueItem(

//                        factory.getName(),

//                        i18n.getTranslation("_" + StringUtils.replaceChars(factory.getName(), ' ', '_'))

//                ));

//            }

//        }

    }

    private List<DynObjectValueItem>  fillAggregateOperations (Class attrClass){

        I18nManager i18n = ToolsLocator.getI18nManager();

        List<DynObjectValueItem> availableOperations = new ArrayList<>();

        for (AggregateOperationFactory factory : DistinctOn.getAggregatesOperationFactories()) {

            if (factory == null) {

                continue;

            }

//            if (Comparable.class.isAssignableFrom((Class<?>) attrClass)){

//                if (operation == null && factory instanceof FirstAggregateOperationFactory) {

//                    operation = factory.getName();

//                }

//            } else {

//                if (operation == null && factory instanceof NothingAggregateOperationFactory) {

//                    operation = factory.getName();

//                }

//            }

            if (factory.isApplicable(attrClass)) {

                availableOperations.add(new DynObjectValueItem(

                        factory.getName(),

                        i18n.getTranslation("_" + StringUtils.replaceChars(factory.getName(), ' ', '_'))

                ));

            }

        } 

        return availableOperations;

    }

    private String getOperation (Class attrClass,String operation){

        for (AggregateOperationFactory factory : DistinctOn.getAggregatesOperationFactories()) {

            if (factory == null) {

                continue;

            }

            if (Comparable.class.isAssignableFrom((Class<?>) attrClass)){

                if (operation == null && factory instanceof FirstAggregateOperationFactory) {

                    operation = factory.getName();

                }

            }

        } 

        return operation;

    }

    public static void selfRegister() {

        try {

            DataSwingManager manager = DALSwingLocator.getDataSwingManager();

            manager.registerSearchPostProcess(new DistinctOnFactory());

        } catch (Exception ex) {

            LOGGER.warn("Can't register distinct on search post process.", ex);

        }

    }

    private List<DynObjectValueItem> getAtributeNames(FeatureStore input) {

        FeatureType ft = input.getDefaultFeatureTypeQuietly();

        List<DynObjectValueItem> values = new ArrayList();

        for (FeatureAttributeDescriptor attr : ft) {

            DataType dataType = attr.getDataType();

            if (!dataType.isContainer()){

                values.add( new DynObjectValueItem(attr.getName(), attr.getLabel()));

            }               

        }

//        return values.toArray(new DynObjectValueItem[values.size()]);

        return values;

    }

}