docs/source/JsonReader.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.JsonReader"></div>/**
  10  * @class Ext.data.JsonReader
  11  * @extends Ext.data.DataReader
  12  * <p>Data reader class to create an Array of {@link Ext.data.Record} objects
  13  * from a JSON packet based on mappings in a provided {@link Ext.data.Record}
  14  * constructor.</p>
  15  * <p>Example code:</p>
  16  * <pre><code>
  17 var myReader = new Ext.data.JsonReader({
  18     // metadata configuration options:
  19     {@link #idProperty}: 'id'
  20     {@link #root}: 'rows',
  21     {@link #totalProperty}: 'results',
  22     {@link Ext.data.DataReader#messageProperty}: "msg"  // The element within the response that provides a user-feedback message (optional)
  23
  24     // the fields config option will internally create an {@link Ext.data.Record}
  25     // constructor that provides mapping for reading the record data objects
  26     {@link Ext.data.DataReader#fields fields}: [
  27         // map Record&#39;s 'firstname' field to data object&#39;s key of same name
  28         {name: 'name'},
  29         // map Record&#39;s 'job' field to data object&#39;s 'occupation' key
  30         {name: 'job', mapping: 'occupation'}
  31     ]
  32 });
  33 </code></pre>
  34  * <p>This would consume a JSON data object of the form:</p><pre><code>
  35 {
  36     results: 2000, // Reader&#39;s configured {@link #totalProperty}
  37     rows: [        // Reader&#39;s configured {@link #root}
  38         // record data objects:
  39         { {@link #idProperty id}: 1, firstname: 'Bill', occupation: 'Gardener' },
  40         { {@link #idProperty id}: 2, firstname: 'Ben' , occupation: 'Horticulturalist' },
  41         ...
  42     ]
  43 }
  44 </code></pre>
  45  * <p><b><u>Automatic configuration using metaData</u></b></p>
  46  * <p>It is possible to change a JsonReader's metadata at any time by including
  47  * a <b><tt>metaData</tt></b> property in the JSON data object. If the JSON data
  48  * object has a <b><tt>metaData</tt></b> property, a {@link Ext.data.Store Store}
  49  * object using this Reader will reconfigure itself to use the newly provided
  50  * field definition and fire its {@link Ext.data.Store#metachange metachange}
  51  * event. The metachange event handler may interrogate the <b><tt>metaData</tt></b>
  52  * property to perform any configuration required.</p>
  53  * <p>Note that reconfiguring a Store potentially invalidates objects which may
  54  * refer to Fields or Records which no longer exist.</p>
  55  * <p>To use this facility you would create the JsonReader like this:</p><pre><code>
  56 var myReader = new Ext.data.JsonReader();
  57 </code></pre>
  58  * <p>The first data packet from the server would configure the reader by
  59  * containing a <b><tt>metaData</tt></b> property <b>and</b> the data. For
  60  * example, the JSON data object might take the form:</p><pre><code>
  61 {
  62     metaData: {
  63         "{@link #idProperty}": "id",
  64         "{@link #root}": "rows",
  65         "{@link #totalProperty}": "results"
  66         "{@link #successProperty}": "success",
  67         "{@link Ext.data.DataReader#fields fields}": [
  68             {"name": "name"},
  69             {"name": "job", "mapping": "occupation"}
  70         ],
  71         // used by store to set its sortInfo
  72         "sortInfo":{
  73            "field": "name",
  74            "direction": "ASC"
  75         },
  76         // {@link Ext.PagingToolbar paging data} (if applicable)
  77         "start": 0,
  78         "limit": 2,
  79         // custom property
  80         "foo": "bar"
  81     },
  82     // Reader&#39;s configured {@link #successProperty}
  83     "success": true,
  84     // Reader&#39;s configured {@link #totalProperty}
  85     "results": 2000,
  86     // Reader&#39;s configured {@link #root}
  87     // (this data simulates 2 results {@link Ext.PagingToolbar per page})
  88     "rows": [ // <b>*Note:</b> this must be an Array
  89         { "id": 1, "name": "Bill", "occupation": "Gardener" },
  90         { "id": 2, "name":  "Ben", "occupation": "Horticulturalist" }
  91     ]
  92 }
  93  * </code></pre>
  94  * <p>The <b><tt>metaData</tt></b> property in the JSON data object should contain:</p>
  95  * <div class="mdetail-params"><ul>
  96  * <li>any of the configuration options for this class</li>
  97  * <li>a <b><tt>{@link Ext.data.Record#fields fields}</tt></b> property which
  98  * the JsonReader will use as an argument to the
  99  * {@link Ext.data.Record#create data Record create method} in order to
 100  * configure the layout of the Records it will produce.</li>
 101  * <li>a <b><tt>{@link Ext.data.Store#sortInfo sortInfo}</tt></b> property
 102  * which the JsonReader will use to set the {@link Ext.data.Store}'s
 103  * {@link Ext.data.Store#sortInfo sortInfo} property</li>
 104  * <li>any custom properties needed</li>
 105  * </ul></div>
 106  *
 107  * @constructor
 108  * Create a new JsonReader
 109  * @param {Object} meta Metadata configuration options.
 110  * @param {Array/Object} recordType
 111  * <p>Either an Array of {@link Ext.data.Field Field} definition objects (which
 112  * will be passed to {@link Ext.data.Record#create}, or a {@link Ext.data.Record Record}
 113  * constructor created from {@link Ext.data.Record#create}.</p>
 114  */
 115 Ext.data.JsonReader = function(meta, recordType){
 116     meta = meta || {};
 117     <div id="cfg-Ext.data.JsonReader-idProperty"></div>/**
 118      * @cfg {String} idProperty [id] Name of the property within a row object
 119      * that contains a record identifier value.  Defaults to <tt>id</tt>
 120      */
 121     <div id="cfg-Ext.data.JsonReader-successProperty"></div>/**
 122      * @cfg {String} successProperty [success] Name of the property from which to
 123      * retrieve the success attribute. Defaults to <tt>success</tt>.  See
 124      * {@link Ext.data.DataProxy}.{@link Ext.data.DataProxy#exception exception}
 125      * for additional information.
 126      */
 127     <div id="cfg-Ext.data.JsonReader-totalProperty"></div>/**
 128      * @cfg {String} totalProperty [total] Name of the property from which to
 129      * retrieve the total number of records in the dataset. This is only needed
 130      * if the whole dataset is not passed in one go, but is being paged from
 131      * the remote server.  Defaults to <tt>total</tt>.
 132      */
 133     <div id="cfg-Ext.data.JsonReader-root"></div>/**
 134      * @cfg {String} root [undefined] <b>Required</b>.  The name of the property
 135      * which contains the Array of row objects.  Defaults to <tt>undefined</tt>.
 136      * An exception will be thrown if the root property is undefined. The data
 137      * packet value for this property should be an empty array to clear the data
 138      * or show no data.
 139      */
 140     Ext.applyIf(meta, {
 141         idProperty: 'id',
 142         successProperty: 'success',
 143         totalProperty: 'total'
 144     });
 145
 146     Ext.data.JsonReader.superclass.constructor.call(this, meta, recordType || meta.fields);
 147 };
 148 Ext.extend(Ext.data.JsonReader, Ext.data.DataReader, {
 149     <div id="prop-Ext.data.JsonReader-meta"></div>/**
 150      * This JsonReader's metadata as passed to the constructor, or as passed in
 151      * the last data packet's <b><tt>metaData</tt></b> property.
 152      * @type Mixed
 153      * @property meta
 154      */
 155     <div id="method-Ext.data.JsonReader-read"></div>/**
 156      * This method is only used by a DataProxy which has retrieved data from a remote server.
 157      * @param {Object} response The XHR object which contains the JSON data in its responseText.
 158      * @return {Object} data A data block which is used by an Ext.data.Store object as
 159      * a cache of Ext.data.Records.
 160      */
 161     read : function(response){
 162         var json = response.responseText;
 163         var o = Ext.decode(json);
 164         if(!o) {
 165             throw {message: 'JsonReader.read: Json object not found'};
 166         }
 167         return this.readRecords(o);
 168     },
 169
 170     <div id="method-Ext.data.JsonReader-readResponse"></div>/**
 171      * Decode a json response from server.
 172      * @param {String} action [Ext.data.Api.actions.create|read|update|destroy]
 173      * @param {Object} response
 174      * TODO: refactor code between JsonReader#readRecords, #readResponse into 1 method.
 175      * there's ugly duplication going on due to maintaining backwards compat. with 2.0.  It's time to do this.
 176      */
 177     readResponse : function(action, response) {
 178         var o = (response.responseText !== undefined) ? Ext.decode(response.responseText) : response;
 179         if(!o) {
 180             throw new Ext.data.JsonReader.Error('response');
 181         }
 182
 183         var root = this.getRoot(o);
 184         if (action === Ext.data.Api.actions.create) {
 185             var def = Ext.isDefined(root);
 186             if (def && Ext.isEmpty(root)) {
 187                 throw new Ext.data.JsonReader.Error('root-empty', this.meta.root);
 188             }
 189             else if (!def) {
 190                 throw new Ext.data.JsonReader.Error('root-undefined-response', this.meta.root);
 191             }
 192         }
 193
 194         // instantiate response object
 195         var res = new Ext.data.Response({
 196             action: action,
 197             success: this.getSuccess(o),
 198             data: (root) ? this.extractData(root, false) : [],
 199             message: this.getMessage(o),
 200             raw: o
 201         });
 202
 203         // blow up if no successProperty
 204         if (Ext.isEmpty(res.success)) {
 205             throw new Ext.data.JsonReader.Error('successProperty-response', this.meta.successProperty);
 206         }
 207         return res;
 208     },
 209
 210     <div id="method-Ext.data.JsonReader-readRecords"></div>/**
 211      * Create a data block containing Ext.data.Records from a JSON object.
 212      * @param {Object} o An object which contains an Array of row objects in the property specified
 213      * in the config as 'root, and optionally a property, specified in the config as 'totalProperty'
 214      * which contains the total size of the dataset.
 215      * @return {Object} data A data block which is used by an Ext.data.Store object as
 216      * a cache of Ext.data.Records.
 217      */
 218     readRecords : function(o){
 219         <div id="prop-Ext.data.JsonReader-jsonData"></div>/**
 220          * After any data loads, the raw JSON data is available for further custom processing.  If no data is
 221          * loaded or there is a load exception this property will be undefined.
 222          * @type Object
 223          */
 224         this.jsonData = o;
 225         if(o.metaData){
 226             this.onMetaChange(o.metaData);
 227         }
 228         var s = this.meta, Record = this.recordType,
 229             f = Record.prototype.fields, fi = f.items, fl = f.length, v;
 230
 231         var root = this.getRoot(o), c = root.length, totalRecords = c, success = true;
 232         if(s.totalProperty){
 233             v = parseInt(this.getTotal(o), 10);
 234             if(!isNaN(v)){
 235                 totalRecords = v;
 236             }
 237         }
 238         if(s.successProperty){
 239             v = this.getSuccess(o);
 240             if(v === false || v === 'false'){
 241                 success = false;
 242             }
 243         }
 244
 245         // TODO return Ext.data.Response instance instead.  @see #readResponse
 246         return {
 247             success : success,
 248             records : this.extractData(root, true), // <-- true to return [Ext.data.Record]
 249             totalRecords : totalRecords
 250         };
 251     },
 252
 253     // private
 254     buildExtractors : function() {
 255         if(this.ef){
 256             return;
 257         }
 258         var s = this.meta, Record = this.recordType,
 259             f = Record.prototype.fields, fi = f.items, fl = f.length;
 260
 261         if(s.totalProperty) {
 262             this.getTotal = this.createAccessor(s.totalProperty);
 263         }
 264         if(s.successProperty) {
 265             this.getSuccess = this.createAccessor(s.successProperty);
 266         }
 267         if (s.messageProperty) {
 268             this.getMessage = this.createAccessor(s.messageProperty);
 269         }
 270         this.getRoot = s.root ? this.createAccessor(s.root) : function(p){return p;};
 271         if (s.id || s.idProperty) {
 272             var g = this.createAccessor(s.id || s.idProperty);
 273             this.getId = function(rec) {
 274                 var r = g(rec);
 275                 return (r === undefined || r === '') ? null : r;
 276             };
 277         } else {
 278             this.getId = function(){return null;};
 279         }
 280         var ef = [];
 281         for(var i = 0; i < fl; i++){
 282             f = fi[i];
 283             var map = (f.mapping !== undefined && f.mapping !== null) ? f.mapping : f.name;
 284             ef.push(this.createAccessor(map));
 285         }
 286         this.ef = ef;
 287     },
 288
 289     /**
 290      * @ignore
 291      * TODO This isn't used anywhere??  Don't we want to use this where possible instead of complex #createAccessor?
 292      */
 293     simpleAccess : function(obj, subsc) {
 294         return obj[subsc];
 295     },
 296
 297     /**
 298      * @ignore
 299      */
 300     createAccessor : function(){
 301         var re = /[\[\.]/;
 302         return function(expr) {
 303             if(Ext.isEmpty(expr)){
 304                 return Ext.emptyFn;
 305             }
 306             if(Ext.isFunction(expr)){
 307                 return expr;
 308             }
 309             var i = String(expr).search(re);
 310             if(i >= 0){
 311                 return new Function('obj', 'return obj' + (i > 0 ? '.' : '') + expr);
 312             }
 313             return function(obj){
 314                 return obj[expr];
 315             };
 316
 317         };
 318     }(),
 319
 320     /**
 321      * type-casts a single row of raw-data from server
 322      * @param {Object} data
 323      * @param {Array} items
 324      * @param {Integer} len
 325      * @private
 326      */
 327     extractValues : function(data, items, len) {
 328         var f, values = {};
 329         for(var j = 0; j < len; j++){
 330             f = items[j];
 331             var v = this.ef[j](data);
 332             values[f.name] = f.convert((v !== undefined) ? v : f.defaultValue, data);
 333         }
 334         return values;
 335     }
 336 });
 337
 338 <div id="cls-Ext.data.JsonReader.Error"></div>/**
 339  * @class Ext.data.JsonReader.Error
 340  * Error class for JsonReader
 341  */
 342 Ext.data.JsonReader.Error = Ext.extend(Ext.Error, {
 343     constructor : function(message, arg) {
 344         this.arg = arg;
 345         Ext.Error.call(this, message);
 346     },
 347     name : 'Ext.data.JsonReader'
 348 });
 349 Ext.apply(Ext.data.JsonReader.Error.prototype, {
 350     lang: {
 351         'response': 'An error occurred while json-decoding your server response',
 352         'successProperty-response': 'Could not locate your "successProperty" in your server response.  Please review your JsonReader config to ensure the config-property "successProperty" matches the property in your server-response.  See the JsonReader docs.',
 353         'root-undefined-config': 'Your JsonReader was configured without a "root" property.  Please review your JsonReader config and make sure to define the root property.  See the JsonReader docs.',
 354         'idProperty-undefined' : 'Your JsonReader was configured without an "idProperty"  Please review your JsonReader configuration and ensure the "idProperty" is set (e.g.: "id").  See the JsonReader docs.',
 355         'root-empty': 'Data was expected to be returned by the server in the "root" property of the response.  Please review your JsonReader configuration to ensure the "root" property matches that returned in the server-response.  See JsonReader docs.'
 356     }
 357 });
 358 </pre>    \r
 359 </body>\r
 360 </html>