gvSIG projects pool

package org.gvsig.vcsgis.app.addlayer;

import java.awt.BorderLayout;

import java.awt.Cursor;

import java.awt.Dimension;

import java.awt.event.ActionEvent;

import java.awt.event.ItemEvent;

import java.net.URL;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import javax.swing.ComboBoxModel;

import javax.swing.DefaultComboBoxModel;

import javax.swing.DefaultListModel;

import javax.swing.DefaultListSelectionModel;

import javax.swing.ImageIcon;

import javax.swing.JOptionPane;

import javax.swing.ListModel;

import javax.swing.ListSelectionModel;

import javax.swing.SwingUtilities;

import javax.swing.event.ChangeEvent;

import javax.swing.event.ListSelectionEvent;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

import org.gvsig.app.gui.WizardPanel;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.swing.ExpressionEvaluatorSwingLocator;

import org.gvsig.expressionevaluator.swing.ExpressionEvaluatorSwingManager;

import org.gvsig.expressionevaluator.swing.ExpressionPickerController;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

import org.gvsig.fmap.dal.store.jdbc.JDBCStoreParameters;

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

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

import org.gvsig.fmap.dal.swing.dataStoreParameters.DataStoreParametersPanel;

import org.gvsig.fmap.dal.swing.dataStoreParameters.DataStoreParametersPanelManager;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

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

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

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

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

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

import org.gvsig.tools.swing.api.task.TaskStatusController;

import org.gvsig.tools.swing.api.task.TaskStatusSwingManager;

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

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

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

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

import org.gvsig.tools.swing.icontheme.IconTheme;

import org.gvsig.tools.util.LabeledValue;

import org.gvsig.tools.util.LabeledValueImpl;

import org.gvsig.vcsgis.lib.VCSGisEntity;

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

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

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

import org.gvsig.vcsgis.swing.VCSGisJInitWorkspace;

import org.gvsig.vcsgis.swing.VCSGisSwingLocator;

