Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 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, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * 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.app.project.documents.table;

import java.awt.Component;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.text.ParseException;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import javax.json.JsonArray;

import javax.json.JsonObject;

import javax.json.JsonValue;

import javax.swing.JOptionPane;

import javax.swing.event.TableModelListener;

import org.apache.bcel.generic.DALOAD;

import org.apache.commons.collections.CollectionUtils;

import org.apache.commons.collections.ListUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.messages.NotificationManager;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.project.documents.table.gui.CreateNewAttributePanel;

import org.gvsig.app.project.documents.table.gui.FeatureTableDocumentPanel;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreProviderFactory;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.EditingNotification;

import org.gvsig.fmap.dal.EditingNotificationManager;

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.exception.StoreUpdateFeatureTypeException;

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

import org.gvsig.fmap.mapcontrol.dal.feature.swing.FeatureTable;

import org.gvsig.fmap.mapcontrol.dal.feature.swing.table.FeatureTableModel;

import org.gvsig.i18n.Messages;

import org.gvsig.json.Json;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.i18n.I18nManager;

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Feature Table Operations.

 *

 * @author Vicente Caballero Navarro

 *

 */

public class TableOperations {

    private static final Logger logger = LoggerFactory.getLogger(TableOperations.class);

    public static final int MAX_FIELD_LENGTH = 254;

    private static TableOperations fto = null;

    private FeatureTableDocumentPanel tablePanel = null;

    private FeatureStore featureStore;

    public static TableOperations getInstance() {

        if (fto == null) {

            fto = new TableOperations();

        }

        return fto;

    }

    public void setTablePanel(FeatureTableDocumentPanel tp) {

        tablePanel = tp;

        featureStore = tp.getModel().getStore();

    }

    public void copyFeatures() throws DataException {

        copy();

    }

    public boolean hasSelection() {

        return !ToolsSwingLocator.getToolsSwingManager().isClipboardEmpty();

    }

    public void pasteFeatures() throws DataException {

        try {

            if( featureStore==null ) {

                return;

            }

            List<EditableFeature> features = DALLocator.getDataManager().getFeaturesFromClipboard(

                    featureStore,

                    null

            );

            if( CollectionUtils.isEmpty(features) ) {

                return;

            }

            for (EditableFeature feature : features) {

                if (!insertFeature(feature) ) {

                    break;

                }

            }

        } catch (Exception e) {

            logger.warn("Can't paste from clipboard.", e);

        }

    }

    private void copy() throws DataException {

        DALLocator.getDataManager().putFeaturesInClipboard(featureStore.getFeatureSelection());

    }

    public void deleteFeatures() throws DataException {

        FeatureTableModel _ftm = this.tablePanel.getTablePanel().getTableModel();

        List<TableModelListener> tmll = removeTableModelListeners(_ftm);

        DisposableIterator feat_iter = null;

        Feature feat = null;

        try {

            FeatureSelection selection = featureStore.createFeatureSelection();

            selection.select((FeatureSet) featureStore.getSelection());

            feat_iter = selection.fastIterator();

            while (feat_iter.hasNext()) {

                feat = (Feature) feat_iter.next();

                if (!deleteFeature(feat)) {

                    return;

                }

            }

        } finally {

            if (feat_iter != null) {

                feat_iter.dispose();

            }

            addTableModelListeners(_ftm, tmll);

        }

    }

    /**

     * @param _ftm

     * @param tmll

     */

    private void addTableModelListeners(

            FeatureTableModel _model,

            List<TableModelListener> _list) {

        Iterator<TableModelListener> iter = _list.iterator();

        while (iter.hasNext()) {

            _model.addTableModelListener(iter.next());

        }

        _model.fireTableDataChanged();

    }

    /**

     * @param ftm

     * @param class1

     * @return

     */

    private List<TableModelListener> removeTableModelListeners(FeatureTableModel ftm) {

        TableModelListener[] ll = ftm.getListeners(TableModelListener.class);

        List<TableModelListener> resp = new ArrayList<>();

        int n = ll.length;

        for (int i = 0; i < n; i++) {

            resp.add(ll[i]);

            ftm.removeTableModelListener(ll[i]);

        }

        return resp;

    }

    public void insertNewFeature() throws DataException {

        EditableFeature feature = featureStore.createNewFeature();

        insertFeature(feature);

    }

    /*

     * Return false if the operation is canceled.

     */

