docs/source/JsonP.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-JsonP'>/**
  19 </span> * @class Ext.data.JsonP
  20  * @singleton
  21  * This class is used to create JSONP requests. JSONP is a mechanism that allows for making
  22  * requests for data cross domain. More information is available here:
  23  * http://en.wikipedia.org/wiki/JSONP
  24  */
  25 Ext.define('Ext.data.JsonP', {
  26
  27     /* Begin Definitions */
  28
  29     singleton: true,
  30
  31     statics: {
  32         requestCount: 0,
  33         requests: {}
  34     },
  35
  36     /* End Definitions */
  37
  38 <span id='Ext-data-JsonP-property-timeout'>    /**
  39 </span>     * @property timeout
  40      * @type Number
  41      * A default timeout for any JsonP requests. If the request has not completed in this time the
  42      * failure callback will be fired. The timeout is in ms. Defaults to &lt;tt&gt;30000&lt;/tt&gt;.
  43      */
  44     timeout: 30000,
  45
  46 <span id='Ext-data-JsonP-property-disableCaching'>    /**
  47 </span>     * @property disableCaching
  48      * @type Boolean
  49      * True to add a unique cache-buster param to requests. Defaults to &lt;tt&gt;true&lt;/tt&gt;.
  50      */
  51     disableCaching: true,
  52
  53 <span id='Ext-data-JsonP-property-disableCachingParam'>    /**
  54 </span>     * @property disableCachingParam
  55      * @type String
  56      * Change the parameter which is sent went disabling caching through a cache buster. Defaults to &lt;tt&gt;'_dc'&lt;/tt&gt;.
  57      */
  58     disableCachingParam: '_dc',
  59
  60 <span id='Ext-data-JsonP-property-callbackKey'>    /**
  61 </span>     * @property callbackKey
  62      * @type String
  63      * Specifies the GET parameter that will be sent to the server containing the function name to be executed when
  64      * the request completes. Defaults to &lt;tt&gt;callback&lt;/tt&gt;. Thus, a common request will be in the form of
  65      * url?callback=Ext.data.JsonP.callback1
  66      */
  67     callbackKey: 'callback',
  68
  69 <span id='Ext-data-JsonP-method-request'>    /**
  70 </span>     * Makes a JSONP request.
  71      * @param {Object} options An object which may contain the following properties. Note that options will
  72      * take priority over any defaults that are specified in the class.
  73      * &lt;ul&gt;
  74      * &lt;li&gt;&lt;b&gt;url&lt;/b&gt; : String &lt;div class=&quot;sub-desc&quot;&gt;The URL to request.&lt;/div&gt;&lt;/li&gt;
  75      * &lt;li&gt;&lt;b&gt;params&lt;/b&gt; : Object (Optional)&lt;div class=&quot;sub-desc&quot;&gt;An object containing a series of
  76      * key value pairs that will be sent along with the request.&lt;/div&gt;&lt;/li&gt;
  77      * &lt;li&gt;&lt;b&gt;timeout&lt;/b&gt; : Number (Optional) &lt;div class=&quot;sub-desc&quot;&gt;See {@link #timeout}&lt;/div&gt;&lt;/li&gt;
  78      * &lt;li&gt;&lt;b&gt;callbackKey&lt;/b&gt; : String (Optional) &lt;div class=&quot;sub-desc&quot;&gt;See {@link #callbackKey}&lt;/div&gt;&lt;/li&gt;
  79      * &lt;li&gt;&lt;b&gt;disableCaching&lt;/b&gt; : Boolean (Optional) &lt;div class=&quot;sub-desc&quot;&gt;See {@link #disableCaching}&lt;/div&gt;&lt;/li&gt;
  80      * &lt;li&gt;&lt;b&gt;disableCachingParam&lt;/b&gt; : String (Optional) &lt;div class=&quot;sub-desc&quot;&gt;See {@link #disableCachingParam}&lt;/div&gt;&lt;/li&gt;
  81      * &lt;li&gt;&lt;b&gt;success&lt;/b&gt; : Function (Optional) &lt;div class=&quot;sub-desc&quot;&gt;A function to execute if the request succeeds.&lt;/div&gt;&lt;/li&gt;
  82      * &lt;li&gt;&lt;b&gt;failure&lt;/b&gt; : Function (Optional) &lt;div class=&quot;sub-desc&quot;&gt;A function to execute if the request fails.&lt;/div&gt;&lt;/li&gt;
  83      * &lt;li&gt;&lt;b&gt;callback&lt;/b&gt; : Function (Optional) &lt;div class=&quot;sub-desc&quot;&gt;A function to execute when the request
  84      * completes, whether it is a success or failure.&lt;/div&gt;&lt;/li&gt;
  85      * &lt;li&gt;&lt;b&gt;scope&lt;/b&gt; : Object (Optional)&lt;div class=&quot;sub-desc&quot;&gt;The scope in
  86      * which to execute the callbacks: The &quot;this&quot; object for the callback function. Defaults to the browser window.&lt;/div&gt;&lt;/li&gt;
  87      * &lt;/ul&gt;
  88      * @return {Object} request An object containing the request details.
  89      */
  90     request: function(options){
  91         options = Ext.apply({}, options);
  92
  93         //&lt;debug&gt;
  94         if (!options.url) {
  95             Ext.Error.raise('A url must be specified for a JSONP request.');
  96         }
  97         //&lt;/debug&gt;
  98
  99         var me = this,
 100             disableCaching = Ext.isDefined(options.disableCaching) ? options.disableCaching : me.disableCaching,
 101             cacheParam = options.disableCachingParam || me.disableCachingParam,
 102             id = ++me.statics().requestCount,
 103             callbackName = 'callback' + id,
 104             callbackKey = options.callbackKey || me.callbackKey,
 105             timeout = Ext.isDefined(options.timeout) ? options.timeout : me.timeout,
 106             params = Ext.apply({}, options.params),
 107             url = options.url,
 108             request,
 109             script;
 110
 111         params[callbackKey] = 'Ext.data.JsonP.' + callbackName;
 112         if (disableCaching) {
 113             params[cacheParam] = new Date().getTime();
 114         }
 115
 116         script = me.createScript(url, params);
 117
 118         me.statics().requests[id] = request = {
 119             url: url,
 120             params: params,
 121             script: script,
 122             id: id,
 123             scope: options.scope,
 124             success: options.success,
 125             failure: options.failure,
 126             callback: options.callback,
 127             callbackName: callbackName
 128         };
 129
 130         if (timeout &gt; 0) {
 131             request.timeout = setTimeout(Ext.bind(me.handleTimeout, me, [request]), timeout);
 132         }
 133
 134         me.setupErrorHandling(request);
 135         me[callbackName] = Ext.bind(me.handleResponse, me, [request], true);
 136         Ext.getHead().appendChild(script);
 137         return request;
 138     },
 139
 140 <span id='Ext-data-JsonP-method-abort'>    /**
 141 </span>     * Abort a request. If the request parameter is not specified all open requests will
 142      * be aborted.
 143      * @param {Object/String} request (Optional) The request to abort
 144      */
 145     abort: function(request){
 146         var requests = this.statics().requests,
 147             key;
 148
 149         if (request) {
 150             if (!request.id) {
 151                 request = requests[request];
 152             }
 153             this.abort(request);
 154         } else {
 155             for (key in requests) {
 156                 if (requests.hasOwnProperty(key)) {
 157                     this.abort(requests[key]);
 158                 }
 159             }
 160         }
 161     },
 162
 163 <span id='Ext-data-JsonP-method-setupErrorHandling'>    /**
 164 </span>     * Sets up error handling for the script
 165      * @private
 166      * @param {Object} request The request
 167      */
 168     setupErrorHandling: function(request){
 169         request.script.onerror = Ext.bind(this.handleError, this, [request]);
 170     },
 171
 172 <span id='Ext-data-JsonP-method-handleAbort'>    /**
 173 </span>     * Handles any aborts when loading the script
 174      * @private
 175      * @param {Object} request The request
 176      */
 177     handleAbort: function(request){
 178         request.errorType = 'abort';
 179         this.handleResponse(null, request);
 180     },
 181
 182 <span id='Ext-data-JsonP-method-handleError'>    /**
 183 </span>     * Handles any script errors when loading the script
 184      * @private
 185      * @param {Object} request The request
 186      */
 187     handleError: function(request){
 188         request.errorType = 'error';
 189         this.handleResponse(null, request);
 190     },
 191
 192 <span id='Ext-data-JsonP-method-cleanupErrorHandling'>    /**
 193 </span>     * Cleans up anu script handling errors
 194      * @private
 195      * @param {Object} request The request
 196      */
 197     cleanupErrorHandling: function(request){
 198         request.script.onerror = null;
 199     },
 200
 201 <span id='Ext-data-JsonP-method-handleTimeout'>    /**
 202 </span>     * Handle any script timeouts
 203      * @private
 204      * @param {Object} request The request
 205      */
 206     handleTimeout: function(request){
 207         request.errorType = 'timeout';
 208         this.handleResponse(null, request);
 209     },
 210
 211 <span id='Ext-data-JsonP-method-handleResponse'>    /**
 212 </span>     * Handle a successful response
 213      * @private
 214      * @param {Object} result The result from the request
 215      * @param {Object} request The request
 216      */
 217     handleResponse: function(result, request){
 218
 219         var success = true;
 220
 221         if (request.timeout) {
 222             clearTimeout(request.timeout);
 223         }
 224         delete this[request.callbackName];
 225         delete this.statics()[request.id];
 226         this.cleanupErrorHandling(request);
 227         Ext.fly(request.script).remove();
 228
 229         if (request.errorType) {
 230             success = false;
 231             Ext.callback(request.failure, request.scope, [request.errorType]);
 232         } else {
 233             Ext.callback(request.success, request.scope, [result]);
 234         }
 235         Ext.callback(request.callback, request.scope, [success, result, request.errorType]);
 236     },
 237
 238 <span id='Ext-data-JsonP-method-createScript'>    /**
 239 </span>     * Create the script tag
 240      * @private
 241      * @param {String} url The url of the request
 242      * @param {Object} params Any extra params to be sent
 243      */
 244     createScript: function(url, params) {
 245         var script = document.createElement('script');
 246         script.setAttribute(&quot;src&quot;, Ext.urlAppend(url, Ext.Object.toQueryString(params)));
 247         script.setAttribute(&quot;async&quot;, true);
 248         script.setAttribute(&quot;type&quot;, &quot;text/javascript&quot;);
 249         return script;
 250     }
 251 });
 252 </pre>
 253 </body>
 254 </html>