server/org.argeo.slc.ria/src/argeo-ria-lib/slc/class/org/argeo/slc/ria/Applet.js

   1 /**
   2  * The canonical SLC applet for test result viewing. It will display a TreeTestResult in a TreeVirtual component
   3  * composed of four columns : test name, state (passed/failed/error), message and date.
   4  *
   5  * It makes use of the StatusCellRenderer class for the "state" cell being a background-colored cell, the color depending on the FAILED or PASSED state message.
   6  * The only associated command is the "Close" command.
   7  */
   8 qx.Class.define("org.argeo.slc.ria.Applet",
   9 {
  10   extend : qx.ui.container.Composite,
  11   implement : [org.argeo.ria.components.IView],
  12
  13   construct : function(){
  14         this.base(arguments);
  15         this.setLayout(new qx.ui.layout.VBox());
  16         this.passedStatus = "PASSED";
  17         this.failedStatus = "FAILED";
  18         this.loaded = false;
  19   },
  20
  21   properties :
  22   {
  23         /**
  24          * The viewPane inside which this applet is added.
  25          */
  26         view : {
  27                 init : null
  28         },
  29         viewSelection : {
  30                 nullable:false,
  31                 check:"org.argeo.ria.components.ViewSelection"
  32         },
  33         instanceId : {
  34                 init : ""
  35         },
  36         instanceLabel : {
  37                 init : ""
  38         },
  39         /**
  40          * Commands definition, see {@link org.argeo.ria.event.CommandsManager#definitions}
  41          */
  42         commands : {
  43                 init : {
  44                         "close" : {
  45                                 label           : "Close Current",
  46                                 icon            : "resource/slc/window-close.png",
  47                                 shortcut        : "Control+w",
  48                                 enabled         : true,
  49                                 menu            : "Test",
  50                                 toolbar         : "result",
  51                                 callback        : function(e){
  52                                         this.getView().closeCurrent();
  53                                         //this.getView().empty();
  54
  55                                 },
  56                                 command         : null
  57                         }
  58                         /*,
  59                         "copytocollection" : {
  60                                 shared          : true,
  61                                 selectionChange : function(viewId, xmlNode){
  62                                         if(viewId != "applet") return;
  63                                         if(!xmlNode){
  64                                                 this.setEnabled(false);
  65                                         }else{
  66                                                 this.setEnabled(true);
  67                                         }
  68                                 }
  69                         },
  70                         "deletetest" : {
  71                                 shared          : true,
  72                                 callback        : function(e){
  73                                         //this.debug(this);
  74                                         alert("Should delete applet selection in " + this.getInstanceId());
  75                                 },
  76                                 selectionChange : function(viewId, xmlNode){
  77                                         if(viewId != "applet") return;
  78                                         if(!xmlNode){
  79                                                 this.setEnabled(false);
  80                                         }else{
  81                                                 this.setEnabled(true);
  82                                         }
  83                                 }
  84                         }
  85                         */
  86                 }
  87         }
  88   },
  89
  90   members :
  91   {
  92         init : function(viewPane, xmlNode){
  93                 this.setView(viewPane);
  94                 this.setViewSelection(new org.argeo.ria.components.ViewSelection(viewPane.getViewId()));
  95                 this.data = xmlNode;
  96                 if(this.data){
  97                         this.testId = org.argeo.ria.util.Element.getSingleNodeText(this.data, "slc:uuid");
  98                         this.setInstanceId("test:"+this.testId);
  99                         this.setInstanceLabel("Test " + this.testId.substring(0,4)+"...");
 100                 }
 101         },
 102
 103         load : function(){
 104                 if(!this.data) return;
 105                 if(this.loaded) return;
 106                 // Load XML or Whatever
 107                 var service;
 108                 //this.testId = qx.dom.Node.getText(org.argeo.ria.util.Element.selectSingleNode(this.data, "slc:uuid"));
 109                 this.getView().setViewTitle("Test "+this.testId);
 110                 var request = org.argeo.slc.ria.SlcApi.getLoadResultService(this.testId);
 111                 request.addListener("completed", function(response){
 112                         this.createXmlGui(response.getContent());
 113                         this.getView().setOnLoad(false);
 114                         this.loaded = true;
 115                 }, this);
 116                 this.getView().setOnLoad(true);
 117                 request.send();
 118
 119         },
 120
 121         addScroll : function(){
 122                 return false;
 123         },
 124
 125         close : function(){
 126
 127         },
 128
 129         /**
 130          * Creates the GUI.
 131          * @param responseXml {Document} The xml response of the "load" query.
 132          */
 133         createXmlGui : function(responseXml){
 134                 var NSMap = {
 135                         "slc" : "http://argeo.org/projects/slc/schemas"
 136                 }
 137                 if(!qx.Class.hasMixin(qx.ui.treevirtual.TreeVirtual, qx.ui.treevirtual.MNode)){
 138                         qx.Class.include(qx.ui.treevirtual.TreeVirtual,qx.ui.treevirtual.MNode);
 139                 }
 140                 this.tree = new qx.ui.treevirtual.TreeVirtual(["Test", "State", "Message", "Id"]);
 141                 this.tree.getTableColumnModel().setDataCellRenderer(0, new org.argeo.ria.util.TreeDataCellRenderer());
 142                 this.tree.getDataRowRenderer().setHighlightFocusRow(false); // Default row renderer
 143                 this.tree.setRowHeight(18);
 144                 this.tree.setStatusBarVisible(false);
 145                 this.tree.setDecorator(new qx.ui.decoration.Background("#fff"));
 146                 var model = this.tree.getDataModel();
 147                 var resNodes = org.argeo.ria.util.Element.selectNodes(responseXml, "//slc:result-part", NSMap);
 148                 var resultParts = {};
 149                 var addedPaths = {};
 150                 for(var i=0;i<resNodes.length;i++){
 151                         var currentParentId = null;
 152                         var node = resNodes[i];
 153                         var pathAttr = qx.xml.Element.getSingleNodeText(node, "@path");
 154                         var pathParts = pathAttr.split("/");
 155                         if(pathParts[0] == ""){
 156                                 pathParts.shift();
 157                         }
 158                         var crtPath = "";
 159                         for(var j=0;j<pathParts.length;j++){
 160                                 //if(pathParts[j] == "") continue;
 161                                 crtPath = crtPath.concat("/", pathParts[j]);
 162                                 if(addedPaths[crtPath]) {
 163                                         currentParentId = addedPaths[crtPath];
 164                                         continue; // Node already exists, set as parent and go to next!
 165                                 }
 166                                 var element = org.argeo.ria.util.Element.selectSingleNode(responseXml, '//slc:element[@path="'+crtPath+'"]', NSMap);
 167                                 var label;
 168                                 if(element != null){
 169                                         label = org.argeo.ria.util.Element.getSingleNodeText(element, "*/slc:label", NSMap);
 170                                 }else{
 171                                         label = crtPath;
 172                                 }
 173                                 var simpleResults = org.argeo.ria.util.Element.selectNodes(node, "slc:part-sub-list/slc:parts/slc:simple-result-part", NSMap);
 174
 175                                 var newId;
 176                                 //newId = model.addBranch(currentParentId, label, false);
 177
 178                                 // Test Leaf Node
 179                                 if(!simpleResults || !simpleResults.length){
 180                                         newId = model.addBranch(currentParentId, label, false);
 181                                         addedPaths[crtPath] = newId;
 182                                         currentParentId = newId;
 183                                         continue;
 184                                 }
 185                                 if(simpleResults.length == 1){
 186                                         //newId = model.addBranch(currentParentId, label, false);
 187                                         var sResNode = simpleResults[0];
 188                                         newId = model.addBranch(currentParentId, label);
 189                                         model.setColumnData(newId, 3, org.argeo.ria.util.Element.getSingleNodeText(sResNode, "slc:test-run-uuid", NSMap));
 190                                         model.setColumnData(newId, 2, org.argeo.ria.util.Element.getSingleNodeText(sResNode, "slc:message", NSMap));
 191                                         var status = org.argeo.ria.util.Element.getSingleNodeText(sResNode, "slc:status", NSMap);
 192                                         if(status != "PASSED"){
 193                                                 status = this.failedStatus ;
 194                                                 this._setParentBranchAsFailed(newId);
 195                                         }else{
 196                                                 status = this.passedStatus;
 197                                         }
 198                                         model.setColumnData(newId, 1, status);
 199                                         addedPaths[crtPath] = newId;
 200                                         currentParentId = newId;
 201                                         continue;
 202                                 }
 203                                 newId = model.addBranch(currentParentId, label, false);
 204                                 for(var k=0;k<simpleResults.length;k++){
 205                                         var sResNode = simpleResults[k];
 206                                         resId = model.addLeaf(currentParentId, label);
 207                                         model.setColumnData(resId, 3, org.argeo.ria.util.Element.getSingleNodeText(sResNode, "slc:test-run-uuid", NSMap));
 208                                         model.setColumnData(resId, 2, org.argeo.ria.util.Element.getSingleNodeText(sResNode, "slc:message", NSMap));
 209                                         var status = org.argeo.ria.util.Element.getSingleNodeText(sResNode, "slc:status", NSMap);
 210                                         if(status != "PASSED"){
 211                                                 status = this.failedStatus ;
 212                                                 this._setParentBranchAsFailed(resId);
 213                                         }else{
 214                                                 status = this.passedStatus;
 215                                         }
 216                                         model.setColumnData(resId, 1, status);
 217                                 }
 218
 219                                 addedPaths[crtPath] = newId;
 220                                 currentParentId = newId;
 221                         }
 222                 }
 223                 this._refineLeaves(this.tree, 0);
 224                 this.add(this.tree, {flex:1});
 225                 model.setData();
 226                 var columnModel = this.tree.getTableColumnModel();
 227                 var resize = columnModel.getBehavior();
 228                 resize.set(0, {width:250, minWidth:250});
 229                 resize.set(1, {width:55});
 230                 resize.set(2, {width:"1*"});
 231                 resize.set(3, {width:150});
 232                 columnModel.setDataCellRenderer(1, new org.argeo.slc.ria.StatusCellRenderer());
 233
 234             this.tree.getSelectionManager().getSelectionModel().addListener("changeSelection", function(e){
 235                         var viewSelection = this.getViewSelection();
 236                         viewSelection.clear();
 237                         var nodes = this.tree.getDataModel().getSelectedNodes();
 238                         if(nodes.length){
 239                                 viewSelection.addNode(nodes[0]);
 240                         }
 241                         this.getView().focus();
 242                 }, this);
 243
 244                 var contextMenu = org.argeo.ria.event.CommandsManager.getInstance().createMenuFromIds(["close"]);
 245                 this.tree.setContextMenu(contextMenu);
 246
 247         },
 248
 249         /**
 250          * Goes up the parents recursively to set a whole tree branch in "failed" mode.
 251          * @param id {Integer} The id of the child node.
 252          */
 253         _setParentBranchAsFailed : function(id){
 254                 var model = this.tree.getDataModel();
 255                 while(id != null && id!=0){
 256                         var node = this.tree.nodeGet(id);
 257                         id = node.parentNodeId;
 258                         if(id != null && id!=0){
 259                                 model.setColumnData(id, 1, this.failedStatus);
 260                                 this.tree.nodeSetOpened(id, true);
 261                         }
 262                 }
 263         },
 264
 265         /**
 266          * Recursively make sur the last children are of qx.ui.treevirtual.SimpleTreeDataModel.Type.LEAF type.
 267          *
 268          * @param tree {qx.ui.treevirtual.TreeVirtual} The main tree of the applet.
 269          * @param nodeId {Integer} Current node id.
 270          */
 271         _refineLeaves : function(tree, nodeId){
 272                 var node = tree.nodeGet(nodeId);
 273                 if(node.children && node.children.length){
 274                         for(var i=0;i<node.children.length;i++){
 275                                 this._refineLeaves(tree, node.children[i]);
 276                         }
 277                 }else{
 278                         node.type = qx.ui.treevirtual.SimpleTreeDataModel.Type.LEAF;
 279                 }
 280         },
 281
 282         /**
 283          * Alternatively to the createXmlGui, create a simple HtmlElement and append the query responseText.
 284          * Not used but sample.
 285          * @param responseText {String} Html code to display.
 286          */
 287         createHtmlGui : function(responseText){
 288                 var htmlElement = new qx.ui.embed.Html(responseText);
 289                 htmlElement.setOverflowX("auto");
 290                 htmlElement.setOverflowY("auto");
 291                 this.add(htmlElement, {flex:1});
 292         }
 293
 294   }
 295 });