gvSIG projects pool

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright (c) 2007-2015 gvSIG Association

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.vcsgis.lib;

import java.io.File;

import java.net.URL;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

import org.gvsig.fmap.dal.store.jdbc.JDBCNewStoreParameters;

import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorerParameters;

import org.gvsig.fmap.dal.store.jdbc.JDBCStoreParameters;

import org.gvsig.fmap.dal.store.jdbc2.JDBCServerExplorer;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.util.HasAFile;

import org.gvsig.tools.util.ListBuilder;

import org.gvsig.vcsgis.lib.repository.VCSGisRepository;

import org.gvsig.vcsgis.lib.repository.localdb.VCSGisRepositoryLocaldb;

import org.gvsig.vcsgis.lib.repository.localdb.tables.DataRepoTable;

import org.gvsig.vcsgis.lib.repository.localdb.tables.EntitiesRepoTable;

import org.gvsig.vcsgis.lib.repository.localdb.tables.HooksRepoTable;

import org.gvsig.vcsgis.lib.repository.localdb.tables.RevisionsRepoTable;

import org.gvsig.vcsgis.lib.repository.localdb.tables.ConfigRepoTable;

import org.gvsig.vcsgis.lib.repository.localdb.tables.TopologyplanRepoTable;

import org.gvsig.vcsgis.lib.repository.localdb.tables.UsersRepoTable;

import org.gvsig.vcsgis.lib.repository.remoteclient.VCSGisRepositoryClient;

import org.gvsig.vcsgis.lib.server.VCSGisServerController;

import org.gvsig.vcsgis.lib.server.VCSGisServerControllerImpl;

import org.gvsig.vcsgis.lib.workspace.StoreProperties;

import org.gvsig.vcsgis.lib.workspace.VCSGisWorkspace;

import org.gvsig.vcsgis.lib.workspace.VCSGisWorkspaceDescriptor;

import org.gvsig.vcsgis.lib.workspace.VCSGisWorkspaceDescriptorImpl;

import org.gvsig.vcsgis.lib.workspace.VCSGisWorkspaceImpl;

import org.gvsig.vcsgis.lib.workspace.tables.EntitiesTable;

import org.gvsig.vcsgis.lib.workspace.tables.EntitiesTable.EntityRow;

import org.gvsig.vcsgis.lib.workspace.tables.LocalRevisionsTable;

import org.gvsig.vcsgis.lib.workspace.tables.RemoteChangesTable;

import org.gvsig.vcsgis.lib.workspace.tables.TopologyplanTable;

import org.gvsig.vcsgis.lib.workspace.tables.UsersTable;

import org.gvsig.vcsgis.lib.workspace.tables.VarsTable;

import org.gvsig.vcsgis.lib.workspace.tables.WorkspaceChangesTable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * @author gvSIG Team

 *

 */

@SuppressWarnings("UseSpecificCatch")

public class VCSGisManagerImpl implements VCSGisManager {

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

    public static final List<String> INTERNAL_WORKSPACE_TABLES = ListBuilder.create(

            EntitiesTable.TABLE_NAME,

            LocalRevisionsTable.TABLE_NAME,

            RemoteChangesTable.TABLE_NAME,

            VarsTable.TABLE_NAME,

            WorkspaceChangesTable.TABLE_NAME,

            UsersTable.TABLE_NAME,

            TopologyplanTable.TABLE_NAME,

            TABLE_RESOURCES_NAME,

            TABLE_CONFIGURATION_NAME

    );

    public static final List<String> INTERNAL_REPOSITORY_TABLES = ListBuilder.create(DataRepoTable.TABLE_NAME, 

            EntitiesRepoTable.TABLE_NAME,

            HooksRepoTable.TABLE_NAME,

            RevisionsRepoTable.TABLE_NAME,

            ConfigRepoTable.TABLE_NAME,

            TopologyplanRepoTable.TABLE_NAME,

            UsersRepoTable.TABLE_NAME,

            TABLE_RESOURCES_NAME,

            TABLE_CONFIGURATION_NAME

    );

    private Map<String,VCSGisWorkspaceDescriptor> workspaces;

    private VCSGisCodeGenerator codeGenerator;

    private VCSGisUserIdentificationRequester userIdentificationRequester;

    public VCSGisManagerImpl() {

        this.workspaces = new HashMap<>();

        this.codeGenerator = new RandomCodeGenerator();

        this.userIdentificationRequester = null;

    }

