aboutsummaryrefslogtreecommitdiff
path: root/includes/js/dojo/rpc
diff options
context:
space:
mode:
authormensonge <mensonge@b3834d28-1941-0410-a4f8-b48e95affb8f>2008-11-13 09:49:11 +0000
committermensonge <mensonge@b3834d28-1941-0410-a4f8-b48e95affb8f>2008-11-13 09:49:11 +0000
commite44a7e37b6c7b5961adaffc62b9042b8d442938e (patch)
tree95b67c356e93163467db2451f2b8cce84ed5d582 /includes/js/dojo/rpc
parenta62b9742ee5e28bcec6872d88f50f25b820914f6 (diff)
downloadsemanticscuttle-e44a7e37b6c7b5961adaffc62b9042b8d442938e.tar.gz
semanticscuttle-e44a7e37b6c7b5961adaffc62b9042b8d442938e.tar.bz2
New feature: basic Ajax suggestion for tags and implementation of Dojo toolkit
git-svn-id: https://semanticscuttle.svn.sourceforge.net/svnroot/semanticscuttle/trunk@151 b3834d28-1941-0410-a4f8-b48e95affb8f
Diffstat (limited to 'includes/js/dojo/rpc')
-rw-r--r--includes/js/dojo/rpc/JsonService.js83
-rw-r--r--includes/js/dojo/rpc/JsonpService.js65
-rw-r--r--includes/js/dojo/rpc/RpcService.js172
3 files changed, 320 insertions, 0 deletions
diff --git a/includes/js/dojo/rpc/JsonService.js b/includes/js/dojo/rpc/JsonService.js
new file mode 100644
index 0000000..d9775f6
--- /dev/null
+++ b/includes/js/dojo/rpc/JsonService.js
@@ -0,0 +1,83 @@
+if(!dojo._hasResource["dojo.rpc.JsonService"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojo.rpc.JsonService"] = true;
+dojo.provide("dojo.rpc.JsonService");
+dojo.require("dojo.rpc.RpcService");
+
+dojo.declare("dojo.rpc.JsonService", dojo.rpc.RpcService, {
+ bustCache: false,
+ contentType: "application/json-rpc",
+ lastSubmissionId: 0,
+
+ callRemote: function(method, params){
+ // summary:
+ // call an arbitrary remote method without requiring it to be
+ // predefined with SMD
+ // method: string
+ // the name of the remote method you want to call.
+ // params: array
+ // array of parameters to pass to method
+
+ var deferred = new dojo.Deferred();
+ this.bind(method, params, deferred);
+ return deferred;
+ },
+
+ bind: function(method, parameters, deferredRequestHandler, url){
+ //summary:
+ // JSON-RPC bind method. Takes remote method, parameters,
+ // deferred, and a url, calls createRequest to make a JSON-RPC
+ // envelope and passes that off with bind.
+ // method: string
+ // The name of the method we are calling
+ // parameters: array
+ // The parameters we are passing off to the method
+ // deferredRequestHandler: deferred
+ // The Deferred object for this particular request
+
+ var def = dojo.rawXhrPost({
+ url: url||this.serviceUrl,
+ postData: this.createRequest(method, parameters),
+ contentType: this.contentType,
+ timeout: this.timeout,
+ handleAs: "json-comment-optional"
+ });
+ def.addCallbacks(this.resultCallback(deferredRequestHandler), this.errorCallback(deferredRequestHandler));
+ },
+
+ createRequest: function(method, params){
+ // summary:
+ // create a JSON-RPC envelope for the request
+ // method: string
+ // The name of the method we are creating the requst for
+ // params: array
+ // The array of parameters for this request;
+
+ var req = { "params": params, "method": method, "id": ++this.lastSubmissionId };
+ var data = dojo.toJson(req);
+ return data;
+ },
+
+ parseResults: function(/*anything*/obj){
+ //summary:
+ // parse the result envelope and pass the results back to
+ // the callback function
+ // obj: Object
+ // Object containing envelope of data we recieve from the server
+
+ if(dojo.isObject(obj)){
+ if("result" in obj){
+ return obj.result;
+ }
+ if("Result" in obj){
+ return obj.Result;
+ }
+ if("ResultSet" in obj){
+ return obj.ResultSet;
+ }
+ }
+ return obj;
+ }
+ }
+);
+
+}
diff --git a/includes/js/dojo/rpc/JsonpService.js b/includes/js/dojo/rpc/JsonpService.js
new file mode 100644
index 0000000..c07d5b9
--- /dev/null
+++ b/includes/js/dojo/rpc/JsonpService.js
@@ -0,0 +1,65 @@
+if(!dojo._hasResource["dojo.rpc.JsonpService"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojo.rpc.JsonpService"] = true;
+dojo.provide("dojo.rpc.JsonpService");
+dojo.require("dojo.rpc.RpcService");
+dojo.require("dojo.io.script");
+
+dojo.declare("dojo.rpc.JsonpService", dojo.rpc.RpcService, {
+ // summary:
+ // Generic JSONP service. Minimally extends RpcService to allow
+ // easy definition of nearly any JSONP style service. Example
+ // SMD files exist in dojox.data
+
+ constructor: function(args, requiredArgs){
+ if(this.required) {
+ if(requiredArgs){
+ dojo.mixin(this.required, requiredArgs);
+ }
+
+ dojo.forEach(this.required, function(req){
+ if(req=="" || req==undefined){
+ throw new Error("Required Service Argument not found: "+req);
+ }
+ });
+ }
+ },
+
+ strictArgChecks: false,
+
+ bind: function(method, parameters, deferredRequestHandler, url){
+ //summary:
+ // JSONP bind method. Takes remote method, parameters,
+ // deferred, and a url, calls createRequest to make a JSON-RPC
+ // envelope and passes that off with bind.
+ // method: string
+ // The name of the method we are calling
+ // parameters: array
+ // The parameters we are passing off to the method
+ // deferredRequestHandler: deferred
+ // The Deferred object for this particular request
+
+ var def = dojo.io.script.get({
+ url: url||this.serviceUrl,
+ callbackParamName: this.callbackParamName||"callback",
+ content: this.createRequest(parameters),
+ timeout: this.timeout,
+ handleAs: "json",
+ preventCache: true
+ });
+ def.addCallbacks(this.resultCallback(deferredRequestHandler), this.errorCallback(deferredRequestHandler));
+ },
+
+ createRequest: function(parameters){
+ // summary:
+ // create a JSONP req
+ // params: array
+ // The array of parameters for this request;
+
+ var params = (dojo.isArrayLike(parameters) && parameters.length==1) ?
+ parameters[0] : {};
+ dojo.mixin(params,this.required);
+ return params;
+ }
+});
+
+}
diff --git a/includes/js/dojo/rpc/RpcService.js b/includes/js/dojo/rpc/RpcService.js
new file mode 100644
index 0000000..22e40ca
--- /dev/null
+++ b/includes/js/dojo/rpc/RpcService.js
@@ -0,0 +1,172 @@
+if(!dojo._hasResource["dojo.rpc.RpcService"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojo.rpc.RpcService"] = true;
+dojo.provide("dojo.rpc.RpcService");
+
+dojo.declare("dojo.rpc.RpcService", null, {
+ constructor: function(args){
+ //summary:
+ //Take a string as a url to retrieve an smd or an object that is an smd or partial smd to use
+ //as a definition for the service
+ //
+ // args: object
+ // Takes a number of properties as kwArgs for defining the service. It also
+ // accepts a string. When passed a string, it is treated as a url from
+ // which it should synchronously retrieve an smd file. Otherwise it is a kwArgs
+ // object. It accepts serviceUrl, to manually define a url for the rpc service
+ // allowing the rpc system to be used without an smd definition. strictArgChecks
+ // forces the system to verify that the # of arguments provided in a call
+ // matches those defined in the smd. smdString allows a developer to pass
+ // a jsonString directly, which will be converted into an object or alternatively
+ // smdObject is accepts an smdObject directly.
+ //
+ if(args){
+ //if the arg is a string, we assume it is a url to retrieve an smd definition from
+ if( (dojo.isString(args)) || (args instanceof dojo._Url)){
+ if (args instanceof dojo._Url){
+ var url = args + "";
+ }else{
+ url = args;
+ }
+ var def = dojo.xhrGet({
+ url: url,
+ handleAs: "json-comment-optional",
+ sync: true
+ });
+
+ def.addCallback(this, "processSmd");
+ def.addErrback(function() {
+ throw new Error("Unable to load SMD from " + args);
+ });
+
+ }else if(args.smdStr){
+ this.processSmd(dojo.eval("("+args.smdStr+")"));
+ }else{
+ // otherwise we assume it's an arguments object with the following
+ // (optional) properties:
+ // - serviceUrl
+ // - strictArgChecks
+ // - smdStr
+ // - smdObj
+
+ if(args.serviceUrl){
+ this.serviceUrl = args.serviceUrl;
+ }
+
+ this.timeout = args.timeout || 3000;
+
+ if("strictArgChecks" in args){
+ this.strictArgChecks = args.strictArgChecks;
+ }
+
+ this.processSmd(args);
+ }
+ }
+ },
+
+ strictArgChecks: true,
+ serviceUrl: "",
+
+ parseResults: function(obj){
+ // summary
+ // parse the results coming back from an rpc request. this
+ // base implementation, just returns the full object
+ // subclasses should parse and only return the actual results
+ // obj: Object
+ // Object that is the return results from an rpc request
+ return obj;
+ },
+
+ errorCallback: function(/* dojo.Deferred */ deferredRequestHandler){
+ // summary:
+ // create callback that calls the Deferres errback method
+ // deferredRequestHandler: Deferred
+ // The deferred object handling a request.
+ return function(data){
+ deferredRequestHandler.errback(new Error(data.message));
+ };
+ },
+
+ resultCallback: function(/* dojo.Deferred */ deferredRequestHandler){
+ // summary:
+ // create callback that calls the Deferred's callback method
+ // deferredRequestHandler: Deferred
+ // The deferred object handling a request.
+
+ var tf = dojo.hitch(this,
+ function(obj){
+ if(obj.error!=null){
+ var err;
+ if(typeof obj.error == 'object'){
+ err = new Error(obj.error.message);
+ err.code = obj.error.code;
+ err.error = obj.error.error;
+ }else{
+ err = new Error(obj.error);
+ }
+ err.id = obj.id;
+ err.errorObject = obj;
+ deferredRequestHandler.errback(err);
+ }else{
+ deferredRequestHandler.callback(this.parseResults(obj));
+ }
+ }
+ );
+ return tf;
+ },
+
+ generateMethod: function(/*string*/ method, /*array*/ parameters, /*string*/ url){
+ // summary:
+ // generate the local bind methods for the remote object
+ // method: string
+ // The name of the method we are generating
+ // parameters: array
+ // the array of parameters for this call.
+ // url: string
+ // the service url for this call
+
+ return dojo.hitch(this, function(){
+ var deferredRequestHandler = new dojo.Deferred();
+
+ // if params weren't specified, then we can assume it's varargs
+ if( (this.strictArgChecks) &&
+ (parameters != null) &&
+ (arguments.length != parameters.length)
+ ){
+ // put error stuff here, no enough params
+ throw new Error("Invalid number of parameters for remote method.");
+ }else{
+ this.bind(method, dojo._toArray(arguments), deferredRequestHandler, url);
+ }
+
+ return deferredRequestHandler;
+ });
+ },
+
+ processSmd: function(object){
+ // summary:
+ // callback method for reciept of a smd object. Parse the smd
+ // and generate functions based on the description
+ // object:
+ // smd object defining this service.
+
+ if(object.methods){
+ dojo.forEach(object.methods, function(m){
+ if(m && m.name){
+ this[m.name] = this.generateMethod( m.name,
+ m.parameters,
+ m.url||m.serviceUrl||m.serviceURL);
+ if(!dojo.isFunction(this[m.name])){
+ throw new Error("RpcService: Failed to create" + m.name + "()");
+ /*console.debug("RpcService: Failed to create", m.name, "()");*/
+ }
+ }
+ }, this);
+ }
+
+ this.serviceUrl = object.serviceUrl||object.serviceURL;
+ this.required = object.required;
+ this.smd = object;
+ }
+});
+
+}