gvSIG projects pool

package org.gvsig.vcsgis.app.addlayer;

import java.awt.BorderLayout;

import java.awt.Component;

import java.awt.Cursor;

import java.awt.event.ActionEvent;

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

import java.util.function.Predicate;

import javax.swing.ImageIcon;

import javax.swing.JOptionPane;

import javax.swing.SwingUtilities;

import javax.swing.UIManager;

import javax.swing.event.ChangeEvent;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.app.gui.WizardPanel;

import org.gvsig.expressionevaluator.swing.ExpressionEvaluatorSwingLocator;

import org.gvsig.expressionevaluator.swing.ExpressionEvaluatorSwingManager;

import org.gvsig.fmap.dal.DataStoreParameters;

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.mapcontext.MapContext;

import org.gvsig.geodb.TableInfo;

import org.gvsig.geodb.TableInfoController;

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.ToolsSwingUtils;

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.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.VCSGisEntitySelectorController;

import static org.gvsig.vcsgis.swing.VCSGisEntitySelectorController.ACTION_BEGIN_PROCESSING_ID;

import static org.gvsig.vcsgis.swing.VCSGisEntitySelectorController.ACTION_CHECK_ID;

import static org.gvsig.vcsgis.swing.VCSGisEntitySelectorController.ACTION_END_PROCESSING_ID;

import static org.gvsig.vcsgis.swing.VCSGisEntitySelectorController.ACTION_RELOAD_ID;

import static org.gvsig.vcsgis.swing.VCSGisEntitySelectorController.ACTION_SELECT_ID;

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 WizardVCSGisViewExtended view;

    private PickerController<VCSGisWorkspace> workspacePicker;

    protected Map<String, TableInfo> tablesInfo = null;

    private boolean processing;

    private TaskStatusController taskStatusController;

    private TableInfoController tableInfoController;

    private VCSGisEntitySelectorController entitySelector;

    public AbstractWizardVCSGis() {

        initComponents();

    }

    private static void waitCursor(Component component, Runnable action) {

        Cursor saved_cursor = component.getCursor();

        try {

            component.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));

            action.run();

        } finally {

            component.setCursor(saved_cursor);

        }

    }

    private void initComponents() {

        DataSwingManager dataSwingManager = DALSwingLocator.getDataSwingManager();

        ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

        ExpressionEvaluatorSwingManager expressionSwingManager = ExpressionEvaluatorSwingLocator.getManager();

        VCSGisSwingManager swingManager = VCSGisSwingLocator.getVCSGisSwingManager();

        this.view = new WizardVCSGisViewExtended();

//        this.view.txtRepositoryInfo.setVisible(false);

        this.entitySelector = swingManager.createEntitySelectorController(

                this.view.treeTables, 

                this.view.txtTablesFilter, 

                this.view.btnTablesFilter);

        Predicate<VCSGisEntity> entitySelectorFilter = VCSGisEntitySelectorController.ALL_ENTITIES;

        if(this.requireGeometry()){

            entitySelectorFilter = (VCSGisEntity t) -> (StringUtils.isNotBlank(t.getGeometryFieldName()));

        }

        this.entitySelector.setFilter(entitySelectorFilter);

        this.entitySelector.setViewFilter(entitySelectorFilter);

        this.entitySelector.setLabelEntityFormatter(this.getLabelEntityFormatter());

        this.entitySelector.setChecksEnabled(true);

        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.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.btnInitWorkspace);

        toolsSwingManager.translate(this.view.chkMaintainStructureInToC);

        toolsSwingManager.translate(this.view.btnTablesCheckAll);

        toolsSwingManager.translate(this.view.btnTablesUncheckAll);

        toolsSwingManager.translate(this.view.chkCheckScale);

        toolsSwingManager.translate(this.view.chkAddToCWhenLoadingAll);

        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.workspacePicker = swingManager.createWorkspacePickerController(

            this.view.cboWorkspaces,

            this.view.btnAddWorkspace

        );

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

            waitCursor(this, () -> {

                doChangeWorkspace();

                doUpdateComponents();

            });

        });

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

            switch(e.getID()){

                case ACTION_RELOAD_ID:

                    doReloadTablesInfo();

                    break;

                case ACTION_BEGIN_PROCESSING_ID:

                case ACTION_END_PROCESSING_ID:

                    doUpdateComponents();

                    break;

                case ACTION_SELECT_ID:

                    doChangeTableSelected();

                    break;

                case ACTION_CHECK_ID:

                    doChangeTableChecked();

                    doUpdateComponents();

                    break;

            }

        });

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

