def _resolve_body(self, info, definitions, parts): """Return an XSD element for the SOAP:Body. Each part is a parameter or a return value and appears inside a wrapper element within the body named identically to the operation name and its namespace is the value of the namespace attribute. """ if not info: return None namespace = info["namespace"] if self.type == "input": tag_name = etree.QName(namespace, self.operation.name) else: tag_name = etree.QName(namespace, self.abstract.name.localname) # Create the xsd element to create/parse the response. Each part # is a sub element of the root node (which uses the operation name) elements = [] for name, msg in parts.items(): if msg.element: elements.append(msg.element) else: elements.append(xsd.Element(name, msg.type)) return xsd.Element(tag_name, xsd.ComplexType(xsd.Sequence(elements)))
def create_xml_soap_map(values): """Create an http://xml.apache.org/xml-soap#Map value.""" Map = xsd.ComplexType( xsd.Sequence([ xsd.Element("item", xsd.AnyType(), min_occurs=1, max_occurs="unbounded") ]), qname=etree.QName("{http://xml.apache.org/xml-soap}Map"), ) KeyValueData = xsd.Element( "{http://xml.apache.org/xml-soap}KeyValueData", xsd.ComplexType( xsd.Sequence([ xsd.Element("key", xsd.AnyType()), xsd.Element("value", xsd.AnyType()) ])), ) return Map(item=[ KeyValueData( xsd.AnyObject(xsd.String(), key), xsd.AnyObject(guess_xsd_type(value), value), ) for key, value in values.items() ])
def resolve(self, definitions, abstract_message): self.abstract = abstract_message children = [] for name, message in self.abstract.parts.items(): if message.element: elm = message.element.clone(name) else: elm = xsd.Element(name, message.type) children.append(elm) self.body = xsd.Element( self.operation.name, xsd.ComplexType(xsd.Sequence(children)) )
def _create_envelope_element(self): """Create combined `envelope` complexType which contains both the elements from the body and the headers. """ all_elements = xsd.Sequence([]) if self.header.type._element: all_elements.append( xsd.Element("{%s}header" % self.nsmap["soap-env"], self.header.type)) all_elements.append( xsd.Element( "{%s}body" % self.nsmap["soap-env"], self.body.type if self.body else None, )) return xsd.Element("{%s}envelope" % self.nsmap["soap-env"], xsd.ComplexType(all_elements))
def resolve(self, definitions, abstract_message): """Resolve the body element The specs are (again) not really clear how to handle the message parts in relation the message element vs type. The following strategy is chosen, which seem to work: - If the message part has a name and it maches then set it as body - If the message part has a name but it doesn't match but there are no other message parts, then just use that one. - If the message part has no name then handle it like an rpc call, in other words, each part is an argument. """ self.abstract = abstract_message if self.part_name and self.abstract.parts: if self.part_name in self.abstract.parts: message = self.abstract.parts[self.part_name] elif len(self.abstract.parts) == 1: message = list(self.abstract.parts.values())[0] else: raise ValueError( "Multiple parts for message %r while no matching part found" % self.part_name) if message.element: self.body = message.element else: elm = xsd.Element(self.part_name, message.type) self.body = xsd.Element(self.operation.name, xsd.ComplexType(xsd.Sequence([elm]))) else: children = [] for name, message in self.abstract.parts.items(): if message.element: elm = message.element.clone(name) else: elm = xsd.Element(name, message.type) children.append(elm) self.body = xsd.Element(self.operation.name, xsd.ComplexType(xsd.Sequence(children)))
def _resolve_header(self, info, definitions, parts): name = etree.QName(self.nsmap["soap-env"], "Header") container = xsd.All(consume_other=True) if not info: return xsd.Element(name, xsd.ComplexType(container)) for item in info: message_name = item["message"].text part_name = item["part"] message = definitions.get("messages", message_name) if message == self.abstract and part_name in parts: del parts[part_name] part = message.parts[part_name] if part.element: element = part.element.clone() element.attr_name = part_name else: element = xsd.Element(part_name, part.type) container.append(element) return xsd.Element(name, xsd.ComplexType(container))
def _resolve_body(self, info, definitions, parts): name = etree.QName(self.nsmap["soap-env"], "Body") if not info or not parts: return None # If the part name is omitted then all parts are available under # the soap:body tag. Otherwise only the part with the given name. if info["part"]: part_name = info["part"] sub_elements = [parts[part_name].element] else: sub_elements = [] for part_name, part in parts.items(): element = part.element.clone() element.attr_name = part_name or element.name sub_elements.append(element) if len(sub_elements) > 1: self._is_body_wrapped = True return xsd.Element(name, xsd.ComplexType(xsd.All(sub_elements))) else: self._is_body_wrapped = False return sub_elements[0]