UserExitGeneratorHandler.java

package com.proalpha.pds.ui.handlers;
 
import java.lang.reflect.InvocationTargetException;
 
import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.operation.IRunnableContext;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.PlatformUI;
 
import com.proalpha.pds.generator.GeneratorFactory;
import com.proalpha.pds.generator.OOABLExitFileGenerator;
import com.proalpha.pds.generator.UserExitFileGenerator;
import com.proalpha.pds.paconnector.PaProject;
import com.proalpha.pds.paconnector.parameter.ParameterFactory;
import com.proalpha.pds.paconnector.parameter.StartparameterReader;
import com.proalpha.pds.paconnector.utils.ExceptionUtils;
import com.proalpha.pds.templates.data.DataContainerFactory;
import com.proalpha.pds.templates.data.IGeneratorDataContainer;
import com.proalpha.pds.ui.Activator;
 
public class UserExitGeneratorHandler extends AbstractHandler {
 
    private DataContainerFactory dataContainerFactory;
    private GeneratorFactory generatorFactory;
    private ParameterFactory parameterFactory;
 
    public UserExitGeneratorHandler() {
        dataContainerFactory = new DataContainerFactory();
        generatorFactory = new GeneratorFactory();
        parameterFactory = new ParameterFactory();
    }
 
    @Override
    public Object execute(ExecutionEvent event) throws ExecutionException {
        
        PaProject paProject = com.proalpha.pds.paconnector.Activator.getDefault().getProjectManager().getPaProjectByTextSelection();
        if (paProject != null  && paProject.isAvailable()) {
                generateUserExits(paProject);
        }
        return null;
    }
 
    private void generateUserExits(PaProject paProject) {
        
        IRunnableWithProgress runnable = monitor -> {
            IFile file = null;
            String pAProcedure = null;
 
            try {
                
                monitor.beginTask("Generate Userexit", 4);
                monitor.worked(1);
                IGeneratorDataContainer datacontainer = dataContainerFactory.createDataContainer(paProject);
                StartparameterReader pAStartParam = parameterFactory
                        .createStartparameterReader(paProject);
                
                file = com.proalpha.pds.paconnector.Activator.getDefault().getProjectManager().getFileFromActiveSelection();
                
                if (file != null) {
                 pAProcedure = file.getName();  
                }
                else {
                    final Shell activeShell = Display.getDefault().getActiveShell();
                    MessageDialog.openError(activeShell, "no procedure name", "can't find filename in current selection.");
                    return;
                }
                
                monitor.worked(2);
                datacontainer.setFileName(pAProcedure);
                datacontainer.setVersion(paProject.getVersion());
                datacontainer.setCustomLevel(paProject.getCustomLevel());
                datacontainer.setObjectInfo(datacontainer.getRepositoryInformations().getProgramShortDesc(pAProcedure));
 
                if (pAProcedure.endsWith(".cls")) {
                    // informations about the Parent Claas
                    String pAParentClaasObj = datacontainer.getRepositoryInformations().getClassOBJ(pAProcedure);
                    datacontainer
                            .setParentObject(datacontainer.getRepositoryInformations().getClassName(pAParentClaasObj));
 
                    OOABLExitFileGenerator gen = generatorFactory.createOOABLExitFileGenerator(datacontainer,
                            "pAOOABLStdClass");
 
                    gen.generateUserExitClassAndBalpEntry();
 
                } else {
                    datacontainer.setParentObject(pAProcedure);
                    UserExitFileGenerator gen = generatorFactory.createUserExitFileGenerator(datacontainer);
                    gen.generateUserExitClassAndBalpEntry();
 
                }
                monitor.worked(2);
                // Job.getJobManager().join(ContentGenerator.JOB_FAMILY, monitor);
 
                pAStartParam.getWorkingDirectory().refreshLocal(IResource.DEPTH_INFINITE, monitor);
                monitor.done();
            } catch (Exception exception) {
                ExceptionUtils.showAndLogErrorMessage(Activator.getDefault(), exception);
            }
 
        };
 
        ISchedulingRule rule = ResourcesPlugin.getWorkspace().getRoot();
        IRunnableContext context = PlatformUI.getWorkbench().getProgressService();
 
        try {
            PlatformUI.getWorkbench().getProgressService().runInUI(context, runnable, rule);
        } catch (InvocationTargetException e) {
            ExceptionUtils.showAndLogErrorMessage(Activator.getDefault(), e);
        } catch (InterruptedException e) {
            ExceptionUtils.showAndLogErrorMessage(Activator.getDefault(), e);
            Thread.currentThread().interrupt();
        }
    }
}