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

import java.awt.Cursor;

import java.awt.Dimension;

import java.awt.event.ActionEvent;

import java.sql.Timestamp;

import java.util.Date;

import javax.swing.ComboBoxModel;

import javax.swing.JComponent;

import javax.swing.SwingUtilities;

import javax.swing.event.ChangeEvent;

import javax.swing.event.DocumentEvent;

import javax.swing.event.DocumentListener;

import org.apache.commons.lang3.StringUtils;

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypeUtils;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.i18n.I18nManager;

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

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.task.TaskStatusController;

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

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

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

import org.gvsig.tools.util.LabeledValue;

import org.gvsig.vcsgis.lib.VCSGisEntity;

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

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

import org.gvsig.vcsgis.lib.VCSGisRevision;

import org.gvsig.vcsgis.lib.VCSGisRuntimeException;

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

import org.gvsig.vcsgis.swing.VCSGisJExport;

import org.gvsig.vcsgis.swing.VCSGisSwingLocator;

import org.gvsig.vcsgis.swing.VCSGisSwingManager;

import org.gvsig.vcsgis.swing.VCSGisSwingServices;

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

import static org.gvsig.vcsgis.swing.impl.VCSGisEntitySelectorController.REMOTE_ENTITIES;

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

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

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

import org.gvsig.vcsgis.swing.impl.revisions.VCSGisRevisionPickerControllerImpl;

import org.slf4j.LoggerFactory;

/**

 *

 * @author gvSIG Team

 */