import org.gvsig.vcsgis.swing.VCSGisSwingManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public abstract class AbstractWizardVCSGis extends WizardPanel {

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

    protected class TableInfo extends LabeledValueImpl<JDBCStoreParameters> {

        private final ListSelectionModel columnChecksModel;

        private FeatureType featureType;

        private int geomFieldSelected = -1;

        private int idFieldSelected = -1;

        private ComboBoxModel<String> idFieldComboModel;

        private ComboBoxModel<String> geomFieldComboModel;

        private List<FeatureAttributeDescriptor> attributeDescriptors;

        private ListModel<LabeledValue<FeatureAttributeDescriptor>> columnsListModel;

        private Expression filter;

        private IProjection projection;

        private boolean selected;

        private String documentName;

        public TableInfo(JDBCStoreParameters parameters) {

            super(getLabelForTable(parameters), parameters);

            this.columnChecksModel = new DefaultListSelectionModel();

            this.selected = false;

            this.documentName = parameters.getTable();

            this.projection = parameters.getCRS();

        }

        public String getDocumentName() {

            return this.documentName;

        }

        public void setDocumentName(String name) {

            this.documentName = name;

        }

        public boolean isSelected() {

            return selected;

        }

        public void setSelected(boolean selected) {

            this.selected = selected;

        }

        public ListSelectionModel getColumnChecksModel() {

            return this.columnChecksModel;

        }

        public JDBCStoreParameters getParameters() {

            JDBCStoreParameters p = this.getValue();

            StringBuilder fields = new StringBuilder();

            List<FeatureAttributeDescriptor> attributes = this.getAttributeDescriptors();

            boolean allSelected = true;

            for (int i = 0; i < attributes.size(); i++) {

                if (this.columnChecksModel.isSelectedIndex(i)) {

                    if (fields.length() > 0) {

                        fields.append(",");

                    }

                    fields.append(attributes.get(i).getName());

                } else {

                    allSelected = false;

                }

            }

            if( !allSelected ) {

                p.setFields(fields.toString());

            }

            p.setPkFields(this.getFieldId());

            p.setCRS(this.getProjection());

            p.setDefaultGeometryField(this.getGeomField());

            if (!ExpressionUtils.isEmpty(this.filter)) {

                p.setBaseFilter(this.filter.toString());

            } else {

                p.setBaseFilter(null);

            }

            return p;

        }

        public void setProjection(IProjection projection) {

            this.projection = projection;

        }

        public IProjection getProjection() {

            return projection;

        }

        public String getFieldId() {

            if (this.idFieldSelected < 0) {

                return null;

            }

            return this.idFieldComboModel.getElementAt(this.idFieldSelected);

        }

        public String getGeomField() {

            if (this.geomFieldSelected < 0) {

                return null;

            }

            return this.geomFieldComboModel.getElementAt(this.geomFieldSelected);

        }

        public FeatureType getFeatureType() {

            if (this.featureType == null) {

                DataManager dataManager = DALLocator.getDataManager();

                try {

                    JDBCStoreParameters params = this.getValue();

                    FeatureStore store = (FeatureStore) dataManager.openStore(

                            params.getDataStoreName(),

                            params

                    );

                    this.featureType = store.getDefaultFeatureType();

                } catch (Exception ex) {

                    LOGGER.trace("Can't get feature type.",ex); // To allow set break points

                }

            }

            return this.featureType;

        }

        public ComboBoxModel getGeomFieldComboModel() {

            if (this.geomFieldComboModel == null) {

                DefaultComboBoxModel<String> geomModel = new DefaultComboBoxModel<>();

                geomModel.addElement(" ");

                int geomIndex = -1;

                int n = 1;

                for (FeatureAttributeDescriptor attr : this.getAttributeDescriptors()) {

                    if (geomIndex < 0 && attr.getType() == DataTypes.GEOMETRY) {

                        geomIndex = n;

                    }

                    int dataType = attr.getType();

                    if (dataType == DataTypes.GEOMETRY

                            || dataType == DataTypes.BYTEARRAY

                            || dataType == DataTypes.STRING) {

                        geomModel.addElement(attr.getName());

                        n++;

                    }

                }

                if (geomIndex < 0) {

                    geomIndex = 0;

                }

                this.geomFieldComboModel = geomModel;

                this.geomFieldSelected = geomIndex;

            }

            return this.geomFieldComboModel;

        }

        public int getGeomFieldSelected() {

            return this.geomFieldSelected;

        }

        public ComboBoxModel getIdFieldComboModel() {

            if (this.idFieldComboModel == null) {

                StringBuilder pkName = new StringBuilder();

                for (FeatureAttributeDescriptor attr : this.getAttributeDescriptors()) {

                    if (attr.isPrimaryKey()) {

                        if (!StringUtils.isBlank(pkName)) {

                            pkName.append(",");

                        }

                        pkName.append(attr.getName());

                    }

                }

                DefaultComboBoxModel<String> idsModel = new DefaultComboBoxModel<>();

                idsModel.addElement(" ");

                int idsIndex = -1;

                int n = 1;

                if (!StringUtils.isBlank(pkName) && StringUtils.contains(pkName, "/")) {

                    idsModel.addElement(pkName.toString());

                    idsIndex = n++;

                }

                for (FeatureAttributeDescriptor attr : getAttributeDescriptors()) {

                    if (idsIndex < 0 && attr.isPrimaryKey()) {

                        idsIndex = n;

                    }

                    idsModel.addElement(attr.getName());

                    n++;

                }

                if (idsIndex < 0) {

                    idsIndex = 0;

                }

                this.idFieldComboModel = idsModel;

                this.idFieldSelected = idsIndex;

            }

            return this.idFieldComboModel;

        }

        public List<FeatureAttributeDescriptor> getAttributeDescriptors() {

            if (this.attributeDescriptors == null) {

                List<FeatureAttributeDescriptor> attrs = new ArrayList<>();

                for (FeatureAttributeDescriptor attr : this.getFeatureType()) {

                    attrs.add(attr);

                }

                attrs.sort((FeatureAttributeDescriptor o1, FeatureAttributeDescriptor o2) -> 

                        o1.getName().compareTo(o2.getName())

                );

                this.columnChecksModel.setSelectionInterval(0, attrs.size());

                this.attributeDescriptors = attrs;

            }

            return this.attributeDescriptors;

        }

        public ListModel<LabeledValue<FeatureAttributeDescriptor>> getColumnsListModel() {

            if (this.columnsListModel == null) {

                DefaultListModel<LabeledValue<FeatureAttributeDescriptor>> model = new DefaultListModel<>();

                for (FeatureAttributeDescriptor attr : this.getAttributeDescriptors()) {

                    model.addElement(new LabeledValueImpl<>(

                            attr.getName() + " [" + attr.getDataTypeName() + "]",

                            attr

                    )

                    );

                }

                this.columnsListModel = model;

            }

            return this.columnsListModel;

        }

        public FeatureAttributeDescriptor getAttributeDescriptor(String attrName) {

            return this.getFeatureType().getAttributeDescriptor(attrName);

        }

        public int getIdFieldSelected() {

            return this.idFieldSelected;

        }

        public Expression getFilter() {

            return this.filter;

        }

        public void setFilter(Expression filter) {

            this.filter = filter;

        }

        private void setIdFieldSelected(int selectedIndex) {

            this.idFieldSelected = selectedIndex;

        }

        private void setGeomFieldSelected(int selectedIndex) {

            this.geomFieldSelected = selectedIndex;

        }

        private boolean hasValidValues() {

            if (this.getGeomFieldSelected() < 0 && requireGeometry()) {

                return false;

            }

            JDBCStoreParameters p = this.getParameters();

            try {

                p.validate();

                return true;

            } catch (ValidateDataParametersException ex) {

                return false;

            }

        }

    }

    private WizardVCSGisViewExtended view;

    private PickerController<VCSGisWorkspace> workspacePicker;

    private PickerController<IProjection> pickerProjection;

    private ExpressionPickerController pickerFilter;

    private JListWithCheckbox lwcTables;

    private JListWithCheckbox lwcColumns;

    protected Map<String, TableInfo> tablesInfo = null;

    protected FilteredListController tablesFilterController;

    private boolean processing;

    private TaskStatusController taskStatusController;

    public AbstractWizardVCSGis() {

        initComponents();

    }

    private void initComponents() {

        DataSwingManager dataSwingManager = DALSwingLocator.getDataSwingManager();

        ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

        ExpressionEvaluatorSwingManager expressionSwingManager = ExpressionEvaluatorSwingLocator.getManager();

        VCSGisSwingManager swingManager = VCSGisSwingLocator.getVCSGisSwingManager();

        this.view = new WizardVCSGisViewExtended();

        TaskStatusSwingManager taskStatusManager = ToolsSwingLocator.getTaskStatusSwingManager();

        this.taskStatusController = taskStatusManager.createTaskStatusController(

                this.view.lblStatusTitle,

                this.view.lblStatusMessages,

                this.view.pbStatus

        );

        this.taskStatusController.setShowCancelButton(false);

        this.taskStatusController.setShowRemoveTaskButton(false);

        this.taskStatusController.bind(ToolsLocator.getTaskStatusManager());

        toolsSwingManager.translate(this.view.btnDeselectAllColumns);

        toolsSwingManager.translate(this.view.btnSelectAllColumns);

        toolsSwingManager.translate(this.view.lblColumns);

        toolsSwingManager.translate(this.view.lblWorkspace);

        toolsSwingManager.translate(this.view.lblFilter);

        toolsSwingManager.translate(this.view.lblGeometryField);

        toolsSwingManager.translate(this.view.lblIdField);

        toolsSwingManager.translate(this.view.lblName);

        toolsSwingManager.translate(this.view.lblProjection);

        toolsSwingManager.translate(this.view.lblTable);

        toolsSwingManager.translate(this.view.cboWorkspaces);

        toolsSwingManager.translate(this.view.btnAddWorkspace);

        toolsSwingManager.translate(this.view.btnCheckout);

        toolsSwingManager.translate(this.view.btnAdvancedProperties);

        toolsSwingManager.translate(this.view.btnInitWorkspace);

        this.view.btnInitWorkspace.setText(toHTML(this.view.btnInitWorkspace.getText()));

        toolsSwingManager.translate(this.view.txtRepositoryInfo);

        toolsSwingManager.addClearButton(this.view.txtName);

        toolsSwingManager.setDefaultPopupMenu(this.view.txtName);

        this.view.btnInitWorkspace.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

        this.view.btnAddWorkspace.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

        this.view.btnSelectAllColumns.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

        this.view.btnDeselectAllColumns.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

        this.view.btnProjection.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

        this.view.btnFilter.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

        this.view.btnFilterBookmarks.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

        this.view.btnFilterHistory.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

        this.view.btnAdvancedProperties.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

        this.view.btnAdvancedProperties.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

        this.lwcTables = toolsSwingManager.createJListWithCheckbox(

                this.view.lstTables

        );

        this.lwcColumns = toolsSwingManager.createJListWithCheckbox(

                this.view.lstColumns

        );

        this.workspacePicker = swingManager.createWorkspacePickerController(

            this.view.cboWorkspaces,

            this.view.btnAddWorkspace

        );

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

            doChangeWorkspace();

            setEditableTables(true);

        });

        this.pickerProjection = dataSwingManager.createProjectionPickerController(

                this.view.txtProjection,

                this.view.btnProjection

        );

        this.pickerFilter = expressionSwingManager.createExpressionPickerController(

                this.view.txtFilter,

                this.view.btnFilter,

                this.view.btnFilterBookmarks,

                this.view.btnFilterHistory

        );

        this.lwcTables.addListSelectionListener((ListSelectionEvent e) -> {

            doChangeTableSelected();

        });

        this.lwcTables.addChecksListener((ListSelectionEvent e) -> {

            doChangeTableSelected();

        });

        this.view.cboGeometryField.addItemListener((ItemEvent e) -> {

            if (e.getStateChange() == ItemEvent.SELECTED) {

                doChangeGeometryField();

            }

        });

        this.view.btnDeselectAllColumns.addActionListener((ActionEvent e) -> {

            doDeselectAllColumns();

        });

        this.view.btnSelectAllColumns.addActionListener((ActionEvent e) -> {

            doSelectAllColumns();

        });

        this.view.btnAdvancedProperties.addActionListener((ActionEvent e) -> {

            doShowAdvancedProperties();

        });

        this.view.btnInitWorkspace.addActionListener((ActionEvent e) -> {

            doShowInitWorkspace();

        });

        this.view.btnCheckout.addActionListener((ActionEvent e) -> {

            doCheckout();

        });

        this.tablesFilterController = toolsSwingManager.createFilteredListController(

                this.view.lstTables, 

                this.view.txtTablesFilter, 

                this.view.btnTablesFilter

        );

        this.clearTables();

        this.setEditableTables(false);

        this.setLayout(new BorderLayout());

        this.add(this.view, BorderLayout.CENTER);

        this.setPreferredSize(new Dimension(500, 400));

        doUpdateComponents();

    }

    protected abstract boolean requireGeometry();

    protected Collection<TableInfo> getTablesInformation() {

        this.updateTableInfoFromUI();

        if( this.tablesInfo == null ) {

            this.tablesInfo = new HashMap<>();

        }

        return this.tablesInfo.values();

    }

    private void doDeselectAllColumns() {

        TableInfo info = this.getCurrentTableInfo();

        if (info == null) {

            return;

        }

        info.getColumnChecksModel().clearSelection();

    }

    private void doSelectAllColumns() {

        TableInfo info = this.getCurrentTableInfo();

        if (info == null) {

            return;

        }

        info.getColumnChecksModel().setSelectionInterval(0, info.getAttributeDescriptors().size());

    }

    private void doShowAdvancedProperties() {

        final TableInfo info = this.getCurrentTableInfo();

        if (info == null) {

            return;

        }

        this.fetch(info);

        I18nManager i18n = ToolsLocator.getI18nManager();

        WindowManager_v2 winmgr = (WindowManager_v2) ToolsSwingLocator.getWindowManager();

        DataStoreParametersPanelManager paramsPanelManager = DALSwingLocator.getDataStoreParametersPanelManager();

        final DataStoreParametersPanel panel = paramsPanelManager.createDataStoreParametersPanel(info.getParameters());

        final Dialog dialog = winmgr.createDialog(

                panel.asJComponent(),

                i18n.getTranslation("_Connection_parameters"),

                null, 

                WindowManager_v2.BUTTONS_OK_CANCEL

        );

        dialog.addActionListener((ActionEvent e) -> {

            if( dialog.getAction()==WindowManager_v2.BUTTON_OK ) {

                panel.fetchParameters(info.getParameters());

            }

        });

        dialog.show(WindowManager.MODE.DIALOG);

    }

    private void clearTables() {

        this.lwcTables.setModel(new DefaultListModel());

        this.lwcTables.getCheckedModel().clearSelection();

        this.clearTableConfig();

    }

    private void clearTableConfig() {

        this.lwcColumns.setModel(new DefaultListModel());

        this.lwcColumns.getCheckedModel().clearSelection();

        this.view.txtName.setText("");

        this.view.cboGeometryField.setModel(new DefaultComboBoxModel());

        this.view.cboIdField.setModel(new DefaultComboBoxModel());

        this.pickerProjection.set(null);

        this.pickerFilter.set(null);

    }

    private void setEditableTables(boolean enable) {

        this.view.lstTables.setEnabled(enable);

        this.setEditableTableConfig(enable);

        this.view.btnDeselectAllColumns.setEnabled(enable);

        this.view.btnSelectAllColumns.setEnabled(enable);

    }

    private void setEditableTableConfig(boolean enable) {

        this.view.lstColumns.setEnabled(enable);

        this.view.txtName.setEditable(enable);

        this.view.cboGeometryField.setEnabled(enable);

        this.view.cboIdField.setEnabled(enable);

        this.pickerProjection.setEditable(enable);

        this.pickerFilter.setEditable(enable);

        this.view.btnAdvancedProperties.setEnabled(enable);

    }

    private TableInfo getCurrentTableInfo() {

        VCSGisEntity rEntity = getRemoteEntity();

        if(rEntity == null){

            return null;

        }

        TableInfo xx = this.tablesInfo.get(rEntity.getEntityName());

        return xx;

    }

    private void doChangeGeometryField() {

        TableInfo info = this.getCurrentTableInfo();

        if (info == null) {

            return;

        }

        String attrName = (String) this.view.cboGeometryField.getSelectedItem();

        if (StringUtils.isBlank(attrName)) {

            return;

        }

        FeatureAttributeDescriptor attr = info.getAttributeDescriptor(attrName);

        IProjection srs = attr.getSRS();

        if (srs == null) {

            return;

        }

        this.pickerProjection.set(srs);

    }

    private void doChangeWorkspace() {

        if (notInSwingThreadInvokeLater(this::doChangeWorkspace)) {

            return;

        }

        this.lwcTables.clearSelection();

        I18nManager i18n = ToolsLocator.getI18nManager();

        VCSGisWorkspace workspace = workspacePicker.get();

        this.tablesFilterController.getModel().clear();

        if (workspace == null) {

            return;

        }

        this.view.txtRepositoryInfo.setText(workspace.getRepository().getLabel());

        reloadEntities(workspace, i18n);

    }

    private void reloadEntities(VCSGisWorkspace workspace, I18nManager i18n) {

        this.tablesInfo = new HashMap<>();

        //Rellenamos la lista de entidades

        Thread task = new Thread(() -> {

            try {

                processing = true;

                doUpdateComponents();

                List<VCSGisEntity> repoEntities = workspace.getRepositoryEntities();

                List<VCSGisWorkspaceEntity> wsEntities = workspace.getWorkspaceEntities();

                doReloadEntitiesList(repoEntities, wsEntities);

            } catch (Exception e) {

                LOGGER.warn("_Cant_retrieve_entities_from_repository", e);

                ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

                dialogs.messageDialog(

                        i18n.getTranslation("_Cant_retrieve_entities_from_repository") + "\n" + e.getMessage(),

                        i18n.getTranslation("_Add_table"),

                        JOptionPane.WARNING_MESSAGE

                );

            } finally {

                processing = false;

                doUpdateComponents();

            }

        }, "VCSGisAddTable_getRepositoryEntities");

        processing = true;

        doUpdateComponents();

        task.start();

    }

