Application: gvSIG desktop

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

            throw new IllegalStateException("Can't start export process, need setting output format.");

        }

        if (this.parameters == null) {

            throw new IllegalStateException("Can't start export process, need setting parameters.");

        }

        try {

            FeatureSet featureSet;

             FeatureQuery exportFeatureQuery;

            if (this.featureQuery!=null) {

                exportFeatureQuery = this.featureQuery.getCopy();

                exportFeatureQuery.clearFilter();

                exportFeatureQuery.retrievesAllAttributes();

            } else {

                exportFeatureQuery = null;

            }

            switch (this.parameters.getFeaturesToUse()) {

                case ExportParameters.USE_ALL_FEATURES:

                default:

                    featureSet = this.parameters.getSourceFeatureStore().getFeatureSet(exportFeatureQuery);

                    break;

                case ExportParameters.USE_SELECTED_FEATURES:

                    featureSet = this.parameters.getSourceFeatureStore().getFeatureSelection();

                    break;

                case ExportParameters.USE_FILTERED_FEATURES:

                    if (exportFeatureQuery!=null) {

                        exportFeatureQuery.setFilter(this.parameters.getFeatureQuery().getExpressionFilter());

                    } else {

                        exportFeatureQuery = this.parameters.getFeatureQuery();

                    }

                    if (exportFeatureQuery!=null) {

                        exportFeatureQuery.retrievesAllAttributes();

                    }

                    featureSet = this.parameters.getSourceFeatureStore().getFeatureSet(exportFeatureQuery);

                    break;

            }

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

            this.parameters.resetVolatileValues();

            service.setTaskStatus(taskStatus);

            service.export(featureSet);

            this.targetOpenStoreParameters = service.getTargetOpenStoreParameters();

        } catch (Exception ex) {

            throw new RuntimeException(ex);

        }

    }

    @Override

    public List<OpenDataStoreParameters> getTargetOpenStoreParameters() {

        return this.targetOpenStoreParameters;

    }

    @Override

    public void setFilterExpression(Expression expression

    ) {

        this.filterExpression = expression;

        if (this.parameters != null) {

            this.parameters.setFilterExpresion(expression);

        }

        if (expression == null) {

            if (this.sourceFeatureStore != null) {

                try {

                    FeatureSelection selection = this.sourceFeatureStore.getFeatureSelection();

                    if (selection != null && selection.size() > 0) {

                        this.setFeaturesToUse(ExportParameters.USE_SELECTED_FEATURES);

                    } else {

                        this.setFeaturesToUse(ExportParameters.USE_ALL_FEATURES);

                    }

                } catch (DataException ex) {

                    this.setFeaturesToUse(ExportParameters.USE_ALL_FEATURES);

                }

            }

        } else {

            this.setFeaturesToUse(ExportParameters.USE_FILTERED_FEATURES);

        }

    }

    @Override

    public void setFeaturesToUse(int featuresToUse

    ) {

        this.featuresToUse = featuresToUse;

        if (this.parameters != null) {

            this.parameters.setFeaturesToUse(featuresToUse);

        }

    }

    @Override

    public void setFeatureQuery(FeatureQuery featureQuery) {

        this.featureQuery = featureQuery;

    }

}