Application: gvSIG desktop

package org.gvsig.fmap.dal.impl;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.InputStream;

import java.net.URL;

import java.net.URLClassLoader;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import java.util.function.Predicate;

import java.util.logging.Level;

import javax.json.JsonArray;

import javax.json.JsonObject;

import javax.json.JsonValue;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.impl.DefaultDALExpressionBuilder;

import org.gvsig.expressionevaluator.impl.DefaultFeatureRuleExpression;

import org.gvsig.expressionevaluator.impl.symboltable.FeatureSymbolTableImpl;

import org.gvsig.fmap.dal.BaseStoresRepository;

import org.gvsig.fmap.dal.DataFactory;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataServerExplorerFactory;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataServerExplorerPool;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreFactory_v2_4;

import org.gvsig.fmap.dal.DataStoreNotification;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataStoreProviderFactory;

import org.gvsig.fmap.dal.DataTransaction;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.DatabaseWorkspaceManager;

import org.gvsig.fmap.dal.DatabaseWorkspaceManager.DatabaseWorkspaceListener;

import org.gvsig.fmap.dal.NewDataStoreParameters;

import org.gvsig.fmap.dal.OpenErrorHandler;

import org.gvsig.fmap.dal.Register;

import org.gvsig.fmap.dal.StoresRepository;

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

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

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

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

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

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

import org.gvsig.fmap.dal.expressionevaluator.DALExpressionBuilder;

import org.gvsig.fmap.dal.expressionevaluator.FeatureAttributeEmulatorExpression;

import org.gvsig.fmap.dal.expressionevaluator.FeatureSymbolTable;

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.exception.UnsupportedDataTypeException;

import org.gvsig.fmap.dal.feature.impl.DALFile;

import org.gvsig.fmap.dal.feature.impl.DataTypeDetectorImpl;

import org.gvsig.fmap.dal.feature.impl.DefaultEditableFeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.impl.DefaultEditableFeatureType;

import org.gvsig.fmap.dal.feature.impl.DefaultFeatureIndex;

import org.gvsig.fmap.dal.feature.impl.DefaultFeatureStore;

import org.gvsig.fmap.dal.feature.impl.FeatureStoreFactory;

import org.gvsig.fmap.dal.feature.impl.LabelsCacheForFieldValuesImpl;

import org.gvsig.fmap.dal.feature.paging.FeaturePagingHelper;

import org.gvsig.fmap.dal.feature.paging.impl.FeaturePagingHelperImpl;

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

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

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

import org.gvsig.fmap.dal.feature.spi.cache.FeatureCacheProvider;

import org.gvsig.fmap.dal.feature.spi.cache.FeatureCacheProviderFactory;

import org.gvsig.fmap.dal.feature.spi.index.FeatureIndexProvider;

import org.gvsig.fmap.dal.feature.spi.index.FeatureIndexProviderServices;

import org.gvsig.fmap.dal.impl.expressionevaluator.DefaultFeatureAttributeEmulatorExpression;

import org.gvsig.fmap.dal.impl.expressionevaluator.DefaultFeatureExpressionEvaluator;

import org.gvsig.fmap.dal.raster.impl.RasterStoreFactory;

import org.gvsig.fmap.dal.raster.impl.RasterStoreOldFactory;

import org.gvsig.fmap.dal.raster.spi.CoverageStoreProvider;

import org.gvsig.fmap.dal.spi.AbstractDataParameters;

import org.gvsig.fmap.dal.spi.DALSPILocator;

import org.gvsig.fmap.dal.spi.DataManagerProviderServices;

import org.gvsig.fmap.dal.spi.DataServerExplorerPoolImpl;

import org.gvsig.fmap.dal.spi.DataStoreProvider;

import org.gvsig.fmap.dal.spi.DataStoreProviderServices;

import static org.gvsig.fmap.dal.spi.DataStoreProviderServices.PROVIDER_PARAMTER_NAME;

import org.gvsig.fmap.dal.store.memory.MemoryStoreParameters;

import org.gvsig.fmap.dal.store.memory.MemoryStoreProvider;

import org.gvsig.json.Json;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.dynobject.DynStruct_v2;

import org.gvsig.tools.dynobject.Tags;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.extensionpoint.ExtensionPoint;

import org.gvsig.tools.folders.FoldersManager;

import org.gvsig.tools.identitymanagement.SimpleIdentityManager;

import org.gvsig.tools.identitymanagement.UnauthorizedException;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.resourcesstorage.BytesResource;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

import org.gvsig.tools.script.Script;

import org.gvsig.tools.script.ScriptManager;

import org.gvsig.tools.service.spi.Services;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.util.Factory;

import org.gvsig.tools.util.Invocable;

import org.gvsig.tools.util.PropertiesSupportHelper;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

