Application: gvSIG desktop

gvSIG. Desktop Geographic Information System.

Copyright (C) 2007-2020 gvSIG Association.

This program is free software; you can redistribute it and/or

modify it under the terms of the GNU General Public License

as published by the Free Software Foundation; either version 3

of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

 You should have received a copy of the GNU General Public License 

along with this program. If not, see <https://www.gnu.org/licenses/>. 

For any additional information, do not hesitate to contact us

at info AT gvsig.com, or visit our website www.gvsig.com.

<?xml version="1.0" encoding="ISO-8859-1"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <artifactId>org.gvsig.exportto</artifactId>

  <packaging>pom</packaging>

  <name>${project.artifactId}</name>

  <description>Exportto project</description>

  <parent>

    <groupId>org.gvsig</groupId>

    <artifactId>org.gvsig.desktop.library</artifactId>

    <version>2.0.321</version>

  </parent>

  <dependencies>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.tools.lib</artifactId>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.tools.lib</artifactId>

      <type>test-jar</type>

      <scope>test</scope>

    </dependency>

  </dependencies>

  <modules>

    <module>org.gvsig.exportto.lib</module>

    <module>org.gvsig.exportto.swing</module>

  </modules>

</project>

<?xml version="1.0" encoding="ISO-8859-1"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <artifactId>org.gvsig.exportto.lib</artifactId>

  <packaging>pom</packaging>

  <name>${project.artifactId}</name>

  <parent>

    <groupId>org.gvsig</groupId>

    <artifactId>org.gvsig.exportto</artifactId>

    <version>2.0.321</version>

  </parent>

  <modules>

    <module>org.gvsig.exportto.lib.api</module>

    <module>org.gvsig.exportto.lib.impl</module>

  </modules>

</project>

package org.gvsig.export.impl;

import org.cresques.cts.ICoordTrans;

import org.gvsig.export.ExportParametersGeometry;

import org.gvsig.export.spi.ExportServiceManager.FixGeometryStatus;

import org.gvsig.fmap.geom.Geometry;

/**

 *

 * @author jjdelcerro

 */

public class ExportGeometryUtils {

    public static class DefaultFixGeometryStatus

            implements FixGeometryStatus 

        {

        private Geometry geometry;

        private final int state;

        private String message;

        public DefaultFixGeometryStatus(Geometry geometry, int state) {

            this.geometry = geometry;

            this.state = state;

        }

        public DefaultFixGeometryStatus(Geometry geometry) {

            this.geometry = geometry;

            this.state = STATE_OK;

        }

        public DefaultFixGeometryStatus(int state) {

            this.geometry = null;

            this.state = state;

        }

        public DefaultFixGeometryStatus(int state, String message) {

            this.geometry = null;

            this.state = state;

            this.message = message;

        }

        private void setGeometry(Geometry geometry) {

            this.geometry = geometry;

        }

        @Override

        public Geometry getGeometry() {

            return this.geometry;

        }

        @Override

        public int getState() {

            return state;

        }

        @Override

        public String getMessage() {

            return this.message;

        }

    }

    public static FixGeometryStatus fixGeometry(

            ExportParametersGeometry options,

            ICoordTrans coord_trans,

            Geometry geometry

    ) {

        Geometry.ValidationStatus geometryCheck;

        DefaultFixGeometryStatus status;

        if (geometry == null) {

            return new DefaultFixGeometryStatus(geometry);

        }

        switch (options.getGeometryChecks()) {

            case ExportParametersGeometry.CHECKGEOMETRY_CHECK_IF_CORRUPT:

                geometryCheck = geometry.getValidationStatus();

                if (geometryCheck.isValid()) {

                    status = new DefaultFixGeometryStatus(geometry);

                    break;

                }

                switch (options.getGeometryChecksAction()) {

                    case ExportParametersGeometry.CHECKGEOMETRYACTION_SET_GEOMETRY_TO_NULL:

                        status = new DefaultFixGeometryStatus(null);

                        break;

                    case ExportParametersGeometry.CHECKGEOMETRYACTION_SKIP_FEATURE:

                        status = new DefaultFixGeometryStatus(FixGeometryStatus.STATE_SKIP, geometryCheck.getMessage());

                        break;

                    case ExportParametersGeometry.CHECKGEOMETRYACTION_ABORT:

                    default:

                        status = new DefaultFixGeometryStatus(FixGeometryStatus.STATE_ABORT, geometryCheck.getMessage());

                        break;

                }

                break;

            case ExportParametersGeometry.CHECKGEOMETRY_CHECK_IF_VALID:

                geometryCheck = geometry.getValidationStatus();

                if (geometryCheck.isValid()) {

                    status = new DefaultFixGeometryStatus(geometry);

                    break;

                }

                Geometry g;

                if (options.getTryToFixGeometry()) {

                    g = geometry.makeValid();

                    if (g != null) {

                        status = new DefaultFixGeometryStatus(g);

                        break;

                    }

                }

                switch (options.getGeometryChecksAction()) {

                    case ExportParametersGeometry.CHECKGEOMETRYACTION_SET_GEOMETRY_TO_NULL:

                        status = new DefaultFixGeometryStatus(null);

                        break;

                    case ExportParametersGeometry.CHECKGEOMETRYACTION_SKIP_FEATURE:

                        status = new DefaultFixGeometryStatus(FixGeometryStatus.STATE_SKIP, geometryCheck.getMessage());

                        break;

                    case ExportParametersGeometry.CHECKGEOMETRYACTION_ABORT:

                    default:

                        status = new DefaultFixGeometryStatus(FixGeometryStatus.STATE_ABORT, geometryCheck.getMessage());

                        break;

                }

                break;

            case ExportParametersGeometry.CHECKGEOMETRY_NONE:

            default:

                status = new DefaultFixGeometryStatus(geometry);

                break;

        }

        if (coord_trans != null) {

            if (status.getState() == FixGeometryStatus.STATE_OK) {

                if (status.getGeometry() != null) {

                    Geometry reproj_geom = status.getGeometry().cloneGeometry();

                    reproj_geom.reProject(coord_trans);

                    status.setGeometry(reproj_geom);

                }

            }

        }

        return status;

    }

}