//    private void doUpdateTables() {

//        JDBCServerExplorerParameters connection = this.pickerConnection.get();

//        if (connection == null) {

//            this.clearTables();

//            return;

//        }

//        DataManager dataManager = DALLocator.getDataManager();

//        DataServerExplorer explorer = null;

//        try {

//            explorer = dataManager.openServerExplorer(

//                    connection.getDataStoreName(),

//                    connection

//            );

//            List<TableInfo> parameters = new ArrayList<>();

//            for (DataStoreParameters params : explorer.list()) {

//                parameters.add(new TableInfo((JDBCStoreParameters) params));

//            }

//            parameters.sort((TableInfo o1, TableInfo o2) -> 

//                    o1.getLabel().compareTo(o2.getLabel())

//            );

//            this.tablesInfo = new HashMap<>();

//            DefaultListModel<TableInfo> model = new DefaultListModel<>();

//            for (TableInfo x : parameters) {

//                model.addElement(x);

//                this.tablesInfo.put(x.getDocumentName(), x);

//            }

//            this.lwcTables.setModel(model);

//            this.lwcTables.getCheckedModel().clearSelection();

//        } catch (Exception ex) {

//        } finally {

//            DisposeUtils.disposeQuietly(explorer);

//        }

//    }

    private void doChangeTableSelected() {

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

            return;

        }

        boolean updatedTableInfo = false;

        VCSGisEntity rEntity = getRemoteEntity();

        if(rEntity != null){

            VCSGisWorkspaceEntity lEntity;

            lEntity = getWorkspace().getWorkspaceEntity(rEntity.getEntityName());

            if(lEntity != null){

                TableInfo tableInfo = tablesInfo.get(rEntity.getEntityName());

                this.updateTableInfoFromUI();

                this.put(tableInfo);

                updatedTableInfo = true;

            } else {

                int index = this.lwcTables.getSelectedIndex();

                this.lwcTables.getCheckedModel().removeIndexInterval(index, index);

            }

        }

        if(!updatedTableInfo){

            this.clearTableConfig();

        }

        showMessage("");

        doUpdateComponents();

    }

    private void updateTableInfoFromUI() {

         String previousTableName = this.view.txtName.getText();

         if (this.tablesInfo!=null && !this.tablesInfo.isEmpty()) {

         TableInfo previousInfo = this.tablesInfo.get(previousTableName);

            if (previousInfo != null) {

               this.fetch(previousInfo);

           }

        }

    }

    private void put(TableInfo tableInfo) {

        this.lwcColumns.setModel(tableInfo.getColumnsListModel());

        this.lwcColumns.setCheckedModel(tableInfo.getColumnChecksModel());

        this.view.cboGeometryField.setModel(tableInfo.getGeomFieldComboModel());

        this.view.cboGeometryField.setSelectedIndex(tableInfo.getGeomFieldSelected());

        this.view.cboIdField.setModel(tableInfo.getIdFieldComboModel());

        this.view.cboIdField.setSelectedIndex(tableInfo.getIdFieldSelected());

        this.pickerProjection.set(tableInfo.getProjection());

        this.pickerFilter.set(tableInfo.getFilter());

        this.view.txtName.setText(tableInfo.getDocumentName());

    }

    private void fetch(TableInfo tableInfo) {

        tableInfo.setIdFieldSelected(this.view.cboIdField.getSelectedIndex());

        tableInfo.setGeomFieldSelected(this.view.cboGeometryField.getSelectedIndex());

        tableInfo.setFilter(this.pickerFilter.get());

        tableInfo.setProjection(this.pickerProjection.get());

        tableInfo.setDocumentName(this.view.txtName.getText());

        int index = this.lwcTables.getSelectedIndex();

        tableInfo.setSelected(this.lwcTables.getCheckedModel().isSelectedIndex(index));

    }

    @Override

    public void initWizard() {

        I18nManager i18n = ToolsLocator.getI18nManager();

        setTabName(i18n.getTranslation("_VCSGis"));

    }

    @Override

    public boolean areSettingsValid() {

        if(processing){

            return false;

        }

        boolean hasInvalidValues = false;

        boolean hasSelectedTables = false;

        for (TableInfo tableInfo : this.getTablesInformation() ) {

            if (tableInfo.isSelected()) {

                hasSelectedTables = true;

                if (!tableInfo.hasValidValues()) {

                    hasInvalidValues = true;

                }

            }

        }

        return hasSelectedTables && !hasInvalidValues;

    }

    @Override

    public DataStoreParameters[] getParameters() {

        int sz = 0;

        for (TableInfo tableInfo : this.getTablesInformation() ) {

            if( tableInfo.isSelected() ) {

                sz++;

            }

        }

        if( sz == 0 ) {

            return null;

        }

        DataStoreParameters[] dbParameters = new DataStoreParameters[sz];

        int n = 0;

        for (TableInfo tableInfo : this.getTablesInformation() ) {

            if( tableInfo.isSelected() ) {

                dbParameters[n++] = tableInfo.getParameters();

            }

        }

        return dbParameters;

    }

    @Override

    public void execute() {

        executeWizard();

    }

    @Override

    public void close() {

    }

    protected void checkFinishable() {

        boolean finishable = areSettingsValid();

        callStateChanged(finishable);

    }

    private static String getLabelForTable(JDBCStoreParameters parameters) {

        String schema = parameters.getSchema();

        String tableName = parameters.getTable();

        if( StringUtils.isBlank(schema) ) {

            return tableName;

        }

        return schema +"."+tableName;

    }

    private void doUpdateComponents() {

        VCSGisEntity rEntity = getRemoteEntity();

        boolean enabled = (rEntity != null);

        VCSGisWorkspace ws = getWorkspace();

        if(enabled){

            VCSGisWorkspaceEntity lEntity;

            lEntity = ws.getWorkspaceEntity(rEntity.getEntityName());

            if (lEntity == null) {

                this.view.btnCheckout.setEnabled(!processing);

                this.setEditableTables(false);

            } else {

                this.view.btnCheckout.setEnabled(false);

                this.setEditableTables(!processing);

            }

        } else {

            this.view.btnCheckout.setEnabled(false);

            this.setEditableTables(false);

        }

//        this.lwcTables.setEnabled(!processing);

        this.tablesFilterController.setEnabled(!processing && ws != null);

        this.workspacePicker.setEnabled(!processing);

        this.view.btnInitWorkspace.setEnabled(!processing);

        this.view.txtRepositoryInfo.setEnabled(!processing && ws != null);

        this.view.btnAdvancedProperties.setEnabled(!processing && enabled);

        this.setVisibleStatus(processing);

        this.checkFinishable();

    }

    private void doShowInitWorkspace() {

        I18nManager i18nManager = ToolsLocator.getI18nManager();

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

        VCSGisSwingManager swingManager = VCSGisSwingLocator.getVCSGisSwingManager();

        final VCSGisJInitWorkspace panelInitWorkspace = swingManager.createInitWorkspacePanel();

        final Dialog dialogInitWorkspace = winManager.createDialog(

                panelInitWorkspace.asJComponent(),

                i18nManager.getTranslation("_VCS_Initialize_workspace"),

                i18nManager.getTranslation("_VCS_Initialize_workspace"),

                WindowManager_v2.BUTTONS_OK_CANCEL

        );

        panelInitWorkspace.setDialog(dialogInitWorkspace);

        dialogInitWorkspace.setButtonLabel(

                WindowManager_v2.BUTTON_OK,

                i18nManager.getTranslation("_VCS_Initialize_workspace")

        );

        dialogInitWorkspace.addActionListener((ActionEvent e) -> {

            switch (dialogInitWorkspace.getAction()) {

                case WindowManager_v2.BUTTON_OK:

                    int r = panelInitWorkspace.initializeWorkspace();

                    if (r != 0) {

                        String message = "_Cant_initialize_workspace_{0}";

                        StringBuilder compoundMessage = new StringBuilder();

                        String[] messageArgs = new String[]{panelInitWorkspace.getWorkspaceName()};

                        compoundMessage.append(i18nManager.getTranslation(

                                message,

                                messageArgs

                        ));

                        ThreadSafeDialogsManager dialogsManager = ToolsSwingLocator.getThreadSafeDialogsManager();

                        dialogsManager.messageDialog(

                                compoundMessage.toString(),

                                i18nManager.getTranslation("_VCS_Initialize_workspace"),

                                JOptionPane.WARNING_MESSAGE

                        );

                    }

                    break;

            }

        });

        dialogInitWorkspace.show(WindowManager.MODE.DIALOG);

    }

    public VCSGisWorkspace getWorkspace() {

        return this.workspacePicker.get();

    }

    private void doReloadEntitiesList(List<VCSGisEntity> repoEntities, List<VCSGisWorkspaceEntity> wsEntities) {

        if (notInSwingThreadInvokeLater(() -> {doReloadEntitiesList(repoEntities, wsEntities);}) ) {

            return;

        }

        I18nManager i18n = ToolsLocator.getI18nManager();

        VCSGisSwingManager swingManager = VCSGisSwingLocator.getVCSGisSwingManager();

        try {

            this.tablesFilterController.getModel().clear();

            //Si estamos añadiendo capas, comprobamos que las entidades que tengan geometría (si no, no son capas)

            for (VCSGisWorkspaceEntity lEntity : wsEntities) {

                if(StringUtils.isNotBlank(lEntity.getGeometryFieldName()) || !requireGeometry()){

                    this.tablesFilterController.getModel().addElement(

                            new LabeledValueImpl(

                                    swingManager.getHTMLColoredForEntity(lEntity, lEntity.getEntityName()),

                                    lEntity

                            )

                    );

                        JDBCStoreParameters parameters = getWorkspace().getExplorer().get(lEntity.getEntityName());

                        this.tablesInfo.put(lEntity.getEntityName(), new TableInfo(parameters));

                }

            }

            // Si estamos añadiendo capas, comprobamos que las entidades que tengan geometría (si no, no son capas)

            // Además, si ya pertenecen al workspace nos las saltamos

            for (VCSGisEntity rEntity : repoEntities) {

                if(StringUtils.isNotBlank(rEntity.getGeometryFieldName()) || !requireGeometry()){

                    VCSGisWorkspaceEntity lEntity = getWorkspace().getWorkspaceEntity(rEntity.getEntityName());

                    if(lEntity == null){

                        this.tablesFilterController.getModel().addElement(

                                new LabeledValueImpl(

                                        swingManager.getHTMLColoredForEntity(lEntity, rEntity.getEntityName()),

                                        rEntity

                                )

                        );

                    }

                }

            }

        } catch (Exception e) {

            LOGGER.warn("_Cant_update_layers_list", e);

            ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

            dialogs.messageDialog(

                    i18n.getTranslation("_Cant_update_layers_list")+"\n"+e.getMessage(), 

                    i18n.getTranslation("_Add_layer"), 

                    JOptionPane.WARNING_MESSAGE

            );

        }

    }

    private void doCheckout() {

        VCSGisWorkspace workspace = getWorkspace();

        if (workspace == null) {

            return;

        }

        ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

        I18nManager i18n = ToolsLocator.getI18nManager();

        VCSGisEntity rEntity = getRemoteEntity();

        VCSGisWorkspaceEntity lEntity = workspace.getWorkspaceEntity(rEntity.getEntityName());

        if (lEntity != null) {

            return;

        }

        Thread task = new Thread(() -> {

            try {

                processing = true;

                doUpdateComponents();

                showMessage(i18n.getTranslation("_Checking_out"));

                int res = workspace.checkout(

                        rEntity.getEntityName(),

                        null,

                        this.getTaskStatusController().getSimpleTaskStatus()

                );

                if (res != ERR_OK) {

                    LOGGER.warn("_Cant_checkout_table");

                    dialogs.messageDialog(

                            i18n.getTranslation("_Cant_checkout_table") + "\n" + workspace.getErrorMessage(res),

                            i18n.getTranslation("_Add_table"),

                            JOptionPane.WARNING_MESSAGE

                    );

                    return;

                }

                showMessage(i18n.getTranslation("_Checkout_finished"));

                JDBCStoreParameters parameters = getWorkspace().getExplorer().get(rEntity.getEntityName());

                this.tablesInfo.put(rEntity.getEntityName(), new TableInfo(parameters));

                doChangeTableSelected();

            } catch (Exception e) {

                LOGGER.warn("_Cant_add_table");

                dialogs.messageDialog(

                        i18n.getTranslation("_Cant_add_table") + "\n" + e.getMessage(),

                        i18n.getTranslation("_Add_table"),

                        JOptionPane.WARNING_MESSAGE

                );

            } finally {

                processing = false;

                doChangeWorkspace();

//                VCSGisWorkspaceEntity localEntity = workspace.getWorkspaceEntity(rEntity.getEntityName());

//                if (localEntity != null) {

//                    lwcTables.setSelectedValue(localEntity, true);

//                }

                doUpdateComponents();

            }

        }, "VCSGisAddTableCheckout");

        processing = true;

        doUpdateComponents();

        task.start();

    }

    private VCSGisEntity getRemoteEntity() {

        LabeledValue<VCSGisEntity> value = (LabeledValue<VCSGisEntity>) this.lwcTables.getSelectedValue();

        if(value == null){

            return null;

        }

        return value.getValue();

    }

    private void showMessage(String message) {

        if( notInSwingThreadInvokeLater(() -> {showMessage(message);}) ) {

            return;

        }

        this.view.lblStatusMessages.setText(message);

    }

        public boolean isProcessing() {

        return processing;

    }

    public void setVisibleStatus(boolean visible) {

        if( notInSwingThreadInvokeLater(() -> {setVisibleStatus(visible);}) ) {

            return;

        }

        this.view.lblStatusTitle.setVisible(visible);

        this.view.pbStatus.setVisible(visible);

        this.view.lblStatusMessages.setVisible(true);

    }

    public TaskStatusController getTaskStatusController() {

        return this.taskStatusController;

    }

    public static boolean notInSwingThreadInvokeLater(Runnable x) {

        if( SwingUtilities.isEventDispatchThread() ) {

            return false;

        }

        SwingUtilities.invokeLater(x);

        return true;

    }

    private static class WizardVCSGisViewExtended extends AbstractWizardVCSGisView {

        @Override

        public ImageIcon loadImage(String imageName) {

            String name = FilenameUtils.getBaseName(imageName);

            IconTheme theme = ToolsSwingLocator.getIconThemeManager().getDefault();

            if (theme.exists(name)) {

                return theme.get(name);

            }

            URL url = WizardVCSGisViewExtended.class.getResource("images/" + name + ".png");

            if (url == null) {

                return null;

            }

            return new ImageIcon(url);

        }

    }

    private String toHTML(String s) {

      s = StringUtils.replace(s, "\n", "<br>");

      s = StringUtils.replace(s, "<html>", "");

      s = StringUtils.replace(s, "</html>", "");

      s = "<html>"+s+"</html>";

      return s;

    }

}