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

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 DatabaseWorkspaceManager workspace;

    private Map<String,DataStoreParameters> repository;

    public static final int FLAG_CHANGE_PORT_HOST = 1;

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

        super(name, label);

        this.workspace = workspace;

        this.repository = null;

    }

    private void evaluateExpressionsInFiles(DataStoreParameters parameters) {

        DynClass dynClass = parameters.getDynClass();

        if( dynClass == null ) {

            return;

        }

        File theBaseFolder = this.workspace.getBaseFolder();

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

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

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

            try {

                Object host = storeParameters.getDynValue("host");

                Object port = storeParameters.getDynValue("port");

                params.setDynValue("host", host);

                params.setDynValue("port", port);

            } catch (Exception ex) {

                throw new RuntimeException("Unable to set host and port 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());

    }

}