    private boolean insertFeature(EditableFeature feature) throws DataException {

        EditingNotificationManager editingNotificationManager = DALSwingLocator.getEditingNotificationManager();

        EditingNotification notification = editingNotificationManager.notifyObservers(

                this,

                EditingNotification.BEFORE_INSERT_FEATURE,

                tablePanel.getDocument(),

                featureStore,

                feature);

        if (notification.isCanceled()) {

            return false;

        }

        if (notification.shouldValidateTheFeature()) {

            if (!editingNotificationManager.validateFeature(feature)) {

                return false;

            }

        }

        featureStore.insert(feature);

        editingNotificationManager.notifyObservers(

                this,

                EditingNotification.AFTER_INSERT_FEATURE,

                tablePanel.getDocument(),

                featureStore,

                feature);

        return true;

    }

    private boolean deleteFeature(Feature feature) throws DataException {

        EditingNotificationManager editingNotification = DALSwingLocator.getEditingNotificationManager();

        EditingNotification notification = editingNotification.notifyObservers(

                this,

                EditingNotification.BEFORE_REMOVE_FEATURE,

                tablePanel.getDocument(),

                featureStore,

                feature);

        if (notification.isCanceled()) {

            return false;

        }

        featureStore.delete(feature);

        editingNotification.notifyObservers(

                this,

                EditingNotification.AFTER_REMOVE_FEATURE,

                tablePanel.getDocument(),

                featureStore,

                feature);

        return true;

    }

    private boolean updateFeatureType(EditableFeatureType featureType) throws DataException {

        EditingNotificationManager editingNotification = DALSwingLocator.getEditingNotificationManager();

        EditingNotification notification = editingNotification.notifyObservers(

                this,

                EditingNotification.BEFORE_UPDATE_FEATURE_TYPE,

                tablePanel.getDocument(),

                featureStore,

                featureType);

        if (notification.isCanceled()) {

            return false;

        }

        featureStore.update(featureType);

        editingNotification.notifyObservers(

                this,

                EditingNotification.AFTER_UPDATE_FEATURE_TYPE,

                tablePanel.getDocument(),

                featureStore,

                featureType);

        return true;

    }

    public void deleteAttributes(FeatureTable table) throws DataException {

        FeatureAttributeDescriptor[] selecteds = table.getSelectedColumnsAttributeDescriptor();

        FeatureQuery query = this.tablePanel.getTablePanel().getFeatureQuery();

        if(query != null){

            FeatureQueryOrder order = query.getOrder();

            if(order != null) {

                I18nManager i18n = ToolsLocator.getI18nManager();

                for (FeatureAttributeDescriptor selected : selecteds) {

                    if(order.contains(selected.getName())){

                        int n = ToolsSwingLocator.getThreadSafeDialogsManager().confirmDialog(

                                i18n.getTranslation(

                                        "_You_are_trying_to_remove_the_column_XcolumnNameX_that_is_being_sorted_by_Do_you_wish_to_continue",

                                        new String[]{selected.getName()}

                                ),

                                i18n.getTranslation("_Delete_column"),

                                JOptionPane.OK_CANCEL_OPTION,

                                JOptionPane.QUESTION_MESSAGE, 

                                "_You_are_trying_to_remove_the_column_XcolumnNameX_that_is_being_sorted_by_Do_you_wish_to_continue"

                        );

                        if (n != JOptionPane.OK_OPTION){

                            return;

                        }

                        try {

                            order.remove(order.getIndex(selected.getName()));

                        } catch (Throwable t) {

                            logger.warn("Can't remove order", t);

                        }

                    }

                }

            }

        }

        EditableFeatureType eft = featureStore.getDefaultFeatureType().getEditable();

        for (FeatureAttributeDescriptor selected : selecteds) {

            eft.remove(selected.getName());

        }

        featureStore.update(eft);

    }

    public void insertAttributes(FeatureTable table) throws DataException {

        EditableFeatureType eft = featureStore.getDefaultFeatureType().getEditable();

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

        int size = eft.size();

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

            FeatureAttributeDescriptor ad = (FeatureAttributeDescriptor) eft.get(i);

            tmpfnames.add(ad.getName());

        }

        CreateNewAttributePanel panelNewField = new CreateNewAttributePanel(featureStore);

        panelNewField.setCurrentFieldNames(tmpfnames.toArray(new String[0]));

        DataManager dataManager = DALLocator.getDataManager();

        FeatureStoreProviderFactory factory

                = (FeatureStoreProviderFactory) dataManager.

                        getStoreProviderFactory(featureStore.getProviderName());

        panelNewField.setMaxAttributeNameSize(factory.getMaxAttributeNameSize());

        panelNewField.setOkAction(new NewFieldActionListener(panelNewField, eft));

        ApplicationLocator.getManager().getUIManager().addWindow(panelNewField);

