Application: gvSIG desktop

/**

 * 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.exportto.swing.prov.jdbc;

import java.text.MessageFormat;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.exportto.ExporttoService;

import org.gvsig.exportto.ExporttoServiceException;

import org.gvsig.exportto.ExporttoServiceFinishAction;

import org.gvsig.exportto.swing.spi.ExportGeometryUtils;

import org.gvsig.exportto.swing.spi.ExportGeometryUtils.FixGeometryStatus;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.task.AbstractMonitorableTask;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * @author gvSIG Team

 * @version $Id$

 *

 */

public class ExporrtoJDBCService extends AbstractMonitorableTask implements

        ExporttoService {

    private static final Logger logger = LoggerFactory.getLogger(ExporrtoJDBCService.class);

    private ExporttoServiceFinishAction exporttoServiceFinishAction = null;

    private final ExporttoJDBCOptions options;

    private FeatureType targetFeatureType = null;

//    private Map<String,String> translationIds;

    public ExporrtoJDBCService(ExporttoJDBCOptions options) {

        this.options = options;

    }

    protected String getTranslatedIdentifier(String identifier) {

        String s = identifier;

        if (this.options.getTranslateIdentifiersToLowerCase()) {

            s = s.toLowerCase();

        }

        if( this.options.getTranslateHyphens()) {

            s = s.replace("-", "_");

        }

        if (this.options.getRemoveSpacesInIdentifiers()) {

            s = StringUtils.normalizeSpace(s).replace(" ", "_");

        }

        return s;

    }

    protected void createTable(JDBCServerExplorer explorer) throws Exception {

        FeatureType targetTempFeatureType;

        EditableFeatureType targetEditableFeatureType;

        DataManager manager = DALLocator.getDataManager();

        FeatureStoreProviderFactory factory = (FeatureStoreProviderFactory) manager.getStoreProviderFactory(explorer.getStoreName());

        boolean preferNotToUseNonNullRestrictions = factory.preferNotToUseNonNullRestrictions();

        targetTempFeatureType = options.getSourceFeatureType().getCopy();

        targetEditableFeatureType = targetTempFeatureType.getEditable();

        // Remove inherited primary keys from the data source and remove NotNull

        // restrictions if proceed.

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

            EditableFeatureAttributeDescriptor x = (EditableFeatureAttributeDescriptor) targetEditableFeatureType.get(i);

            x.setIsPrimaryKey(false);

            if( preferNotToUseNonNullRestrictions ) {

                x.setAllowNull(true);

            }

        }

        if (this.options.getTranslateIdentifiersToLowerCase()

                || this.options.getRemoveSpacesInIdentifiers() 

                || this.options.getTranslateHyphens()) {

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

                EditableFeatureAttributeDescriptor x = (EditableFeatureAttributeDescriptor) targetEditableFeatureType.get(i);

                x.setName(getTranslatedIdentifier(x.getName()));

            }

        }

        if (this.options.getPrimaryKey() != null) {

            EditableFeatureAttributeDescriptor pk = (EditableFeatureAttributeDescriptor) targetEditableFeatureType.get(getTranslatedIdentifier(options.getPrimaryKey()));

            if (pk == null) {

                pk = targetEditableFeatureType.add(

                        getTranslatedIdentifier(this.options.getPrimaryKey()),

                        DataTypes.LONG

                );

                pk.setIsPrimaryKey(true);

                pk.setIsAutomatic(true);

            } else {

                pk.setIsPrimaryKey(true);

            }

        }

        if (this.options.getCreateIndexInGeometryRow()) {

            EditableFeatureAttributeDescriptor x = (EditableFeatureAttributeDescriptor) targetEditableFeatureType.getDefaultGeometryAttribute();

            x.setIsIndexed(true);

        }

        // ======================================================

        // Reprojection: set SRS of geometry field to target SRS

        EditableFeatureAttributeDescriptor attrdescriptor

                = (EditableFeatureAttributeDescriptor) targetEditableFeatureType.getDefaultGeometryAttribute();

        if (attrdescriptor != null) {

            attrdescriptor.setSRS(this.options.getTargetProjection());

        }

        // ======================================

        // Remove index to improve performance

        this.targetFeatureType = targetEditableFeatureType.getNotEditableCopy();

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

            EditableFeatureAttributeDescriptor x = (EditableFeatureAttributeDescriptor) targetEditableFeatureType.get(i);

            //x.setIsPrimaryKey(false);

            x.setIsIndexed(false);

        }

        // ======================================

        JDBCNewStoreParameters createTableParams = (JDBCNewStoreParameters) explorer.getAddParameters();

        createTableParams.setSelectRole(this.options.getSelectRole());

        createTableParams.setInsertRole(this.options.getInsertRole());

        createTableParams.setUpdateRole(this.options.getUpdateRole());

        createTableParams.setDeleteRole(this.options.getDeleteRole());

        createTableParams.setTruncateRole(this.options.getTruncateRole());

        createTableParams.setReferenceRole(this.options.getReferenceRole());

        createTableParams.setTriggerRole(this.options.getTriggerRole());

        createTableParams.setAllRole(this.options.getAllRole());

        createTableParams.setSchema(this.options.getSchema());

        createTableParams.setPostCreatingStatement(this.options.getPostCreatingStatement());

        createTableParams.setDefaultFeatureType(targetEditableFeatureType);

        createTableParams.setTable(this.options.getTableName());

        explorer.add(explorer.getStoreName(), createTableParams, true);

    }

    private static class InvalidGeometryException extends ExporttoServiceException {

        private static final long serialVersionUID = 3082742759529054747L;

        public InvalidGeometryException(Feature feature, String checkMessage) {

            super(checkMessage, null, checkMessage, 0);

            this.feature = feature;

        }

    }

    @Override

    public void export(FeatureSet featureSet) throws ExporttoServiceException {

        Geometry.ValidationStatus geometryCheck;

        DisposableIterator it = null;

        EditableFeature targetFeature = null;

        FeatureStore target = null;

        try {

            // ======================================

            // Reprojection

            FeatureAttributeDescriptor geo_att = this.options.getSourceFeatureType().getDefaultGeometryAttribute();

            IProjection sourceProjection;

            ICoordTrans coord_trans = null;

            Geometry reproj_geom;

            IProjection targetProjection = this.options.getTargetProjection();

            if (geo_att != null) {

                sourceProjection = geo_att.getSRS();

                // 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) {

                    coord_trans = sourceProjection.getCT(targetProjection);

                }

            }

            // ============================================

            DataManager dataManager = DALLocator.getDataManager();

            JDBCServerExplorer explorer = (JDBCServerExplorer) dataManager.openServerExplorer(

                    this.options.getExplorerParameters().getExplorerName(),

                    this.options.getExplorerParameters()

            );

            if (this.options.canCreatetable()) {

                logger.debug("Creating table");

                taskStatus.message("Creating table");

                this.createTable(explorer);

            }

            JDBCStoreParameters openParams = (JDBCStoreParameters) explorer.getOpenParameters();

            openParams.setSchema(this.options.getSchema());

            openParams.setTable(this.options.getTableName());

            openParams.setCRS(targetProjection);

            openParams.setDefaultGeometryField(

                    this.options.getSourceFeatureType().getDefaultGeometryAttributeName()

            );

            target = (FeatureStore) explorer.open(openParams);

            FeatureType targetFeatureType = target.getDefaultFeatureType();

            FeatureType sourceFeatureType = featureSet.getDefaultFeatureType();

            target.edit(FeatureStore.MODE_APPEND);

            long featureCount = 1;

            taskStatus.setRangeOfValues(0, featureSet.getSize());

            int targetGeometryIndex;

            int sourceGeometryIndex;

            if( getGeometryColumnCount(sourceFeatureType)==1

                    && getGeometryColumnCount(targetFeatureType)==1 ) {

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

                // independientemente de como se llamen los campos.

                targetGeometryIndex = targetFeatureType.getDefaultGeometryAttributeIndex();

                sourceGeometryIndex = sourceFeatureType.getDefaultGeometryAttributeIndex();

            } else {

                FeatureAttributeDescriptor attr = sourceFeatureType.getDefaultGeometryAttribute();

                sourceGeometryIndex = attr.getIndex();

                targetGeometryIndex = targetFeatureType.getAttributeDescriptor(attr.getName()).getIndex();

            }

            logger.debug("Inserting rows");

            taskStatus.message("Inserting rows");

            it = featureSet.fastIterator();

            while (it.hasNext()) {

                Feature feature = (Feature) it.next();

                this.taskStatus.setCurValue(featureCount);

                targetFeature = target.createNewFeature(targetFeatureType, feature);

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

                    if (i == sourceGeometryIndex) {

                        // Es facil que los campos geometria no se llamen igual, asi que

                        // el campo geometria lo asignamos a capon.

                        // Esto puede ocasionar problemas cuando la tabla destino no tenga

                        // geometria o tenga mas de una.

                        targetFeature.set(targetGeometryIndex, feature.get(sourceGeometryIndex));

                    } else {

                        FeatureAttributeDescriptor x = sourceFeatureType.getAttributeDescriptor(i);

                        int targetAttributeIndex = targetFeatureType.getIndex(getTranslatedIdentifier(x.getName()));

                        if (targetAttributeIndex < 0) {

                            throw new RuntimeException("Can't locate column '" + x.getName() + "' in the target table.");

                        }

                        targetFeature.set(targetAttributeIndex, feature.get(x.getName()));

                    }

                }

                Geometry geometry = targetFeature.getGeometry(targetGeometryIndex);

                FixGeometryStatus check = ExportGeometryUtils.fixGeometry(options, coord_trans, geometry);

                switch(check.getState()) {

                    case FixGeometryStatus.STATE_OK:

                        targetFeature.setDefaultGeometry(check.getGeometry());

                        break;

                    case FixGeometryStatus.STATE_SKIP:

                        continue;

                    case FixGeometryStatus.STATE_ABORT:

                        throw new InvalidGeometryException(targetFeature, check.getMessage());

                }

                target.insert(targetFeature);

                if (this.taskStatus.isCancellationRequested()) {

                    return;

                }

                featureCount++;

            }

            String msgRowCount = MessageFormat.format(" ({0,number, #,###} rows)",featureCount);

            targetFeature = null;

            taskStatus.setIndeterminate();

            logger.debug("Finish editing"+msgRowCount);

            if( featureCount > 50000 ) {

                taskStatus.message("Finishing insertion of records, may take a while" + msgRowCount);

            } else {

                taskStatus.message("Finishing insertion of records"+msgRowCount);

            }

            target.finishEditing();

             if (this.options.canCreatetable()) {

                taskStatus.message("Preparing the update of the indices"+msgRowCount);

                target.edit();

                EditableFeatureType ft = target.getDefaultFeatureType().getEditable();

                for( FeatureAttributeDescriptor attr : this.targetFeatureType) {

                    EditableFeatureAttributeDescriptor attr2 = (EditableFeatureAttributeDescriptor) ft.getAttributeDescriptor(attr.getName());

                    if( attr2!=null ) {

                        //attr2.setIsPrimaryKey(attr.isPrimaryKey());

                        attr2.setIsIndexed(attr.isIndexed());

                        attr2.setIsAutomatic(attr.isAutomatic());

                    }

                }

                target.update(ft);

                taskStatus.message("Updating the indices"+msgRowCount);

                target.finishEditing();

            }

            if (this.options.getUpdateTableStatistics()) {

                logger.debug("Updating statistics");

                taskStatus.message("Updating statistics"+msgRowCount);

                explorer.updateTableStatistics(

                        openParams.getDBName(),

                        openParams.getSchema(),

                        openParams.getTable()

                );

            }

            logger.debug("finish");

            taskStatus.message("Exportation finished");

            this.taskStatus.terminate();

            if (exporttoServiceFinishAction != null) {

                exporttoServiceFinishAction.finished(

                        this.options.getTableName() + " (" + explorer.getStoreName() + ")",

                        openParams);

            }

        } catch (Exception e) {

            logger.warn("Can't export data.", e);

            taskStatus.message("Problems exporting data");

            throw new ExporttoServiceException(e, targetFeature);

        } finally {

            if (it != null) {

                it.dispose();

            }

            featureSet.dispose();

            if (target != null) {

                if( target.isAppending() ) {

                    try {

                        target.cancelEditing();

                    } catch(Exception ex) {

                        logger.warn("Can't cancel editing.",ex);

                    }

                }

                target.dispose();

            }

            this.taskStatus.terminate();

            this.taskStatus.remove();

        }

    }

    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 void setFinishAction(

            ExporttoServiceFinishAction exporttoServiceFinishAction) {

        this.exporttoServiceFinishAction = exporttoServiceFinishAction;

    }

}