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