//            this.entitySelector.checkAll();

            waitCursor(this, () -> {

                List<String> entityCodes = new ArrayList<>();

                Collection<VCSGisEntity> entities = entitySelector.getEntities();

                for (VCSGisEntity entity : entities) {

                    if( entity instanceof VCSGisWorkspaceEntity ){

                        entityCodes.add(entity.getEntityCode());

                    }                

                }

                entitySelector.setCheck(entityCodes, true);

            });

        });

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

            this.entitySelector.clearChecks();

        });

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

            doShowInitWorkspace();

        });

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

            doCheckout();

        });

        this.tableInfoController = new TableInfoController(

                this.view.btnDeselectAllColumns,

                this.view.btnSelectAllColumns,

                this.view.lstColumns,

                this.view.txtName,

                this.view.cboIdField,

                this.view.cboGeometryField,

                this.view.txtProjection,

                this.view.btnProjection,

                this.view.txtFilter,

                this.view.btnFilter,

                this.view.btnFilterBookmarks,

                this.view.btnFilterHistory,

                this.view.btnAdvancedProperties,

                this.view.lblReadOnlyNotification,

                null,

                this.view.btnChangeViewProjection

        );

        this.view.btnChangeViewProjection.setVisible(this.requireGeometry());

        this.view.btnInitWorkspace.setBackground(UIManager.getColor("Panel.background"));

