plugins/org.argeo.slc.client.ui.dist/src/main/java/org/argeo/slc/client/ui/dist/editors/DistWkspBrowserPage.java

   1 /*
   2  * Copyright (C) 2007-2012 Argeo GmbH
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *         http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.argeo.slc.client.ui.dist.editors;
  17
  18 import java.util.ArrayList;
  19 import java.util.List;
  20
  21 import javax.jcr.Node;
  22 import javax.jcr.NodeIterator;
  23 import javax.jcr.RepositoryException;
  24 import javax.jcr.Session;
  25 import javax.jcr.query.QueryManager;
  26 import javax.jcr.query.QueryResult;
  27 import javax.jcr.query.qom.Ordering;
  28 import javax.jcr.query.qom.QueryObjectModel;
  29 import javax.jcr.query.qom.QueryObjectModelFactory;
  30 import javax.jcr.query.qom.Selector;
  31
  32 import org.argeo.ArgeoException;
  33 import org.argeo.jcr.JcrUtils;
  34 import org.argeo.slc.SlcException;
  35 import org.argeo.slc.client.ui.dist.DistConstants;
  36 import org.argeo.slc.client.ui.dist.DistImages;
  37 import org.argeo.slc.client.ui.dist.DistPlugin;
  38 import org.argeo.slc.jcr.SlcNames;
  39 import org.argeo.slc.jcr.SlcTypes;
  40 import org.argeo.slc.repo.RepoConstants;
  41 import org.eclipse.jface.viewers.ColumnLabelProvider;
  42 import org.eclipse.jface.viewers.DoubleClickEvent;
  43 import org.eclipse.jface.viewers.IDoubleClickListener;
  44 import org.eclipse.jface.viewers.IStructuredSelection;
  45 import org.eclipse.jface.viewers.ITreeContentProvider;
  46 import org.eclipse.jface.viewers.TreeViewer;
  47 import org.eclipse.jface.viewers.Viewer;
  48 import org.eclipse.swt.SWT;
  49 import org.eclipse.swt.graphics.Image;
  50 import org.eclipse.swt.layout.FillLayout;
  51 import org.eclipse.swt.widgets.Composite;
  52 import org.eclipse.swt.widgets.Tree;
  53 import org.eclipse.swt.widgets.TreeColumn;
  54 import org.eclipse.ui.PartInitException;
  55 import org.eclipse.ui.forms.IManagedForm;
  56 import org.eclipse.ui.forms.editor.FormEditor;
  57 import org.eclipse.ui.forms.editor.FormPage;
  58 import org.eclipse.ui.forms.widgets.ScrolledForm;
  59
  60 /**
  61  * Expose Maven artifacts of a given workspace as a tree. Artifacts are grouped
  62  * by Maven group.
  63  */
  64 public class DistWkspBrowserPage extends FormPage implements DistConstants,
  65                 RepoConstants {
  66         // private final static Log log = LogFactory
  67         // .getLog(ArtifactsBrowserPage.class);
  68
  69         final static String PAGE_ID = "artifactsBrowserPage";
  70
  71         // Business object
  72         private Session session;
  73
  74         // This page widgets
  75         private TreeViewer artifactTreeViewer;
  76
  77         public DistWkspBrowserPage(FormEditor editor, String title, Session session) {
  78                 super(editor, PAGE_ID, title);
  79                 this.session = session;
  80         }
  81
  82         @Override
  83         protected void createFormContent(IManagedForm managedForm) {
  84                 try {
  85                         ScrolledForm form = managedForm.getForm();
  86                         Composite parent = form.getBody();
  87                         parent.setLayout(new FillLayout());
  88                         createExportPackageSection(parent);
  89                         getEditor().getSite().setSelectionProvider(artifactTreeViewer);
  90                 } catch (RepositoryException e) {
  91                         throw new SlcException("Cannot create artifact browser page", e);
  92                 }
  93         }
  94
  95         private NodeIterator listNodes(String nodeType, String orderBy)
  96                         throws RepositoryException {
  97                 QueryManager queryManager = session.getWorkspace().getQueryManager();
  98                 QueryObjectModelFactory factory = queryManager.getQOMFactory();
  99
 100                 final String nodeSelector = "nodes";
 101                 Selector source = factory.selector(nodeType, nodeSelector);
 102
 103                 Ordering order = factory.ascending(factory.propertyValue(nodeSelector,
 104                                 orderBy));
 105                 Ordering[] orderings = { order };
 106
 107                 QueryObjectModel query = factory.createQuery(source, null, orderings,
 108                                 null);
 109
 110                 QueryResult result = query.execute();
 111
 112                 return result.getNodes();
 113         }
 114
 115         /** Export Package Section */
 116         private void createExportPackageSection(Composite parent)
 117                         throws RepositoryException {
 118
 119                 int style = SWT.SINGLE | SWT.H_SCROLL | SWT.V_SCROLL
 120                                 | SWT.FULL_SELECTION | SWT.BORDER;
 121                 Tree tree = new Tree(parent, style);
 122                 createColumn(tree, "Artifacts", SWT.LEFT, 300);
 123                 tree.setLinesVisible(true);
 124                 tree.setHeaderVisible(true);
 125
 126                 artifactTreeViewer = new TreeViewer(tree);
 127
 128                 artifactTreeViewer.setLabelProvider(new ColumnLabelProvider() {
 129                         @Override
 130                         public String getText(Object element) {
 131                                 Node node = (Node) element;
 132                                 try {
 133                                         if (node.isNodeType(SlcTypes.SLC_GROUP_BASE))
 134                                                 return JcrUtils.get((Node) element,
 135                                                                 SlcNames.SLC_GROUP_BASE_ID);
 136                                         else if (node.isNodeType(SlcTypes.SLC_ARTIFACT_BASE))
 137                                                 return JcrUtils.get((Node) element,
 138                                                                 SlcNames.SLC_ARTIFACT_ID);
 139                                         else
 140                                                 return node.getName();
 141                                 } catch (RepositoryException e) {
 142                                         throw new SlcException("Cannot browse artifacts", e);
 143                                 }
 144                         }
 145
 146                         @Override
 147                         public Image getImage(Object element) {
 148                                 Node node = (Node) element;
 149                                 try {
 150
 151                                         if (node.isNodeType(SlcTypes.SLC_GROUP_BASE))
 152                                                 return DistImages.IMG_GROUP_BASE;
 153                                         else if (node.isNodeType(SlcTypes.SLC_ARTIFACT_BASE))
 154                                                 return DistImages.IMG_ARTIFACT_BASE;
 155                                         else if (node
 156                                                         .isNodeType(SlcTypes.SLC_ARTIFACT_VERSION_BASE))
 157                                                 return DistImages.IMG_ARTIFACT_VERSION_BASE;
 158                                         else
 159                                                 return null;
 160                                 } catch (RepositoryException e) {
 161                                         throw new SlcException("Cannot get images for artifacts", e);
 162                                 }
 163                         }
 164                 });
 165
 166                 artifactTreeViewer.setContentProvider(new ITreeContentProvider() {
 167
 168                         public void dispose() {
 169                         }
 170
 171                         public void inputChanged(Viewer viewer, Object oldInput,
 172                                         Object newInput) {
 173                         }
 174
 175                         public Object[] getElements(Object inputElement) {
 176                                 try {
 177                                         List<Node> nodes = JcrUtils.nodeIteratorToList(listNodes(
 178                                                         SlcTypes.SLC_GROUP_BASE, SlcNames.SLC_NAME));
 179                                         return nodes.toArray();
 180                                 } catch (RepositoryException e) {
 181                                         throw new SlcException("Cannot list children Nodes", e);
 182                                 }
 183                         }
 184
 185                         public Object[] getChildren(Object parentElement) {
 186                                 // Only 3 levels for the time being
 187                                 try {
 188                                         Node pNode = (Node) parentElement;
 189                                         if (pNode.isNodeType(SlcTypes.SLC_GROUP_BASE)) {
 190                                                 return getArtifactBase(pNode,
 191                                                                 SlcTypes.SLC_ARTIFACT_BASE);
 192                                         } else if (pNode.isNodeType(SlcTypes.SLC_ARTIFACT_BASE)) {
 193                                                 return getArtifactBase(pNode,
 194                                                                 SlcTypes.SLC_ARTIFACT_VERSION_BASE);
 195                                         }
 196                                         return null;
 197                                 } catch (RepositoryException e) {
 198                                         throw new SlcException("Cannot list children Nodes", e);
 199                                 }
 200                         }
 201
 202                         // Helper to get children because current version of Jackrabbit is
 203                         // buggy in remote
 204                         private Object[] getArtifactBase(Node parent, String nodeType)
 205                                         throws RepositoryException {
 206                                 List<Node> nodes = new ArrayList<Node>();
 207                                 NodeIterator ni = parent.getNodes();
 208                                 while (ni.hasNext()) {
 209                                         Node node = ni.nextNode();
 210                                         if (node.isNodeType(nodeType))
 211                                                 nodes.add(node);
 212                                 }
 213                                 return nodes.toArray();
 214                         }
 215
 216                         public Object getParent(Object element) {
 217                                 return null;
 218                         }
 219
 220                         public boolean hasChildren(Object element) {
 221                                 try {
 222                                         Node pNode = (Node) element;
 223                                         if (pNode.isNodeType(SlcTypes.SLC_GROUP_BASE)
 224                                                         || pNode.isNodeType(SlcTypes.SLC_ARTIFACT_BASE)) {
 225                                                 // might return true even if there is no "valid" child
 226                                                 return pNode.hasNodes();
 227                                         } else
 228                                                 return false;
 229                                 } catch (RepositoryException e) {
 230                                         throw new SlcException("Cannot check children Nodes", e);
 231                                 }
 232                         }
 233                 });
 234
 235                 artifactTreeViewer.addDoubleClickListener(new DoubleClickListener());
 236
 237                 artifactTreeViewer.setInput("Initialize");
 238         }
 239
 240         private class DoubleClickListener implements IDoubleClickListener {
 241
 242                 public void doubleClick(DoubleClickEvent event) {
 243                         Object obj = ((IStructuredSelection) event.getSelection())
 244                                         .getFirstElement();
 245                         try {
 246                                 if (obj instanceof Node) {
 247                                         Node node = (Node) obj;
 248                                         if (node.isNodeType(SlcTypes.SLC_ARTIFACT_VERSION_BASE)) {
 249                                                 // TODO fix using QOM after jcr upgrade
 250                                                 NodeIterator ni = node.getNodes();
 251                                                 while (ni.hasNext()) {
 252                                                         Node curr = ni.nextNode();
 253                                                         if (curr.isNodeType(SlcTypes.SLC_BUNDLE_ARTIFACT)) {
 254                                                                 GenericBundleEditorInput gaei = new GenericBundleEditorInput(
 255                                                                                 curr);
 256                                                                 DistPlugin
 257                                                                                 .getDefault()
 258                                                                                 .getWorkbench()
 259                                                                                 .getActiveWorkbenchWindow()
 260                                                                                 .getActivePage()
 261                                                                                 .openEditor(gaei,
 262                                                                                                 GenericBundleEditor.ID);
 263                                                         }
 264                                                 }
 265                                         }
 266                                 }
 267                         } catch (RepositoryException re) {
 268                                 throw new ArgeoException(
 269                                                 "Repository error while getting node info", re);
 270                         } catch (PartInitException pie) {
 271                                 throw new ArgeoException(
 272                                                 "Unexepected exception while opening artifact editor",
 273                                                 pie);
 274                         }
 275                 }
 276         }
 277
 278         private static TreeColumn createColumn(Tree parent, String name, int style,
 279                         int width) {
 280                 TreeColumn result = new TreeColumn(parent, style);
 281                 result.setText(name);
 282                 result.setWidth(width);
 283                 result.setMoveable(true);
 284                 result.setResizable(true);
 285                 return result;
 286         }
 287
 288 }