PaWizard.java

package com.proalpha.pds.ui.wizards.controller;
 
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
 
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.window.Window;
import org.eclipse.jface.wizard.IWizardPage;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchWizard;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import com.proalpha.pds.exception.ProALPHANotAvailableException;
import com.proalpha.pds.generator.ContentGenerator;
import com.proalpha.pds.paconnector.Activator;
import com.proalpha.pds.paconnector.PaProject;
import com.proalpha.pds.paconnector.RunProgramInPa;
import com.proalpha.pds.paconnector.parameter.ParameterFactory;
import com.proalpha.pds.paconnector.parameter.StartparameterReader;
import com.proalpha.pds.paconnector.repository.RepositoryDelegate;
import com.proalpha.pds.paconnector.repository.RepositoryFactory;
import com.proalpha.pds.paconnector.repository.RepositoryInformations;
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.PaProjectSelection;
import com.proalpha.pds.ui.wizards.wizardpages.WizardMainPage;
import com.proalpha.pds.ui.wizards.wizardpages.WizardMainPageConfiguration;
import com.proalpha.pds.ui.wizards.wizardpages.WizardpageFactory;
 
public abstract class PaWizard extends Wizard {
 
    private final Logger logger = LoggerFactory.getLogger(PaWizard.class);
 
    protected ISelection selection;
 
    protected WizardMainPage wizardMainPage;
 
    private RunProgramInPa bridge;
 
    private LinkedHashMap<String, WizardMainPageConfiguration> configList;
 
    private RepositoryDelegate repositoryDelegate;
 
    private RepositoryInformations repositoryInformations;
 
    private StartparameterReader startparameterReader;
 
    protected Map<String, Object> wizardSettings;
 
    PaProject paProject;
 
    public PaWizard() {
        super();
        setNeedsProgressMonitor(true);
 
        this.paProject = Activator.getDefault().getProjectManager().getPaProjectByProjectExplorer();
 
        if (this.paProject == null || !this.paProject.getOeProject().getProject().isOpen()
                || !this.paProject.isAvailable()) {
            PaProjectSelection dialog = new PaProjectSelection(getShell());
            dialog.create();
            if (dialog.open() == Window.OK) {
                this.paProject = dialog.getSelectedProject();
            }
        }
 
        if (this.paProject == null || !this.paProject.getOeProject().getProject().isOpen()
                || !this.paProject.isAvailable()) {
            this.dispose();
            return;
        }
 
        logger.debug("Running wizard for {}", this.paProject);
 
        try {
            RepositoryFactory repositoryFactory = new RepositoryFactory();
            this.repositoryDelegate = repositoryFactory.createRepositoryDelegate(this.paProject);
            this.repositoryInformations = repositoryFactory.createRepositoryInformations(this.paProject);
            ParameterFactory parameterFactory = new ParameterFactory();
            this.startparameterReader = parameterFactory.createStartparameterReader(this.paProject);
        } catch (ProALPHANotAvailableException e) {
            ExceptionUtils.showAndLogErrorMessage(Activator.getDefault(), e);
        }
 
        if (!this.paProject.isAvailable()) {
            MessageDialog.openError(getShell(), "Connect to version control failed",
                    "The version control is not available.");
            throw new IllegalStateException("Version control is not available");
        }
 
        wizardSettings = new HashMap<>();
    }
 
    protected boolean doFinish() {
 
        try {
            DataContainerFactory factory = new DataContainerFactory();
            IGeneratorDataContainer dataContainer = factory.createDataContainer(this.paProject, wizardSettings);
            new ContentGenerator("", dataContainer, wizardSettings.get("TemplateName").toString()).schedule();
        } catch (Exception e) {
            ExceptionUtils.showAndLogErrorMessage(Activator.getDefault(), e);
            return false;
        }
 
        return true;
    }
 
    protected void throwCoreException(String message) throws CoreException {
        IStatus status = new Status(IStatus.ERROR, "com.proalpha.java.plugins.templates", IStatus.OK, message, null);
        throw new CoreException(status);
    }
 
    public void init(IWorkbench wb, IStructuredSelection selection) {
        this.selection = selection;
    }
 
    @SuppressWarnings("unchecked")
    public boolean performFinish() {
 
        IWizardPage[] wizardPages = getPages();
 
        for (IWizardPage page : wizardPages) {
            Class<?>[] interfaces = page.getClass().getInterfaces();
            for (Class<?> c : interfaces) {
                if (c.getName().contains("IpaWizardPage")) {
                    try {
                        Method method = page.getClass().getMethod("getSettings");
                        wizardSettings.putAll((HashMap<String, Object>) method.invoke(page));
                    } catch (Exception e) {
                        ExceptionUtils.showAndLogErrorMessage(Activator.getDefault(), e);
                        return false;
                    }
                }
            }
        }
        return doFinish();
    }
 
    @Override
    public void addPages() {
 
        wizardMainPage = WizardpageFactory.createWizardMainPage(this.paProject, this.configList, this.repositoryDelegate,
                this.repositoryInformations, this.startparameterReader);
 
        addPage(wizardMainPage);
    }
 
    public RunProgramInPa getbridge() {
        return this.bridge;
    }
 
    public RepositoryDelegate getRepositoryDelegate() {
        return repositoryDelegate;
    }
 
    public RepositoryInformations getRepositoryInformations() {
        return repositoryInformations;
    }
 
    public StartparameterReader getStartparameterReader() {
        return startparameterReader;
    }
 
    public LinkedHashMap<String, WizardMainPageConfiguration> getConfigList() {
        return configList;
    }
 
    public void setConfigList(LinkedHashMap<String, WizardMainPageConfiguration> configList) {
        this.configList = configList;
    }
}