eclipse/plugins/runtime/org.argeo.slc.client.core/src/main/java/org/argeo/slc/client/contentprovider/ResultDetailContentProvider.java

   1 package org.argeo.slc.client.contentprovider;
   2
   3 import java.util.List;
   4 import java.util.SortedMap;
   5
   6 import org.apache.commons.logging.Log;
   7 import org.apache.commons.logging.LogFactory;
   8 import org.argeo.eclipse.ui.TreeObject;
   9 import org.argeo.eclipse.ui.TreeParent;
  10 import org.argeo.slc.core.structure.tree.TreeSPath;
  11 import org.argeo.slc.core.test.tree.PartSubList;
  12 import org.argeo.slc.core.test.tree.TreeTestResult;
  13 import org.argeo.slc.test.TestResultPart;
  14 import org.eclipse.jface.viewers.ITreeContentProvider;
  15 import org.eclipse.jface.viewers.Viewer;
  16
  17 /**
  18  * Basic tree view of the chosen process details
  19  */
  20 public class ResultDetailContentProvider implements ITreeContentProvider {
  21         private final static Log log = LogFactory
  22                         .getLog(ResultDetailContentProvider.class);
  23
  24         private TreeTestResult treeTestResult;
  25
  26         public Object[] getChildren(Object parent) {
  27                 if (parent instanceof TreeTestResult) {
  28                         log.error("We should not reach this point.");
  29                         return null;
  30                 }
  31
  32                 if (parent instanceof TreeParent) {
  33                         return ((TreeParent) parent).getChildren();
  34                 }
  35
  36                 if (parent instanceof ResultPartNode) {
  37                         // we reached a leaf
  38                         return null;
  39                 }
  40                 return null;
  41         }
  42
  43         public Object getParent(Object node) {
  44                 if (node instanceof TreeObject) {
  45                         return ((TreeObject) node).getParent();
  46                 }
  47                 return null;
  48         }
  49
  50         public boolean hasChildren(Object parent) {
  51                 if (parent instanceof TreeParent && ((TreeParent) parent).isLoaded()) {
  52                         return ((TreeParent) parent).hasChildren();
  53                 }
  54                 return false;
  55         }
  56
  57         public void inputChanged(Viewer v, Object oldInput, Object newInput) {
  58         }
  59
  60         public void dispose() {
  61         }
  62
  63         public Object[] getElements(Object parent) {
  64                 if (parent instanceof TreeTestResult) {
  65                         treeTestResult = (TreeTestResult) parent;
  66
  67                         // We wrap domain object in ViewSpecificObjects.
  68                         ResultTreeParent root = new ResultTreeParent("Test "
  69                                         + treeTestResult.getUuid());
  70                         SortedMap<TreeSPath, PartSubList> partSubLists = treeTestResult
  71                                         .getResultParts();
  72
  73                         for (TreeSPath key : partSubLists.keySet()) {
  74                                 String relPath = key.getAsUniqueString();
  75
  76                                 // get rid of '/' that begins every TreeSPath Unique string
  77                                 relPath = relPath.substring(1);
  78                                 String[] pathes = relPath.split("/"); // parse the TreeSPath
  79                                 ResultTreeParent curTreeParent = root;
  80
  81                                 // We create intermediate folders if needed
  82                                 for (int i = 0; i < pathes.length; i++) {
  83                                         if (log.isDebugEnabled())
  84                                                 log.debug("i = " + i + " - " + pathes[i]);
  85
  86                                         if (curTreeParent.getChildByName(pathes[i]) == null) {
  87                                                 ResultTreeParent child = new ResultTreeParent(pathes[i]);
  88                                                 curTreeParent.addChild(child);
  89                                                 curTreeParent = child;
  90                                         } else
  91                                                 curTreeParent = (ResultTreeParent) curTreeParent
  92                                                                 .getChildByName(pathes[i]);
  93                                 }
  94
  95                                 // We create leafs
  96                                 List<TestResultPart> parts = partSubLists.get(key).getParts();
  97                                 for (TestResultPart part : parts) {
  98                                         ResultPartNode node = new ResultPartNode(part.toString(),
  99                                                         part.getStatus(), part.getMessage(),
 100                                                         part.getExceptionMessage());
 101                                         curTreeParent.addChild(node);
 102                                 }
 103                         }
 104
 105                         // We must set status isPassed for each node.
 106                         setIsPassed(root);
 107                         return root.getChildren();
 108                 }
 109                 return null;
 110         }
 111
 112         public void setIsPassed(StatusAware node) {
 113
 114                 if (node instanceof ResultTreeObject) {
 115                         ResultTreeObject rto = (ResultTreeObject) node;
 116                         rto.isPassed = rto.isPassed();
 117                         return;
 118                 }
 119                 if (node instanceof ResultTreeParent) {
 120                         ResultTreeParent rtp = (ResultTreeParent) node;
 121                         // we dig the tree recursivly
 122                         for (TreeObject to : rtp.getChildren())
 123                                 setIsPassed((StatusAware) to);
 124                         // we set is passed
 125                         for (TreeObject to : rtp.getChildren()) {
 126                                 if (!((StatusAware) to).isPassed()) {
 127                                         rtp.isPassed = false;
 128                                         return;
 129                                 }
 130                         }
 131                         return;
 132                 }
 133         }
 134
 135         // To enable display of color to show if a test is passed or not even when
 136         // hidden. We say a test is in error if its status is FAILED or ERROR (e.g,
 137         // if it has not executed completely due to technical problems).
 138         public interface StatusAware {
 139                 public void setPassed(boolean isPassed);
 140
 141                 public boolean isPassed();
 142         }
 143
 144         public class ResultTreeParent extends TreeParent implements StatusAware {
 145
 146                 public ResultTreeParent(String name) {
 147                         super(name);
 148                 }
 149
 150                 private boolean isPassed = true;
 151
 152                 public void setPassed(boolean isPassed) {
 153                         this.isPassed = isPassed;
 154                 }
 155
 156                 public boolean isPassed() {
 157                         return isPassed;
 158                 }
 159         }
 160
 161         public class ResultTreeObject extends TreeObject implements StatusAware {
 162
 163                 public ResultTreeObject(String name) {
 164                         super(name);
 165                 }
 166
 167                 private boolean isPassed = true;
 168
 169                 public void setPassed(boolean isPassed) {
 170                         this.isPassed = isPassed;
 171                 }
 172
 173                 public boolean isPassed() {
 174                         return isPassed;
 175                 }
 176         }
 177
 178         // Specific inner classes
 179         public class ResultPartNode extends ResultTreeObject {
 180
 181                 private String status;
 182                 private String message;
 183                 private String exceptionMessage;
 184
 185                 public ResultPartNode(String label, Integer status, String message) {
 186                         super(label);
 187                         handleStatus(status);
 188                         this.message = message;
 189                 }
 190
 191                 public ResultPartNode(String label, Integer status, String message,
 192                                 String exceptionMessage) {
 193                         super(label);
 194                         handleStatus(status);
 195                         this.message = message;
 196                         this.exceptionMessage = exceptionMessage;
 197                 }
 198
 199                 private void handleStatus(Integer status) {
 200                         switch (status) {
 201                         case 0:
 202                                 this.status = "PASSED";
 203                                 setPassed(true);
 204                                 break;
 205                         case 1:
 206                                 this.status = "FAILED";
 207                                 setPassed(false);
 208                                 break;
 209                         case 2:
 210                                 this.status = "ERROR";
 211                                 setPassed(false);
 212                                 break;
 213                         }
 214                         // for the moment being we don't have a relevant label
 215                 }
 216
 217                 public String getStatus() {
 218                         return status;
 219                 }
 220
 221                 public String getMessage() {
 222                         return message;
 223                 }
 224
 225                 public String getExceptionMessage() {
 226                         return exceptionMessage;
 227                 }
 228         }
 229 }