PaProjectManager.java

package com.proalpha.pds.paconnector;
 
import java.text.MessageFormat;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
 
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IAdapterManager;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeSelection;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.ISelectionService;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import com.openedge.pdt.project.IOpenEdgeProject;
import com.openedge.pdt.project.IOpenEdgeProjectListener;
import com.openedge.pdt.project.OEProject;
import com.openedge.pdt.project.OEProjectPlugin;
import com.proalpha.pds.paconnector.utils.CheckPythonModules;
 
public class PaProjectManager {
 
    private final Logger logger = LoggerFactory.getLogger(PaProjectManager.class);
 
    private OpenEdgeProjectListener projectListener;
    private List<PaProject> paProjects;
 
    public List<PaProject> getPaProjects() {
        return paProjects;
    }
 
    private Boolean pythonVersionChecked = false;
 
    public PaProjectManager() {
        this.paProjects = new CopyOnWriteArrayList<>();
        this.projectListener = new OpenEdgeProjectListener();
        OEProjectPlugin.getDefault().getProjectManager().addOpenEdgeProjectListener(projectListener);
 
        // Add all projects that were already opened before the listener was registered
        this.checkPythonVersions();
        this.addOpenProjects();
 
    }
 
    private void addOpenProjects() {
        List<IProject> projects = Arrays.asList(ResourcesPlugin.getWorkspace().getRoot().getProjects());
        for (IProject project : projects) {
            if (project.isOpen()) {
                OEProject oeProject = (OEProject) OEProjectPlugin.getDefault().getOpenEdgeModel()
                        .getOpenEdgeProject(project);
                if(oeProject != null) addPaProject(oeProject);
            }
        }
    }
 
    public void addPaProject(IOpenEdgeProject oeProject) {
        if (canAddPaProject(oeProject)) {
            final PaProject paProject = new PaProject((OEProject) oeProject);
            paProjects.add(paProject);
            this.checkPythonVersions();
        }
    }
 
    public void addPaProject(PaProject paProject) {
        if (canAddPaProject(paProject.getOeProject())) {
            paProjects.add(paProject);
            this.checkPythonVersions();
        }
    }
 
    private boolean canAddPaProject(IOpenEdgeProject oeProject) {
        try {
            IProject project = oeProject.getProject();
            if(project != null) return project.hasNature("com.proalpha.pds.ui.proalphaNature");
            return false;
        } catch (CoreException e) {
            return false;
        }
    }
 
    public void removePaProject(IOpenEdgeProject oeProject) {
        paProjects.forEach(paProject -> {
            if (paProject.getOeProject().equals(oeProject)) {
                paProject.dispose();
                paProjects.remove(paProject);
            }
        });
    }
 
    public void openProjects(List<IProject> affectedProjects, SubMonitor monitor) {
        for (IProject iProject : affectedProjects) {
            SubMonitor subMonitor = monitor.newChild(1);
            subMonitor.subTask(MessageFormat.format("Opening project {0}", iProject.getName()));
            try {
                iProject.open(subMonitor);
            } catch (CoreException e) {
                logger.error("Error while opening project {}", iProject);
            } finally {
                subMonitor.done();
            }
        }
    }
 
    public void closeProjects(List<IProject> affectedProjects, SubMonitor monitor) {
        for (IProject iProject : affectedProjects) {
            SubMonitor subMonitor = monitor.newChild(1);
            subMonitor.subTask(MessageFormat.format("Closing project {0}", iProject.getName()));
            try {
                iProject.close(subMonitor);
            } catch (CoreException e) {
                logger.error("Error while closing project {}", iProject);
            } finally {
                subMonitor.done();
            }
        }
    }
 
    public PaProject getPaProject(IOpenEdgeProject oeProject) {
        for (PaProject paProject : paProjects) {
            if (paProject.getOeProject().equals(oeProject))
                return paProject;
        }
        return null;
    }
 
    public PaProject getPaProject(IProject iProject) {
 
        OEProject oeProject = (OEProject) OEProjectPlugin.getDefault().getOpenEdgeModel().getOpenEdgeProject(iProject);
        for (PaProject paProject : paProjects) {
            if (paProject.getOeProject().equals(oeProject))
                return paProject;
        }
        return null;
    }
 
