/*
This file is part of Ext JS 4.2
Copyright (c) 2011-2013 Sencha Inc
Contact: http://www.sencha.com/contact
GNU General Public License Usage
This file may be used under the terms of the GNU General Public License version 3.0 as
published by the Free Software Foundation and appearing in the file LICENSE included in the
packaging of this file.
Please review the following information to ensure the GNU General Public License version 3.0
requirements will be met: http://www.gnu.org/copyleft/gpl.html.
If you are unsure which license is appropriate for your use, please contact the sales department
at http://www.sencha.com/contact.
Build date: 2013-05-16 14:36:50 (f9be68accb407158ba2b1be2c226a6ce1f649314)
*/
/**
* The {@link Ext.direct.RemotingProvider RemotingProvider} exposes access to
* server side methods on the client (a remote procedure call (RPC) type of
* connection where the client can initiate a procedure on the server).
*
* This allows for code to be organized in a fashion that is maintainable,
* while providing a clear path between client and server, something that is
* not always apparent when using URLs.
*
* To accomplish this the server-side needs to describe what classes and methods
* are available on the client-side. This configuration will typically be
* outputted by the server-side Ext.Direct stack when the API description is built.
*/
Ext.define('Ext.direct.RemotingProvider', {
extend: 'Ext.direct.JsonProvider',
alias: 'direct.remotingprovider',
requires: [
'Ext.util.MixedCollection',
'Ext.util.DelayedTask',
'Ext.direct.Transaction',
'Ext.direct.RemotingMethod'
],
/**
* @cfg {Object} actions
*
* Object literal defining the server side actions and methods. For example, if
* the Provider is configured with:
*
* // each property within the 'actions' object represents a server side Class
* actions: {
* TestAction: [ // array of methods within each server side Class to be
* { // stubbed out on client
* name: 'doEcho', // stub method will be TestAction.doEcho
* len: 1
* }, {
* name: 'multiply', // name of method
* len: 2 // The number of parameters that will be used to create an
* // array of data to send to the server side function.
* }, {
* name: 'doForm',
* formHandler: true // tells the client that this method handles form calls
* }],
*
* // These methods will be created in nested namespace TestAction.Foo
* 'TestAction.Foo': [{
* name: 'ordered', // stub method will be TestAction.Foo.ordered
* len: 1
* }, {
* name: 'noParams', // this method does not accept any parameters
* len: 0
* }, {
* name: 'named', // stub method will be TestAction.Foo.named
* params: ['foo', 'bar'] // parameters are passed by name
* }]
* }
*
* Note that starting with 4.2, dotted Action names will generate nested objects.
* If you wish to reverse to previous behavior, set {@link #cfg-disableNestedActions}
* to `true`.
*
* In the following example a *client side* handler is used to call the
* server side method "multiply" in the server-side "TestAction" Class:
*
* TestAction.multiply(
* // pass two arguments to server, so specify len=2
* 2, 4,
*
* // callback function after the server is called
* // result: the result returned by the server
* // e: Ext.direct.RemotingEvent object
* // success: true or false
* // options: options to be applied to method call and passed to callback
* function (result, e, success, options) {
* var t, action, method;
*
* t = e.getTransaction();
* action = t.action; // server side Class called
* method = t.method; // server side method called
*
* if (e.status) {
* var answer = Ext.encode(result); // 8
* }
* else {
* var msg = e.message; // failure message
* }
* },
*
* // Scope to call the callback in (optional)
* window,
*
* // Options to apply to this method call. This can include
* // Ajax.request() options; only `timeout` is supported at this time.
* // When timeout is set for a method call, it will be executed immediately
* // without buffering.
* // The same options object is passed to the callback so it's possible
* // to "forward" some data when needed.
* {
* timeout: 60000, // milliseconds
* foo: 'bar'
* }
* );
*
* In the example above, the server side "multiply" function will be passed two
* arguments (2 and 4). The "multiply" method should return the value 8 which will be
* available as the `result` in the callback example above.
*/
/**
* @cfg {Boolean} [disableNestedActions=false]
* In versions prior to 4.2, using dotted Action names was not really meaningful,
* because it generated flat {@link #cfg-namespace} object with dotted property names.
* For example, take this API declaration:
*
* {
* actions: {
* TestAction: {
* name: 'foo',
* len: 1
* },
* 'TestAction.Foo' {
* name: 'bar',
* len: 1
* }
* },
* namespace: 'MyApp'
* }
*
* Before 4.2, that would generate the following API object:
*
* window.MyApp = {
* TestAction: {
* foo: function() { ... }
* },
* 'TestAction.Foo': {
* bar: function() { ... }
* }
* }
*
* In Ext JS 4.2, we introduced new namespace handling behavior. Now the same API object
* will be like this:
*
* window.MyApp = {
* TestAction: {
* foo: function() { ... },
*
* Foo: {
* bar: function() { ... }
* }
* }
* }
*
* Instead of addressing Action methods array-style `MyApp['TestAction.Foo'].bar()`,
* now it is possible to use object addressing: `MyApp.TestAction.Foo.bar()`.
*
* If you find this behavior undesirable, set this config option to `true`.
*/
/**
* @cfg {String/Object} namespace
*
* Namespace for the Remoting Provider (defaults to `Ext.global`).
* Explicitly specify the namespace Object, or specify a String to have a
* {@link Ext#namespace namespace} created implicitly.
*/
/**
* @cfg {String} url
*
* **Required**. The url to connect to the {@link Ext.direct.Manager} server-side router.
*/
/**
* @cfg {String} [enableUrlEncode=data]
*
* Specify which param will hold the arguments for the method.
*/
/**
* @cfg {Number/Boolean} [enableBuffer=10]
*
* `true` or `false` to enable or disable combining of method
* calls. If a number is specified this is the amount of time in milliseconds
* to wait before sending a batched request.
*
* Calls which are received within the specified timeframe will be
* concatenated together and sent in a single request, optimizing the
* application by reducing the amount of round trips that have to be made
* to the server. To cancel buffering for some particular invocations, pass
* `timeout` parameter in `options` object for that method call.
*/
enableBuffer: 10,
/**
* @cfg {Number} [maxRetries=1]
*
* Number of times to re-attempt delivery on failure of a call.
*/
maxRetries: 1,
/**
* @cfg {Number} [timeout]
*
* The timeout to use for each request.
*/
constructor: function(config) {
var me = this;
me.callParent(arguments);
me.addEvents(
/**
* @event beforecall
* @preventable
*
* Fires immediately before the client-side sends off the RPC call. By returning
* `false` from an event handler you can prevent the call from being made.
*
* @param {Ext.direct.RemotingProvider} provider
* @param {Ext.direct.Transaction} transaction
* @param {Object} meta The meta data
*/
'beforecall',
/**
* @event call
*
* Fires immediately after the request to the server-side is sent. This does
* NOT fire after the response has come back from the call.
*
* @param {Ext.direct.RemotingProvider} provider
* @param {Ext.direct.Transaction} transaction
* @param {Object} meta The meta data
*/
'call',
/**
* @event beforecallback
* @preventable
*
* Fires before callback function is executed. By returning `false` from an event handler
* you can prevent the callback from executing.
*
* @param {Ext.direct.RemotingProvider} provider
* @param {Ext.direct.Transaction} transaction
*/
'beforecallback'
);
me.namespace = (Ext.isString(me.namespace)) ? Ext.ns(me.namespace) : me.namespace || Ext.global;
me.transactions = new Ext.util.MixedCollection();
me.callBuffer = [];
},
/**
* Get nested namespace by property.
*
* @private
*/
getNamespace: function(root, action) {
var parts, ns, i, l;
root = root || Ext.global;
parts = action.toString().split('.');
for (i = 0, l = parts.length; i < l; i++) {
ns = parts[i];
root = root[ns];
if (typeof root === 'undefined') {
return root;
}
}
return root;
},
/**
* Create nested namespaces. Unlike {@link Ext#ns} this method supports
* nested objects as root of the namespace, not only Ext.global (window).
*
* @private
*/
createNamespaces: function(root, action) {
var parts, ns;
root = root || Ext.global;
parts = action.toString().split('.');
for ( var i = 0, l = parts.length; i < l; i++ ) {
ns = parts[i];
root[ns] = root[ns] || {};
root = root[ns];
};
return root;
},
/**
* Initialize the API
*
* @private
*/
initAPI: function() {
var me = this,
actions = me.actions,
namespace = me.namespace,
action, cls, methods, i, len, method;
for (action in actions) {
if (actions.hasOwnProperty(action)) {
if (me.disableNestedActions) {
cls = namespace[action];
if (!cls) {
cls = namespace[action] = {};
}
}
else {
cls = me.getNamespace(namespace, action);
if (!cls) {
cls = me.createNamespaces(namespace, action);
}
}
methods = actions[action];
for (i = 0, len = methods.length; i < len; ++i) {
method = new Ext.direct.RemotingMethod(methods[i]);
cls[method.name] = me.createHandler(action, method);
}
}
}
},
/**
* Create a handler function for a direct call.
*
* @param {String} action The action the call is for
* @param {Object} method The details of the method
*
* @return {Function} A JS function that will kick off the call
*
* @private
*/
createHandler: function(action, method) {
var me = this,
slice = Array.prototype.slice,
handler;
if (!method.formHandler) {
handler = function() {
me.configureRequest(action, method, slice.call(arguments, 0));
};
}
else {
handler = function(form, callback, scope) {
me.configureFormRequest(action, method, form, callback, scope);
};
}
handler.directCfg = {
action: action,
method: method
};
return handler;
},
/**
* @inheritdoc
*/
isConnected: function() {
return !!this.connected;
},
/**
* @inheritdoc
*/
connect: function() {
var me = this;
if (me.url) {
me.initAPI();
me.connected = true;
me.fireEvent('connect', me);
}
//<debug>
else if (!me.url) {
Ext.Error.raise('Error initializing RemotingProvider "' + me.id +
'", no url configured.');
}
//</debug>
},
/**
* @inheritdoc
*/
disconnect: function() {
var me = this;
if (me.connected) {
me.connected = false;
me.fireEvent('disconnect', me);
}
},
/**
* Run any callbacks related to the transaction.
*
* @param {Ext.direct.Transaction} transaction The transaction
* @param {Ext.direct.Event} event The event
*
* @private
*/
runCallback: function(transaction, event) {
var success = !!event.status,
funcName = success ? 'success' : 'failure',
callback, options, result;
if (transaction && transaction.callback) {
callback = transaction.callback;
options = transaction.callbackOptions;
result = typeof event.result !== 'undefined' ? event.result : event.data;
if (Ext.isFunction(callback)) {
callback(result, event, success, options);
}
else {
Ext.callback(callback[funcName], callback.scope, [result, event, success, options]);
Ext.callback(callback.callback, callback.scope, [result, event, success, options]);
}
}
},
/**
* React to the ajax request being completed
*
* @private
*/
onData: function(options, success, response) {
var me = this,
i, len, events, event, transaction, transactions;
if (success) {
events = me.createEvents(response);
for (i = 0, len = events.length; i < len; ++i) {
event = events[i];
transaction = me.getTransaction(event);
me.fireEvent('data', me, event);
if (transaction && me.fireEvent('beforecallback', me, event, transaction) !== false) {
me.runCallback(transaction, event, true);
Ext.direct.Manager.removeTransaction(transaction);
}
}
}
else {
transactions = [].concat(options.transaction);
for (i = 0, len = transactions.length; i < len; ++i) {
transaction = me.getTransaction(transactions[i]);
if (transaction && transaction.retryCount < me.maxRetries) {
transaction.retry();
}
else {
event = new Ext.direct.ExceptionEvent({
data: null,
transaction: transaction,
code: Ext.direct.Manager.exceptions.TRANSPORT,
message: 'Unable to connect to the server.',
xhr: response
});
me.fireEvent('data', me, event);
if (transaction && me.fireEvent('beforecallback', me, transaction) !== false) {
me.runCallback(transaction, event, false);
Ext.direct.Manager.removeTransaction(transaction);
}
}
}
}
},
/**
* Get transaction from XHR options
*
* @param {Object} options The options sent to the Ajax request
*
* @return {Ext.direct.Transaction} The transaction, null if not found
*
* @private
*/
getTransaction: function(options) {
return options && options.tid ? Ext.direct.Manager.getTransaction(options.tid) : null;
},
/**
* Configure a direct request
*
* @param {String} action The action being executed
* @param {Object} method The being executed
*
* @private
*/
configureRequest: function(action, method, args) {
var me = this,
callData, data, callback, scope, opts, transaction, params;
callData = method.getCallData(args);
data = callData.data;
callback = callData.callback;
scope = callData.scope;
opts = callData.options || {};
params = Ext.apply({}, {
provider: me,
args: args,
action: action,
method: method.name,
data: data,
callbackOptions: opts,
callback: scope && Ext.isFunction(callback) ? Ext.Function.bind(callback, scope) : callback
});
if (opts.timeout) {
Ext.applyIf(params, {
timeout: opts.timeout
});
};
transaction = new Ext.direct.Transaction(params);
if (me.fireEvent('beforecall', me, transaction, method) !== false) {
Ext.direct.Manager.addTransaction(transaction);
me.queueTransaction(transaction);
me.fireEvent('call', me, transaction, method);
}
},
/**
* Gets the Ajax call info for a transaction
*
* @param {Ext.direct.Transaction} transaction The transaction
*
* @return {Object} The call params
*
* @private
*/
getCallData: function(transaction) {
return {
action: transaction.action,
method: transaction.method,
data: transaction.data,
type: 'rpc',
tid: transaction.id
};
},
/**
* Sends a request to the server
*
* @param {Object/Array} data The data to send
*
* @private
*/
sendRequest: function(data) {
var me = this,
request, callData, params,
enableUrlEncode = me.enableUrlEncode,
i, len;
request = {
url: me.url,
callback: me.onData,
scope: me,
transaction: data,
timeout: me.timeout
};
// Explicitly specified timeout for Ext.Direct call overrides defaults
if (data.timeout) {
request.timeout = data.timeout;
}
if (Ext.isArray(data)) {
callData = [];
for (i = 0, len = data.length; i < len; ++i) {
callData.push(me.getCallData(data[i]));
}
}
else {
callData = me.getCallData(data);
}
if (enableUrlEncode) {
params = {};
params[Ext.isString(enableUrlEncode) ? enableUrlEncode : 'data'] = Ext.encode(callData);
request.params = params;
}
else {
request.jsonData = callData;
}
Ext.Ajax.request(request);
},
/**
* Add a new transaction to the queue
*
* @param {Ext.direct.Transaction} transaction The transaction
*
* @private
*/
queueTransaction: function(transaction) {
var me = this,
enableBuffer = me.enableBuffer;
if (transaction.form) {
me.sendFormRequest(transaction);
return;
}
if (enableBuffer === false || typeof transaction.timeout !== 'undefined') {
me.sendRequest(transaction);
return;
}
me.callBuffer.push(transaction);
if (enableBuffer) {
if (!me.callTask) {
me.callTask = new Ext.util.DelayedTask(me.combineAndSend, me);
}
me.callTask.delay(Ext.isNumber(enableBuffer) ? enableBuffer : 10);
}
else {
me.combineAndSend();
}
},
/**
* Combine any buffered requests and send them off
*
* @private
*/
combineAndSend : function() {
var me = this,
buffer = me.callBuffer,
len = buffer.length;
if (len > 0) {
me.sendRequest(len == 1 ? buffer[0] : buffer);
me.callBuffer = [];
}
},
/**
* Configure a form submission request
*
* @param {String} action The action being executed
* @param {Object} method The method being executed
* @param {HTMLElement} form The form being submitted
* @param {Function} [callback] A callback to run after the form submits
* @param {Object} [scope] A scope to execute the callback in
*
* @private
*/
configureFormRequest: function(action, method, form, callback, scope) {
var me = this,
transaction, isUpload, params;
transaction = new Ext.direct.Transaction({
provider: me,
action: action,
method: method.name,
args: [form, callback, scope],
callback: scope && Ext.isFunction(callback) ? Ext.Function.bind(callback, scope) : callback,
isForm: true
});
if (me.fireEvent('beforecall', me, transaction, method) !== false) {
Ext.direct.Manager.addTransaction(transaction);
isUpload = String(form.getAttribute("enctype")).toLowerCase() == 'multipart/form-data';
params = {
extTID: transaction.id,
extAction: action,
extMethod: method.name,
extType: 'rpc',
extUpload: String(isUpload)
};
// change made from typeof callback check to callback.params
// to support addl param passing in DirectSubmit EAC 6/2
Ext.apply(transaction, {
form: Ext.getDom(form),
isUpload: isUpload,
params: callback && Ext.isObject(callback.params) ? Ext.apply(params, callback.params) : params
});
me.fireEvent('call', me, transaction, method);
me.sendFormRequest(transaction);
}
},
/**
* Sends a form request
*
* @param {Ext.direct.Transaction} transaction The transaction to send
*
* @private
*/
sendFormRequest: function(transaction) {
var me = this;
Ext.Ajax.request({
url: me.url,
params: transaction.params,
callback: me.onData,
scope: me,
form: transaction.form,
isUpload: transaction.isUpload,
transaction: transaction
});
}
});
|
Download
