gvSIG projects pool

/*

 * gvSIG. Desktop Geographic Information System.

 * 

 * Copyright (C) 2007-2020 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, see <https://www.gnu.org/licenses/>. 

 * 

 * 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.vcsgis.swing.impl.changes;

import java.awt.Component;

import java.awt.Cursor;

import java.awt.Dimension;

import java.awt.event.ActionEvent;

import java.awt.event.KeyAdapter;

import java.awt.event.KeyEvent;

import java.sql.Timestamp;

import java.util.Date;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.List;

import java.util.Set;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.json.JsonObject;

import javax.swing.JButton;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JTable;

import javax.swing.JTextField;

import javax.swing.ListSelectionModel;

import javax.swing.SwingUtilities;

import javax.swing.event.ChangeEvent;

import javax.swing.event.ListSelectionEvent;

import javax.swing.event.TableModelEvent;

import javax.swing.event.TableModelListener;

import javax.swing.table.DefaultTableCellRenderer;

import javax.swing.table.TableModel;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.mutable.MutableObject;

import org.gvsig.featureform.swing.CreateJFeatureFormException;

import org.gvsig.featureform.swing.JFeatureForm;

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

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

import org.gvsig.fmap.dal.swing.DALSwingLocator;

import org.gvsig.fmap.dal.swing.DataSwingManager;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.swing.api.ToolsSwingManager;

import org.gvsig.tools.swing.api.pickercontroller.DatePickerController;

import org.gvsig.tools.swing.api.pickercontroller.PickerController;

import org.gvsig.tools.swing.api.threadsafedialogs.ThreadSafeDialogsManager;

import org.gvsig.tools.swing.api.windowmanager.WindowManager;

import org.gvsig.tools.swing.api.windowmanager.WindowManager_v2;

import org.gvsig.topology.lib.api.TopologyLocator;

import org.gvsig.topology.lib.api.TopologyManager;

import org.gvsig.topology.lib.api.TopologyPlan;

import org.gvsig.topology.swing.api.JTopologyReport;

import org.gvsig.topology.swing.api.TopologySwingLocator;

import org.gvsig.topology.swing.api.TopologySwingManager;

import org.gvsig.vcsgis.lib.VCSGisChange;

import org.gvsig.vcsgis.lib.VCSGisEntity;

import org.gvsig.vcsgis.lib.VCSGisLocator;

import org.gvsig.vcsgis.lib.VCSGisManager;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_OK;

import static org.gvsig.vcsgis.lib.VCSGisManager.OP_ADD_ENTITY;

import static org.gvsig.vcsgis.lib.VCSGisManager.OP_DELETE;

import org.gvsig.vcsgis.lib.workspace.VCSGisWorkspace;

import org.gvsig.vcsgis.lib.workspace.VCSGisWorkspaceChange;

import org.gvsig.vcsgis.lib.workspace.VCSGisWorkspaceChanges;

import org.gvsig.vcsgis.lib.workspace.VCSGisWorkspaceEntity;

import org.gvsig.vcsgis.swing.VCSGisSwingLocator;

import org.gvsig.vcsgis.swing.VCSGisSwingManager;

import org.gvsig.vcsgis.swing.VCSGisSwingServices;

import static org.gvsig.vcsgis.swing.VCSGisSwingServices.HIGHLIGHT_WORKSPACE;

import static org.gvsig.vcsgis.swing.VCSGisSwingServices.HIGHLIGHT_WORKSPACE_PREVIOUS;

import org.gvsig.vcsgis.swing.impl.VCSGisSwingCommons;

import static org.gvsig.vcsgis.swing.impl.VCSGisSwingCommons.cleanHighligthed;

import static org.gvsig.vcsgis.swing.impl.VCSGisSwingCommons.notInSwingThreadInvokeLater;

import static org.gvsig.vcsgis.swing.impl.VCSGisSwingCommons.refreshDocument;

/**

 *

 * @author gvSIG Team

 */

public class LocalChangesController {

    private final JTable tblLocalChanges;

    private final JButton btnLocalCheckAll;

