/**
* @class Ext.data.Connection
* The Connection class encapsulates a connection to the page's originating domain, allowing requests to be made either
* to a configured URL, or to a URL specified at request time.
*
* Requests made by this class are asynchronous, and will return immediately. No data from the server will be available
* to the statement immediately following the {@link #request} call. To process returned data, use a success callback
* in the request options object, or an {@link #requestcomplete event listener}.
*
* <p><u>File Uploads</u></p>
*
* File uploads are not performed using normal "Ajax" techniques, that is they are not performed using XMLHttpRequests.
* Instead the form is submitted in the standard manner with the DOM <form> element temporarily modified to have its
* target set to refer to a dynamically generated, hidden <iframe> which is inserted into the document but removed
* after the return data has been gathered.
*
* The server response is parsed by the browser to create the document for the IFRAME. If the server is using JSON to
* send the return object, then the Content-Type header must be set to "text/html" in order to tell the browser to
* insert the text unchanged into the document body.
*
* Characters which are significant to an HTML parser must be sent as HTML entities, so encode "<" as "&lt;", "&" as
* "&amp;" etc.
*
* The response text is retrieved from the document, and a fake XMLHttpRequest object is created containing a
* responseText property in order to conform to the requirements of event handlers and callbacks.
*
* Be aware that file upload packets are sent with the content type multipart/form and some server technologies
* (notably JEE) may require some custom processing in order to retrieve parameter names and parameter values from the
* packet content.
*
* Also note that it's not possible to check the response code of the hidden iframe, so the success handler will ALWAYS fire.
*/
Ext.define('Ext.data.Connection', {
mixins: {
observable: 'Ext.util.Observable'
},
statics: {
requestId: 0
},
url: null,
async: true,
method: null,
username: '',
password: '',
/**
* @cfg {Boolean} disableCaching (Optional) True to add a unique cache-buster param to GET requests. (defaults to true)
*/
disableCaching: true,
/**
* @cfg {String} disableCachingParam (Optional) Change the parameter which is sent went disabling caching
* through a cache buster. Defaults to '_dc'
*/
disableCachingParam: '_dc',
/**
* @cfg {Number} timeout (Optional) The timeout in milliseconds to be used for requests. (defaults to 30000)
*/
timeout : 30000,
* @cfg {Object} extraParams (Optional) Any parameters to be appended to the request.
*/
useDefaultHeader : true,
defaultPostHeader : 'application/x-www-form-urlencoded; charset=UTF-8',
useDefaultXhrHeader : true,
defaultXhrHeader : 'XMLHttpRequest',
constructor : function(config) {
config = config || {};
Ext.apply(this, config);
this.addEvents(
/**
* @event beforerequest
* Fires before a network request is made to retrieve a data object.
* @param {Connection} conn This Connection object.
* @param {Object} options The options config object passed to the {@link #request} method.
*/
'beforerequest',
/**
* @event requestcomplete
* Fires if the request was successfully completed.
* @param {Connection} conn This Connection object.
* @param {Object} response The XHR object containing the response data.
* See <a href="http://www.w3.org/TR/XMLHttpRequest/">The XMLHttpRequest Object</a>
* for details.
* @param {Object} options The options config object passed to the {@link #request} method.
*/
'requestcomplete',
/**
* @event requestexception
* Fires if an error HTTP status was returned from the server.
* See <a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html">HTTP Status Code Definitions</a>
* for details of HTTP status codes.
* @param {Connection} conn This Connection object.
* @param {Object} response The XHR object containing the response data.
* See <a href="http://www.w3.org/TR/XMLHttpRequest/">The XMLHttpRequest Object</a>
* for details.
* @param {Object} options The options config object passed to the {@link #request} method.
*/
'requestexception'
);
this.requests = {};
this.mixins.observable.constructor.call(this);
},
/**
* <p>Sends an HTTP request to a remote server.</p>
* <p><b>Important:</b> Ajax server requests are asynchronous, and this call will
* return before the response has been received. Process any returned data
* in a callback function.</p>
* <pre><code>
Ext.Ajax.request({
url: 'ajax_demo/sample.json',
success: function(response, opts) {
var obj = Ext.decode(response.responseText);
console.dir(obj);
},
failure: function(response, opts) {
console.log('server-side failure with status code ' + response.status);
}
});
* </code></pre>
* <p>To execute a callback function in the correct scope, use the <tt>scope</tt> option.</p>
* @param {Object} options An object which may contain the following properties:<ul>
* <li><b>url</b> : String/Function (Optional)<div class="sub-desc">The URL to
* which to send the request, or a function to call which returns a URL string. The scope of the
* function is specified by the <tt>scope</tt> option. Defaults to the configured
* <tt>{@link #url}</tt>.</div></li>
* <li><b>params</b> : Object/String/Function (Optional)<div class="sub-desc">
* An object containing properties which are used as parameters to the
* request, a url encoded string or a function to call to get either. The scope of the function
* is specified by the <tt>scope</tt> option.</div></li>
* <li><b>method</b> : String (Optional)<div class="sub-desc">The HTTP method to use
* for the request. Defaults to the configured method, or if no method was configured,
* "GET" if no parameters are being sent, and "POST" if parameters are being sent. Note that
* the method name is case-sensitive and should be all caps.</div></li>
* <li><b>callback</b> : Function (Optional)<div class="sub-desc">The
* function to be called upon receipt of the HTTP response. The callback is
* called regardless of success or failure and is passed the following
* parameters:<ul>
* <li><b>options</b> : Object<div class="sub-desc">The parameter to the request call.</div></li>
* <li><b>success</b> : Boolean<div class="sub-desc">True if the request succeeded.</div></li>
* <li><b>response</b> : Object<div class="sub-desc">The XMLHttpRequest object containing the response data.
* See <a href="http://www.w3.org/TR/XMLHttpRequest/">http://www.w3.org/TR/XMLHttpRequest/</a> for details about
* accessing elements of the response.</div></li>
* </ul></div></li>
* <li><a id="request-option-success"></a><b>success</b> : Function (Optional)<div class="sub-desc">The function
* to be called upon success of the request. The callback is passed the following
* parameters:<ul>
* <li><b>response</b> : Object<div class="sub-desc">The XMLHttpRequest object containing the response data.</div></li>
* <li><b>options</b> : Object<div class="sub-desc">The parameter to the request call.</div></li>
* </ul></div></li>
* <li><b>failure</b> : Function (Optional)<div class="sub-desc">The function
* to be called upon failure of the request. The callback is passed the
* following parameters:<ul>
* <li><b>response</b> : Object<div class="sub-desc">The XMLHttpRequest object containing the response data.</div></li>
* <li><b>options</b> : Object<div class="sub-desc">The parameter to the request call.</div></li>
* </ul></div></li>
* <li><b>scope</b> : Object (Optional)<div class="sub-desc">The scope in
* which to execute the callbacks: The "this" object for the callback function. If the <tt>url</tt>, or <tt>params</tt> options were
* specified as functions from which to draw values, then this also serves as the scope for those function calls.
* Defaults to the browser window.</div></li>
* <li><b>timeout</b> : Number (Optional)<div class="sub-desc">The timeout in milliseconds to be used for this request. Defaults to 30 seconds.</div></li>
* <li><b>form</b> : Element/HTMLElement/String (Optional)<div class="sub-desc">The <tt><form></tt>
* Element or the id of the <tt><form></tt> to pull parameters from.</div></li>
* <li><a id="request-option-isUpload"></a><b>isUpload</b> : Boolean (Optional)<div class="sub-desc"><b>Only meaningful when used
* with the <tt>form</tt> option</b>.
* <p>True if the form object is a file upload (will be set automatically if the form was
* configured with <b><tt>enctype</tt></b> "multipart/form-data").</p>
* <p>File uploads are not performed using normal "Ajax" techniques, that is they are <b>not</b>
* performed using XMLHttpRequests. Instead the form is submitted in the standard manner with the
* DOM <tt><form></tt> element temporarily modified to have its
* <a href="http://www.w3.org/TR/REC-html40/present/frames.html#adef-target">target</a> set to refer
* to a dynamically generated, hidden <tt><iframe></tt> which is inserted into the document
* but removed after the return data has been gathered.</p>
* <p>The server response is parsed by the browser to create the document for the IFRAME. If the
* server is using JSON to send the return object, then the
* <a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.17">Content-Type</a> header
* must be set to "text/html" in order to tell the browser to insert the text unchanged into the document body.</p>
* <p>The response text is retrieved from the document, and a fake XMLHttpRequest object
* is created containing a <tt>responseText</tt> property in order to conform to the
* requirements of event handlers and callbacks.</p>
* <p>Be aware that file upload packets are sent with the content type <a href="http://www.faqs.org/rfcs/rfc2388.html">multipart/form</a>
* and some server technologies (notably JEE) may require some custom processing in order to
* retrieve parameter names and parameter values from the packet content.</p>
* </div></li>
* <li><b>headers</b> : Object (Optional)<div class="sub-desc">Request
* headers to set for the request.</div></li>
* <li><b>xmlData</b> : Object (Optional)<div class="sub-desc">XML document
* to use for the post. Note: This will be used instead of params for the post
* data. Any params will be appended to the URL.</div></li>
* <li><b>jsonData</b> : Object/String (Optional)<div class="sub-desc">JSON
* data to use as the post. Note: This will be used instead of params for the post
* data. Any params will be appended to the URL.</div></li>
* <li><b>disableCaching</b> : Boolean (Optional)<div class="sub-desc">True
* to add a unique cache-buster param to GET requests.</div></li>
* </ul></p>
* <p>The options object may also contain any other property which might be needed to perform
* postprocessing in a callback because it is passed to callback functions.</p>
* @return {Object} request The request object. This may be used
* to cancel the request.
*/
request : function(options) {
options = options || {};
var me = this,
scope = options.scope || window,
username = options.username || me.username,
password = options.password || me.password || '',
async,
requestOptions,
request,
headers,
xhr;
if (me.fireEvent('beforerequest', me, options) !== false) {
requestOptions = me.setOptions(options, scope);
if (this.isFormUpload(options) === true) {
this.upload(options.form, requestOptions.url, requestOptions.data, options);
return null;
}
// if autoabort is set, cancel the current transactions
if (options.autoAbort === true || me.autoAbort) {
me.abort();
}
// create a connection object
xhr = this.getXhrInstance();
async = options.async !== false ? (options.async || me.async) : false;
// open the request
if (username) {
xhr.open(requestOptions.method, requestOptions.url, async, username, password);
} else {
xhr.open(requestOptions.method, requestOptions.url, async);
}
headers = me.setupHeaders(xhr, options, requestOptions.data, requestOptions.params);
// create the transaction object
request = {
id: ++Ext.data.Connection.requestId,
xhr: xhr,
headers: headers,
options: options,
async: async,
timeout: setTimeout(function() {
request.timedout = true;
me.abort(request);
}, options.timeout || me.timeout)
};
me.requests[request.id] = request;
// bind our statechange listener
if (async) {
xhr.onreadystatechange = Ext.Function.bind(me.onStateChange, me, [request]);
}
// start the request!
xhr.send(requestOptions.data);
if (!async) {
return this.onComplete(request);
}
return request;
} else {
Ext.callback(options.callback, options.scope, [options, undefined, undefined]);
return null;
}
},
/**
* Upload a form using a hidden iframe.
* @param {Mixed} form The form to upload
* @param {String} url The url to post to
* @param {String} params Any extra parameters to pass
* @param {Object} options The initial options
*/
upload: function(form, url, params, options){
form = Ext.getDom(form);
options = options || {};
var id = Ext.id(),
frame = document.createElement('iframe'),
hiddens = [],
encoding = 'multipart/form-data',
buf = {
target: form.target,
method: form.method,
encoding: form.encoding,
enctype: form.enctype,
action: form.action
}, hiddenItem;
/*
* Originally this behaviour was modified for Opera 10 to apply the secure URL after
* the frame had been added to the document. It seems this has since been corrected in
* Opera so the behaviour has been reverted, the URL will be set before being added.
*/
Ext.fly(frame).set({
id: id,
name: id,
cls: Ext.baseCSSPrefix + 'hide-display',
src: Ext.SSL_SECURE_URL
});
document.body.appendChild(frame);
// This is required so that IE doesn't pop the response up in a new window.
if (document.frames) {
document.frames[id].name = id;
}
Ext.fly(form).set({
target: id,
method: 'POST',
enctype: encoding,
encoding: encoding,
action: url || buf.action
});
// add dynamic params
if (params) {
Ext.iterate(Ext.Object.fromQueryString(params), function(name, value){
hiddenItem = document.createElement('input');
Ext.fly(hiddenItem).set({
type: 'hidden',
value: value,
name: name
});
form.appendChild(hiddenItem);
hiddens.push(hiddenItem);
});
}
Ext.fly(frame).on('load', Ext.Function.bind(this.onUploadComplete, this, [frame, options]), null, {single: true});
form.submit();
Ext.fly(form).set(buf);
Ext.each(hiddens, function(h) {
Ext.removeNode(h);
});
},
onUploadComplete: function(frame, options){
var me = this,
// bogus response object
response = {
responseText: '',
responseXML: null
}, doc, firstChild;
try {
doc = frame.contentWindow.document || frame.contentDocument || window.frames[id].document;
if (doc) {
if (doc.body) {
if (/textarea/i.test((firstChild = doc.body.firstChild || {}).tagName)) { // json response wrapped in textarea
response.responseText = firstChild.value;
} else {
response.responseText = doc.body.innerHTML;
}
}
//in IE the document may still have a body even if returns XML.
response.responseXML = doc.XMLDocument || doc;
}
} catch (e) {
}
me.fireEvent('requestcomplete', me, response, options);
Ext.callback(options.success, options.scope, [response, options]);
Ext.callback(options.callback, options.scope, [options, true, response]);
setTimeout(function(){
Ext.removeNode(frame);
}, 100);
},
/**
* Detect whether the form is intended to be used for an upload.
* @private
*/
isFormUpload: function(options){
var form = this.getForm(options);
if (form) {
return (options.isUpload || (/multipart\/form-data/i).test(form.getAttribute('enctype')));
}
return false;
},
/**
* Get the form object from options.
* @private
* @param {Object} options The request options
* @return {HTMLElement} The form, null if not passed
*/
getForm: function(options){
return Ext.getDom(options.form) || null;
},
/**
* Set various options such as the url, params for the request
* @param {Object} options The initial options
* @param {Object} scope The scope to execute in
* @return {Object} The params for the request
*/
setOptions: function(options, scope){
var me = this,
params = options.params || {},
extraParams = me.extraParams,
urlParams = options.urlParams,
url = options.url || me.url,
jsonData = options.jsonData,
method,
disableCache,
data;
// allow params to be a method that returns the params object
if (Ext.isFunction(params)) {
params = params.call(scope, options);
}
// allow url to be a method that returns the actual url
if (Ext.isFunction(url)) {
url = url.call(scope, options);
}
url = this.setupUrl(options, url);
//<debug>
if (!url) {
Ext.Error.raise({
options: options,
msg: 'No URL specified'
});
}
//</debug>
// check for xml or json data, and make sure json data is encoded
data = options.rawData || options.xmlData || jsonData || null;
if (jsonData && !Ext.isPrimitive(jsonData)) {
data = Ext.encode(data);
}
// make sure params are a url encoded string and include any extraParams if specified
if (Ext.isObject(params)) {
params = Ext.Object.toQueryString(params);
}
if (Ext.isObject(extraParams)) {
extraParams = Ext.Object.toQueryString(extraParams);
}
params = params + ((extraParams) ? ((params) ? '&' : '') + extraParams : '');
urlParams = Ext.isObject(urlParams) ? Ext.Object.toQueryString(urlParams) : urlParams;
params = this.setupParams(options, params);
// decide the proper method for this request
method = (options.method || me.method || ((params || data) ? 'POST' : 'GET')).toUpperCase();
this.setupMethod(options, method);
disableCache = options.disableCaching !== false ? (options.disableCaching || me.disableCaching) : false;
// if the method is get append date to prevent caching
if (method === 'GET' && disableCache) {
url = Ext.urlAppend(url, (options.disableCachingParam || me.disableCachingParam) + '=' + (new Date().getTime()));
}
// if the method is get or there is json/xml data append the params to the url
if ((method == 'GET' || data) && params) {
url = Ext.urlAppend(url, params);
params = null;
}
// allow params to be forced into the url
if (urlParams) {
url = Ext.urlAppend(url, urlParams);
}
return {
url: url,
method: method,
data: data || params || null
};
},
/**
* Template method for overriding url
* @private
* @param {Object} options
* @param {String} url
* @return {String} The modified url
*/
setupUrl: function(options, url){
var form = this.getForm(options);
if (form) {
url = url || form.action;
}
return url;
},
/**
* Template method for overriding params
* @private
* @param {Object} options
* @param {String} params
* @return {String} The modified params
*/
setupParams: function(options, params) {
var form = this.getForm(options),
serializedForm;
if (form && !this.isFormUpload(options)) {
serializedForm = Ext.core.Element.serializeForm(form);
params = params ? (params + '&' + serializedForm) : serializedForm;
}
return params;
},
/**
* Template method for overriding method
* @private
* @param {Object} options
* @param {String} method
* @return {String} The modified method
*/
setupMethod: function(options, method){
if (this.isFormUpload(options)) {
return 'POST';
}
return method;
},
* Setup all the headers for the request
* @private
* @param {Object} xhr The xhr object
* @param {Object} options The options for the request
* @param {Object} data The data for the request
* @param {Object} params The params for the request
*/
setupHeaders: function(xhr, options, data, params){
var me = this,
headers = Ext.apply({}, options.headers || {}, me.defaultHeaders || {}),
contentType = me.defaultPostHeader,
jsonData = options.jsonData,
xmlData = options.xmlData,
key,
header;
if (!headers['Content-Type'] && (data || params)) {
if (data) {
if (options.rawData) {
contentType = 'text/plain';
} else {
if (xmlData && Ext.isDefined(xmlData)) {
contentType = 'text/xml';
} else if (jsonData && Ext.isDefined(jsonData)) {
contentType = 'application/json';
}
}
}
headers['Content-Type'] = contentType;
}
if (me.useDefaultXhrHeader && !headers['X-Requested-With']) {
headers['X-Requested-With'] = me.defaultXhrHeader;
}
// set up all the request headers on the xhr object
try{
for (key in headers) {
if (headers.hasOwnProperty(key)) {
header = headers[key];
xhr.setRequestHeader(key, header);
}
}
} catch(e) {
me.fireEvent('exception', key, header);
}
return headers;
},
/**
* Creates the appropriate XHR transport for the browser.
* @private
*/
getXhrInstance: (function(){
var options = [function(){
return new XMLHttpRequest();
}, function(){
return new ActiveXObject('MSXML2.XMLHTTP.3.0');
}, function(){
return new ActiveXObject('MSXML2.XMLHTTP');
}, function(){
return new ActiveXObject('Microsoft.XMLHTTP');
}], i = 0,
len = options.length,
xhr;
for(; i < len; ++i) {
try{
xhr = options[i];
xhr();
break;
}catch(e){}
}
return xhr;
})(),
/**
* Determine whether this object has a request outstanding.
* @param {Object} request (Optional) defaults to the last transaction
* @return {Boolean} True if there is an outstanding request.
*/
isLoading : function(request) {
if (!(request && request.xhr)) {
return false;
}
// if there is a connection and readyState is not 0 or 4
var state = request.xhr.readyState;
return !(state === 0 || state == 4);
},
/**
* Aborts any outstanding request.
* @param {Object} request (Optional) defaults to the last request
*/
abort : function(request) {
var me = this,
requests = me.requests,
id;
if (request && me.isLoading(request)) {
/*
* Clear out the onreadystatechange here, this allows us
* greater control, the browser may/may not fire the function
* depending on a series of conditions.
*/
request.xhr.onreadystatechange = null;
request.xhr.abort();
me.clearTimeout(request);
if (!request.timedout) {
request.aborted = true;
}
me.onComplete(request);
me.cleanup(request);
} else if (!request) {
for(id in requests) {
if (requests.hasOwnProperty(id)) {
me.abort(requests[id]);
}
}
}
},
/**
* Fires when the state of the xhr changes
* @private
* @param {Object} request The request
*/
onStateChange : function(request) {
if (request.xhr.readyState == 4) {
this.clearTimeout(request);
this.onComplete(request);
this.cleanup(request);
}
},
/**
* Clear the timeout on the request
* @private
* @param {Object} The request
*/
clearTimeout: function(request){
clearTimeout(request.timeout);
delete request.timeout;
},
/**
* Clean up any left over information from the request
* @private
* @param {Object} The request
*/
cleanup: function(request){
request.xhr = null;
delete request.xhr;
},
/**
* To be called when the request has come back from the server
* @private
* @param {Object} request
* @return {Object} The response
*/
onComplete : function(request) {
var me = this,
options = request.options,
result,
success,
response;
try {
result = me.parseStatus(request.xhr.status);
} catch (e) {
// in some browsers we can't access the status if the readyState is not 4, so the request has failed
result = {
success : false,
isException : false
};
}
success = result.success;
if (success) {
response = me.createResponse(request);
me.fireEvent('requestcomplete', me, response, options);
Ext.callback(options.success, options.scope, [response, options]);
} else {
if (result.isException || request.aborted || request.timedout) {
response = me.createException(request);
} else {
response = me.createResponse(request);
}
me.fireEvent('requestexception', me, response, options);
Ext.callback(options.failure, options.scope, [response, options]);
}
Ext.callback(options.callback, options.scope, [options, success, response]);
delete me.requests[request.id];
return response;
},
/**
* Check if the response status was successful
* @param {Number} status The status code
* @return {Object} An object containing success/status state
*/
parseStatus: function(status) {
// see: https://prototype.lighthouseapp.com/projects/8886/tickets/129-ie-mangles-http-response-status-code-204-to-1223
status = status == 1223 ? 204 : status;
var success = (status >= 200 && status < 300) || status == 304,
isException = false;
if (!success) {
switch (status) {
case 12002:
case 12029:
case 12030:
case 12031:
case 12152:
case 13030:
isException = true;
break;
}
}
return {
success: success,
isException: isException
};
},
/**
* Create the response object
* @private
* @param {Object} request
*/
createResponse : function(request) {
var xhr = request.xhr,
headers = {},
lines = xhr.getAllResponseHeaders().replace(/\r\n/g, '\n').split('\n'),
count = lines.length,
line, index, key, value, response;
while (count--) {
line = lines[count];
index = line.indexOf(':');
if(index >= 0) {
key = line.substr(0, index).toLowerCase();
if (line.charAt(index + 1) == ' ') {
++index;
}
headers[key] = line.substr(index + 1);
}
}
request.xhr = null;
delete request.xhr;
response = {
request: request,
requestId : request.id,
status : xhr.status,
statusText : xhr.statusText,
getResponseHeader : function(header){ return headers[header.toLowerCase()]; },
getAllResponseHeaders : function(){ return headers; },
responseText : xhr.responseText,
responseXML : xhr.responseXML
};
// If we don't explicitly tear down the xhr reference, IE6/IE7 will hold this in the closure of the
// functions created with getResponseHeader/getAllResponseHeaders
xhr = null;
return response;
},
/**
* Create the exception object
* @private
* @param {Object} request
*/
createException : function(request) {
return {
request : request,
requestId : request.id,
status : request.aborted ? -1 : 0,
statusText : request.aborted ? 'transaction aborted' : 'communication failure',
aborted: request.aborted,
timedout: request.timedout
};
}
});