    @Override

    public Map<String, VCSGisWorkspaceDescriptor> getWorkspaces() {

        return Collections.unmodifiableMap(this.workspaces);

    }

    @Override

    public void restoreWorkspaces(Map<String, VCSGisWorkspaceDescriptor> descriptors) {

        this.workspaces = new HashMap<>();

        if( descriptors != null ) {

            this.workspaces.putAll(descriptors);

        }

    }

    @Override

    public int initWorkspace(File wsfile, VCSGisRepository repo, String label, SimpleTaskStatus status) {

        int err = ERR_NO_ERROR;

        if (wsfile == null) {

            return ERR_DBFILE_IS_NULL;

        }

        if (status == null) {

            status = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus("vcsgis init_workspace");

            status.add();

        }

        status.push();

        DataManager dataManager = DALLocator.getDataManager();

        try {

            wsfile = removeH2FileExtension(wsfile);

            if (StringUtils.isBlank(label)) {

                label = wsfile.getName();

            }

            err = ERR_CANT_OPEN_WORKSPACE_SERVEREXPLORER;

            JDBCServerExplorerParameters explorerParams = (JDBCServerExplorerParameters) dataManager.createServerExplorerParameters(DataStore.H2SPATIAL_PROVIDER_NAME);

            ((HasAFile) explorerParams).setFile(wsfile);

            JDBCServerExplorer explorer = (JDBCServerExplorer) dataManager.openServerExplorer(

                    explorerParams.getProviderName(),

                    explorerParams

            );

            return this.initWorkspace(explorer, repo, label, status);

        } catch (Exception ex) {

            status.abort();

            LOGGER.warn("Can't init workspace in '" + wsfile.getAbsolutePath() + "'.", ex);

            status.message(ex.getMessage());

            return err;

        } finally {

            status.pop();

        }

    }

    @Override

    public int initWorkspace(JDBCServerExplorer wsexplorer, VCSGisRepository repository, String label, SimpleTaskStatus status) {

        int err = ERR_NO_ERROR;

        if (wsexplorer == null) {

            return ERR_WSEXPLORER_IS_NULL;

        }

        if (StringUtils.isBlank(label)) {

            return ERR_LABEL_IS_NULL;

        }

        if (status == null) {

            status = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus("vcsgis init_workspace");

            status.add();

        }

        status.push();

        DataManager dataManager = DALLocator.getDataManager();

        try {

            status.setTitle("vcsgis init_workspace");

            FeatureType[] tables = new FeatureType[]{

                VarsTable.featureType(),

                EntitiesTable.featureType(),

                WorkspaceChangesTable.featureType(),

                RemoteChangesTable.featureType(),

                LocalRevisionsTable.featureType(),

                UsersTable.featureType(),

                TopologyplanTable.featureType()

            };

            status.setRangeOfValues(0, tables.length);

            int step = 1;

            for (FeatureType table : tables) {

                status.message(table.getLabel());

                status.setCurValue(step++);

                err = ERR_CANT_CREATE_TABLE + step;

                JDBCNewStoreParameters table_params = wsexplorer.getAddParameters();

                table_params.setDefaultFeatureType(table.getEditable());

                table_params.setTable(table.getTags().getString("ID"));

                wsexplorer.add(wsexplorer.getProviderName(), table_params, false);

            }

            try {

                wsexplorer.execute(VCSGisUtils.getSqlTemplate(wsexplorer.getProviderName(), "createWorkspaceIndex1"));

                wsexplorer.execute(VCSGisUtils.getSqlTemplate(wsexplorer.getProviderName(), "createWorkspaceIndex2"));

                wsexplorer.execute(VCSGisUtils.getSqlTemplate(wsexplorer.getProviderName(), "createWorkspaceIndex3"));

            } catch (Exception ex) {

                LOGGER.warn("Can't create index in workspace", ex);

            }

            status.setTitle("vcsgis retrieving entities");

            VCSGisWorkspaceImpl workspace = new VCSGisWorkspaceImpl(wsexplorer, this.codeGenerator, repository, label);

            workspace.initialize();

            this.registerWorkspace(workspace);

            status.terminate();

            return ERR_NO_ERROR;

        } catch (Exception ex) {

            status.abort();

            LOGGER.warn("Can't init workspace in '" + getMessageLabel(wsexplorer) + "'.", ex);

            status.message(ex.getMessage());

            return err;

        } finally {

            status.pop();

        }

    }

