Application: gvSIG desktop

package org.gvsig.fmap.dal.impl;

import java.io.File;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.List;

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.expressionevaluator.SymbolTable;

import org.gvsig.expressionevaluator.spi.AbstractSymbolTable;

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.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.resourcesstorage.FilesResourcesStorage;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

import org.gvsig.tools.util.FileTools;

import org.gvsig.tools.util.HasAFile;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class DefaultDatabaseWorkspaceManager 

        extends AbstractSymbolTable

        implements DatabaseWorkspaceManager

    {

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

    private static final String CONFIG_NAME_BASEFOLDER = "BASEFOLDER";

    private static final String CONFIG_NAME_ALTERNATIVE_RESOURCES_PATH = "ALTERNATIVE_RESOURCES_PATH";

    private static abstract class CachedValue<T> {

        protected T value = null;

        private long lastAccess = 0;

        private final int millis;

        protected CachedValue(int millis) {

            this.millis = millis;

        }

        protected abstract void reload();

        public boolean isExpired() {

            long now = System.currentTimeMillis();

            return now - lastAccess > millis;

        }

        public T get() {

            if (isExpired()) {

                reload();

            }

            lastAccess = System.currentTimeMillis();

            return value;

        }

        public void set(T value) {

            this.value = value;

            lastAccess = System.currentTimeMillis();

        }

    }

    private class BaseFolder extends CachedValue<File> {

        public BaseFolder() {

            super(3000);

        }

        @Override

        protected void reload() {

            String s = DefaultDatabaseWorkspaceManager.this.get(CONFIG_NAME_BASEFOLDER);

            if( StringUtils.isBlank(s) ) {

                this.value = null;

            } else {

                this.value = new File(s);

            }

        }

        @Override

        public void set(File value) {

            DefaultDatabaseWorkspaceManager.this.set(CONFIG_NAME_BASEFOLDER, value.toString());

            super.set(value);

        }

    }

    private final DataServerExplorerParameters serverParameters;

    private Boolean existsConfiguration = null;

    private StoresRepository storesRepository;

    private Mutable<File> alternativeResourcesFolder = null;

    private BaseFolder baseFolder = null;

    public DefaultDatabaseWorkspaceManager(DataServerExplorerParameters serverParameters) {

        this.serverParameters = serverParameters;

        this.baseFolder = new BaseFolder();

    }

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

            value = ExpressionUtils.evaluateDynamicText(this, 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

            );

        }

        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 File getBaseFolder() {

        return this.baseFolder.get();

    }

    @Override

    public void setBaseFolder(File baseFolder) {

        this.baseFolder.set(baseFolder);

    }

    private DataStoreParameters replaceInFilesToUseBaseFolder(DataStoreParameters parameters) {

        DynClass dynClass = parameters.getDynClass();

        if( dynClass == null ) {

            return parameters;

        }

        File theBaseFolder = this.getBaseFolder();

        if( theBaseFolder==null ) {

            return parameters;

        }

        DataStoreParameters replaced = parameters;

        for (DynField dynField : dynClass.getDynFields()) {

            switch(dynField.getType()) {

                case DataTypes.FILE:

                case DataTypes.FOLDER:

                    File f = (File) parameters.getDynValue(dynField.getName());

                    if( f!=null ) {

                        File f2 = FileTools.relativizeFile(theBaseFolder, f);

                        if( f2!=f ) {

                            f = new File("<%="+CONFIG_NAME_BASEFOLDER+"%>/"+f2.getPath());

                            if( replaced == parameters ) {

                                replaced = (DataStoreParameters) replaced.getCopy();

                            }

                            replaced.setDynValue(dynField.getName(), f);

                        }

                    }

                    break;

            }

        }

        return replaced;

    }

    @Override

    public boolean writeStoresRepositoryEntry(String name, DataStoreParameters parameters) {

        try {

            parameters = this.replaceInFilesToUseBaseFolder(parameters);

            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(CONFIG_NAME_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(CONFIG_NAME_ALTERNATIVE_RESOURCES_PATH,"");

        File theBaseFolder = this.getBaseFolder();

        if( this.serverParameters instanceof HasAFile && theBaseFolder==null ) {

            File f = ((HasAFile)this.serverParameters).getFile();

            if( f != null ) {

                theBaseFolder = f.getParentFile();

                this.setBaseFolder(theBaseFolder);

            } else {

                this.set(CONFIG_NAME_BASEFOLDER,"");

            }

        } else {

            this.set(CONFIG_NAME_BASEFOLDER,"");

        }

    }

    @Override

    public boolean exists(String name) {

        try {

            if (this.existsConfiguration()) {

                FeatureStore store = this.getTable(TABLE_CONFIGURATION);

                if (store != 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 true;

                    }

                }

            }

            return super.exists(name);

        } catch (Exception ex) {

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

            return false;

        }

    }

    @Override

    public Object value(String name) {

        String v = this.get(name);

        if( v!=null ) {

            return v;

        }

        return super.value(name);

    }

    @Override

    public Collection<String> localvariables() {

        try {

            final List<String> theVars = new ArrayList<>();

            if (this.existsConfiguration()) {

                FeatureStore store = this.getTable(TABLE_CONFIGURATION);

                if (store != null) {

                    store.accept(new Visitor() {

                        @Override

                        public void visit(Object obj) throws VisitCanceledException, BaseException {

                            Feature feature = (Feature) obj;

                            theVars.add(feature.getString(FIELD_CONFIGURATION_NAME));

                        }

                    });

                }

            }

            return theVars;

        } catch (Exception ex) {

            LOGGER.warn("Can't read configuration variables", ex);

            return Collections.EMPTY_LIST;

        }

    }

}