Application: gvSIG desktop

/*

 * 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.app.extension.updatetable;

import java.util.List;

import org.gvsig.app.extension.updatetable.UpdateTableProcessParameters.ProcessFieldParameters;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

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

import org.gvsig.fmap.dal.expressionevaluator.FeatureSymbolTable;

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

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

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

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

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

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

import org.gvsig.tools.dataTypes.DataTypeUtils;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.dal.DataTransaction;

import org.gvsig.tools.dispose.DisposeUtils;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class UpdateTableProcessImpl implements UpdateTableProcess {

    protected final Logger LOGGER = LoggerFactory.getLogger(UpdateTableProcessImpl.class);

    private UpdateTableProcessParameters parameters;

    private SimpleTaskStatus status;

    private Runnable postprocess;

    private FeatureSymbolTable featureSymbolTable;

    private DataTransaction transaction;

    private MutableSymbolTable out;

    public UpdateTableProcessImpl() {

    }

    public UpdateTableProcessImpl(UpdateTableProcessParameters parameters, SimpleTaskStatus status, Runnable postprocess) {

        this();

        this.parameters = parameters;

        this.status = status;

        this.postprocess = postprocess;

    }

    @Override

    public void start() {

        Thread th = new Thread(

                () -> {

                    try {

                        run();

                    } catch (Exception ex) {

                        LOGGER.warn("Can't process table update.");

                    }

                },

                "UpdateTableProcess"

        );

        th.start();

    }

    @Override

    public void run() {

        try {

            DataManager dataManager = DALLocator.getDataManager();

            this.transaction = dataManager.createTransaction();

            this.transaction.begin();

            FeatureStore store = this.parameters.getStore();

            this.transaction.add(store, false);

            this.status.setTitle("Update table '" + store.getName() + "'");

            this.status.setIndeterminate();

            this.featureSymbolTable = dataManager.createFeatureSymbolTable();

            switch (this.parameters.getRowsToProcess()) {

                case UpdateTableProcessParameters.BATCHUPDATE_PROCESS_ALL:

                    update_all();

                    break;

                case UpdateTableProcessParameters.BATCHUPDATE_PROCESS_SELECTION:

                    update_selection();

                    break;

                case UpdateTableProcessParameters.BATCHUPDATE_PROCESS_EDITEDS:

                    update_editeds();

                    break;

            }

            if (this.status.isCancelled()) {

                abortEditing();

                DataTransaction.rollbackQuietly(this.transaction);

                this.status.message("Operation cancelled by user");

            } else {

                endEditing();

                this.transaction.commit();

                this.status.terminate();

                this.output();

                out.setVar("store", store);

                if (postprocess != null) {

                    postprocess.run();

                }

            }

        } catch (Exception ex) {

            DataTransaction.rollbackQuietly(this.transaction);

            this.status.abort();

            this.status.message("Can't update features");

        } finally {

            DisposeUtils.dispose(this.transaction);

        }

    }

    public void update_editeds() throws DataException {

        FeatureStore store = this.parameters.getStore();

        Expression filter = this.parameters.getFilter();

        List<FeatureReference> set = store.getEditedFeatures();

        if( set.isEmpty() ) {

            return;

        }

        this.beginEditing();

        long rows = set.size();

        this.status.setRangeOfValues(0, rows);

        for (FeatureReference featureReferfence : set) {

            this.status.incrementCurrentValue();

            if (this.status.isCancellationRequested()) {

                this.status.cancel();

                this.abortEditing();

                return;

            }

            Feature feature = featureReferfence.getFeature();

            this.featureSymbolTable.setFeature(feature);

            boolean sholdProcessFeature = DataTypeUtils.toBoolean(filter.execute(featureSymbolTable), false);

            if (!sholdProcessFeature) {

                continue;

            }

            EditableFeature editable_feature = feature.getEditable();

            process_feature(editable_feature);

            store.update(editable_feature);

            restart_editing();

        }

        this.endEditing();

    }

    public void update_selection() throws DataException {

        FeatureStore store = this.parameters.getStore();

        Expression filter = this.parameters.getFilter();

        FeatureSet set = store.getFeatureSelection();

        this.beginEditing();

        long rows = set.getSize();

        this.status.setRangeOfValues(0, rows);

        for (Feature feature : set) {

            this.status.incrementCurrentValue();

            if (this.status.isCancellationRequested()) {

                this.status.cancel();

                this.abortEditing();

                return;

            }

            this.featureSymbolTable.setFeature(feature);

            if( filter!=null ) {

                boolean sholdProcessFeature = DataTypeUtils.toBoolean(filter.execute(featureSymbolTable), false);

                if (!sholdProcessFeature) {

                    continue;

                }

            }

            EditableFeature editable_feature = feature.getEditable();

            process_feature(editable_feature);

            set.update(editable_feature);

            restart_editing();

        }

        this.endEditing();

    }

    public void update_all() throws DataException {

        FeatureStore store = this.parameters.getStore();

        Expression filter = this.parameters.getFilter();

        FeatureQuery query = store.createFeatureQuery(filter);

        FeatureSet set = store.getFeatureSet(query);

        this.transaction.add(set);

        this.beginEditing();

        long rows = set.getSize();

        this.status.setRangeOfValues(0, rows);

        for (Feature feature : set) {

            this.status.incrementCurrentValue();

            if (this.status.isCancellationRequested()) {

                this.status.cancel();

                this.abortEditing();

                return;

            }

            EditableFeature editable_feature = feature.getEditable();

            process_feature(editable_feature);

            set.update(editable_feature);

            restart_editing();

        }

        this.endEditing();

    }

    private void process_feature(EditableFeature feature) {

        for (ProcessFieldParameters field : parameters) {

            if (!field.isUpdate()) {

                continue;

            }

            Expression expression = field.getExpression();

            if (expression == null || expression.isPhraseEmpty()) {

                continue;

            }

            this.featureSymbolTable.setFeature(feature);

            Object x = expression.execute(this.featureSymbolTable);

            feature.set(field.getName(), x);

        }

    }

    private void beginEditing() throws DataException {

        if( this.parameters.getRowsToProcess()==UpdateTableProcessParameters.BATCHUPDATE_PROCESS_EDITEDS ) {

            // Si hemos de procesar las editadas, mantenemos el modo de edicion

            // que hubiese, que deberia ser MODE_FULLEDIT.

            return;

        }

        if (!this.parameters.isBeginEditIfNeed()) {

            return;

        }

        FeatureStore store = this.parameters.getStore();

        if (store.getMode() != FeatureStore.MODE_QUERY) {

            if (this.parameters.isFinishAndRestarEdit()) {

                store.finishEditing();

            }

        }

        store.edit(this.parameters.getEditMode());

    }

    private void endEditing() throws DataException {

        if (this.parameters.isFinishEditAfterTerminate()) {

            FeatureStore store = this.parameters.getStore();

            if( store.getMode() != FeatureStore.MODE_QUERY ) {

                store.finishEditing();

            }

        }

    }

    private void abortEditing() throws DataException {

        if (this.parameters.isFinishEditAfterTerminate()) {

            FeatureStore store = this.parameters.getStore();

            if( store.getMode() != FeatureStore.MODE_QUERY ) {

                store.cancelEditing();

            }

        }

    }

    private void restart_editing() throws DataException {

        if( this.parameters.getRowsToProcess()==UpdateTableProcessParameters.BATCHUPDATE_PROCESS_EDITEDS ) {

            // Si estamos procesando las editadas no reiniciamos la edicion nunca

            // ya que perderiamos las features editadas.

            return;

        }

        int n = this.parameters.getFinishAndRestarEditEach();

        if (n < 1) {

            return;

        }

        FeatureStore store = this.parameters.getStore();

        switch (store.getMode()) {

            case FeatureStore.MODE_PASS_THROUGH:

            case FeatureStore.MODE_APPEND:

                return;

            case FeatureStore.MODE_FULLEDIT:

            default:

                break;

        }

        if (store.getMode() != FeatureStore.MODE_FULLEDIT) {

            return;

        }

        if (store.getPendingChangesCount() < n) {

            return;

        }

        store.finishEditing();

        store.edit(this.parameters.getEditMode());

    }

    @Override

    public UpdateTableProcess parameters(UpdateTableProcessParameters params) {

        this.parameters = params;

        return this;

    }

    @Override

    public UpdateTableProcess status(SimpleTaskStatus taskStatus) {

        this.status = taskStatus;

        return this;

    }

    @Override

    public UpdateTableProcess postProcess(Runnable postProcess) {

        this.postprocess = postProcess;

        return this;

    }

    @Override

    public UpdateTableProcessParameters createParameters() {

        return new UpdateTableProcessParametersImpl();

    }

    @Override

    public SymbolTable output() {

        if( this.out == null ) {

            this.out = ExpressionUtils.createSymbolTable();

        }

        return this.out;

    }

}