<?xml version="1.0" encoding="UTF-8" ?>

<!--

    gvSIG. Desktop Geographic Information System.

    Copyright (C) 2007-2013 gvSIG Association.

    This program is free software; you can redistribute it and/or

    modify it under the terms of the GNU General Public License

    as published by the Free Software Foundation; either version 3

    of the License, or (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program; if not, write to the Free Software

    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

    MA  02110-1301, USA.

    For any additional information, do not hesitate to contact us

    at info AT gvsig.com, or visit our website www.gvsig.com.

-->

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />

<title>org.gvsig.exportto package documentation</title>

</head>

<body>

	<p>Exportto library API default implementation.</p>

</body>

</html>

package org.gvsig.export.impl.service;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.export.ExportLocator;

import org.gvsig.export.ExportParametersGeometry;

import org.gvsig.export.spi.ExportGeometryHelper;

import org.gvsig.export.spi.ExportServiceManager;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

/**

 *

 * @author jjdelcerro

 */

public class DefaultExportGeometryHelper implements ExportGeometryHelper {

        private final int targetGeometryIndex;

        private final int sourceGeometryIndex;

        private final ICoordTrans coord_trans;

        private final ExportServiceManager serviceManager;

        private final ExportParametersGeometry parameters;

        private String lastErrorMessage;

        public DefaultExportGeometryHelper(

            ExportParametersGeometry parameters,

            FeatureType theTargetFeatureType,

            FeatureType theSourceFeatureType

        ) {

            this.serviceManager = ExportLocator.getServiceManager();

            this.parameters = parameters;

            FeatureAttributeDescriptor sourceGeomAtt = theSourceFeatureType.getDefaultGeometryAttribute();

            FeatureAttributeDescriptor targetGeomAtt;

            String sourceGeometryFieldName = this.parameters.getSourceGeometryFieldName();

            if( !StringUtils.isEmpty(sourceGeometryFieldName) ) {

                sourceGeomAtt = theSourceFeatureType.getAttributeDescriptor(sourceGeometryFieldName);

            }

            if (sourceGeomAtt == null) {

                // Si el origen no tiene geometria, no haremos nada con las

                // geometrias.

                this.targetGeometryIndex = -1;

                this.sourceGeometryIndex = -1;

                this.coord_trans = null;

                return;

            }

            switch( this.getGeometryColumnCount(theTargetFeatureType) ) {

                case 0:

                    // Si el destino no tiene campo geometry no haremos nada con 

                    // las geometrias.

                    this.targetGeometryIndex = -1;

                    this.sourceGeometryIndex = -1;

                    this.coord_trans = null;

                    return;

                case 1:

                    // Si solo hay una columna de geometria asignaremos las geometrias

                    // independientemente de como se llamen los campos.

                    targetGeomAtt = theTargetFeatureType.getDefaultGeometryAttribute();

                    break;

                default:

                    // Si hay mas de una geometria en el target y hay un campo de tipo

                    // geometria que coincida en nombre con el del source, usamos ese.

                    targetGeomAtt = theTargetFeatureType.getAttributeDescriptor(sourceGeomAtt.getName());

                    if( targetGeomAtt == null || targetGeomAtt.getType()!=DataTypes.GEOMETRY ) {

                        // Si no coinciden por nombre y tipo, pillaremos el primer campo

                        // geometry por defecto del target.

                        targetGeomAtt = theTargetFeatureType.getDefaultGeometryAttribute();

                        if( targetGeomAtt==null ) {

                            targetGeomAtt = this.getFirstGeometryColumn(theTargetFeatureType);

                            if( targetGeomAtt == null ) {

                                this.targetGeometryIndex = -1;

                                this.sourceGeometryIndex = -1;

                                this.coord_trans = null;

                                return;

                            }

                        }

                    }

            }

            IProjection targetProjection = this.parameters.getTargetProjection();

            IProjection sourceProjection = sourceGeomAtt.getSRS();

            if( targetProjection == null ) {

                targetProjection = sourceProjection;

            }

            // this comparison is perhaps too preventive

            // we could  have two instances of same projection

            // so we would do more computations than needed

            if (sourceProjection != null && targetProjection != null && sourceProjection != targetProjection) {

                this.coord_trans = sourceProjection.getCT(targetProjection);

            } else {

                this.coord_trans = null;

            }

            this.sourceGeometryIndex = sourceGeomAtt.getIndex();

            this.targetGeometryIndex = targetGeomAtt.getIndex();

        }

        private int getGeometryColumnCount(FeatureType featureType) {

            int count = 0;

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

                if( featureType.getAttributeDescriptor(i).getType()==DataTypes.GEOMETRY ) {

                    count++;

                }

            }

            return count;

        }

        @Override

        public String getLastErrorMessage() {

            return this.lastErrorMessage;

        }

        @Override

        public int copyGeometry(

                Feature sourceFeature, 

                EditableFeature targetFeature

            ) {

            if( this.sourceGeometryIndex<0 || this.targetGeometryIndex<0 ) {

                return ExportServiceManager.FixGeometryStatus.STATE_OK;

            }

            Geometry geometry = sourceFeature.getGeometry(this.sourceGeometryIndex);

            ExportServiceManager.FixGeometryStatus check = serviceManager.fixGeometry(

                    this.parameters, 

                    this.coord_trans, 

                    geometry

            );

            if( check.getState() == ExportServiceManager.FixGeometryStatus.STATE_OK ) {

                targetFeature.setGeometry(this.targetGeometryIndex, check.getGeometry());

            }

            this.lastErrorMessage = check.getMessage();

            return check.getState();

        }

        @Override

        public boolean canProcessGeometry() {

            return this.sourceGeometryIndex>=0 && this.targetGeometryIndex>=0 ;

        }

        private FeatureAttributeDescriptor getFirstGeometryColumn(FeatureType featureType) {

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

                FeatureAttributeDescriptor descriptor = featureType.getAttributeDescriptor(i);

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

                    return descriptor;

                }

            }

            return null;

        }

}

