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 java.util.Map;

import java.util.Objects;

import org.apache.commons.collections4.map.LRUMap;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionUtils;

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.DataTransaction;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.DatabaseWorkspaceManager;

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

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.StoresRepository;

import org.gvsig.fmap.dal.SupportTransactionsHelper;

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.feature.NewFeatureStoreParameters;

import org.gvsig.fmap.dal.feature.spi.LocalTransaction;

import static org.gvsig.fmap.dal.impl.DatabaseWorkspaceStoresRepository.BIT_CHANGE_DBNAME_CATALOG_SCHEMA;

import static org.gvsig.fmap.dal.impl.DatabaseWorkspaceStoresRepository.BIT_CHANGE_PORT_HOST;

import static org.gvsig.fmap.dal.impl.DatabaseWorkspaceStoresRepository.BIT_CHANGE_USER;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.resourcesstorage.FilesResourcesStorage;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

import org.gvsig.tools.util.Bitmask;

import org.gvsig.tools.util.CachedValue;

import org.gvsig.tools.util.FileTools;

import org.gvsig.tools.util.HasAFile;

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 SupportTransactionsHelper transactionsHelper;

    private class CachedConfigValue extends CachedValue<String> {

        private final String name;

        public CachedConfigValue(String name, String value) {

          this.setValue(value);

          this.name = name;

        }

        public CachedConfigValue(String name, String value, long expireTime) {

          this.name = name;

          this.setValue(value);

          this.setExpireTime(expireTime);

        }

        @Override

        protected void reload() {

//            LOGGER.info("reload CachedConfigValue "+name);

            String s = DefaultDatabaseWorkspaceManager.this.getConfigValue(name);

            if( StringUtils.isBlank(s) ) {

                this.setValue(null);

            } else {

                this.setValue(s);

            }

        }

        @Override

        public String toString() {

            return this.name+" = "+this.getValue();

        }

    }

    private final DataServerExplorerParameters serverParameters;

    private Boolean existsConfiguration = null;

    private StoresRepository storesRepository;

    private CachedConfigValue alternativeResourcesFolder = null;

    private CachedValue<File> baseFolder;

    private Map<String,CachedConfigValue> cachedConfigValues;

    public DefaultDatabaseWorkspaceManager(DataServerExplorerParameters serverParameters) {

        this.serverParameters = serverParameters;

        this.transactionsHelper = new SupportTransactionsHelper();

        this.baseFolder = new CachedValue() {

          @Override

          protected void reload() {

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

            if( StringUtils.isBlank(s) ) {

                this.setValue(null);

            } else {

                s = ExpressionUtils.evaluateDynamicText(DefaultDatabaseWorkspaceManager.this, s);

                this.setValue(new File(s));

            }

          }

        };

        this.baseFolder.setExpireTime(20000); // 20seg

        this.alternativeResourcesFolder = new CachedConfigValue(CONFIG_NAME_ALTERNATIVE_RESOURCES_PATH, null, 30000);

//        this.alternativeResourcesFolder = new CachedValue() {

//          @Override

//          protected void reload() {

//            String s = DefaultDatabaseWorkspaceManager.this.getConfigValue(CONFIG_NAME_ALTERNATIVE_RESOURCES_PATH);

//            if( StringUtils.isBlank(s) ) {

//                this.setValue(null);

//            } else {

//                this.setValue(new File(s));

//            }

//          }

//

//        };

//        this.alternativeResourcesFolder.setExpireTime(30000); // 20seg

        this.cachedConfigValues = new LRUMap<>(20, 20);

        ExpressionEvaluatorLocator.getExpressionEvaluatorManager().populateSymbolTable(this);

    }

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

        if (StringUtils.isBlank(label)) {

            return this.getId();

        }

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

        }

    }

    @Override

    public DataServerExplorer getServerExplorer() {

        DataManager dataManager = DALLocator.getDataManager();

        DataServerExplorer server = null;

        LocalTransaction trans = new LocalTransaction(dataManager, this.getTransaction());

        try {

            trans.begin();

            trans.add(this);

            server = dataManager.openServerExplorer(

                    this.serverParameters.getProviderName(),

                    this.serverParameters

            );

            trans.add(server);

            trans.commit();

            return server;

        } catch (Exception ex) {

            trans.abortQuietly();

            throw new RuntimeException("Can't get server explorer for workspace '"+Objects.toString(this.serverParameters)+"'", ex);

        } finally {

            trans.closeQuietly();

        }

    }

    @Override

    public DataServerExplorerParameters getServerExplorerParameters() {

        return this.serverParameters;

    }

    private boolean existsTable(String tableName) {

        DataServerExplorer server = null;

        LocalTransaction trans = new LocalTransaction(null, this.getTransaction());

        try {

            trans.begin();

            trans.add(this);

            server = this.getServerExplorer();

            trans.add(server);

            List<DataStoreParameters> list = server.list();

            if(list == null){

                trans.commit();

                return false;

            }

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

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

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

                    trans.commit();

                    return true;

                }

            }

            trans.commit();

        } catch (Exception ex) {

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

            trans.abortQuietly();

        } finally {

            trans.closeQuietly();

            DisposeUtils.disposeQuietly(server);

        }

        return false;

    }

    private FeatureStore getTable(String tableName) {

        DataServerExplorer server = null;

        LocalTransaction trans = new LocalTransaction(null, this.getTransaction());

        try {

            trans.begin();

            trans.add(this);

            DataManager dataManager = DALLocator.getDataManager();

            server = this.getServerExplorer();

            trans.add(server);

            DataStoreParameters params = server.get(tableName);

            if( params!=null ) {

                FeatureStore store = (FeatureStore) dataManager.openStore(

                        this.getTransaction(),

                        params.getProviderName(),

                        params,

                        true

                );

                trans.commit();

                return store;

            }

            trans.commit();

        } catch (Exception ex) {

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

            trans.abortQuietly();

        } finally {

            trans.closeQuietly();

            DisposeUtils.disposeQuietly(server);

        }

        return null;

    }

    private void dropTable(String tableName) {

        DataServerExplorer server = null;

        LocalTransaction trans = new LocalTransaction(null, this.getTransaction());

        try {

            trans.begin();

            trans.add(this);

            server = this.getServerExplorer();

            trans.add(server);

            DataStoreParameters params = server.get(tableName);

            if( params!=null ) {

                server.remove(params);

            }

            trans.commit();

        } catch (Exception ex) {

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

            trans.abortQuietly();

        } finally {

            trans.closeQuietly();

            DisposeUtils.disposeQuietly(server);

        }

    }

    @Override

    public void createTableResources(String tableName) throws RuntimeException {

        // H2Spatial crea esta table a mano.

        // Si tocamos algo aqu? hay que modificar

        // la creacion de esta tabla en el helper de H2

        DataServerExplorer server = null;

        LocalTransaction trans = new LocalTransaction(null, this.getTransaction());

        try {

            trans.begin();

            trans.add(this);

            server = this.getServerExplorer();

            trans.add(server);

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

            trans.commit();

        } catch (Exception ex) {

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

            trans.abortQuietly();

            throw new RuntimeException("Can't create resources table '"+tableName+"'.", ex);

        } finally {

            trans.closeQuietly();

            DisposeUtils.disposeQuietly(server);

        }

    }

    private void createTableResources() {

        createTableResources(TABLE_RESOURCES_NAME);

    }

    @Override

    public void createTableRepository(String tableName) throws RuntimeException {

        DataServerExplorer server = null;

        LocalTransaction trans = new LocalTransaction(null, this.getTransaction());

        try {

            trans.begin();

            trans.add(this);

            server = this.getServerExplorer();

            trans.add(server);

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

            ft.add(FIELD_REPOSITORY_FLAGS, DataTypes.INT)

                    .setAllowNull(false)

                    .setDefaultValue(0);

            server.add(tableName, params, false);

            trans.commit();

        } catch (Exception ex) {

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

            trans.abortQuietly();

            throw new RuntimeException("Can't create repository table '"+tableName+"'.", ex);

        } finally {

            trans.closeQuietly();

            DisposeUtils.disposeQuietly(server);

        }

    }

    private void createTableRepository() {

        createTableRepository(TABLE_REPOSITORY_NAME);

    }

    private void createTableConfiguration() {

        // H2Spatial crea esta table a mano.

        // Si tocamos algo aqu? hay que modificar

        // la creacion de esta tabla en el helper de H2

        String tableName = TABLE_CONFIGURATION_NAME;

        DataServerExplorer server = null;

        FeatureStore store = null;

        LocalTransaction trans = new LocalTransaction(null, this.getTransaction());

        try {

            trans.begin();

            trans.add(this);

            server = this.getServerExplorer();

            trans.add(server);

            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, 10240)

                    .setAllowNull(true);

            server.add(tableName, params, false);

            DataStoreParameters openParams = server.get(TABLE_CONFIGURATION_NAME);

            store = (FeatureStore) DALLocator.getDataManager().openStore(

                    this.getTransaction(), openParams.getProviderName(), openParams

            );

            store.edit();

            EditableFeature efeature = store.createNewFeature();

            efeature.set(FIELD_CONFIGURATION_NAME, CONFIG_NAME_ALTERNATIVE_RESOURCES_PATH);

            efeature.set(FIELD_CONFIGURATION_VALUE, null);

            store.insert(efeature);

            store.finishEditing();

            this.existsConfiguration = null;

            trans.commit();

        } catch (Exception ex) {

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

//            FeatureStore.cancelEditingQuietly(store);

            trans.abortQuietly();

        } finally {

            trans.closeQuietly();

            DisposeUtils.disposeQuietly(server);

            DisposeUtils.disposeQuietly(store);

        }

    }

    private boolean existsConfiguration() {

        if( this.existsConfiguration==null ) {

            this.existsConfiguration = this.existsTable(TABLE_CONFIGURATION_NAME);

        }

        return this.existsConfiguration;

    }

    @Override

    public String get(String name) {

        LocalTransaction trans = new LocalTransaction(null, this.getTransaction());

        try {

            trans.begin();

            trans.add(this);

            if (!this.existsConfiguration()) {

                trans.commit();

                return null;

            }

            if (StringUtils.equalsIgnoreCase(name, CONFIG_NAME_BASEFOLDER)) {

                String s = Objects.toString(this.baseFolder.get(), null);

                trans.commit();

                return s;

            }

            if (StringUtils.equalsIgnoreCase(name, CONFIG_NAME_ALTERNATIVE_RESOURCES_PATH)) {

                String s = Objects.toString(this.alternativeResourcesFolder.get(), null);

                trans.commit();

                return s;

            }

            CachedConfigValue cachedValue = this.cachedConfigValues.get(name);

            if (cachedValue != null) {

                String s = cachedValue.get();

                trans.commit();

                return s;

            }

            String value = this.getConfigValue(name);

            this.cachedConfigValues.put(name, new CachedConfigValue(name, value, 15000));

            value = ExpressionUtils.evaluateDynamicText(this, value);

            trans.commit();

            return value;

        } catch (Exception ex) {

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

            trans.abortQuietly();

            return null;

        } finally {

            trans.closeQuietly();

        }

    }

    private String getConfigValue(String name) {

        FeatureStore store = null;

        LocalTransaction trans = new LocalTransaction(null, this.getTransaction());

        try {

            trans.begin();

            trans.add(this);

            if( !this.existsConfiguration() ) {

                trans.commit();

                return null;

            }

            store = this.getTable(TABLE_CONFIGURATION);

            if( store == null ) {

                trans.commit();

                return null;

            }

            trans.add(store);

            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 ) {

                trans.commit();

                return null;

            }

            String value = feature.getString(FIELD_CONFIGURATION_VALUE);

//            value = ExpressionUtils.evaluateDynamicText(this, value);

            trans.commit();

            return value;

        } catch (Exception ex) {

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

            trans.abortQuietly();

            return null;

        } finally {

            trans.closeQuietly();

            DisposeUtils.disposeQuietly(store);

        }

    }

    @Override

    public boolean set(String name, String value) {

        FeatureStore store = null;

        LocalTransaction trans = new LocalTransaction(null, this.getTransaction());

        try {

            trans.begin();

            trans.add(this);

            if( !this.existsConfiguration() ) {

                trans.commit();

                return false;

            }

            store = this.getTable(TABLE_CONFIGURATION);

            if( store == null ) {

                trans.commit();

                return false;

            }

            trans.add(store);

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

            if( StringUtils.equalsIgnoreCase(name, CONFIG_NAME_ALTERNATIVE_RESOURCES_PATH)) {

                this.alternativeResourcesFolder.expired();

            } else if( this.cachedConfigValues.containsKey(name) ) {

                value = ExpressionUtils.evaluateDynamicText(this, value);

                this.cachedConfigValues.get(name).set(value);

            }

            trans.commit();

            return true;

        } catch (Exception ex) {

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

            trans.abortQuietly();

            return false;

        } finally {

            trans.closeQuietly();

            DisposeUtils.disposeQuietly(store);

        }

    }

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

        this.set(CONFIG_NAME_BASEFOLDER, baseFolder.toString());

    }

    public File getWorkspaceFile() {

        if( this.serverParameters instanceof HasAFile ) {

            return ((HasAFile)this.serverParameters).getFile();

        }

        return null;

    }

    private DataStoreParameters replaceInFilesToUseBaseFolder(DataStoreParameters parameters) {

        DynClass dynClass = parameters.getDynClass();

        if( dynClass == null ) {

            return parameters;

        }

        File theBaseFolder = this.getBaseFolder();

        File wsfile = getWorkspaceFile();

        if( theBaseFolder==null && wsfile==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());

                    File newf = null;

                    if( f!=null ) {

                        if( wsfile!=null ) {

                            if( wsfile.equals(f) ) {

                                ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

                                newf = ExpressionUtils.createDynamicFile(

                                    builder.ifnull(

                                        builder.variable("WORKSPACEFILE"),

                                        builder.constant(f.toString()),

                                        builder.variable("WORKSPACEFILE")

                                    )

                                );

                            }

                        }

                        if( newf==null ) {

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

                            if( frel!=f ) {

                                ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

                                newf = ExpressionUtils.createDynamicFile(

                                    builder.concat(

                                            builder.variable(CONFIG_NAME_BASEFOLDER),

                                            builder.constant("/"),

                                            builder.variable(frel.getPath())

                                    )

                                );

                            }

                        }

                        if( newf!=null ) {

                            if( replaced == parameters ) {

                                replaced = (DataStoreParameters) replaced.getCopy();

                            }

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

                        }

                    }

                    break;

            }

        }

        return replaced;

    }

    @Override

    public boolean writeStoresRepositoryEntry(String name, DataStoreParameters parameters) {

        return writeStoresRepositoryEntry(

                name,

                parameters,

                Bitmask.createBitmask(0)

                        .setBit(BIT_CHANGE_PORT_HOST)

                        .setBit(BIT_CHANGE_USER)

                        .setBit(BIT_CHANGE_DBNAME_CATALOG_SCHEMA)

        );

    }

    @Override

    public boolean writeStoresRepositoryEntry(String name, DataStoreParameters parameters, Bitmask flags) {

        FeatureStore store = null;

        LocalTransaction trans = new LocalTransaction(null, this.getTransaction());

        try {

            trans.begin();

            trans.add(this);

            parameters = this.replaceInFilesToUseBaseFolder(parameters);

            byte[] data = parameters.toByteArray();

            if( data == null ) {

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

            }

            store = this.getTable(TABLE_REPOSITORY);

            trans.add(store);

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

                efeature.set(FIELD_REPOSITORY_FLAGS, flags.get());

                store.insert(efeature);

            } else {

                efeature = feature.getEditable();

                efeature.set(FIELD_REPOSITORY_PARAMETERS, data);

                efeature.set(FIELD_REPOSITORY_FLAGS, flags.get());

                store.update(efeature);

            }

            store.finishEditing();

            this.storesRepository = null;

            trans.commit();

            return true;

        } catch (Exception ex) {

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

            trans.abortQuietly();

            return false;

        } finally {

            trans.closeQuietly();

            DisposeUtils.disposeQuietly(store);

        }

    }

    @Override

    public boolean isValid() {

      try {

        String id = this.get(CONFIG_NAME_STORESREPOSITORYID);

        if( StringUtils.isBlank(id) ) {

            return false;

        }

        return true;

      } catch(Exception ex) {

        return false;

      }

    }

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