    private final JButton btnLocalUnCheckAll;

    private final JButton btnLocalShowForm;

    private final JButton btnLocalRefresh;

    private final JButton btnLocalCommit;

    private final JButton btnLocalRevert;

    private final JLabel lblLocalEffectiveDate;

    private final JTextField txtLocalEffectiveDate;

    private final JTextField txtLocalComment;

    private final JButton btnLocalEffectiveDate;

    private final JLabel lblLocalComment;

    private final PickerController<VCSGisWorkspace> workspacePicker;    

    private final VCSGisJChangesImpl context;

    private final JButton btnLocalZoom;

    private final JButton btnLocalCenter;

    private final JLabel lblLocalChangesCount;

    private VCSGisWorkspaceChanges<VCSGisWorkspaceChange> changes;

    private ChangesTableModel localChangesTableModel;

    private List<VCSGisWorkspaceEntity> entitiesWithChanges = null;

    private DatePickerController effectiveDatePicker;

    private final Set<String> entitiesToUnCheckAll;

    private TableModelListener tableModelListener;

    private boolean dissabledUncheckAllByEntities;

    private final JButton btnLocalCleanHighlighted;

    public LocalChangesController(

        VCSGisJChangesImpl context,

        PickerController<VCSGisWorkspace> workspacePicker,

        JTable tblLocalChanges,

        JButton btnLocalCheckAll,

        JButton btnLocalUnCheckAll,

        JButton btnLocalShowForm,

        JButton btnLocalRefresh,

        JButton btnLocalCommit,

        JButton btnLocalRevert,

        JLabel lblLocalEffectiveDate,

        JTextField txtLocalEffectiveDate,

        JTextField txtLocalComment,

        JButton btnLocalEffectiveDate,

        JLabel lblLocalComment,

        JButton btnLocalZoom,

        JButton btnLocalCenter,

        JButton btnLocalCleanHighlighted,

        JLabel lblLocalChangesCount

        ) {

        this.dissabledUncheckAllByEntities = false;

        this.context = context;

        this.workspacePicker = workspacePicker;

        this.tblLocalChanges = tblLocalChanges;

        this.btnLocalCheckAll = btnLocalCheckAll;

        this.btnLocalCommit = btnLocalCommit;

        this.btnLocalEffectiveDate = btnLocalEffectiveDate;

        this.btnLocalRefresh = btnLocalRefresh;

        this.btnLocalRevert = btnLocalRevert;

        this.btnLocalShowForm = btnLocalShowForm;

        this.btnLocalUnCheckAll = btnLocalUnCheckAll;

        this.lblLocalComment = lblLocalComment;

        this.lblLocalEffectiveDate = lblLocalEffectiveDate;

        this.txtLocalComment = txtLocalComment;

        this.txtLocalEffectiveDate = txtLocalEffectiveDate;

        this.btnLocalZoom = btnLocalZoom;

        this.btnLocalCenter = btnLocalCenter;

        this.btnLocalCleanHighlighted = btnLocalCleanHighlighted;

        this.lblLocalChangesCount= lblLocalChangesCount;

        this.entitiesToUnCheckAll = new HashSet<>();

        initComponents();

    }

    private void initComponents() {

        ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

        translate();

        this.btnLocalCheckAll.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

        this.btnLocalCommit.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

        this.btnLocalEffectiveDate.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

        this.btnLocalRefresh.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

        this.btnLocalRevert.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

        this.btnLocalShowForm.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

        this.btnLocalUnCheckAll.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

        this.btnLocalZoom.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

        this.btnLocalCenter.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

        this.btnLocalCleanHighlighted.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

        this.workspacePicker.addChangeListener((ChangeEvent e) -> {

            doUpdateTableLocalChanges();

            doReloadRepositoryEntities();

        });

        this.tblLocalChanges.getSelectionModel().setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);

        this.tblLocalChanges.addKeyListener(new KeyAdapter() {

            @Override

            public void keyPressed(KeyEvent e) {

                if (e.getKeyCode() == KeyEvent.VK_SPACE) {

                    doToggleSelection();

                }

            }

        });