/*

 * 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.export.impl.service;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.cresques.cts.ICoordTrans;

import org.gvsig.export.ExportAttributes;

import org.gvsig.export.ExportParameters;

import org.gvsig.export.ExportParametersGeometry;

import org.gvsig.export.Filter;

import org.gvsig.export.impl.ExportGeometryUtils;

import org.gvsig.export.spi.ExportGeometryHelper;

import org.gvsig.export.spi.ExportService;

import org.gvsig.export.spi.ExportServiceFactory;

import org.gvsig.export.spi.ExportServiceManager;

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

import org.gvsig.fmap.geom.Geometry;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

public class DefaultExportServiceManager implements ExportServiceManager {

    private static final Logger LOG = LoggerFactory.getLogger(DefaultExportServiceManager.class);

    private final Map<String, ExportServiceFactory> factories;

    public DefaultExportServiceManager() {

        super();

        this.factories = new HashMap<>();

    }

    @Override

    public ExportServiceFactory getServiceFactory(String name) {

        ExportServiceFactory factory = this.factories.get(name);

        if (factory == null) {

            throw new IllegalArgumentException("Don't exists export factory '" + name + "'.");

        }

        return factory;

    }

    @Override

    public ExportService createService(ExportParameters parameters) {

        return this.getServiceFactory(parameters.getServiceName()).createService(parameters);

    }

    @Override

    public ExportParameters createServiceParameters(String name) {

        return this.getServiceFactory(name).createParameters();

    }

    @Override

    public void register(ExportServiceFactory factory) {

        this.factories.put(factory.getName(), factory);

    }

    @Override

    public List<ExportServiceFactory> getAllServiceFactories() {

        List<ExportServiceFactory> result = new ArrayList<>();

        result.addAll(this.factories.values());

        return Collections.unmodifiableList(result);

    }

    @Override

    public List<ExportServiceFactory> getServiceFactories(Filter<ExportServiceFactory> filter) {

        List<ExportServiceFactory> result = new ArrayList<>();

        if (filter == null) {

            result.addAll(this.factories.values());

        } else {

            for (ExportServiceFactory factory : this.factories.values()) {

                if (factory.isEnabled() && filter.apply(factory)) {

                    result.add(factory);

                }

            }

        }

        return Collections.unmodifiableList(result);

    }

    @Override

    public FixGeometryStatus fixGeometry(

            ExportParametersGeometry parmeters,

            ICoordTrans coord_trans,

            Geometry geometry

    ) {

        return ExportGeometryUtils.fixGeometry(parmeters, coord_trans, geometry);

    }

    @Override

    public ExportGeometryHelper createGeometryHelper(ExportParametersGeometry parameters, FeatureType theTargetFeatureType, FeatureType theSourceFeatureType) {

        DefaultExportGeometryHelper helper = new DefaultExportGeometryHelper(

                parameters,

                theTargetFeatureType,

                theSourceFeatureType

        );

        return helper;

    }

    @Override

    public ExportAttributes createExportAttributes() {

        DefaultExportAttributes exp = new DefaultExportAttributes();

        return exp;

    }

}

/*

 * 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.export.impl.service;

import org.gvsig.export.ExportAttributes;

import org.gvsig.export.ExportAttributes.ExportAttribute;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.namestranslator.NamesTranslator;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

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

public class DefaultExportAttribute implements ExportAttributes.ExportAttribute {

    private FeatureAttributeDescriptor fad;

    private int newDataType;

    private int size;

    private boolean exported;

    private boolean computed;

    private NamesTranslator translator;

    public DefaultExportAttribute(FeatureAttributeDescriptor fad, NamesTranslator namesTranslator) {

        this.fad = fad;

        this.translator = namesTranslator;

        this.computed = this.fad.isComputed();

    }

    public DefaultExportAttribute() {

    }

    @Override

    public FeatureAttributeDescriptor getDescriptor() {

        return this.fad;

    }

    @Override

    public String getName() {

        return this.fad.getName();

    }

    @Override

    public int getDataType() {

        return this.fad.getDataType().getType();

    }

    @Override

    public String getNewName() {

        if (translator==null) {

            return this.getName();

        }

        return translator.getTranslation(this.getName());

    }

    @Override

    public int getNewDataType() {

        return this.newDataType;

    }

    @Override

    public boolean isExported() {

        return this.exported;

    }

    @Override

    public boolean isComputed() {

        return this.computed;

    }

    @Override

    public int setNewName(String newName) {

        if (translator==null) {

            return -1;

        }

        int indexChanged = this.translator.setTranslation(this.getName(), newName);

        return indexChanged;

    }

    @Override

    public void setExported(boolean exported) {

        this.exported = exported;

    }

    @Override

    public void setComputed(boolean computed) {

        this.computed = computed;

    }

    @Override

    public void setNewType(int dataType) {

        this.newDataType = dataType;

    }

    @Override

    public int getSize() {

        return this.size;

    }

    @Override

    public void setSize(int size) {

        this.size = size;

    }

    @Override

    public ExportAttribute clone() throws CloneNotSupportedException {

        DefaultExportAttribute clone = (DefaultExportAttribute) super.clone();

        clone.fad = (FeatureAttributeDescriptor) fad.clone();

        return clone;

    }

    public static void registerPersistence() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

            DynStruct definition = manager.addDefinition(DefaultExportAttribute.class,

                    "ExportAttribute", "ExportAttribute persistence definition", null, null);

            definition.addDynFieldObject("fad").setClassOfValue(FeatureAttributeDescriptor.class);

//            definition.addDynFieldString("newName").setMandatory(false);

            definition.addDynFieldInt("newDataType").setMandatory(false);

            definition.addDynFieldInt("size").setMandatory(false);

            definition.addDynFieldBoolean("exported").setMandatory(false);

            definition.addDynFieldBoolean("calculated").setMandatory(false);

        }

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

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

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

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

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

        state.set("calculated", this.computed);

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        FeatureAttributeDescriptor stateFad = (FeatureAttributeDescriptor) state.get("fad");

        this.fad = stateFad;

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

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

        this.exported = state.getBoolean("exported");

        this.computed = state.getBoolean("calculated");

    }

}

package org.gvsig.export.impl.service;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.function.Function;

import org.apache.commons.collections.CollectionUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.export.ExportAttributes;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataTypes;

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

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

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.FeatureType;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.namestranslator.NamesTranslator;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public final class DefaultExportAttributes implements ExportAttributes {

    private List<ExportAttribute> exportAttributes;

    private NamesTranslator namesTranslator = null;

    private FeatureType sourceFeatureType;

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

    private boolean active;

    private FeatureQuery query = null;

    public DefaultExportAttributes() {

        this.namesTranslator = NamesTranslator.createBaseTranslator();

        this.active = false;

    }

    public void fillExportAttributes(FeatureType ftype, FeatureQuery query) {

        ArrayList attrs = new ArrayList();

        if (ftype != null) {

            for (FeatureAttributeDescriptor fad : ftype) {

                DefaultExportAttribute exportAttribute = new DefaultExportAttribute(fad.getCopy(), this.getNamesTranslator());

                exportAttribute.setNewType(fad.getDataType().getType());

                exportAttribute.setSize(fad.getSize());

                if (query == null || (query != null && query.getGroupByColumns().isEmpty())) {

                    exportAttribute.setExported(isShowableDataType(fad.getDataType()));

                } else {

                    if (query.getAggregate(fad.getName()) != null || query.getGroupByColumns().contains(fad.getName())) {

                        exportAttribute.setExported(isShowableDataType(fad.getDataType()));

                    } else {

                        exportAttribute.setExported(false);

                    }

                }

                attrs.add(exportAttribute);

            }

        }

        if (query != null && query.getExtraColumn().getColumns() != null && !query.getExtraColumn().getColumns().isEmpty()) {

            for (FeatureAttributeDescriptor fad : query.getExtraColumn().getColumns()) {

                DefaultExportAttribute exportAttribute = new DefaultExportAttribute(fad.getCopy(), this.getNamesTranslator());

                this.getNamesTranslator().addSource(fad.getName());

                exportAttribute.setNewType(fad.getDataType().getType());

                exportAttribute.setSize(fad.getSize());

                if (attributeAsComputedAndGroupBy(query, fad.getName())) {

                    exportAttribute.setComputed(false);

                }

                exportAttribute.setExported(isShowableDataType(fad.getDataType()));

                attrs.add(exportAttribute);

            }

        }

        this.setExportAttributes(attrs);

    }

    protected boolean attributeAsComputedAndGroupBy(FeatureQuery query, String attr) {

        if (!query.hasGroupByColumns()) {

            return false;

        }

        List<String> groupByCols = query.getGroupByColumns();

        if (groupByCols.isEmpty()) {

            return false;

        }

        return groupByCols.contains(attr);

    }

    protected boolean isShowableDataType(DataType dataType) {

        if ( dataType.getType() != DataTypes.GEOMETRY && (

                 dataType.isContainer()

                || dataType.isObject()

                || dataType.getType() == DataTypes.ARRAY)) {

            return false;

        } else {

            return true;

        }

    }

    @Override

    public void setNamesTranslator(NamesTranslator namesTranslator) {

        if (this.namesTranslator != namesTranslator) {

            this.namesTranslator = namesTranslator;

            if (this.sourceFeatureType != null) {

                this.namesTranslator.rebuild();

            }

        }

    }

    @Override

    public NamesTranslator getNamesTranslator() {

        return this.namesTranslator;

    }

    @Override

    public List<ExportAttribute> toList() {

        return this.exportAttributes;

    }

    @Override

    public boolean isEmpty() {

        return this.exportAttributes.isEmpty();

    }

    @Override

    public int size() {

        return this.exportAttributes.size();

    }

    @Override

    public Iterator<ExportAttribute> iterator() {

        return this.exportAttributes.iterator();

    }

    @Override

    public ExportAttribute get(int position) {

        return this.exportAttributes.get(position);

    }

    @Override

    public ExportAttribute getExportAttribute(String name) {

        for (ExportAttribute exportAttribute : this.exportAttributes) {

            if (StringUtils.equals(exportAttribute.getName(), name)) {

                return exportAttribute;

            }

        }

        return null;

    }

    @Override

    public FeatureType getTargetFeatureType() {

        EditableFeatureType targetFeatureType = DALLocator.getDataManager().createFeatureType();

        for (ExportAttribute exportAttribute : this.exportAttributes) {

            if (!exportAttribute.isExported()) {

                continue;

            }

            FeatureAttributeDescriptor descriptor = exportAttribute.getDescriptor().getCopy();

            EditableFeatureAttributeDescriptor targetDescriptor = DALLocator.getDataManager().createFeatureAttributeDescriptor();

            targetDescriptor.copyFrom(descriptor);

            targetDescriptor.setName(exportAttribute.getNewName());

            if (targetDescriptor.isComputed() && !exportAttribute.isComputed()) {

                targetDescriptor.setFeatureAttributeEmulator((FeatureAttributeEmulator) null);

            }

            if (targetDescriptor.getType() != exportAttribute.getNewDataType()) {

                targetDescriptor.setDefaultValue(null);

            }

            targetDescriptor.setDataType(exportAttribute.getNewDataType());

            targetDescriptor.setSize(exportAttribute.getSize());

            targetFeatureType.addLike(targetDescriptor);

        }

        return targetFeatureType.getNotEditableCopy();

    }

    @Override

    public void setSourceFeatureType(FeatureType sourceFeatureType, FeatureQuery query) {

        this.query = query;

        if (!sourceFeatureType.equals(this.sourceFeatureType)) {

            this.sourceFeatureType = sourceFeatureType;

            this.getNamesTranslator().updateSourceNames(sourceFeatureType, new Function() {

                @Override

                public Object apply(Object t) {

                    FeatureAttributeDescriptor attr = (FeatureAttributeDescriptor) t;

                    return attr.getName();

                }

            });

            this.fillExportAttributes(this.sourceFeatureType, query);

        }

    }

    @Override

    public FeatureType getSourceFeatureType() {

        return this.sourceFeatureType;

    }

    @Override

    public String getTargetName(String name) {

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

            ExportAttribute exportAttribute = exportAttributes.get(i);

            if (StringUtils.equals(exportAttribute.getName(), name)) {

                String newName = exportAttribute.getNewName();

                return newName;

            }

        }

        return null;

    }

    @Override

    public String getSourceName(String name) {

        for (ExportAttribute exportAttribute : this.exportAttributes) {

            if (StringUtils.equalsIgnoreCase(exportAttribute.getNewName(), name)) {

                return exportAttribute.getName();

            }

        }

        return null;

    }

    @Override

    public int getTargetType(String name) {

        for (ExportAttribute exportAttribute : this.exportAttributes) {

            if (StringUtils.equals(exportAttribute.getName(), name)) {

                return exportAttribute.getNewDataType();

            }

        }

        return 0;

    }

    @Override

    public int getSourceType(String name) {

        for (ExportAttribute exportAttribute : this.exportAttributes) {

            if (StringUtils.equals(exportAttribute.getNewName(), name)) {

                return exportAttribute.getDataType();

            }

        }

        return 0;

    }

    @Override

    public ExportAttributes clone() throws CloneNotSupportedException {

        DefaultExportAttributes clone = (DefaultExportAttributes) super.clone();

        clone.namesTranslator = this.namesTranslator.clone();

        List cloneListAttribute = new ArrayList();

        for (ExportAttribute exportAttribute : exportAttributes) {

            cloneListAttribute.add(exportAttribute.clone());

        }

        clone.setExportAttributes(cloneListAttribute);

        return clone;

    }

    @Override

    public void setExportAttributes(List<ExportAttribute> exportAttributes) {

        this.exportAttributes = exportAttributes;

    }

    @Override

    public void setActive(boolean active) {

        this.active = active;

    }

    @Override

    public boolean isActive() {

        return this.active;

    }

    public static void registerPersistence() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

            DynStruct definition = manager.addDefinition(DefaultExportAttributes.class,

                    "ExportAttributes", "ExportAttributes persistence definition", null, null);

            definition.addDynFieldList("exportAttributes").setClassOfItems(ExportAttribute.class);

            definition.addDynFieldObject("namesTranslator").setClassOfValue(NamesTranslator.class);

            definition.addDynFieldObject("sourceFeatureType").setClassOfValue(FeatureType.class);

            definition.addDynFieldBoolean("active");

        }

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set("exportAttributes", this.exportAttributes.iterator());

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

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

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

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        Iterator it = state.getIterator("exportAttributes");

        List<ExportAttribute> data = new ArrayList<>();

        while (it.hasNext()) {

            ExportAttribute ref = (ExportAttribute) it.next();

            data.add(ref);

        }

        this.exportAttributes = data;

        NamesTranslator nameTranslatorState = (NamesTranslator) state.get("namesTranslator");

        if (nameTranslatorState != null) {

            this.namesTranslator = nameTranslatorState;

        }

        this.sourceFeatureType = (FeatureType) state.get("sourceFeatureType");

        this.active = state.getBoolean("active");

    }

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or modify it under

 * the terms of the GNU General Public License as published by the Free Software

 * Foundation; either version 3 of the License, or (at your option) any later

 * version.

 *

 * This program is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more

 * details.

 *

 * You should have received a copy of the GNU General Public License along with

 * this program; if not, write to the Free Software Foundation, Inc., 51

 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us at info AT

 * gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.export.impl;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Properties;

import org.apache.commons.io.IOUtils;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.export.ExportManager;

import org.gvsig.export.ExportParameters;

import org.gvsig.export.ExportProcess;

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

import org.gvsig.tools.bookmarksandhistory.Bookmarks;

import org.gvsig.tools.bookmarksandhistory.History;

import org.gvsig.tools.bookmarksandhistory.impl.BaseBookmarks;

import org.gvsig.tools.bookmarksandhistory.impl.BaseHistory;

/**

 * Default {@link ExportManager} implementation.

 *

 * @author gvSIG Team

 * @version $Id$

 */

