path: root/bundles/org.eclipse.jst.ws.jaxws.ui/src/org/eclipse/jst/ws/internal/jaxws/ui/wizards/OrderHandlerChainPage.java

/*******************************************************************************
 * Copyright (c) 2010 Shane Clarke.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Shane Clarke - initial API and implementation
 *******************************************************************************/
package org.eclipse.jst.ws.internal.jaxws.ui.wizards;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.ITypeHierarchy;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.ITypeBinding;
import org.eclipse.jdt.core.dom.ParameterizedType;
import org.eclipse.jdt.core.dom.TypeDeclaration;
import org.eclipse.jdt.ui.JavaElementLabelProvider;
import org.eclipse.jdt.ui.StandardJavaElementContentProvider;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.viewers.ColumnLabelProvider;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.TreeViewerColumn;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.window.Window;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.jst.ws.internal.jaxws.core.utils.JAXWSHandlerUtils;
import org.eclipse.jst.ws.internal.jaxws.ui.JAXWSUIMessages;
import org.eclipse.jst.ws.internal.jaxws.ui.JAXWSUIPlugin;
import org.eclipse.jst.ws.internal.jaxws.ui.filters.NewHandlerChainViewerFilter;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.TreeColumn;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.ElementTreeSelectionDialog;
import org.eclipse.ui.dialogs.ISelectionStatusValidator;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;

public class OrderHandlerChainPage extends WizardPage {
    private static final String LOGICAL_HANDLER = "javax.xml.ws.handler.LogicalHandler"; //$NON-NLS-1$
    private static final String SOAP_HANDLER = "javax.xml.ws.handler.soap.SOAPHandler"; //$NON-NLS-1$

    private IStatus ok_status = new Status(IStatus.OK, JAXWSUIPlugin.PLUGIN_ID, "");  //$NON-NLS-1$

    private TreeViewer treeViewer;

    private Document doc;
    private Element root;

    private IPath handlerChainPath;
    private IJavaProject javaProject;

    private boolean configure;

    private String newHandlerClassName;
    private String newHandlerType;

    public OrderHandlerChainPage() {
        super("order.handlerchain.wizard.page"); //$NON-NLS-1$
        setTitle(JAXWSUIMessages.JAXWS_ORDER_HANDLER_WIZARD_PAGE_TITLE);
        setDescription(JAXWSUIMessages.JAXWS_ORDER_HANDLER_WIZARD_PAGE_DESCRIPTION);
    }

    public OrderHandlerChainPage(IPath handlerChainPath, IJavaProject javaProject) {
        this();
        this.handlerChainPath = handlerChainPath;
        this.javaProject = javaProject;
        this.configure = true;
    }

    public Document getDocument() {
        return doc;
    }

    public void refreshViewer() {
        treeViewer.refresh();
    }

    public void setSelection(ISelection selection) {
        treeViewer.setSelection(selection, true);
    }

