DatabaseConnectionBuilder.java

package com.proalpha.pds.projconf.configure;
 
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.List;
import java.util.Properties;
import java.util.Set;
import java.util.TreeSet;
 
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import com.openedge.pdt.project.OEProjectPlugin;
import com.openedge.pdt.project.connection.DatabaseConnectionManager;
import com.openedge.pdt.project.connection.DatabaseConnectionProfile;
import com.proalpha.pds.projconf.Activator;
import com.proalpha.pds.projconf.properties.PropertiesManager;
 
import net.sourceforge.sqlexplorer.AliasModel;
import net.sourceforge.sqlexplorer.IdentifierFactory;
import net.sourceforge.sqlexplorer.plugin.SQLExplorerPlugin;
import net.sourceforge.squirrel_sql.fw.id.IIdentifier;
import net.sourceforge.squirrel_sql.fw.sql.ISQLAlias;
 
public class DatabaseConnectionBuilder {
 
    private final Logger logger = LoggerFactory.getLogger(DatabaseConnectionBuilder.class);
 
    private final Properties databaseProperties;
    private final String projectVersionIdenifier;
    private final String databaseDirectory;
    private final String dlc;
 
    public DatabaseConnectionBuilder(String projectVersionIdenifier, String propertiesFile,
            String databaseDirectory, String dlc) throws IOException {
 
        this.projectVersionIdenifier = projectVersionIdenifier;
        this.databaseDirectory = databaseDirectory;
        this.dlc = dlc;
 
        databaseProperties = PropertiesManager.getProperties(new File(propertiesFile));
 
    }
 
    private void addProfilesToConnectionManager(IProject project, List<DatabaseConnectionProfile> dbConnections) {
 
        DatabaseConnectionManager databaseConnectionManager = OEProjectPlugin.getDefault()
                .getDatabaseConnectionManager();
 
        List<DatabaseConnectionProfile> existDBProfils = Arrays
                .asList(databaseConnectionManager.getDatabaseConnectionProfiles());
 
        // Add the database profile to the DatabaseConnectionProfile pool
        try {
            for (DatabaseConnectionProfile dbProfile : dbConnections) {
                if (existDBProfils.contains(dbProfile)) {
                    databaseConnectionManager.removeDatabaseConnectionProfile(dbProfile.getIdentifier());
                }
                dbProfile.setAutoStartServer(false);
            }
 
            databaseConnectionManager
                    .addDatabaseConnectionProfile(dbConnections.toArray(new DatabaseConnectionProfile[0]));
 
        } catch (Exception e) {
            IStatus status = new Status(IStatus.WARNING, Activator.PLUGIN_ID, e.getMessage(), e);
            Activator.getDefault().getLog().log(status);
        }
 
        if (project.exists()) {
            databaseConnectionManager.writeDBMappingFile(dbConnections, project);
        }
    }
 
    private String buildUrl(String dbPort, String dbName, String dbHost) {
        return "jdbc:datadirect:openedge://" + dbHost + ":" + dbPort + ";databaseName=" + dbName;
    }
 
    private DatabaseConnectionProfile createDatabaseConnectionProfile(String logicalName) {
 
        String physicalName = databaseDirectory + "\\"
                + databaseProperties.getProperty(logicalName + ".dbPhysicalName");
        String connectionName = projectVersionIdenifier + " " + logicalName;
 
        String dbPort = databaseProperties.getProperty(logicalName + ".dbPort");
        String dbHost = databaseProperties.getProperty(logicalName + ".dbHost");
        String dbUserName = databaseProperties.getProperty(logicalName + ".dbUserName");
        String dbPassword = databaseProperties.getProperty(logicalName + ".dbPassword");
        String dbServerParameter = databaseProperties.getProperty(logicalName + ".dbServerParameter");
        String dbParameters = databaseProperties.getProperty(logicalName + ".dbParameter");
        String hasSecurity = databaseProperties.getProperty(logicalName + ".dbHasSecurity");
 
        String url = buildUrl(dbPort, new Path(physicalName).lastSegment(), dbHost);
 
        ISQLAlias sqlAlias = createSQLAlias(connectionName, url, dbUserName, dbPassword);
        DatabaseConnectionProfile dbProfile = new DatabaseConnectionProfile(connectionName);
 
        dbProfile.setIdentifier(connectionName.replace(' ', '_'));
        dbProfile.setGroup(projectVersionIdenifier);
        dbProfile.setPhysicalName(physicalName);
        dbProfile.setLogicalName(logicalName);
        dbProfile.setProVersion(identifyProgressVersion());
 
        if (Boolean.valueOf(hasSecurity)) {
            dbProfile.setUser(dbUserName);
            dbProfile.setPassword(dbPassword);
        }
 
        if (dbParameters != null) {
            dbProfile.setParameters(dbParameters);
        }
 
        dbProfile.setHost(dbHost);
        dbProfile.setService(dbPort);
 
        if (sqlAlias != null) {
            dbProfile.setAsociatedSQLAlias(sqlAlias);
            dbProfile.setSqlIdentifier(sqlAlias.getIdentifier().toString());
            dbProfile.setSqlName(connectionName + "_SQL");
            dbProfile.setSqlAliasObject(sqlAlias);
            dbProfile.setAutoStartServer(true);
            dbProfile.setAutoShutdownServer(true);
            dbProfile.setServerParameters("-db " + physicalName + " " + "-S " + dbPort + " " + dbServerParameter);
        }
 
        return dbProfile;
    }
 
