1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
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;
}
});
}
|
