docs/source/XmlReader.html

   1 <html>\r
   2 <head>\r
   3   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />    \r
   4   <title>The source code</title>\r
   5     <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />\r
   6     <script type="text/javascript" src="../resources/prettify/prettify.js"></script>\r
   7 </head>\r
   8 <body  onload="prettyPrint();">\r
   9     <pre class="prettyprint lang-js"><div id="cls-Ext.data.XmlReader"></div>/**
  10  * @class Ext.data.XmlReader
  11  * @extends Ext.data.DataReader
  12  * <p>Data reader class to create an Array of {@link Ext.data.Record} objects from an XML document
  13  * based on mappings in a provided {@link Ext.data.Record} constructor.</p>
  14  * <p><b>Note</b>: that in order for the browser to parse a returned XML document, the Content-Type
  15  * header in the HTTP response must be set to "text/xml" or "application/xml".</p>
  16  * <p>Example code:</p>
  17  * <pre><code>
  18 var Employee = Ext.data.Record.create([
  19    {name: 'name', mapping: 'name'},     // "mapping" property not needed if it is the same as "name"
  20    {name: 'occupation'}                 // This field will use "occupation" as the mapping.
  21 ]);
  22 var myReader = new Ext.data.XmlReader({
  23    totalProperty: "results", // The element which contains the total dataset size (optional)
  24    record: "row",           // The repeated element which contains row information
  25    idProperty: "id"         // The element within the row that provides an ID for the record (optional)
  26    messageProperty: "msg"   // The element within the response that provides a user-feedback message (optional)
  27 }, Employee);
  28 </code></pre>
  29  * <p>
  30  * This would consume an XML file like this:
  31  * <pre><code>
  32 &lt;?xml version="1.0" encoding="UTF-8"?>
  33 &lt;dataset>
  34  &lt;results>2&lt;/results>
  35  &lt;row>
  36    &lt;id>1&lt;/id>
  37    &lt;name>Bill&lt;/name>
  38    &lt;occupation>Gardener&lt;/occupation>
  39  &lt;/row>
  40  &lt;row>
  41    &lt;id>2&lt;/id>
  42    &lt;name>Ben&lt;/name>
  43    &lt;occupation>Horticulturalist&lt;/occupation>
  44  &lt;/row>
  45 &lt;/dataset>
  46 </code></pre>
  47  * @cfg {String} totalProperty The DomQuery path from which to retrieve the total number of records
  48  * in the dataset. This is only needed if the whole dataset is not passed in one go, but is being
  49  * paged from the remote server.
  50  * @cfg {String} record The DomQuery path to the repeated element which contains record information.
  51  * @cfg {String} record The DomQuery path to the repeated element which contains record information.
  52  * @cfg {String} successProperty The DomQuery path to the success attribute used by forms.
  53  * @cfg {String} idPath The DomQuery path relative from the record element to the element that contains
  54  * a record identifier value.
  55  * @constructor
  56  * Create a new XmlReader.
  57  * @param {Object} meta Metadata configuration options
  58  * @param {Object} recordType Either an Array of field definition objects as passed to
  59  * {@link Ext.data.Record#create}, or a Record constructor object created using {@link Ext.data.Record#create}.
  60  */
  61 Ext.data.XmlReader = function(meta, recordType){
  62     meta = meta || {};
  63
  64     // backwards compat, convert idPath or id / success
  65     Ext.applyIf(meta, {
  66         idProperty: meta.idProperty || meta.idPath || meta.id,
  67         successProperty: meta.successProperty || meta.success
  68     });
  69
  70     Ext.data.XmlReader.superclass.constructor.call(this, meta, recordType || meta.fields);
  71 };
  72 Ext.extend(Ext.data.XmlReader, Ext.data.DataReader, {
  73     /**
  74      * This method is only used by a DataProxy which has retrieved data from a remote server.
  75      * @param {Object} response The XHR object which contains the parsed XML document.  The response is expected
  76      * to contain a property called <tt>responseXML</tt> which refers to an XML document object.
  77      * @return {Object} records A data block which is used by an {@link Ext.data.Store} as
  78      * a cache of Ext.data.Records.
  79      */
  80     read : function(response){
  81         var doc = response.responseXML;
  82         if(!doc) {
  83             throw {message: "XmlReader.read: XML Document not available"};
  84         }
  85         return this.readRecords(doc);
  86     },
  87
  88     /**
  89      * Create a data block containing Ext.data.Records from an XML document.
  90      * @param {Object} doc A parsed XML document.
  91      * @return {Object} records A data block which is used by an {@link Ext.data.Store} as
  92      * a cache of Ext.data.Records.
  93      */
  94     readRecords : function(doc){
  95         /**
  96          * After any data loads/reads, the raw XML Document is available for further custom processing.
  97          * @type XMLDocument
  98          */
  99         this.xmlData = doc;
 100
 101         var root    = doc.documentElement || doc,
 102             q       = Ext.DomQuery,
 103             totalRecords = 0,
 104             success = true;
 105
 106         if(this.meta.totalProperty){
 107             totalRecords = this.getTotal(root, 0);
 108         }
 109         if(this.meta.successProperty){
 110             success = this.getSuccess(root);
 111         }
 112
 113         var records = this.extractData(q.select(this.meta.record, root), true); // <-- true to return Ext.data.Record[]
 114
 115         // TODO return Ext.data.Response instance.  @see #readResponse
 116         return {
 117             success : success,
 118             records : records,
 119             totalRecords : totalRecords || records.length
 120         };
 121     },
 122
 123     /**
 124      * Decode a json response from server.
 125      * @param {String} action [{@link Ext.data.Api#actions} create|read|update|destroy]
 126      * @param {Object} response HTTP Response object from browser.
 127      * @return {Ext.data.Response} response Returns an instance of {@link Ext.data.Response}
 128      */
 129     readResponse : function(action, response) {
 130         var q   = Ext.DomQuery,
 131         doc     = response.responseXML;
 132
 133         // create general Response instance.
 134         var res = new Ext.data.Response({
 135             action: action,
 136             success : this.getSuccess(doc),
 137             message: this.getMessage(doc),
 138             data: this.extractData(q.select(this.meta.record, doc) || q.select(this.meta.root, doc), false),
 139             raw: doc
 140         });
 141
 142         if (Ext.isEmpty(res.success)) {
 143             throw new Ext.data.DataReader.Error('successProperty-response', this.meta.successProperty);
 144         }
 145
 146         // Create actions from a response having status 200 must return pk
 147         if (action === Ext.data.Api.actions.create) {
 148             var def = Ext.isDefined(res.data);
 149             if (def && Ext.isEmpty(res.data)) {
 150                 throw new Ext.data.JsonReader.Error('root-empty', this.meta.root);
 151             }
 152             else if (!def) {
 153                 throw new Ext.data.JsonReader.Error('root-undefined-response', this.meta.root);
 154             }
 155         }
 156         return res;
 157     },
 158
 159     getSuccess : function() {
 160         return true;
 161     },
 162
 163     /**
 164      * build response-data extractor functions.
 165      * @private
 166      * @ignore
 167      */
 168     buildExtractors : function() {
 169         if(this.ef){
 170             return;
 171         }
 172         var s       = this.meta,
 173             Record  = this.recordType,
 174             f       = Record.prototype.fields,
 175             fi      = f.items,
 176             fl      = f.length;
 177
 178         if(s.totalProperty) {
 179             this.getTotal = this.createAccessor(s.totalProperty);
 180         }
 181         if(s.successProperty) {
 182             this.getSuccess = this.createAccessor(s.successProperty);
 183         }
 184         if (s.messageProperty) {
 185             this.getMessage = this.createAccessor(s.messageProperty);
 186         }
 187         this.getRoot = function(res) {
 188             return (!Ext.isEmpty(res[this.meta.record])) ? res[this.meta.record] : res[this.meta.root];
 189         }
 190         if (s.idPath || s.idProperty) {
 191             var g = this.createAccessor(s.idPath || s.idProperty);
 192             this.getId = function(rec) {
 193                 var id = g(rec) || rec.id;
 194                 return (id === undefined || id === '') ? null : id;
 195             };
 196         } else {
 197             this.getId = function(){return null;};
 198         }
 199         var ef = [];
 200         for(var i = 0; i < fl; i++){
 201             f = fi[i];
 202             var map = (f.mapping !== undefined && f.mapping !== null) ? f.mapping : f.name;
 203             ef.push(this.createAccessor(map));
 204         }
 205         this.ef = ef;
 206     },
 207
 208     /**
 209      * Creates a function to return some particular key of data from a response.
 210      * @param {String} key
 211      * @return {Function}
 212      * @private
 213      * @ignore
 214      */
 215     createAccessor : function(){
 216         var q = Ext.DomQuery;
 217         return function(key) {
 218             switch(key) {
 219                 case this.meta.totalProperty:
 220                     return function(root, def){
 221                         return q.selectNumber(key, root, def);
 222                     }
 223                     break;
 224                 case this.meta.successProperty:
 225                     return function(root, def) {
 226                         var sv = q.selectValue(key, root, true);
 227                         var success = sv !== false && sv !== 'false';
 228                         return success;
 229                     }
 230                     break;
 231                 default:
 232                     return function(root, def) {
 233                         return q.selectValue(key, root, def);
 234                     }
 235                     break;
 236             }
 237         };
 238     }(),
 239
 240     /**
 241      * extracts values and type-casts a row of data from server, extracted by #extractData
 242      * @param {Hash} data
 243      * @param {Ext.data.Field[]} items
 244      * @param {Number} len
 245      * @private
 246      * @ignore
 247      */
 248     extractValues : function(data, items, len) {
 249         var f, values = {};
 250         for(var j = 0; j < len; j++){
 251             f = items[j];
 252             var v = this.ef[j](data);
 253             values[f.name] = f.convert((v !== undefined) ? v : f.defaultValue, data);
 254         }
 255         return values;
 256     }
 257 });</pre>    \r
 258 </body>\r
 259 </html>