def headpart_types(self, method, input=True): """ Get a list of I{parameter definitions} (pdef) defined for the specified method. Each I{pdef} is a tuple (I{name}, L{xsd.sxbase.SchemaObject}) @param method: A service method. @type method: I{service.Method} @param input: Defines input/output message. @type input: boolean @return: A list of parameter definitions @rtype: [I{pdef},] """ result = [] if input: headers = method.soap.input.headers else: headers = method.soap.output.headers for header in headers: part = header.part if part.element is not None: query = ElementQuery(part.element) else: query = TypeQuery(part.type) pt = query.execute(self.schema()) if pt is None: raise TypeNotFound(query.ref) if part.type is not None: pt = PartElement(part.name, pt) if input: if pt.name is None: result.append((part.name, pt)) else: result.append((pt.name, pt)) else: result.append(pt) return result
def bodypart_types(method, schema, input=True): """ This returns the types of a soap body. This is basically copied from the suds source code (suds.bindings.binding) """ result = [] if input: parts = method.soap.input.body.parts else: parts = method.soap.output.body.parts for p in parts: if p.element is not None: query = ElementQuery(p.element) else: query = TypeQuery(p.type) pt = query.execute(schema) if pt is None: raise TypeNotFound(query.ref) if p.type is not None: pt = TypeNotFound(p.name, pt) if input: if pt.name is None: result.append((p.name, pt)) else: result.append((pt.name, pt)) else: result.append(pt) return result
def marshal_exception(self, exc, method): raise NotImplementedError("cannot yet handle exceptions") # The following code is very much unfinished and there is no # guaranty that it is correct or even makes sense # Currently it finds the fault return types (there should only # be one AFAICT). How to get from there and to to a fault body # is still open. from suds import TypeNotFound from suds.bindings.binding import PartElement from suds.xsd.query import TypeQuery, ElementQuery rtypes = [] for f in method.unwrapped_.soap.faults: for p in f.parts: if p.element is not None: query = ElementQuery(p.element) else: query = TypeQuery(p.type) pt = query.execute(method.binding.output.schema()) if pt is None: raise TypeNotFound(query.ref) if p.type is not None: pt = PartElement(p.name, pt) rtypes.append(pt) return rtypes
def dependencies(self): deps = [] midx = None if self.ref is not None: query = ElementQuery(self.ref) e = query.execute(self.schema) if e is None: log.debug(self.schema) raise TypeNotFound(self.ref) deps.append(e) midx = 0 return (midx, deps)
def __part_type(self, part, input): """ Get a I{parameter definition} (pdef) defined for a given body or header message part. An input I{pdef} is a (I{name}, L{xsd.sxbase.SchemaObject}) tuple, while an output I{pdef} is a L{xsd.sxbase.SchemaObject}. @param part: A service method input or output part. @type part: I{suds.wsdl.Part} @param input: Defines input/output message. @type input: boolean @return: A list of parameter definitions @rtype: [I{pdef},...] """ if part.element is None: query = TypeQuery(part.type) else: query = ElementQuery(part.element) part_type = query.execute(self.schema()) if part_type is None: raise TypeNotFound(query.ref) if part.type is not None: part_type = PartElement(part.name, part_type) if not input: return part_type if part_type.name is None: return part.name, part_type return part_type.name, part_type
def set_wrapped(self): """ set (wrapped|bare) flag on messages """ for m in self.messages.values(): m.wrapped = False if len(m.parts) != 1: continue for p in m.parts: if p.element is None: continue query = ElementQuery(p.element) pt = query.execute(self.schema) if pt is None: raise TypeNotFound(query.ref) resolved = pt.resolve() if resolved.builtin(): continue m.wrapped = True
def set_wrapped(self): """ set (wrapped|bare) flag on messages """ for b in self.bindings.values(): for op in b.operations.values(): for body in (op.soap.input.body, op.soap.output.body): body.wrapped = False if len(body.parts) != 1: continue for p in body.parts: if p.element is None: continue query = ElementQuery(p.element) pt = query.execute(self.schema) if pt is None: raise TypeNotFound(query.ref) resolved = pt.resolve() if resolved.builtin(): continue body.wrapped = True
def set_wrapped(self): """ set (wrapped|bare) flag on messages """ for b in list(self.bindings.values()): for op in list(b.operations.values()): for body in (op.soap.input.body, op.soap.output.body): body.wrapped = False if len(body.parts) != 1: continue for p in body.parts: if p.element is None: continue query = ElementQuery(p.element) pt = query.execute(self.schema) if pt is None: raise TypeNotFound(query.ref) resolved = pt.resolve() if resolved.builtin(): continue body.wrapped = True