editors/DistWkspBrowserPage.java

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