public class DefaultExportManager implements ExportManager {

    private static final Logger LOG = LoggerFactory.getLogger(DefaultExportManager.class);

    private static class DefaultExportFilter implements ExportFilter {

        private final String name;

        private final String expression;

        public DefaultExportFilter(String name, String expression) {

            this.name = name;

            this.expression = expression;

        }

        @Override

        public String getName() {

            return name;

        }

        @Override

        public String getExpression() {

            return expression;

        }

    }

    private Map<String, ExportFilter> filters = null;

    private File homeFolder = null;

    private final History<ExportParameters> history;

    private final Bookmarks<ExportParameters> bookmarks;

    public DefaultExportManager() {

        super();

        this.history = new BaseHistory<>(10);

        this.bookmarks = new BaseBookmarks<>();

    }

    private void loadFilters() {

        this.filters = new HashMap<>();

        if (this.homeFolder != null) {

            File filtersFile = new File(this.homeFolder, "filters");

            if (filtersFile.exists()) {

                FileInputStream fis = null;

                try {

                    fis = new FileInputStream(filtersFile);

                    Properties properties = new Properties();

                    properties.load(fis);

                    for (Object name : properties.keySet()) {

                        String value = (String) properties.get(name);

                        ExportFilter filter = new DefaultExportFilter((String) name, value);

                        this.filters.put(filter.getName(), filter);

                    }

                } catch (IOException ex) {

                    LOG.warn("Can't load filters file '" + filtersFile.getAbsolutePath() + "'.", ex);

                } finally {

                    IOUtils.closeQuietly(fis);

                }

            }

        }

    }

