CheckTreeView.java

package com.proalpha.pds.checks;
 
import java.io.File;
import java.text.MessageFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
 
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
 
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.QualifiedName;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Cursor;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.layout.RowLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.forms.widgets.Form;
import org.eclipse.ui.forms.widgets.FormToolkit;
import org.eclipse.ui.part.ViewPart;
 
import com.proalpha.pds.jaxb.DsDSConsistencyChecks;
import com.proalpha.pds.jaxb.DsDSConsistencyChecks.TtDSCheck;
import com.proalpha.pds.jaxb.DsDSConsistencyChecks.TtDSCheck.TtDSSubCheck;
import com.proalpha.pds.jaxb.DsDSConsistencyChecks.TtDSCheck.TtDSSubCheck.TtDSLogEntryRepos;
import com.proalpha.pds.jaxb.DsDSConsistencyChecks.TtDSCheck.TtDSSubCheck.TtDSLogEntrySrc;
import com.proalpha.pds.paconnector.PaProject;
 
public class CheckTreeView extends ViewPart {
 
    private static final String LOCAL = "Local";
    public static final String ID = "com.proalpha.pds.checks.CheckTreeView";
    private static final String CHECK_ALL = "<ALL>";
 
    private DsDSConsistencyChecks currentChecks;
    private String currentTeam = CHECK_ALL;
    private String currentModule = CHECK_ALL;
    private CheckFilter filter;
    private Form form;
    private String location;
    private Combo projectViewer;
    private Combo teamViewer;
    private Combo moduleViewer;
    private TreeViewer viewer;
    private File xmlFile;
    private Button serverButton;
    private Button localButton;
 
    public String getCurrentTeam() {
        return currentTeam;
    }
 
    public String getCurrentModule() {
        return currentModule;
    }
 
    public class CollapseAllAction extends Action {
        public CollapseAllAction() {
            setImageDescriptor(ImageDescriptor.createFromURL(getClass().getResource("/images/collapse_all.png")));
            setToolTipText("Collapse all");
        }
 
        @Override
        public void run() {
            viewer.collapseAll();
        }
    }
 
    public class ExpandAllAction extends Action {
        public ExpandAllAction() {
            setImageDescriptor(ImageDescriptor.createFromURL(getClass().getResource("/images/expand_all.gif")));
            setToolTipText("Expand all");
        }
 
        @Override
        public void run() {
            viewer.expandAll();
        }
    }
 
