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

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

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

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

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);

    public static final int CHECK_NONE = 0;

    public static final int CHECK_IF_CORRUPT = 1;

    public static final int CHECK_IF_VALID = 2;

    public static final int ACTION_SET_GEOMETRY_TO_NULL = 0;

    public static final int ACTION_SKIP_FEATURE = 1;

    public static final int ACTION_ABORT = 2;

    private final FeatureStore source;

    private final JDBCServerExplorerParameters explorerParameters;

    private final String tableName;

    private final String pkname;

    private final int geometryChecks;

    private final int geometryChecksAction;

    private final IProjection tarjetProjection;

    private final boolean canCreateTable;

    private final boolean tryToFixGeometries;

    private ExporttoServiceFinishAction exporttoServiceFinishAction = null;

    public ExporrtoJDBCService(FeatureStore source,

            JDBCServerExplorerParameters explorerParameters,

            String tablename,

            String primaryKeyName,

            IProjection tarjetProjection,

            boolean canCreatetable,

            int geometryChecks,

            int geometryChecksAction,

            boolean tryToFixGeometries) {

        this.source = source;

        this.explorerParameters = explorerParameters;

        this.tableName = tablename;

        this.pkname = primaryKeyName;

        this.tarjetProjection = tarjetProjection;

        this.canCreateTable = canCreatetable;

        this.geometryChecks = geometryChecks;

        this.geometryChecksAction = geometryChecksAction;

        this.tryToFixGeometries = tryToFixGeometries;

    }

    protected void createTable(JDBCServerExplorer explorer) throws Exception {

        FeatureType targetFeatureType;

        EditableFeatureType targetEditableFeatureType;

        targetFeatureType = source.getDefaultFeatureType().getCopy();

        targetEditableFeatureType = targetFeatureType.getEditable();

        if (this.pkname != null) {

            EditableFeatureAttributeDescriptor pk = (EditableFeatureAttributeDescriptor) targetEditableFeatureType.get(pkname);

            if (pk == null) {

                pk = targetEditableFeatureType.add(this.pkname, DataTypes.LONG);

                pk.setIsPrimaryKey(true);

                pk.setIsAutomatic(true);

            } else {

                pk.setIsPrimaryKey(true);

            }

        }

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

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

        EditableFeatureAttributeDescriptor attrdescriptor

                = (EditableFeatureAttributeDescriptor) targetEditableFeatureType.getDefaultGeometryAttribute();

        if (attrdescriptor != null) {

            attrdescriptor.setSRS(this.tarjetProjection);

        }

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

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

        createTableParams.setDefaultFeatureType(targetEditableFeatureType);

        //createTableParams.setTable(this.tableName); // ?????

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

    }

    private static class InvalidGeometryException extends ExporttoServiceException {

        public InvalidGeometryException(Feature feature, String checkMessage) {

            super(checkMessage, null, checkMessage, 0);

            this.feature = feature;

        }

    }

    public void export(FeatureSet featureSet) throws ExporttoServiceException {

        Geometry.ValidationStatus geometryCheck;

        DisposableIterator it = null;

        EditableFeature targetFeature = null;

        FeatureStore target = null;

        try {

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

            // Reprojection 

            FeatureAttributeDescriptor geo_att = source.getDefaultFeatureType().getDefaultGeometryAttribute();

            IProjection sourceProjection = null;

            ICoordTrans coord_trans = null;

            Geometry reproj_geom = null;

            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 != this.tarjetProjection) {

                    coord_trans = sourceProjection.getCT(this.tarjetProjection);

                }

            }

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

            DataManager dataManager = DALLocator.getDataManager();

            JDBCServerExplorer explorer = (JDBCServerExplorer) dataManager.openServerExplorer(

                    this.explorerParameters.getExplorerName(),

                    this.explorerParameters

            );

            if (this.canCreateTable) {

                this.createTable(explorer);

            }

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

            openParams.setTable(this.tableName);

            openParams.setCRS(this.tarjetProjection);

            openParams.setDefaultGeometryField(

                    source.getDefaultFeatureType().getDefaultGeometryAttributeName()

            );

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

            FeatureType targetFeatureType = target.getDefaultFeatureType();

            target.edit(FeatureStore.MODE_APPEND);

            int featureCount = 1;

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

            it = featureSet.fastIterator();

            while (it.hasNext()) {

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

                targetFeature = target.createNewFeature(targetFeatureType, feature);

                Geometry geometry = targetFeature.getDefaultGeometry();

                if (geometry != null) {

                    switch (this.geometryChecks) {

                        case CHECK_IF_CORRUPT:

                            geometryCheck = geometry.getValidationStatus();

                            if (geometryCheck.getStatusCode() == Geometry.ValidationStatus.CURRUPTED) {

                                switch (this.geometryChecksAction) {

                                    case ACTION_SET_GEOMETRY_TO_NULL:

                                        targetFeature.setDefaultGeometry(null);

                                        break;

                                    case ACTION_SKIP_FEATURE:

                                        continue;

                                    case ACTION_ABORT:

                                    default:

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

                                }

                            }

                            break;

                        case CHECK_IF_VALID:

                            geometryCheck = geometry.getValidationStatus();

                            if (!geometryCheck.isValid()) {

                                Geometry g = null;

                                if (this.tryToFixGeometries) {

                                    g = geometry.makeValid();

                                    if (g != null) {

                                        targetFeature.setDefaultGeometry(g);

                                    }

                                }

                                if (g == null) {

                                    switch (this.geometryChecksAction) {

                                        case ACTION_SET_GEOMETRY_TO_NULL:

                                            targetFeature.setDefaultGeometry(null);

                                            break;

                                        case ACTION_SKIP_FEATURE:

                                            continue;

                                        case ACTION_ABORT:

                                        default:

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

                                    }

                                }

                            }

                            break;

                        case CHECK_NONE:

                        default:

                            break;

                    }

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

                    // Reprojection 

                    if (geo_att != null && coord_trans != null) {

                        reproj_geom = targetFeature.getDefaultGeometry();

                        reproj_geom = reproj_geom.cloneGeometry();

                        reproj_geom.reProject(coord_trans);

                        targetFeature.setDefaultGeometry(reproj_geom);

                    }

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

                }

                target.insert(targetFeature);

                this.taskStatus.setCurValue(featureCount);

                if (this.taskStatus.isCancellationRequested()) {

                    return;

                }

                featureCount++;

            }

            targetFeature = null;

            target.finishEditing();

            if (exporttoServiceFinishAction != null) {

                exporttoServiceFinishAction.finished(

                        this.tableName + " (" + explorer.getStoreName() + ")",

                        openParams);

            }

        } catch (Exception e) {

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

            taskStatus.message(e.getMessage());

            throw new ExporttoServiceException(e, targetFeature);

        } finally {

            if (it != null) {

                it.dispose();

            }

            featureSet.dispose();

            if (target != null) {

                target.dispose();

            }

            this.taskStatus.terminate();

            this.taskStatus.remove();

        }

    }

    public void setFinishAction(

            ExporttoServiceFinishAction exporttoServiceFinishAction) {

        this.exporttoServiceFinishAction = exporttoServiceFinishAction;

    }

}