    public void saveFilters() {

        if (this.homeFolder != null) {

            Properties properties = new Properties();

            for (ExportFilter filter : this.filters.values()) {

                properties.setProperty(filter.getName(), filter.getExpression());

            }

            File filtersFile = new File(this.homeFolder, "filters");

            FileOutputStream fos = null;

            try {

                fos = new FileOutputStream(filtersFile);

                properties.store(fos, "");

            } catch (IOException ex) {

                LOG.warn("Can't load filters file '" + filtersFile.getAbsolutePath() + "'.", ex);

            } finally {

                IOUtils.closeQuietly(fos);

            }

        }

    }

    public Map<String,ExportFilter> getFiltersAsMap() {

        if (this.filters == null) {

            loadFilters();

        }

        return this.filters;

    }

    @Override

    public List<ExportFilter> getFilters() {

        List<ExportFilter> l = new ArrayList<>();

        l.addAll(this.getFiltersAsMap().values());

        return l;

    }

    @Override

    public ExportFilter getFilter(String filterName) {

        return this.getFiltersAsMap().get(filterName);

    }

    @Override

    public ExportFilter addFilter(String name, String expression) {

        ExportFilter filter = new DefaultExportFilter(name, expression);

        this.filters.put(filter.getName(), filter);

        return filter;

    }

