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

import java.awt.Cursor;

import java.awt.Dimension;

import java.awt.event.ActionEvent;

import java.awt.event.ItemEvent;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import javax.swing.ComboBoxModel;

import javax.swing.DefaultComboBoxModel;

import javax.swing.ImageIcon;

import javax.swing.JComponent;

import javax.swing.SwingUtilities;

import javax.swing.event.ChangeEvent;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.BaseStoresRepository;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.OpenDataStoreParameters;

import org.gvsig.fmap.dal.StoresRepository;

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

import org.gvsig.tools.ToolsLocator;

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

import static org.gvsig.tools.util.ContainerUtils.EQUALS_IGNORECASE_COMPARATOR;

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

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

import org.gvsig.vcsgis.swing.VCSGisJCheckoutDataModel;

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

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

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

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

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

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

import static org.gvsig.vcsgis.swing.impl.VCSGisSwingManagerImpl.ICON_COMMON_GROUP_NAME;

import static org.gvsig.vcsgis.swing.impl.VCSGisSwingManagerImpl.ICON_GROUP_NAME;

import static org.gvsig.vcsgis.swing.impl.VCSGisSwingManagerImpl.ICON_PROVIDER_NAME;

import static org.gvsig.vcsgis.swing.impl.VCSGisSwingManagerImpl.registerIcons;

import org.slf4j.LoggerFactory;

/**

 *

 * @author gvSIG Team

 */

