Upgrade to ExtJS 3.3.1 - Released 11/30/2010
[extjs.git] / docs / source / DataProxy.html
1 <html>
2 <head>
3   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />    
4   <title>The source code</title>
5     <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
6     <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
7 </head>
8 <body  onload="prettyPrint();">
9     <pre class="prettyprint lang-js">/*!
10  * Ext JS Library 3.3.1
11  * Copyright(c) 2006-2010 Sencha Inc.
12  * licensing@sencha.com
13  * http://www.sencha.com/license
14  */
15 <div id="cls-Ext.data.DataProxy"></div>/**
16  * @class Ext.data.DataProxy
17  * @extends Ext.util.Observable
18  * <p>Abstract base class for implementations which provide retrieval of unformatted data objects.
19  * This class is intended to be extended and should not be created directly. For existing implementations,
20  * see {@link Ext.data.DirectProxy}, {@link Ext.data.HttpProxy}, {@link Ext.data.ScriptTagProxy} and
21  * {@link Ext.data.MemoryProxy}.</p>
22  * <p>DataProxy implementations are usually used in conjunction with an implementation of {@link Ext.data.DataReader}
23  * (of the appropriate type which knows how to parse the data object) to provide a block of
24  * {@link Ext.data.Records} to an {@link Ext.data.Store}.</p>
25  * <p>The parameter to a DataProxy constructor may be an {@link Ext.data.Connection} or can also be the
26  * config object to an {@link Ext.data.Connection}.</p>
27  * <p>Custom implementations must implement either the <code><b>doRequest</b></code> method (preferred) or the
28  * <code>load</code> method (deprecated). See
29  * {@link Ext.data.HttpProxy}.{@link Ext.data.HttpProxy#doRequest doRequest} or
30  * {@link Ext.data.HttpProxy}.{@link Ext.data.HttpProxy#load load} for additional details.</p>
31  * <p><b><u>Example 1</u></b></p>
32  * <pre><code>
33 proxy: new Ext.data.ScriptTagProxy({
34     {@link Ext.data.Connection#url url}: 'http://extjs.com/forum/topics-remote.php'
35 }),
36  * </code></pre>
37  * <p><b><u>Example 2</u></b></p>
38  * <pre><code>
39 proxy : new Ext.data.HttpProxy({
40     {@link Ext.data.Connection#method method}: 'GET',
41     {@link Ext.data.HttpProxy#prettyUrls prettyUrls}: false,
42     {@link Ext.data.Connection#url url}: 'local/default.php', // see options parameter for {@link Ext.Ajax#request}
43     {@link #api}: {
44         // all actions except the following will use above url
45         create  : 'local/new.php',
46         update  : 'local/update.php'
47     }
48 }),
49  * </code></pre>
50  * <p>And <b>new in Ext version 3</b>, attach centralized event-listeners upon the DataProxy class itself!  This is a great place
51  * to implement a <i>messaging system</i> to centralize your application's user-feedback and error-handling.</p>
52  * <pre><code>
53 // Listen to all "beforewrite" event fired by all proxies.
54 Ext.data.DataProxy.on('beforewrite', function(proxy, action) {
55     console.log('beforewrite: ', action);
56 });
57
58 // Listen to "write" event fired by all proxies
59 Ext.data.DataProxy.on('write', function(proxy, action, data, res, rs) {
60     console.info('write: ', action);
61 });
62
63 // Listen to "exception" event fired by all proxies
64 Ext.data.DataProxy.on('exception', function(proxy, type, action, exception) {
65     console.error(type + action + ' exception);
66 });
67  * </code></pre>
68  * <b>Note:</b> These three events are all fired with the signature of the corresponding <i>DataProxy instance</i> event {@link #beforewrite beforewrite}, {@link #write write} and {@link #exception exception}.
69  */
70 Ext.data.DataProxy = function(conn){
71     // make sure we have a config object here to support ux proxies.
72     // All proxies should now send config into superclass constructor.
73     conn = conn || {};
74
75     // This line caused a bug when people use custom Connection object having its own request method.
76     // http://extjs.com/forum/showthread.php?t=67194.  Have to set DataProxy config
77     //Ext.applyIf(this, conn);
78
79     this.api     = conn.api;
80     this.url     = conn.url;
81     this.restful = conn.restful;
82     this.listeners = conn.listeners;
83
84     // deprecated
85     this.prettyUrls = conn.prettyUrls;
86
87     <div id="cfg-Ext.data.DataProxy-api"></div>/**
88      * @cfg {Object} api
89      * Specific urls to call on CRUD action methods "read", "create", "update" and "destroy".
90      * Defaults to:<pre><code>
91 api: {
92     read    : undefined,
93     create  : undefined,
94     update  : undefined,
95     destroy : undefined
96 }
97      * </code></pre>
98      * <p>The url is built based upon the action being executed <tt>[load|create|save|destroy]</tt>
99      * using the commensurate <tt>{@link #api}</tt> property, or if undefined default to the
100      * configured {@link Ext.data.Store}.{@link Ext.data.Store#url url}.</p><br>
101      * <p>For example:</p>
102      * <pre><code>
103 api: {
104     load :    '/controller/load',
105     create :  '/controller/new',  // Server MUST return idProperty of new record
106     save :    '/controller/update',
107     destroy : '/controller/destroy_action'
108 }
109
110 // Alternatively, one can use the object-form to specify each API-action
111 api: {
112     load: {url: 'read.php', method: 'GET'},
113     create: 'create.php',
114     destroy: 'destroy.php',
115     save: 'update.php'
116 }
117      * </code></pre>
118      * <p>If the specific URL for a given CRUD action is undefined, the CRUD action request
119      * will be directed to the configured <tt>{@link Ext.data.Connection#url url}</tt>.</p>
120      * <br><p><b>Note</b>: To modify the URL for an action dynamically the appropriate API
121      * property should be modified before the action is requested using the corresponding before
122      * action event.  For example to modify the URL associated with the load action:
123      * <pre><code>
124 // modify the url for the action
125 myStore.on({
126     beforeload: {
127         fn: function (store, options) {
128             // use <tt>{@link Ext.data.HttpProxy#setUrl setUrl}</tt> to change the URL for *just* this request.
129             store.proxy.setUrl('changed1.php');
130
131             // set optional second parameter to true to make this URL change
132             // permanent, applying this URL for all subsequent requests.
133             store.proxy.setUrl('changed1.php', true);
134
135             // Altering the proxy API should be done using the public
136             // method <tt>{@link Ext.data.DataProxy#setApi setApi}</tt>.
137             store.proxy.setApi('read', 'changed2.php');
138
139             // Or set the entire API with a config-object.
140             // When using the config-object option, you must redefine the <b>entire</b>
141             // API -- not just a specific action of it.
142             store.proxy.setApi({
143                 read    : 'changed_read.php',
144                 create  : 'changed_create.php',
145                 update  : 'changed_update.php',
146                 destroy : 'changed_destroy.php'
147             });
148         }
149     }
150 });
151      * </code></pre>
152      * </p>
153      */
154
155     this.addEvents(
156         <div id="event-Ext.data.DataProxy-exception"></div>/**
157          * @event exception
158          * <p>Fires if an exception occurs in the Proxy during a remote request. This event is relayed
159          * through a corresponding {@link Ext.data.Store}.{@link Ext.data.Store#exception exception},
160          * so any Store instance may observe this event.</p>
161          * <p>In addition to being fired through the DataProxy instance that raised the event, this event is also fired
162          * through the Ext.data.DataProxy <i>class</i> to allow for centralized processing of exception events from <b>all</b>
163          * DataProxies by attaching a listener to the Ext.data.DataProxy class itself.</p>
164          * <p>This event can be fired for one of two reasons:</p>
165          * <div class="mdetail-params"><ul>
166          * <li>remote-request <b>failed</b> : <div class="sub-desc">
167          * The server did not return status === 200.
168          * </div></li>
169          * <li>remote-request <b>succeeded</b> : <div class="sub-desc">
170          * The remote-request succeeded but the reader could not read the response.
171          * This means the server returned data, but the configured Reader threw an
172          * error while reading the response.  In this case, this event will be
173          * raised and the caught error will be passed along into this event.
174          * </div></li>
175          * </ul></div>
176          * <br><p>This event fires with two different contexts based upon the 2nd
177          * parameter <tt>type [remote|response]</tt>.  The first four parameters
178          * are identical between the two contexts -- only the final two parameters
179          * differ.</p>
180          * @param {DataProxy} this The proxy that sent the request
181          * @param {String} type
182          * <p>The value of this parameter will be either <tt>'response'</tt> or <tt>'remote'</tt>.</p>
183          * <div class="mdetail-params"><ul>
184          * <li><b><tt>'response'</tt></b> : <div class="sub-desc">
185          * <p>An <b>invalid</b> response from the server was returned: either 404,
186          * 500 or the response meta-data does not match that defined in the DataReader
187          * (e.g.: root, idProperty, successProperty).</p>
188          * </div></li>
189          * <li><b><tt>'remote'</tt></b> : <div class="sub-desc">
190          * <p>A <b>valid</b> response was returned from the server having
191          * successProperty === false.  This response might contain an error-message
192          * sent from the server.  For example, the user may have failed
193          * authentication/authorization or a database validation error occurred.</p>
194          * </div></li>
195          * </ul></div>
196          * @param {String} action Name of the action (see {@link Ext.data.Api#actions}.
197          * @param {Object} options The options for the action that were specified in the {@link #request}.
198          * @param {Object} response
199          * <p>The value of this parameter depends on the value of the <code>type</code> parameter:</p>
200          * <div class="mdetail-params"><ul>
201          * <li><b><tt>'response'</tt></b> : <div class="sub-desc">
202          * <p>The raw browser response object (e.g.: XMLHttpRequest)</p>
203          * </div></li>
204          * <li><b><tt>'remote'</tt></b> : <div class="sub-desc">
205          * <p>The decoded response object sent from the server.</p>
206          * </div></li>
207          * </ul></div>
208          * @param {Mixed} arg
209          * <p>The type and value of this parameter depends on the value of the <code>type</code> parameter:</p>
210          * <div class="mdetail-params"><ul>
211          * <li><b><tt>'response'</tt></b> : Error<div class="sub-desc">
212          * <p>The JavaScript Error object caught if the configured Reader could not read the data.
213          * If the remote request returns success===false, this parameter will be null.</p>
214          * </div></li>
215          * <li><b><tt>'remote'</tt></b> : Record/Record[]<div class="sub-desc">
216          * <p>This parameter will only exist if the <tt>action</tt> was a <b>write</b> action
217          * (Ext.data.Api.actions.create|update|destroy).</p>
218          * </div></li>
219          * </ul></div>
220          */
221         'exception',
222         <div id="event-Ext.data.DataProxy-beforeload"></div>/**
223          * @event beforeload
224          * Fires before a request to retrieve a data object.
225          * @param {DataProxy} this The proxy for the request
226          * @param {Object} params The params object passed to the {@link #request} function
227          */
228         'beforeload',
229         <div id="event-Ext.data.DataProxy-load"></div>/**
230          * @event load
231          * Fires before the load method's callback is called.
232          * @param {DataProxy} this The proxy for the request
233          * @param {Object} o The request transaction object
234          * @param {Object} options The callback's <tt>options</tt> property as passed to the {@link #request} function
235          */
236         'load',
237         <div id="event-Ext.data.DataProxy-loadexception"></div>/**
238          * @event loadexception
239          * <p>This event is <b>deprecated</b>.  The signature of the loadexception event
240          * varies depending on the proxy, use the catch-all {@link #exception} event instead.
241          * This event will fire in addition to the {@link #exception} event.</p>
242          * @param {misc} misc See {@link #exception}.
243          * @deprecated
244          */
245         'loadexception',
246         <div id="event-Ext.data.DataProxy-beforewrite"></div>/**
247          * @event beforewrite
248          * <p>Fires before a request is generated for one of the actions Ext.data.Api.actions.create|update|destroy</p>
249          * <p>In addition to being fired through the DataProxy instance that raised the event, this event is also fired
250          * through the Ext.data.DataProxy <i>class</i> to allow for centralized processing of beforewrite events from <b>all</b>
251          * DataProxies by attaching a listener to the Ext.data.DataProxy class itself.</p>
252          * @param {DataProxy} this The proxy for the request
253          * @param {String} action [Ext.data.Api.actions.create|update|destroy]
254          * @param {Record/Record[]} rs The Record(s) to create|update|destroy.
255          * @param {Object} params The request <code>params</code> object.  Edit <code>params</code> to add parameters to the request.
256          */
257         'beforewrite',
258         <div id="event-Ext.data.DataProxy-write"></div>/**
259          * @event write
260          * <p>Fires before the request-callback is called</p>
261          * <p>In addition to being fired through the DataProxy instance that raised the event, this event is also fired
262          * through the Ext.data.DataProxy <i>class</i> to allow for centralized processing of write events from <b>all</b>
263          * DataProxies by attaching a listener to the Ext.data.DataProxy class itself.</p>
264          * @param {DataProxy} this The proxy that sent the request
265          * @param {String} action [Ext.data.Api.actions.create|upate|destroy]
266          * @param {Object} data The data object extracted from the server-response
267          * @param {Object} response The decoded response from server
268          * @param {Record/Record[]} rs The Record(s) from Store
269          * @param {Object} options The callback's <tt>options</tt> property as passed to the {@link #request} function
270          */
271         'write'
272     );
273     Ext.data.DataProxy.superclass.constructor.call(this);
274
275     // Prepare the proxy api.  Ensures all API-actions are defined with the Object-form.
276     try {
277         Ext.data.Api.prepare(this);
278     } catch (e) {
279         if (e instanceof Ext.data.Api.Error) {
280             e.toConsole();
281         }
282     }
283     // relay each proxy's events onto Ext.data.DataProxy class for centralized Proxy-listening
284     Ext.data.DataProxy.relayEvents(this, ['beforewrite', 'write', 'exception']);
285 };
286
287 Ext.extend(Ext.data.DataProxy, Ext.util.Observable, {
288     <div id="cfg-Ext.data.DataProxy-restful"></div>/**
289      * @cfg {Boolean} restful
290      * <p>Defaults to <tt>false</tt>.  Set to <tt>true</tt> to operate in a RESTful manner.</p>
291      * <br><p> Note: this parameter will automatically be set to <tt>true</tt> if the
292      * {@link Ext.data.Store} it is plugged into is set to <code>restful: true</code>. If the
293      * Store is RESTful, there is no need to set this option on the proxy.</p>
294      * <br><p>RESTful implementations enable the serverside framework to automatically route
295      * actions sent to one url based upon the HTTP method, for example:
296      * <pre><code>
297 store: new Ext.data.Store({
298     restful: true,
299     proxy: new Ext.data.HttpProxy({url:'/users'}); // all requests sent to /users
300     ...
301 )}
302      * </code></pre>
303      * If there is no <code>{@link #api}</code> specified in the configuration of the proxy,
304      * all requests will be marshalled to a single RESTful url (/users) so the serverside
305      * framework can inspect the HTTP Method and act accordingly:
306      * <pre>
307 <u>Method</u>   <u>url</u>        <u>action</u>
308 POST     /users     create
309 GET      /users     read
310 PUT      /users/23  update
311 DESTROY  /users/23  delete
312      * </pre></p>
313      * <p>If set to <tt>true</tt>, a {@link Ext.data.Record#phantom non-phantom} record's
314      * {@link Ext.data.Record#id id} will be appended to the url. Some MVC (e.g., Ruby on Rails,
315      * Merb and Django) support segment based urls where the segments in the URL follow the
316      * Model-View-Controller approach:<pre><code>
317      * someSite.com/controller/action/id
318      * </code></pre>
319      * Where the segments in the url are typically:<div class="mdetail-params"><ul>
320      * <li>The first segment : represents the controller class that should be invoked.</li>
321      * <li>The second segment : represents the class function, or method, that should be called.</li>
322      * <li>The third segment : represents the ID (a variable typically passed to the method).</li>
323      * </ul></div></p>
324      * <br><p>Refer to <code>{@link Ext.data.DataProxy#api}</code> for additional information.</p>
325      */
326     restful: false,
327
328     <div id="method-Ext.data.DataProxy-setApi"></div>/**
329      * <p>Redefines the Proxy's API or a single action of an API. Can be called with two method signatures.</p>
330      * <p>If called with an object as the only parameter, the object should redefine the <b>entire</b> API, e.g.:</p><pre><code>
331 proxy.setApi({
332     read    : '/users/read',
333     create  : '/users/create',
334     update  : '/users/update',
335     destroy : '/users/destroy'
336 });
337 </code></pre>
338      * <p>If called with two parameters, the first parameter should be a string specifying the API action to
339      * redefine and the second parameter should be the URL (or function if using DirectProxy) to call for that action, e.g.:</p><pre><code>
340 proxy.setApi(Ext.data.Api.actions.read, '/users/new_load_url');
341 </code></pre>
342      * @param {String/Object} api An API specification object, or the name of an action.
343      * @param {String/Function} url The URL (or function if using DirectProxy) to call for the action.
344      */
345     setApi : function() {
346         if (arguments.length == 1) {
347             var valid = Ext.data.Api.isValid(arguments[0]);
348             if (valid === true) {
349                 this.api = arguments[0];
350             }
351             else {
352                 throw new Ext.data.Api.Error('invalid', valid);
353             }
354         }
355         else if (arguments.length == 2) {
356             if (!Ext.data.Api.isAction(arguments[0])) {
357                 throw new Ext.data.Api.Error('invalid', arguments[0]);
358             }
359             this.api[arguments[0]] = arguments[1];
360         }
361         Ext.data.Api.prepare(this);
362     },
363
364     <div id="method-Ext.data.DataProxy-isApiAction"></div>/**
365      * Returns true if the specified action is defined as a unique action in the api-config.
366      * request.  If all API-actions are routed to unique urls, the xaction parameter is unecessary.  However, if no api is defined
367      * and all Proxy actions are routed to DataProxy#url, the server-side will require the xaction parameter to perform a switch to
368      * the corresponding code for CRUD action.
369      * @param {String [Ext.data.Api.CREATE|READ|UPDATE|DESTROY]} action
370      * @return {Boolean}
371      */
372     isApiAction : function(action) {
373         return (this.api[action]) ? true : false;
374     },
375
376     <div id="method-Ext.data.DataProxy-request"></div>/**
377      * All proxy actions are executed through this method.  Automatically fires the "before" + action event
378      * @param {String} action Name of the action
379      * @param {Ext.data.Record/Ext.data.Record[]/null} rs Will be null when action is 'load'
380      * @param {Object} params
381      * @param {Ext.data.DataReader} reader
382      * @param {Function} callback
383      * @param {Object} scope The scope (<code>this</code> reference) in which the callback function is executed. Defaults to the Proxy object.
384      * @param {Object} options Any options specified for the action (e.g. see {@link Ext.data.Store#load}.
385      */
386     request : function(action, rs, params, reader, callback, scope, options) {
387         if (!this.api[action] && !this.load) {
388             throw new Ext.data.DataProxy.Error('action-undefined', action);
389         }
390         params = params || {};
391         if ((action === Ext.data.Api.actions.read) ? this.fireEvent("beforeload", this, params) : this.fireEvent("beforewrite", this, action, rs, params) !== false) {
392             this.doRequest.apply(this, arguments);
393         }
394         else {
395             callback.call(scope || this, null, options, false);
396         }
397     },
398
399
400     <div id="method-Ext.data.DataProxy-load"></div>/**
401      * <b>Deprecated</b> load method using old method signature. See {@doRequest} for preferred method.
402      * @deprecated
403      * @param {Object} params
404      * @param {Object} reader
405      * @param {Object} callback
406      * @param {Object} scope
407      * @param {Object} arg
408      */
409     load : null,
410
411     <div id="cfg-Ext.data.DataProxy-doRequest"></div>/**
412      * @cfg {Function} doRequest Abstract method that should be implemented in all subclasses.  <b>Note:</b> Should only be used by custom-proxy developers.
413      * (e.g.: {@link Ext.data.HttpProxy#doRequest HttpProxy.doRequest},
414      * {@link Ext.data.DirectProxy#doRequest DirectProxy.doRequest}).
415      */
416     doRequest : function(action, rs, params, reader, callback, scope, options) {
417         // default implementation of doRequest for backwards compatibility with 2.0 proxies.
418         // If we're executing here, the action is probably "load".
419         // Call with the pre-3.0 method signature.
420         this.load(params, reader, callback, scope, options);
421     },
422
423     <div id="cfg-Ext.data.DataProxy-onRead"></div>/**
424      * @cfg {Function} onRead Abstract method that should be implemented in all subclasses.  <b>Note:</b> Should only be used by custom-proxy developers.  Callback for read {@link Ext.data.Api#actions action}.
425      * @param {String} action Action name as per {@link Ext.data.Api.actions#read}.
426      * @param {Object} o The request transaction object
427      * @param {Object} res The server response
428      * @fires loadexception (deprecated)
429      * @fires exception
430      * @fires load
431      * @protected
432      */
433     onRead : Ext.emptyFn,
434     <div id="cfg-Ext.data.DataProxy-onWrite"></div>/**
435      * @cfg {Function} onWrite Abstract method that should be implemented in all subclasses.  <b>Note:</b> Should only be used by custom-proxy developers.  Callback for <i>create, update and destroy</i> {@link Ext.data.Api#actions actions}.
436      * @param {String} action [Ext.data.Api.actions.create|read|update|destroy]
437      * @param {Object} trans The request transaction object
438      * @param {Object} res The server response
439      * @fires exception
440      * @fires write
441      * @protected
442      */
443     onWrite : Ext.emptyFn,
444     /**
445      * buildUrl
446      * Sets the appropriate url based upon the action being executed.  If restful is true, and only a single record is being acted upon,
447      * url will be built Rails-style, as in "/controller/action/32".  restful will aply iff the supplied record is an
448      * instance of Ext.data.Record rather than an Array of them.
449      * @param {String} action The api action being executed [read|create|update|destroy]
450      * @param {Ext.data.Record/Ext.data.Record[]} record The record or Array of Records being acted upon.
451      * @return {String} url
452      * @private
453      */
454     buildUrl : function(action, record) {
455         record = record || null;
456
457         // conn.url gets nullified after each request.  If it's NOT null here, that means the user must have intervened with a call
458         // to DataProxy#setUrl or DataProxy#setApi and changed it before the request was executed.  If that's the case, use conn.url,
459         // otherwise, build the url from the api or this.url.
460         var url = (this.conn && this.conn.url) ? this.conn.url : (this.api[action]) ? this.api[action].url : this.url;
461         if (!url) {
462             throw new Ext.data.Api.Error('invalid-url', action);
463         }
464
465         // look for urls having "provides" suffix used in some MVC frameworks like Rails/Merb and others.  The provides suffice informs
466         // the server what data-format the client is dealing with and returns data in the same format (eg: application/json, application/xml, etc)
467         // e.g.: /users.json, /users.xml, etc.
468         // with restful routes, we need urls like:
469         // PUT /users/1.json
470         // DELETE /users/1.json
471         var provides = null;
472         var m = url.match(/(.*)(\.json|\.xml|\.html)$/);
473         if (m) {
474             provides = m[2];    // eg ".json"
475             url      = m[1];    // eg: "/users"
476         }
477         // prettyUrls is deprectated in favor of restful-config
478         if ((this.restful === true || this.prettyUrls === true) && record instanceof Ext.data.Record && !record.phantom) {
479             url += '/' + record.id;
480         }
481         return (provides === null) ? url : url + provides;
482     },
483
484     <div id="method-Ext.data.DataProxy-destroy"></div>/**
485      * Destroys the proxy by purging any event listeners and cancelling any active requests.
486      */
487     destroy: function(){
488         this.purgeListeners();
489     }
490 });
491
492 // Apply the Observable prototype to the DataProxy class so that proxy instances can relay their
493 // events to the class.  Allows for centralized listening of all proxy instances upon the DataProxy class.
494 Ext.apply(Ext.data.DataProxy, Ext.util.Observable.prototype);
495 Ext.util.Observable.call(Ext.data.DataProxy);
496
497 <div id="cls-Ext.data.DataProxy.Error"></div>/**
498  * @class Ext.data.DataProxy.Error
499  * @extends Ext.Error
500  * DataProxy Error extension.
501  * constructor
502  * @param {String} message Message describing the error.
503  * @param {Record/Record[]} arg
504  */
505 Ext.data.DataProxy.Error = Ext.extend(Ext.Error, {
506     constructor : function(message, arg) {
507         this.arg = arg;
508         Ext.Error.call(this, message);
509     },
510     name: 'Ext.data.DataProxy'
511 });
512 Ext.apply(Ext.data.DataProxy.Error.prototype, {
513     lang: {
514         'action-undefined': "DataProxy attempted to execute an API-action but found an undefined url / function.  Please review your Proxy url/api-configuration.",
515         'api-invalid': 'Recieved an invalid API-configuration.  Please ensure your proxy API-configuration contains only the actions from Ext.data.Api.actions.'
516     }
517 });
518
519
520 </pre>    
521 </body>
522 </html>