//        this.view.txtRepositoryInfo.setBackground(UIManager.getColor("Panel.background"));

        this.clearTables();

        this.view.chkMaintainStructureInToC.setVisible(false);

        this.view.chkMaintainStructureInToC.setSelected(true);

        this.view.chkCheckScale.setSelected(true);

        this.view.chkAddToCWhenLoadingAll.setSelected(true);

        this.setLayout(new BorderLayout());

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

        ToolsSwingUtils.ensureRowsCols(this, 22, 90, 25, 100);

        doUpdateComponents();

    }

    protected abstract boolean requireGeometry();

    protected boolean maintainStructureInToC() {

        return this.view.chkMaintainStructureInToC.isSelected();

    }

    protected void setVidibleMaintainStructureInToC(boolean visible) {

        this.view.chkMaintainStructureInToC.setVisible(visible);

    }

    protected Collection<TableInfo> getTablesInformation() {

        this.updateTableInfoFromUI();

        if( this.tablesInfo == null ) {

            this.tablesInfo = new HashMap<>();

        }

        return this.tablesInfo.values();

    }

    private void clearTables() {

        this.entitySelector.clear();

        this.tableInfoController.clear();

    }

    private void doChangeWorkspace() {

        if (notInSwingThreadInvokeLater(this::doChangeWorkspace)) {

            return;

        }

        VCSGisWorkspace workspace = workspacePicker.get();

        this.entitySelector.setWorkspace(workspace);

//        if (workspace == null) {

//            this.view.txtRepositoryInfo.setText("");

//            return;

//        }

//

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

    }

    private TableInfo getTableInfo(VCSGisEntity entity){

        Collection<TableInfo> tablesInformation = getTablesInformation();

        for (TableInfo tableInfo : tablesInformation) {

            VCSGisEntity tableInfoEntity = (VCSGisEntity) tableInfo.getProperty("entity");

            if(tableInfoEntity!=null && StringUtils.equals(tableInfoEntity.getEntityCode(), entity.getEntityCode())){

                return tableInfo;

            }

        }

        return null;

    }

    private void doChangeTableSelected() {

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

            return;

        }

        VCSGisEntity selected = this.entitySelector.getSelectedEntity();

        if(selected == null){

            this.tableInfoController.put(null);

            return;

        }

        TableInfo tableInfo = getTableInfo(selected);

        if (tableInfo != null) {

            this.updateTableInfoFromUI();

            this.tableInfoController.put(tableInfo);

            this.tableInfoController.setEnabled(true);

        } else {

            this.tableInfoController.clear();

            this.tableInfoController.setEnabled(false);

        }

        showMessage("");

        doUpdateComponents();

    }

    private void doChangeTableChecked() {

        List<VCSGisEntity> checkedEntities = this.entitySelector.getCheckedEntities();

        List<String> entityCodes = new ArrayList<>();

        for (VCSGisEntity checkedEntity : checkedEntities) {

            if( checkedEntity!=null && !(checkedEntity instanceof VCSGisWorkspaceEntity)){

                entityCodes.add(checkedEntity.getEntityCode());

            }

        }

        this.entitySelector.setCheck(entityCodes, false);

        Collection<TableInfo> tablesInformation = getTablesInformation();

        for (TableInfo tableInfo : tablesInformation) {

            VCSGisEntity tableInfoEntity = (VCSGisEntity) tableInfo.getProperty("entity");

            tableInfo.setSelected(checkedEntities.contains(tableInfoEntity));

        }

        this.checkFinishable();

    }

    private void updateTableInfoFromUI() {

        String previousId = this.tableInfoController.getId();

        if (previousId == null) {

            return;

        }

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

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

            if (previousInfo != null) {

                this.tableInfoController.fetch(previousInfo);

            }

        }

    }

    @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 void doUpdateComponents() {

        VCSGisEntity entity = this.entitySelector.getSelectedEntity();

        boolean theProcessing = this.processing || this.entitySelector.isProcessing();

        VCSGisWorkspace ws = getWorkspace();

        if(entity == null){

            this.view.btnCheckout.setEnabled(false);

            this.tableInfoController.setEnabled(false);

        } else if(entity instanceof VCSGisWorkspaceEntity){

            this.view.btnCheckout.setEnabled(false);

            this.tableInfoController.setEditable(!theProcessing && ws != null);

            this.tableInfoController.setEnabled(ws != null);

        } else { //Entidad de repositorio

            this.view.btnCheckout.setEnabled(!theProcessing && ws != null);

            this.tableInfoController.setEnabled(false);

        }

        this.entitySelector.setEnabled(!theProcessing && ws != null);

        this.view.btnTablesCheckAll.setEnabled(this.entitySelector.isEnabled());

        this.view.btnTablesUncheckAll.setEnabled(this.entitySelector.isEnabled());

        this.workspacePicker.setEnabled(!theProcessing);

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

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

        this.setVisibleStatus(theProcessing);

        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_workingcopy"),

                i18nManager.getTranslation("_VCS_Initialize_workingcopy"),

                WindowManager_v2.BUTTONS_OK_CANCEL

        );

        panelInitWorkspace.setDialog(dialogInitWorkspace);

        dialogInitWorkspace.setButtonLabel(

                WindowManager_v2.BUTTON_OK,

                i18nManager.getTranslation("_VCS_Initialize_workingcopy")

        );

        dialogInitWorkspace.addActionListener((ActionEvent e) -> {

            switch (dialogInitWorkspace.getAction()) {

                case WindowManager_v2.BUTTON_OK:

                    int r = panelInitWorkspace.initializeWorkspace();

                    if (r != 0) {

                        String message = "_Cant_initialize_workingcopy_{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_workingcopy"),

                                JOptionPane.WARNING_MESSAGE

                        );

                    }

                    break;

            }

        });

        dialogInitWorkspace.show(WindowManager.MODE.DIALOG);

    }

    public VCSGisWorkspace getWorkspace() {

        return this.workspacePicker.get();

    }

    private void doReloadTablesInfo() {

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

            return;

        }

        I18nManager i18n = ToolsLocator.getI18nManager();

        try {

            Collection<VCSGisEntity> entities = this.entitySelector.getEntities();

            for (VCSGisEntity entity : entities) {

                if (entity instanceof VCSGisWorkspaceEntity) {

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

                    TableInfo tableInfo = new VCSGisTableInfo(entity, parameters, this.requireGeometry(), false);

                    if(StringUtils.isNotBlank(entity.getLabel()) ) {

                        tableInfo.setDocumentName(entity.getLabel());

                    }

                    tableInfo.setProperty("entity", entity);

                    this.tablesInfo.put(tableInfo.getId(), tableInfo);

                }

            }

        } 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 = this.entitySelector.getSelectedEntity();

        if(rEntity== null || rEntity instanceof VCSGisWorkspaceEntity){

            return;

        }

        final String entityName = rEntity.getEntityName();

        Thread task = new Thread(() -> {

            try {

                processing = true;

                doUpdateComponents();

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

                int res = workspace.checkout(

                        entityName,

                        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;

                }

                downloadAndRegisterResources(entityName);

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

                JDBCStoreParameters parameters = getWorkspace().getExplorer().get(entityName);

                TableInfo tableInfo = new VCSGisTableInfo(workspace.getWorkspaceEntity(entityName), parameters, this.requireGeometry(), false);

                this.tablesInfo.put(tableInfo.getId(), tableInfo);

                doPostCheckout(entityName);

            } 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;

                doUpdateComponents();

            }

        }, "VCSGisAddTableCheckout");

        processing = true;

        doUpdateComponents();

        task.start();

    }

    private void doPostCheckout(String entityName) {

        if (notInSwingThreadInvokeLater(() -> { doPostCheckout(entityName); })) {

            return;

        }

        VCSGisWorkspace workspace = getWorkspace();

        if (workspace == null) {

            return;

        }

        doChangeWorkspace();

        this.entitySelector.setSelectedEntity(workspace.getWorkspaceEntity(entityName));

        doChangeTableSelected();

    }

    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;

    }

    protected 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;

    }

    protected void downloadAndRegisterResources(String tableName) {

        VCSGisWorkspace workspace = getWorkspace();

        VCSGisWorkspaceEntity entity = workspace.getWorkspaceEntityByName(tableName);

        if(entity == null){

            return;

        }

        VCSGisEntity lEntity = workspace.getEntity(entity.getEntityCode());

        String resources = lEntity.getResources();

        if (StringUtils.isNotBlank(resources)) {

            try {

                if (!workspace.existsInWorkspace(resources)) {

                    workspace.checkout(

                            resources,

                            null

                    );

                }

            } catch (Exception e) {

                LOGGER.warn("Can't checkout resources table '" + resources + "'", e);

            }

            workspace.getExplorer().setCustomResources(entity.getEntityName(), resources,true);

        }

    }

    @Override

    public void setMapContext(MapContext mapContext) {

        super.setMapContext(mapContext);

        this.tableInfoController.setMapContext(mapContext);

    }

    protected Function<VCSGisEntity,String> getLabelEntityFormatter() {

        return null;

    }

    protected boolean getCheckScale() {

        return this.view.chkCheckScale.isSelected();

    }

    protected boolean getAddToCWhenLoadingAll() {

        return this.view.chkAddToCWhenLoadingAll.isSelected();

    }

}