docs/source/Direct.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="../prettify/prettify.css" type="text/css" rel="stylesheet" />
   7   <script type="text/javascript" src="../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-Direct'>/**
  19 </span> * @class Ext.data.proxy.Direct
  20  * @extends Ext.data.proxy.Server
  21  *
  22  * This class is used to send requests to the server using {@link Ext.direct}. When a request is made,
  23  * the transport mechanism is handed off to the appropriate {@link Ext.direct.RemotingProvider Provider}
  24  * to complete the call.
  25  *
  26  * ## Specifying the function
  27  * This proxy expects a Direct remoting method to be passed in order to be able to complete requests.
  28  * This can be done by specifying the {@link #directFn} configuration. This will use the same direct
  29  * method for all requests. Alternatively, you can provide an {@link #api} configuration. This
  30  * allows you to specify a different remoting method for each CRUD action.
  31  *
  32  * ## Paramaters
  33  * This proxy provides options to help configure which parameters will be sent to the server.
  34  * By specifying the {@link #paramsAsHash} option, it will send an object literal containing each
  35  * of the passed parameters. The {@link #paramOrder} option can be used to specify the order in which
  36  * the remoting method parameters are passed.
  37  *
  38  * ## Example Usage
  39  *
  40  *     Ext.define('User', {
  41  *         extend: 'Ext.data.Model',
  42  *         fields: ['firstName', 'lastName'],
  43  *         proxy: {
  44  *             type: 'direct',
  45  *             directFn: MyApp.getUsers,
  46  *             paramOrder: 'id' // Tells the proxy to pass the id as the first parameter to the remoting method.
  47  *         }
  48  *     });
  49  *     User.load(1);
  50  */
  51 Ext.define('Ext.data.proxy.Direct', {
  52     /* Begin Definitions */
  53
  54     extend: 'Ext.data.proxy.Server',
  55     alternateClassName: 'Ext.data.DirectProxy',
  56
  57     alias: 'proxy.direct',
  58
  59     requires: ['Ext.direct.Manager'],
  60
  61     /* End Definitions */
  62
  63 <span id='Ext-data-proxy-Direct-cfg-paramOrder'>   /**
  64 </span>     * @cfg {Array/String} paramOrder Defaults to &lt;tt&gt;undefined&lt;/tt&gt;. A list of params to be executed
  65      * server side.  Specify the params in the order in which they must be executed on the server-side
  66      * as either (1) an Array of String values, or (2) a String of params delimited by either whitespace,
  67      * comma, or pipe. For example,
  68      * any of the following would be acceptable:&lt;pre&gt;&lt;code&gt;
  69 paramOrder: ['param1','param2','param3']
  70 paramOrder: 'param1 param2 param3'
  71 paramOrder: 'param1,param2,param3'
  72 paramOrder: 'param1|param2|param'
  73      &lt;/code&gt;&lt;/pre&gt;
  74      */
  75     paramOrder: undefined,
  76
  77 <span id='Ext-data-proxy-Direct-cfg-paramsAsHash'>    /**
  78 </span>     * @cfg {Boolean} paramsAsHash
  79      * Send parameters as a collection of named arguments (defaults to &lt;tt&gt;true&lt;/tt&gt;). Providing a
  80      * &lt;tt&gt;{@link #paramOrder}&lt;/tt&gt; nullifies this configuration.
  81      */
  82     paramsAsHash: true,
  83
  84 <span id='Ext-data-proxy-Direct-cfg-directFn'>    /**
  85 </span>     * @cfg {Function} directFn
  86      * Function to call when executing a request.  directFn is a simple alternative to defining the api configuration-parameter
  87      * for Store's which will not implement a full CRUD api.
  88      */
  89     directFn : undefined,
  90
  91 <span id='Ext-data-proxy-Direct-cfg-api'>    /**
  92 </span>     * @cfg {Object} api The same as {@link Ext.data.proxy.Server#api}, however instead of providing urls, you should provide a direct
  93      * function call.
  94      */
  95
  96 <span id='Ext-data-proxy-Direct-cfg-extraParams'>    /**
  97 </span>     * @cfg {Object} extraParams Extra parameters that will be included on every read request. Individual requests with params
  98      * of the same name will override these params when they are in conflict.
  99      */
 100
 101     // private
 102     paramOrderRe: /[\s,|]/,
 103
 104     constructor: function(config){
 105         var me = this;
 106
 107         Ext.apply(me, config);
 108         if (Ext.isString(me.paramOrder)) {
 109             me.paramOrder = me.paramOrder.split(me.paramOrderRe);
 110         }
 111         me.callParent(arguments);
 112     },
 113
 114     doRequest: function(operation, callback, scope) {
 115         var me = this,
 116             writer = me.getWriter(),
 117             request = me.buildRequest(operation, callback, scope),
 118             fn = me.api[request.action]  || me.directFn,
 119             args = [],
 120             params = request.params,
 121             paramOrder = me.paramOrder,
 122             method,
 123             i = 0,
 124             len;
 125
 126         //&lt;debug&gt;
 127         if (!fn) {
 128             Ext.Error.raise('No direct function specified for this proxy');
 129         }
 130         //&lt;/debug&gt;
 131
 132         if (operation.allowWrite()) {
 133             request = writer.write(request);
 134         }
 135
 136         if (operation.action == 'read') {
 137             // We need to pass params
 138             method = fn.directCfg.method;
 139
 140             if (method.ordered) {
 141                 if (method.len &gt; 0) {
 142                     if (paramOrder) {
 143                         for (len = paramOrder.length; i &lt; len; ++i) {
 144                             args.push(params[paramOrder[i]]);
 145                         }
 146                     } else if (me.paramsAsHash) {
 147                         args.push(params);
 148                     }
 149                 }
 150             } else {
 151                 args.push(params);
 152             }
 153         } else {
 154             args.push(request.jsonData);
 155         }
 156
 157         Ext.apply(request, {
 158             args: args,
 159             directFn: fn
 160         });
 161         args.push(me.createRequestCallback(request, operation, callback, scope), me);
 162         fn.apply(window, args);
 163     },
 164
 165     /*
 166      * Inherit docs. We don't apply any encoding here because
 167      * all of the direct requests go out as jsonData
 168      */
 169     applyEncoding: function(value){
 170         return value;
 171     },
 172
 173     createRequestCallback: function(request, operation, callback, scope){
 174         var me = this;
 175
 176         return function(data, event){
 177             me.processResponse(event.status, operation, request, event, callback, scope);
 178         };
 179     },
 180
 181     // inherit docs
 182     extractResponseData: function(response){
 183         return Ext.isDefined(response.result) ? response.result : response.data;
 184     },
 185
 186     // inherit docs
 187     setException: function(operation, response) {
 188         operation.setException(response.message);
 189     },
 190
 191     // inherit docs
 192     buildUrl: function(){
 193         return '';
 194     }
 195 });
 196 </pre>
 197 </body>
 198 </html>