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