-<html>\r
-<head>\r
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> \r
- <title>The source code</title>\r
- <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />\r
- <script type="text/javascript" src="../resources/prettify/prettify.js"></script>\r
-</head>\r
-<body onload="prettyPrint();">\r
- <pre class="prettyprint lang-js"><div id="cls-Ext.Direct"></div>/**\r
- * @class Ext.Direct\r
- * @extends Ext.util.Observable\r
- * <p><b><u>Overview</u></b></p>\r
- * \r
- * <p>Ext.Direct aims to streamline communication between the client and server\r
- * by providing a single interface that reduces the amount of common code\r
- * typically required to validate data and handle returned data packets\r
- * (reading data, error conditions, etc).</p>\r
- * \r
- * <p>The Ext.direct namespace includes several classes for a closer integration\r
- * with the server-side. The Ext.data namespace also includes classes for working\r
- * with Ext.data.Stores which are backed by data from an Ext.Direct method.</p>\r
- * \r
- * <p><b><u>Specification</u></b></p>\r
- * \r
- * <p>For additional information consult the \r
- * <a href="http://extjs.com/products/extjs/direct.php">Ext.Direct Specification</a>.</p>\r
- * \r
- * <p><b><u>Providers</u></b></p>\r
- * \r
- * <p>Ext.Direct uses a provider architecture, where one or more providers are\r
- * used to transport data to and from the server. There are several providers\r
- * that exist in the core at the moment:</p><div class="mdetail-params"><ul>\r
- * \r
- * <li>{@link Ext.direct.JsonProvider JsonProvider} for simple JSON operations</li>\r
- * <li>{@link Ext.direct.PollingProvider PollingProvider} for repeated requests</li>\r
- * <li>{@link Ext.direct.RemotingProvider RemotingProvider} exposes server side\r
- * on the client.</li>\r
- * </ul></div>\r
- * \r
- * <p>A provider does not need to be invoked directly, providers are added via\r
- * {@link Ext.Direct}.{@link Ext.Direct#add add}.</p>\r
- * \r
- * <p><b><u>Router</u></b></p>\r
- * \r
- * <p>Ext.Direct utilizes a "router" on the server to direct requests from the client\r
- * to the appropriate server-side method. Because the Ext.Direct API is completely\r
- * platform-agnostic, you could completely swap out a Java based server solution\r
- * and replace it with one that uses C# without changing the client side JavaScript\r
- * at all.</p>\r
- * \r
- * <p><b><u>Server side events</u></b></p>\r
- * \r
- * <p>Custom events from the server may be handled by the client by adding\r
- * listeners, for example:</p>\r
- * <pre><code>\r
-{"type":"event","name":"message","data":"Successfully polled at: 11:19:30 am"}\r
-\r
-// add a handler for a 'message' event sent by the server \r
-Ext.Direct.on('message', function(e){\r
- out.append(String.format('<p><i>{0}</i></p>', e.data));\r
- out.el.scrollTo('t', 100000, true);\r
-});\r
- * </code></pre>\r
- * @singleton\r
- */\r
-Ext.Direct = Ext.extend(Ext.util.Observable, {\r
- <div id="prop-Ext.Direct-eventTypes"></div>/**\r
- * Each event type implements a getData() method. The default event types are:\r
- * <div class="mdetail-params"><ul>\r
- * <li><b><tt>event</tt></b> : Ext.Direct.Event</li>\r
- * <li><b><tt>exception</tt></b> : Ext.Direct.ExceptionEvent</li>\r
- * <li><b><tt>rpc</tt></b> : Ext.Direct.RemotingEvent</li>\r
- * </ul></div>\r
- * @property eventTypes\r
- * @type Object\r
- */\r
-\r
- <div id="prop-Ext.Direct-exceptions"></div>/**\r
- * Four types of possible exceptions which can occur:\r
- * <div class="mdetail-params"><ul>\r
- * <li><b><tt>Ext.Direct.exceptions.TRANSPORT</tt></b> : 'xhr'</li>\r
- * <li><b><tt>Ext.Direct.exceptions.PARSE</tt></b> : 'parse'</li>\r
- * <li><b><tt>Ext.Direct.exceptions.LOGIN</tt></b> : 'login'</li>\r
- * <li><b><tt>Ext.Direct.exceptions.SERVER</tt></b> : 'exception'</li>\r
- * </ul></div>\r
- * @property exceptions\r
- * @type Object\r
- */\r
- exceptions: {\r
- TRANSPORT: 'xhr',\r
- PARSE: 'parse',\r
- LOGIN: 'login',\r
- SERVER: 'exception'\r
- },\r
- \r
- // private\r
- constructor: function(){\r
- this.addEvents(\r
- <div id="event-Ext.Direct-event"></div>/**\r
- * @event event\r
- * Fires after an event.\r
- * @param {event} e The {@link Ext.Direct#eventTypes Ext.Direct.Event type} that occurred.\r
- * @param {Ext.direct.Provider} provider The {@link Ext.direct.Provider Provider}.\r
- */\r
- 'event',\r
- <div id="event-Ext.Direct-exception"></div>/**\r
- * @event exception\r
- * Fires after an event exception.\r
- * @param {event} e The {@link Ext.Direct#eventTypes Ext.Direct.Event type} that occurred.\r
- */\r
- 'exception'\r
- );\r
- this.transactions = {};\r
- this.providers = {};\r
- },\r
-\r
- <div id="method-Ext.Direct-addProvider"></div>/**\r
- * Adds an Ext.Direct Provider and creates the proxy or stub methods to execute server-side methods.\r
- * If the provider is not already connected, it will auto-connect.\r
- * <pre><code>\r
-var pollProv = new Ext.direct.PollingProvider({\r
- url: 'php/poll2.php'\r
-}); \r
-\r
-Ext.Direct.addProvider(\r
- {\r
- "type":"remoting", // create a {@link Ext.direct.RemotingProvider} \r
- "url":"php\/router.php", // url to connect to the Ext.Direct server-side router.\r
- "actions":{ // each property within the actions object represents a Class \r
- "TestAction":[ // array of methods within each server side Class \r
- {\r
- "name":"doEcho", // name of method\r
- "len":1\r
- },{\r
- "name":"multiply",\r
- "len":1\r
- },{\r
- "name":"doForm",\r
- "formHandler":true, // handle form on server with Ext.Direct.Transaction \r
- "len":1\r
- }]\r
- },\r
- "namespace":"myApplication",// namespace to create the Remoting Provider in\r
- },{\r
- type: 'polling', // create a {@link Ext.direct.PollingProvider} \r
- url: 'php/poll.php'\r
- },\r
- pollProv // reference to previously created instance\r
-);\r
- * </code></pre>\r
- * @param {Object/Array} provider Accepts either an Array of Provider descriptions (an instance\r
- * or config object for a Provider) or any number of Provider descriptions as arguments. Each\r
- * Provider description instructs Ext.Direct how to create client-side stub methods.\r
- */\r
- addProvider : function(provider){ \r
- var a = arguments;\r
- if(a.length > 1){\r
- for(var i = 0, len = a.length; i < len; i++){\r
- this.addProvider(a[i]);\r
- }\r
- return;\r
- }\r
- \r
- // if provider has not already been instantiated\r
- if(!provider.events){\r
- provider = new Ext.Direct.PROVIDERS[provider.type](provider);\r
- }\r
- provider.id = provider.id || Ext.id();\r
- this.providers[provider.id] = provider;\r
-\r
- provider.on('data', this.onProviderData, this);\r
- provider.on('exception', this.onProviderException, this);\r
-\r
-\r
- if(!provider.isConnected()){\r
- provider.connect();\r
- }\r
-\r
- return provider;\r
- },\r
-\r
- <div id="method-Ext.Direct-getProvider"></div>/**\r
- * Retrieve a {@link Ext.direct.Provider provider} by the\r
- * <b><tt>{@link Ext.direct.Provider#id id}</tt></b> specified when the provider is\r
- * {@link #addProvider added}.\r
- * @param {String} id Unique identifier assigned to the provider when calling {@link #addProvider} \r
- */\r
- getProvider : function(id){\r
- return this.providers[id];\r
- },\r
-\r
- removeProvider : function(id){\r
- var provider = id.id ? id : this.providers[id.id];\r
- provider.un('data', this.onProviderData, this);\r
- provider.un('exception', this.onProviderException, this);\r
- delete this.providers[provider.id];\r
- return provider;\r
- },\r
-\r
- addTransaction: function(t){\r
- this.transactions[t.tid] = t;\r
- return t;\r
- },\r
-\r
- removeTransaction: function(t){\r
- delete this.transactions[t.tid || t];\r
- return t;\r
- },\r
-\r
- getTransaction: function(tid){\r
- return this.transactions[tid.tid || tid];\r
- },\r
-\r
- onProviderData : function(provider, e){\r
- if(Ext.isArray(e)){\r
- for(var i = 0, len = e.length; i < len; i++){\r
- this.onProviderData(provider, e[i]);\r
- }\r
- return;\r
- }\r
- if(e.name && e.name != 'event' && e.name != 'exception'){\r
- this.fireEvent(e.name, e);\r
- }else if(e.type == 'exception'){\r
- this.fireEvent('exception', e);\r
- }\r
- this.fireEvent('event', e, provider);\r
- },\r
-\r
- createEvent : function(response, extraProps){\r
- return new Ext.Direct.eventTypes[response.type](Ext.apply(response, extraProps));\r
- }\r
-});\r
-// overwrite impl. with static instance\r
-Ext.Direct = new Ext.Direct();\r
-\r
-Ext.Direct.TID = 1;\r
-Ext.Direct.PROVIDERS = {};</pre> \r
-</body>\r
-</html>
\ No newline at end of file
+<!DOCTYPE html>
+<html>
+<head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+ <title>The source code</title>
+ <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
+ <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
+ <style type="text/css">
+ .highlight { display: block; background-color: #ddd; }
+ </style>
+ <script type="text/javascript">
+ function highlight() {
+ document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
+ }
+ </script>
+</head>
+<body onload="prettyPrint(); highlight();">
+ <pre class="prettyprint lang-js"><span id='Ext-data-proxy-Direct'>/**
+</span> * This class is used to send requests to the server using {@link Ext.direct.Manager Ext.Direct}. When a
+ * request is made, the transport mechanism is handed off to the appropriate
+ * {@link Ext.direct.RemotingProvider Provider} to complete the call.
+ *
+ * # Specifying the function
+ *
+ * This proxy expects a Direct remoting method to be passed in order to be able to complete requests.
+ * This can be done by specifying the {@link #directFn} configuration. This will use the same direct
+ * method for all requests. Alternatively, you can provide an {@link #api} configuration. This
+ * allows you to specify a different remoting method for each CRUD action.
+ *
+ * # Parameters
+ *
+ * This proxy provides options to help configure which parameters will be sent to the server.
+ * By specifying the {@link #paramsAsHash} option, it will send an object literal containing each
+ * of the passed parameters. The {@link #paramOrder} option can be used to specify the order in which
+ * the remoting method parameters are passed.
+ *
+ * # Example Usage
+ *
+ * Ext.define('User', {
+ * extend: 'Ext.data.Model',
+ * fields: ['firstName', 'lastName'],
+ * proxy: {
+ * type: 'direct',
+ * directFn: MyApp.getUsers,
+ * paramOrder: 'id' // Tells the proxy to pass the id as the first parameter to the remoting method.
+ * }
+ * });
+ * User.load(1);
+ */
+Ext.define('Ext.data.proxy.Direct', {
+ /* Begin Definitions */
+
+ extend: 'Ext.data.proxy.Server',
+ alternateClassName: 'Ext.data.DirectProxy',
+
+ alias: 'proxy.direct',
+
+ requires: ['Ext.direct.Manager'],
+
+ /* End Definitions */
+
+<span id='Ext-data-proxy-Direct-cfg-paramOrder'> /**
+</span> * @cfg {String/String[]} paramOrder
+ * Defaults to undefined. A list of params to be executed server side. Specify the params in the order in
+ * which they must be executed on the server-side as either (1) an Array of String values, or (2) a String
+ * of params delimited by either whitespace, comma, or pipe. For example, any of the following would be
+ * acceptable:
+ *
+ * paramOrder: ['param1','param2','param3']
+ * paramOrder: 'param1 param2 param3'
+ * paramOrder: 'param1,param2,param3'
+ * paramOrder: 'param1|param2|param'
+ */
+ paramOrder: undefined,
+
+<span id='Ext-data-proxy-Direct-cfg-paramsAsHash'> /**
+</span> * @cfg {Boolean} paramsAsHash
+ * Send parameters as a collection of named arguments.
+ * Providing a {@link #paramOrder} nullifies this configuration.
+ */
+ paramsAsHash: true,
+
+<span id='Ext-data-proxy-Direct-cfg-directFn'> /**
+</span> * @cfg {Function} directFn
+ * Function to call when executing a request. directFn is a simple alternative to defining the api configuration-parameter
+ * for Store's which will not implement a full CRUD api.
+ */
+ directFn : undefined,
+
+<span id='Ext-data-proxy-Direct-cfg-api'> /**
+</span> * @cfg {Object} api
+ * The same as {@link Ext.data.proxy.Server#api}, however instead of providing urls, you should provide a direct
+ * function call.
+ */
+
+<span id='Ext-data-proxy-Direct-cfg-extraParams'> /**
+</span> * @cfg {Object} extraParams
+ * Extra parameters that will be included on every read request. Individual requests with params
+ * of the same name will override these params when they are in conflict.
+ */
+
+ // private
+ paramOrderRe: /[\s,|]/,
+
+ constructor: function(config){
+ var me = this;
+
+ Ext.apply(me, config);
+ if (Ext.isString(me.paramOrder)) {
+ me.paramOrder = me.paramOrder.split(me.paramOrderRe);
+ }
+ me.callParent(arguments);
+ },
+
+ doRequest: function(operation, callback, scope) {
+ var me = this,
+ writer = me.getWriter(),
+ request = me.buildRequest(operation, callback, scope),
+ fn = me.api[request.action] || me.directFn,
+ args = [],
+ params = request.params,
+ paramOrder = me.paramOrder,
+ method,
+ i = 0,
+ len;
+
+ //<debug>
+ if (!fn) {
+ Ext.Error.raise('No direct function specified for this proxy');
+ }
+ //</debug>
+
+ if (operation.allowWrite()) {
+ request = writer.write(request);
+ }
+
+ if (operation.action == 'read') {
+ // We need to pass params
+ method = fn.directCfg.method;
+
+ if (method.ordered) {
+ if (method.len > 0) {
+ if (paramOrder) {
+ for (len = paramOrder.length; i < len; ++i) {
+ args.push(params[paramOrder[i]]);
+ }
+ } else if (me.paramsAsHash) {
+ args.push(params);
+ }
+ }
+ } else {
+ args.push(params);
+ }
+ } else {
+ args.push(request.jsonData);
+ }
+
+ Ext.apply(request, {
+ args: args,
+ directFn: fn
+ });
+ args.push(me.createRequestCallback(request, operation, callback, scope), me);
+ fn.apply(window, args);
+ },
+
+ /*
+ * Inherit docs. We don't apply any encoding here because
+ * all of the direct requests go out as jsonData
+ */
+ applyEncoding: function(value){
+ return value;
+ },
+
+ createRequestCallback: function(request, operation, callback, scope){
+ var me = this;
+
+ return function(data, event){
+ me.processResponse(event.status, operation, request, event, callback, scope);
+ };
+ },
+
+ // inherit docs
+ extractResponseData: function(response){
+ return Ext.isDefined(response.result) ? response.result : response.data;
+ },
+
+ // inherit docs
+ setException: function(operation, response) {
+ operation.setException(response.message);
+ },
+
+ // inherit docs
+ buildUrl: function(){
+ return '';
+ }
+});
+</pre>
+</body>
+</html>
git.ithinksw.org / extjs.git / blobdiff