    public void createControl(Composite parent) {
        final Composite composite = new Composite(parent, SWT.NONE);
        GridLayout gridLayout = new GridLayout(2, false);
        composite.setLayout(gridLayout);

        treeViewer = new TreeViewer(composite, SWT.SINGLE | SWT.FULL_SELECTION | SWT.BORDER);
        treeViewer.getTree().setHeaderVisible(true);
        treeViewer.getTree().setLinesVisible(true);
        treeViewer.setContentProvider(new HandlerChainContentProvider());

        TreeViewerColumn nameViewerColumn = new TreeViewerColumn(treeViewer, SWT.LEFT);
        TreeColumn nameColumn = nameViewerColumn.getColumn();
        nameColumn.setWidth(200);
        nameColumn.setMoveable(false);
        nameColumn.setText(JAXWSUIMessages.JAXWS_HANDLER_NAME_COLUMN);

        nameViewerColumn.setLabelProvider(new ColumnLabelProvider() {

            @Override
            public String getText(Object element) {
                if (element instanceof Element) {
                    Element node = (Element) element;
                    if (node.getName().equals(JAXWSHandlerUtils.HANDLER)) {
                        Element handlerNameElement = node.getChild(JAXWSHandlerUtils.HANDLER_NAME, JAXWSHandlerUtils.JAVAEE_NS);
                        if (handlerNameElement != null) {
                            return handlerNameElement.getText().trim();
                        }
                    }
                    if (node.getName().equals(JAXWSHandlerUtils.HANDLER_CHAIN)) {
                        return node.getName();
                    }
                }
                return null;
            }

            @Override
            public Image getImage(Object element) {
                if (element instanceof Element) {
                    return PlatformUI.getWorkbench().getSharedImages().getImage(
                            org.eclipse.ui.ISharedImages.IMG_OBJ_FILE);
                }
                return null;
            }
        });

        TreeViewerColumn classViewerColumn = new TreeViewerColumn(treeViewer, SWT.LEFT);
        TreeColumn classColumn = classViewerColumn.getColumn();
        classColumn.setWidth(200);
        classColumn.setMoveable(false);
        classColumn.setText(JAXWSUIMessages.JAXWS_HANDLER_CLASS_COLUMN);

        classViewerColumn.setLabelProvider(new ColumnLabelProvider() {

            @Override
            public String getText(Object element) {
                if (element instanceof Element) {
                    Element node = (Element) element;
                    if (node.getName().equals(JAXWSHandlerUtils.HANDLER)) {
                        Element handlerNameElement = node.getChild(JAXWSHandlerUtils.HANDLER_CLASS, JAXWSHandlerUtils.JAVAEE_NS);
                        if (handlerNameElement != null) {
                            return handlerNameElement.getText().trim();
                        }
                    }
                }
                return null;
            }
        });

        TreeViewerColumn typeViewerColumn = new TreeViewerColumn(treeViewer, SWT.LEFT);
        TreeColumn typeColumn = typeViewerColumn.getColumn();
        typeColumn.setWidth(100);
        typeColumn.setMoveable(false);
        typeColumn.setText(JAXWSUIMessages.JAXWS_HANDLER_TYPE_COLUMN);

        typeViewerColumn.setLabelProvider(new ColumnLabelProvider() {

            @Override
            public String getText(Object element) {
                if (element instanceof Element) {
                    Element node = (Element) element;
                    if (node.getName().equals(JAXWSHandlerUtils.HANDLER)) {
                        Element handlerClassElement = node.getChild(JAXWSHandlerUtils.HANDLER_CLASS, JAXWSHandlerUtils.JAVAEE_NS);
                        if (handlerClassElement != null) {
                            if (newHandlerClassName != null && newHandlerClassName.equals(handlerClassElement.getValue().trim())) {
                                return newHandlerType;
                            }
                            try {
                                IType handler = javaProject.findType(handlerClassElement.getText().trim());
                                if (handler != null) {
                                    ITypeHierarchy typeHierarchy = handler.newTypeHierarchy(javaProject, null);
                                    IType[] allInterfaces = typeHierarchy.getAllInterfaces();
                                    for (IType aInterface : allInterfaces) {
                                        if (aInterface.getFullyQualifiedName().equals(LOGICAL_HANDLER)) {
                                            return JAXWSUIMessages.JAXWS_LOGICAL;
                                        }
                                        if (aInterface.getFullyQualifiedName().equals(SOAP_HANDLER)) {
                                            return JAXWSUIMessages.JAXWS_PROTOCOL;
                                        }
                                    }
                                }
                            } catch (JavaModelException jme) {
                                JAXWSUIPlugin.log(jme.getStatus());
                            }
                        }
                    }
                }
                return null;
            }
        });

        GridData gridData = new GridData(SWT.FILL, SWT.FILL, true, true);
        gridData.verticalSpan = 6;
        treeViewer.getTree().setLayoutData(gridData);

        if (configure) {
            Button addButton = new Button(composite, SWT.PUSH);
            addButton.setText(JAXWSUIMessages.JAXWS_HANDLER_ADD);
            gridData = new GridData(SWT.FILL, SWT.CENTER, true, false);
            addButton.setLayoutData(gridData);
            addButton.addSelectionListener(new SelectionAdapter() {

                @Override
                public void widgetSelected(SelectionEvent e) {
                    ElementTreeSelectionDialog dialog = new ElementTreeSelectionDialog(getShell(),
                            new JavaElementLabelProvider(), new StandardJavaElementContentProvider());
                    dialog.setTitle(JAXWSUIMessages.JAXWS_HANDLER_CONFIGURATION_HANDLER_DIALOG_TITLE);
                    dialog.setMessage(JAXWSUIMessages.JAXWS_HANDLER_CONFIGURATION_HANDLER_DIALOG_DESCRIPTION);
                    dialog.setAllowMultiple(false);
                    dialog.setInput(JavaCore.create(ResourcesPlugin.getWorkspace().getRoot()));

                    dialog.addFilter(new NewHandlerChainViewerFilter(javaProject, true, false));
                    dialog.setValidator(new ISelectionStatusValidator() {

                        public IStatus validate(Object[] selection) {
                            if (selection.length == 1) {
                                if (selection[0] instanceof ICompilationUnit) {
                                    ICompilationUnit compilationUnit = (ICompilationUnit) selection[0];
                                    if (isHandler(compilationUnit)) {
                                        return ok_status;
                                    } else {
                                        return new Status(IStatus.ERROR, JAXWSUIPlugin.PLUGIN_ID,
                                                JAXWSUIMessages.JAXWS_HANDLER_CONFIGURATION_HANDLER_DIALOG_INVALID);
                                    }
                                }
                            }
                            return new Status(IStatus.ERROR, JAXWSUIPlugin.PLUGIN_ID, ""); //$NON-NLS-1$
                        }
                    });

                    if (dialog.open() == Window.OK) {
                        ICompilationUnit selectedHandler = (ICompilationUnit) dialog.getFirstResult();
                        addHandler(selectedHandler.findPrimaryType().getElementName(),
                                selectedHandler.findPrimaryType().getPackageFragment().getElementName());
                    }

                }
            });

            Button removeButton = new Button(composite, SWT.PUSH);
            removeButton.setText(JAXWSUIMessages.JAXWS_HANDLER_REMOVE);
            gridData = new GridData(SWT.FILL, SWT.CENTER, true, false);
            removeButton.setLayoutData(gridData);
            removeButton.addSelectionListener(new SelectionAdapter() {

                @Override
                public void widgetSelected(SelectionEvent e) {
                    IStructuredSelection selection = (IStructuredSelection) treeViewer.getSelection();
                    if (!selection.isEmpty()) {
                        Element selected = (Element) selection.getFirstElement();
                        if (selected.getName().equals(JAXWSHandlerUtils.HANDLER)) {
                            Element handlerChain = (Element) selected.getParent();
                            if (handlerChain != null) {
                                handlerChain.removeContent(selected);
                                treeViewer.refresh();
                            }
                        }
                    }
                }
            });
        }

        Button moveUpButton = new Button(composite, SWT.PUSH);
        moveUpButton.setText(JAXWSUIMessages.JAXWS_HANDLER_MOVE_UP);
        gridData = new GridData(SWT.FILL, SWT.CENTER, true, false);
        moveUpButton.setLayoutData(gridData);
        moveUpButton.addSelectionListener(new SelectionAdapter() {

            @Override
            @SuppressWarnings("unchecked")
            public void widgetSelected(SelectionEvent e) {
                IStructuredSelection selection = (IStructuredSelection) treeViewer.getSelection();
                if (!selection.isEmpty()) {
                    Element selected = (Element) selection.getFirstElement();
                    Element parent = (Element) selected.getParent();
                    List children = parent.getChildren();
                    int index = children.indexOf(selected);
                    if (index > 0) {
                        children.remove(selected);
                        children.add(index - 1, selected);
                    } else if (index == 0) {
                        Element root = (Element) parent.getParent();
                        List handlerChains = root.getChildren();
                        int topIndex = handlerChains.indexOf(parent);
                        if (topIndex > 0 && handlerChains.get(topIndex - 1) != null) {
                            children.remove(selected);
                            Element topChild = (Element) handlerChains.get(topIndex - 1);
                            topChild.getChildren().add(topChild.getChildren().size(), selected);
                        }
                    }
                    treeViewer.refresh();
                }
            }
        });

        Button moveDownButton = new Button(composite, SWT.PUSH);
        moveDownButton.setText(JAXWSUIMessages.JAXWS_HANDLER_MOVE_DOWN);
        gridData = new GridData(SWT.FILL, SWT.CENTER, true, false);
        moveDownButton.setLayoutData(gridData);
        moveDownButton.addSelectionListener(new SelectionAdapter() {

            @Override
            @SuppressWarnings("unchecked")
            public void widgetSelected(SelectionEvent e) {
                IStructuredSelection selection = (IStructuredSelection) treeViewer.getSelection();
                if (!selection.isEmpty()) {
                    Element selected = (Element) selection.getFirstElement();
                    Element parent = (Element) selected.getParent();
                    List children = parent.getChildren();
                    int index = children.indexOf(selected);
                    if (index >= 0 && index < children.size() - 1) {
                        children.remove(selected);
                        children.add(index + 1, selected);
                    } else if (index == children.size() - 1) {
                        Element root = (Element) parent.getParent();
                        List handlerChains = root.getChildren();
                        int hIndex = handlerChains.indexOf(parent);
                        if (hIndex >= 0 && hIndex < handlerChains.size() - 1 && handlerChains.get(hIndex + 1) != null) {
                            children.remove(selected);
                            Element topChild = (Element) handlerChains.get(hIndex + 1);
                            topChild.getChildren().add(0, selected);
                        }
                    }
                    treeViewer.refresh();
                }
            }
        });

        if (handlerChainPath != null) {
            setInput(handlerChainPath);
        }

        treeViewer.expandAll();

        composite.pack();
        setControl(composite);
        Dialog.applyDialogFont(composite);
    }


