Application: gvSIG desktop

package org.gvsig.app.project.documents.view.dalactions;

import java.awt.event.ActionEvent;

import java.io.File;

import java.util.HashMap;

import java.util.Map;

import java.util.UUID;

import javax.swing.AbstractAction;

import javax.swing.Action;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

import org.gvsig.app.project.documents.Document;

import org.gvsig.app.project.documents.view.ViewDocument;

import org.gvsig.app.project.documents.view.gui.IView;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataTypes;

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.jdbc2.JDBCServerExplorer;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.dal.swing.DALActionFactory.DALActionContext;

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

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

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.layers.FLayer;

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

import org.gvsig.fmap.mapcontext.rendering.legend.ILegend;

import org.gvsig.fmap.mapcontext.rendering.legend.IVectorLegend;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.folders.FoldersManager;

import org.gvsig.tools.namestranslator.NamesTranslator;

import org.gvsig.tools.util.HasAFile;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class CreateTemporalLayerAction

        extends AbstractAction {

        public static class CreateTemporalLayerActionFactory extends AbstractDALActionFactory {

                public static final String ACTION_NAME = "CreateTemporalLayerAction";

                public CreateTemporalLayerActionFactory() {

                        super(ACTION_NAME);

                }

                @Override

                public Action createAction(DALActionContext context) {

                        return new CreateTemporalLayerAction(context);

                }

                public static void selfRegister() {

                        DataSwingManager dalSwingManager = DALSwingLocator.getSwingManager();

                        dalSwingManager.registerStoreAction(new CreateTemporalLayerAction.CreateTemporalLayerActionFactory());

                }

        }

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

        private final DALActionContext context;

        public CreateTemporalLayerAction(DALActionContext context) {

                this.context = context;

                I18nManager i18n = ToolsLocator.getI18nManager();

                this.putValue(

                        Action.ACTION_COMMAND_KEY,

                        CreateTemporalLayerActionFactory.ACTION_NAME

                );

                this.putValue(

                        Action.SHORT_DESCRIPTION,

                        i18n.getTranslation("_Create_layer_filtered")

                );

                this.putValue(

                        Action.SMALL_ICON,

                        ToolsSwingLocator.getIconThemeManager().getCurrent().get("view-layer-add")

                );

        }

        private FeatureStore createTemporaryH2Store(String name, FeatureType ft_sourceStore, FeatureQuery query) throws Exception {

                FoldersManager foldersManager = ToolsLocator.getFoldersManager();

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

                // crear SERVER STORE

                DataManager dataManager = DALLocator.getDataManager();

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

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

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

                //Crear tablas en server store

                JDBCNewStoreParameters newParametersTarget = serverExplorer.getAddParameters();

                newParametersTarget.setDynValue("Table", name);

                EditableFeatureType ft_targetStore = dataManager.createFeatureType();

                ft_targetStore.addAll(ft_sourceStore);

                boolean ignoreDefaultGeometry = false;

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

                        if (column.getType() == DataTypes.GEOMETRY) {

                                ignoreDefaultGeometry = true;

                        }

                }

                for (FeatureAttributeDescriptor attr : ft_sourceStore) {

                        DataType dataType = attr.getDataType();

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

                        if (dataType.isContainer()) {

                                ft_targetStore.remove(attr.getName());

                                continue;

                        }

                        if (dataType.getType() == DataTypes.GEOMETRY && ignoreDefaultGeometry) {

                                ft_targetStore.remove(attr.getName());

                                continue;

                        }

                        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_sourceStore.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()) {

                                        EditableFeatureAttributeDescriptor attr;

//                                        if (column.getType() == DataTypes.GEOMETRY) {

//                                                attr = ft_targetStore.add(column.getName(), DataTypes.GEOMETRY);

//                                                //attr.setGeometryType(column.getGeomType().getType(), column.getGeomType().getSubType());

//                                        } else {

//                                                attr = ft_targetStore.add(column.getName(), column.getType(), column.getSize());

//                                        }

                                        attr = ft_targetStore.add(column.getName(), column.getType());

                                        attr.copyFrom(column);

                                        attr.setFeatureAttributeEmulator((Expression)null);

                                }

                        }

                }

                NamesTranslator tr = NamesTranslator.createBaseTranslator();

                for (FeatureAttributeDescriptor attr : ft_targetStore) {

                        tr.addSource(attr.getName());

                }

                String suggestedPk = tr.getSuggestion("ID");

                EditableFeatureAttributeDescriptor pkAttr = ft_targetStore.add(suggestedPk, DataTypes.LONG);

                pkAttr.setIsPrimaryKey(true);

                newParametersTarget.setDefaultFeatureType(ft_targetStore);

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

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

                openParametersTarget.setDynValue("database_file", tempFile);

                openParametersTarget.setDynValue("Table", name);

                //Creaci?n del store con los resultados

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

                return storeResults;

        }

        private FLyrVect getFLyrVect(FeatureStore store) {

                ApplicationManager aplication = ApplicationLocator.getApplicationManager();

                FLayer layer = aplication.getCurrentLayer();

                if (layer instanceof FLyrVect && ((FLyrVect) layer).getFeatureStore() == store) {

                        return (FLyrVect) layer;

                }

                ViewDocument viewDoc = (ViewDocument) aplication.getActiveDocument(ViewDocument.class);

                if (viewDoc == null) {

                        return null;

                }

                for (FLayer layer1 : viewDoc.getMapContext().getLayers().getLayers(null)) {

                        if (layer1 instanceof FLyrVect && ((FLyrVect) layer1).getFeatureStore() == store) {

                                return (FLyrVect) layer1;

                        }

                }

                return null;

        }

        @Override

        public void actionPerformed(ActionEvent e) {

                FeatureStore featureStore = null;

                FeatureStore targetStore = null;

                FeatureSet fs = null;

                ApplicationManager aplication = ApplicationLocator.getApplicationManager();

                try {

                        Document viewDoc = aplication.getActiveDocument(ViewDocument.class);

                        if (viewDoc == null) {

                                //msgbox

                                return;

                        }

                        DataStore store = this.context.getStore();

                        if (!(store instanceof FeatureStore)) {

                                return;

                        }

                        featureStore = (FeatureStore) store;

                        FeatureQuery query = this.context.getQuery();

                        targetStore = createTemporaryH2Store(featureStore.getName() + "_filtered", featureStore.getDefaultFeatureTypeQuietly(), query);

                        fs = featureStore.getFeatureSet(query);

                        targetStore.edit(FeatureStore.MODE_APPEND);

                        long n = 0;

                        String pkName = targetStore.getDefaultFeatureTypeQuietly().getPrimaryKey()[0].getName();

                        for (Feature f : fs) {

                                EditableFeature newf = targetStore.createNewFeature(f);

                                newf.set(pkName, n++);

                                targetStore.insert(newf);

                        }

                        targetStore.finishEditingQuietly();

                        FLyrVect layer = (FLyrVect) MapContextLocator.getMapContextManager().createLayer(targetStore.getName(), targetStore);

                        layer.setTemporary(true);

                        FLyrVect sourceLayer = getFLyrVect(featureStore);

                        if (sourceLayer != null) {

                                layer.setProjection(sourceLayer.getProjection());

                                if (!query.hasGroupByColumns()) {

                                        try {

                                                if (sourceLayer != null && sourceLayer.getGeometryType() == layer.getGeometryType()) {

                                                        ILegend legend = sourceLayer.getLegend().cloneLegend();

                                                        layer.setLegend((IVectorLegend) legend);

                                                }

                                        } catch (Exception ex) {

                                                LOGGER.warn("Not able to apply same legend", ex);

                                        }

                                }

                        }

                        IView view = (IView) viewDoc.getMainWindow();

                        view.getMapControl().addLayer(layer);

                } catch (Exception ex) {

                        LOGGER.warn("Can't create filtered layer.", ex);

                        FeatureStore.cancelEditingQuietly(targetStore);

                        //msgbox

                } finally {

                        DisposeUtils.disposeQuietly(fs);

                        DisposeUtils.disposeQuietly(featureStore);

                        DisposeUtils.disposeQuietly(targetStore);

                }

        }

}