    private List<DatabaseConnectionProfile> createDatabaseConnectionProfile() {
 
        // Create any database connection definition
        List<DatabaseConnectionProfile> dbProfiles = new ArrayList<>();
        Set<String> databaseNames = new TreeSet<>();
 
        databaseNames.addAll(getDatabaseNames());
 
        for (String logicalName : databaseNames) {
            dbProfiles.add(createDatabaseConnectionProfile(logicalName));
        }
 
        return dbProfiles;
    }
 
    public void createDbConnections(IProject project) {
 
        List<DatabaseConnectionProfile> dbConnections = createDatabaseConnectionProfile();
 
        addProfilesToConnectionManager(project, dbConnections);
 
    }
 
    private static void removeSQLAlias(String connectionName) {
        AliasModel aliasModel = SQLExplorerPlugin.getDefault().getAliasModel();
        for (Object alias : aliasModel.getElements()) {
            if (((ISQLAlias) alias).getName().equals(connectionName + "_SQL")) {
                aliasModel.removeAlias((ISQLAlias) alias);
                break;
            }
        }
    }
 
    public static void removeDatabaseConnections(String groupName) {
 
        DatabaseConnectionManager manager = OEProjectPlugin.getDefault().getDatabaseConnectionManager();
 
        try {
            DatabaseConnectionProfile[] databaseConnectionProfiles = manager.getDatabaseConnectionProfiles();
 
            for (int i = 0; i < databaseConnectionProfiles.length; i++) {
                DatabaseConnectionProfile databaseConnectionProfile = databaseConnectionProfiles[i];
                String connectionName;
 
                if (databaseConnectionProfile.getGroup().equalsIgnoreCase(groupName)) {
                    connectionName = databaseConnectionProfile.getName();
                    manager.removeDatabaseConnectionProfile(databaseConnectionProfile.getIdentifier());
 
                    removeSQLAlias(connectionName);
                }
            }
 
        } catch (Exception e) {
            IStatus status = new Status(IStatus.INFO, Activator.PLUGIN_ID, e.getMessage(), e);
            Activator.getDefault().getLog().log(status);
        }
    }
 
    private ISQLAlias createSQLAlias(String connectionName, String url, String userName, String password) {
 
        IIdentifier identifier = null;
        Boolean isAliasExsits = false;
        ISQLAlias sqlAlias = null;
 
        AliasModel aliasModel = SQLExplorerPlugin.getDefault().getAliasModel();
 
        for (Object alias : aliasModel.getElements()) {
            if (((ISQLAlias) alias).getName().equals(connectionName + "_SQL")) {
                isAliasExsits = true;
                sqlAlias = (ISQLAlias) alias;
                break;
            }
        }
 
        if (!isAliasExsits) {
            for (int i = 0; i < SQLExplorerPlugin.getDefault().getDriverModel().size(); i++) {
 
                if (SQLExplorerPlugin.getDefault().getDriverModel().getElement(i).getUrl()
                        .startsWith("jdbc:datadirect:openedge")) {
 
                    identifier = SQLExplorerPlugin.getDefault().getDriverModel().getElement(i).getIdentifier();
                    break;
                }
            }
 
            sqlAlias = aliasModel.createAlias(IdentifierFactory.getInstance().createIdentifier());
 
            try {
                sqlAlias.setName(connectionName + "_SQL");
                sqlAlias.setDriverIdentifier(identifier);
                sqlAlias.setUrl(url.trim());
                sqlAlias.setUserName(userName);
                sqlAlias.setPassword(password);
                sqlAlias.setAutoLogon(true);
                SQLExplorerPlugin.getDefault().getAliasModel().addAlias(sqlAlias);
 
            } catch (Exception e) {
                logger.error(e.getMessage(), e);
                sqlAlias = null;
            }
        }
 
        return sqlAlias;
    }
 
    private Set<String> getDatabaseNames() {
        Set<String> databaseNames = new TreeSet<>();
 
        Enumeration<?> propertyNames = databaseProperties.propertyNames();
 
        while (propertyNames.hasMoreElements()) {
 
            String propertyName = (String) propertyNames.nextElement();
 
            databaseNames.add(propertyName.substring(0, propertyName.indexOf('.')));
 
        }
 
        return databaseNames;
    }
 
    private String identifyProgressVersion() {
        String progressVersion = "";
 
        try (BufferedReader br = new BufferedReader(
                new FileReader(new File(new Path(dlc).append("version").toString())));) {
 
            String line = br.readLine();
 
            if (line != null) {
                progressVersion = line.substring(17, 22);
            }
 
        } catch (FileNotFoundException e) {
            logger.error("Couldn't find version file in dlc dir", e);
        } catch (IOException e) {
            logger.error("IOException occured during search of progress version", e);
        }
 
        return progressVersion;
    }
 
}