Mercurial > repos > uga-galaxy-group > webservice_toolsuite_v1_1

comparison WebServiceExtensionsV1.1/WebServiceToolWorkflow_REST_SOAP/clientGenerator/msHandler.py @ 0:049760c677de default tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Galaxy WSExtensions added successfully
author uga-galaxy-group
date Tue, 05 Jul 2011 19:34:18 -0400
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:049760c677de
1 '''
2 @author Rui Wang
3 @see LICENSE (MIT style license file).
4 '''
5
6
7 import ZSI.TC
8 import copy
9
10 __author__="Rui Wang, Chaitanya Guttula"
11
12 class MessageHandler:
13 '''handle message class'''
14
15 def msAssign(self, msInstance, nameValueDic):
16 '''given message class instance, _name:value tree structure dictionary,
17 assign the values to the correct leaves in the message tree,
18 return message class instance with values'''
19
20 #get the list of all parts of message
21 partList=getattr(getattr(msInstance, 'typecode'), 'ofwhat')
22 for part in partList:
23 #_name of part of message
24 partName=getattr(part, 'aname')
25 if partName not in nameValueDic.keys():
26 continue
27 #value assigned to part, can be simple type(directly assign) or tree structure(pass to complextypeAssign() or arraytypeAssign())
28 partValue=nameValueDic[partName]
29 if isinstance(part, ZSI.TC.ComplexType):
30 complextypeHolderClassInstance=self.complextypeAssign(part, partValue)
31 setattr(msInstance, partName, complextypeHolderClassInstance)
32 elif isinstance(part, ZSI.TC.Array) :
33 subArray=self.arraytypeAssign(part, partValue)
34 setattr(msInstance, partName, subArray)
35 print 'the arraay type is : ',subArray
36 else:
37 #simple type such as string...directly assign the value to the part
38 setattr(msInstance, partName, partValue)
39 return msInstance
40
41 def complextypeAssign(self, complextypeInstance, subNameValueDic):
42 '''given complex type instance, subtree of _name:value dictionary
43 traverse the tree structure recursively,
44 return top complextype holder class instance with values filled in'''
45
46 if not isinstance(complextypeInstance, ZSI.TC.ComplexType):
47 raise TypeError, 'First parameter has to be instance of ZSI.TC.ComplexType'
48 else:
49 complextypeHolderClassInstance=getattr(complextypeInstance,'pyclass')()
50
51 #element instance list of complex type
52 elementList=getattr(complextypeInstance, 'ofwhat')
53 for ele in elementList:
54
55 #_name of element of complex type
56 eleName=getattr(ele, 'aname')
57 if eleName not in subNameValueDic.keys():
58 continue
59
60 #value assigned to element, can be simple type(directly assign) or tree structure(pass to complextypeAssign() or arraytypeAssign())
61 eleValue=subNameValueDic[eleName]
62 if isinstance(ele, ZSI.TC.ComplexType):
63 subclomplextypeClassInstance=self.complextypeAssign(ele, eleValue)
64 setattr(complextypeHolderClassInstance, eleName, subclomplextypeClassInstance)
65 elif isinstance(ele, ZSI.TC.Array) :
66 subArray=self.arraytypeAssign(ele, eleValue)
67 setattr(complextypeHolderClassInstance, eleName, subArray)
68 else:
69
70 #simple type such as string...directly assign the value to the element
71 setattr(complextypeHolderClassInstance, eleName, eleValue)
72
73 return complextypeHolderClassInstance
74
75 def arraytypeAssign(self,arraytypeInstance, subValueArray):
76 '''given arraytype class instance, [values...],
77 recursively handle values,
78 return [arraytypeInstance filled with values]'''
79
80
81 if not isinstance(arraytypeInstance, ZSI.TC.Array):
82 raise TypeError, 'First parameter has to be instance of ZSI.TC.Array'
83 else:
84 resultArray=[]
85 if subValueArray is None:
86 return None
87 if subValueArray is []:
88 return []
89
90 #element instance of array type
91 elementInstance=getattr(arraytypeInstance, 'ofwhat')
92 if isinstance(elementInstance, ZSI.TC.ComplexType):
93 for eleValue in subValueArray:
94 subclomplextypeClassInstance=self.complextypeAssign(copy.deepcopy(elementInstance), eleValue)
95 resultArray.append(subclomplextypeClassInstance)
96 elif isinstance(elementInstance, ZSI.TC.Array) :
97 for eleValue in subValueArray:
98 subArray=self.arraytypeAssign(copy.deepcopy(elementInstance), eleValue)
99 resultArray.append(subArray)
100
101 else:
102
103 #simple type such as string...directly return the [value,...]
104 resultArray=subValueArray
105
106 return resultArray
107
108 def msParser(self, msInstance):
109 '''given message class instance,
110 parse the message class tree,
111 return message tree of _name:value dictionary'''
112
113 nameValueDic={}
114
115
116 #get the list of all parts of message
117 partList=getattr(getattr(msInstance, 'typecode'), 'ofwhat')
118 for part in partList:
119
120 #_name of part of message
121 partName=getattr(part, 'aname')
122 partValueDefault=getattr(msInstance, partName)
123
124 #value assigned to part, can be simple type(directly assign) or tree structure(pass to complextypeAssign() or arraytypeAssign())
125 # partValue=nameValueDic[partName]
126 # nameValueDic[partName]=None
127 if isinstance(part, ZSI.TC.ComplexType):
128 nameValueDic[partName]=self.complextypeParser(part)
129 elif isinstance(part, ZSI.TC.Array) :
130 nameValueDic[partName]=self.arraytypeParser(part, partValueDefault)
131 else:
132 #simple type such as string...directly retrieve the value of the part
133 nameValueDic[partName]=partValueDefault
134 return nameValueDic
135
136 def complextypeParser(self, complextypeInstance):
137 '''given complex type class instance,
138 traverse the tree structure recursively,
139 return subtree of _name:value dictionary'''
140
141 if not isinstance(complextypeInstance, ZSI.TC.ComplexType):
142 raise TypeError, 'First parameter has to be instance of ZSI.TC.ComplexType'
143 else:
144 subNameValueDic={}
145 complextypeHolderClassInstance=getattr(complextypeInstance,'pyclass')()
146 #element instance list of complex type
147 elementList=getattr(complextypeInstance, 'ofwhat')
148 for ele in elementList:
149 #_name of element of complex type
150 eleName=getattr(ele, 'aname')
151 eleValueDefault=getattr(complextypeHolderClassInstance,eleName)
152 print eleName
153 #value assigned to element, can be simple type(directly assign) or tree structure(pass to complextypeAssign() or arraytypeAssign())
154 # eleValue=subNameValueDic[eleName]
155 if isinstance(ele, ZSI.TC.ComplexType):
156 if(getattr(ele,'maxOccurs')=='unbounded'): # Handling element with maxOccurances as unbounded and type as complextype
157 print 'arraytype',eleName
158 tempArray=[]
159 sub = self.complextypeParser(ele)
160 tempArray.append(sub)
161 print 'array is : ',tempArray
162 subNameValueDic[eleName]=tempArray #tempArray.append(sub)#self.arraytypeParser(ele, eleValueDefault)
163 else:
164 print 'complextype', eleName
165 subNameValueDic[eleName]=self.complextypeParser(ele)
166 elif isinstance(ele, ZSI.TC.Array):
167 print 'arraytype', eleValueDefault
168 subNameValueDic[eleName]=self.arraytypeParser(ele, eleValueDefault)
169 else:
170 subNameValueDic[eleName] = eleValueDefault
171
172 return subNameValueDic
173
174
175 def arraytypeParser(self,arraytypeInstance, defaultValueArray):
176 '''given arraytype class instance, and its default value [defaultvalues...]
177 if element of array is not simple type then recursively handle traverse the type tree,
178 return [values...]
179 else return defaultValueArray[defaultvalues...]'''
180
181
182 if (not isinstance(arraytypeInstance, ZSI.TC.Array)): #or (getattr(arraytypeInstance,'maxOccurs')!='unbounded') :
183 raise TypeError, 'First parameter has to be instance of ZSI.TC.Array'
184 else:
185 subValueArray=[]
186
187
188 #element instance of array type
189 elementInstance=getattr(arraytypeInstance, 'ofwhat')
190 if isinstance(elementInstance, ZSI.TC.ComplexType):
191 if defaultValueArray is None:
192 subclomplextypeClassInstance=self.complextypeParser(elementInstance)
193 subValueArray.append(subclomplextypeClassInstance)
194 else:
195 for eleValue in defaultValueArray:
196 subclomplextypeClassInstance=self.complextypeParser(eleValue)
197 subValueArray.append(subclomplextypeClassInstance)
198 elif isinstance(elementInstance, ZSI.TC.Array) :
199 if defaultValueArray is None:
200 subarraytypeClassInstance=self.arraytypeParser(elementInstance, None)
201 subValueArray.append(subarraytypeClassInstance)
202 else:
203 for eleValue in defaultValueArray:
204 subArray=self.arraytypeParser(copy.deepcopy(elementInstance), eleValue)
205 subValueArray.append(subArray)
206
207 else:
208 #simple type such as string...directly return the [value,...]of the arraytypeInstance (default value)
209 subValueArray=defaultValueArray
210
211 return subValueArray
212
213
214 def flatten(self,obj):
215 if obj is None:
216 return None
217 elif hasattr(obj, '__dict__') and obj.__dict__:
218 return dict([(k, self.flatten(v)) for (k, v) in obj.__dict__.items()])
219 if isinstance(obj, (dict,)):
220 return dict([(k, self.flatten(v)) for (k, v) in obj.items()])
221 elif isinstance(obj, (list,)):
222 return [self.flatten(x) for x in obj]
223 elif isinstance(obj, (tuple,)):
224 return tuple([flatten(x) for x in obj])
225 else:
226 return obj
227
228 def getParameter(self, msInstance,param):
229 '''given message class instance, and parameter
230 parse the message class tree,
231 return the element '''
232 nameValueDic={}
233 plist = []
234 if(param.find('|0|')>-1):
235 s = param.split('|0|')
236 print 'found |0|',s
237 for l in s:
238 if(l.find('|')>-1):
239 t = l.split('|')
240 print 'found |',t
241 for i in t:
242 print 'i',i
243 plist.append(i)
244 else:
245 plist.append(l)
246 elif(param.find('|')>-1):
247 plist = param.split('|')
248 else:
249 partlist = getattr(getattr(msInstance , 'typecode'),'ofwhat')
250 for part in partlist:
251 if param == getattr(part,'aname'):
252 print part
253 return part
254
255
256 element = None
257 #get the list of all parts of message
258 partList=getattr(getattr(msInstance, 'typecode'), 'ofwhat')
259 for part in partList:
260 #_name of part of message
261 partName=getattr(part, 'aname')
262
263 if(partName == plist[0]):
264
265 partname=getattr(part,'pname')
266 partValueDefault=getattr(msInstance, partName)
267 break
268 #value assigned to part, can be simple type(directly assign) or tree structure(pass to complextypeAssign() or arraytypeAssign())
269 # partValue=nameValueDic[partName]
270 # nameValueDic[partName]=None
271 if isinstance(part, ZSI.TC.ComplexType):
272 print 'complextype', getattr(part,'aname')#plist[-1]
273 sp = ( self.complextypParser(part,plist[-1]))
274 if(sp !=None):
275 element = sp
276
277 elif isinstance(part, ZSI.TC.Array) :
278 element = self.arraytypParser(part, partValueDefault,plist[-1])
279 #nameValueDic[partName]=self.arraytypeParser(part, partValueDefault,param)
280 else:
281 #simple type such as string...directly retrieve the value of the part
282 if(partName == plist[-1]):
283 element = part
284 print 'spart',element
285 res = getattr(element,'nillable')
286 print res
287 return element
288
289 def complextypParser(self, complextypeInstance,param):
290 '''given complex type class instance, and paramater name
291 traverse the tree structure recursively,
292 return the element with parameter name'''
293 part =None
294 if not isinstance(complextypeInstance, ZSI.TC.ComplexType):
295 raise TypeError, 'First parameter has to be instance of ZSI.TC.ComplexType'
296 else:
297 subNameValueDic={}
298 complextypeHolderClassInstance=getattr(complextypeInstance,'pyclass')()
299 #element instance list of complex type
300 elementList=getattr(complextypeInstance, 'ofwhat')
301
302 for ele in elementList:
303 #_name of element of complex type
304 eleName=getattr(ele, 'aname')
305 eleValueDefault=getattr(complextypeHolderClassInstance, eleName)
306 #value assigned to element, can be simple type(directly assign) or tree structure(pass to complextypeAssign() or arraytypeAssign())
307 # eleValue=subNameValueDic[eleName]
308 if isinstance(ele, ZSI.TC.ComplexType):
309
310 if getattr(ele,'aname') == param:
311 print 'returning the middle complex type'
312 return ele
313 else:
314 part = self.complextypParser(ele,param)
315 return part
316 #subNameValueDic[eleName]=self.complextypeParser(ele)
317 # setattr(complextypeHolderClassInstance, eleName, subclomplextypeClassInstance)
318 elif isinstance(ele, ZSI.TC.Array) :
319 part = self.arraytypParser(ele, eleValueDefault,param)
320 return part
321
322 else:
323 if(param == eleName):
324 print 'matched',param
325 part = (ele)
326 return part
327 #simple type such as string...directly retrieve the value of the element
328 subNameValueDic[eleName]=eleValueDefault
329 return None#subNameValueDic
330
331
332
333 def arraytypParser(self,arraytypeInstance, defaultValueArray,param):
334 '''given arraytype class instance, and its default value [defaultvalues...]
335 if element of array is not simple type then recursively handle traverse the type tree,
336 return [values...]
337 else return defaultValueArray[defaultvalues...]'''
338
339
340 if not isinstance(arraytypeInstance, ZSI.TC.Array):
341 raise TypeError, 'First parameter has to be instance of ZSI.TC.Array'
342 else:
343 subValueArray=[]
344
345 #element instance of array type
346 elementInstance=getattr(arraytypeInstance, 'ofwhat')
347 if isinstance(elementInstance, ZSI.TC.ComplexType):
348 if defaultValueArray is None:
349 part = self.complextypParser(elementInstance,param)
350 return part
351 # subclomplextypeClassInstance=self.complextypeParser(elementInstance)
352 # subValueArray.append(subclomplextypeClassInstance)
353 else:
354 for eleValue in defaultValueArray:
355 part = self.complextypParser(eleValue,defaulValueArray,param)
356 subclomplextypeClassInstance=self.complextypeParser(eleValue)
357 # subValueArray.append(subclomplextypeClassInstance)
358 # setattr(elementInstance, eleName, subclomplextypeClassInstance)
359 elif isinstance(elementInstance, ZSI.TC.Array) :
360 # print 'arraytype', elementInstance
361 if defaultValueArray is None:
362 part = self.arraytypParser(elementInstance, None,param)
363 # subarraytypeClassInstance=self.arraytypeParser(elementInstance, None)
364 # subValueArray.append(subarraytypeClassInstance)
365 else:
366 for eleValue in defaultValueArray:
367 part = self.arraytypParser(copy.deepcopy(elementInstance), eleValue,param)
368 # subArray=self.arraytypeParser(copy.deepcopy(elementInstance), eleValue)
369 # subValueArray.append(subArray)
370
371 else:
372 #simple type such as string...directly return the [value,...]of the arraytypeInstance (default value)
373 return elementInstance
374 return None
375
376
377
378 #if __name__=="__main__":
379
380