//        LOGGER.info("getAlternativeResourcesStorage from cache: "+!this.alternativeResourcesFolder.isExpired());

        String s = this.alternativeResourcesFolder.get();

//        LOGGER.info("alternativeResourcesStorage: "+s);

        if( StringUtils.isBlank(s) ) {

            return null;

        }

        s = ExpressionUtils.evaluateDynamicText(this, s);

        File folder = new File(s);

        if( folder==null ) {

            return null;

        }

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

        ResourcesStorage resources = new FilesResourcesStorage(resourcesRoot);

        return resources;

    }

    @Override

    public boolean hasAlternativeResourcesStorage() {

        String path = this.get(CONFIG_NAME_ALTERNATIVE_RESOURCES_PATH);

        return StringUtils.isNotBlank(path);

    }

    @Override

    public void setAlternativeResourcesStorage(String resourcesPath) {

//        this.fix();

      this.set(CONFIG_NAME_ALTERNATIVE_RESOURCES_PATH, resourcesPath);

//      this.alternativeResourcesFolder.expired();

    }

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

        LocalTransaction trans = new LocalTransaction(null, this.getTransaction());

        try {

            trans.begin();

            trans.add(this);

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

            }

            trans.commit();

        } catch (RuntimeException ex) {

            trans.abortQuietly();

            throw ex;

        } catch (Exception ex) {

            trans.abortQuietly();

            throw new RuntimeException("Can't create table " + id, ex);

        } finally {

            trans.closeQuietly();

        }

    }

    @Override

    public boolean exists(String name) {

        FeatureStore store = null;

        LocalTransaction trans = new LocalTransaction(null, this.getTransaction());

        try {

            trans.begin();

            trans.add(this);

            if( StringUtils.equalsIgnoreCase(name, "WORKSPACEFILE") ) {

                File wsfile = getWorkspaceFile();

                if( wsfile!=null ) {

                    trans.commit();

                    return true;

                }

            }

            if (this.existsConfiguration()) {

              if( StringUtils.equalsIgnoreCase(name, CONFIG_NAME_BASEFOLDER) ) {

                trans.commit();

                return true;

              }

              if( this.cachedConfigValues.containsKey(name) ) {

                trans.commit();

                return true;

              }

              store = this.getTable(TABLE_CONFIGURATION);

              trans.add(store);

              if (store != null) {

                  ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

                  String filter = builder.eq(