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.io.File;

import java.util.Collection;

import java.util.HashMap;

import java.util.Map;

import java.util.Objects;

import java.util.UUID;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

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

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

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

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.store.jdbc.JDBCNewStoreParameters;

import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorer;

import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorerParameters;

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.folders.FoldersManager;

import org.gvsig.tools.util.HasAFile;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jovivas

 */

public class DistinctOn extends AbstractSearchPostProcess{

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

    public DistinctOn (

        SearchPostProcessFactory factory,

        FeatureStore input,

        FeatureQuery query,

        DynObject parameters

    ){

        super( factory, input, query, parameters);

    }

    @Override

    public  SearchPostProcessResult execute (FeatureStore inputStore, FeatureQuery query, DynObject parameters){  

        String uniqueFieldName;

        uniqueFieldName = (String) parameters.getDynValue("field");

        try {

            // crear ruta de archivo temporal

            FoldersManager foldersManager = ToolsLocator.getFoldersManager();

            File tempFile = foldersManager.getUniqueTemporaryFile("distinctOn_process_"+ UUID.randomUUID().toString());

            // crear SERVER STORE

            DataManager dataManager = DALLocator.getDataManager();

            JDBCServerExplorerParameters serverParameters = (JDBCServerExplorerParameters) dataManager.createServerExplorerParameters("H2Spatial");

            ((HasAFile) serverParameters).setFile(tempFile);

            JDBCServerExplorer serverExplorer = (JDBCServerExplorer) dataManager.openServerExplorer("H2Spatial",serverParameters);

            //Crear tablas en server store

            JDBCNewStoreParameters parametersResults = serverExplorer.getAddParameters();

            parametersResults.setDynValue("Table", "results");

            FeatureType ft_inputStore = inputStore.getDefaultFeatureType();

            EditableFeatureType ft_inputStoreNoContainer = dataManager.createFeatureType();

            ft_inputStoreNoContainer.addAll(ft_inputStore);

            for (FeatureAttributeDescriptor attr : ft_inputStore) {

                DataType dataType = attr.getDataType();

                EditableFeatureAttributeDescriptor eattr = ft_inputStoreNoContainer.getEditableAttributeDescriptor(attr.getName());

                if (dataType.isContainer()){

                    ft_inputStoreNoContainer.remove(attr.getName());

                } 

                if (eattr.isComputed()){

                    eattr.setFeatureAttributeEmulator((FeatureAttributeEmulator) null);  

                }    

                if (eattr.isPrimaryKey()){

                    eattr.setIsPrimaryKey(false); 

                }

                if (eattr.allowIndexDuplicateds()){

                    eattr.setAllowIndexDuplicateds(true);

                }                  

            }

            Map<String, EditableFeatureAttributeDescriptor> allExtraColumns = new HashMap<>();

            for (EditableFeatureAttributeDescriptor column : ft_inputStore.getExtraColumns().getColumns()) {

                allExtraColumns.put(column.getName(), column);

            }

            for (EditableFeatureAttributeDescriptor column : query.getExtraColumn().getColumns()) {

                allExtraColumns.put(column.getName(), column);

            }

            if (allExtraColumns.size()>0) {

                for (EditableFeatureAttributeDescriptor column : allExtraColumns.values()) {

                    DataType dataType = column.getDataType();

                    if (!dataType.isContainer()){

                        ft_inputStoreNoContainer.add(column.getName(), column.getType(), column.getSize());

                    } 

                }

            }

            parametersResults.setDefaultFeatureType(ft_inputStoreNoContainer);     

            serverExplorer.add("H2Spatial", parametersResults, true);

            DataStoreParameters storeParametersResults = dataManager.createStoreParameters("H2Spatial");

            storeParametersResults.setDynValue("database_file",tempFile);

            storeParametersResults.setDynValue("Table","results");

            //Creaci?n del store con los resultados

            FeatureStore storeResults = (FeatureStore) dataManager.openStore("H2Spatial",storeParametersResults);

            // Creaci?n del Map con las funciones de agragado

            Map <String, AggregateOperation> aggregates = new HashMap <>();

            for (FeatureAttributeDescriptor attr : ft_inputStoreNoContainer) {

                if (parameters.hasDynValue(attr.getName())){

                    String operation = (String) parameters.getDynValue(attr.getName());

                    aggregates.put(

                            attr.getName(),

                            (AggregateOperation) aggregatesOperationFactories.get(operation).create()

                    );

                }                 

            }

            // distictOn

            storeResults.edit(FeatureStore.MODE_APPEND);

            FeatureSet features;

            if (query != null){

                features = inputStore.getFeatureSet(query);

            }else{

                features = inputStore.getFeatureSet();

            }

            EditableFeature lastFeature = null; 

            for (Feature feature : features) {

                if (lastFeature == null){

                    lastFeature=storeResults.createNewFeature(feature);

                    for (Map.Entry<String, AggregateOperation> entry : aggregates.entrySet()) {

                        String name = entry.getKey();

                        AggregateOperation operation = entry.getValue();

                        operation.reset();

                        Object value = feature.get(name);

                        if (operation.isApplicable(value)){

                            operation.perform(value);

                        }

                        lastFeature.set(name, operation.getValue()); 

                    }

                }

                if ( Objects.equals(feature.get(uniqueFieldName), lastFeature.get(uniqueFieldName))){

                    for (Map.Entry<String, AggregateOperation> entry : aggregates.entrySet()) {

                        String name = entry.getKey();

                        AggregateOperation operation = entry.getValue();

                        Object value = feature.get(name);

                        if (operation.isApplicable(value)){

                            operation.perform(value);

                        }

                        lastFeature.set(name, operation.getValue()); 

                    }

                }else{

                    storeResults.insert(lastFeature);

                    lastFeature = null; 

                }

            }

            storeResults.insert(lastFeature);

            storeResults.finishEditing();

//            storeUValues.finishEditing();

            SearchPostProcessResult searchPostProcessResult = new DefaultSearchPostProcessResult(storeResults,null);

            return searchPostProcessResult;

        } catch (DataException | ValidateDataParametersException ex) {

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

        }

        return null;

    }

    private static Map<String, AggregateOperationFactory> aggregatesOperationFactories = new HashMap<>();

    public static void registerAggregateOperation(AggregateOperationFactory aggregateOperationFactory){

        aggregatesOperationFactories.put(aggregateOperationFactory.getName(), aggregateOperationFactory);

    }

    public static Collection<AggregateOperationFactory> getAggregatesOperationFactories(){

        return aggregatesOperationFactories.values();

    }

}