    @Override
    public void setVisible(boolean visible) {
        super.setVisible(visible);
        if (visible) {
            setInput(handlerChainPath);
        }
    }

    public void setHandlerChainPath(IPath handlerChainPath) {
        this.handlerChainPath = handlerChainPath;
    }

    private boolean isHandler(ICompilationUnit source) {
        final List<String> interfaces = new ArrayList<String>();
        ASTParser parser = ASTParser.newParser(AST.JLS3);
        parser.setSource(source);
        parser.setResolveBindings(true);
        CompilationUnit compilationUnit = (CompilationUnit) parser.createAST(null);
        compilationUnit.accept(new ASTVisitor() {
            @Override
            public boolean visit(TypeDeclaration typeDeclaration) {
                @SuppressWarnings("unchecked")
                List superInterfaces = typeDeclaration.superInterfaceTypes();
                for (Object object : superInterfaces) {
                    if (object instanceof ParameterizedType) {
                        ParameterizedType parameterizedType = (ParameterizedType) object;
                        ITypeBinding binding = parameterizedType.resolveBinding();
                        if (binding != null) {
                            String qualifiedName = binding.getErasure().getQualifiedName();
                            if (qualifiedName.equals(LOGICAL_HANDLER) || qualifiedName.equals(SOAP_HANDLER)) {
                                interfaces.add(qualifiedName);
                                break;
                            }
                        }
                    }
                }
                return false;
            }
        });
        return interfaces.size() > 0;
    }