    private String getMessageLabel(JDBCServerExplorer explorer) {

        return explorer.getParameters().getUrl();

    }

    @Override

    public VCSGisWorkspace openWorkspace(File wsfile) {

        if (wsfile == null) {

            return null;

        }

        try {

            DataManager dataManager = DALLocator.getDataManager();

            JDBCServerExplorerParameters explorerParams = (JDBCServerExplorerParameters) dataManager.createServerExplorerParameters(DataStore.H2SPATIAL_PROVIDER_NAME);

            ((HasAFile) explorerParams).setFile(wsfile);

            JDBCServerExplorer explorer = (JDBCServerExplorer) dataManager.openServerExplorer(

                    explorerParams.getProviderName(),

                    explorerParams

            );

            VCSGisWorkspace workspace = openWorkspace(explorer);

            return workspace;

        } catch (Exception ex) {

            return null;

        }

    }

    @Override

    public VCSGisWorkspace openWorkspace(JDBCServerExplorer wsexplorer) {

        if (wsexplorer == null) {

            return null;

        }

        try {

            VCSGisWorkspace workspace;

            JDBCServerExplorerParameters params = wsexplorer.getParameters();

            String url = params.getUrl();

            for (VCSGisWorkspaceDescriptor value : this.workspaces.values()) {

                if (value.isWorkspaceInitialized() && StringUtils.equals(url, value.getExplorerParameters().getUrl())) {

                    workspace = value.getWorkspace();

//                    LOGGER.debug("===: OPEN WORKSPACE "+ hexId(workspace)+ " from registry (code='"+workspace.getCode()+"', label='"+workspace.getLabel()+"')");        

                    return workspace;

                }

            }

            workspace = new VCSGisWorkspaceImpl(wsexplorer, this.codeGenerator);

            workspace.setUserIdentificationRequester(this.userIdentificationRequester);

            this.registerWorkspace(workspace);

            return workspace;

        } catch (Exception ex) {

            return null;

        }

    }

    @Override

    public void registerWorkspace(VCSGisWorkspace workspace) {

        VCSGisWorkspaceDescriptorImpl descriptor = new VCSGisWorkspaceDescriptorImpl(workspace);

        this.workspaces.put(descriptor.getCode(), descriptor);

    }

    @Override

    public void deregisterWorkspace(VCSGisWorkspace workspace) {

        this.deregisterWorkspace(workspace.getCode());

    }

    @Override

    public void deregisterWorkspace(String workspaceCode) {

        this.workspaces.remove(workspaceCode);

    }

    @Override

    public VCSGisWorkspace getWorkspace(FeatureStore store) {

        try {

            VCSGisWorkspace workspace;

            switch(StoreProperties.getVCSMode(store)) {

                case StoreProperties.MODE_NOT_VCS:

                    return null;

                case StoreProperties.MODE_VCS:

                    String workspace_code = StoreProperties.getWorkspaceCode(store);

                    VCSGisWorkspaceDescriptor workspaceDescriptor = this.workspaces.get(workspace_code);

                    if( workspaceDescriptor!=null ) {

                        workspace = workspaceDescriptor.getWorkspace();

                        if (workspace != null) {

                            String entity_name = StoreProperties.getEntityName(store);

                            EntityRow entity = (EntityRow) workspace.getWorkspaceEntityByName(entity_name);

                            if (entity == null) {

                                StoreProperties.setNotVCSMode(store);

                                return null;

                            }

//                            LOGGER.debug("===: GET WORKSPACE "+ hexId(workspace)+ " from property (code='"+workspace.getCode()+"', label='"+workspace.getLabel()+"') for store '"+store.getName()+"'");        

                            return workspace;

                        }

                    }

                    // break;

                case StoreProperties.MODE_UNKNOWN:

                default:

                    DataStoreParameters params = store.getParameters();

                    if(!(params instanceof JDBCStoreParameters)) {

                        StoreProperties.setNotVCSMode(store);

                        return null;

                    }

                    String entity_name = ((JDBCStoreParameters) params).getTable();

                    if (INTERNAL_WORKSPACE_TABLES.contains(entity_name)) {

                        StoreProperties.setNotVCSMode(store);

                        return null;

                    }

                    String storeUrl = ((JDBCStoreParameters)params).getUrl();

                    for (VCSGisWorkspaceDescriptor value : this.workspaces.values()) {

                        if (StringUtils.equals(storeUrl, value.getExplorerParameters().getUrl())) {

                            workspace = value.getWorkspace();

                            EntityRow entity = (EntityRow) workspace.getWorkspaceEntityByName(entity_name);

                            if (entity == null) {

                                StoreProperties.setNotVCSMode(store);

                                return null;

                            }

                            StoreProperties.set(store, workspace, entity_name);

//                            LOGGER.debug("===: GET WORKSPACE "+ hexId(workspace)+ " from registry (code='"+workspace.getCode()+"', label='"+workspace.getLabel()+"') for store '"+store.getName()+"'");        

                            return workspace;

                        }

                    }

                    try {

                        workspace = openWorkspace((JDBCServerExplorer)store.getExplorer());

                    } catch (Exception e) {

                        workspace = null;

                    }

                    if (workspace == null) {

                        StoreProperties.setNotVCSMode(store);

                        return null;

                    }

                    this.registerWorkspace(workspace);

                    EntityRow entity = (EntityRow) workspace.getWorkspaceEntityByName(entity_name);

                    if (entity == null) {

                        StoreProperties.setNotVCSMode(store);

                        return null;

                    }

                    StoreProperties.set(store, workspace, entity_name);

                    return workspace;

            }

        } catch (Exception ex) {

            LOGGER.warn("Can't get '" +store.getName()+ "'store's workspace ", ex);

            StoreProperties.setNotVCSMode(store);

            return null;

        }

    }