    public void createPartControl(Composite parent) {
 
        FormToolkit toolkit = new FormToolkit(parent.getDisplay());
        form = toolkit.createForm(parent);
        form.getBody().setLayout(new GridLayout(4, false));
 
        toolkit.decorateFormHeading(form);
 
        Label lblProject = new Label(form.getBody(), SWT.NONE);
        GridData gridData = new GridData(SWT.RIGHT, SWT.CENTER, false, false, 1, 1);
        gridData.widthHint = 50;
        lblProject.setLayoutData(gridData);
        toolkit.adapt(lblProject, true, true);
        lblProject.setText("Project");
 
        projectViewer = new Combo(form.getBody(), SWT.DROP_DOWN | SWT.READ_ONLY);
        GridData gridDataCombo = new GridData(SWT.FILL, SWT.CENTER, true, false, 2, 1);
        gridDataCombo.widthHint = 200;
        projectViewer.setLayoutData(gridDataCombo);
        projectViewer.setItems(getCurrentProjectList());
        projectViewer.addSelectionListener(projectSelectedListener());
 
        toolkit.adapt(projectViewer);
        toolkit.paintBordersFor(projectViewer);
 
        Group group = new Group(form.getBody(), SWT.NONE);
        group.setText("Location");
        group.setLayout(new RowLayout(SWT.VERTICAL));
        group.setLayoutData(new GridData(SWT.LEFT, -7, false, false, 1, 2));
        toolkit.adapt(group);
        toolkit.paintBordersFor(group);
 
        serverButton = new Button(group, SWT.RADIO);
        serverButton.setText("Server");
        serverButton.setImage(
                ImageDescriptor.createFromURL(getClass().getResource("/images/server_earth.png")).createImage());
        serverButton.addSelectionListener(locationSelectedListener());
        serverButton.setEnabled(false);
        toolkit.adapt(serverButton, true, true);
 
        localButton = new Button(group, SWT.RADIO);
        localButton.setText(LOCAL);
        localButton
                .setImage(ImageDescriptor.createFromURL(getClass().getResource("/images/text_tree.png")).createImage());
        localButton.addSelectionListener(locationSelectedListener());
        localButton.setEnabled(false);
        localButton.setSelection(true);
        toolkit.adapt(localButton, true, true);
 
        Label lblModule = new Label(form.getBody(), SWT.NONE);
        GridData gridData3 = new GridData(SWT.RIGHT, SWT.CENTER, false, false, 1, 1);
        gridData3.widthHint = 50;
        lblModule.setLayoutData(gridData3);
        toolkit.adapt(lblModule, true, true);
        lblModule.setText("Module");
 
        teamViewer = new Combo(form.getBody(), SWT.DROP_DOWN | SWT.READ_ONLY);
        teamViewer.setVisibleItemCount(12);
        teamViewer.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false, 1, 1));
        teamViewer.addSelectionListener(teamSelectedListener());
 
        toolkit.adapt(teamViewer);
        toolkit.paintBordersFor(teamViewer);
 
        moduleViewer = new Combo(form.getBody(), SWT.DROP_DOWN | SWT.READ_ONLY);
        moduleViewer.setVisibleItemCount(12);
        moduleViewer.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, false, false, 1, 1));
        moduleViewer.addSelectionListener(moduleSelectedListener());
 
        toolkit.adapt(moduleViewer);
        toolkit.paintBordersFor(moduleViewer);
 
        location = LOCAL;
        form.setText("select an installed project to show the results of the consistency checks");
        form.update();
 
        viewer = new TreeViewer(form.getBody(), SWT.NONE);
        filter = new CheckFilter();
        viewer.setContentProvider(new CheckTreeViewContentProvider());
        viewer.setLabelProvider(new CheckTreeViewLabelProvider(filter));
        viewer.addFilter(filter);
        viewer.getTree().setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, true, 4, 1));
 
        getSite().setSelectionProvider(viewer);
 
        IToolBarManager toolBarManager = getViewSite().getActionBars().getToolBarManager();
        toolBarManager.add(new ExpandAllAction());
        toolBarManager.add(new CollapseAllAction());
    }
 
    private SelectionListener projectSelectedListener() {
        return new SelectionListener() {
            public void widgetSelected(SelectionEvent selectedItem) {
                if (selectedItem != null) {
                    String selectedProjectName = ((Combo) selectedItem.getSource()).getText();
                    if (!selectedProjectName.isEmpty()) {
                        localButton.setEnabled(true);
                        serverButton.setEnabled(true);
                    }
                    checksXmlFile(selectedProjectName);
                }
                refreshChecks();
            }
 
            public void widgetDefaultSelected(SelectionEvent selectedItem) {
                // ignored
            }
        };
    }
 
    private SelectionListener locationSelectedListener() {
        return new SelectionListener() {
            public void widgetSelected(SelectionEvent selectedItem) {
 
                if (selectedItem != null && selectedItem.widget instanceof Button
                        && ((Button) selectedItem.widget).getSelection() && projectViewer.getSelectionIndex() != -1) {
                    location = ((Button) selectedItem.widget).getText();
                    String selectedProjectName = projectViewer.getText();
                    checksXmlFile(selectedProjectName);
                }
                refreshChecks();
            }
 
            public void widgetDefaultSelected(SelectionEvent selectedItem) {
                // ignored
            }
        };
    }
 
    private SelectionListener teamSelectedListener() {
        return new SelectionListener() {
 
            public void widgetSelected(SelectionEvent selectedItem) {
                if (selectedItem != null) {
                    currentTeam = ((Combo) selectedItem.getSource()).getText();
                    currentModule = CHECK_ALL;
                    filter.setSearchFilter(currentTeam, currentModule);
                    viewer.setSelection(StructuredSelection.EMPTY);
                    moduleViewer.setItems(getModules());
                    moduleViewer.select(moduleViewer.indexOf(CHECK_ALL));
                    viewer.refresh();
                    viewer.expandAll();
                }
            }
 
            @Override
            public void widgetDefaultSelected(SelectionEvent selectedItem) {
                // ignored
            }
        };
    }
 
    private SelectionListener moduleSelectedListener() {
        return new SelectionListener() {
 
            public void widgetSelected(SelectionEvent selectedItem) {
                if (selectedItem != null) {
                    currentModule = ((Combo) selectedItem.getSource()).getText();
                    filter.setSearchFilter(currentTeam, currentModule);
                    viewer.setSelection(StructuredSelection.EMPTY);
                    viewer.refresh();
                    viewer.expandAll();
                }
            }
 
            @Override
            public void widgetDefaultSelected(SelectionEvent selectedItem) {
                // ignored
            }
        };
    }
 
    public void checksXmlFile(String selectedProjectName) {
 
        if (selectedProjectName != null) {
            xmlFile = getXMLFile(selectedProjectName);
            displayCheckDate();
        } else {
            xmlFile = null;
            MessageDialog.openWarning(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(),
                    "Consistency checks not available",
                    "The selected project is not open. Consistency checks are only accessible "
                            + "if the selected project is available.");
        }
    }
 
    public String[] getCurrentProjectList() {
 
        IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
 
        IProject[] projects = workspaceRoot.getProjects();
        String[] projectNames = new String[projects.length];
        for (int i = 0; i < projects.length; i++) {
            IProject project = projects[i];
            projectNames[i] = project.getName();
        }
 
        return projectNames;
    }
 
    public String[] getModules() {
        Set<String> modules = new TreeSet<>();
        modules.add(CHECK_ALL);
        List<TtDSCheck> filteredList = currentChecks.getTtDSCheck();
        for (TtDSCheck check : filteredList) {
            List<TtDSSubCheck> filteredCheck = check.getTtDSSubCheck();
            for (DsDSConsistencyChecks.TtDSCheck.TtDSSubCheck filteredSubCheck : filteredCheck) {
                List<TtDSLogEntrySrc> filteredSrcEntries = filteredSubCheck.getTtDSLogEntrySrc();
                if (!filteredSrcEntries.isEmpty()) {
                    for (TtDSLogEntrySrc filteredSrcEntry : filteredSrcEntries) {
                        if (filteredSrcEntry.getModule() != null && !filteredSrcEntry.getModule().isEmpty()
                                && filter.select(null, null, filteredSrcEntry)) {
                            modules.add(filteredSrcEntry.getModule());
                        }
                    }
                }
                List<TtDSLogEntryRepos> filteredRepoEntries = filteredSubCheck.getTtDSLogEntryRepos();
                if (!filteredRepoEntries.isEmpty()) {
                    for (TtDSLogEntryRepos filteredRepoEntry : filteredRepoEntries) {
                        if (filteredRepoEntry.getModule() != null && !filteredRepoEntry.getModule().isEmpty()
                                && filter.select(null, null, filteredRepoEntry)) {
                            modules.add(filteredRepoEntry.getModule());
                        }
                    }
                }
            }
        }
        return modules.stream().toArray(String[]::new);
    }
 
    private void displayCheckDate() {
        if (xmlFile != null && xmlFile.exists() && projectViewer.getSelectionIndex() != -1) {
            Date date = new Date();
            date.setTime(xmlFile.lastModified());
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            SimpleDateFormat dateFormat = new SimpleDateFormat("dd.MM.yyyy HH:mm:ss");
            String heading = MessageFormat.format("{0} ({1})", location, dateFormat.format(calendar.getTime()));
            form.setText(heading);
            form.update();
        }
    }
 
    private void refreshChecks() {
 
        if ((xmlFile != null) && (xmlFile.exists())) {
 
            Unmarshaller unmarshaller = null;
            try {
                JAXBContext context = JAXBContext.newInstance(DsDSConsistencyChecks.class);
                unmarshaller = context.createUnmarshaller();
                if (unmarshaller != null) {
                    this.currentChecks = (DsDSConsistencyChecks) unmarshaller.unmarshal(xmlFile);
                }
            } catch (JAXBException e) {
                throw new IllegalStateException(e);
            }
 
            currentTeam = CHECK_ALL;
            currentModule = CHECK_ALL;
            filter.setSearchFilter(currentTeam, currentModule);
            teamViewer.setItems(filter.getTeams());
            moduleViewer.setItems(getModules());
            teamViewer.select(teamViewer.indexOf(CHECK_ALL));
            moduleViewer.select(moduleViewer.indexOf(CHECK_ALL));
        } else {
            currentChecks = null;
            teamViewer.removeAll();
            moduleViewer.removeAll();
        }
        refreshTree();
    }
 
    private void refreshTree() {
        if (currentChecks != null) {
            List<TtDSCheck> filteredList = currentChecks.getTtDSCheck();
            viewer.setInput(filteredList);
        } else {
            viewer.setInput(null);
        }
        Object[] expandedElements = null;
        expandedElements = viewer.getExpandedElements();
        if (expandedElements != null)
            viewer.setExpandedElements(expandedElements);
 
        viewer.refresh();
    }
 
    @Override
    public void showBusy(boolean busy) {
        Cursor systemCursor = busy ? Display.getCurrent().getSystemCursor(SWT.CURSOR_WAIT)
                : Display.getCurrent().getSystemCursor(SWT.CURSOR_ARROW);
        viewer.getTree().setCursor(systemCursor);
    }
 
    public String getSelectedProject() {
        return projectViewer.getText();
    }
 
    public void setSelectedProject(PaProject paProject) {
 
        projectViewer.select(projectViewer.indexOf(paProject.getName()));
        checksXmlFile(paProject.getName());
        try {
            // TODO do better synch for showing the results
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
            Thread.currentThread().interrupt();
        }
        refreshChecks();
        viewer.refresh(true);
    }
 
    private File getXMLFile(String selectedProjectName) {
        IPath pathToXMLFile = null;
        String fileName = "ConsistencyCheck.xml";
        Path localLocation = null;
        Path serverLocation = null;
        try {
            IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
            localLocation = new Path(root
                    .getPersistentProperty(new QualifiedName(selectedProjectName, "ConsistencyChecksLocationLocal")));
            serverLocation = new Path(root
                    .getPersistentProperty(new QualifiedName(selectedProjectName, "ConsistencyChecksLocationServer")));
        } catch (CoreException e1) {
            e1.printStackTrace();
        }
        if (location.equals(LOCAL)) {
            pathToXMLFile = localLocation;
        } else {
            pathToXMLFile = serverLocation;
        }
        File resultFile = null;
        if (pathToXMLFile != null) {
            resultFile = pathToXMLFile.append(fileName).toFile();
        } else {
            resultFile = new File("");
        }
        return resultFile;
    }
 
    @Override
    public void setFocus() {
        // Ignored
 
    }
}