        featureStore.update(eft);

    }

    public void renameAttributes(FeatureTable table) throws DataException {

        FeatureAttributeDescriptor[] selecteds = table.getSelectedColumnsAttributeDescriptor();

        I18nManager i18n = ToolsLocator.getI18nManager();

        FeatureQuery query = this.tablePanel.getTablePanel().getFeatureQuery();

        if(query != null){

            FeatureQueryOrder order = query.getOrder();

            if(order != null) {

                for (FeatureAttributeDescriptor selected : selecteds) {

                    if(order.contains(selected.getName())){

                        int n = ToolsSwingLocator.getThreadSafeDialogsManager().confirmDialog(

                                i18n.getTranslation(

                                        "_You_are_trying_to_rename_the_column_XcolumnNameX_that_is_being_sorted_by_Do_you_wish_to_continue",

                                        new String[]{selected.getName()}

                                ),

                                i18n.getTranslation("_Rename_column"),

                                JOptionPane.OK_CANCEL_OPTION,

                                JOptionPane.QUESTION_MESSAGE, 

                                "_You_are_trying_to_rename_the_column_XcolumnNameX_that_is_being_sorted_by_Do_you_wish_to_continue"

                        );

                        if (n != JOptionPane.OK_OPTION){

                            return;

                        }

                        try {

                            order.remove(order.getIndex(selected.getName()));

                        } catch (Throwable t) {

                            logger.warn("Can't remove order", t);

                        }

                    }

                }

            }

        }

        FeatureType _ft = featureStore.getDefaultFeatureType();

        int maxAttributeNameSize = getMaxAttributeSize();

        for (int i = selecteds.length - 1; i >= 0; i--) {

            String newName = "";

            while (newName != null 

                    && (newName.isEmpty() || checkFieldAlreadyExists(_ft, newName))

                    || (maxAttributeNameSize > -1 && StringUtils.length(newName) > maxAttributeNameSize)) {

                newName = JOptionPane.showInputDialog((Component) PluginServices

                        .getMDIManager().getActiveWindow(),

                        PluginServices.getText(

                                this, "_Please_insert_new_field_name"),

                        selecteds[i].getName());

                if (newName == null) {

                    continue;

                }

                if (newName.length() == 0) {

                    ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

                    dialogs.messageDialog(

                            i18n.getTranslation("_Attribute_name_must_not_by_empty"),

                            null,

                            i18n.getTranslation("_Warning"),

                            JOptionPane.WARNING_MESSAGE

                    );

                }

                if (maxAttributeNameSize > -1 && StringUtils.length(newName) > maxAttributeNameSize) {

                    ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

                    dialogs.messageDialog(

                            i18n.getTranslation("_Attribute_name_is_too_long") + "\n"

                            + i18n.getTranslation("_max_size_allowed_for_this_table_is_{0}", new String[]{String.valueOf(maxAttributeNameSize)}),

                            null,

                            i18n.getTranslation("_Warning"),

                            JOptionPane.WARNING_MESSAGE

                    );

                }

                // To be able to change the name of the attribute when it is changed

                // from uppercase to lowercase or vice versa

                if (checkFieldAlreadyExists(_ft, newName)) {

                    ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

                    dialogs.messageDialog(

                            i18n.getTranslation("field_already_exists"),

                            null,

                            i18n.getTranslation("_Warning"),

                            JOptionPane.WARNING_MESSAGE

                    );

                }

            }

            if (newName == null) {

                continue;

            }

            renameAttribute(featureStore, selecteds[i].getName(), newName);

        }

    }

    private boolean checkFieldAlreadyExists(FeatureType ft, String name) {

        FeatureAttributeDescriptor attr = ft.getAttributeDescriptor(name);

        return (attr != null && attr.getName().equals(name));

    }

    private int getMaxAttributeSize() {

        if(featureStore == null){

            return -1;

        }

        DataStoreProviderFactory providerFactory = featureStore.getProviderFactory();

        if(providerFactory == null){

            return -1;

        }

        return ((FeatureStoreProviderFactory)providerFactory).getMaxAttributeNameSize();

    }

    /**

     * This method renames a field in three steps:

     *

     * (1) add new field using type and size of old field. (2) copy value from

     * old field to new field. (3) remove old field.

     *

     * @param fs

     * @param name

     * @param newName

     * @return true if the change took place

     */

    private static boolean renameAttribute(FeatureStore fs, String name, String newName) {

        EditableFeatureType eft = null;

        FeatureType dft = null;

        try {

            dft = fs.getDefaultFeatureType();

            if (dft instanceof EditableFeatureType) {

                eft = (EditableFeatureType) dft;

            } else {

                eft = dft.getEditable();

            }

            EditableFeatureAttributeDescriptor efad

                    = (EditableFeatureAttributeDescriptor) eft.getAttributeDescriptor(name);

            efad.setName(newName);

            fs.update(eft);

        } catch (DataException de) {

            Component root_comp

                    = ApplicationLocator.getManager().getRootComponent();

            JOptionPane.showMessageDialog(

                    root_comp,

                    Messages.getText("_Unable_to_rename_attribute")

                    + ": " + de.getMessage(),

                    Messages.getText("_Unable_to_rename_attribute"),

                    JOptionPane.ERROR_MESSAGE);

            return false;

        }

        return true;

        /*

        try {

            // ========== add new field

            eft = fs.getDefaultFeatureType().getEditable();

            FeatureAttributeDescriptor fad = eft.getAttributeDescriptor(name);

            eft.add(newName, fad.getType(), fad.getSize());

            fs.update(eft);

        } catch (DataException ex) {

            logger.info("Unable to rename attribute (" + name + " --> " + newName + ")", ex);

            ApplicationLocator.getManager().message(

                Messages.getText("_Unable_to_rename_attribute"),

                JOptionPane.ERROR_MESSAGE);

            // did not even add new field

            return false;

        }

        boolean error_when_inserting = false;

        try {

            // ========== copy value old field -> new field

            FeatureSet fset = fs.getFeatureSet();

            DisposableIterator diter = fset.fastIterator();

            Feature feat = null;

            Object val = null;

            EditableFeature efeat = null;

            while (diter.hasNext()) {

                feat = (Feature) diter.next();

                val = feat.get(name);

                efeat = feat.getEditable();

                efeat.set(newName, val);

                fset.update(efeat);

            }

            diter.dispose();

            // Closing editing to check that store admits new field

            fs.finishEditing();

        } catch (DataException ex) {

            logger.info("Error while renaming att to: " + newName, ex);

            String final_msg = getLastMessage(ex);

            JOptionPane.showMessageDialog(

                root_comp,

                Messages.getText("_Unable_to_rename_attribute")

                + ": " + final_msg,

                Messages.getText("_Rename_column"),

                JOptionPane.ERROR_MESSAGE);

            error_when_inserting = true;

        }

        if (error_when_inserting) {

            try {

                // Trying to remove new field and leave table as it was

                eft.remove(newName);

                fs.update(eft);

            } catch (DataException ex) {

                // Unable to remove added field but user was

                // already notified that something went wrong

            }

            // Not changed

            return false;

        }

        try {

            // Finally reopen editing and delete old field

            fs.edit(FeatureStore.MODE_FULLEDIT);

            eft = fs.getDefaultFeatureType().getEditable();

            eft.remove(name);

            fs.update(eft);

        } catch (DataException ex) {

            logger.info("Unable to rename attribute (" + name + " --> " + newName + ")", ex);

            ApplicationLocator.getManager().message(

                Messages.getText("_Unable_to_rename_attribute"),

                JOptionPane.ERROR_MESSAGE);

            return false;

        }

        return true;

         */

    }

    /**

     * Renames field in feature store

     *

     * @param fs

     * @param oldname

     * @param newname

     * @throws DataException

     */

    public static void renameColumn(FeatureStore fs,

            String oldname, String newname) throws DataException {

        FeatureType _ft = fs.getDefaultFeatureType();

        if (_ft.getIndex(newname) != -1) {

            throw new StoreUpdateFeatureTypeException(

                    new Exception("Attribute name already existed."),

                    fs.getName());

        }

        renameAttribute(fs, oldname, newname);

        // fs.finishEditing();

    }

    public class NewFieldActionListener implements ActionListener {

        private CreateNewAttributePanel panel = null;

        private EditableFeatureType eft = null;

        public NewFieldActionListener(CreateNewAttributePanel p, EditableFeatureType t) {

            eft = t;

            panel = p;

        }

        @Override

        public void actionPerformed(ActionEvent e) {

            try {

                EditableFeatureAttributeDescriptor ead = panel.loadFieldDescription(eft);

                if (ead == null) {

                    return;

                }

                if (ead.getType() == DataTypes.STRING

                        && ead.getSize() > TableOperations.MAX_FIELD_LENGTH) {

                    NotificationManager.showMessageInfo(

                            PluginServices.getText(this,

                                    "max_length_is")

                            + ":"

                            + TableOperations.MAX_FIELD_LENGTH,

                            null);

                    ead.setSize(TableOperations.MAX_FIELD_LENGTH);

                }

                PluginServices.getMDIManager().closeWindow(panel);

            } catch (ParseException e2) {

                NotificationManager.addError(e2);

            }

        }

    }

}