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                 //createHyperlink(details, "Licence", DistConstants.SLC_BUNDLE_LICENCE);
 119                 createField(details, "Vendor", DistConstants.SLC_BUNDLE_VENDOR);
 120
 121         }
 122
 123         /** Import Package Section */
 124         private void createExportPackageSection(Composite parent)
 125                         throws RepositoryException {
 126
 127                 // Define the TableViewer
 128                 Section headerSection = addSection(parent, "Export packages");
 129                 // TreeViewer viewer = new TreeViewer(parent, SWT.MULTI | SWT.H_SCROLL
 130                 // | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.BORDER);
 131                 TreeViewer viewer = new TreeViewer(headerSection, SWT.MULTI
 132                                 | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.BORDER);
 133
 134                 final Tree tree = viewer.getTree();
 135                 tree.setHeaderVisible(false);
 136                 tree.setLinesVisible(true);
 137                 GridData gd = new GridData(SWT.LEFT, SWT.TOP, true, true);
 138                 gd.heightHint = 300;
 139                 tree.setLayoutData(gd);
 140
 141                 TreeViewerColumn col = new TreeViewerColumn(viewer, SWT.FILL);
 142                 col.getColumn().setWidth(200);
 143
 144                 col.setLabelProvider(new ColumnLabelProvider() {
 145                         @Override
 146                         public String getText(Object element) {
 147                                 return JcrUtils.get((Node) element, SlcNames.SLC_NAME);
 148                         }
 149
 150                         @Override
 151                         public Image getImage(Object element) {
 152                                 return null;
 153                         }
 154                 });
 155
 156                 viewer.setContentProvider(new ITreeContentProvider() {
 157
 158                         public void dispose() {
 159                         }
 160
 161                         public void inputChanged(Viewer viewer, Object oldInput,
 162                                         Object newInput) {
 163                         }
 164
 165                         public Object[] getElements(Object inputElement) {
 166                                 try {
 167                                         List<Node> nodes = JcrUtils.nodeIteratorToList(listNodes(
 168                                                         currBundle, SlcTypes.SLC_EXPORTED_PACKAGE,
 169                                                         SlcNames.SLC_NAME));
 170                                         return nodes.toArray();
 171                                 } catch (RepositoryException e) {
 172                                         throw new SlcException("Cannot list children Nodes", e);
 173                                 }
 174                         }
 175
 176                         public Object[] getChildren(Object parentElement) {
 177                                 // Only 2 levels for the time being
 178                                 try {
 179                                         Node pNode = (Node) parentElement;
 180                                         if (pNode.isNodeType(SlcTypes.SLC_EXPORTED_PACKAGE)) {
 181                                                 List<Node> nodes = JcrUtils
 182                                                                 .nodeIteratorToList(listNodes(pNode,
 183                                                                                 SlcTypes.SLC_JAVA_PACKAGE,
 184                                                                                 SlcNames.SLC_NAME));
 185                                                 return nodes.toArray();
 186                                         } else
 187                                                 return null;
 188                                 } catch (RepositoryException e) {
 189                                         throw new SlcException("Cannot list children Nodes", e);
 190                                 }
 191                         }
 192
 193                         public Object getParent(Object element) {
 194                                 // useless
 195                                 return null;
 196                         }
 197
 198                         public boolean hasChildren(Object element) {
 199                                 try {
 200                                         Node pNode = (Node) element;
 201                                         if (pNode.isNodeType(SlcTypes.SLC_EXPORTED_PACKAGE)) {
 202                                                 // might return true even if there is no "valid" child
 203                                                 return pNode.hasNodes();
 204                                         } else
 205                                                 return false;
 206                                 } catch (RepositoryException e) {
 207                                         throw new SlcException("Cannot check children Nodes", e);
 208                                 }
 209                         }
 210                 });
 211
 212                 headerSection.setClient(tree);
 213                 viewer.setInput("Initialize");
 214         }
 215
 216         /** Import Package Section */
 217         private void createImportPackageSection(Composite parent)
 218                         throws RepositoryException {
 219
 220                 // Define the TableViewer
 221                 Section headerSection = addSection(parent, "Import packages");
 222                 TableViewer viewer = new TableViewer(headerSection, SWT.MULTI
 223                                 | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.BORDER);
 224
 225                 // Name
 226                 TableViewerColumn col = new TableViewerColumn(viewer, SWT.NONE);
 227                 col.getColumn().setWidth(300);
 228                 col.getColumn().setText("Name");
 229                 col.setLabelProvider(new ColumnLabelProvider() {
 230                         @Override
 231                         public String getText(Object element) {
 232                                 return JcrUtils.get((Node) element, SLC_NAME);
 233                         }
 234                 });
 235
 236                 // Version
 237                 col = new TableViewerColumn(viewer, SWT.NONE);
 238                 col.getColumn().setWidth(100);
 239                 col.getColumn().setText("Version");
 240                 col.setLabelProvider(new ColumnLabelProvider() {
 241                         @Override
 242                         public String getText(Object element) {
 243                                 return JcrUtils.get((Node) element, SLC_VERSION);
 244                         }
 245                 });
 246
 247                 // Optional
 248                 col = new TableViewerColumn(viewer, SWT.NONE);
 249                 col.getColumn().setWidth(100);
 250                 col.getColumn().setText("Optional");
 251                 col.setLabelProvider(new ColumnLabelProvider() {
 252                         @Override
 253                         public String getText(Object element) {
 254                                 return JcrUtils.get((Node) element, SLC_OPTIONAL);
 255                         }
 256                 });
 257
 258                 final Table table = viewer.getTable();
 259                 table.setHeaderVisible(true);
 260                 table.setLinesVisible(true);
 261                 GridData gd = new GridData(SWT.LEFT, SWT.TOP, true, true);
 262                 gd.heightHint = 300;
 263                 table.setLayoutData(gd);
 264
 265                 viewer.setContentProvider(new TableContentProvider(
 266                                 SLC_IMPORTED_PACKAGE, SLC_NAME));
 267                 headerSection.setClient(viewer.getTable());
 268
 269                 viewer.setInput("Initialize");
 270         }
 271
 272         /** Required Bundle Section */
 273         private void createReqBundleSection(Composite parent)
 274                         throws RepositoryException {
 275
 276                 // Define the TableViewer
 277                 Section headerSection = addSection(parent, "Required bundles");
 278                 TableViewer viewer = new TableViewer(headerSection, SWT.MULTI
 279                                 | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.BORDER);
 280
 281                 // Name
 282                 TableViewerColumn col = new TableViewerColumn(viewer, SWT.NONE);
 283                 col.getColumn().setWidth(300);
 284                 col.getColumn().setText("Name");
 285                 col.setLabelProvider(new ColumnLabelProvider() {
 286                         @Override
 287                         public String getText(Object element) {
 288                                 return JcrUtils.get((Node) element, SLC_SYMBOLIC_NAME);
 289                         }
 290                 });
 291
 292                 // Version
 293                 col = new TableViewerColumn(viewer, SWT.NONE);
 294                 col.getColumn().setWidth(100);
 295                 col.getColumn().setText("Version");
 296                 col.setLabelProvider(new ColumnLabelProvider() {
 297                         @Override
 298                         public String getText(Object element) {
 299                                 return JcrUtils.get((Node) element, SLC_BUNDLE_VERSION);
 300                         }
 301                 });
 302
 303                 // Version
 304                 col = new TableViewerColumn(viewer, SWT.NONE);
 305                 col.getColumn().setWidth(100);
 306                 col.getColumn().setText("Optional");
 307                 col.setLabelProvider(new ColumnLabelProvider() {
 308                         @Override
 309                         public String getText(Object element) {
 310                                 return JcrUtils.get((Node) element, SLC_OPTIONAL);
 311                         }
 312                 });
 313
 314                 final Table table = viewer.getTable();
 315                 table.setHeaderVisible(true);
 316                 table.setLinesVisible(true);
 317
 318                 viewer.setContentProvider(new TableContentProvider(SLC_REQUIRED_BUNDLE,
 319                                 SLC_SYMBOLIC_NAME));
 320                 headerSection.setClient(viewer.getTable());
 321
 322                 viewer.setInput("Initialize");
 323         }
 324
 325         /** Build repository request */
 326         private NodeIterator listNodes(Node parent, String nodeType, String orderBy)
 327                         throws RepositoryException {
 328                 QueryManager queryManager = currBundle.getSession().getWorkspace()
 329                                 .getQueryManager();
 330                 QueryObjectModelFactory factory = queryManager.getQOMFactory();
 331
 332                 final String nodeSelector = "nodes";
 333                 Selector source = factory.selector(nodeType, nodeSelector);
 334
 335                 Constraint childOf = factory.childNode(nodeSelector, parent.getPath());
 336
 337                 Ordering order = factory.ascending(factory.propertyValue(nodeSelector,
 338                                 orderBy));
 339                 Ordering[] orderings = { order };
 340
 341                 QueryObjectModel query = factory.createQuery(source, childOf,
 342                                 orderings, null);
 343
 344                 QueryResult result = query.execute();
 345                 return result.getNodes();
 346
 347         }
 348
 349         private class TableContentProvider implements IStructuredContentProvider {
 350                 private String nodeType;
 351                 private String orderBy;
 352
 353                 TableContentProvider(String nodeType, String orderBy) {
 354                         this.nodeType = nodeType;
 355                         this.orderBy = orderBy;
 356                 }
 357
 358                 public void dispose() {
 359                 }
 360
 361                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 362                 }
 363
 364                 public Object[] getElements(Object arg0) {
 365                         try {
 366                                 List<Node> nodes = JcrUtils.nodeIteratorToList(listNodes(
 367                                                 currBundle, nodeType, orderBy));
 368                                 return nodes.toArray();
 369                         } catch (RepositoryException e) {
 370                                 ErrorFeedback.show("Cannot list children Nodes", e);
 371                                 return null;
 372                         }
 373                 }
 374         }
 375
 376         /* HELPERS */
 377         private void createField(Composite parent, String label, String jcrPropName)
 378                         throws RepositoryException {
 379                 toolkit.createLabel(parent, label, SWT.NONE);
 380                 Text txt = toolkit.createText(parent, "", SWT.SINGLE);
 381                 txt.setText(currBundle.hasProperty(jcrPropName) ? currBundle
 382                                 .getProperty(jcrPropName).getString() : "");
 383                 txt.setEditable(false);
 384                 GridData gd = new GridData(SWT.FILL, SWT.TOP, true, false);
 385                 txt.setLayoutData(gd);
 386         }
 387
 388         private Section addSection(Composite parent, String title) {
 389                 Section section = toolkit.createSection(parent, Section.TWISTIE);
 390                 section.setText(title);
 391                 section.setExpanded(false);
 392                 GridData gd = new GridData(SWT.FILL, SWT.FILL, false, false);
 393                 section.setLayoutData(gd);
 394                 Composite body = new Composite(section, SWT.FILL);
 395                 section.setClient(body);
 396                 // Layout
 397                 body.setLayout(new TableLayout());
 398                 return section;
 399         }
 400
 401         // private void createHyperlink(Composite parent, String label,
 402         // String jcrPropName) throws RepositoryException {
 403         // toolkit.createLabel(parent, label, SWT.NONE);
 404         // if (currBundle.hasProperty(jcrPropName)) {
 405         // final Hyperlink link = toolkit.createHyperlink(parent, currBundle
 406         // .getProperty(jcrPropName).getString(), SWT.NONE);
 407         // link.addHyperlinkListener(new AbstractHyperlinkListener() {
 408         // @Override
 409         // public void linkActivated(HyperlinkEvent e) {
 410         // try {
 411         // IWorkbenchBrowserSupport browserSupport = PlatformUI
 412         // .getWorkbench().getBrowserSupport();
 413         // IWebBrowser browser = browserSupport
 414         // .createBrowser(
 415         // IWorkbenchBrowserSupport.LOCATION_BAR
 416         // | IWorkbenchBrowserSupport.NAVIGATION_BAR,
 417         // "SLC Distribution browser",
 418         // "SLC Distribution browser",
 419         // "A tool tip");
 420         // browser.openURL(new URL(link.getText()));
 421         // } catch (Exception ex) {
 422         //                                              throw new SlcException("error opening browser", ex); //$NON-NLS-1$
 423         // }
 424         // }
 425         // });
 426         // } else
 427         // toolkit.createLabel(parent, "", SWT.NONE);
 428         // }
 429
 430         /** Creates a text area with corresponding maven snippet */
 431         private void createMavenSnipet(Composite parent) {
 432                 mavenSnippet = new Text(parent, SWT.MULTI | SWT.WRAP | SWT.BORDER);
 433                 GridData gd = new GridData(GridData.FILL_HORIZONTAL);
 434                 gd.grabExcessHorizontalSpace = true;
 435                 gd.heightHint = 100;
 436                 mavenSnippet.setLayoutData(gd);
 437                 mavenSnippet.setText(generateXmlSnippet());
 438         }
 439
 440         // Helpers
 441         private String generateXmlSnippet() {
 442                 try {
 443                         StringBuffer sb = new StringBuffer();
 444                         sb.append("<dependency>\n");
 445                         sb.append("\t<groupeId>");
 446                         sb.append(currBundle.getProperty(SLC_GROUP_ID).getString());
 447                         sb.append("</groupeId>\n");
 448                         sb.append("\t<artifactId>");
 449                         sb.append(currBundle.getProperty(SLC_ARTIFACT_ID).getString());
 450                         sb.append("</artifactId>\n");
 451                         sb.append("\t<version>");
 452                         sb.append(currBundle.getProperty(SLC_ARTIFACT_VERSION).getString());
 453                         sb.append("</version>\n");
 454                         sb.append("</dependency>");
 455                         return sb.toString();
 456                 } catch (RepositoryException re) {
 457                         throw new ArgeoException(
 458                                         "unexpected error while generating maven snippet");
 459                 }
 460         }
 461 }