public class DefaultDataManager

        implements DataManager, DataManagerProviderServices, Services {

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

    final static private String DATA_MANAGER_CACHE = "Data.manager.caches";

    final static private String DATA_MANAGER_CACHE_DESCRIPTION =

        "DAL cache providers";

    public static final String FILESYSTEM_EXPLORER_NAME = "FilesystemExplorer";

    public static final long DEFAULT_MAX_SIZE_FOR_SMALL_FEATURE_SELECTION = 2000000000;

    private class Registers {

        private final Register store;

        private final Register storeProvider;

        private final Register serverExplorer;

        private final Register featureIndexProvider;

        public Registers() {

            this.store = new RegisterImpl(

                    "Data.manager.stores.factory",

                    "DAL store factories"

            );

            this.storeProvider = new RegisterImpl(

                    "Data.manager.providers.factory",

                    "DAL store provider factories"

            );

            this.serverExplorer = new RegisterImpl(

                    "Data.manager.servereexplorer.factory",

                    "DAL server explorer factories"

            );

            this.featureIndexProvider = new RegisterImpl(

                    "Data.manager.feature.index.factory",

                    "DAL feature index factories"

            );

            this.store.register(new FeatureStoreFactory());

        }

    }

    private static final String TAG_DAL_OPENSTORE = "dal.openstore.";

    private final Registers registers;

    private final Map<Integer, String> defaultDataIndexProviders;

    private OpenErrorHandler openErrorHandler = null;

    private DataServerExplorerPool dataServerExplorerPool = null;

    private List<DataType> dataTypes = null;

    private ClassLoader resourcesLoader = null;

    private Map<String,DataProfile> dataProfiles;

    private final Map<String, DatabaseWorkspaceManager> databaseWorkspaces = new HashMap<>();

    private final Map<String,DatabaseWorkspaceListener> addDatabaseWorkspaceListeners = new HashMap<>();

    private final Set<Observer>storeObservers = new HashSet<>();

    private long maxSizeForSmallFeatureSelection;

    private Factory largeMapFactory;

    private Factory largeSetFactory;

    public DefaultDataManager() {

        this.registers = new Registers();

        this.defaultDataIndexProviders = new HashMap<>();

        this.maxSizeForSmallFeatureSelection = DEFAULT_MAX_SIZE_FOR_SMALL_FEATURE_SELECTION;

        this.largeMapFactory = new Factory() {

            @Override

            public String getName() {

                return "HashMapFactory";

            }

            @Override

            public Object create(Object... parameters) {

                return new HashMap();

            }

        };

        this.largeSetFactory = new Factory() {

            @Override

            public String getName() {

                return "HashSetFactory";

            }

            @Override

            public Object create(Object... parameters) {

                return new HashSet();

            }

        };

    }

    @Override

    public Register getStoreRegister() {

        return this.registers.store;

    }

    @Override

    public Register getStoreProviderRegister() {

        return this.registers.storeProvider;

    }

    @Override

    public Register getServerExplorerRegister() {

        return this.registers.serverExplorer;

    }

    @Override

    public Register getFeatureIndexRegister() {

        return this.registers.featureIndexProvider;

    }

    private String getStoreName(DataStoreParameters parameters) {

        for (DataFactory factory : this.getStoreRegister()) {

            DataStoreFactory_v2_4 storeFactory = (DataStoreFactory_v2_4) factory;

            if (storeFactory.canUse(parameters)) {

                return storeFactory.getName();

            }

        }

        return null;

    }

    /**

     * @deprecated

     */

    @Override

    public void registerDefaultRasterStore(Class rasterStoreClass) {

        // Metodo usado por el raster nuevo para regstrar su factoria de store

        this.getStoreRegister().register(new RasterStoreFactory(rasterStoreClass));

    }

    private boolean oldRasterRegistered = false;

    /**

     * @deprecated

     */

    @Override

    public void registerStoreFactory(String name, Class storeFactoryClass) {

        // Metodo usado por el raster viejo para registrar las factorias de sus stores

        this.getStoreRegister().register(new RasterStoreOldFactory(name, storeFactoryClass));

        this.oldRasterRegistered = true;

    }

    @Override

    public boolean isTheOldRasterRegistered() {

      return this.oldRasterRegistered;

    }

    /**

     * @param name

     * @param storeProviderClass

     * @param parametersClass

     * @deprecated use registerStoreProviderFactory

     */

    @Override

    public void registerStoreProvider(String name, Class storeProviderClass,

            Class parametersClass) {

        if (name == null || storeProviderClass == null || parametersClass == null) {

            throw new IllegalArgumentException("Any parameters can be null");

        }

        if (!DataStoreParameters.class.isAssignableFrom(parametersClass)) {

            throw new IllegalArgumentException(parametersClass.getName()

                    + " must implement org.gvsig.fmap.dal.DataStoreParameters");

        }

        if (CoverageStoreProvider.class.isAssignableFrom(storeProviderClass)) {

            // Envuelve al proveedor en una factoria por defecto.

            this.registerStoreProviderFactory(new DataStoreProviderToCoverageProviderFactoryWrapper(

                    name, "", storeProviderClass, parametersClass));

            return;

        }

        if (FeatureStoreProvider.class.isAssignableFrom(storeProviderClass)) {

            // Envuelve al proveedor en una factoria por defecto.

            this.registerStoreProviderFactory(new DataStoreProviderToFeatureStoreProviderFactoryWrapper(

                    name, "", storeProviderClass, parametersClass));

            return;

        }

        throw new IllegalArgumentException("Not supported implemtation: name="

                + name + " provider class=" + storeProviderClass.getName());

    }

    @Override

    public void registerExplorerProvider(String name, Class explorerClass, Class parametersClass) {

        if (name == null || explorerClass == null || parametersClass == null) {

            // FIXME Exception

            throw new IllegalArgumentException("Any parameters can be null");

        }

        if (!DataServerExplorerParameters.class

                .isAssignableFrom(parametersClass)) {

            // FIXME Exception

            throw new IllegalArgumentException(

                    parametersClass.getName()

                    + " must implement org.gvsig.fmap.dal.DataServerExplorerParameters");

        }

        if (!DataServerExplorer.class.isAssignableFrom(explorerClass)) {

            // FIXME Exception

            throw new IllegalArgumentException(explorerClass.getName()

                    + " must implement org.gvsig.fmap.dal.DataServerExplorer");

        }

        // Envuelve al proveedor en una factoria por defecto.

        this.registerServerExplorerFactory(

                new DataServerExplorerToDataExplorerFactoryWrapper(

                        name, "", explorerClass, parametersClass

                )

        );

    }

    @Override

    public void registerStoreFactory(DataStoreFactory_v2_4 factory) {

        this.getStoreRegister().register(factory);

    }

    @Override

    public void registerStoreProviderFactory(DataStoreProviderFactory factory) {

        this.getStoreProviderRegister().register(factory);

    }

    @Override

    public void registerServerExplorerFactory(DataServerExplorerFactory factory) {

        this.getServerExplorerRegister().register(factory);

    }

    @Override

    public DataStoreParameters createStoreParameters(byte[] data) {

        DataStoreParameters parameters = (DataStoreParameters) AbstractDataParameters.fromByteArray(data);

        return parameters;

    }

    public DataStoreParameters createStoreParameters(String providerName) throws InitializeException, ProviderNotRegisteredException {

      // Cuando desde python se llama a createStoreParameters con solo un argumento 

      // acaba entrando por aqui en lugar de por

      //   createStoreParameters(String providerName, Object... arguments)

      return this.createStoreParameters(providerName, (Object[]) null);

    }

    @Override

    public DataStoreParameters createStoreParameters(String providerName, Object... arguments) throws InitializeException, ProviderNotRegisteredException {

        if( providerName == null ) {

            String msg = "Provider name can't be null.";

            LOGGER.warn(msg);

            throw new IllegalArgumentException(msg);

        }

        if( arguments!=null && arguments.length>0 ) {

          if( arguments.length == 1 ) { 

              // Desde jython entra por este metodo en lugar de los especificos

              // de DataStoreParameters o DynObject

              if( arguments[0] instanceof DataStoreParameters ) {

                  return this.createStoreParameters(providerName, (DataStoreParameters)(arguments[0]));

              } else if( arguments[0] instanceof DynObject ) {

                  return this.createStoreParameters(providerName, (DynObject)(arguments[0]));

              }

          }

          if( (arguments.length % 2)!= 0 ) {

              throw new IllegalArgumentException("The number of arguments must be even.");

          }

        }

        if( providerName == null ) {

            String msg = "Provider name can't be null.";

            LOGGER.warn(msg);

            throw new IllegalArgumentException(msg);

        }

        DataFactory providerFactory = this.getStoreProviderRegister().getFactory(providerName);

        if( providerFactory == null ) {

            String msg = "Can't locate provider factory for '"+providerName+"'.";

            LOGGER.warn(msg);

            throw new IllegalArgumentException(msg);

        }

        DataStoreParameters parameters = (DataStoreParameters) providerFactory.createParameters();

        if( arguments!=null && arguments.length>0 ) {

          for( int i=0; i<arguments.length; i+=2 ) {

              String name = (String) arguments[i];

              if( name.endsWith("=") ) {

                  name = name.substring(0, name.length()-1);

              }

              Object value = arguments[i+1];

              parameters.setDynValue(name, value);

          }

        }

        return parameters;

    }

    @Override

    public NewDataStoreParameters createNewStoreParameters(String providerName) throws InitializeException, ProviderNotRegisteredException {

        String explorerName = this.getServerExplorerFromStore(providerName);

        return createNewStoreParameters(explorerName, providerName);

    }

    @Override

    public NewDataStoreParameters createNewStoreParameters(String explorerName, String providerName) throws InitializeException, ProviderNotRegisteredException {

        try {

            DataServerExplorer explorer = this.openServerExplorer(explorerName, (DataServerExplorerParameters)null);

            return explorer.getAddParameters(providerName);

        } catch (Exception ex) {

            throw new InitializeException(ex);

        }

    }

    @Override

    public DataServerExplorerParameters createServerExplorerParameters(String explorerName) throws InitializeException, ProviderNotRegisteredException {

        if( explorerName == null ) {

            String msg = "Explorer name can't be null.";

            LOGGER.warn(msg);

            throw new IllegalArgumentException(msg);

        }

        JsonObject parameters_json = null;

        DataFactory explorerFactory = this.getServerExplorerRegister().getFactory(explorerName);

        if( explorerFactory == null ) {           

            parameters_json = Json.createObject(explorerName);

            if( parameters_json==null || 

                    !parameters_json.containsKey(PROVIDER_PARAMTER_NAME) ) {

                String msg = "Can't locate server explorer factory for '"+explorerName+"'.";

                LOGGER.warn(msg);

                throw new IllegalArgumentException(msg);

            }

            explorerName = parameters_json.getString(PROVIDER_PARAMTER_NAME);

            explorerFactory = this.getServerExplorerRegister().getFactory(explorerName);

            if( explorerFactory == null ) {           

                String msg = "Can't locate server explorer factory for '"+explorerName+"'.";

                LOGGER.warn(msg);

                throw new IllegalArgumentException(msg);

            }

        }

        DataServerExplorerParameters params = (DataServerExplorerParameters) explorerFactory.createParameters();

        if( parameters_json!=null ) {

            Json.addAll(params, parameters_json);

        }

        return params;

    }

    @Override

    public DataStoreParameters createMemoryStoreParameters(String autoOrderAttributeName) throws InitializeException {

        try {

            DataStoreParameters parameters = createStoreParameters(MemoryStoreProvider.NAME);

            if (autoOrderAttributeName != null) {

                parameters.setDynValue(

                        MemoryStoreParameters.ORDER_PARAMETER_NAME,

                        autoOrderAttributeName);

            }

            return parameters;

        } catch (Exception ex) {

            throw new InitializeException(ex);

        }

    }

    @Override

    public DataServerExplorer openServerExplorer(String explorerName, DataServerExplorerParameters parameters) throws InitializeException, ProviderNotRegisteredException, ValidateDataParametersException {

        if( explorerName == null ) {

            String msg = "Explorer name can't be null.";

            LOGGER.warn(msg);

            throw new IllegalArgumentException(msg);

        }

        DataFactory explorerFactory = this.getServerExplorerRegister().getFactory(explorerName);

        if( explorerFactory == null ) {

            String msg = "Can't locate server explorer factory for '"+explorerName+"'.";

            LOGGER.warn(msg);

            throw new IllegalArgumentException(msg);

        }

        if (parameters == null) {

            parameters = (DataServerExplorerParameters) explorerFactory.createParameters();

        }

        DataServerExplorer explorer = (DataServerExplorer) explorerFactory.create(

                parameters,

                new DefaultDataServerExplorerProviderServices()

        );

        return explorer;

    }

    @Override

    public DataServerExplorer openServerExplorer(String explorerName, Object... arguments) throws InitializeException, ProviderNotRegisteredException, ValidateDataParametersException {

        if( arguments.length==1 && arguments[0] instanceof DataServerExplorerParameters ) {

            // Esto hace falta ya que desde scripting si se invoca a openServerExplorer con solo 

            // un parametro de tipo DataServerExplorerParameters llama ha este metodo en lugar de

            // llamar al que toca.

            return openServerExplorer(explorerName, (DataServerExplorerParameters)(arguments[0]));

        }

        if( explorerName == null ) {

            String msg = "Explorer name can't be null.";

            LOGGER.warn(msg);

            throw new IllegalArgumentException(msg);

        }

        if( (arguments.length % 2)!= 0 ) {

            throw new ValidateDataParametersException();

        }

        DataFactory explorerFactory = this.getServerExplorerRegister().getFactory(explorerName);

        DataServerExplorerParameters parameters = (DataServerExplorerParameters) explorerFactory.createParameters();

        for( int i=0; i<arguments.length; i+=2 ) {

            String name = (String) arguments[i];

            if( name.endsWith("=") ) {

                name = name.substring(0, name.length()-1);

            }

            Object value = arguments[i+1];

            parameters.setDynValue(name, value);

        }

        return this.openServerExplorer(explorerName, parameters);

    }

    /**

     * @param parameters

     * @return

     * @throws org.gvsig.fmap.dal.exception.InitializeException

     * @throws org.gvsig.fmap.dal.exception.ProviderNotRegisteredException

     * @throws org.gvsig.fmap.dal.exception.ValidateDataParametersException

     * @deprecated see openServerExplorer

     */

    @Override

    public DataServerExplorer createServerExplorer(

            DataServerExplorerParameters parameters) throws InitializeException,

            ProviderNotRegisteredException, ValidateDataParametersException {

        return openServerExplorer(parameters.getExplorerName(), parameters);

    }

    /**

     * @deprecated use openStore

     * @param parameters

     * @return

     * @throws InitializeException

     * @throws ProviderNotRegisteredException

     * @throws ValidateDataParametersException

     */

    @Override

    public DataStore createStore(DataStoreParameters parameters)

        throws InitializeException, ProviderNotRegisteredException,

        ValidateDataParametersException {

        return openStore(parameters.getDataStoreName(), parameters);

    }

    @Override

    public DataStore openStore(DataTransaction transaction, String providerName, DataStoreParameters parameters) throws InitializeException, ProviderNotRegisteredException, ValidateDataParametersException {

        return this.openStore(transaction, providerName, parameters, false);

    }

    @Override

    public DataStore openStore(String providerName, DataStoreParameters parameters) throws InitializeException, ProviderNotRegisteredException, ValidateDataParametersException {

        return this.openStore((DataTransaction)null, providerName, parameters, false);

    }

    @Override

    public DataStore openStore(String providerName, DataStoreParameters parameters, boolean ignoreDALResource) throws InitializeException, ProviderNotRegisteredException, ValidateDataParametersException {

        return this.openStore((DataTransaction)null, providerName, parameters, ignoreDALResource);

    }

    @Override

    public DataStore openStore(DataTransaction transaction, String providerName, DataStoreParameters parameters, boolean ignoreDALResource) throws InitializeException, ProviderNotRegisteredException, ValidateDataParametersException {

        if (providerName == null) {

            String msg = "Provider name can't be null.";

            LOGGER.warn(msg);

            throw new IllegalArgumentException(msg);

        }

        SimpleIdentityManager identityManager = ToolsLocator.getIdentityManager();

        if (!identityManager.getCurrentIdentity().isAuthorized(READ_STORE_AUTHORIZATION, parameters, providerName)) {

            throw new UnauthorizedException(READ_STORE_AUTHORIZATION, parameters, providerName);

        }

        parameters.validate();

        String storeName = this.getStoreName(parameters);

        if( StringUtils.isEmpty(storeName) ) {

            String msg = "Can't locate the store name from the parameters. parameters=" + parameters.toString();

            LOGGER.warn(msg);

            throw new IllegalArgumentException(msg);

        }

        DataStoreFactory_v2_4 storeFactory = (DataStoreFactory_v2_4) this.getStoreRegister().getFactory(storeName);

        if( storeFactory == null ) {

            String msg = "Can't locate store factory for '"+storeName+"'.";

            LOGGER.warn(msg);

            throw new IllegalArgumentException(msg);

        }

        DataFactory providerFactory = this.getStoreProviderRegister().getFactory(providerName);

        if( providerFactory == null ) {

            String msg = "Can't locate provider factory for '"+providerName+"'.";

            LOGGER.warn(msg);

            throw new IllegalArgumentException(msg);

        }

        DataStore store = (DataStore) storeFactory.create(parameters, this);

        if( store instanceof DefaultFeatureStore ) {

            ((DefaultFeatureStore)store).setIgnoreDALResource(ignoreDALResource);

            try {

                DataTransaction.add(transaction, (FeatureStore) store, false);

            } catch (Exception ex) {

                throw new InitializeException(store.getFullName(), ex);

            }

        }

        DataStoreProvider provider = (DataStoreProvider) providerFactory.create(parameters, store);

        if( provider == null ) {

            String msg = "Can't create provider for '"+providerName+"'.";

            LOGGER.trace(msg);

            throw new IllegalArgumentException(msg);

        }

        storeFactory.setProvider(store, provider);

        addObservers(store);

        if( store instanceof FeatureStoreProviderServices ) {

          ((FeatureStoreProviderServices) store).notifyChange(DataStoreNotification.AFTER_OPEN);

        }

        return store;

    }

    @Override

    public DataFactory getStoreFactory(DataStoreParameters parameters) {

        String storeName = this.getStoreName(parameters);

        if( StringUtils.isEmpty(storeName) ) {

            return null;

        }

        DataFactory storeFactory = this.getStoreRegister().getFactory(storeName);

        return storeFactory;

    }

    public void addObservers(DataStore store){

        for (Observer storeObserver : storeObservers) {

          if( storeObserver!=null) {

            store.addObserver(storeObserver);

          }

        }

    }

    @Override

    public DataStore openStore(DataStoreParameters parameters, DataStoreProvider provider) {

        String storeName = this.getStoreName(parameters);

        if( StringUtils.isEmpty(storeName) ) {

            String msg = "Can't locate the store name from the parameters. parameters=" + parameters.toString();

            LOGGER.warn(msg);

            throw new IllegalArgumentException(msg);

        }

        DataStoreFactory_v2_4 storeFactory = (DataStoreFactory_v2_4) this.getStoreRegister().getFactory(storeName);

        if( storeFactory == null ) {

            String msg = "Can't locate store factory for '"+storeName+"'.";

            LOGGER.warn(msg);

            throw new IllegalArgumentException(msg);

        }

        DataStore store = (DataStore) storeFactory.create(parameters, this);

        storeFactory.setProvider(store, provider);

        for (Observer storeObserver : storeObservers) {

          if( storeObserver!=null) {

            store.addObserver(storeObserver);

          }

        }

        if( store instanceof FeatureStoreProviderServices ) {

          ((FeatureStoreProviderServices) store).notifyChange(DataStoreNotification.AFTER_OPEN);

        }

        return store;

    }

    @Override

    public DataStore openStore(String provider, DynObject parameters) throws InitializeException, ProviderNotRegisteredException, ValidateDataParametersException {

        DataStoreParameters params = toDataStoreParameters(provider, parameters);

        DataStore store = openStore(params.getDataStoreName(), params);

        return store;

    }

    @Override

    public DataStore openStore(String providerName, Object... arguments) throws InitializeException, ProviderNotRegisteredException, ValidateDataParametersException {

        if( arguments.length == 1 ) { 

            // Desde jython entra por este metodo en lugar de los especificos

            // de DataStoreParameters o DynObject

            if( arguments[0] instanceof DataStoreParameters ) {

                return this.openStore(providerName, (DataStoreParameters)(arguments[0]));

            } else if( arguments[0] instanceof DynObject ) {

                return this.openStore(providerName, (DynObject)(arguments[0]));

            }

        }

        if( arguments.length == 2 &&  arguments[0] instanceof DataStoreParameters && arguments[1] instanceof Boolean) { 

            return this.openStore(providerName, (DataStoreParameters)(arguments[0]), (boolean)(arguments[1]));

        }

        if( (arguments.length % 2)!= 0 ) {

            throw new ValidateDataParametersException();

        }

        if( providerName == null ) {

            String msg = "Provider name can't be null.";

            LOGGER.warn(msg);

            throw new IllegalArgumentException(msg);

        }

        DataFactory providerFactory = this.getStoreProviderRegister().getFactory(providerName);

        DataStoreParameters parameters = (DataStoreParameters) providerFactory.createParameters();

        for( int i=0; i<arguments.length; i+=2 ) {

            String name = (String) arguments[i];

            if( name.endsWith("=") ) {

                name = name.substring(0, name.length()-1);

            }

            Object value = arguments[i+1];

            parameters.setDynValue(name, value);

        }

        return this.openStore(providerName, parameters);

    }

    @Override

    public FeatureStore createMemoryStore(String autoOrderAttributeName) throws InitializeException {

        try {

            DataStoreParameters parameters = createMemoryStoreParameters(autoOrderAttributeName);

            DataStore store = openStore(MemoryStoreProvider.NAME, parameters);

            return (FeatureStore) store;

        } catch (Exception ex) {

            throw new InitializeException(ex);

        }

    }

    @Override

    public DataStoreProviderFactory getStoreProviderFactory(String providerName) {

        if( providerName == null ) {

            String msg = "Provider name can't be null.";

            LOGGER.warn(msg);

            throw new IllegalArgumentException(msg);

        }

        DataFactory providerFactory = this.getStoreProviderRegister().getFactory(providerName);

        return (DataStoreProviderFactory) providerFactory;

    }

    @Override

    public List<String> getStoreProviders() {

        return this.getStoreProviderRegister().getFactoryNames();

    }

    @Override

    public List<String> getStoreProviders(String explorerName) {

        if( explorerName == null ) {

            String msg = "Explorer name can't be null.";

            LOGGER.warn(msg);

            throw new IllegalArgumentException(msg);

        }

        try {

            DataServerExplorer explorer = openServerExplorer(explorerName, (DataServerExplorerParameters)null);

            List names = explorer.getDataStoreProviderNames();

            return names;

        } catch (Exception ex) {

            throw new RuntimeException("Can't get stores availables for explorer '" + explorerName + "'.", ex);

        }

    }

    @Override

    public List<String> getExplorerProviders() {

        List<String> names = this.getServerExplorerRegister().getFactoryNames();

        return names;

    }

    @Override

    public DataStoreProvider createProvider(DataStoreProviderServices providerServices, DataStoreParameters parameters) throws InitializeException, ProviderNotRegisteredException {

        String providerName = parameters.getDataStoreName();

        DataFactory providerFactory = this.getStoreProviderRegister().getFactory(providerName);

        if (providerFactory == null) {

            throw new ProviderNotRegisteredException(providerName);

        }

        while (true) {

            try {

                DataStoreProvider provider = (DataStoreProvider) providerFactory.create(

                        parameters, providerServices

                );

                return provider;

            } catch (Exception e) {

                if (openErrorHandler == null) {

                    throw new InitializeException(providerName, e);

                }

                boolean retry = openErrorHandler.canRetryOpen(e, parameters);

                if (!retry) {

                    throw new InitializeException(providerName, e);

                }

            }

        }

    }

    @Override

    public List<String> getFeatureIndexProviders() {

        List<String> names = this.getFeatureIndexRegister().getFactoryNames();

        return names;

    }

    @Override

    public void setDefaultFeatureIndexProviderName(int dataType, String name) {

        this.defaultDataIndexProviders.put(dataType, name);

    }

    @Override

    public String getDefaultFeatureIndexProviderName(int dataType) {

        return this.defaultDataIndexProviders.get(dataType);

    }

    @Override

    public FeatureIndexProviderServices createFeatureIndexProvider(

            String name,

            FeatureStore store,

            FeatureType type,

            String indexName,

            FeatureAttributeDescriptor attr

    ) throws InitializeException, ProviderNotRegisteredException {

        if (name == null) {

            name = getDefaultFeatureIndexProviderName(attr.getType());

        }

        if (name == null) {

            throw new InitializeException(

                    "There not any index provider registered.", null);

        }

        DataFactory indexfactory = this.getFeatureIndexRegister().getFactory(name);

        if (indexfactory == null) {

            throw new InitializeException(

                    "There not any index provider registered with name '" + name + "'.", null);

        }

        FeatureIndexProvider provider = (FeatureIndexProvider) indexfactory.create(null, null);

        FeatureIndexProviderServices services = new DefaultFeatureIndex(

                (FeatureStoreProviderServices) store,

                type,

                provider,

                attr.getName(),

                indexName

        );

        services.initialize();

        return services;

    }

    @Override

    public String getTemporaryDirectory() {

        FoldersManager manager = ToolsLocator.getFoldersManager();

        File folder = manager.getUniqueTemporaryFile("_daltmp_");

        return folder.getAbsolutePath();

    }

    @Override

    public DataStoreParameters createStoreParameters(DynStruct struct) throws InitializeException, ProviderNotRegisteredException {

        if (!(struct instanceof DynStruct_v2)) {

            throw new IllegalArgumentException("A DynStruct_v2 is required.");

        }

        Tags tags = ((DynStruct_v2) struct).getTags();

        return this.createStoreParameters(tags);

    }

    @Override

    public DataStoreParameters createStoreParameters(Tags tags) throws InitializeException, ProviderNotRegisteredException {

        String providerName = (String) tags.get(TAG_DAL_OPENSTORE + "provider");

        if (providerName == null) {

            throw new IllegalArgumentException("Tag DAL.OpenStore.provider is missing in struct.");

        }

        int prefixlen = TAG_DAL_OPENSTORE.length();

        DataStoreParameters parameters = this.createStoreParameters(providerName);

        for (String key : tags) {

            if (key.startsWith(TAG_DAL_OPENSTORE)) {

                parameters.setDynValue(key.substring(prefixlen), tags.get(key));

            }

        }

        return parameters;

    }

    @Override

    public DataStore openStore(DynStruct struct) throws InitializeException, ProviderNotRegisteredException, ValidateDataParametersException {

        DataStoreParameters paramters = this.createStoreParameters(struct);

        DataStore store = this.openStore(paramters.getDataStoreName(), paramters);

        return store;

    }

    @Override

    public void newStore(String providerName, NewDataStoreParameters parameters, boolean overwrite) throws InitializeException, ProviderNotRegisteredException, ValidateDataParametersException {

        String explorerName = this.getServerExplorerFromStore(providerName);

        newStore(explorerName, providerName, parameters, overwrite);

    }

    @Override

    public void newStore(String explorerName, String providerName, NewDataStoreParameters parameters, boolean overwrite) throws InitializeException, ProviderNotRegisteredException, ValidateDataParametersException {

        if( explorerName == null ) {

            String msg = "Explorer name can't be null.";

            LOGGER.warn(msg);

            throw new IllegalArgumentException(msg);

        }

        if( providerName == null ) {

            String msg = "Provider name can't be null.";

            LOGGER.warn(msg);

            throw new IllegalArgumentException(msg);

        }

        SimpleIdentityManager identityManager = ToolsLocator.getIdentityManager();

        if (!identityManager.getCurrentIdentity().isAuthorized(CREATE_STORE_AUTHORIZATION, parameters, providerName)) {

            throw new UnauthorizedException(CREATE_STORE_AUTHORIZATION, parameters, providerName);

        }

        parameters.validate();

        try {

            DataServerExplorerParameters explorerParameters = this.createServerExplorerParameters(explorerName);

            DataServerExplorer server = this.openServerExplorer(explorerName, explorerParameters);

            server.add(providerName, parameters, overwrite);

        } catch (Exception e) {

            throw new InitializeException(e);

        }

    }

    @Override

    @Deprecated

    public Evaluator createExpresion(String expression) throws InitializeException {

        Expression exp = ExpressionEvaluatorLocator.getManager().createExpression();

        exp.setPhrase(expression);

        return this.createExpresion(exp);

    }

    @Override

    @Deprecated

    public Evaluator createExpresion(Expression expression) throws InitializeException {

        DefaultFeatureExpressionEvaluator exp = new DefaultFeatureExpressionEvaluator(expression);

        return exp;        

    }

    @Override

    public Evaluator createFilter(String expression) throws InitializeException {

        Expression exp = ExpressionEvaluatorLocator.getManager().createExpression();

        exp.setPhrase(expression);

        return this.createFilter(exp);

    }

    @Override

    public Evaluator createFilter(Expression expression) throws InitializeException {

        DefaultFeatureExpressionEvaluator exp = new DefaultFeatureExpressionEvaluator(expression);

        return exp;        

    }

    @Override

    public FeaturePagingHelper createFeaturePagingHelper(

            FeatureStore featureStore, int pageSize) throws BaseException {

        return new FeaturePagingHelperImpl(featureStore, pageSize);

    }

    @Override

    public FeaturePagingHelper createFeaturePagingHelper(

            FeatureStore featureStore, FeatureQuery featureQuery, int pageSize)

            throws BaseException {

        return new FeaturePagingHelperImpl(featureStore, featureQuery, pageSize);

    }

    @Override

    public void setOpenErrorHandler(OpenErrorHandler handler) {

        openErrorHandler = handler;

    }

    @Override

    public OpenErrorHandler getOpenErrorHandler() {

        return this.openErrorHandler;

    }

    @Override

    public EditableFeatureType createFeatureType() {

        return new DefaultEditableFeatureType(null);

    }

    @Override

    public EditableFeatureType createFeatureType(JsonObject json) {

        EditableFeatureType featureType = this.createFeatureType();

        featureType.fromJson(json);

        return featureType;

    }

    @Override

    public DataServerExplorerPool getDataServerExplorerPool() {

        if (this.dataServerExplorerPool == null) {

            this.dataServerExplorerPool = new DataServerExplorerPoolImpl();

        }

        return this.dataServerExplorerPool;

    }

    @Override

    public void setDataServerExplorerPool(DataServerExplorerPool pool) {

        this.dataServerExplorerPool = pool;

    }

    public DataStoreParameters toDataStoreParameters(String provider, DynObject params) throws InitializeException, ProviderNotRegisteredException {

        if (params instanceof DataStoreParameters) {

            return (DataStoreParameters) params;

        }

        String providerName;

        try {

            providerName = (String) params.getDynValue(DataStoreProviderServices.PROVIDER_PARAMTER_NAME);

        } catch (Exception ex) {

            providerName = provider;

        }

        DataStoreParameters parameters = this.createStoreParameters(providerName);

        ToolsLocator.getDynObjectManager().copy(params, parameters);

        return parameters;

    }

    @Override

    public List<DataType> getDataTypes() {

        if (dataTypes == null) {

            DataTypesManager manager = ToolsLocator.getDataTypesManager();

            dataTypes = new ArrayList<>();

            dataTypes.add(manager.get(DataTypes.STRING));

            dataTypes.add(manager.get(DataTypes.BOOLEAN));

            dataTypes.add(manager.get(DataTypes.INT));

            dataTypes.add(manager.get(DataTypes.DOUBLE));

            dataTypes.add(manager.get(DataTypes.DATE));

            dataTypes.add(manager.get(DataTypes.GEOMETRY));

        }

        return dataTypes;

    }

    @Override

    public void setResourcesLoader(ClassLoader loader) {

        this.resourcesLoader = loader;

    }

    @Override

    public void setResourcesLoader(File folder) {

        if (folder == null) {

            this.resourcesLoader = null;

            return;

        }

        try {

            URL[] urls = new URL[]{folder.toURI().toURL()};

            this.resourcesLoader = new URLClassLoader(urls);

        } catch (Exception ex) {

            throw new IllegalArgumentException("Can't create a ClassLoader from '" + folder.toString() + "'.", ex);

        }

    }

    @Override

    public URL getResource(Object reourceLoader, String name) {

        URL x;

        if (this.resourcesLoader != null) {

            x = this.resourcesLoader.getResource(name);

            if (x != null) {

                return x;

            }

        }

        x = reourceLoader.getClass().getResource(name);

        return x;

    }

    @Override

    public InputStream getResourceAsStream(Object reourceLoader, String name) {

        InputStream x;

        if (this.resourcesLoader != null) {

            x = this.resourcesLoader.getResourceAsStream(name);

            if (x != null) {

                return x;

            }

        }

        x = reourceLoader.getClass().getResourceAsStream(name);

        return x;

    }

    @Override

    public ExpressionBuilder createExpressionBuilder() {

        return ExpressionEvaluatorLocator.getManager().createExpressionBuilder();

    }

    public void registerFeatureCacheProvider(

        FeatureCacheProviderFactory providerFactory) {

        ToolsLocator.getExtensionPointManager()

            .add(DATA_MANAGER_CACHE, DATA_MANAGER_CACHE_DESCRIPTION)

            .append(providerFactory.getName(), "", providerFactory);

    }

    public FeatureCacheProvider createFeatureCacheProvider(String name,

        DynObject parameters) throws DataException {

        if (name == null) {

            throw new InitializeException(

                "It is necessary to provide a cache name", null);

        }

        if (parameters == null) {

            throw new InitializeException(

                "It is necessary to provide parameters to create the explorer",

                null);

        }

        FeatureCacheProviderFactory featureCacheProviderFactory;

        try {

            featureCacheProviderFactory =

                (FeatureCacheProviderFactory) ToolsLocator

                    .getExtensionPointManager().get(DATA_MANAGER_CACHE)

                    .create(name);

            if (featureCacheProviderFactory == null) {

                throw new ProviderNotRegisteredException(name);

            }

            return featureCacheProviderFactory.createCacheProvider(parameters);

        } catch (Exception e) {

            throw new InitializeException(e);

        }

    }

    @Override

    public List getFeatureCacheProviders() {

        ExtensionPoint extensionPoint =

            ToolsLocator.getExtensionPointManager().get(DATA_MANAGER_CACHE);

        if (extensionPoint != null) {

            return ToolsLocator.getExtensionPointManager()

                .get(DATA_MANAGER_CACHE).getNames();

        } else {

            return new ArrayList();

        }

    }

    @Override

    public DynObject createCacheParameters(String name)

        throws InitializeException, ProviderNotRegisteredException {

        if (name == null) {

            throw new InitializeException(

                "It is necessary to provide a cache name", null);

        }

        FeatureCacheProviderFactory featureCacheProviderFactory;

        try {

            featureCacheProviderFactory =

                (FeatureCacheProviderFactory) ToolsLocator

                    .getExtensionPointManager().get(DATA_MANAGER_CACHE)

                    .create(name);

            if (featureCacheProviderFactory == null) {

                throw new ProviderNotRegisteredException(name);

            }

            return featureCacheProviderFactory.createParameters();

        } catch (Exception e) {

            throw new InitializeException(e);

        }

    }

    @Override

    public void createFileStore(String providerName, NewDataStoreParameters params, boolean overwrite) throws DataException {

        DataManagerProviderServices dataManager = DALSPILocator.getDataManagerProviderServices();

        DataServerExplorerParameters eparams = null;

        DataServerExplorer serverExplorer;

        try {

            serverExplorer = dataManager.openServerExplorer(FILESYSTEM_EXPLORER_NAME, eparams);

        } catch (ValidateDataParametersException | InitializeException | ProviderNotRegisteredException e) {

            throw new OpenException(FILESYSTEM_EXPLORER_NAME, e);

        }

        try {

            serverExplorer.add(providerName, params, overwrite);

        } catch (DataException e) {

            throw new CreateFileStoreException(e, providerName);

        }

    }

    @Override

    public FeatureSymbolTable createFeatureSymbolTable() {

        FeatureSymbolTable symbolTable = new FeatureSymbolTableImpl();

        return symbolTable;

    }

    @Override

    public FeatureSymbolTable createFeatureSymbolTable(String name) {

        FeatureSymbolTable symbolTable = new FeatureSymbolTableImpl(name);

        return symbolTable;

    }

    @Override

    public FeatureAttributeEmulatorExpression createFeatureAttributeEmulatorExpression(FeatureType type, Expression expression) {

        FeatureAttributeEmulatorExpression emulator = new DefaultFeatureAttributeEmulatorExpression(type, expression);

        return emulator;

    }

    @Override

    public void registerDataProfile(DataProfile profile) {

        if( profile==null ) {

            return;

        }

        if( this.dataProfiles==null ) {

            this.dataProfiles = new HashMap<>();

        }

        this.dataProfiles.put(profile.getID().toLowerCase(), profile);

    }

    @Override

    public List<DataProfile> getDataProfiles() {

        if( this.dataProfiles==null ) {

            return null;

        }

        return Collections.unmodifiableList(new ArrayList<>(this.dataProfiles.values()));

    }

    @Override

    public DataProfile getDataProfile(String name) {

        if( StringUtils.isBlank(name) ) {

            return null;

        }

        if(this.dataProfiles == null){

            return null;

        }

        return this.dataProfiles.get(name.toLowerCase());

    }

    private StoresRepository storesRepository;

    @Override

    public StoresRepository getStoresRepository() {

        if( this.storesRepository==null ) {

            this.storesRepository = new BaseStoresRepository("DAL");

        }

        return this.storesRepository;

    }

    @Override

    public DatabaseWorkspaceManager createDatabaseWorkspaceManager(DataServerExplorerParameters connection) {

        DatabaseWorkspaceManager workspace = new DefaultDatabaseWorkspaceManager(connection);

        return workspace;

    }

    @Override

    public void removeDatabaseWorkspace(DatabaseWorkspaceManager databaseWorkspace) {

        this.databaseWorkspaces.remove(databaseWorkspace.getId(),databaseWorkspace);