public class VCSGisJCheckoutDataModelImpl extends VCSGisJCheckoutDataModelView

        implements Component, VCSGisJCheckoutDataModel {

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

    private Dialog dialog;

    private boolean processing;

    private PickerController<VCSGisWorkspace> workspacePicker;

    private TaskStatusController taskStatusController;

    private VCSGisEntitySelectorController entitySelector;

    public VCSGisJCheckoutDataModelImpl() {

        processing = false;

        initComponents();

    }

    private void initComponents() {

        TaskStatusSwingManager taskStatusManager = ToolsSwingLocator.getTaskStatusSwingManager();

        VCSGisSwingManager swingManager = VCSGisSwingLocator.getVCSGisSwingManager();

        VCSGisSwingServices services = swingManager.getDefaultServices();

        translate();

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

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

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

        this.entitySelector.setFilter(ALL_ENTITIES);

        this.entitySelector.setViewFilter(ALL_ENTITIES);

        this.entitySelector.setChecksEnabled(true);

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

//            doChangeTable();

//        });

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

            doUpdateComponents();

        });

        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.setVisibleStatus(false); });

        this.workspacePicker = swingManager.createWorkspacePickerController(

                cboWorkspaces,

                btnInitWorkspace

        );

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

            doChangeWorkspace();

            doUpdateComponents();

        });

        this.cboDataModels.addItemListener((ItemEvent e) -> {

            doChangeDataModel();

        });

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

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

            doUpdateComponents();

        });

        showMessage(" ", null);

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

    }

    @Override

    public JComponent asJComponent() {

        return this;

    }

    public void setVisibleStatus(boolean visible) {

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

            return;

        }

        this.lblStatusTitle.setVisible(visible);

        this.pbStatus.setVisible(visible);

        this.lblStatusMessages.setVisible(true);

    }

    @Override

    public void setDialog(Dialog dialog) {

        this.dialog = dialog;

        this.doUpdateComponents();

    }

    private void doChangeWorkspace() {

        try {

            VCSGisWorkspace ws = this.getWorkspace();

            if (ws == null) {

                ComboBoxModel<String> model = new DefaultComboBoxModel<>();

                this.cboDataModels.setModel(model);

                this.cboDataModels.setSelectedIndex(-1);

                this.entitySelector.setWorkspace(ws);

                doUpdateComponents();

                return;

            }

            if (ws.authenticate(null)) {

                ComboBoxModel<String> model = new DefaultComboBoxModel<>(ws.getDataModels().toArray(new String[0]));

                this.cboDataModels.setModel(model);

                this.cboDataModels.setSelectedIndex(-1);

                this.entitySelector.setWorkspace(ws);

                doUpdateComponents();

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

        }

    }

    @Override

    public VCSGisWorkspace getWorkspace() {

        return this.workspacePicker.get();

    }

    private void doUpdateComponents() {

        if( notInSwingThreadInvokeLater(this::doUpdateComponents) ) {

            return;

        }

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

        I18nManager i18n = ToolsLocator.getI18nManager();

        VCSGisWorkspace workspace = getWorkspace();

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

        this.btnCheckAllEntities.setEnabled(!isProcessing);

        this.btnUnCheckAllEntities.setEnabled(!isProcessing);

        this.chkOverwriteExistingTables.setEnabled(!isProcessing);

        boolean canCheckout = !isProcessing &&

                workspace!=null &&

                checkedEntities.size() > 0;

        this.workspacePicker.setEnabled(!isProcessing);

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

        this.pbStatus.setVisible(isProcessing);

        this.lblStatusTitle.setVisible(isProcessing);

        if (dialog != null) {

            this.dialog.setButtonEnabled(WindowManager_v2.BUTTON_OK,

                    canCheckout

            );

        }

    }

    private boolean isLayer(VCSGisEntity entity) {

        return entity != null && !StringUtils.isBlank(entity.getGeometryFieldName());

    }

    @Override

    public int checkout() {

        I18nManager i18n = ToolsLocator.getI18nManager();

        List<VCSGisEntity> entities = entitySelector.getCheckedEntities();

        final VCSGisWorkspace workspace = this.getWorkspace();

        final String dataModelName = this.getDataModel();

        if (workspace != null && entities != null && entities.size()>0) {

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

            for (VCSGisEntity entity : entities) {

                entityCodes.add(entity.getEntityCode());

            }

            try {

                processing = true;

                doUpdateComponents();

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

                int res = ERR_OK;

                if(chkOverwriteExistingTables.isSelected()){

                    res = workspace.removeEntities(entityCodes);

                }

                if(res == ERR_OK){

                    res = workspace.checkout(

                            entityCodes,

                            null

                    );

                    for (VCSGisEntity entity : entities) {

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

                        workspace.getExplorer().setCustomResources(entity.getEntityName(), lEntity.getResources());

                    }

                    registerStoresRepository(workspace, dataModelName, entities);

                    postCheckout(res, entities);

                }

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

                return res;

            } finally {

                processing = false;

                doUpdateComponents();

            }

        }

        return ERR_CANT_CHECKOUT;

    }

    private void postCheckout(int checkoutStatus, List<VCSGisEntity> entities) {

        if( notInSwingThreadInvokeLater(() -> {postCheckout(checkoutStatus,entities);}) ) {

            return;

        }

        VCSGisSwingManager swingManager = VCSGisSwingLocator.getVCSGisSwingManager();

        VCSGisSwingServices services = swingManager.getDefaultServices();

        final VCSGisWorkspace workspace = this.getWorkspace();

        if (checkoutStatus == ERR_OK) {

            //Nos vamos guardando los stores para, después, refrescar solo una vez cada documento al que pertenecen

            Set stores = new HashSet();

            for (VCSGisEntity entity : entities) {

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

                stores.add(store);

            }

            if (chkOverwriteExistingTables.isSelected() && !stores.isEmpty()) {

                refreshDocument(stores);

            }

            for (Object store : stores) {

                DisposeUtils.dispose(store);

            }

            this.setVisibleStatus(false);

        } else {

            this.setVisibleStatus(true);

        }

        this.doUpdateComponents();

    }

    private void registerStoresRepository(VCSGisWorkspace workspace, String name, List<VCSGisEntity> entities) {

        DataManager dataManager = DALLocator.getDataManager();

        BaseStoresRepository modelRepository = new BaseStoresRepository(name);

        for (VCSGisEntity entity : entities) {

            OpenDataStoreParameters params = workspace.createOpenStoreParameters(entity.getEntityName());

            modelRepository.add(entity.getEntityName(), params);

        }

        StoresRepository globalRepository = dataManager.getStoresRepository();

        globalRepository.addRepository(modelRepository);

    }

    private void showMessage(String message, String toolTipText) {

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

            return;

        }

        this.lblStatusMessages.setText(message);

        this.lblStatusMessages.setToolTipText(toolTipText);

    }

    private void translate() {

        ToolsSwingManager swingManager = ToolsSwingLocator.getToolsSwingManager();

        swingManager.translate(this.lblWorkspace);

        swingManager.translate(this.lblDataModel);

        swingManager.translate(this.chkOverwriteExistingTables);

    }

    @Override

    public boolean isProcessing() {

        return processing;

    }

    public static void selfRegister() {

        String[][] iconsInfo = new String[][]{

            new String[]{ICON_PROVIDER_NAME, ICON_GROUP_NAME, "vcsgis-checkout"},

            new String[]{ICON_PROVIDER_NAME, ICON_COMMON_GROUP_NAME, "common-check-off"},

            new String[]{ICON_PROVIDER_NAME, ICON_COMMON_GROUP_NAME, "common-check-on"},

        };

        registerIcons(iconsInfo);

    }

//    private void doChangeTable() {

//        VCSGisWorkspace workspace = getWorkspace();

//        VCSGisEntity selectedTable = this.entitySelector.getSelectedEntity();

//

//        this.chkOverwriteExistingTables.setSelected(workspace!=null && workspace.existsInWorkspace(selectedTable));

//

//        doUpdateComponents();

//    }

    @Override

    public String getDataModel() {

        return (String)this.cboDataModels.getSelectedItem();

    }

    private void doChangeDataModel() {

        String selectedDataModel = getDataModel();

        this.entitySelector.setViewFilter(

                (VCSGisEntity t) -> (ContainerUtils.contains(

                        t.getDataModelsAsList(),

                        selectedDataModel,

                        EQUALS_IGNORECASE_COMPARATOR))

        );

    }

    @Override

    public ImageIcon loadImage(String imageName) {

        return VCSGisSwingManagerImpl.loadImage(imageName);

    }

}