Application: gvSIG desktop

package org.gvsig.fmap.dal.impl;

import java.io.File;

import org.gvsig.fmap.dal.DatabaseWorkspaceManager;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.mutable.Mutable;

import org.apache.commons.lang3.mutable.MutableObject;

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 static org.gvsig.fmap.dal.DatabaseWorkspaceManager.CONFIG_NAME_STORESREPOSITORYID;

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

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

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

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 static org.gvsig.fmap.dal.DatabaseWorkspaceManager.FIELD_REPOSITORY_NAME;

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

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

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

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

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

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

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

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

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

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

import org.gvsig.tools.resourcesstorage.FilesResourcesStorage;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

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

    private Boolean existsConfiguration = null;

    private StoresRepository storesRepository;

    private Mutable<File> alternativeResourcesFolder = null;

    public DefaultDatabaseWorkspaceManager(DataServerExplorerParameters serverParameters) {

        this.serverParameters = serverParameters;

    }

    @Override

    public String toString() {

        return this.getLabel();

    }

    @Override

    public String getId() {

        String id = this.get(CONFIG_NAME_STORESREPOSITORYID);

        return id;

    }

    @Override

    public String getLabel() {

        String label = this.get(CONFIG_NAME_STORESREPOSITORYLABEL);

        return label;

    }

    @Override

    public DatabaseWorkspaceManager getValue() {

        return this;

    }

    @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.serverParameters.getProviderName(),

                    this.serverParameters

            );

            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.serverParameters.getProviderName(),

                    this.serverParameters

            );

            DataStoreParameters params = server.get(tableName);

            if( params!=null ) {

                FeatureStore store = (FeatureStore) dataManager.openStore(

                        params.getProviderName(), 

                        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.serverParameters.getProviderName(),

                    this.serverParameters

            );

            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.serverParameters.getProviderName(),

                    this.serverParameters

            );

            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.serverParameters.getProviderName(),

                    this.serverParameters

            );

            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.serverParameters.getProviderName(),

                    this.serverParameters

            );

            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 boolean set(String name, String value) {

        try {

            if( !this.existsConfiguration() ) {

                return false;

            }

            FeatureStore store = this.getTable(TABLE_CONFIGURATION);

            if( store == null ) {

                return false;

            }

            store.edit();

            ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

            String filter = builder.eq(

                    builder.column(FIELD_CONFIGURATION_NAME),

                    builder.constant(name)

            ).toString();

            Feature feature = store.findFirst(filter);

            EditableFeature efeature;

            if (feature == null) {

                efeature = store.createNewFeature();

                efeature.set(FIELD_CONFIGURATION_NAME, name);

                efeature.set(FIELD_CONFIGURATION_VALUE, value);

                store.insert(efeature);

            } else {

                efeature = feature.getEditable();

                efeature.set(FIELD_CONFIGURATION_VALUE, value);

                store.update(efeature);

            }

            store.finishEditing();

            return true;

        } catch (Exception ex) {

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

            return false;

        }

    }

    @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.serverParameters

            );

        }

        return this.storesRepository;

    }

    public boolean contains(DataStoreParameters parameters) {

        boolean c = this.getStoresRepository().contains(parameters);

        return c;

    }

    @Override

    public boolean canAnonymousUserWriteInTheTables() {

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

    }

    @Override

    public boolean writeStoresRepositoryEntry(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 isValid() {

        String id = this.get(CONFIG_NAME_STORESREPOSITORYID);

        if( StringUtils.isBlank(id) ) {

            return false;

        }

        return true;

    }

    @Override

    public boolean isValidStoresRepository() {

        if( !this.isValid() ) {

            return false;

        }

        if( !this.existsTable(TABLE_REPOSITORY_NAME) ) {

            return false;

        }

        return true;

    }

    @Override

    public ResourcesStorage getAlternativeResourcesStorage(String tableName) {

        if( this.alternativeResourcesFolder==null ) {

            this.alternativeResourcesFolder = new MutableObject<>(null);

            String resourcesPath = this.get("ALTERNATIVE_RESOURCES_PATH");

            if( !StringUtils.isBlank(resourcesPath) ) {

                try {

                    resourcesPath = (String) ExpressionUtils.evaluate(resourcesPath);

                } catch(Throwable th) {

                    // Do nothing

                }

                File f = new File(resourcesPath);

                if( f.exists() ) {

                    this.alternativeResourcesFolder.setValue(f);

                }

            }

        }

        File folder = this.alternativeResourcesFolder.getValue();

        if( folder==null ) {

            return null;

        }

        String resourcesRoot = folder.getAbsolutePath().replace("\\","/") + "/" + tableName;

        ResourcesStorage resources = new FilesResourcesStorage(resourcesRoot);

        return resources;

    }

    @Override

    public void drop() {

        if( !this.existsTable(TABLE_RESOURCES) ) {

            this.dropTable(TABLE_RESOURCES);

        }

        if( !this.existsTable(TABLE_CONFIGURATION) ) {

            this.dropTable(TABLE_CONFIGURATION);

        }

        if( !this.existsTable(TABLE_REPOSITORY) ) {

            this.dropTable(TABLE_REPOSITORY);

        }

    }

    @Override

    public void create(String id, String description) {

        if( !this.existsTable(TABLE_RESOURCES) ) {

            this.createTable(TABLE_RESOURCES);

        }

        if( !this.existsTable(TABLE_CONFIGURATION) ) {

            this.createTable(TABLE_CONFIGURATION);

        }

        if( !this.existsTable(TABLE_REPOSITORY) ) {

            this.createTable(TABLE_REPOSITORY);

        }

        this.set(CONFIG_NAME_STORESREPOSITORYID,id);

        this.set(CONFIG_NAME_STORESREPOSITORYLABEL,description);

        this.set(CONFIG_CAN_ANONYMOUS_USER_WRITE_IN_THE_TABLES,"true");

        this.set("ALTERNATIVE_RESOURCES_PATH","");

    }

}