Application: gvSIG desktop

package org.gvsig.fmap.dal.impl;

import org.gvsig.fmap.dal.DatabaseWorkspaceManager;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.StoresRepository;

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

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

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

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

//import org.gvsig.fmap.dal.store.jdbc.JDBCNewStoreParameters;

//import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorer;

//import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorerParameters;

//import org.gvsig.fmap.dal.store.jdbc.JDBCStoreParameters;

import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.FIELD_REPOSITORY_NAME;

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class DefaultDatabaseWorkspaceManager implements DatabaseWorkspaceManager {

    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultDatabaseWorkspaceManager.class);

    private final DataServerExplorerParameters connection;

    private Boolean existsConfiguration = null;

    private StoresRepository storesRepository;

    public DefaultDatabaseWorkspaceManager(DataServerExplorerParameters connection) {

        this.connection = connection;

    }

    @Override

    public boolean existsTable(int tableid) {

        switch(tableid) {

            case TABLE_RESOURCES:

                return this.existsTable(TABLE_RESOURCES_NAME);

            case TABLE_REPOSITORY:

                return this.existsTable(TABLE_REPOSITORY_NAME);

            case TABLE_CONFIGURATION:

                return this.existsTable(TABLE_CONFIGURATION_NAME);

            default:

                throw new IllegalArgumentException("Invalid table identitier "+tableid);

        }

    }

    @Override

    public void createTable(int tableid) {

        switch(tableid) {

            case TABLE_RESOURCES:

                createTableResources();

                break;

            case TABLE_REPOSITORY:

                createTableRepository();

                break;

            case TABLE_CONFIGURATION:

                createTableConfiguration();

                break;

            default:

                throw new IllegalArgumentException("Invalid table identitier "+tableid);

        }

    }

    @Override

    public void dropTable(int tableid) {

        switch(tableid) {

            case TABLE_RESOURCES:

                this.dropTable(TABLE_RESOURCES_NAME);

                break;

            case TABLE_REPOSITORY:

                this.dropTable(TABLE_REPOSITORY_NAME);

                break;

            case TABLE_CONFIGURATION:

                this.dropTable(TABLE_CONFIGURATION_NAME);

                break;

            default:

                throw new IllegalArgumentException("Invalid table identitier "+tableid);

        }

    }

    @Override

    public FeatureStore getTable(int tableid) {

        switch(tableid) {

            case TABLE_RESOURCES:

                return this.getTable(TABLE_RESOURCES_NAME);

            case TABLE_REPOSITORY:

                return this.getTable(TABLE_REPOSITORY_NAME);

            case TABLE_CONFIGURATION:

                return this.getTable(TABLE_CONFIGURATION_NAME);

            default:

                throw new IllegalArgumentException("Invalid table identitier "+tableid);

        }

    }

    private boolean existsTable(String tableName) {

        try {

            DataManager dataManager = DALLocator.getDataManager();

            DataServerExplorer server = dataManager.openServerExplorer(

                    this.connection.getExplorerName(),

                    this.connection

            );

            for (DataStoreParameters params : server.list()) {

                String theTableName = (String) params.getDynValue("Table");

                if( StringUtils.equals(theTableName, tableName) ) {

                    return true;

                }

            }

        } catch (Exception ex) {

            LOGGER.warn("Can't check if the table '"+tableName+"' exists.",ex);

        }

        return false;

    }

    private FeatureStore getTable(String tableName) {

        try {

            DataManager dataManager = DALLocator.getDataManager();

            DataServerExplorer server = dataManager.openServerExplorer(

                    this.connection.getExplorerName(),

                    this.connection

            );

            DataStoreParameters params = server.get(tableName);

            if( params!=null ) {

                FeatureStore store = (FeatureStore) dataManager.openStore(

                        params.getDataStoreName(), 

                        params

                );

                return store;

            }

        } catch (Exception ex) {

            LOGGER.warn("Can't open table '"+tableName+"'.",ex);

        }

        return null;

    }

    private void dropTable(String tableName) {

        try {

            DataManager dataManager = DALLocator.getDataManager();

            DataServerExplorer server = dataManager.openServerExplorer(

                    this.connection.getExplorerName(),

                    this.connection

            );

            DataStoreParameters params = server.get(tableName);

            if( params!=null ) {

                server.remove(params);

            }

        } catch (Exception ex) {

            LOGGER.warn("Can't drop table '"+tableName+"'.",ex);

        }

    }

    private void createTableResources() {

        String tableName = TABLE_RESOURCES_NAME;

        try {

            DataManager dataManager = DALLocator.getDataManager();

            DataServerExplorer server = dataManager.openServerExplorer(

                    this.connection.getExplorerName(),

                    this.connection

            );

            NewFeatureStoreParameters params = (NewFeatureStoreParameters) server.getAddParameters(tableName);

            EditableFeatureType ft = params.getDefaultFeatureType();

            ft.add(FIELD_RESOURCES_NAME, DataTypes.STRING, 150)

                    .setAllowNull(false)

                    .setIsPrimaryKey(true);

            ft.add(FIELD_RESOURCES_RESOURCE, DataTypes.BYTEARRAY)

                    .setAllowNull(true);

            server.add(tableName, params, false);

        } catch (Exception ex) {

            LOGGER.warn("Can't create table '"+tableName+"'.",ex);

        }

    }

    private void createTableRepository() {

        String tableName = TABLE_REPOSITORY_NAME;

        try {

            DataManager dataManager = DALLocator.getDataManager();

            DataServerExplorer server = dataManager.openServerExplorer(

                    this.connection.getExplorerName(),

                    this.connection

            );

            NewFeatureStoreParameters params = (NewFeatureStoreParameters) server.getAddParameters(tableName);

            EditableFeatureType ft = params.getDefaultFeatureType();

            ft.add(FIELD_REPOSITORY_NAME, DataTypes.STRING, 150)

                    .setAllowNull(false)

                    .setIsPrimaryKey(true);

            ft.add(FIELD_REPOSITORY_PARAMETERS, DataTypes.BYTEARRAY)

                    .setAllowNull(true);

            server.add(tableName, params, false);

        } catch (Exception ex) {

            LOGGER.warn("Can't create table '"+tableName+"'.",ex);

        }

    }

    private void createTableConfiguration() {

        String tableName = TABLE_CONFIGURATION_NAME;

        try {

            DataManager dataManager = DALLocator.getDataManager();

            DataServerExplorer server = dataManager.openServerExplorer(

                    this.connection.getExplorerName(),

                    this.connection

            );

            NewFeatureStoreParameters params = (NewFeatureStoreParameters) server.getAddParameters(tableName);

            EditableFeatureType ft = params.getDefaultFeatureType();

            ft.add(FIELD_CONFIGURATION_NAME, DataTypes.STRING, 200)

                    .setAllowNull(false)

                    .setIsPrimaryKey(true);

            ft.add(FIELD_CONFIGURATION_VALUE, DataTypes.STRING, 200)

                    .setAllowNull(true);

            server.add(tableName, params, false);

        } catch (Exception ex) {

            LOGGER.warn("Can't create table '"+tableName+"'.",ex);

        }

    }

    private boolean existsConfiguration() {

        if( this.existsConfiguration==null ) {

            this.existsConfiguration = this.existsTable(TABLE_CONFIGURATION_NAME);

        }

        return this.existsConfiguration;

    }

    @Override

    public String get(String name) {

        try {

            if( !this.existsConfiguration() ) {

                return null;

            }

            FeatureStore store = this.getTable(TABLE_CONFIGURATION);

            if( store == null ) {

                return null;

            }

            ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

            String filter = builder.eq(

                    builder.column(FIELD_CONFIGURATION_NAME),

                    builder.constant(name)

            ).toString();

            Feature feature = store.findFirst(filter);

            if( feature == null ) {

                return null;

            }

            String value = feature.getString(FIELD_CONFIGURATION_VALUE);

            return value;

        } catch (Exception ex) {

            LOGGER.warn("Can't read configuration value '"+name+"'", ex);

            return null;

        }

    }

    @Override

    public void set(String name, String value) {

        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    }

    @Override

    public StoresRepository getStoresRepository() {

        if( this.storesRepository==null ) {

            String id = this.get(CONFIG_NAME_STORESREPOSITORYID);

            String label = this.get(CONFIG_NAME_STORESREPOSITORYLABEL);

            this.storesRepository = new DatabaseWorkspaceStoresRepository(

                    id,

                    label,

                    this.connection

            );

        }

        return this.storesRepository;

    }

    @Override

    public boolean canAnonymousUserWriteInTheTables() {

        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    }

    @Override

    public boolean storesRepositoryWriteEntry(String name, DataStoreParameters parameters) {

        try {

            byte[] data = parameters.toByteArray();

            if( data == null ) {

                throw new RuntimeException("Can't convert parameters to byte array.");

            }

            FeatureStore store = this.getTable(TABLE_REPOSITORY);

            store.edit();

            ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

            String filter = builder.eq(

                    builder.column(FIELD_REPOSITORY_NAME),

                    builder.constant(name)

            ).toString();

            Feature feature = store.findFirst(filter);

            EditableFeature efeature;

            if (feature == null) {

                efeature = store.createNewFeature();

                efeature.set(FIELD_REPOSITORY_NAME, name);

                efeature.set(FIELD_REPOSITORY_PARAMETERS, data);

                store.insert(efeature);

            } else {

                efeature = feature.getEditable();

                efeature.set(FIELD_REPOSITORY_PARAMETERS, data);

                store.update(efeature);

            }

            store.finishEditing();

            return true;

        } catch (Exception ex) {

            LOGGER.warn("Can't save entry '"+name+"' in repository information", ex);

            return false;

        }

    }

    @Override

    public boolean isValidStoresRepository() {

        String id = this.get(CONFIG_NAME_STORESREPOSITORYID);

        if( StringUtils.isBlank(id) ) {

            return false;

        }

        if( !this.existsTable(TABLE_REPOSITORY_NAME) ) {

            return false;

        }

        return true;

    }

}