Application: gvSIG desktop

package org.gvsig.fmap.dal.impl;

import java.io.File;

import org.gvsig.fmap.dal.DatabaseWorkspaceManager;

import java.util.HashMap;

import java.util.Map;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.AbstractStoresRepository;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataTypes;

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

import org.gvsig.fmap.dal.StoresRepository;

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 org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.util.UnmodifiableBasicSet;

import org.gvsig.tools.util.UnmodifiableBasicSetAdapter;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

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

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.util.Bitmask;

import org.gvsig.tools.util.HasAFile;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class DatabaseWorkspaceStoresRepository 

        extends AbstractStoresRepository

        implements StoresRepository 

    {

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

    private final DefaultDatabaseWorkspaceManager workspace;

    private Map<String,DataStoreParameters> repository;

    public static final int BIT_CHANGE_PORT_HOST = 0;

    public static final int BIT_CHANGE_USER = 1;

    public static final int BIT_CHANGE_DBNAME_CATALOG_SCHEMA = 2;

    /* Copied from DBParameters */

    private static final String HOST_PARAMTER_NAME = "host";

    private static final String PORT_PARAMTER_NAME = "port";

    private static final String DBNAME_PARAMTER_NAME = "dbname";

    private static final String USER_PARAMTER_NAME = "dbuser";

    private static final String PASSWORD_PARAMTER_NAME = "password";

    private static final String URL_PARAMTER_NAME = "url";

    /* Copied from JDBCConnectionParameters */

    private static final String CATALOG_PARAMTER_NAME = "catalog";

    private static final String SCHEMA_PARAMTER_NAME = "schema";

    public DatabaseWorkspaceStoresRepository(String name, String label, DatabaseWorkspaceManager workspace) {

        super(name, label);

        this.workspace = (DefaultDatabaseWorkspaceManager) workspace;

        this.repository = null;

        this.setServerParameters(this.workspace.getServerExplorerParameters());

    }

    private void evaluateExpressionsInFiles(DataStoreParameters parameters) {

        DynClass dynClass = parameters.getDynClass();

        if( dynClass == null ) {

            return;

        }

        File theBaseFolder = this.workspace.getBaseFolder();

        File theWorkspaceFile = this.workspace.getWorkspaceFile();

        if( theBaseFolder==null && theWorkspaceFile==null ) {

            return;

        }

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

            switch(dynField.getType()) {

                case DataTypes.FILE:

                case DataTypes.FOLDER:

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

                    if( ExpressionUtils.isDynamicFilename(f) ) {

                        parameters.setDynValue(dynField.getName(), ExpressionUtils.evaluateFilename(this.workspace, f));

                    }

                    break;

            }

        }

        try {

            if (parameters instanceof HasAFile) {

                HasAFile params = (HasAFile) parameters;

                params.setFile(ExpressionUtils.evaluateFilename(params.getFile()));

            }

            parameters.validate();

        } catch (ValidateDataParametersException ex) {

            LOGGER.warn("Not been able to validate parameters", ex);

        }

    }

    private void load() {

        FeatureStore store = null;

        try {

            this.repository = new HashMap<>();

            final DataManager dataManager = DALLocator.getDataManager();

            store = this.workspace.getTable(DatabaseWorkspaceManager.TABLE_REPOSITORY);

            if(store == null) {

                return;

            }

            DataStoreParameters storeParameters = store.getParameters();

            store.accept(new Visitor() {

                @Override

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

                    Feature f = (Feature) obj;

                    String name = f.getString(FIELD_REPOSITORY_NAME);

                    byte[] data = f.getByteArray(FIELD_REPOSITORY_PARAMETERS);

                    // Compatibilidad con antiguos repositorios sin falgs

                    int flags = 0;

                    if (f.getType().getAttributeDescriptor(FIELD_REPOSITORY_FLAGS)!=null) {

                        flags = f.getInt(FIELD_REPOSITORY_FLAGS);

                    }

                    DataStoreParameters params = dataManager.createStoreParameters(data);

                    if( params==null ) {

                        LOGGER.warn("Can't restore parameters from repository entry '"+name+"'.");

                        return;

                    }

                    processParameters(params, storeParameters, Bitmask.createBitmask(flags));

                    evaluateExpressionsInFiles(params);

                    repository.put(name, params);

                }

            });

        } catch (Exception ex) {

            if(store == null) {

                LOGGER.warn("Can't open repository information");

                LOGGER.debug("Can't open repository information", ex);

            } else {

                LOGGER.warn("Can't load repository information", ex);

            }

        } finally {

            DisposeUtils.disposeQuietly(store);

        }

    }

    private void processParameters(DataStoreParameters params, DataStoreParameters storeParameters, Bitmask mask) {

        if (mask.isEmpty()) {

            return;

        }

        if (mask.isSetBit(BIT_CHANGE_PORT_HOST)) {

            try {

                Object host = storeParameters.getDynValue(HOST_PARAMTER_NAME);

                Object port = storeParameters.getDynValue(PORT_PARAMTER_NAME);

                params.setDynValue(HOST_PARAMTER_NAME, host);

                params.setDynValue(PORT_PARAMTER_NAME, port);

                params.setDynValue(URL_PARAMTER_NAME, null);

            } catch (Exception ex) {

                throw new RuntimeException("Unable to set host and port from actual connection", ex);

            }

        }

        if (mask.isSetBit(BIT_CHANGE_USER)) {

            try {

                Object dbuser = storeParameters.getDynValue(USER_PARAMTER_NAME);

                Object password = storeParameters.getDynValue(PASSWORD_PARAMTER_NAME);

                params.setDynValue(USER_PARAMTER_NAME, dbuser);

                params.setDynValue(PASSWORD_PARAMTER_NAME, password);

            } catch (Exception ex) {

                throw new RuntimeException("Unable to set user and passwrod from actual connection", ex);

            }

        }

        if (mask.isSetBit(BIT_CHANGE_DBNAME_CATALOG_SCHEMA)) {

            try {

                Object dbname = storeParameters.getDynValue(DBNAME_PARAMTER_NAME);

                Object catalog = storeParameters.getDynValue(CATALOG_PARAMTER_NAME);

                Object schema = storeParameters.getDynValue(SCHEMA_PARAMTER_NAME);

                params.setDynValue(DBNAME_PARAMTER_NAME, dbname);

                params.setDynValue(CATALOG_PARAMTER_NAME, catalog);

                params.setDynValue(SCHEMA_PARAMTER_NAME, schema);

                params.setDynValue(URL_PARAMTER_NAME, null);

            } catch (Exception ex) {

                throw new RuntimeException("Unable to set dbname and catalog, schema from actual connection", ex);

            }

        }

    }

    @Override

    protected DataStoreParameters getMyParameters(String name) {

        if( this.repository==null ) {

            this.load();

        }

        DataStoreParameters params = this.repository.get(name);

        if (params!=null) {

            return params;

        }

        for (String key : this.repository.keySet()) {

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

                return this.repository.get(key);

            }

        }

        return null;

    }

    @Override

    protected boolean isEmptyMyRepository() {

        if( this.repository==null ) {

            this.load();

        }

        return this.repository.isEmpty();

    }

    @Override

    protected int getMySize() {

        if( this.repository==null ) {

            this.load();

        }

        return this.repository.size();

    }

    @Override

    protected UnmodifiableBasicSet<String> getMyKeySet() {

        if( this.repository==null ) {

            this.load();

        }

        return new UnmodifiableBasicSetAdapter<>(this.repository.keySet());

    }

}