        this.tblLocalChanges.getSelectionModel().addListSelectionListener((ListSelectionEvent e) -> {

            context.doUpdateComponents();

        });

        this.btnLocalCheckAll.addActionListener((ActionEvent e) -> {

            if (changes != null) {

                doCheckAll();

                doUpdateTableLocalChanges();

            }

        });

        this.btnLocalUnCheckAll.addActionListener((ActionEvent e) -> {

            if (changes != null) {

                doUnCheckAll();

                doUpdateTableLocalChanges();

            }

        });

        this.btnLocalShowForm.addActionListener((ActionEvent e) -> {

            doShowForm();

        });

        this.btnLocalCommit.addActionListener((ActionEvent e) -> {

            doCommit();

        });

        this.btnLocalRevert.addActionListener((ActionEvent e) -> {

            doRevert();

        });

        this.effectiveDatePicker = toolsSwingManager.createDatePickerController(

                this.txtLocalEffectiveDate,

                this.btnLocalEffectiveDate

        );

        this.effectiveDatePicker.set(new Date());

        this.btnLocalRefresh.addActionListener((ActionEvent e) -> {

            doUpdateTableLocalChanges();

        });

        this.btnLocalZoom.addActionListener((ActionEvent e) -> {

            doZoomToSelectedChange();

        });

        this.btnLocalCenter.addActionListener((ActionEvent e) -> {

            doCenterToSelectedChange();

        });

        this.btnLocalCleanHighlighted.addActionListener((ActionEvent e) -> {

            cleanHighligthed();

        });

        toolsSwingManager.addClearButton(this.txtLocalComment);

        toolsSwingManager.setDefaultPopupMenu(txtLocalComment);

