RunProgramInPa.java

package com.proalpha.pds.paconnector;
 
import java.util.Enumeration;
import java.util.Hashtable;
 
import org.eclipse.core.runtime.IPath;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import com.openedge.core.runtime.ProgressCommand;
import com.proalpha.pds.exception.ProALPHANotAvailableException;
import com.proalpha.pds.paconnector.utils.CharsetConverter;
import com.proalpha.pds.paconnector.utils.ExceptionUtils;
 
public class RunProgramInPa {
 
    private final Logger logger = LoggerFactory.getLogger(RunProgramInPa.class);
    private static final String S_SUBPATH = "adm/support/proc/";
 
    // S T A T I C S
 
    // Run Internal Method of a Persistent Procedure or run a .p
 
    private static final int P_INTERNALCALL = 1;
    private static final int P_EXTERNALCALL = 2;
    private static final int P_FINDRECORD = 3;
    private static final int P_EXTERNALCALLPERSISTENT = 4;
 
    // If Internal, run a Function or a Procedure
 
    private static final int P_INTERNALFUNCTION = 1;
    private static final int P_INTERNALPROCEDURE = 2;
    private static final int P_UNDEFINEDMETHODTYPE = 0;
 
    protected final PaProject paProject;
 
    public RunProgramInPa(PaProject paProject) throws ProALPHANotAvailableException {
 
        this.paProject = paProject;
 
        IPath bridgePath = this.paProject.getOeProject().getPropath().search("paoidebr.p", true);
 
        if (bridgePath == null)
            throw new ProALPHANotAvailableException("paoidebr.p not Found. Not a pA Project");
 
        this.paProject.setBridgePath(bridgePath);
        
        try {
            this.paProject.setCodepage(runSupportProcedure("ds_oea36.p"));
            this.paProject.setVersion(callFunctionInService("session", "pa_cOIDEProperty", "proALPHAVersion"));
            this.paProject.setCustomLevel(getpAStartupParam("CustomLevel", ""));
            this.paProject.setAvailable(true);
        } catch (IllegalArgumentException e) {
            this.paProject.setCodepage("");
        }
    }
 
    public String callProcedureInService(String service, String procedureName, String... parameters) {
        return run(P_INTERNALCALL, P_INTERNALPROCEDURE, service, procedureName, parameters);
    }
 
    public String callFunctionInService(String service, String functionName, String... parameters) {
        return run(P_INTERNALCALL, P_INTERNALFUNCTION, service, functionName, parameters);
    }
 
    public String runExternalProcedure(String procedure, String... parameters) {
        return run(P_EXTERNALCALL, P_UNDEFINEDMETHODTYPE, procedure, "", parameters);
    }
 
    public String runExternalProcedurePersistent(String procedure, String... parameters) {
        return run(P_EXTERNALCALLPERSISTENT, P_UNDEFINEDMETHODTYPE, procedure, "", parameters);
    }
 
    public String recordField(String tableName, Hashtable<String, String> selection, String fieldName) {
 
        String[] parameters = new String[(selection.size() * 2) + 2];
        parameters[0] = tableName;
        parameters[1] = fieldName;
        int k = 2;
        Enumeration<String> keys = selection.keys();
        Enumeration<String> values = selection.elements();
        for (int i = 0; i < selection.size(); i++) {
            parameters[k++] = keys.nextElement();
            parameters[k++] = values.nextElement();
        }
 
        return run(P_FINDRECORD, P_UNDEFINEDMETHODTYPE, "", "", parameters);
    }
 
    private synchronized String run(int serviceType, int methodType, String program, String methodName,
            String... parameters) {
        return run(serviceType, methodType, program, methodName, false, parameters);
    }
 
