1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.argeo.slc.client.ui.dist.editors;
17
18 import java.net.URL;
19 import java.util.ArrayList;
20 import java.util.HashMap;
21 import java.util.List;
22 import java.util.Map;
23
24 import javax.jcr.Node;
25 import javax.jcr.NodeIterator;
26 import javax.jcr.PropertyType;
27 import javax.jcr.RepositoryException;
28 import javax.jcr.Session;
29 import javax.jcr.query.QueryManager;
30 import javax.jcr.query.QueryResult;
31 import javax.jcr.query.qom.Constraint;
32 import javax.jcr.query.qom.DynamicOperand;
33 import javax.jcr.query.qom.QueryObjectModel;
34 import javax.jcr.query.qom.QueryObjectModelFactory;
35 import javax.jcr.query.qom.Selector;
36 import javax.jcr.query.qom.StaticOperand;
37
38 import org.apache.commons.logging.Log;
39 import org.apache.commons.logging.LogFactory;
40 import org.argeo.cms.ui.workbench.util.CommandUtils;
41 import org.argeo.eclipse.ui.EclipseUiUtils;
42 import org.argeo.jcr.JcrUtils;
43 import org.argeo.slc.SlcException;
44 import org.argeo.slc.SlcNames;
45 import org.argeo.slc.SlcTypes;
46 import org.argeo.slc.client.ui.dist.DistConstants;
47 import org.argeo.slc.client.ui.dist.DistImages;
48 import org.argeo.slc.client.ui.dist.commands.OpenModuleEditor;
49 import org.argeo.slc.client.ui.dist.utils.DistNodeViewerComparator;
50 import org.argeo.slc.client.ui.dist.utils.HyperlinkAdapter;
51 import org.argeo.slc.repo.RepoConstants;
52 import org.argeo.slc.repo.RepoUtils;
53 import org.argeo.slc.repo.maven.MavenConventionsUtils;
54 import org.eclipse.aether.artifact.Artifact;
55 import org.eclipse.aether.artifact.DefaultArtifact;
56 import org.eclipse.jface.dialogs.IMessageProvider;
57 import org.eclipse.jface.viewers.ColumnLabelProvider;
58 import org.eclipse.jface.viewers.DoubleClickEvent;
59 import org.eclipse.jface.viewers.IDoubleClickListener;
60 import org.eclipse.jface.viewers.IStructuredContentProvider;
61 import org.eclipse.jface.viewers.IStructuredSelection;
62 import org.eclipse.jface.viewers.TableViewer;
63 import org.eclipse.jface.viewers.TableViewerColumn;
64 import org.eclipse.jface.viewers.Viewer;
65 import org.eclipse.swt.SWT;
66 import org.eclipse.swt.events.ModifyEvent;
67 import org.eclipse.swt.events.ModifyListener;
68 import org.eclipse.swt.events.SelectionAdapter;
69 import org.eclipse.swt.events.SelectionEvent;
70 import org.eclipse.swt.layout.FillLayout;
71 import org.eclipse.swt.layout.GridData;
72 import org.eclipse.swt.layout.GridLayout;
73 import org.eclipse.swt.widgets.Button;
74 import org.eclipse.swt.widgets.Composite;
75 import org.eclipse.swt.widgets.Label;
76 import org.eclipse.swt.widgets.Table;
77 import org.eclipse.swt.widgets.Text;
78 import org.eclipse.ui.PlatformUI;
79 import org.eclipse.ui.browser.IWebBrowser;
80 import org.eclipse.ui.browser.IWorkbenchBrowserSupport;
81 import org.eclipse.ui.forms.IManagedForm;
82 import org.eclipse.ui.forms.editor.FormEditor;
83 import org.eclipse.ui.forms.editor.FormPage;
84 import org.eclipse.ui.forms.events.HyperlinkEvent;
85 import org.eclipse.ui.forms.widgets.FormToolkit;
86 import org.eclipse.ui.forms.widgets.Hyperlink;
87 import org.eclipse.ui.forms.widgets.ScrolledForm;
88
89
90
91
92
93 public class ModularDistVersionOverviewPage extends FormPage implements
94 SlcNames {
95
96 private final static Log log = LogFactory
97 .getLog(ModularDistVersionOverviewPage.class);
98
99 final static String PAGE_ID = "ModularDistVersionOverviewPage";
100
101
102 private Node modularDistribution;
103
104
105
106 private DistNodeViewerComparator comparator;
107 private TableViewer viewer;
108 private FormToolkit tk;
109 private Text filterTxt;
110 private final static String FILTER_HELP_MSG = "Enter filter criterion separated by a space";
111
112 public ModularDistVersionOverviewPage(FormEditor formEditor, String title,
113 Node modularDistribution) {
114 super(formEditor, PAGE_ID, title);
115 this.modularDistribution = modularDistribution;
116 }
117
118 @Override
119 protected void createFormContent(IManagedForm managedForm) {
120
121 ScrolledForm form = managedForm.getForm();
122 tk = managedForm.getToolkit();
123 Composite body = form.getBody();
124
125 GridLayout layout = new GridLayout(1, false);
126 layout.marginWidth = 5;
127 layout.marginRight = 15;
128 layout.verticalSpacing = 0;
129 body.setLayout(layout);
130 try {
131 form.setText(modularDistribution.hasProperty(SlcNames.SLC_NAME) ? modularDistribution
132 .getProperty(SlcNames.SLC_NAME).getString() : "");
133 form.setMessage(
134 modularDistribution
135 .hasProperty(DistConstants.SLC_BUNDLE_DESCRIPTION) ? modularDistribution
136 .getProperty(DistConstants.SLC_BUNDLE_DESCRIPTION)
137 .getString() : "", IMessageProvider.NONE);
138 } catch (RepositoryException re) {
139 throw new SlcException("Unable to get bundle name for node "
140 + modularDistribution, re);
141 }
142
143
144 Composite header = tk.createComposite(body);
145 header.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, false));
146 populateHeaderPart(header);
147
148 Composite moduleTablePart = tk.createComposite(body);
149 moduleTablePart.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true,
150 true));
151 populateModuleTablePart(moduleTablePart);
152 }
153
154 private void populateHeaderPart(Composite parent) {
155 GridLayout layout = new GridLayout(6, false);
156 layout.horizontalSpacing = 10;
157 parent.setLayout(layout);
158 try {
159
160 createLT(
161 parent,
162 "Category",
163 modularDistribution.hasProperty(SlcNames.SLC_CATEGORY) ? modularDistribution
164 .getProperty(SlcNames.SLC_CATEGORY).getString()
165 : "");
166 createLT(
167 parent,
168 "Name",
169 modularDistribution.hasProperty(SlcNames.SLC_NAME) ? modularDistribution
170 .getProperty(SlcNames.SLC_NAME).getString() : "");
171 createLT(
172 parent,
173 "Version",
174 modularDistribution.hasProperty(SlcNames.SLC_VERSION) ? modularDistribution
175 .getProperty(SlcNames.SLC_VERSION).getString() : "");
176
177
178 createLT(
179 parent,
180 "Vendor",
181 modularDistribution
182 .hasProperty(DistConstants.SLC_BUNDLE_VENDOR) ? modularDistribution
183 .getProperty(DistConstants.SLC_BUNDLE_VENDOR)
184 .getString() : "N/A");
185
186 createHyperlink(parent, "Licence", DistConstants.SLC_BUNDLE_LICENCE);
187 addSourceSourcesLink(parent);
188 } catch (RepositoryException re) {
189 throw new SlcException("Unable to get bundle name for node "
190 + modularDistribution, re);
191 }
192
193 }
194
195 private Text createLT(Composite parent, String labelValue, String textValue) {
196 Label label = tk.createLabel(parent, labelValue, SWT.RIGHT);
197
198 label.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, false, false));
199
200
201 Text text = new Text(parent, SWT.LEFT);
202 text.setText(textValue + " ");
203 text.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));
204 text.setEditable(false);
205 return text;
206 }
207
208 private void createHyperlink(Composite parent, String label,
209 String jcrPropName) throws RepositoryException {
210 tk.createLabel(parent, label, SWT.NONE);
211 if (modularDistribution.hasProperty(jcrPropName)) {
212 final Hyperlink link = tk.createHyperlink(parent,
213 modularDistribution.getProperty(jcrPropName).getString(),
214 SWT.NONE);
215 link.addHyperlinkListener(new HyperlinkAdapter() {
216 @Override
217 public void linkActivated(HyperlinkEvent e) {
218 try {
219 IWorkbenchBrowserSupport browserSupport = PlatformUI
220 .getWorkbench().getBrowserSupport();
221 IWebBrowser browser = browserSupport
222 .createBrowser(
223 IWorkbenchBrowserSupport.LOCATION_BAR
224 | IWorkbenchBrowserSupport.NAVIGATION_BAR,
225 "SLC Distribution browser",
226 "SLC Distribution browser",
227 "A tool tip");
228 browser.openURL(new URL(link.getText()));
229 } catch (Exception ex) {
230 throw new SlcException("error opening browser", ex);
231 }
232 }
233 });
234 } else
235 tk.createLabel(parent, "N/A", SWT.NONE);
236 }
237
238
239 private void addSourceSourcesLink(Composite parent) {
240 try {
241 String srcPath = RepoUtils.relatedPdeSourcePath(
242 RepoConstants.DEFAULT_ARTIFACTS_BASE_PATH,
243 modularDistribution);
244 if (!modularDistribution.getSession().nodeExists(srcPath)) {
245 createLT(parent, "Sources", "N/A");
246 } else {
247 final Node sourcesNode = modularDistribution.getSession()
248 .getNode(srcPath);
249
250 String srcName = null;
251 if (sourcesNode.hasProperty(SlcNames.SLC_SYMBOLIC_NAME))
252 srcName = sourcesNode.getProperty(
253 SlcNames.SLC_SYMBOLIC_NAME).getString();
254 else
255 srcName = sourcesNode.getName();
256 Label label = tk.createLabel(parent, "Sources", SWT.RIGHT);
257 label.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, false,
258 false));
259 Hyperlink link = tk.createHyperlink(parent, srcName, SWT.NONE);
260 link.addHyperlinkListener(new OpenFileLinkListener(sourcesNode
261 .getPath()));
262 }
263 } catch (RepositoryException e) {
264 throw new SlcException("Unable to configure sources link for "
265 + modularDistribution, e);
266 }
267 }
268
269 private class OpenFileLinkListener extends HyperlinkAdapter {
270 final private String path;
271
272 public OpenFileLinkListener(String path) {
273 this.path = path;
274 }
275
276 @Override
277 public void linkActivated(HyperlinkEvent e) {
278 log.warn("File download must be implemented. Cannot provide access to "
279 + path);
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297 }
298 }
299
300 private void populateModuleTablePart(Composite parent) {
301 GridLayout layout = new GridLayout(1, false);
302 layout.marginWidth = layout.horizontalSpacing = 0;
303 layout.verticalSpacing = 5;
304 layout.marginTop = 15;
305 parent.setLayout(layout);
306
307 Label label = tk.createLabel(parent,
308 "Modules included in the current distribution", SWT.NONE);
309 label.setFont(EclipseUiUtils.getBoldFont(parent));
310
311
312 Composite filterPart = tk.createComposite(parent);
313 filterPart.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, false));
314 createFilterPart(filterPart);
315
316
317 Composite tablePart = tk.createComposite(parent);
318 tablePart.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
319 createTableViewer(tablePart);
320
321 refresh();
322 }
323
324 private void createFilterPart(Composite parent) {
325 GridLayout layout = new GridLayout(2, false);
326 layout.marginWidth = layout.marginHeight = layout.verticalSpacing = 0;
327 layout.horizontalSpacing = 5;
328 parent.setLayout(layout);
329
330
331 filterTxt = tk.createText(parent, "", SWT.BORDER | SWT.SINGLE
332 | SWT.SEARCH | SWT.CANCEL);
333 filterTxt.setMessage(FILTER_HELP_MSG);
334 filterTxt.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false));
335 filterTxt.addModifyListener(new ModifyListener() {
336 private static final long serialVersionUID = -276152321986407726L;
337
338 public void modifyText(ModifyEvent event) {
339 refresh();
340 }
341 });
342
343 Button resetBtn = tk.createButton(parent, null, SWT.PUSH);
344 resetBtn.setImage(DistImages.IMG_CLEAR);
345 resetBtn.addSelectionListener(new SelectionAdapter() {
346 private static final long serialVersionUID = -3549303742841670919L;
347
348 public void widgetSelected(SelectionEvent e) {
349 filterTxt.setText("");
350 filterTxt.setMessage(FILTER_HELP_MSG);
351 }
352 });
353 }
354
355 private void createTableViewer(Composite parent) {
356 parent.setLayout(new FillLayout());
357
358 List<String> propertiesList = new ArrayList<String>();
359 List<Integer> propertyTypesList = new ArrayList<Integer>();
360
361
362 viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL
363 | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.BORDER);
364
365
366 TableViewerColumn col = new TableViewerColumn(viewer, SWT.NONE);
367 col.getColumn().setWidth(220);
368 col.getColumn().setText("Category");
369 col.setLabelProvider(new ColumnLabelProvider() {
370 private static final long serialVersionUID = 5875398301711336875L;
371
372 @Override
373 public String getText(Object element) {
374 return JcrUtils.get((Node) element, SlcNames.SLC_CATEGORY);
375 }
376 });
377 col.getColumn().addSelectionListener(getSelectionAdapter(0));
378 propertiesList.add(SlcNames.SLC_CATEGORY);
379 propertyTypesList.add(PropertyType.STRING);
380
381
382 col = new TableViewerColumn(viewer, SWT.NONE);
383 col.getColumn().setWidth(220);
384 col.getColumn().setText("Name");
385 col.setLabelProvider(new ColumnLabelProvider() {
386 private static final long serialVersionUID = 3880240676256465072L;
387
388 @Override
389 public String getText(Object element) {
390 return JcrUtils.get((Node) element, SLC_NAME);
391 }
392 });
393 col.getColumn().addSelectionListener(getSelectionAdapter(1));
394 propertiesList.add(SLC_NAME);
395 propertyTypesList.add(PropertyType.STRING);
396
397
398 col = new TableViewerColumn(viewer, SWT.NONE);
399 col.getColumn().setWidth(160);
400 col.getColumn().setText("Version");
401 col.setLabelProvider(new ColumnLabelProvider() {
402 private static final long serialVersionUID = -4706438113850571784L;
403
404 @Override
405 public String getText(Object element) {
406 return JcrUtils.get((Node) element, SLC_VERSION);
407 }
408 });
409 col.getColumn().addSelectionListener(getSelectionAdapter(2));
410 propertiesList.add(SLC_VERSION);
411 propertyTypesList.add(DistNodeViewerComparator.VERSION_TYPE);
412
413
414 col = new TableViewerColumn(viewer, SWT.NONE);
415 col.getColumn().setWidth(160);
416 col.getColumn().setText("Exists in workspace");
417 col.setLabelProvider(new ColumnLabelProvider() {
418 private static final long serialVersionUID = 8190063212920414300L;
419
420 @Override
421 public String getText(Object element) {
422 return getRealizedModule((Node) element) != null ? "Yes" : "No";
423
424 }
425 });
426
427
428
429
430 final Table table = viewer.getTable();
431 table.setHeaderVisible(true);
432 table.setLinesVisible(true);
433
434 viewer.setContentProvider(new DistributionsContentProvider());
435 getSite().setSelectionProvider(viewer);
436
437 comparator = new DistNodeViewerComparator(2,
438 DistNodeViewerComparator.ASCENDING, propertiesList,
439 propertyTypesList);
440 viewer.setComparator(comparator);
441
442
443
444
445
446
447
448
449
450
451
452
453
454 viewer.addDoubleClickListener(new DoubleClickListener());
455 }
456
457 private Node getRealizedModule(Node moduleCoordinates) {
458 try {
459 String category = JcrUtils.get(moduleCoordinates, SLC_CATEGORY);
460 String name = JcrUtils.get(moduleCoordinates, SLC_NAME);
461 String version = JcrUtils.get(moduleCoordinates, SLC_VERSION);
462 Artifact artifact = new DefaultArtifact(category + ":" + name + ":"
463 + version);
464 String parentPath = MavenConventionsUtils.artifactParentPath(
465 RepoConstants.DEFAULT_ARTIFACTS_BASE_PATH, artifact);
466
467 Session session = modularDistribution.getSession();
468 if (session.nodeExists(parentPath)) {
469 Node parent = session.getNode(parentPath);
470 NodeIterator nit = parent.getNodes();
471 while (nit.hasNext()) {
472 Node currN = nit.nextNode();
473 if (currN.isNodeType(SlcTypes.SLC_ARTIFACT))
474 return currN;
475 }
476 }
477 } catch (RepositoryException re) {
478 throw new SlcException(
479 "unable to retrieve realized module with coordinates "
480 + moduleCoordinates, re);
481 }
482 return null;
483 }
484
485 private void refresh() {
486 final List<Node> result = JcrUtils
487 .nodeIteratorToList(listBundleArtifacts());
488 viewer.setInput(result);
489 }
490
491
492 private NodeIterator listBundleArtifacts() {
493 try {
494 Session session = modularDistribution.getSession();
495 QueryManager queryManager = session.getWorkspace()
496 .getQueryManager();
497 QueryObjectModelFactory factory = queryManager.getQOMFactory();
498
499 Selector source = factory.selector(SlcTypes.SLC_MODULE_COORDINATES,
500 SlcTypes.SLC_MODULE_COORDINATES);
501
502
503
504 DynamicOperand catDO = factory.propertyValue(
505 source.getSelectorName(), SlcNames.SLC_CATEGORY);
506 DynamicOperand nameDO = factory.propertyValue(
507 source.getSelectorName(), SlcNames.SLC_NAME);
508 DynamicOperand versionDO = factory.propertyValue(
509 source.getSelectorName(), SlcNames.SLC_VERSION);
510
511 String path = modularDistribution.getPath() + "/"
512 + SlcNames.SLC_MODULES;
513
514
515 Constraint defaultC = factory.descendantNode(
516 source.getSelectorName(), path);
517
518 String filter = filterTxt.getText();
519
520
521 if (filter != null && !"".equals(filter.trim())) {
522
523 String[] strs = filter.trim().split(" ");
524 for (String token : strs) {
525 token = token.replace('*', '%');
526 StaticOperand so = factory.literal(session
527 .getValueFactory().createValue("%" + token + "%"));
528
529 Constraint currC = factory.comparison(catDO,
530 QueryObjectModelFactory.JCR_OPERATOR_LIKE, so);
531 currC = factory.or(currC, factory.comparison(versionDO,
532 QueryObjectModelFactory.JCR_OPERATOR_LIKE, so));
533 currC = factory.or(currC, factory.comparison(nameDO,
534 QueryObjectModelFactory.JCR_OPERATOR_LIKE, so));
535
536 defaultC = factory.and(defaultC, currC);
537 }
538 }
539
540 QueryObjectModel query = factory.createQuery(source, defaultC,
541 null, null);
542 QueryResult result = query.execute();
543 return result.getNodes();
544 } catch (RepositoryException re) {
545 throw new SlcException("Unable to refresh module list for node "
546 + modularDistribution, re);
547 }
548 }
549
550 @Override
551 public void setFocus() {
552 viewer.getTable().setFocus();
553 }
554
555
556
557
558
559
560
561
562
563
564
565
566 private SelectionAdapter getSelectionAdapter(final int index) {
567 SelectionAdapter selectionAdapter = new SelectionAdapter() {
568 private static final long serialVersionUID = 1260801795934660840L;
569
570 @Override
571 public void widgetSelected(SelectionEvent e) {
572 Table table = viewer.getTable();
573 comparator.setColumn(index);
574 int dir = table.getSortDirection();
575 if (table.getSortColumn() == table.getColumn(index)) {
576 dir = dir == SWT.UP ? SWT.DOWN : SWT.UP;
577 } else {
578 dir = SWT.DOWN;
579 }
580 table.setSortDirection(dir);
581 table.setSortColumn(table.getColumn(index));
582 viewer.refresh();
583 }
584 };
585 return selectionAdapter;
586 }
587
588
589 private class DistributionsContentProvider implements
590 IStructuredContentProvider {
591 private static final long serialVersionUID = 8385338190908823791L;
592
593
594 private List<Node> nodes;
595
596 public void dispose() {
597 }
598
599
600 @SuppressWarnings("unchecked")
601 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
602 nodes = (List<Node>) newInput;
603 }
604
605 public Object[] getElements(Object arg0) {
606 return nodes.toArray();
607 }
608 }
609
610 private class DoubleClickListener implements IDoubleClickListener {
611
612 public void doubleClick(DoubleClickEvent event) {
613 Object obj = ((IStructuredSelection) event.getSelection())
614 .getFirstElement();
615 if (obj instanceof Node) {
616 Node node = (Node) obj;
617 try {
618 if (node.isNodeType(SlcTypes.SLC_MODULE_COORDINATES)) {
619 Node realizedModule = getRealizedModule(node);
620 if (realizedModule != null) {
621 ModuleEditorInput dwip = (ModuleEditorInput) getEditorInput();
622 Map<String, String> params = new HashMap<String, String>();
623 params.put(OpenModuleEditor.PARAM_REPO_NODE_PATH,
624 dwip.getRepoNodePath());
625 params.put(OpenModuleEditor.PARAM_REPO_URI,
626 dwip.getUri());
627 params.put(OpenModuleEditor.PARAM_WORKSPACE_NAME,
628 dwip.getWorkspaceName());
629 String path = realizedModule.getPath();
630 params.put(OpenModuleEditor.PARAM_MODULE_PATH, path);
631 CommandUtils.callCommand(OpenModuleEditor.ID,
632 params);
633 }
634 }
635 } catch (RepositoryException re) {
636 throw new SlcException("Cannot get path for node " + node
637 + " while setting parameters for "
638 + "command OpenModuleEditor", re);
639 }
640 }
641 }
642 }
643 }