plugins/org.argeo.slc.client.ui.dist/src/main/java/org/argeo/slc/client/ui/dist/editors/BundleDetailsPage.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.List;
  19
  20 import javax.jcr.Node;
  21 import javax.jcr.NodeIterator;
  22 import javax.jcr.RepositoryException;
  23 import javax.jcr.query.QueryManager;
  24 import javax.jcr.query.QueryResult;
  25 import javax.jcr.query.qom.Constraint;
  26 import javax.jcr.query.qom.Ordering;
  27 import javax.jcr.query.qom.QueryObjectModel;
  28 import javax.jcr.query.qom.QueryObjectModelFactory;
  29 import javax.jcr.query.qom.Selector;
  30
  31 import org.argeo.ArgeoException;
  32 import org.argeo.eclipse.ui.ErrorFeedback;
  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.jcr.SlcNames;
  37 import org.argeo.slc.jcr.SlcTypes;
  38 import org.eclipse.jface.viewers.ColumnLabelProvider;
  39 import org.eclipse.jface.viewers.IStructuredContentProvider;
  40 import org.eclipse.jface.viewers.ITreeContentProvider;
  41 import org.eclipse.jface.viewers.TableLayout;
  42 import org.eclipse.jface.viewers.TableViewer;
  43 import org.eclipse.jface.viewers.TableViewerColumn;
  44 import org.eclipse.jface.viewers.TreeViewer;
  45 import org.eclipse.jface.viewers.TreeViewerColumn;
  46 import org.eclipse.jface.viewers.Viewer;
  47 import org.eclipse.swt.SWT;
  48 import org.eclipse.swt.graphics.Image;
  49 import org.eclipse.swt.layout.GridData;
  50 import org.eclipse.swt.layout.GridLayout;
  51 import org.eclipse.swt.widgets.Composite;
  52 import org.eclipse.swt.widgets.Table;
  53 import org.eclipse.swt.widgets.Text;
  54 import org.eclipse.swt.widgets.Tree;
  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.FormToolkit;
  59 import org.eclipse.ui.forms.widgets.ScrolledForm;
  60 import org.eclipse.ui.forms.widgets.Section;
  61
  62 /**
  63  * Presents main information of a given OSGI bundle
  64  */
  65
  66 public class BundleDetailsPage extends FormPage implements SlcNames, SlcTypes {
  67         // private final static Log log =
  68         // LogFactory.getLog(ArtifactDetailsPage.class);
  69
  70         // Main business Objects
  71         private Node currBundle;
  72
  73         // This page widgets
  74         private Text mavenSnippet;
  75         private FormToolkit toolkit;
  76
  77         public BundleDetailsPage(FormEditor editor, String title, Node currentNode) {
  78                 super(editor, "id", title);
  79                 this.currBundle = currentNode;
  80         }
  81
  82         protected void createFormContent(IManagedForm managedForm) {
  83                 ScrolledForm form = managedForm.getForm();
  84                 toolkit = managedForm.getToolkit();
  85                 try {
  86                         form.setText(currBundle.hasProperty(DistConstants.SLC_BUNDLE_NAME) ? currBundle
  87                                         .getProperty(DistConstants.SLC_BUNDLE_NAME).getString()
  88                                         : "");
  89                         Composite body = form.getBody();
  90                         GridLayout layout = new GridLayout(1, false);
  91                         layout.marginWidth = 5;
  92                         layout.verticalSpacing = 15;
  93
  94                         body.setLayout(layout);
  95                         createdetailsPart(body);
  96
  97                         createExportPackageSection(body);
  98                         createImportPackageSection(body);
  99                         createReqBundleSection(body);
 100                         createMavenSnipet(body);
 101
 102                 } catch (RepositoryException e) {
 103                         throw new SlcException("unexpected error "
 104                                         + "while creating bundle details page");
 105                 }
 106         }
 107
 108         /** Add useful info for the current bundle */
 109         private void createdetailsPart(Composite parent) throws RepositoryException {
 110                 Composite details = toolkit.createComposite(parent);
 111                 GridLayout layout = new GridLayout(2, false);
 112                 layout.horizontalSpacing = 20;
 113                 details.setLayout(layout);
 114
 115                 createField(details, "Symbolic name", SlcNames.SLC_SYMBOLIC_NAME);
 116                 createField(details, "Version", SlcNames.SLC_BUNDLE_VERSION);
 117                 createField(details, "Group Id", SlcNames.SLC_GROUP_ID);
 118                 // Single sourcing issue: this does not works with rap
 119                 // createHyperlink(details, "Licence",
 120                 // DistConstants.SLC_BUNDLE_LICENCE);
 121                 createField(details, "Licence", DistConstants.SLC_BUNDLE_LICENCE);
 122
 123                 createField(details, "Vendor", DistConstants.SLC_BUNDLE_VENDOR);
 124
 125         }
 126
 127         /** Import Package Section */
 128         private void createExportPackageSection(Composite parent)
 129                         throws RepositoryException {
 130
 131                 // Define the TableViewer
 132                 Section headerSection = addSection(parent, "Export packages");
 133                 // TreeViewer viewer = new TreeViewer(parent, SWT.MULTI | SWT.H_SCROLL
 134                 // | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.BORDER);
 135                 TreeViewer viewer = new TreeViewer(headerSection, SWT.MULTI
 136                                 | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.BORDER);
 137
 138                 final Tree tree = viewer.getTree();
 139                 tree.setHeaderVisible(false);
 140                 tree.setLinesVisible(true);
 141                 GridData gd = new GridData(SWT.LEFT, SWT.TOP, true, true);
 142                 gd.heightHint = 300;
 143                 tree.setLayoutData(gd);
 144
 145                 TreeViewerColumn col = new TreeViewerColumn(viewer, SWT.FILL);
 146                 col.getColumn().setWidth(200);
 147
 148                 col.setLabelProvider(new ColumnLabelProvider() {
 149                         @Override
 150                         public String getText(Object element) {
 151                                 return JcrUtils.get((Node) element, SlcNames.SLC_NAME);
 152                         }
 153
 154                         @Override
 155                         public Image getImage(Object element) {
 156                                 return null;
 157                         }
 158                 });
 159
 160                 viewer.setContentProvider(new ITreeContentProvider() {
 161
 162                         public void dispose() {
 163                         }
 164
 165                         public void inputChanged(Viewer viewer, Object oldInput,
 166                                         Object newInput) {
 167                         }
 168
 169                         public Object[] getElements(Object inputElement) {
 170                                 try {
 171                                         List<Node> nodes = JcrUtils.nodeIteratorToList(listNodes(
 172                                                         currBundle, SlcTypes.SLC_EXPORTED_PACKAGE,
 173                                                         SlcNames.SLC_NAME));
 174                                         return nodes.toArray();
 175                                 } catch (RepositoryException e) {
 176                                         throw new SlcException("Cannot list children Nodes", e);
 177                                 }
 178                         }
 179
 180                         public Object[] getChildren(Object parentElement) {
 181                                 // Only 2 levels for the time being
 182                                 try {
 183                                         Node pNode = (Node) parentElement;
 184                                         if (pNode.isNodeType(SlcTypes.SLC_EXPORTED_PACKAGE)) {
 185                                                 List<Node> nodes = JcrUtils
 186                                                                 .nodeIteratorToList(listNodes(pNode,
 187                                                                                 SlcTypes.SLC_JAVA_PACKAGE,
 188                                                                                 SlcNames.SLC_NAME));
 189                                                 return nodes.toArray();
 190                                         } else
 191                                                 return null;
 192                                 } catch (RepositoryException e) {
 193                                         throw new SlcException("Cannot list children Nodes", e);
 194                                 }
 195                         }
 196
 197                         public Object getParent(Object element) {
 198                                 // useless
 199                                 return null;
 200                         }
 201
 202                         public boolean hasChildren(Object element) {
 203                                 try {
 204                                         Node pNode = (Node) element;
 205                                         if (pNode.isNodeType(SlcTypes.SLC_EXPORTED_PACKAGE)) {
 206                                                 // might return true even if there is no "valid" child
 207                                                 return pNode.hasNodes();
 208                                         } else
 209                                                 return false;
 210                                 } catch (RepositoryException e) {
 211                                         throw new SlcException("Cannot check children Nodes", e);
 212                                 }
 213                         }
 214                 });
 215
 216                 headerSection.setClient(tree);
 217                 viewer.setInput("Initialize");
 218         }
 219
 220         /** Import Package Section */
 221         private void createImportPackageSection(Composite parent)
 222                         throws RepositoryException {
 223
 224                 // Define the TableViewer
 225                 Section headerSection = addSection(parent, "Import packages");
 226                 TableViewer viewer = new TableViewer(headerSection, SWT.MULTI
 227                                 | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.BORDER);
 228
 229                 // Name
 230                 TableViewerColumn col = new TableViewerColumn(viewer, SWT.NONE);
 231                 col.getColumn().setWidth(300);
 232                 col.getColumn().setText("Name");
 233                 col.setLabelProvider(new ColumnLabelProvider() {
 234                         @Override
 235                         public String getText(Object element) {
 236                                 return JcrUtils.get((Node) element, SLC_NAME);
 237                         }
 238                 });
 239
 240                 // Version
 241                 col = new TableViewerColumn(viewer, SWT.NONE);
 242                 col.getColumn().setWidth(100);
 243                 col.getColumn().setText("Version");
 244                 col.setLabelProvider(new ColumnLabelProvider() {
 245                         @Override
 246                         public String getText(Object element) {
 247                                 return JcrUtils.get((Node) element, SLC_VERSION);
 248                         }
 249                 });
 250
 251                 // Optional
 252                 col = new TableViewerColumn(viewer, SWT.NONE);
 253                 col.getColumn().setWidth(100);
 254                 col.getColumn().setText("Optional");
 255                 col.setLabelProvider(new ColumnLabelProvider() {
 256                         @Override
 257                         public String getText(Object element) {
 258                                 return JcrUtils.get((Node) element, SLC_OPTIONAL);
 259                         }
 260                 });
 261
 262                 final Table table = viewer.getTable();
 263                 table.setHeaderVisible(true);
 264                 table.setLinesVisible(true);
 265                 GridData gd = new GridData(SWT.LEFT, SWT.TOP, true, true);
 266                 gd.heightHint = 300;
 267                 table.setLayoutData(gd);
 268
 269                 viewer.setContentProvider(new TableContentProvider(
 270                                 SLC_IMPORTED_PACKAGE, SLC_NAME));
 271                 headerSection.setClient(viewer.getTable());
 272
 273                 viewer.setInput("Initialize");
 274         }
 275
 276         /** Required Bundle Section */
 277         private void createReqBundleSection(Composite parent)
 278                         throws RepositoryException {
 279
 280                 // Define the TableViewer
 281                 Section headerSection = addSection(parent, "Required bundles");
 282                 TableViewer viewer = new TableViewer(headerSection, SWT.MULTI
 283                                 | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.BORDER);
 284
 285                 // Name
 286                 TableViewerColumn col = new TableViewerColumn(viewer, SWT.NONE);
 287                 col.getColumn().setWidth(300);
 288                 col.getColumn().setText("Name");
 289                 col.setLabelProvider(new ColumnLabelProvider() {
 290                         @Override
 291                         public String getText(Object element) {
 292                                 return JcrUtils.get((Node) element, SLC_SYMBOLIC_NAME);
 293                         }
 294                 });
 295
 296                 // Version
 297                 col = new TableViewerColumn(viewer, SWT.NONE);
 298                 col.getColumn().setWidth(100);
 299                 col.getColumn().setText("Version");
 300                 col.setLabelProvider(new ColumnLabelProvider() {
 301                         @Override
 302                         public String getText(Object element) {
 303                                 return JcrUtils.get((Node) element, SLC_BUNDLE_VERSION);
 304                         }
 305                 });
 306
 307                 // Version
 308                 col = new TableViewerColumn(viewer, SWT.NONE);
 309                 col.getColumn().setWidth(100);
 310                 col.getColumn().setText("Optional");
 311                 col.setLabelProvider(new ColumnLabelProvider() {
 312                         @Override
 313                         public String getText(Object element) {
 314                                 return JcrUtils.get((Node) element, SLC_OPTIONAL);
 315                         }
 316                 });
 317
 318                 final Table table = viewer.getTable();
 319                 table.setHeaderVisible(true);
 320                 table.setLinesVisible(true);
 321
 322                 viewer.setContentProvider(new TableContentProvider(SLC_REQUIRED_BUNDLE,
 323                                 SLC_SYMBOLIC_NAME));
 324                 headerSection.setClient(viewer.getTable());
 325
 326                 viewer.setInput("Initialize");
 327         }
 328
 329         /** Build repository request */
 330         private NodeIterator listNodes(Node parent, String nodeType, String orderBy)
 331                         throws RepositoryException {
 332                 QueryManager queryManager = currBundle.getSession().getWorkspace()
 333                                 .getQueryManager();
 334                 QueryObjectModelFactory factory = queryManager.getQOMFactory();
 335
 336                 final String nodeSelector = "nodes";
 337                 Selector source = factory.selector(nodeType, nodeSelector);
 338
 339                 Constraint childOf = factory.childNode(nodeSelector, parent.getPath());
 340
 341                 Ordering order = factory.ascending(factory.propertyValue(nodeSelector,
 342                                 orderBy));
 343                 Ordering[] orderings = { order };
 344
 345                 QueryObjectModel query = factory.createQuery(source, childOf,
 346                                 orderings, null);
 347
 348                 QueryResult result = query.execute();
 349                 return result.getNodes();
 350
 351         }
 352
 353         private class TableContentProvider implements IStructuredContentProvider {
 354                 private String nodeType;
 355                 private String orderBy;
 356
 357                 TableContentProvider(String nodeType, String orderBy) {
 358                         this.nodeType = nodeType;
 359                         this.orderBy = orderBy;
 360                 }
 361
 362                 public void dispose() {
 363                 }
 364
 365                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 366                 }
 367
 368                 public Object[] getElements(Object arg0) {
 369                         try {
 370                                 List<Node> nodes = JcrUtils.nodeIteratorToList(listNodes(
 371                                                 currBundle, nodeType, orderBy));
 372                                 return nodes.toArray();
 373                         } catch (RepositoryException e) {
 374                                 ErrorFeedback.show("Cannot list children Nodes", e);
 375                                 return null;
 376                         }
 377                 }
 378         }
 379
 380         /* HELPERS */
 381         private void createField(Composite parent, String label, String jcrPropName)
 382                         throws RepositoryException {
 383                 toolkit.createLabel(parent, label, SWT.NONE);
 384                 Text txt = toolkit.createText(parent, "", SWT.SINGLE);
 385                 txt.setText(currBundle.hasProperty(jcrPropName) ? currBundle
 386                                 .getProperty(jcrPropName).getString() : "");
 387                 txt.setEditable(false);
 388                 GridData gd = new GridData(SWT.FILL, SWT.TOP, true, false);
 389                 txt.setLayoutData(gd);
 390         }
 391
 392         private Section addSection(Composite parent, String title) {
 393                 Section section = toolkit.createSection(parent, Section.TWISTIE);
 394                 section.setText(title);
 395                 section.setExpanded(false);
 396                 GridData gd = new GridData(SWT.FILL, SWT.FILL, false, false);
 397                 section.setLayoutData(gd);
 398                 Composite body = new Composite(section, SWT.FILL);
 399                 section.setClient(body);
 400                 // Layout
 401                 body.setLayout(new TableLayout());
 402                 return section;
 403         }
 404
 405         // private void createHyperlink(Composite parent, String label,
 406         // String jcrPropName) throws RepositoryException {
 407         // toolkit.createLabel(parent, label, SWT.NONE);
 408         // if (currBundle.hasProperty(jcrPropName)) {
 409         // final Hyperlink link = toolkit.createHyperlink(parent, currBundle
 410         // .getProperty(jcrPropName).getString(), SWT.NONE);
 411         // link.addHyperlinkListener(new AbstractHyperlinkListener() {
 412         // @Override
 413         // public void linkActivated(HyperlinkEvent e) {
 414         // try {
 415         // IWorkbenchBrowserSupport browserSupport = PlatformUI
 416         // .getWorkbench().getBrowserSupport();
 417         // IWebBrowser browser = browserSupport
 418         // .createBrowser(
 419         // IWorkbenchBrowserSupport.LOCATION_BAR
 420         // | IWorkbenchBrowserSupport.NAVIGATION_BAR,
 421         // "SLC Distribution browser",
 422         // "SLC Distribution browser",
 423         // "A tool tip");
 424         // browser.openURL(new URL(link.getText()));
 425         // } catch (Exception ex) {
 426         //                                              throw new SlcException("error opening browser", ex); //$NON-NLS-1$
 427         // }
 428         // }
 429         // });
 430         // } else
 431         // toolkit.createLabel(parent, "", SWT.NONE);
 432         // }
 433
 434         /** Creates a text area with corresponding maven snippet */
 435         private void createMavenSnipet(Composite parent) {
 436                 mavenSnippet = new Text(parent, SWT.MULTI | SWT.WRAP | SWT.BORDER);
 437                 GridData gd = new GridData(GridData.FILL_HORIZONTAL);
 438                 gd.grabExcessHorizontalSpace = true;
 439                 gd.heightHint = 100;
 440                 mavenSnippet.setLayoutData(gd);
 441                 mavenSnippet.setText(generateXmlSnippet());
 442         }
 443
 444         // Helpers
 445         private String generateXmlSnippet() {
 446                 try {
 447                         StringBuffer sb = new StringBuffer();
 448                         sb.append("<dependency>\n");
 449                         sb.append("\t<groupeId>");
 450                         sb.append(currBundle.getProperty(SLC_GROUP_ID).getString());
 451                         sb.append("</groupeId>\n");
 452                         sb.append("\t<artifactId>");
 453                         sb.append(currBundle.getProperty(SLC_ARTIFACT_ID).getString());
 454                         sb.append("</artifactId>\n");
 455                         sb.append("\t<version>");
 456                         sb.append(currBundle.getProperty(SLC_ARTIFACT_VERSION).getString());
 457                         sb.append("</version>\n");
 458                         sb.append("</dependency>");
 459                         return sb.toString();
 460                 } catch (RepositoryException re) {
 461                         throw new ArgeoException(
 462                                         "unexpected error while generating maven snippet");
 463                 }
 464         }
 465 }