    private synchronized String run(int serviceType, int methodType, String program, String methodName, boolean toTop,
            String... parameters) {
 
        String commandString;
 
        if (this.paProject.getBridgePath() == null) {
            Throwable e = new Throwable("Bridge to pA not available. cancel action " + program);
            ExceptionUtils.showAndLogErrorMessage(Activator.getDefault(), e);
            return "";
        }
        // Setup Command String
 
        commandString = "ServiceType=" + serviceType + ",MethodType=" + methodType + ",Program=" + program
                + ",MethodName=" + methodName + ",NumberOfParameters=" + parameters.length;
 
        int i = 1;
 
        StringBuilder cmdStr = new StringBuilder(commandString);
        for (String parameter : parameters) {
            cmdStr.append(",ParameterValue");
            cmdStr.append(i++);
            cmdStr.append("=");
            cmdStr.append(parameter);
        }
        commandString = cmdStr.toString();
 
        // Progress Command objects can be used to run a file with
        // an option single character string parameter
 
        if (this.paProject.getCodepage() != null) {
            commandString = CharsetConverter.encode(this.paProject.getCodepage(), commandString);
        }
 
        ProgressCommand cmd = new ProgressCommand((this.paProject.getBridgePath()).toOSString(), commandString,
                "EXTERNAL");
 
        // send the command
        this.paProject.getOeProject().getRuntime().runProgressCommand(cmd);
 
        // Set focus to runtime and display it on top of all windows
        if (toTop)
            this.paProject.getOeProject().getRuntime().bringToTop();
 
        // wait for a response...it may take a while depending
        // on the program there is another for of
        // waitForResult() that accepts a timeout in ms, if you
        // don't care to wait longer than a given amount of
        // time
 
        try {
            cmd.waitforResult();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            ExceptionUtils.showAndLogErrorMessage(Activator.getDefault(), e);
        }
 
        if (!cmd.isFinished()) {
            Throwable e = new Throwable("Openedge Command couldn't get finished!");
            ExceptionUtils.showAndLogErrorMessage(Activator.getDefault(), e);
        }
 
        // make sure it was actually run. If the status isn't
        // completed, then maybe something failed
 
        if (cmd.getCompletionStatus() == ProgressCommand.STATUS_COMPLETED) {
 
            // fetch the result and return it
            String result = cmd.getResult();
            logger.debug("CommandString: {}", commandString);
            logger.debug("Result: {}", result);
 
            return result;
        }
 
        return "";
    }
 
    public String runSupportProcedure(String supportProcedure, String... parameters) {
 
        String filePath = null;
        IPath iPath = this.paProject.getOeProject().getPropath().search(S_SUBPATH + supportProcedure, true);
 
        if (iPath != null && !iPath.isEmpty())
            filePath = iPath.toOSString();
 
        if (filePath == null) {
            throw new IllegalArgumentException(
                    String.format("In this version, this feature is not supported. (%s)", supportProcedure));
        } else {
            String retVal = runExternalProcedure(filePath, parameters);
 
            if (retVal.startsWith("PROGRESS runtime error ")) {
                StringBuilder errorMsg = new StringBuilder();
                errorMsg.append(
                        "Support procedure " + supportProcedure + " returned\n" + retVal + "\n\nParameters given:\n");
                for (int i = 0; i < parameters.length; i++)
                    errorMsg.append(parameters[i] + "\n");
 
                throw new IllegalArgumentException(errorMsg.toString());
            }
 
            return retVal;
        }
 
    }
 
    public String getpAStartupParam(String startupParam, String defaultValue) {
 
        // first check the parameter is available
        // the result of ds_oea is a parameter List
        String[] results = runSupportProcedure("ds_oea06.p", "", "%" + startupParam).split(",");
 
        // the information is in parameter 2.
        // result can be be the value of the Parameter or the Text unknown startup
        // parameter "PARMANAME"
        for (String result : results) {
 
            if (result.split("=")[0].equals("2")) {
 
                if ((result.split("=").length == 1)
                        // do not check the parameter name is included in response.
                        // do not work with parameter temp witch ends with temp
                        || !result.split("=")[1].contains("Unknown"))
                    return runSupportProcedure("ds_oea15.p", startupParam);
                else
                    return defaultValue;
            }
        }
        // this code never within reach
        return defaultValue;
    }
 
}