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 java.util.function.Predicate;

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.fmap.dal.feature.FeatureStoreNotification;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.identitymanagement.IdentityUtils;

/**

 *

 * @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();

            FeatureStore store = this.parameters.getStore();

            if( !IdentityUtils.isAuthorized(

                    "tools-updatetable", store, store.getFullName()) ) {

                this.status.message("User not authotized to this action");

                return;

            }

            this.transaction = dataManager.createTransaction();

            this.transaction.begin();

            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 {

        Predicate<FeatureStoreNotification> saveNotificationsFilter = null;

        FeatureStore store = this.parameters.getStore();

        try {

            saveNotificationsFilter = store.setNotificationsFilter(new StoreNotificationsFilter());

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

        } finally {

            store.setNotificationsFilter(saveNotificationsFilter);

        }

    }

    public void update_selection() throws DataException {

        Predicate<FeatureStoreNotification> saveNotificationsFilter = null;

        FeatureStore store = this.parameters.getStore();

        try {

            saveNotificationsFilter = store.setNotificationsFilter(new StoreNotificationsFilter());

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

        } finally {

            store.setNotificationsFilter(saveNotificationsFilter);

        }

    }

    public void update_all() throws DataException {

        Predicate<FeatureStoreNotification> saveNotificationsFilter = null;

        FeatureStore store = this.parameters.getStore();

        try {

            saveNotificationsFilter = store.setNotificationsFilter(new StoreNotificationsFilter());

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

        } finally {

            store.setNotificationsFilter(saveNotificationsFilter);

        }

    }

    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;

    }

    private class StoreNotificationsFilter implements Predicate<FeatureStoreNotification> {

        @Override

        public boolean test(FeatureStoreNotification t) {

            if( t!=null ) {

                switch(t.getType()) {

                    case FeatureStoreNotification.AFTER_UPDATE:

                    case FeatureStoreNotification.BEFORE_UPDATE:

                        return true;

                }

                LOGGER.info(t.getType());

            }

            return false;

        }

    }

}