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