Application: gvSIG desktop

package org.gvsig.export.spi;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.export.ExportAttributes;

import org.gvsig.export.ExportException;

import org.gvsig.export.ExportLocator;

import org.gvsig.export.ExportParameters;

import org.gvsig.export.ExportParametersGeometry;

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

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.NewDataStoreParameters;

import org.gvsig.fmap.dal.OpenDataStoreParameters;

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

public abstract class AbstractExportService

        implements ExportService {

    protected static final Logger LOG = LoggerFactory.getLogger(AbstractExportService.class);

    private final ExportParameters parameters;

    private final Set<ExportFinishListener> finishListeners;

//    protected AttributeNamesTranslator attributeNamesTranslator;

    private SimpleTaskStatus taskStatus;

    private final ExportServiceFactory factory;

    protected AbstractExportService(ExportServiceFactory factory, ExportParameters parameters) {

        this.factory = factory;

        this.parameters = parameters;

        this.finishListeners = new HashSet<>();

    }

    @Override

    public ExportParameters getParameters() {

        return this.parameters;

    }

    @Override

    public ExportServiceFactory getFactory() {

        return factory;

    }

    @Override

    public void addFinishListener(ExportFinishListener listener) {

        this.finishListeners.add(listener);

    }

    protected void fireFinishedListener() {

        for (ExportFinishListener listener : finishListeners) {

            try {

                listener.finished(this);

            } catch (Exception ex) {

            }

        }

    }

    protected void fireCancelledListeners() {

        for (ExportFinishListener listener : finishListeners) {

            try {

                listener.cancelled(this);

            } catch (Exception ex) {

            }

        }

    }

    @Override

    public SimpleTaskStatus getTaskStatus() {

        if (this.taskStatus == null) {

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

        }

        return this.taskStatus;

    }

    @Override

    public void setTaskStatus(SimpleTaskStatus taskStatus) {

        this.taskStatus = taskStatus;

    }

    @Override

    public boolean isCancellationRequested() {

        return this.getTaskStatus().isCancellationRequested();

    }

    @Override

    public void cancelRequest() {

        this.getTaskStatus().cancelRequest();

    }

//    @Override

//    public AttributeNamesTranslator getAttributeNamesTranslator() {

//        if (attributeNamesTranslator == null) {

//            this.attributeNamesTranslator = ExportLocator.getServiceManager().createAttributeNamesTranslator();

//        }

//        return this.attributeNamesTranslator;

//    }

    @Override

    public List<OpenDataStoreParameters> getTargetOpenStoreParameters() throws ExportException {

        List<OpenDataStoreParameters> r = new ArrayList<>();

        r.add(this.createTargetOpenStoreParameters());

        return r;

    }

    abstract protected DataServerExplorer createServerExplorer() throws ExportException;

    abstract protected NewDataStoreParameters createTargetNewStoreParameters() throws ExportException;

    abstract protected OpenDataStoreParameters createTargetOpenStoreParameters() throws ExportException;

    protected static class InvalidGeometryException extends ExportException {

        public InvalidGeometryException(Feature feature, String checkMessage) {

            super(checkMessage, feature);

        }

    }

    @Override

    public void export(FeatureSet featureSet) throws ExportException {

        DataServerExplorer explorer = createServerExplorer();

        NewDataStoreParameters newStoreParameters = createTargetNewStoreParameters();

        OpenDataStoreParameters openStoreParameters = createTargetOpenStoreParameters();

        String providerName = newStoreParameters.getDataStoreName();

        String explorerName = explorer.getProviderName();

        DisposableIterator it = null;

        FeatureStore target = null;

        EditableFeature targetFeature = null;

        try {

            this.getTaskStatus().setRangeOfValues(0, featureSet.getSize());

            DataManager dataManager = DALLocator.getDataManager();

            dataManager.newStore(explorerName, providerName, newStoreParameters, true);

            target = (FeatureStore) dataManager.openStore(providerName, openStoreParameters);

            FeatureType theTargetFeatureType;

            if (this.getParameters().getExportAttributes().isActive()) {

                theTargetFeatureType = this.getParameters().getExportAttributes().getTargetFeatureType();

            } else {

                theTargetFeatureType = target.getDefaultFeatureType();

            }

            FeatureType theSourceFeatureType = featureSet.getDefaultFeatureType();

            ExportGeometryHelper geomHelper = null;

            if (this.getParameters() instanceof ExportParametersGeometry) {

                geomHelper = ExportLocator.getServiceManager().createGeometryHelper(

                        (ExportParametersGeometry) this.getParameters(),

                        theTargetFeatureType,

                        theSourceFeatureType

                );

                if (!geomHelper.canProcessGeometry()) {

                    geomHelper = null;

                }

            }

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

            target.edit(FeatureStore.MODE_APPEND);

            it = featureSet.fastIterator();

            long featureCount = 1;

            while (it.hasNext()) {

                this.getTaskStatus().setCurValue(featureCount);

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

                targetFeature = target.createNewFeature(true); //theTargetFeatureType, true);

                copyValues(sourceFeature, targetFeature);

                if (geomHelper != null) {

                    switch (geomHelper.copyGeometry(sourceFeature, targetFeature)) {

                        case FixGeometryStatus.STATE_OK:

                            break;

                        case FixGeometryStatus.STATE_SKIP:

                            continue;

                        case FixGeometryStatus.STATE_ABORT:

                            throw new InvalidGeometryException(targetFeature, geomHelper.getLastErrorMessage());

                    }

                }

                target.insert(targetFeature);

                featureCount++;

                if (this.getTaskStatus().isCancellationRequested()) {

                    return;

                }

            }

            target.finishEditing();

            this.getTaskStatus().terminate();

            this.getTaskStatus().remove();

            fireFinishedListener();

        } catch (Exception e) {

            fireCancelledListeners();

            throw new ExportException(e, targetFeature);

        } finally {

            DisposeUtils.dispose(it);

            DisposeUtils.dispose(featureSet);

            DisposeUtils.dispose(target);

        }

    }

    protected void copyValues(Feature source, EditableFeature target) {

        FeatureType sourceType = source.getType();

        FeatureType targetType = target.getType();

        ExportAttributes exp = this.getParameters().getExportAttributes();

        boolean isActive = exp.isActive();

        for (FeatureAttributeDescriptor targetAttr : targetType) {

            if (targetAttr.isReadOnly() || targetAttr.isComputed()) {

                continue;

            }

            String targetAttrName = targetAttr.getName();

            //translate field

            FeatureAttributeDescriptor sourceAttr;

            String sourceAttrName;            

            if (isActive) {

                sourceAttrName = exp.getSourceName(targetAttrName);

                for (ExportAttributes.ExportAttribute exportAttribute : exp) {

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

                        sourceAttrName = exportAttribute.getName();

                    }

                }

                sourceAttr = sourceType.getAttributeDescriptor(sourceAttrName);

            } else {

                sourceAttrName = targetAttrName;

                sourceAttr = sourceType.getAttributeDescriptor(targetAttrName);

            }            

            if (sourceAttr != null) {

                Object value = source.get(sourceAttrName);                

                if (value == null) {

                    if (targetAttr.allowNull()) {

                        target.set(targetAttrName, null);

                    }

                } else {

                    target.set(targetAttrName, value);

                }

            } else if (sourceAttr==null && source.hasExtraValue(sourceAttrName)) {

                    Object value = source.getExtraValue(sourceAttrName);

                    target.set(targetAttrName, value);

                }

            }

        }

    }