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