    public PaProject getPaProjectByTextSelection() {
        PaProject paProject = null;
 
        // get the WorkbenchWindow
        IWorkbenchWindow activeWorkbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
 
        if (activeWorkbenchWindow == null) {
            // without a activeWorkbenchWindow we can't find anything.
            return null;
        }
        // first try to find with Selection Service
        ISelectionService service = activeWorkbenchWindow.getService(ISelectionService.class);
 
        if (service != null) {
            ISelection selection = service.getSelection();
            if (selection instanceof IStructuredSelection) {
                if (((IStructuredSelection) selection).getFirstElement() instanceof IResource) {
                    IProject curProject = ((IResource) ((IStructuredSelection) selection).getFirstElement())
                            .getProject();
                    // OEProjet found. Return
                    paProject = getPaProject(curProject);
                }
            }
        }
 
        // If we didn't find any project try to find it via EditorInput
        if (paProject == null) {
 
            // second try to find with active Page of workbench
            try {
                // Every single assign could throw a NPE. But we don't want to
                // check for null after every assign. Try and catch is the better way
                IWorkbenchPage activePage = activeWorkbenchWindow.getActivePage();
                IEditorPart activeEditor = activePage.getActiveEditor();
                IEditorInput curedit = activeEditor.getEditorInput();
                IResource curresource = curedit.getAdapter(IResource.class);
                IProject curProject = curresource.getProject();
                paProject = getPaProject(curProject);
            } catch (NullPointerException e) {
                // do nothing. So we return null
            }
        }
        return paProject;
    }
 
    public PaProject getPaProjectByProjectExplorer() {
        ISelectionService ss = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getSelectionService();
        String projExpID = "org.eclipse.ui.navigator.ProjectExplorer";
        ISelection sel = ss.getSelection(projExpID);
        Object selectedObject = sel;
        if (sel instanceof IStructuredSelection) {
            selectedObject = ((IStructuredSelection) sel).getFirstElement();
        }
        if (selectedObject instanceof IAdaptable) {
            IResource res = ((IAdaptable) selectedObject).getAdapter(IResource.class);
            return getPaProject(res.getProject());
        }
        return null;
    }
 
    public IFile getFileFromActiveSelection() {
 
        IFile file = null;
        IWorkbenchWindow workbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
        IAdapterManager adapterManager = Platform.getAdapterManager();
 
        if (workbenchWindow != null && adapterManager != null) {
 
            ISelectionService selectionService = workbenchWindow.getSelectionService();
            ISelection activSelection = selectionService.getSelection();
 
            if (activSelection instanceof ITreeSelection) {
                Object input = ((ITreeSelection) activSelection).getFirstElement();
                if (input != null)
                    file = adapterManager.getAdapter(input, IFile.class);
            }
 
            else if (activSelection instanceof ITextSelection) {
                IWorkbenchPage page = workbenchWindow.getActivePage();
                IEditorPart editor = page.getActiveEditor();
                if (editor != null) {
                    IEditorInput input = editor.getEditorInput();
                    file = adapterManager.getAdapter(input, IFile.class);
                }
            }
 
        }
 
        return file;
 
    }
 
    public void dispose() {
        if (projectListener != null) {
            OEProjectPlugin.getDefault().getProjectManager().removeOpenEdgeProjectListener(projectListener);
            projectListener = null;
        }
    }
 
    private void checkPythonVersions() {
        // if version checked do not check again
        if (this.pythonVersionChecked)
            return;
 
        CheckPythonModules pycheck = new CheckPythonModules();
 
        if (!pycheck.pythonVersionsMatch()) {
            // message dialogs can rise an error with invalid Thread access. execute in own
            // thread and try a several times
            new Thread(new Runnable() {
                public void run() {
                    final String messagetext = "To use this plugin version of proALPHA higher versions of python modules is needed. "
                            + "To update the python module execute\n\n"
                            + "python -m pip install pa_installer --upgrade --upgrade-strategy=eager\n\n"
                            + "in a command line started with admin rights.";
                    // try till worked
                    while (true) {
                        try {
                            Thread.sleep(1000);
                        } catch (Exception e) {
                        }
                        Display.getDefault().asyncExec(new Runnable() {
                            public void run() {
                                MessageDialog.openWarning(
                                        PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(),
                                        "python not up to date", messagetext);
                            }
                        });
                        // after work done return
                        break;
                    }
                }
            }).start();
 
        }
        this.pythonVersionChecked = true;
    }
 
    private class OpenEdgeProjectListener implements IOpenEdgeProjectListener {
        public void projectCreated(final IOpenEdgeProject project) {
            PaProjectManager.this.addPaProject(project);
        }
 
        public void projectDeleted(final IOpenEdgeProject project) {
            PaProjectManager.this.removePaProject(project);
        }
 
    }
 
}