    public void setInput(IPath handlerChainPath) {
        if (handlerChainPath == null) {
            return;
        }
        if (!handlerChainPath.isEmpty()) {
            try {
                IFile handlerChainFile = ResourcesPlugin.getWorkspace().getRoot().getFile(handlerChainPath);
                if (handlerChainFile.getFileExtension().equals("xml")) { //$NON-NLS-1$
                    if (handlerChainFile.exists() && JAXWSHandlerUtils.isHandlerChainFile(handlerChainFile)) {
                        FileInputStream handlerInputStream = new FileInputStream(handlerChainFile.getLocation().toFile());
                        SAXBuilder builder = new SAXBuilder();
                        doc = builder.build(handlerInputStream);
                        root = doc.getRootElement();
                        treeViewer.setInput(root);
                        treeViewer.expandAll();
                    } else {
                        JAXWSHandlerUtils.createHandlerChainFile(handlerChainPath);
                        setInput(handlerChainPath);
                    }
                }
            } catch (IOException ioe) {
                JAXWSUIPlugin.log(ioe);
            } catch (JDOMException jdome) {
                JAXWSUIPlugin.log(jdome);
            }
        }
    }

    public void setJavaProject(IJavaProject javaProject) {
        this.javaProject = javaProject;
    }

    public void addHandler(String newHandlerName, String packageName) {
        if (root != null) {
            Element handlerChainElement = root.getChild(JAXWSHandlerUtils.HANDLER_CHAIN, JAXWSHandlerUtils.JAVAEE_NS);
            if (handlerChainElement == null) {
                handlerChainElement = new Element(JAXWSHandlerUtils.HANDLER_CHAIN, JAXWSHandlerUtils.JAVAEE_NS);
                root.addContent(handlerChainElement);
            }
            Element handlerElement = new Element(JAXWSHandlerUtils.HANDLER, JAXWSHandlerUtils.JAVAEE_NS);

            Element handlerNameElement = new Element(JAXWSHandlerUtils.HANDLER_NAME, JAXWSHandlerUtils.JAVAEE_NS);
            handlerNameElement.setText(newHandlerName);

            Element handlerClassElement = new Element(JAXWSHandlerUtils.HANDLER_CLASS, JAXWSHandlerUtils.JAVAEE_NS);
            if (packageName.trim().length() > 0) {
                handlerClassElement.setText(packageName + "." + newHandlerName);
            } else {
                handlerClassElement.setText(newHandlerName);
            }

            handlerElement.addContent(handlerNameElement);
            handlerElement.addContent(handlerClassElement);
            handlerChainElement.addContent(handlerElement);
            treeViewer.refresh();
            treeViewer.setSelection(new StructuredSelection(handlerElement));
        }
    }

