docs/source/Proxy2.html

   1 <!DOCTYPE html>
   2 <html>
   3 <head>
   4   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
   5   <title>The source code</title>
   6   <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
   7   <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
   8   <style type="text/css">
   9     .highlight { display: block; background-color: #ddd; }
  10   </style>
  11   <script type="text/javascript">
  12     function highlight() {
  13       document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
  14     }
  15   </script>
  16 </head>
  17 <body onload="prettyPrint(); highlight();">
  18   <pre class="prettyprint lang-js"><span id='Ext-data-proxy-Proxy'>/**
  19 </span> * @author Ed Spencer
  20  *
  21  * Proxies are used by {@link Ext.data.Store Stores} to handle the loading and saving of {@link Ext.data.Model Model}
  22  * data. Usually developers will not need to create or interact with proxies directly.
  23  *
  24  * # Types of Proxy
  25  *
  26  * There are two main types of Proxy - {@link Ext.data.proxy.Client Client} and {@link Ext.data.proxy.Server Server}.
  27  * The Client proxies save their data locally and include the following subclasses:
  28  *
  29  * - {@link Ext.data.proxy.LocalStorage LocalStorageProxy} - saves its data to localStorage if the browser supports it
  30  * - {@link Ext.data.proxy.SessionStorage SessionStorageProxy} - saves its data to sessionStorage if the browsers supports it
  31  * - {@link Ext.data.proxy.Memory MemoryProxy} - holds data in memory only, any data is lost when the page is refreshed
  32  *
  33  * The Server proxies save their data by sending requests to some remote server. These proxies include:
  34  *
  35  * - {@link Ext.data.proxy.Ajax Ajax} - sends requests to a server on the same domain
  36  * - {@link Ext.data.proxy.JsonP JsonP} - uses JSON-P to send requests to a server on a different domain
  37  * - {@link Ext.data.proxy.Direct Direct} - uses {@link Ext.direct.Manager} to send requests
  38  *
  39  * Proxies operate on the principle that all operations performed are either Create, Read, Update or Delete. These four
  40  * operations are mapped to the methods {@link #create}, {@link #read}, {@link #update} and {@link #destroy}
  41  * respectively. Each Proxy subclass implements these functions.
  42  *
  43  * The CRUD methods each expect an {@link Ext.data.Operation Operation} object as the sole argument. The Operation
  44  * encapsulates information about the action the Store wishes to perform, the {@link Ext.data.Model model} instances
  45  * that are to be modified, etc. See the {@link Ext.data.Operation Operation} documentation for more details. Each CRUD
  46  * method also accepts a callback function to be called asynchronously on completion.
  47  *
  48  * Proxies also support batching of Operations via a {@link Ext.data.Batch batch} object, invoked by the {@link #batch}
  49  * method.
  50  */
  51 Ext.define('Ext.data.proxy.Proxy', {
  52     alias: 'proxy.proxy',
  53     alternateClassName: ['Ext.data.DataProxy', 'Ext.data.Proxy'],
  54     requires: [
  55         'Ext.data.reader.Json',
  56         'Ext.data.writer.Json'
  57     ],
  58     uses: [
  59         'Ext.data.Batch',
  60         'Ext.data.Operation',
  61         'Ext.data.Model'
  62     ],
  63     mixins: {
  64         observable: 'Ext.util.Observable'
  65     },
  66
  67 <span id='Ext-data-proxy-Proxy-cfg-batchOrder'>    /**
  68 </span>     * @cfg {String} batchOrder
  69      * Comma-separated ordering 'create', 'update' and 'destroy' actions when batching. Override this to set a different
  70      * order for the batched CRUD actions to be executed in. Defaults to 'create,update,destroy'.
  71      */
  72     batchOrder: 'create,update,destroy',
  73
  74 <span id='Ext-data-proxy-Proxy-cfg-batchActions'>    /**
  75 </span>     * @cfg {Boolean} batchActions
  76      * True to batch actions of a particular type when synchronizing the store. Defaults to true.
  77      */
  78     batchActions: true,
  79
  80 <span id='Ext-data-proxy-Proxy-cfg-defaultReaderType'>    /**
  81 </span>     * @cfg {String} defaultReaderType
  82      * The default registered reader type. Defaults to 'json'.
  83      * @private
  84      */
  85     defaultReaderType: 'json',
  86
  87 <span id='Ext-data-proxy-Proxy-cfg-defaultWriterType'>    /**
  88 </span>     * @cfg {String} defaultWriterType
  89      * The default registered writer type. Defaults to 'json'.
  90      * @private
  91      */
  92     defaultWriterType: 'json',
  93
  94 <span id='Ext-data-proxy-Proxy-cfg-model'>    /**
  95 </span>     * @cfg {String/Ext.data.Model} model
  96      * The name of the Model to tie to this Proxy. Can be either the string name of the Model, or a reference to the
  97      * Model constructor. Required.
  98      */
  99
 100 <span id='Ext-data-proxy-Proxy-cfg-reader'>    /**
 101 </span>     * @cfg {Object/String/Ext.data.reader.Reader} reader
 102      * The Ext.data.reader.Reader to use to decode the server's response or data read from client. This can either be a
 103      * Reader instance, a config object or just a valid Reader type name (e.g. 'json', 'xml').
 104      */
 105
 106 <span id='Ext-data-proxy-Proxy-cfg-writer'>    /**
 107 </span>     * @cfg {Object/String/Ext.data.writer.Writer} writer
 108      * The Ext.data.writer.Writer to use to encode any request sent to the server or saved to client. This can either be
 109      * a Writer instance, a config object or just a valid Writer type name (e.g. 'json', 'xml').
 110      */
 111
 112     isProxy: true,
 113
 114 <span id='Ext-data-proxy-Proxy-method-constructor'>    /**
 115 </span>     * Creates the Proxy
 116      * @param {Object} config (optional) Config object.
 117      */
 118     constructor: function(config) {
 119         config = config || {};
 120
 121         if (config.model === undefined) {
 122             delete config.model;
 123         }
 124
 125         this.mixins.observable.constructor.call(this, config);
 126
 127         if (this.model !== undefined &amp;&amp; !(this.model instanceof Ext.data.Model)) {
 128             this.setModel(this.model);
 129         }
 130     },
 131
 132 <span id='Ext-data-proxy-Proxy-method-setModel'>    /**
 133 </span>     * Sets the model associated with this proxy. This will only usually be called by a Store
 134      *
 135      * @param {String/Ext.data.Model} model The new model. Can be either the model name string,
 136      * or a reference to the model's constructor
 137      * @param {Boolean} setOnStore Sets the new model on the associated Store, if one is present
 138      */
 139     setModel: function(model, setOnStore) {
 140         this.model = Ext.ModelManager.getModel(model);
 141
 142         var reader = this.reader,
 143             writer = this.writer;
 144
 145         this.setReader(reader);
 146         this.setWriter(writer);
 147
 148         if (setOnStore &amp;&amp; this.store) {
 149             this.store.setModel(this.model);
 150         }
 151     },
 152
 153 <span id='Ext-data-proxy-Proxy-method-getModel'>    /**
 154 </span>     * Returns the model attached to this Proxy
 155      * @return {Ext.data.Model} The model
 156      */
 157     getModel: function() {
 158         return this.model;
 159     },
 160
 161 <span id='Ext-data-proxy-Proxy-method-setReader'>    /**
 162 </span>     * Sets the Proxy's Reader by string, config object or Reader instance
 163      *
 164      * @param {String/Object/Ext.data.reader.Reader} reader The new Reader, which can be either a type string,
 165      * a configuration object or an Ext.data.reader.Reader instance
 166      * @return {Ext.data.reader.Reader} The attached Reader object
 167      */
 168     setReader: function(reader) {
 169         var me = this;
 170
 171         if (reader === undefined || typeof reader == 'string') {
 172             reader = {
 173                 type: reader
 174             };
 175         }
 176
 177         if (reader.isReader) {
 178             reader.setModel(me.model);
 179         } else {
 180             Ext.applyIf(reader, {
 181                 proxy: me,
 182                 model: me.model,
 183                 type : me.defaultReaderType
 184             });
 185
 186             reader = Ext.createByAlias('reader.' + reader.type, reader);
 187         }
 188
 189         me.reader = reader;
 190         return me.reader;
 191     },
 192
 193 <span id='Ext-data-proxy-Proxy-method-getReader'>    /**
 194 </span>     * Returns the reader currently attached to this proxy instance
 195      * @return {Ext.data.reader.Reader} The Reader instance
 196      */
 197     getReader: function() {
 198         return this.reader;
 199     },
 200
 201 <span id='Ext-data-proxy-Proxy-method-setWriter'>    /**
 202 </span>     * Sets the Proxy's Writer by string, config object or Writer instance
 203      *
 204      * @param {String/Object/Ext.data.writer.Writer} writer The new Writer, which can be either a type string,
 205      * a configuration object or an Ext.data.writer.Writer instance
 206      * @return {Ext.data.writer.Writer} The attached Writer object
 207      */
 208     setWriter: function(writer) {
 209         if (writer === undefined || typeof writer == 'string') {
 210             writer = {
 211                 type: writer
 212             };
 213         }
 214
 215         if (!(writer instanceof Ext.data.writer.Writer)) {
 216             Ext.applyIf(writer, {
 217                 model: this.model,
 218                 type : this.defaultWriterType
 219             });
 220
 221             writer = Ext.createByAlias('writer.' + writer.type, writer);
 222         }
 223
 224         this.writer = writer;
 225
 226         return this.writer;
 227     },
 228
 229 <span id='Ext-data-proxy-Proxy-method-getWriter'>    /**
 230 </span>     * Returns the writer currently attached to this proxy instance
 231      * @return {Ext.data.writer.Writer} The Writer instance
 232      */
 233     getWriter: function() {
 234         return this.writer;
 235     },
 236
 237 <span id='Ext-data-proxy-Proxy-method-create'>    /**
 238 </span>     * Performs the given create operation.
 239      * @param {Ext.data.Operation} operation The Operation to perform
 240      * @param {Function} callback Callback function to be called when the Operation has completed (whether successful or not)
 241      * @param {Object} scope Scope to execute the callback function in
 242      * @method
 243      */
 244     create: Ext.emptyFn,
 245
 246 <span id='Ext-data-proxy-Proxy-method-read'>    /**
 247 </span>     * Performs the given read operation.
 248      * @param {Ext.data.Operation} operation The Operation to perform
 249      * @param {Function} callback Callback function to be called when the Operation has completed (whether successful or not)
 250      * @param {Object} scope Scope to execute the callback function in
 251      * @method
 252      */
 253     read: Ext.emptyFn,
 254
 255 <span id='Ext-data-proxy-Proxy-method-update'>    /**
 256 </span>     * Performs the given update operation.
 257      * @param {Ext.data.Operation} operation The Operation to perform
 258      * @param {Function} callback Callback function to be called when the Operation has completed (whether successful or not)
 259      * @param {Object} scope Scope to execute the callback function in
 260      * @method
 261      */
 262     update: Ext.emptyFn,
 263
 264 <span id='Ext-data-proxy-Proxy-method-destroy'>    /**
 265 </span>     * Performs the given destroy operation.
 266      * @param {Ext.data.Operation} operation The Operation to perform
 267      * @param {Function} callback Callback function to be called when the Operation has completed (whether successful or not)
 268      * @param {Object} scope Scope to execute the callback function in
 269      * @method
 270      */
 271     destroy: Ext.emptyFn,
 272
 273 <span id='Ext-data-proxy-Proxy-method-batch'>    /**
 274 </span>     * Performs a batch of {@link Ext.data.Operation Operations}, in the order specified by {@link #batchOrder}. Used
 275      * internally by {@link Ext.data.Store}'s {@link Ext.data.Store#sync sync} method. Example usage:
 276      *
 277      *     myProxy.batch({
 278      *         create : [myModel1, myModel2],
 279      *         update : [myModel3],
 280      *         destroy: [myModel4, myModel5]
 281      *     });
 282      *
 283      * Where the myModel* above are {@link Ext.data.Model Model} instances - in this case 1 and 2 are new instances and
 284      * have not been saved before, 3 has been saved previously but needs to be updated, and 4 and 5 have already been
 285      * saved but should now be destroyed.
 286      *
 287      * @param {Object} operations Object containing the Model instances to act upon, keyed by action name
 288      * @param {Object} listeners (optional) listeners object passed straight through to the Batch -
 289      * see {@link Ext.data.Batch}
 290      * @return {Ext.data.Batch} The newly created Ext.data.Batch object
 291      */
 292     batch: function(operations, listeners) {
 293         var me = this,
 294             batch = Ext.create('Ext.data.Batch', {
 295                 proxy: me,
 296                 listeners: listeners || {}
 297             }),
 298             useBatch = me.batchActions,
 299             records;
 300
 301         Ext.each(me.batchOrder.split(','), function(action) {
 302             records = operations[action];
 303             if (records) {
 304                 if (useBatch) {
 305                     batch.add(Ext.create('Ext.data.Operation', {
 306                         action: action,
 307                         records: records
 308                     }));
 309                 } else {
 310                     Ext.each(records, function(record){
 311                         batch.add(Ext.create('Ext.data.Operation', {
 312                             action : action,
 313                             records: [record]
 314                         }));
 315                     });
 316                 }
 317             }
 318         }, me);
 319
 320         batch.start();
 321         return batch;
 322     }
 323 }, function() {
 324     // Ext.data.proxy.ProxyMgr.registerType('proxy', this);
 325
 326     //backwards compatibility
 327     Ext.data.DataProxy = this;
 328     // Ext.deprecate('platform', '2.0', function() {
 329     //     Ext.data.DataProxy = this;
 330     // }, this);
 331 });
 332 </pre>
 333 </body>
 334 </html>