org.argeo.slc.client.ui/src/org/argeo/slc/client/ui/views/JcrResultTreeView.java

   1 package org.argeo.slc.client.ui.views;
   2
   3 import java.text.DateFormat;
   4 import java.text.SimpleDateFormat;
   5 import java.util.ArrayList;
   6 import java.util.Calendar;
   7 import java.util.Iterator;
   8 import java.util.List;
   9
  10 import javax.jcr.Node;
  11 import javax.jcr.NodeIterator;
  12 import javax.jcr.Property;
  13 import javax.jcr.Repository;
  14 import javax.jcr.RepositoryException;
  15 import javax.jcr.Session;
  16 import javax.jcr.nodetype.NodeType;
  17 import javax.jcr.observation.Event;
  18 import javax.jcr.observation.EventListener;
  19 import javax.jcr.observation.ObservationManager;
  20
  21 import org.argeo.api.NodeConstants;
  22 import org.argeo.cms.ui.workbench.util.CommandUtils;
  23 import org.argeo.eclipse.ui.jcr.AsyncUiEventListener;
  24 import org.argeo.jcr.JcrUtils;
  25 import org.argeo.slc.SlcException;
  26 import org.argeo.slc.SlcNames;
  27 import org.argeo.slc.SlcTypes;
  28 import org.argeo.slc.client.ui.ClientUiPlugin;
  29 import org.argeo.slc.client.ui.SlcUiConstants;
  30 import org.argeo.slc.client.ui.commands.AddResultFolder;
  31 import org.argeo.slc.client.ui.commands.DeleteItems;
  32 import org.argeo.slc.client.ui.commands.RefreshJcrResultTreeView;
  33 import org.argeo.slc.client.ui.commands.RenameResultFolder;
  34 import org.argeo.slc.client.ui.commands.RenameResultNode;
  35 import org.argeo.slc.client.ui.editors.ProcessEditor;
  36 import org.argeo.slc.client.ui.editors.ProcessEditorInput;
  37 import org.argeo.slc.client.ui.model.ParentNodeFolder;
  38 import org.argeo.slc.client.ui.model.ResultFolder;
  39 import org.argeo.slc.client.ui.model.ResultItemsComparator;
  40 import org.argeo.slc.client.ui.model.ResultItemsComparer;
  41 import org.argeo.slc.client.ui.model.ResultParent;
  42 import org.argeo.slc.client.ui.model.ResultParentUtils;
  43 import org.argeo.slc.client.ui.model.SingleResultNode;
  44 import org.argeo.slc.client.ui.model.VirtualFolder;
  45 import org.argeo.slc.client.ui.providers.ResultTreeContentProvider;
  46 import org.argeo.slc.client.ui.providers.ResultTreeLabelProvider;
  47 import org.argeo.slc.jcr.SlcJcrResultUtils;
  48 import org.eclipse.jface.action.IMenuListener;
  49 import org.eclipse.jface.action.IMenuManager;
  50 import org.eclipse.jface.action.MenuManager;
  51 import org.eclipse.jface.dialogs.MessageDialog;
  52 import org.eclipse.jface.viewers.ColumnLabelProvider;
  53 import org.eclipse.jface.viewers.DecoratingLabelProvider;
  54 import org.eclipse.jface.viewers.DoubleClickEvent;
  55 import org.eclipse.jface.viewers.IDoubleClickListener;
  56 import org.eclipse.jface.viewers.ILabelDecorator;
  57 import org.eclipse.jface.viewers.ISelectionChangedListener;
  58 import org.eclipse.jface.viewers.IStructuredContentProvider;
  59 import org.eclipse.jface.viewers.IStructuredSelection;
  60 import org.eclipse.jface.viewers.SelectionChangedEvent;
  61 import org.eclipse.jface.viewers.TableViewer;
  62 import org.eclipse.jface.viewers.TableViewerColumn;
  63 import org.eclipse.jface.viewers.TreePath;
  64 import org.eclipse.jface.viewers.TreeViewer;
  65 import org.eclipse.jface.viewers.Viewer;
  66 import org.eclipse.jface.viewers.ViewerDropAdapter;
  67 import org.eclipse.swt.SWT;
  68 import org.eclipse.swt.custom.SashForm;
  69 import org.eclipse.swt.dnd.DND;
  70 import org.eclipse.swt.dnd.DragSourceEvent;
  71 import org.eclipse.swt.dnd.DragSourceListener;
  72 import org.eclipse.swt.dnd.TextTransfer;
  73 import org.eclipse.swt.dnd.Transfer;
  74 import org.eclipse.swt.dnd.TransferData;
  75 import org.eclipse.swt.layout.FillLayout;
  76 import org.eclipse.swt.layout.GridData;
  77 import org.eclipse.swt.layout.GridLayout;
  78 import org.eclipse.swt.widgets.Composite;
  79 import org.eclipse.swt.widgets.Display;
  80 import org.eclipse.swt.widgets.Menu;
  81 import org.eclipse.ui.ISharedImages;
  82 import org.eclipse.ui.IWorkbenchPage;
  83 import org.eclipse.ui.IWorkbenchWindow;
  84 import org.eclipse.ui.PlatformUI;
  85 import org.eclipse.ui.part.ViewPart;
  86
  87 /** SLC generic JCR Result tree view. */
  88 public class JcrResultTreeView extends ViewPart {
  89         public final static String ID = ClientUiPlugin.ID + ".jcrResultTreeView";
  90
  91         private final static DateFormat dateFormat = new SimpleDateFormat(
  92                         SlcUiConstants.DEFAULT_DISPLAY_DATE_TIME_FORMAT);
  93
  94         // private final static Log log =
  95         // LogFactory.getLog(JcrResultTreeView.class);
  96
  97         /* DEPENDENCY INJECTION */
  98         private Repository repository;
  99         private Session session;
 100
 101         // This page widgets
 102         private TreeViewer resultTreeViewer;
 103         private TableViewer propertiesViewer;
 104
 105         private EventListener myResultsObserver = null;
 106         private EventListener allResultsObserver = null;
 107
 108         // under My Results
 109         private final static String[] observedNodeTypesUnderMyResult = {
 110                         SlcTypes.SLC_TEST_RESULT, SlcTypes.SLC_RESULT_FOLDER,
 111                         SlcTypes.SLC_MY_RESULT_ROOT_FOLDER };
 112
 113         private final static String[] observedNodeTypesUnderAllResults = {
 114                         SlcTypes.SLC_TEST_RESULT, NodeType.NT_UNSTRUCTURED };
 115
 116         private boolean isResultFolder = false;
 117
 118         /**
 119          * To be overridden to adapt size of form and result frames.
 120          */
 121         protected int[] getWeights() {
 122                 return new int[] { 70, 30 };
 123         }
 124
 125         @Override
 126         public void createPartControl(Composite parent) {
 127                 try {
 128                         session = repository.login(NodeConstants.HOME_WORKSPACE);
 129                 } catch (RepositoryException e1) {
 130                         throw new SlcException("Cannot log in to repository");
 131                 }
 132
 133                 parent.setLayout(new FillLayout());
 134                 // Main layout
 135                 SashForm sashForm = new SashForm(parent, SWT.VERTICAL);
 136                 sashForm.setSashWidth(4);
 137                 sashForm.setLayout(new FillLayout());
 138
 139                 // Create the tree on top of the view
 140                 Composite top = new Composite(sashForm, SWT.NONE);
 141                 GridLayout gl = new GridLayout(1, false);
 142                 top.setLayout(gl);
 143                 resultTreeViewer = createResultsTreeViewer(top);
 144
 145                 // Create the property viewer on the bottom
 146                 Composite bottom = new Composite(sashForm, SWT.NONE);
 147                 bottom.setLayout(new GridLayout(1, false));
 148                 propertiesViewer = createPropertiesViewer(bottom);
 149
 150                 sashForm.setWeights(getWeights());
 151
 152                 setOrderedInput(resultTreeViewer);
 153
 154                 // Initialize observer
 155                 try {
 156                         ObservationManager observationManager = session.getWorkspace()
 157                                         .getObservationManager();
 158                         myResultsObserver = new MyResultsObserver(resultTreeViewer
 159                                         .getTree().getDisplay());
 160                         allResultsObserver = new AllResultsObserver(resultTreeViewer
 161                                         .getTree().getDisplay());
 162
 163                         // observe tree changes under MyResults
 164                         observationManager.addEventListener(myResultsObserver,
 165                                         Event.NODE_ADDED | Event.NODE_REMOVED,
 166                                         SlcJcrResultUtils.getMyResultsBasePath(session), true,
 167                                         null, observedNodeTypesUnderMyResult, false);
 168                         // observe tree changes under All results
 169                         observationManager.addEventListener(allResultsObserver,
 170                                         Event.NODE_ADDED | Event.NODE_REMOVED,
 171                                         SlcJcrResultUtils.getSlcResultsBasePath(session), true,
 172                                         null, observedNodeTypesUnderAllResults, false);
 173                 } catch (RepositoryException e) {
 174                         throw new SlcException("Cannot register listeners", e);
 175                 }
 176         }
 177
 178         /**
 179          * Override default behaviour so that default defined order remains
 180          * unchanged on first level of the tree
 181          */
 182         private void setOrderedInput(TreeViewer viewer) {
 183                 // Add specific ordering
 184                 viewer.setInput(null);
 185                 viewer.setComparator(null);
 186                 viewer.setInput(initializeResultTree());
 187                 viewer.setComparator(new ResultItemsComparator());
 188         }
 189
 190         // The main tree viewer
 191         protected TreeViewer createResultsTreeViewer(Composite parent) {
 192                 int style = SWT.BORDER | SWT.MULTI;
 193
 194                 TreeViewer viewer = new TreeViewer(parent, style);
 195                 viewer.getTree().setLayoutData(
 196                                 new GridData(SWT.FILL, SWT.FILL, true, true));
 197
 198                 viewer.setContentProvider(new ResultTreeContentProvider());
 199
 200                 // Add label provider with label decorator
 201                 ResultTreeLabelProvider rtLblProvider = new ResultTreeLabelProvider();
 202                 ILabelDecorator decorator = ClientUiPlugin.getDefault().getWorkbench()
 203                                 .getDecoratorManager().getLabelDecorator();
 204                 viewer.setLabelProvider(new DecoratingLabelProvider(rtLblProvider,
 205                                 decorator));
 206                 viewer.addDoubleClickListener(new ViewDoubleClickListener());
 207
 208                 // Override default behaviour to insure that 2 distincts results that
 209                 // have the same name will be correctly and distincly returned by
 210                 // corresponding TreeViewer.getSelection() method.
 211                 viewer.setComparer(new ResultItemsComparer());
 212
 213                 // viewer.setLabelProvider(rtLblProvider);
 214                 getSite().setSelectionProvider(viewer);
 215
 216                 // add drag & drop support
 217                 int operations = DND.DROP_COPY | DND.DROP_MOVE;
 218                 Transfer[] tt = new Transfer[] { TextTransfer.getInstance() };
 219                 viewer.addDragSupport(operations, tt, new ViewDragListener());
 220                 viewer.addDropSupport(operations, tt, new ViewDropListener(viewer));
 221
 222                 // add context menu
 223                 MenuManager menuManager = new MenuManager();
 224                 Menu menu = menuManager.createContextMenu(viewer.getTree());
 225                 menuManager.addMenuListener(new IMenuListener() {
 226                         public void menuAboutToShow(IMenuManager manager) {
 227                                 contextMenuAboutToShow(manager);
 228                         }
 229                 });
 230                 viewer.getTree().setMenu(menu);
 231                 menuManager.setRemoveAllWhenShown(true);
 232
 233                 getSite().registerContextMenu(menuManager, viewer);
 234
 235                 // add change listener to display TestResult information in the property
 236                 // viewer
 237                 viewer.addSelectionChangedListener(new MySelectionChangedListener());
 238                 return viewer;
 239         }
 240
 241         // Detailed property viewer
 242         protected TableViewer createPropertiesViewer(Composite parent) {
 243                 propertiesViewer = new TableViewer(parent);
 244                 propertiesViewer.getTable().setLayoutData(
 245                                 new GridData(SWT.FILL, SWT.FILL, true, true));
 246                 propertiesViewer.getTable().setHeaderVisible(true);
 247                 propertiesViewer.setContentProvider(new PropertiesContentProvider());
 248                 TableViewerColumn col = new TableViewerColumn(propertiesViewer,
 249                                 SWT.NONE);
 250                 col.getColumn().setText("Name");
 251                 col.getColumn().setWidth(100);
 252                 col.setLabelProvider(new ColumnLabelProvider() {
 253                         public String getText(Object element) {
 254                                 try {
 255                                         String name = ((Property) element).getName();
 256                                         String value = null;
 257                                         if (SlcNames.SLC_TEST_CASE.equals(name))
 258                                                 value = "Test case";
 259                                         else if (SlcNames.SLC_COMPLETED.equals(name))
 260                                                 value = "Completed on";
 261                                         else if (SlcNames.SLC_SUCCESS.equals(name))
 262                                                 value = "Status";
 263                                         else if (SlcNames.SLC_MESSAGE.equals(name))
 264                                                 value = "Message";
 265                                         else if (SlcNames.SLC_ERROR_MESSAGE.equals(name))
 266                                                 value = "Error";
 267                                         return value;
 268                                 } catch (RepositoryException e) {
 269                                         throw new SlcException(
 270                                                         "Unexpected exception in label provider", e);
 271                                 }
 272                         }
 273                 });
 274                 col = new TableViewerColumn(propertiesViewer, SWT.NONE);
 275                 col.getColumn().setText("Value");
 276                 col.getColumn().setWidth(200);
 277                 col.setLabelProvider(new ColumnLabelProvider() {
 278                         public String getText(Object element) {
 279                                 try {
 280                                         Property property = (Property) element;
 281                                         String name = property.getName();
 282                                         String value = null;
 283
 284                                         if (SlcNames.SLC_TEST_CASE.equals(name)
 285                                                         || SlcNames.SLC_ERROR_MESSAGE.equals(name)
 286                                                         || SlcNames.SLC_MESSAGE.equals(name))
 287                                                 value = property.getValue().getString();
 288                                         else if (SlcNames.SLC_COMPLETED.equals(name)) {
 289                                                 Calendar date = property.getValue().getDate();
 290                                                 value = dateFormat.format(date.getTime());
 291                                         } else if (SlcNames.SLC_SUCCESS.equals(name)) {
 292                                                 if (property.getValue().getBoolean())
 293                                                         value = "PASSED";
 294                                                 else {
 295                                                         if (property.getParent().hasProperty(
 296                                                                         SlcNames.SLC_ERROR_MESSAGE))
 297                                                                 value = "ERROR";
 298                                                         else
 299                                                                 value = "FAILED";
 300                                                 }
 301                                         }
 302                                         return value;
 303                                 } catch (RepositoryException e) {
 304                                         throw new SlcException(
 305                                                         "Unexpected exception in label provider", e);
 306                                 }
 307                         }
 308                 });
 309                 propertiesViewer.setInput(getViewSite());
 310                 return propertiesViewer;
 311         }
 312
 313         /**
 314          * Override to provide specific behaviour. Typically to enable the display
 315          * of a result file.
 316          *
 317          * @param evt
 318          */
 319         protected void processDoubleClick(DoubleClickEvent evt) {
 320                 Object obj = ((IStructuredSelection) evt.getSelection())
 321                                 .getFirstElement();
 322                 try {
 323                         if (obj instanceof SingleResultNode) {
 324                                 SingleResultNode srNode = (SingleResultNode) obj;
 325                                 Node node = srNode.getNode();
 326                                 // FIXME: open a default result editor
 327                                 if (node.isNodeType(SlcTypes.SLC_PROCESS)) {
 328                                         IWorkbenchPage activePage = PlatformUI.getWorkbench()
 329                                                         .getActiveWorkbenchWindow().getActivePage();
 330                                         activePage.openEditor(
 331                                                         new ProcessEditorInput(node.getPath()),
 332                                                         ProcessEditor.ID);
 333                                 }
 334                         }
 335                 } catch (Exception e) {
 336                         throw new SlcException("Cannot open " + obj, e);
 337                 }
 338         }
 339
 340         @Override
 341         public void setFocus() {
 342         }
 343
 344         /**
 345          * refreshes the passed resultParent and its corresponding subtree. It
 346          * refreshes the whole viewer if null is passed.
 347          *
 348          * @param ResultParent
 349          *
 350          */
 351         public void refresh(ResultParent resultParent) {
 352                 if (resultParent == null) {
 353                         if (!resultTreeViewer.getTree().isDisposed()) {
 354                                 TreePath[] tps = resultTreeViewer.getExpandedTreePaths();
 355                                 setOrderedInput(resultTreeViewer);
 356                                 resultTreeViewer.setExpandedTreePaths(tps);
 357                         } else
 358                                 setOrderedInput(resultTreeViewer);
 359                 } else {
 360                         if (resultParent instanceof ParentNodeFolder) {
 361                                 ParentNodeFolder currFolder = (ParentNodeFolder) resultParent;
 362                                 jcrRefresh(currFolder.getNode());
 363                                 currFolder.forceFullRefresh();
 364                         }
 365                         // FIXME: specific refresh does not work
 366                         // resultTreeViewer.refresh(resultParent, true);
 367                         refresh(null);
 368                 }
 369         }
 370
 371         /**
 372          * refreshes the passed node and its corresponding subtree.
 373          *
 374          * @param node
 375          *            cannot be null
 376          *
 377          */
 378         public boolean jcrRefresh(Node node) {
 379                 // if (log.isDebugEnabled())
 380                 // log.debug(" JCR refreshing " + node + "...");
 381                 // Thread.dumpStack();
 382                 boolean isPassed = true;
 383                 try {
 384                         if (node.isNodeType(SlcTypes.SLC_TEST_RESULT)) {
 385                                 isPassed = node.getNode(SlcNames.SLC_AGGREGATED_STATUS)
 386                                                 .getProperty(SlcNames.SLC_SUCCESS).getBoolean();
 387                         } else if (node.isNodeType(SlcTypes.SLC_RESULT_FOLDER)) {
 388                                 NodeIterator ni = node.getNodes();
 389                                 while (ni.hasNext()) {
 390                                         Node currChild = ni.nextNode();
 391                                         isPassed = isPassed & jcrRefresh(currChild);
 392                                 }
 393                                 if (isPassed != node.getNode(SlcNames.SLC_AGGREGATED_STATUS)
 394                                                 .getProperty(SlcNames.SLC_SUCCESS).getBoolean()) {
 395                                         node.getNode(SlcNames.SLC_AGGREGATED_STATUS).setProperty(
 396                                                         SlcNames.SLC_SUCCESS, isPassed);
 397                                         node.getSession().save();
 398                                         return isPassed;
 399                                 }
 400                         } else
 401                                 ; // do nothing
 402                 } catch (RepositoryException e) {
 403                         throw new SlcException("Cannot register listeners", e);
 404                 }
 405                 return isPassed;
 406         }
 407
 408         private ResultParent[] initializeResultTree() {
 409                 try {
 410                         // Force initialization of the tree structure if needed
 411                         SlcJcrResultUtils.getSlcResultsParentNode(session);
 412                         SlcJcrResultUtils.getMyResultParentNode(session);
 413                         // Remove yesterday and last 7 days virtual folders
 414                         // ResultParent[] roots = new ResultParent[5];
 415                         ResultParent[] roots = new ResultParent[3];
 416
 417                         // My results
 418                         roots[0] = new ParentNodeFolder(null,
 419                                         SlcJcrResultUtils.getMyResultParentNode(session),
 420                                         SlcUiConstants.DEFAULT_MY_RESULTS_FOLDER_LABEL);
 421
 422                         // today
 423                         Calendar cal = Calendar.getInstance();
 424                         String relPath = JcrUtils.dateAsPath(cal);
 425                         List<String> datePathes = new ArrayList<String>();
 426                         datePathes.add(relPath);
 427                         roots[1] = new VirtualFolder(null,
 428                                         ResultParentUtils.getResultsForDates(session, datePathes),
 429                                         "Today");
 430
 431                         // // Yesterday
 432                         // cal = Calendar.getInstance();
 433                         // cal.add(Calendar.DAY_OF_YEAR, -1);
 434                         // relPath = JcrUtils.dateAsPath(cal);
 435                         // datePathes = new ArrayList<String>();
 436                         // datePathes.add(relPath);
 437                         // roots[2] = new VirtualFolder(null,
 438                         // ResultParentUtils.getResultsForDates(session, datePathes),
 439                         // "Yesterday");
 440                         // // Last 7 days
 441                         //
 442                         // cal = Calendar.getInstance();
 443                         // datePathes = new ArrayList<String>();
 444                         //
 445                         // for (int i = 0; i < 7; i++) {
 446                         // cal.add(Calendar.DAY_OF_YEAR, -i);
 447                         // relPath = JcrUtils.dateAsPath(cal);
 448                         // datePathes.add(relPath);
 449                         // }
 450                         // roots[3] = new VirtualFolder(null,
 451                         // ResultParentUtils.getResultsForDates(session, datePathes),
 452                         // "Last 7 days");
 453
 454                         // All results
 455                         Node otherResultsPar = session.getNode(SlcJcrResultUtils
 456                                         .getSlcResultsBasePath(session));
 457                         // roots[4] = new ParentNodeFolder(null, otherResultsPar,
 458                         // "All results");
 459                         roots[2] = new ParentNodeFolder(null, otherResultsPar,
 460                                         "All results");
 461                         return roots;
 462                 } catch (RepositoryException re) {
 463                         throw new SlcException(
 464                                         "Unexpected error while initializing ResultTree.", re);
 465                 }
 466         }
 467
 468         // Manage context menu
 469         /**
 470          * Defines the commands that will pop up in the context menu.
 471          **/
 472         protected void contextMenuAboutToShow(IMenuManager menuManager) {
 473                 IWorkbenchWindow window = ClientUiPlugin.getDefault().getWorkbench()
 474                                 .getActiveWorkbenchWindow();
 475
 476                 IStructuredSelection selection = (IStructuredSelection) resultTreeViewer
 477                                 .getSelection();
 478                 boolean canAddSubfolder = false;
 479                 boolean canRenamefolder = false;
 480                 boolean isSingleResultNode = false;
 481                 boolean isUnderMyResult = false;
 482                 boolean validMultipleDelete = false;
 483                 try {
 484
 485                         // Building conditions
 486                         if (selection.size() == 1) {
 487                                 Object obj = selection.getFirstElement();
 488                                 if (obj instanceof SingleResultNode)
 489                                         isSingleResultNode = true;
 490                                 else if (obj instanceof ParentNodeFolder) {
 491                                         Node cNode = ((ParentNodeFolder) obj).getNode();
 492                                         if (cNode.isNodeType(SlcTypes.SLC_RESULT_FOLDER)) {
 493                                                 canAddSubfolder = true;
 494                                                 canRenamefolder = true;
 495                                                 isUnderMyResult = true;
 496                                         } else if (cNode
 497                                                         .isNodeType(SlcTypes.SLC_MY_RESULT_ROOT_FOLDER)) {
 498                                                 canAddSubfolder = true;
 499                                         }
 500                                 }
 501                         } else {
 502                                 @SuppressWarnings("rawtypes")
 503                                 Iterator it = selection.iterator();
 504                                 multicheck: while (it.hasNext()) {
 505                                         validMultipleDelete = true;
 506                                         Object obj = it.next();
 507                                         if (obj instanceof SingleResultNode)
 508                                                 continue multicheck;
 509                                         else if (obj instanceof ParentNodeFolder) {
 510                                                 Node cNode = ((ParentNodeFolder) obj).getNode();
 511                                                 if (cNode.isNodeType(SlcTypes.SLC_RESULT_FOLDER))
 512                                                         continue multicheck;
 513                                                 else {
 514                                                         validMultipleDelete = false;
 515                                                         break multicheck;
 516                                                 }
 517                                         } else {
 518                                                 validMultipleDelete = false;
 519                                                 break multicheck;
 520                                         }
 521                                 }
 522                         }
 523                 } catch (RepositoryException re) {
 524                         throw new SlcException(
 525                                         "unexpected error while building condition for context menu",
 526                                         re);
 527                 }
 528
 529                 // Effective Refresh
 530                 CommandUtils.refreshCommand(menuManager, window,
 531                                 RefreshJcrResultTreeView.ID,
 532                                 RefreshJcrResultTreeView.DEFAULT_LABEL,
 533                                 RefreshJcrResultTreeView.DEFAULT_IMG_DESCRIPTOR, true);
 534
 535                 CommandUtils.refreshCommand(menuManager, window, DeleteItems.ID,
 536                                 DeleteItems.DEFAULT_LABEL, DeleteItems.DEFAULT_IMG_DESCRIPTOR,
 537                                 isUnderMyResult || isSingleResultNode || validMultipleDelete);
 538
 539                 CommandUtils.refreshCommand(menuManager, window, AddResultFolder.ID,
 540                                 AddResultFolder.DEFAULT_LABEL,
 541                                 ClientUiPlugin.getDefault().getWorkbench().getSharedImages()
 542                                                 .getImageDescriptor(ISharedImages.IMG_OBJ_ADD),
 543                                 canAddSubfolder);
 544
 545                 CommandUtils.refreshCommand(menuManager, window, RenameResultFolder.ID,
 546                                 RenameResultFolder.DEFAULT_LABEL,
 547                                 RenameResultFolder.DEFAULT_IMG_DESCRIPTOR, canRenamefolder);
 548
 549                 // Command removed for the time being.
 550                 CommandUtils.refreshCommand(menuManager, window, RenameResultNode.ID,
 551                                 RenameResultNode.DEFAULT_LABEL,
 552                                 RenameResultNode.DEFAULT_IMG_DESCRIPTOR, false);
 553
 554                 // Test to be removed
 555                 // If you use this pattern, do not forget to call
 556                 // menuManager.setRemoveAllWhenShown(true);
 557                 // when creating the menuManager
 558
 559                 // menuManager.add(new Action("Test") {
 560                 // public void run() {
 561                 // log.debug("do something");
 562                 // }
 563                 // });
 564         }
 565
 566         /* INNER CLASSES */
 567         class ViewDragListener implements DragSourceListener {
 568
 569                 public void dragStart(DragSourceEvent event) {
 570                         // Check if the drag action should start.
 571                         IStructuredSelection selection = (IStructuredSelection) resultTreeViewer
 572                                         .getSelection();
 573                         boolean doIt = false;
 574
 575                         // FIXME clean this code.
 576                         try {
 577                                 if (selection.size() == 1) {
 578                                         Object obj = selection.getFirstElement();
 579                                         if (obj instanceof ResultFolder) {
 580                                                 Node tNode = ((ResultFolder) obj).getNode();
 581                                                 if (tNode.getPrimaryNodeType().isNodeType(
 582                                                                 SlcTypes.SLC_RESULT_FOLDER)) {
 583                                                         doIt = true;
 584                                                         isResultFolder = true;
 585                                                 }
 586                                         } else
 587                                                 isResultFolder = false;
 588                                 } else
 589                                         isResultFolder = false;
 590
 591                                 if (!isResultFolder) {
 592                                         @SuppressWarnings("rawtypes")
 593                                         Iterator it = selection.iterator();
 594                                         while (it.hasNext()) {
 595                                                 Object obj = it.next();
 596                                                 if (obj instanceof SingleResultNode) {
 597                                                         Node tNode = ((SingleResultNode) obj).getNode();
 598                                                         if (tNode.getPrimaryNodeType().isNodeType(
 599                                                                         SlcTypes.SLC_TEST_RESULT)) {
 600                                                                 doIt = true;
 601                                                         }
 602                                                 }
 603                                         }
 604                                 }
 605
 606                         } catch (RepositoryException re) {
 607                                 throw new SlcException(
 608                                                 "unexpected error while validating drag source", re);
 609                         }
 610                         event.doit = doIt;
 611                 }
 612
 613                 public void dragSetData(DragSourceEvent event) {
 614                         IStructuredSelection selection = (IStructuredSelection) resultTreeViewer
 615                                         .getSelection();
 616
 617                         try {
 618                                 // specific case of a result folder
 619                                 if (isResultFolder) {
 620                                         Object obj = selection.getFirstElement();
 621                                         event.data = ((ResultFolder) obj).getNode().getIdentifier();
 622                                 } else {
 623                                         @SuppressWarnings("rawtypes")
 624                                         Iterator it = selection.iterator();
 625                                         StringBuilder nodes = new StringBuilder();
 626                                         while (it.hasNext()) {
 627                                                 Object obj = it.next();
 628                                                 if (obj instanceof SingleResultNode) {
 629                                                         Node tNode = ((SingleResultNode) obj).getNode();
 630                                                         if (tNode.getPrimaryNodeType().isNodeType(
 631                                                                         SlcTypes.SLC_TEST_RESULT)) {
 632                                                                 nodes.append(tNode.getIdentifier()).append(";");
 633                                                         }
 634                                                 }
 635                                         }
 636                                         event.data = nodes.toString();
 637                                 }
 638                         } catch (RepositoryException re) {
 639                                 throw new SlcException("unexpected error while setting data",
 640                                                 re);
 641                         }
 642                 }
 643
 644                 public void dragFinished(DragSourceEvent event) {
 645                         // refresh is done via observer
 646                 }
 647         }
 648
 649         // Implementation of the Drop Listener
 650         protected class ViewDropListener extends ViewerDropAdapter {
 651                 private Node targetParentNode = null;
 652
 653                 public ViewDropListener(Viewer viewer) {
 654                         super(viewer);
 655                 }
 656
 657                 @Override
 658                 public boolean validateDrop(Object target, int operation,
 659                                 TransferData transferType) {
 660                         boolean validDrop = false;
 661                         try {
 662                                 // We can only drop under myResults
 663                                 Node tpNode = null;
 664                                 if (target instanceof SingleResultNode) {
 665                                         Node currNode = ((SingleResultNode) target).getNode();
 666                                         String pPath = currNode.getParent().getPath();
 667                                         if (pPath.startsWith(SlcJcrResultUtils
 668                                                         .getMyResultsBasePath(session)))
 669                                                 tpNode = currNode.getParent();
 670                                 } else if (target instanceof ResultFolder) {
 671                                         tpNode = ((ResultFolder) target).getNode();
 672                                 } else if (target instanceof ParentNodeFolder) {
 673                                         Node node = ((ParentNodeFolder) target).getNode();
 674                                         if (node.isNodeType(SlcTypes.SLC_MY_RESULT_ROOT_FOLDER))
 675                                                 tpNode = ((ParentNodeFolder) target).getNode();
 676                                 }
 677
 678                                 if (tpNode != null) {
 679                                         targetParentNode = tpNode;
 680                                         validDrop = true;
 681                                 }
 682                         } catch (RepositoryException re) {
 683                                 throw new SlcException(
 684                                                 "unexpected error while validating drop target", re);
 685                         }
 686                         return validDrop;
 687                 }
 688
 689                 @Override
 690                 public boolean performDrop(Object data) {
 691                         // clear selection to prevent unwanted scrolling of the UI
 692                         resultTreeViewer.setSelection(null);
 693                         try {
 694                                 if (isResultFolder) {
 695                                         // Sanity check : we cannot move a folder to one of its sub
 696                                         // folder or neither move an object in the same parent
 697                                         // folder
 698                                         Node source = session.getNodeByIdentifier((String) data);
 699                                         if (targetParentNode.getPath().startsWith(source.getPath())
 700                                                         || source.getParent().getPath()
 701                                                                         .equals(targetParentNode.getPath()))
 702                                                 return false;
 703
 704                                         // Move
 705                                         String sourcePath = source.getPath();
 706                                         String destPath = targetParentNode.getPath() + "/"
 707                                                         + source.getName();
 708                                         session.move(sourcePath, destPath);
 709                                         // Update passed status of the parent source Node
 710                                         ResultParentUtils.updatePassedStatus(
 711                                                         session.getNode(JcrUtils.parentPath(sourcePath)),
 712                                                         true);
 713                                         // Node target = session.getNode(destPath);
 714                                         session.save();
 715                                         return true;
 716                                 }
 717
 718                                 String[] datas = ((String) data).split(";");
 719                                 nodesToCopy: for (String id : datas) {
 720
 721                                         Node source = session.getNodeByIdentifier(id);
 722                                         String name;
 723                                         if (source.hasProperty(Property.JCR_TITLE))
 724                                                 name = source.getProperty(Property.JCR_TITLE)
 725                                                                 .getString();
 726                                         else if (source.hasProperty(SlcNames.SLC_TEST_CASE))
 727                                                 name = source.getProperty(SlcNames.SLC_TEST_CASE)
 728                                                                 .getString();
 729                                         else
 730                                                 name = source.getName();
 731
 732                                         // Check if another copy of the same test instance already
 733                                         // exists at target
 734                                         NodeIterator ni = targetParentNode.getNodes();
 735                                         String slcUid = source.getProperty(SlcNames.SLC_UUID)
 736                                                         .getString();
 737                                         while (ni.hasNext()) {
 738                                                 Node curr = ni.nextNode();
 739                                                 if (curr.hasProperty(SlcNames.SLC_UUID)
 740                                                                 && slcUid.equals(curr.getProperty(
 741                                                                                 SlcNames.SLC_UUID).getString())) {
 742                                                         MessageDialog
 743                                                                         .openWarning(
 744                                                                                         PlatformUI.getWorkbench()
 745                                                                                                         .getDisplay()
 746                                                                                                         .getActiveShell(),
 747                                                                                         "Duplicated instance.",
 748                                                                                         "An instance of the same test case ("
 749                                                                                                         + name
 750                                                                                                         + ") exists at destination.\n "
 751                                                                                                         + "This item will not be neither copied nor moved.");
 752                                                         continue nodesToCopy;
 753
 754                                                 }
 755                                         }
 756
 757                                         Node target;
 758                                         boolean passedStatus = false;
 759                                         if (source.hasNode(SlcNames.SLC_AGGREGATED_STATUS))
 760                                                 passedStatus = source
 761                                                                 .getNode(SlcNames.SLC_AGGREGATED_STATUS)
 762                                                                 .getProperty(SlcNames.SLC_SUCCESS).getBoolean();
 763
 764                                         boolean isActionUnderMyResult = source.getPath()
 765                                                         .startsWith(
 766                                                                         SlcJcrResultUtils
 767                                                                                         .getMyResultsBasePath(session));
 768
 769                                         if (!isActionUnderMyResult) {// Copy
 770                                                 target = targetParentNode.addNode(source.getName(),
 771                                                                 source.getPrimaryNodeType().getName());
 772                                                 JcrUtils.copy(source, target);
 773                                         } else {// move
 774                                                 String sourcePath = source.getPath();
 775                                                 String destPath = targetParentNode.getPath() + "/"
 776                                                                 + name;
 777                                                 session.move(sourcePath, destPath);
 778                                                 // Update passed status of the parent source Node
 779                                                 ResultParentUtils
 780                                                                 .updatePassedStatus(session.getNode(JcrUtils
 781                                                                                 .parentPath(sourcePath)), true);
 782                                                 target = session.getNode(destPath);
 783
 784                                         }
 785                                         if (!target.isNodeType(NodeType.MIX_TITLE))
 786                                                 target.addMixin(NodeType.MIX_TITLE);
 787                                         target.setProperty(Property.JCR_TITLE, name);
 788                                         ResultParentUtils.updatePassedStatus(target.getParent(),
 789                                                         passedStatus);
 790                                         session.save();
 791                                 }
 792                         } catch (RepositoryException re) {
 793                                 throw new SlcException(
 794                                                 "unexpected error while copying dropped node", re);
 795
 796                         }
 797                         return true;
 798                 }
 799         }
 800
 801         class MyResultsObserver extends AsyncUiEventListener {
 802
 803                 public MyResultsObserver(Display display) {
 804                         super(display);
 805                 }
 806
 807                 @Override
 808                 protected Boolean willProcessInUiThread(List<Event> events)
 809                                 throws RepositoryException {
 810                         // unfiltered for the time being
 811                         return true;
 812                 }
 813
 814                 protected void onEventInUiThread(List<Event> events)
 815                                 throws RepositoryException {
 816                         List<Node> nodesToRefresh = new ArrayList<Node>();
 817
 818                         for (Event event : events) {
 819                                 String parPath = JcrUtils.parentPath(event.getPath());
 820                                 if (session.nodeExists(parPath)) {
 821                                         Node node = session.getNode(parPath);
 822                                         if (!nodesToRefresh.contains(node)) {
 823                                                 nodesToRefresh.add(node);
 824                                         }
 825                                 }
 826                         }
 827
 828                         // Update check nodes
 829                         for (Node node : nodesToRefresh)
 830                                 jcrRefresh(node);
 831                         refresh(null);
 832                 }
 833         }
 834
 835         class AllResultsObserver extends AsyncUiEventListener {
 836
 837                 public AllResultsObserver(Display display) {
 838                         super(display);
 839                 }
 840
 841                 @Override
 842                 protected Boolean willProcessInUiThread(List<Event> events)
 843                                 throws RepositoryException {
 844                         // unfiltered for the time being
 845                         return true;
 846                 }
 847
 848                 protected void onEventInUiThread(List<Event> events)
 849                                 throws RepositoryException {
 850                         refresh(null);
 851                         // if (lastSelectedSourceElementParent != null)
 852                         // refresh(lastSelectedSourceElementParent);
 853                 }
 854         }
 855
 856         class PropertiesContentProvider implements IStructuredContentProvider {
 857
 858                 public void dispose() {
 859                 }
 860
 861                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 862                 }
 863
 864                 public Object[] getElements(Object inputElement) {
 865                         try {
 866                                 if (inputElement instanceof Node) {
 867                                         Node node = (Node) inputElement;
 868                                         if (node.isNodeType(SlcTypes.SLC_TEST_RESULT)) {
 869                                                 List<Property> props = new ArrayList<Property>();
 870                                                 if (node.hasProperty(SlcNames.SLC_TEST_CASE))
 871                                                         props.add(node.getProperty(SlcNames.SLC_TEST_CASE));
 872                                                 if (node.hasProperty(SlcNames.SLC_COMPLETED))
 873                                                         props.add(node.getProperty(SlcNames.SLC_COMPLETED));
 874                                                 if (node.hasNode(SlcNames.SLC_AGGREGATED_STATUS)) {
 875                                                         Node status = node
 876                                                                         .getNode(SlcNames.SLC_AGGREGATED_STATUS);
 877                                                         props.add(status.getProperty(SlcNames.SLC_SUCCESS));
 878                                                         if (status.hasProperty(SlcNames.SLC_MESSAGE))
 879                                                                 props.add(status
 880                                                                                 .getProperty(SlcNames.SLC_MESSAGE));
 881                                                         if (status.hasProperty(SlcNames.SLC_ERROR_MESSAGE))
 882                                                                 props.add(status
 883                                                                                 .getProperty(SlcNames.SLC_ERROR_MESSAGE));
 884                                                 }
 885                                                 return props.toArray();
 886                                         }
 887                                 }
 888                                 return new Object[] {};
 889
 890                         } catch (RepositoryException e) {
 891                                 throw new SlcException("Cannot get element for "
 892                                                 + inputElement, e);
 893                         }
 894                 }
 895         }
 896
 897         class MySelectionChangedListener implements ISelectionChangedListener {
 898
 899                 public void selectionChanged(SelectionChangedEvent event) {
 900                         if (!event.getSelection().isEmpty()) {
 901                                 IStructuredSelection sel = (IStructuredSelection) event
 902                                                 .getSelection();
 903                                 ResultParent firstItem = (ResultParent) sel.getFirstElement();
 904                                 if (firstItem instanceof SingleResultNode)
 905                                         propertiesViewer.setInput(((SingleResultNode) firstItem)
 906                                                         .getNode());
 907                                 else
 908                                         propertiesViewer.setInput(null);
 909                                 // update cache for Drag & drop
 910                                 // lastSelectedTargetElement = firstItem;
 911                                 // lastSelectedSourceElement = firstItem;
 912                                 // lastSelectedSourceElementParent = (ResultParent) firstItem
 913                                 // .getParent();
 914                                 // String pPath = "";
 915                                 // try {
 916                                 //
 917                                 // if (firstItem instanceof ParentNodeFolder)
 918                                 // pPath = ((ParentNodeFolder) firstItem).getNode()
 919                                 // .getPath();
 920                                 // else if (firstItem instanceof SingleResultNode)
 921                                 // pPath = ((SingleResultNode) firstItem).getNode()
 922                                 // .getPath();
 923                                 // } catch (RepositoryException e) {
 924                                 // throw new SlcException(
 925                                 // "Unexpected error while checking parent UI tree", e);
 926                                 // }
 927                                 // if ((pPath.startsWith(SlcJcrResultUtils
 928                                 // .getMyResultsBasePath(session))))
 929                                 // isActionUnderMyResult = true;
 930                                 // else
 931                                 // isActionUnderMyResult = false;
 932                         }
 933                 }
 934         }
 935
 936         class ViewDoubleClickListener implements IDoubleClickListener {
 937                 public void doubleClick(DoubleClickEvent evt) {
 938                         processDoubleClick(evt);
 939                 }
 940
 941         }
 942
 943         /* DEPENDENCY INJECTION */
 944         public void dispose() {
 945                 // JcrUtils.unregisterQuietly(session.getWorkspace(), resultsObserver);
 946                 JcrUtils.logoutQuietly(session);
 947                 super.dispose();
 948         }
 949
 950         public void setRepository(Repository repository) {
 951                 this.repository = repository;
 952         }
 953 }