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.online.lib.impl.workspace.tables;

import java.sql.Timestamp;

import java.util.HashMap;

import java.util.Map;

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

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

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

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

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

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

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

import org.gvsig.tools.dispose.DisposeUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.online.lib.api.workingcopy.OnlineWorkingcopy;

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings(value = "UseSpecificCatch")

public abstract class AbstractTable {

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

    public static abstract class AbstractRow {

        protected final OnlineWorkingcopy workspace;

//        private EditableFeature feature;

        private final String tableName;

        private final String codeName;

        private Map<String,Object> values;

        protected AbstractRow(OnlineWorkingcopy workspace, String tableName, String codeName) {

            this.tableName = tableName;

            this.codeName = codeName;

            this.workspace = workspace;

            this.values = new HashMap<>();

//            this.newCode();

        }

        protected AbstractRow(OnlineWorkingcopy workspace, String tableName, String codeName, Feature feature) {

            this(workspace, tableName, codeName);

            if (feature != null) {

                FeatureType ft = feature.getType();

                for (FeatureAttributeDescriptor attrdesc : ft) {

                    String attrname = attrdesc.getName();

                    this.values.put(attrname, feature.get(attrname));

                }

            }

        }

        protected boolean isNull(String attrname) {

            return this.values.get(attrname) == null;

        }

        protected String getString(String attrname) {

            return (String) this.values.get(attrname);

        }

        protected Timestamp getTimestamp(String attrname) {

            return (Timestamp) this.values.getOrDefault(attrname, null);

        }

        protected int getInt(String attrname) {

            return this.getInt(attrname, -1);

        }

        protected int getInt(String attrname, int defaultValue) {

            Integer n = (Integer) this.values.get(attrname);

            if( n==null ) {

                return defaultValue;

            }

            return n;

        }

        protected long getLong(String attrname) {

            return this.getLong(attrname, -1);

        }

        protected long getLong(String attrname, long defaultValue) {

            Long n = (Long) this.values.get(attrname);

            if( n==null ) {

                return defaultValue;

            }

            return n;

        }

        protected boolean getBoolean(String attrname) {

            return this.getBoolean(attrname, false);

        }

        protected boolean getBoolean(String attrname, boolean defaultValue) {

            Boolean n = (Boolean) this.values.get(attrname);

            if( n==null ) {

                return defaultValue;

            }

            return n;

        }

        protected String getLabelOfValue(String attrname) {

            FeatureType ft = this.workspace.getFeatureType(this.tableName);

            FeatureAttributeDescriptor attrdesc = ft.getAttributeDescriptor(attrname);

            String label = attrdesc.getLabelOfValue(this.values.get(attrname));

            return label;

        }

        protected void set(String attrname, String value) {

            this.values.put(attrname, value);

        }

        protected void set(String attrname, int value) {

            this.values.put(attrname, value);

        }

        protected void set(String attrname, long value) {

            this.values.put(attrname, value);

        }

        protected void set(String attrname, boolean value) {

            this.values.put(attrname, value);

        }

        protected void set(String attrname, Timestamp value) {

            this.values.put(attrname, value);

        }

        public void update() {

            FeatureStore store = null;

            boolean pendingFinishEditing = false;

            try {

                store = this.workspace.openFeatureStore(this.tableName,false);

                if( store.getMode() == FeatureStore.MODE_QUERY ) {

                    store.edit(FeatureStore.MODE_PASS_THROUGH);

                    pendingFinishEditing = true;

                }

                this.update(store);

                if( pendingFinishEditing ) {

                    store.finishEditing();

                }

            } catch (Exception ex) {

                if( store!=null && pendingFinishEditing ) {

                    store.cancelEditingQuietly();

                }

                throw new RuntimeException("Can't update feature on '"+this.tableName+"'.", ex);

            } finally {

               DisposeUtils.disposeQuietly(store);

            }

        }

        public void insert() {

            FeatureStore store = null;

            boolean pendingFinishEditing = false;

            try {

                store = this.workspace.openFeatureStore(this.tableName, false);

                if( !store.isEditing() ) {

                    store.edit(FeatureStore.MODE_FULLEDIT);

                    pendingFinishEditing = true;

                }

                this.insert(store);

                if( pendingFinishEditing ) {

                    store.finishEditing();

                }

            } catch (Exception ex) {

                if( store!=null && pendingFinishEditing ) {

                    store.cancelEditingQuietly();

                }

                throw new RuntimeException("Can't update feature on '"+this.tableName+"'.", ex);

            } finally {

               DisposeUtils.disposeQuietly(store);

            }

        }

        public EditableFeature createFeature(FeatureStore store) throws DataException {

            EditableFeature f = store.createNewFeature();

            for (Map.Entry<String, Object> value : this.values.entrySet()) {

                if( f.hasValue(value.getKey())) {

                    f.set(value.getKey(), value.getValue());

                }

            }

            return f;

        }

        public void insert(FeatureStore store) {

            try {

                store.insert(this.createFeature(store));

            } catch (Exception ex) {

                throw new RuntimeException("Can't insert feature on '"+this.tableName+"'.", ex);

            }

        }

        public void update(FeatureStore store) {

            try {

                EditableFeature feature = this.createFeature(store);

                feature.setUpdatable(true);

                store.update(feature);

            } catch (Exception ex) {

                throw new RuntimeException("Can't update feature on '"+this.tableName+"'.", ex);

            }

        }

        public void update(FeatureStore store, FeatureSet fSet) {

            try {

                EditableFeature feature = this.createFeature(store);

                feature.setUpdatable(true);

                fSet.update(feature);

            } catch (Exception ex) {

                throw new RuntimeException("Can't update feature on '"+this.tableName+"'.", ex);

            }

        }

        public void delete(FeatureStore store) {

            try {

//                EditableFeature feat = this.createFeature(store);

//                feat.setUpdatable(true);

//                store.delete(feat);

                store.delete("\""+this.codeName+"\" = '"+this.getString(this.codeName)+"'");

            } catch (Exception ex) {

                throw new RuntimeException("Can't delete feature on '"+this.tableName+"'.", ex);

            }

        }

        public String getCode() {

            return this.getString(this.codeName);

        }

        public void newCode() {

            this.set(this.codeName, workspace.createUniqueCode());

        }

        public void setCode(String code) {

            this.set(this.codeName, code);

        }

    }

    private final String tableName;

    private final FeatureType featureType;

    public AbstractTable(String tableName, FeatureType featureType) {

        this.tableName = tableName;

        this.featureType = featureType;

    }

    public String getTableName() {

        return this.tableName;

    }

    public FeatureType getFeatureType() {

        return this.featureType;

    }

}