public class VCSGisJExportImpl extends VCSGisJExportView

        implements Component, VCSGisJExport {

    private static final org.slf4j.Logger LOGGER = LoggerFactory.getLogger(VCSGisJExportImpl.class);

    private Dialog dialog;

    private PickerController<VCSGisWorkspace> workspacePicker;

    private DatePickerController efectivePicker;

    private VCSGisEntitySelectorController entitySelector;

    private VCSGisRevisionPickerControllerImpl revisionPicker;

    private boolean processing;

    private TaskStatusController taskStatusController;

    private String searchedTable;

    private boolean existsInDataBaseSearchedTable;

    public VCSGisJExportImpl() {

        translate();

        processing = false;

        initComponents();

    }

    private void initComponents() {

        //TODO: remove next line in next build (>3208)

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

        TaskStatusSwingManager taskStatusManager = ToolsSwingLocator.getTaskStatusSwingManager();

        ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

        VCSGisSwingManager swingManager = VCSGisSwingLocator.getVCSGisSwingManager();

        VCSGisSwingServices services = swingManager.getDefaultServices();

        this.workspacePicker = swingManager.createWorkspacePickerController(

                cboWorkspaces,

                btnInitWorkspace

        );

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

            doChangeWorkspace();

            doUpdateEnableComponents();

        });

        this.taskStatusController = taskStatusManager.createTaskStatusController(

                this.lblStatusTitle,

                this.lblStatusMessages,

                this.pbStatus

        );

        this.taskStatusController.setShowCancelButton(false);

        this.taskStatusController.setShowRemoveTaskButton(false);

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

        SwingUtilities.invokeLater(() -> {

            this.taskStatusController.setVisible(false);

        });

        this.entitySelector = VCSGisEntitySelectorController.create(lstTables, txtFilter, btnTable);

        this.entitySelector.setFilter(REMOTE_ENTITIES);

        this.entitySelector.setViewFilter(REMOTE_ENTITIES);

        this.entitySelector.setChecksEnabled(false);

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

            doChangeTable();

            doChangeTableName();

        });

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

            doUpdateEnableComponents();

        });

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

            doUpdateEnableComponents();

        });

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

            doUpdateEnableComponents();

        });

        this.efectivePicker = toolsSwingManager.createDatePickerController(txtEffectiveDate, btnEffectiveDate);

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

            doChangeTableName();

        });

        this.revisionPicker = new VCSGisRevisionPickerControllerImpl(txtRevision, btnRevision);

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

            doChangeTableName();

        });

        ComboBoxModel<LabeledValue> viewDocumentsModel = services.getViewDocumentsComboBoxModel();

        cboView.setModel(viewDocumentsModel);

        cboView.addActionListener((ActionEvent e) -> {

            doUpdateEnableComponents();

        });

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

            doUpdateEnableComponents();

        });

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

            doUpdateEnableComponents();

        });

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

            doUpdateEnableComponents();

        });

        this.txtTableName.getDocument().addDocumentListener(new DocumentListener() {

            @Override

            public void changedUpdate(DocumentEvent e) {

                doUpdateEnableComponents();

            }

            @Override

            public void removeUpdate(DocumentEvent e) {

                doUpdateEnableComponents();

            }

            @Override

            public void insertUpdate(DocumentEvent e) {

                doUpdateEnableComponents();

            }

        });

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

        doUpdateEnableComponents();

    }

    @Override

    public JComponent asJComponent() {

        return this;

    }

    @Override

    public void setDialog(Dialog dialog) {

        this.dialog = dialog;

        this.doUpdateEnableComponents();

    }

    private void doChangeWorkspace() {

        try {

            VCSGisWorkspace ws = this.getWorkspace();

            if (ws == null) {

                this.entitySelector.setWorkspace(ws);

                this.revisionPicker.setWorkspace(ws);

                return;

            }

            if (ws.authenticate(null)) {

                this.entitySelector.setWorkspace(ws);

                this.revisionPicker.setWorkspace(ws);

                Thread task = new Thread(

                        () -> {

                            try {

                                LOGGER.info("Entro en el thread");

                                processing = true;

                                doUpdateEnableComponents();

                                ws.getRepositoryEntities();

                            } catch (Exception ex) {

                                LOGGER.warn("Can't retrieve repository entities", ex);

                            } finally {

                                LOGGER.info("Salgo del thread");

                                processing = false;

                                doUpdateEnableComponents();

                            }

                        },

                        "VCSGisExportGetRepositoryEntities"

                );

                this.processing = true;

                LOGGER.info("Creando thread");

                doUpdateEnableComponents();

                task.start();

                return;

            }

            showAuthenticationRequiredMessage("_VCS_Checkout");

            this.workspacePicker.set(null);

            doChangeWorkspace();

        } catch (VCSGisRuntimeException e1) {

            LOGGER.warn("Can't set workspace.", e1);

            if (showAuthenticationErrors("_VCS_Checkout", e1)) {

                this.workspacePicker.set(null);

                doChangeWorkspace();

            }

        } catch (Exception e2) {

            LOGGER.warn("Can't set workspace.", e2);

        }

//        VCSGisWorkspace workspace = this.getWorkspace();

//        if (workspace == null) {

//            return;

//        }

//        this.entitySelector.setWorkspace(workspace);

//        this.revisionPicker.setWorkspace(workspace);

//

//        Thread task = new Thread(

//                () -> {

//                    try {

//                        LOGGER.info("Entro en el thread");

//                        processing = true;

//                        doUpdateEnableComponents();

//                        workspace.getRepositoryEntities();

//                    }catch (Exception ex){

//                        LOGGER.warn("Can't retrieve repository entities", ex);

//                    }finally{

//                        LOGGER.info("Salgo del thread");

//                        processing = false;

//                        doUpdateEnableComponents();

//                    }

//                },

//                "VCSGisExportGetRepositoryEntities"

//        );

//        this.processing = true;

//        LOGGER.info("Creando thread");

//        doUpdateEnableComponents();

//        task.start();

    }

    private void doChangeTable() {

        VCSGisEntity selectedTable = this.entitySelector.getSelectedEntity();

        this.revisionPicker.setEntity(selectedTable);

        this.efectivePicker.set(null);

        this.txtTableName.setText("");

    }

    private void doChangeTableName() {

        VCSGisEntity selectedTable = this.entitySelector.getSelectedEntity();

        if(selectedTable == null){

            this.txtTableName.setText("");

            return;

        }

        String suffix;

        Timestamp timestamp;

        if(rdbEffectiveDate.isSelected() && this.efectivePicker.get() != null){

            timestamp = DataTypeUtils.toTimestamp(this.efectivePicker.get());

            suffix = timestamp.toString();

        } else if(rdbRevision.isSelected() && revisionPicker.get() != null){

            VCSGisRevision revision = revisionPicker.get();

            suffix = "r"+revision.getNumber()+" "+revision.getRevisionDate().toString();

        } else {

            timestamp = DataTypeUtils.toTimestamp(new Date());

            suffix = timestamp.toString();

        }

        this.txtTableName.setText(normalizeTableName(selectedTable.getEntityName() + "_" + suffix));

    }

    @Override

    public VCSGisWorkspace getWorkspace() {

        return this.workspacePicker.get();

    }

    @Override

    public VCSGisEntity getTable() {

        return this.entitySelector.getSelectedEntity();

    }

    private void doUpdateEnableComponents() {

        if (notInSwingThreadInvokeLater(this::doUpdateEnableComponents)) {

            return;

        }

        try {

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

            this.workspacePicker.setEnabled(!isProcessing);

            VCSGisWorkspace workspace = getWorkspace();

            VCSGisEntity selectedTable = this.entitySelector.getSelectedEntity();

            String tableName = this.txtTableName.getText();

            boolean exists = workspace != null

                    && selectedTable != null

                    && existsInDataBase();

            boolean isThereTableSelected = !isProcessing && workspace != null

                    && (selectedTable != null);

            boolean canExport = isThereTableSelected

                    && StringUtils.isNotBlank(tableName)

                    && !exists

                    && workspace.getEntity(tableName) == null;

            if(exists){

                I18nManager i18n = ToolsLocator.getI18nManager();

                showMessage(

                        i18n.getTranslation("_Table_already_exists_in_working_copy"),

                        i18n.getTranslation("_You_can_rename_the_table")

                );

                setVisibleStatus(true);

            } else {

                showMessage("", "");

                setVisibleStatus(true);

            }

            LOGGER.info("canExport = "+canExport+", processing = "+processing+", ws = "+workspace);

            this.entitySelector.setEnabled(!isProcessing && workspace != null);

            this.rdbRevision.setEnabled(isThereTableSelected);

            this.revisionPicker.setEnabled(isThereTableSelected && this.rdbRevision.isSelected());

            this.rdbEffectiveDate.setEnabled(isThereTableSelected);

            this.efectivePicker.setEnabled(isThereTableSelected && this.rdbEffectiveDate.isSelected());

            this.rdbDontAddToProject.setEnabled(canExport);

            this.rdbAddTableToProject.setEnabled(canExport);

            if (canExport) {

                if (isLayer(selectedTable)) {

                    this.rdbAddLayerToView.setEnabled(canExport);

                    this.cboView.setEnabled(canExport && this.rdbAddLayerToView.isSelected());

                } else {

                    this.rdbAddLayerToView.setEnabled(false);

                    this.cboView.setEnabled(false);

                }

            } else {

                this.rdbAddLayerToView.setEnabled(false);

                this.cboView.setEnabled(false);

            }

    //        this.workspacePicker.setEnabled(!isProcessing);

            this.entitySelector.setEnabled(!isProcessing && workspace != null);

            this.lblTableName.setEnabled(isThereTableSelected);

            this.txtTableName.setEnabled(isThereTableSelected);

            LOGGER.info("isProcessing = "+isProcessing+", processing = "+processing+", ws = "+workspace);

            this.pbStatus.setVisible(isProcessing);

            this.lblStatusTitle.setVisible(isProcessing);

            if (dialog != null) {

                LabeledValue selectedView = (LabeledValue) cboView.getSelectedItem();

                boolean dontAddNothing = rdbDontAddToProject.isSelected();

                boolean addLayerToView = rdbAddLayerToView.isSelected() && selectedView != null && selectedView.getValue() != null;

                boolean addTableToProject = rdbAddTableToProject.isSelected();

                this.dialog.setButtonEnabled(WindowManager_v2.BUTTON_OK,

                        canExport && (dontAddNothing || (addLayerToView || addTableToProject))

                );

            }

        } catch (VCSGisRuntimeException e1) {

            LOGGER.warn("Can't updating components.", e1);

            if (showAuthenticationErrors("_VCS_Export", e1)) {

                this.workspacePicker.set(null);

                doChangeWorkspace();

                doUpdateEnableComponents();

            }

        } catch (Exception e2) {

            LOGGER.warn("Can't updating components.", e2);

        }

    }

    private boolean isLayer(VCSGisEntity entity) {

        return !StringUtils.isBlank(entity.getGeometryFieldName());

    }

    private boolean isLayer(FeatureStore store) {

        FeatureType ft = store.getDefaultFeatureTypeQuietly();

        if(ft == null){

            return false;

        }

        return ft.getDefaultGeometryAttribute()!=null;

    }

    @Override

    public int export() {

        I18nManager i18n = ToolsLocator.getI18nManager();

        VCSGisEntity entity = entitySelector.getSelectedEntity();

        final VCSGisWorkspace workspace = this.getWorkspace();

        VCSGisRevision revision = this.revisionPicker.get();

        if (workspace != null && entity != null) {

            try {

                processing = true;

                doUpdateEnableComponents();

                showMessage(i18n.getTranslation("_Processing"), null);

                int res; // = ERR_OK;

                String tableName = this.txtTableName.getText();

                res = workspace.export(entity.getEntityName(),

                        tableName,

                        (revision == null) ? null : revision.getRevisionCode(),

                        DataTypeUtils.toTimestamp(efectivePicker.get()),

                        null

                );

                postExport(res, tableName);

                showMessage(i18n.getTranslation("_Ended_process"), null);

                return res;

            } finally {

                processing = false;

                doUpdateEnableComponents();

            }

        }

        return ERR_CANT_CHECKOUT;

    }

    private void translate() {

        ToolsSwingManager swingManager = ToolsSwingLocator.getToolsSwingManager();

        swingManager.translate(this.lblWorkspace);

        swingManager.translate(this.lblTable);

        swingManager.translate(this.rdbEffectiveDate);

        swingManager.translate(this.rdbRevision);

        swingManager.translate(this.rdbDontAddToProject);

        swingManager.translate(this.rdbAddLayerToView);

        swingManager.translate(this.rdbAddTableToProject);

        swingManager.translate(this.lblTableName);

        swingManager.translate(this.lblAddTableToProject);

    }

    @Override

    public boolean isProcessing() {

        return this.processing;

    }

    private void postExport(int checkoutStatus, String tableName) {

        if (notInSwingThreadInvokeLater(() -> {

            postExport(checkoutStatus, tableName);

        })) {

            return;

        }

        VCSGisSwingManager swingManager = VCSGisSwingLocator.getVCSGisSwingManager();

        VCSGisSwingServices services = swingManager.getDefaultServices();

        final VCSGisWorkspace workspace = this.getWorkspace();

        if (checkoutStatus == ERR_OK) {

            FeatureStore store = workspace.openFeatureStore(tableName);

            if (!rdbDontAddToProject.isSelected()) {

                if (rdbAddLayerToView.isSelected()) {

                    if (isLayer(store)) {

                        String newLayerName = tableName;

                        services.addLayerToView(store, (LabeledValue) cboView.getSelectedItem(), newLayerName);

                    }

                }

                if (rdbAddTableToProject.isSelected()) {

                    String newLayerName = this.txtTableName.getText();

                    services.addTableToProject(workspace, store, newLayerName);

                }

            }

            this.setVisibleStatus(false);

        } else {

            this.setVisibleStatus(true);

        }

        searchedTable = null;

        this.doUpdateEnableComponents();

    }

    public void setVisibleStatus(boolean visible) {

        if (notInSwingThreadInvokeLater(() -> {

            setVisibleStatus(visible);

        })) {

            return;

        }

        this.lblStatusTitle.setVisible(visible);

        this.pbStatus.setVisible(visible);

        this.lblStatusMessages.setVisible(true);

    }

    private void showMessage(String message, String toolTipText) {

        if (notInSwingThreadInvokeLater(() -> {

            showMessage(message, toolTipText);

        })) {

            return;

        }

        this.lblStatusMessages.setText(message);

        this.lblStatusMessages.setToolTipText(toolTipText);

    }

    private boolean existsInDataBase() {

        String tableName = this.txtTableName.getText();

        if (StringUtils.isBlank(tableName)) {

            return true;

        }

        if(StringUtils.equalsIgnoreCase(tableName, searchedTable)){

            return existsInDataBaseSearchedTable;

        }

        VCSGisWorkspace ws = getWorkspace();

        FeatureStore store = null;

        try {

            store = ws.openFeatureStore(tableName);

            searchedTable = tableName;

            existsInDataBaseSearchedTable = (store != null);

            return existsInDataBaseSearchedTable;

        } catch (Exception ex) {

            return false;

        } finally {

            DisposeUtils.disposeQuietly(store);

        }

    }

    private String normalizeTableName(String tableName){

        return tableName.replaceAll("[-:]", "").replaceAll("[ .]", "_").toUpperCase();

    }

}