    @Override

    public boolean isWorkspace(JDBCServerExplorerParameters params) {

        try {

            DataManager dataManager = DALLocator.getDataManager();

            DataServerExplorer explorer = dataManager.openServerExplorer(params.getProviderName(), params);

            DataStoreParameters x = explorer.get(VarsTable.TABLE_NAME);

            if(x==null) {

                return false;

            }

            return explorer.exists(x);

        } catch (Exception ex) {

            return false;

        }

    }

    @Override

    public boolean isWorkspace(File dbfile) {

        try {

            DataManager dataManager = DALLocator.getDataManager();

            JDBCServerExplorerParameters params = (JDBCServerExplorerParameters) dataManager.createServerExplorerParameters(DataStore.H2SPATIAL_PROVIDER_NAME);

            ((HasAFile)params).setFile(dbfile);

            return isWorkspace(params);

        } catch (Exception ex) {

            return false;

        }

    }    

    private File removeH2FileExtension(File f) {

        if (f == null) {

            return null;

        }

        String pathname = f.getAbsolutePath();

        String lpathname = pathname.toLowerCase();

        for (String ext : new String[]{".mv.db", ".mv", ".trace.db", ".trace"}) {

            if (lpathname.endsWith(ext)) {

                pathname = pathname.substring(0, pathname.length() - ext.length());

                return new File(pathname);

            }

        }

        return f;

    }

    public static String hexId(Object obj) {

        if( obj==null ) {

            return "NULL";

        }

        return Integer.toHexString(obj.hashCode()).toUpperCase();

    }    

    @Override

    public VCSGisWorkspaceDescriptor getWorkspaceDescriptor(String code) {

        return this.workspaces.get(code);

    }

    @Override

    public int initRepository(JDBCServerExplorerParameters repositoryParameters, SimpleTaskStatus status) {

        return VCSGisRepositoryLocaldb.create(repositoryParameters, this.codeGenerator, status);

    }

    @Override

    public VCSGisRepository openRepository(JDBCServerExplorerParameters repositoryParameters) {

        return new VCSGisRepositoryLocaldb(repositoryParameters, codeGenerator);

    }

    @Override

    public VCSGisRepository openRepository(URL repository) {

        return new VCSGisRepositoryClient(repository);

    }

    @Override

    public VCSGisServerController createServerController(VCSGisRepository repository) {

        return new VCSGisServerControllerImpl(repository);

    }

    @Override

    public void setCodeGenerator(VCSGisCodeGenerator generator) {

        this.codeGenerator = generator;

    }

    @Override

    public VCSGisCodeGenerator getCodeGenerator() {

        return this.codeGenerator;

    }

    @Override

    public String getErrorMessage(int errcode) {

        return VCSGisUtils.getErrorMessage(errcode);

    }

    @Override

    public void setUserIdentificationRequester(VCSGisUserIdentificationRequester userIdentificationRequester) {

        this.userIdentificationRequester = userIdentificationRequester;

    }

}