    @Override

    public void setHomeFolder(File homeFolder) {

        this.homeFolder = homeFolder;

    }

    @Override

    public ExportProcess createProcess() {

        ExportProcess process = new DefaultExportProcess();

        return process;

    }

    @Override

    public ExportProcess createProcess(FeatureStore store) {

        ExportProcess process = new DefaultExportProcess();

        process.setSourceFeatureStore(store);

        return process;

    }

    @Override

    public ExportProcess createProcess(FeatureStore store, IProjection contextProjection) {

        ExportProcess process = new DefaultExportProcess();

        process.setSourceFeatureStore(store);

        process.setContextProjection(contextProjection);

        return process;

    }

    @Override

    public History<ExportParameters> getHistory() {

        return this.history;

    }

    @Override

    public Bookmarks<ExportParameters> getBookmarks() {

        return this.bookmarks;

    }

}

package org.gvsig.export.impl;

import java.util.List;

import java.util.Objects;

import javax.swing.JOptionPane;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.export.ExportException;

import org.gvsig.export.ExportLocator;

import org.gvsig.export.ExportParameters;

import org.gvsig.export.ExportParametersGeometry;

import org.gvsig.export.ExportProcess;

import org.gvsig.export.spi.ExportService;

import org.gvsig.export.spi.ExportServiceFactory;