    public void addHandler(String newHandlerName, String packageName, String newHandlerType) {
        addHandler(newHandlerName, packageName);
        this.newHandlerClassName = packageName + "." + newHandlerName;
        this.newHandlerType = newHandlerType;
        if (newHandlerType.equals(JAXWSUIMessages.JAXWS_LOGICAL_HANDLER)) {
            this.newHandlerType = JAXWSUIMessages.JAXWS_LOGICAL;
        } else if (newHandlerType.equals(JAXWSUIMessages.JAXWS_SOAP_HANDLER)) {
            this.newHandlerType = JAXWSUIMessages.JAXWS_PROTOCOL;
        }
    }

    private class HandlerChainContentProvider implements ITreeContentProvider {

        public Object[] getChildren(Object parentElement) {
            if (parentElement instanceof Element) {
                Element element = (Element) parentElement;
                return element.getChildren().toArray();
            }
            return new Object[] {};
        }

        public Object getParent(Object element) {
            if (element instanceof Element) {
                Element node = (Element) element;
                return node.getParent();
            }
            return null;
        }

        public boolean hasChildren(Object element) {
            if (element instanceof Element) {
                Element node = (Element) element;
                if (node.getName().equals(JAXWSHandlerUtils.HANDLER_CHAIN)) {
                    return node.getChildren().size() > 0;
                }
            }
            return false;
        }

        public Object[] getElements(Object inputElement) {
            if (inputElement instanceof Element) {
                Element element = (Element) inputElement;
                return element.getChildren().toArray();
            }
            return new Object[] {};
        }

        public void dispose() {
        }

        public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
        }
    }

}