        context.doUpdateComponents();

    }

    private void translate() {

        ToolsSwingManager swingManager = ToolsSwingLocator.getToolsSwingManager();

        swingManager.translate(this.btnLocalCheckAll);

        swingManager.translate(this.btnLocalCommit);

        swingManager.translate(this.btnLocalRefresh);

        swingManager.translate(this.btnLocalRevert);

        swingManager.translate(this.btnLocalShowForm);

        swingManager.translate(this.btnLocalUnCheckAll);

        swingManager.translate(this.lblLocalEffectiveDate);

        swingManager.translate(this.lblLocalComment);

        swingManager.translate(this.btnLocalCenter);

        swingManager.translate(this.btnLocalZoom);

        swingManager.translate(this.btnLocalCleanHighlighted);

    }

    private Iterator<Long> getSelectionIterator() {

        ListSelectionModel selection = this.tblLocalChanges.getSelectionModel();

        return new Iterator<Long>() {

            long n = selection.getMinSelectionIndex();

            @Override

            public boolean hasNext() {

                while (n <= selection.getMaxSelectionIndex()){

                    if(selection.isSelectedIndex((int) n)){

                       return true; 

                    }

                    n++;

                }

                return false;

            }

            @Override

            public Long next() {

                if(n > selection.getMaxSelectionIndex()){

                    throw new IllegalStateException();

                }

                return n++;

            }

        };

    }

    private void doToggleSelection() {

        Thread task = new Thread(() -> {

            try {

                context.processing = true;

                context.doUpdateComponents();

                Iterator<Long> rows = getSelectionIterator();

                this.changes.process(rows, (VCSGisWorkspaceChange change) -> {

                    if(change.getOperation() == OP_ADD_ENTITY) {

                        if(change.isSelected()){

                            entitiesToUnCheckAll.add(change.getEntityCode());

                        }

                    }

                    change.setSelected(!change.isSelected());

                    return true;

                });

                if(!entitiesToUnCheckAll.isEmpty()){

                    doUnCheckAllByEntities();

                }

            } finally {

                context.processing = false;

                context.doUpdateComponents();

            }

        }, "VCSGisToggleSelectionLocalChanges");

        task.start();

    }

    private Iterator<Long> getRowsByEntitiesToUnCheckIterator() {

        long size = changes.size64();

        TableModel model = this.tblLocalChanges.getModel();

        return new Iterator<Long>() {

            long n = 0;

            @Override

            public boolean hasNext() {

                while (n < size){

                    VCSGisWorkspaceChange row = changes.get64(n);

                    if(entitiesToUnCheckAll.contains(row.getEntityCode())){

                       return true; 

                    }

                    n++;

                }

                return false;

            }

            @Override

            public Long next() {

                return n++;

            }

        };

    }

    private void doUnCheckAllByEntities(){

        if(dissabledUncheckAllByEntities){

            return;

        }

        Thread task = new Thread(() -> {

            try {

                context.processing = true;

                context.doUpdateComponents();

                if(!entitiesToUnCheckAll.isEmpty()) {

                    Iterator<Long> rows = getRowsByEntitiesToUnCheckIterator();

                    this.changes.process(rows, (VCSGisWorkspaceChange change) -> {

                         if(change.getOperation() != OP_ADD_ENTITY) {

                            change.setSelected(false);

                         }

                        return true;

                    });

                    entitiesToUnCheckAll.clear();

                }

            } finally {

                context.processing = false;

                context.doUpdateComponents();

            }

        }, "VCSGisUnCheckAllByEntitiesLocalChanges");

        task.start();

    }

    private Iterator<Long> getRowsIterator() {

        long size = changes.size64();

        return new Iterator<Long>() {

            long n = 0;

            @Override

            public boolean hasNext() {

                return (n < size);

            }

            @Override

            public Long next() {

                return n++;

            }

        };

    }

    private void doCheckAll() {

        Thread task = new Thread(() -> {

            try {

                context.processing = true;

                dissabledUncheckAllByEntities = true;

                context.doUpdateComponents();

                this.changes.setSelectionAll();

            } finally {

                context.processing = false;

                dissabledUncheckAllByEntities = false;

                context.doUpdateComponents();

            }

        }, "VCSGisCheckAllLocalChanges");

        task.start();

    }

    private void doUnCheckAll() {

        Thread task = new Thread(() -> {

            try {

                context.processing = true;

                dissabledUncheckAllByEntities = true;

                context.doUpdateComponents();

                this.changes.clearSelection();

            } finally {

                context.processing = false;

                dissabledUncheckAllByEntities = false;

                context.doUpdateComponents();

            }

        }, "VCSGisUncheckAllLocalChanges");

        task.start();

    }

    public VCSGisWorkspace getWorkspace() {

        return this.context.getWorkspace();

    }

    /* friend */void doUpdateComponents() {

        if (notInSwingThreadInvokeLater(() -> {doUpdateComponents();})) {

            return;

        }

        this.context.setVisibleStatus(context.processing);

        VCSGisWorkspace ws = getWorkspace();

        this.context.updateEntitiesFromRepository(false);

        this.effectiveDatePicker.setEnabled(!context.processing);

        this.workspacePicker.setEnabled(!context.processing);

        this.btnLocalCheckAll.setEnabled(!context.processing && changes!=null && changes.size64()>0);

        this.btnLocalUnCheckAll.setEnabled(!context.processing && changes!=null && changes.size64()>0);

        this.btnLocalRefresh.setEnabled(!context.processing && changes!=null);

        this.btnLocalRevert.setEnabled(ws!=null && 

                        !context.processing && 

                        changes!=null && 

                        changes.size64()>0 && 

                        entitiesWithChanges != null &&

                        !entitiesWithChanges.isEmpty()

        );      

        this.btnLocalRevert.setVisible(true);      

        this.btnLocalCommit.setEnabled(ws!=null && 

                !context.processing && 

                changes!=null && 

                !this.changes.isSelectionEmpty() && 

                ws.canCommit()

        );

        //Show form

        boolean enableShowForm = false;

        int row = this.tblLocalChanges.getSelectedRow();

        if(!context.processing && row>=0){

            VCSGisWorkspaceChange change = this.changes.get64(row);

            if(change.getOperation() != OP_ADD_ENTITY){

                enableShowForm = true;

            }

        }

        this.btnLocalShowForm.setEnabled(!context.processing && enableShowForm);

        this.tblLocalChanges.setEnabled(!context.processing);

        this.txtLocalComment.setEnabled(!context.processing);

        this.effectiveDatePicker.setEnabled(!context.processing);

        this.workspacePicker.setEnabled(!context.processing);

        Geometry geom = getGeometryOfSelectedChange();

        Geometry originalGeom = getOriginalGeometryOfSelectedChange();

        this.btnLocalCenter.setEnabled(!context.processing && (geom!=null || originalGeom!=null));

        this.btnLocalZoom.setEnabled(!context.processing && (geom!=null || originalGeom!=null));

        this.btnLocalCleanHighlighted.setEnabled(!context.processing);

    }

    public void doUpdateTableLocalChanges() {

        if( context.processing ) {

            return;

        }

        I18nManager i18n = ToolsLocator.getI18nManager();

        VCSGisWorkspace ws = this.getWorkspace();

        if(ws != null){

            entitiesWithChanges = ws.getEntitiesWithChanges();

            changes = ws.getLocalChanges();

            localChangesTableModel = new ChangesTableModel(changes, ws);

            this.tblLocalChanges.setModel(localChangesTableModel);

            int columns = this.tblLocalChanges.getColumnModel().getColumnCount();

            for (int i = 1; i < columns; i++) {

                this.tblLocalChanges.getColumnModel().getColumn(i).setCellRenderer(new DefaultTableCellRenderer() {

                    @Override

                    public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {

                        Component c = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);

                        VCSGisChange changeRow = changes.get64(row);

                        VCSGisSwingCommons.setColorCompoment(c, changeRow.getStatus());

                        return c;

                    }

                });

            }

            this.tableModelListener = null;

            localChangesTableModel.addTableModelListener(getTableModelListener());

            context.message(i18n.getTranslation(

                    "_Workspace_changes_list_updated", 

                    new String[] { String.valueOf(changes.size64()) }

                )

            );

            this.lblLocalChangesCount.setText(String.valueOf(changes.size64()));

        }

        context.doUpdateComponents();

    }

    private void doReloadRepositoryEntities() {

        VCSGisWorkspace ws = this.getWorkspace();

        if (ws != null) {

            Thread task = new Thread(() -> {

                try {

                    context.processing = true;

                    context.doUpdateComponents();

                    ws.reloadRepositoryEntities(null);

                } finally {

                    context.processing = false;

                    context.doUpdateComponents();

                }

            }, "VCSGisReloadRepositoryEntities");

            context.processing = true;

            context.doUpdateComponents();

            task.start();

        }

    }

    private TableModelListener getTableModelListener() {

        if(tableModelListener == null){

            tableModelListener =  (TableModelEvent e) -> {

                if (e.getType() == TableModelEvent.UPDATE) {

                    TableModel model = ((TableModel) (e.getSource()));

                    VCSGisWorkspaceChange change = changes.get64(e.getFirstRow());

                    if(change.getOperation() == OP_ADD_ENTITY) {

                        if(!change.isSelected()) {

                            if (entitiesToUnCheckAll.add(change.getEntityCode())) {

                                doUnCheckAllByEntities();

                            }

                        }

                    }

                }

            };

        }

        return tableModelListener;

    }

    private void doShowForm() {

        int row = this.tblLocalChanges.getSelectedRow();

        VCSGisWorkspaceChange change = this.changes.get64(row);

        if(change.getOperation() == OP_DELETE || change.getOperation() == OP_ADD_ENTITY){

            return;

        }

        Feature feature = change.getRelatedFeature();

        if(feature == null){

            return;

        }

        try {

            DataSwingManager dataSwingManager = DALSwingLocator.getDataSwingManager();

            JFeatureForm form;

            form = dataSwingManager.createJFeatureForm(feature);

            WindowManager winManager = ToolsSwingLocator.getWindowManager();

            form.asJComponent().setPreferredSize(new Dimension(400,200));

            winManager.showWindow(form.asJComponent(), "Local change: "+change.getLabel(), WindowManager.MODE.WINDOW);

        } catch (CreateJFeatureFormException ex) {

            Logger.getLogger(VCSGisJChangesImpl.class.getName()).log(Level.SEVERE, null, ex);

        }

    }

    private void doCommit() {

        I18nManager i18n = ToolsLocator.getI18nManager();

        ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

        VCSGisWorkspace ws = getWorkspace();

        if( ws==null ) {

            // TODO: Mensaje al usuario

            return;

        }

        this.context.updateEntitiesFromRepository(false);

        MutableObject<String> message = new MutableObject<>();

        if( !ws.canCommit(message) ) {

            dialogs.messageDialog(

                    i18n.getTranslation("_Cant_commit") + "\n" + message.getValue(),

                    i18n.getTranslation("_Commit"), 

                    JOptionPane.WARNING_MESSAGE

            );

            return;

        }

        Timestamp effectiveDate = new Timestamp(effectiveDatePicker.get().getTime());

        this.tblLocalChanges.setModel(new ChangesTableModel(ws));

        List<VCSGisEntity> entities = ws.getEntitiesOfLocalChanges();

        Thread task = new Thread(() -> {

            try {

                context.processing = true;

                context.doUpdateComponents();

                if( !executeTopologyPlans(ws, entities) ) {

                    dialogs.messageDialog(

                            i18n.getTranslation("_Cant_pass_topology_plans"),

                            i18n.getTranslation("_Commit"), 

                            JOptionPane.WARNING_MESSAGE

                    );

                    return;

                }

                int r = ws.commit(

                        effectiveDate, 

                        this.txtLocalComment.getText(), 

                        this.context.getTaskStatusController().getSimpleTaskStatus()

                );

                doPostCommit(r);

            } finally {

                context.processing = false;

                context.doUpdateComponents();

            }

        }, "VCSGisCommit");

        context.processing = true;

        context.doUpdateComponents();

        task.start();

    }

    private boolean executeTopologyPlans(VCSGisWorkspace ws, List<VCSGisEntity> entities) {

        final I18nManager i18n = ToolsLocator.getI18nManager();

        final TopologyManager topologyManager = TopologyLocator.getTopologyManager();

        final TopologySwingManager swingManager = TopologySwingLocator.getTopologySwingManager();

        final WindowManager_v2 winManager = (WindowManager_v2) ToolsSwingLocator.getWindowManager();

        Map<String, TopologyPlan> topologyPlans = new HashMap<>();

        for (VCSGisEntity entity : entities) {

            String x = ws.getTopologyPlan(entity.getTopologyPlanCode());

            if( StringUtils.isBlank(x) ) {

                continue;

            }

            TopologyPlan plan = topologyManager.createTopologyPlan();

            plan.fromJSON(x);

            if( plan.hasRules() ) {

                topologyPlans.put(plan.getName(), plan);

            }

        }

        if( topologyPlans.isEmpty() ) {

            return true;

        }

        for (TopologyPlan plan : topologyPlans.values()) {

            JTopologyReport panel = swingManager.createJTopologyReport(plan);

            panel.put(plan);

            SwingUtilities.invokeLater(() -> {

                winManager.showWindow(

                        panel.asJComponent(),

                        i18n.getTranslation("_Topology_plan_error_inspector") + " ("+plan.getName()+")",

                        WindowManager.MODE.TOOL

                );

            });

            try {

                plan.execute();

                if( plan.getReport().size()>0 ) {

                    return false;

                }

            } catch(Exception ex) {

                return false;

            }

        }

        return true;

    }

    private void doPostCommit(int commitStatus) {

        if (notInSwingThreadInvokeLater(() -> {doPostCommit(commitStatus);})) {

            return;

        }

        if( commitStatus ==ERR_OK) {

            this.context.setVisibleStatus(false);

        }

        context.updateLocalChangesTable();

    }

    private void doRevert() {

        VCSGisWorkspace ws = getWorkspace();

        if( ws==null ) {

            // TODO: Mensaje al usuario

            return;

        }

        this.context.updateEntitiesFromRepository(false);

        Thread task = new Thread(() -> {

            try {

                context.processing = true;

                context.doUpdateComponents();

                List<VCSGisWorkspaceEntity> entities = ws.getEntitiesWithChanges();

                int r = ERR_OK;

                if(!entities.isEmpty()){

                    for (VCSGisWorkspaceEntity entity : entities) {

                        r = ws.revert(entity.getEntityCode(), 

                                this.context.getTaskStatusController().getSimpleTaskStatus()

                        );

                        if(r != ERR_OK){

                            break;

                        }

                    }

                }

                doPostRevert(r, entities);

            } finally {

                context.processing = false;

                context.doUpdateComponents();

            }

        }, "VCSGisRevert");

        context.processing = true;

        context.doUpdateComponents();

        task.start();

    }

    private void doPostRevert(int revertStatus, List<VCSGisWorkspaceEntity> entities) {

        if (notInSwingThreadInvokeLater(() -> {doPostRevert(revertStatus, entities);})) {

            return;

        }

        if( revertStatus == ERR_OK) {

            this.context.setVisibleStatus(false);

        }

        for (VCSGisWorkspaceEntity entity : entities) {

            FeatureStore store = getWorkspace().getFeatureStore(entity.getEntityName());

            refreshDocument(store);

        }

        context.updateLocalChangesTable();

    }

    private Geometry getGeometryOfSelectedChange() {

        Geometry geom = null;

        int selected = this.tblLocalChanges.getSelectedRow();

        if(selected >= 0){

            VCSGisWorkspaceChange change = changes.get64(selected);

            try {

                Feature feature = change.getRelatedFeature();

                geom = feature.getDefaultGeometry();

            } catch (Exception ex){

            }

        }

        return geom;

    }

    private Geometry getOriginalGeometryOfSelectedChange() {

        Geometry geom = null;

        int selected = this.tblLocalChanges.getSelectedRow();

        if(selected >= 0){

            VCSGisWorkspaceChange change = changes.get64(selected);

            try {

                VCSGisWorkspace ws = getWorkspace();

                if(ws!=null) {

                    JsonObject json = change.getDataAsJson();

                    String entityCode = change.getEntityCode();

                    VCSGisEntity entity = ws.getEntity(entityCode);

                    FeatureStore store = ws.getFeatureStore(entity.getEntityName());

                    Feature feature = store.createNewFeature(json);

                    geom = feature.getDefaultGeometry();

                }

            } catch (Exception ex){

            }

        }

        return geom;

    }

    private void doZoomToSelectedChange() {

        cleanHighligthed();

        VCSGisManager manager = VCSGisLocator.getVCSGisManager();

        VCSGisSwingManager swingManager = VCSGisSwingLocator.getVCSGisSwingManager();

        VCSGisSwingServices services =swingManager.getDefaultServices();

        Geometry geom = getGeometryOfSelectedChange();

        Geometry originalGeom = getOriginalGeometryOfSelectedChange();

        services.zoomActiveViewToGeometry(VCSGisSwingCommons.createBBox(geom, originalGeom));

        if(geom != null){

            services.highlight(HIGHLIGHT_WORKSPACE, geom);

        }

        if(originalGeom != null){

            services.highlight(HIGHLIGHT_WORKSPACE_PREVIOUS, originalGeom);

        }

    }

    private void doCenterToSelectedChange() {

        cleanHighligthed();

        VCSGisManager manager = VCSGisLocator.getVCSGisManager();

        VCSGisSwingManager swingManager = VCSGisSwingLocator.getVCSGisSwingManager();

        VCSGisSwingServices services =swingManager.getDefaultServices();

        Geometry geom = getGeometryOfSelectedChange();

        Geometry originalGeom = getOriginalGeometryOfSelectedChange();

        services.centerActiveViewToGeometry(VCSGisSwingCommons.createBBox(geom, originalGeom));

        if(geom != null){

            services.highlight(HIGHLIGHT_WORKSPACE, geom);

        }

        if(originalGeom != null){

            services.highlight(HIGHLIGHT_WORKSPACE_PREVIOUS, originalGeom);

        }

    }

}