import org.gvsig.export.spi.ExportServiceManager;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.OpenDataStoreParameters;

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

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

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.TaskStatus;

/**

 *

 * @author jjdelcerro

 */

public class DefaultExportProcess

        implements ExportProcess {

    private ExportServiceFactory factory;

    private List<OpenDataStoreParameters> targetOpenStoreParameters;

    private ExportParameters parameters;

    private FeatureStore sourceFeatureStore;

    private IProjection contextProjection;

    private ICoordTrans sourceTransformation;

    private IProjection sourceProjection;

    private Object context;

    private Expression filterExpression;

    private int featuresToUse;

    private SimpleTaskStatus taskStatus;

    private FeatureQuery featureQuery;

    public DefaultExportProcess() {

    }

    @Override

    public void setOutputFormat(String serviceName) throws ExportException {

        ExportServiceManager serviceManager = ExportLocator.getServiceManager();

        this.factory = serviceManager.getServiceFactory(serviceName);

        this.parameters = this.factory.createParameters();

        this.parameters.setFeatureQuery(featureQuery);

//        this.service = this.factory.createService(this.parameters);

        this.parameters.setSourceFeatureStore(this.sourceFeatureStore);

        this.parameters.setFeaturesToUse(featuresToUse);

        if (this.parameters instanceof ExportParametersGeometry) {

            ExportParametersGeometry params = (ExportParametersGeometry) this.parameters;

            params.setContextProjection(this.contextProjection);

            params.setSourceProjection(this.sourceProjection);

            params.setSourceTransformation(this.sourceTransformation);

            params.setTargetProjection(this.contextProjection);

            params.setContext(this.context);

            if (this.sourceFeatureStore != null) {

                try {

                    FeatureType ftype = this.sourceFeatureStore.getDefaultFeatureType();

                    if (ftype != null) {

                        params.setSourceGeometryFieldName(ftype.getDefaultGeometryAttributeName());

                    }

                } catch (DataException ex) {

                    //

                }

            }

        }

        this.setFilterExpression(this.filterExpression); //set features to use and expression

    }

    @Override

    public void setParameters(ExportParameters params) {

        this.parameters = params;

        this.factory = this.parameters.getFactory();

        this.parameters.setSourceFeatureStore(this.sourceFeatureStore);

        this.parameters.setContext(this.context);

        this.featuresToUse = this.parameters.getFeaturesToUse();

        if (ExpressionUtils.isEmpty(filterExpression)) {

            this.filterExpression = this.parameters.getFilterExpresion();

        } else if (!Objects.equals(this.filterExpression, this.parameters.getFilterExpresion())) {

            StringBuilder message = new StringBuilder();

            message.append(ToolsLocator.getI18nManager().getTranslation("_A_filter_is_already_applied_to_this_export_process"));

            message.append(":\n");

            message.append(StringUtils.abbreviate(this.filterExpression.getPhrase(), 30));

            message.append("\n");

            message.append(ToolsLocator.getI18nManager().getTranslation("_Its_going_to_be_replace_by_the_filter_in_the_parameters"));

            message.append(":\n");

            if (this.parameters.getFilterExpresion() != null) {

                message.append(StringUtils.abbreviate(this.parameters.getFilterExpresion().getPhrase(), 30));

            } else {

                message.append("empty filter");

            }

            message.append("\n");

            message.append(ToolsLocator.getI18nManager().getTranslation("_Do_you_want_to_keep_the_applied_filter"));

            int keepFilter = ToolsSwingLocator.getThreadSafeDialogsManager().confirmDialog(

                    message.toString(),//ToolsLocator.getI18nManager().getTranslation("_Do_you_want_to_keep_the_applied_filter_and_not_use_the_one_in_the_parameters"),

                    ToolsLocator.getI18nManager().getTranslation("_Filter_to_apply"),

                    JOptionPane.YES_NO_OPTION,

                    JOptionPane.WARNING_MESSAGE,

                    "exporto-overwrite-expression-parameters");

            if (keepFilter == JOptionPane.YES_OPTION) {

                this.parameters.setFilterExpresion(this.filterExpression);

            }

        }

        if (this.parameters instanceof ExportParametersGeometry) {

            ExportParametersGeometry pa = (ExportParametersGeometry) this.parameters;

            this.contextProjection = pa.getContextProjection();

            this.sourceProjection = pa.getSourceProjection();

            this.sourceTransformation = pa.getSourceTransformation();

        }

    }

    @Override

    public void setSourceFeatureStore(FeatureStore store

    ) {

        this.sourceFeatureStore = store;

        if (this.parameters != null) {

            this.parameters.setSourceFeatureStore(sourceFeatureStore);

        }

    }

    @Override

    public void setContextProjection(IProjection projection

    ) {

        this.contextProjection = projection;

        if (this.parameters instanceof ExportParametersGeometry) {

            ((ExportParametersGeometry) this.parameters).setContextProjection(projection);

        }

    }

    @Override

    public void setSourceTransformation(ICoordTrans transformation

    ) {

        this.sourceTransformation = transformation;

        if (this.parameters instanceof ExportParametersGeometry) {

            ((ExportParametersGeometry) this.parameters).setSourceTransformation(transformation);

        }

    }

    @Override

    public void setSourceProjection(IProjection projection

    ) {

        this.sourceProjection = projection;

        if (this.parameters instanceof ExportParametersGeometry) {

            ((ExportParametersGeometry) this.parameters).setSourceProjection(projection);

        }

    }

    @Override

    public Object getContext() {

        return context;

    }

    @Override

    public void setContext(Object context

    ) {

        this.context = context;

        if (this.parameters != null) {

            this.parameters.setContext(context);

        }

    }

    @Override

    public ExportParameters getParameters() {

        return this.parameters;

    }

    @Override

    public TaskStatus getTaskStatus() {

        if (this.taskStatus == null) {

            this.taskStatus = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus("Export");

        }

        return this.taskStatus;

    }

    @Override

    public void run() {

        if (this.factory == null) {