def encryptMessage(self, env, use_encrypted_header=False, second_pass=False):
encrypted_parts = second_pass and self.second_pass_encrypted_parts or self.encrypted_parts
elements_to_encrypt = []
encrypted_headers = []
for elements_to_encrypt_func in encrypted_parts:
addl_elements = elements_to_encrypt_func(env)
if addl_elements[0] is None:
continue
if not isinstance(addl_elements[0], list):
addl_elements = ([addl_elements[0]], addl_elements[1])
for element in addl_elements[0]:
if element not in elements_to_encrypt:
if element[0].parent.match("Header") and use_encrypted_header:
enc_hdr = Element("EncryptedHeader", ns=wsse11ns)
element[0].parent.replaceChild(element[0], enc_hdr)
enc_hdr.append(element[0])
elements_to_encrypt.append((enc_hdr, "Content"))
encrypted_headers.append(enc_hdr)
else:
elements_to_encrypt.append((element, addl_elements[1]))
ref_list = xmlsec.encryptMessage(
self.cert, self.symmetricKey, elements_to_encrypt, "#" + self.keyId, self.keyReference, self.keyTransport
)
for enc_hdr in encrypted_headers:
enc_hdr.set("wsu:Id", enc_hdr[0].get("Id"))
enc_hdr[0].unset("Id")
if self.includeRefList:
self.encryptedKey.append(ref_list)
return self.encryptedKey
else:
return (self.encryptedKey, ref_list)
def main(self):
items = self.adsm_lists.service.GetListItems(self.args.list, self.args.view).listitems.data.row
method_idx = 1
batch = Element('Batch')\
.append(Attribute('OnError', 'Continue'))\
.append(Attribute('ListVersion', 1))
def update(b):
if not self.args.d:
updates = Element('ns1:updates').append(b)
print self.adsm_lists.service.UpdateListItems(listName=self.args.list, updates=updates)
for item in items:
method = Element('Method')\
.append(Attribute('ID', method_idx))\
.append(Attribute('Cmd', 'Delete'))\
.append(Element('Field')\
.append(Attribute('Name', 'ID'))\
.setText(item['_ows_ID']))
batch.append(method)
print method
method_idx += 1
if len(batch) > 20:
update(batch)
batch.detachChildren()
if len(batch) > 0:
update(batch)
def init_client(faults=True):
ENTREPRISE_WSDL = getattr(settings, 'SALESFORCE_ENTERPRISE_WSDL')
DJANGO_WSDL = getattr(settings, 'SALESFORCE_DJANGO_WSDL')
SALESFORCE_ENDPOINT = getattr(settings, 'SALESFORCE_ENDPOINT')
SALESFORCE_USER = getattr(settings, 'SALESFORCE_USER')
SALESFORCE_PASS = getattr(settings, 'SALESFORCE_PASS')
SALESFORCE_TOKEN = getattr(settings, 'SALESFORCE_TOKEN')
# Use the entreprise login to get a session id
entreprise_client = Client(ENTREPRISE_WSDL)
#entreprise_client.wsdl.url = SALESFORCE_ENDPOINT
login_result = entreprise_client.service.login(SALESFORCE_USER,
SALESFORCE_PASS+SALESFORCE_TOKEN)
# our client specific methods are in this specific
# NOTE we have to create the endpoint url using values from the serverUrl in the loginResponse plus
# the djangoAdapter schema
options = urlparse(login_result.serverUrl)
#DJANGO_SF_ENDPOINT = '%s://%s/services/Soap/class/dJangoAdapter' % (options.scheme, options.netloc)
django_client = Client(DJANGO_WSDL, location = SALESFORCE_ENDPOINT, faults=faults)
session_name_space = ('djan', 'http://soap.sforce.com/schemas/class/dJangoAdapter')
session = Element('sessionId').setText(login_result.sessionId)
wrapper = Element('SessionHeader')
wrapper.append(session)
django_client.set_options(soapheaders=wrapper)
return django_client
def set_auth_header(self):
"""Set up the authorization header"""
auth_user = Element("username").setText(self.api_user)
auth_key = Element("apiKey").setText(self.api_key)
auth_header = Element("authenticate", ns=self.ims_ns)
auth_header.children = [auth_user, auth_key]
return auth_header
def testWSDL(wsdlURL):
replyURL = 'http://wsamplification.appspot.com/?webservice=' + wsdlURL
try:
client = Client(wsdlURL)
wsans = ('wsa', 'http://schemas.xmlsoap.org/ws/2004/08/addressing')
wsaReply = Element('ReplyTo', ns=wsans)
wsaAddress = Element('Address', ns=wsans).setText(replyURL)
wsaReply.insert(wsaAddress)
except:
print 'Moving on...'
return
try:
client.set_options(soapheaders=wsaReply)
#impl = getattr(client.service, 'submitOrderNoAck')
#print impl()
for method in client.wsdl.services[0].ports[0].methods.values():
print method.name
result = getattr(client.service, method.name)()
#print result()
except suds.WebFault as detail:
print 'Invoking method failed'
print client
except:
print 'Derping...'
print client
def marshalled(self, context):
userid = self.userid
timestamp = rfc3339(datetime.datetime.now())
secret = self.secret
signature = sign(secret, timestamp+userid)
auth = self.authfragment % locals()
envelope = context.envelope
#Set the right ns prefixes
envelope.nsprefixes[ 'ns1' ] = envelope.nsprefixes[ 'ns0' ]
envelope.clearPrefix( 'ns0' )
#Add our auth to the header element
header = envelope.getChild('Header')
authns = Element( 'ns1:AuthenticationHeader' )
authns.append( Element( 'mktowsUserId' ).setText(self.userid) )
authns.append( Element( 'requestSignature' ).setText(signature) )
authns.append( Element( 'requestTimestamp' ).setText(timestamp) )
header.append( authns )
#Set the proper body prefixes
body = envelope.getChild( 'Body' )
body.prefix = 'SOAP-ENV'
body.children[0].prefix = 'ns1'
if self.debug:
with open("/tmp/envelope.txt","w") as f: f.write(envelope.str())
def set_object_mask(self, data):
"""Create an object mask to tell the API what we want"""
print "%sObjectMask" % self.object_type
el = Element("%sObjectMask" % self.object_type, ns=self.ims_ns)
mask = Element("mask")
mask = self.build_soap_header(mask, data)
el.children = [mask]
return el
def to_xml(self, factory):
# Needs to be an xsd:int with an attribute
# Can't do that with factory.create('ns0:quantity')
#metadata = factory.resolver.find('ns0:quantity')
#ns = metadata.namespace()
element = Element('ns0:quantity')
element.setText(str(self.value))
element.set('unitOfMeasure', self.unit)
return element
def node(self, content):
ns = content.type.namespace()
if content.type.form_qualified:
node = Element(content.tag, ns=ns)
node.addPrefix(ns[0], ns[1])
else:
node = Element(content.tag)
self.encode(node, content)
log.debug('created - node:\n%s', node)
return node
def xml(self):
"""
Get xml representation of the object.
@return: The root node.
@rtype: L{Element}
"""
root = Element('Security', ns=wssens)
root.set('mustUnderstand', str(self.mustUnderstand).lower())
for t in self.tokens:
root.append(t.xml())
return root
def header(self, content):
"""
Build the B{<Body/>} for an soap outbound message.
@param content: The header content.
@type content: L{Element}
@return: the soap body fragment.
@rtype: L{Element}
"""
header = Element('Header', ns=envns)
header.append(content)
return header
def body(self, content):
"""
Build the B{<Body/>} for an soap outbound message.
@param content: The body content.
@type content: L{Element}
@return: the soap body fragment.
@rtype: L{Element}
"""
body = Element('Body', ns=envns)
body.append(content)
return body
def set_session(self, session_id):
"""
Record the session info.
"""
self.session = session_id
self.session_expiration = datetime.now() + timedelta(
seconds=self.session_duration)
session_namespace = ('ns1', 'http://api.zuora.com/')
session = Element('session', ns=session_namespace).setText(session_id)
header = Element('SessionHeader', ns=session_namespace)
header.append(session)
self.client.set_options(soapheaders=[header])
def connect(self):
from .client import SmsClient
from suds.sax.element import Element
self.client = SmsClient(self._vim.server_fqdn)
session = eval(list(self._vim.client.client.options.transport.cookiejar)[0].value)
cookie = Element("vcSessionCookie")
cookie.setText(session)
self.client.wsdl.options.__pts__.set("soapheaders", cookie)
ref = Property('ServiceInstance')
ref._type = 'ServiceInstance'
self.service_instance = SmsServiceInstance(self, name='ServiceInstance', ref=ref)
self.connected = True
def add(self, root):
"""
Add an <xs:import/> to the specified schema root.
@param root: A schema root.
@type root: L{Element}
"""
node = Element('import', ns=self.xsdns)
node.set('namespace', self.ns)
if self.location is not None:
node.set('schemaLocation', self.location)
log.debug('%s inserted', node)
root.insert(node)
def startElement(self, name, attrs):
top = self.top()
node = Element(unicode(name), parent=top)
for a in attrs.getNames():
n = unicode(a)
v = unicode(attrs.getValue(a))
attribute = Attribute(n,v)
if self.mapPrefix(node, attribute):
continue
node.append(attribute)
top.append(node)
self.push(node)
def xml(self):
root = Element("Timestamp", ns=wsuns)
created = Element('Created', ns=wsuns)
created.setText(str(DateTime(self.created)))
expires = Element('Expires', ns=wsuns)
expires.setText(str(DateTime(self.expires)))
root.append(created)
root.append(expires)
return root
def body(self, content):
"""
Build the B{<Body/>} for a SOAP outbound message.
@param content: The body content.
@type content: L{Element}
@return: The SOAP body fragment.
@rtype: L{Element}
"""
body = Element("Body", ns=envns)
body.append(content)
return body
def startElement(self, name, attrs):
top = self.top()
node = Element(str(name))
for a in attrs.getNames():
n = str(a)
v = str(attrs.getValue(a))
attribute = Attribute(n,v)
if self.mapPrefix(node, attribute):
continue
node.append(attribute)
node.charbuffer = []
top.append(node)
self.push(node)
def xml(self):
root = Element("Timestamp", ns=wsuns)
# xsd:datetime format does not have fractional seconds
created = Element("Created", ns=wsuns)
created.setText(str(UTC(self.created - timedelta(microseconds=self.created.microsecond))))
expires = Element("Expires", ns=wsuns)
expires.setText(str(UTC(self.expires - timedelta(microseconds=self.expires.microsecond))))
root.append(created)
root.append(expires)
return root
def node(self, content):
#
# Create an XML node and namespace qualify as defined
# by the schema (elementFormDefault).
#
ns = content.type.namespace()
if content.type.form_qualified:
node = Element(content.tag, ns=ns)
node.addPrefix(ns[0], ns[1])
else:
node = Element(content.tag)
self.encode(node, content)
log.debug('created - node:\n%s', node)
return node
def _build_mouser_header(self):
header_partnerid = Element('PartnerID').setText(self._api_key)
header_accountinfo = Element('AccountInfo')
header_accountinfo.insert(header_partnerid)
header = Element('MouserHeader')
header.insert(header_accountinfo)
header.set('xmlns', 'http://api.mouser.com/service')
return header
def build_soap_header(self, el, data):
"""Set up a SOAP object for our headers"""
## make our first element
for name in data:
if type(data[name]) is dict:
## append to the current element
nel = Element(name)
el.children.append(nel)
self.build_soap_header(nel, data[name])
else:
opt = Element(name)
opt.setText(data[name])
el.children.append(opt)
# print "{name} - {data}".format(name=name,data=data[name])
return el
def describe_vehicle_failure2(vin):
"""This fails because there is a bug related when prettyxml is False
https://fedorahosted.org/suds/ticket/432
"""
client = Client(CHROME_URL)
account_info = client.factory.create('AccountInfo')
account_info._number = CHROME_ACCOUNT_NUMBER
account_info._secret = CHROME_ACCOUNT_SECRET
account_info._country = 'US'
account_info._language = 'en'
vin_element = Element('vin', ns=('ns1', 'urn:description7a.services.chrome.com'))
vin_element.setText(vin)
result = client.service.describeVehicle(account_info, vin_element)
print result
def apply(self, root):
"""
Apply the import (rule) to the specified schema.
If the schema does not already contain an import for the
I{namespace} specified here, it is added.
@param root: A schema root.
@type root: L{Element}
"""
if not self.filter.match(root, self.ns):
return
if self.exists(root):
return
node = Element('import', ns=self.xsdns)
node.set('namespace', self.ns)
if self.location is not None:
node.set('schemaLocation', self.location)
log.debug('inserting: %s', node)
root.insert(node)
def node(self, content):
"""
Create an XML node.
The XML node is namespace qualified as defined by the corresponding
schema element.
"""
ns = content.type.namespace()
if content.type.form_qualified:
node = Element(content.tag, ns=ns)
if ns[0]:
node.addPrefix(ns[0], ns[1])
else:
node = Element(content.tag)
self.encode(node, content)
log.debug("created - node:\n%s", node)
return node
def xml(self, wsse):
"""
Get xml representation of the object.
@return: The root node.
@rtype: L{Element}
"""
root = Element("Security", ns=wssens)
root.set("mustUnderstand", "true")
if wsse.includeTimestamp and wsse.headerLayout != HEADER_LAYOUT_LAX_TIMESTAMP_LAST:
root.append(Timestamp().xml())
for t in wsse.tokens:
root.append(UsernameToken(t.username, t.password, t.includenonce).xml())
if wsse.includeTimestamp and wsse.headerLayout == HEADER_LAYOUT_LAX_TIMESTAMP_LAST:
root.append(Timestamp().xml())
return root
def to_xml(self, factory):
# make sure the namespace is set to the correct one
metadata = factory.resolver.find('ns0:totalVatAmount')
element = Element("totalVatAmount", ns=metadata.namespace())
element.setText(str(int(self.value * 100)))
element.set('rate', self.rate)
element.set('currency', self.currency)
return element
def to_xml(self, factory):
# Dear Docdata: apparently, reusing Vat was not possible..?
#node = factory.create('ns0:totalVatAmount') does not support setting text.
element = Element('ns0:totalVatAmount')
element.setText(str(int(self.value * 100)))
element.set('rate', self.rate)
element.set('currency', self.currency)
return element
def build_soap_client(self):
if self.soap_endpoint is None or not self.soap_endpoint:
self.soap_endpoint = self.get_soap_endpoint()
self.soap_client = suds.client.Client(self.wsdl_file_url, faults=False, cachingpolicy=1)
self.soap_client.set_options(location=self.soap_endpoint)
self.soap_client.set_options(headers={'user-agent' : 'FuelSDK-Python-v1.3.0'})
if self.use_oAuth2_authentication == 'True':
element_oAuth = Element('fueloauth', ns=('etns', 'http://exacttarget.com'))
element_oAuth.setText(self.authToken);
self.soap_client.set_options(soapheaders=(element_oAuth))
else:
element_oAuth = Element('oAuth', ns=('etns', 'http://exacttarget.com'))
element_oAuthToken = Element('oAuthToken').setText(self.internalAuthToken)
element_oAuth.append(element_oAuthToken)
self.soap_client.set_options(soapheaders=(element_oAuth))
security = suds.wsse.Security()
token = suds.wsse.UsernameToken('*', '*')
security.tokens.append(token)
self.soap_client.set_options(wsse=security)
def xml(self):
"""
Get xml representation of the object.
@return: The root node.
@rtype: L{Element}
"""
root = Element('Security', ns=wssens)
root.set('mustUnderstand', str(self.mustUnderstand).lower())
for t in self.tokens:
root.append(t.xml())
return root
def login(self):
url = "/".join([
self.globalconfig["baseURL"], self.globalconfig["webservice"],
self.globalconfig["webservicefile"]
])
clientlogin = Client(url)
token = clientlogin.service.authenticate(
username=self.globalconfig["username"],
password=self.globalconfig["password"])
ssnns = (self.globalconfig["ns"], self.globalconfig["mainurl"])
ssn = Element('SecureToken', ns=ssnns).setText(token)
self.ssn = ssn
return ssn
def setUp(self):
url = 'http://localhost:8080/tmis-ws-laboratory/tmis-laboratory-integration?wsdl'
self.client = Client(url, username='', password='', cache=None)
medipadWsUrl = 'http://localhost:8080/tmis-ws-medipad/tmis-medipad?wsdl'
self.medipadClient = Client(medipadWsUrl, username='', password='', cache=None)
# Authenticate
authenticator = Authenticator()
authData = authenticator.asAdmin()
# Add auth headers
tmisAuthNS = ('ta', 'http://korus.ru/tmis/auth')
authHeader = Element('tmisAuthToken', ns=tmisAuthNS).setText(authData.authToken.id)
self.medipadClient.set_options(soapheaders=authHeader)
db.initialize()
def augment_metadata(self, entities, board='departures', **kwargs):
station_entities = []
for entity in entities:
if not entity.identifiers.get('crs'):
continue
station_entities.append(entity)
station_entities = station_entities[:self._max_results]
if not station_entities:
return
try:
ldb = suds.client.Client(self._WSDL_URL, soapheaders=Element('AccessToken').insert(Element('TokenValue').setText(self._token)))
except Exception, e:
logger.warning("Could not instantiate suds client for live departure board.", exc_info=True, extra={'wsdl_url': self._WSDL_URL})
self._add_error(station_entities)
return
def add(self, root):
"""
Add an <xs:import/> to the specified schema root.
@param root: A schema root.
@type root: L{Element}
"""
node = Element('import', ns=self.xsdns)
node.set('namespace', self.ns)
if self.location is not None:
node.set('schemaLocation', self.location)
log.debug('%s inserted', node)
root.insert(node)
def get_suds_element(suds_obj, element_name):
"Build a suds Element based on a suds-encoded response variable"
el = Element(element_name)
for node in suds_obj:
left = node[0]
right = node[1]
# Attributes start with _
if left[:1] == '_':
el.set(left[1:], str(right))
# Otherwise it's a subelement
else:
if type(right) is list:
for item in right:
sub = get_suds_element(item, str(left))
el.append(sub)
else:
sub = get_suds_element(right, str(left))
el.append(sub)
return el
def __init__(self, wsdl=None, api_key=None, timeout=5):
"""
Constructor
Keyword arguments:
wsdl -- the URL of the Darwin LDB WSDL document. Will fall back to using the DARWIN_WEBSERVICE_WSDL environment variable if not supplied
api_key -- a valid API key for the Darwin LDB webservice. Will fall back to the DARWIN_WEBSERVICE_API_KEY if not supplied
timeout -- a timeout in seconds for calls to the LDB Webservice (default 5)
"""
if not wsdl:
wsdl = os.environ['DARWIN_WEBSERVICE_WSDL']
if not api_key:
api_key = os.environ['DARWIN_WEBSERVICE_API_KEY']
self._soap_client = Client(wsdl)
self._soap_client.set_options(timeout=timeout)
#build soap headers
token3 = Element('AccessToken', ns=DARWIN_WEBSERVICE_NAMESPACE)
token_value = Element('TokenValue', ns=DARWIN_WEBSERVICE_NAMESPACE)
token_value.setText(api_key)
token3.append(token_value)
self._soap_client.set_options(soapheaders=(token3))
def node(self, content):
#
# Create an XML node and namespace qualify as defined
# by the schema (elementFormDefault).
#
ns = content.type.namespace()
if content.type.form_qualified:
node = Element(content.tag, ns=ns)
node.addPrefix(ns[0], ns[1])
else:
node = Element(content.tag)
self.encode(node, content)
log.debug('created - node:\n%s', node)
return node
def build_schema(self):
"""Process L{Types} objects and create the schema collection."""
loaded_schemata = {}
container = SchemaCollection(self)
for t in (t for t in self.types if t.local()):
for root in t.contents():
schema = Schema(root, self.url, self.options, loaded_schemata, container)
container.add(schema)
if not container:
root = Element.buildPath(self.root, "types/schema")
schema = Schema(root, self.url, self.options, loaded_schemata, container)
container.add(schema)
self.schema = container.load(self.options, loaded_schemata)
#TODO: Recheck this XSD schema merging. XSD schema imports are not
# supposed to be transitive. They only allow the importing schema to
# reference entities from the imported schema, but do not include them
# as their own content.
for s in (t.schema() for t in self.types if t.imported()):
self.schema.merge(s)
return self.schema
def to_xml(self, factory):
# Needs to be an xsd:int with an attribute. Suds is not
# responding nicely with basic types combined with attributes, so
# we can't do that with factory.create('ns0:quantity')
#
# See also:
# https://stackoverflow.com/questions/13103023/how-can-i-assign-a-value-to-a-factory-created-simpletype-object-with-python-suds
# make sure the namespace is set to the correct one
metadata = factory.resolver.find('ns0:quantity')
element = Element("quantity", ns=metadata.namespace())
element.setText(str(self.value))
element.set('unitOfMeasure', self.unit)
return element
def __init__(self, key):
"""
input - 'key' - your unique access token.
"""
self.key = key
self.url = 'https://lite.realtime.nationalrail.co.uk/OpenLDBWS/wsdl.aspx?ver=2017-10-01'
self.namespace = ('ns2',
'http://thalesgroup.com/RTTI/2013-11-28/Token/types')
self.header = Element('AccessToken', ns=self.namespace)
header_val = Element('TokenValue',
ns=self.namespace,
parent=self.header)
header_val.setText(key)
self.header.append(header_val)
self.__client = Client(self.url)
self.__client.set_options(soapheaders=self.header)
def __init__(self, url, username, password, query):
self.url = url
self.username = username
self.password = password
self.query = query #project.id:ProjectPeriod AND type:defect
self.connected = True
self.session = Client(
self.url +
'/ws/services/SessionWebService?wsdl') #http://10.0.0.1/polarion
try:
self.session.service.logIn(self.username, self.password)
header_regex = re.compile('<ns1:sessionID.+>(.*)</ns1:sessionID')
m = header_regex.search(self.session.last_received().str())
sessionId = m.group(1)
session_ns = ('ns1', 'http://ws.polarion.com/session')
self.sessionId = Element('sessionID',
ns=session_ns).setText(sessionId)
except:
logger.error('Can not get the issues from ' + self.url +
' with the username ' + self.username)
self.connected = False
def apply(self, root):
"""
Apply the import (rule) to the specified schema.
If the schema does not already contain an import for the
I{namespace} specified here, it is added.
@param root: A schema root.
@type root: L{Element}
"""
if not self.filter.match(root, self.ns):
return
if self.exists(root):
return
node = Element('import', ns=self.xsdns)
node.set('namespace', self.ns)
if self.location is not None:
node.set('schemaLocation', self.location)
log.debug('inserting: %s', node)
root.insert(node)
def node(self, content):
"""
Create an XML node.
The XML node is namespace qualified as defined by the corresponding
schema element.
"""
ns = content.type.namespace()
if content.type.form_qualified:
node = Element(content.tag, ns=ns)
if ns[0]:
node.addPrefix(ns[0], ns[1])
else:
node = Element(content.tag)
self.encode(node, content)
log.debug("created - node:\n%s", node)
return node
def node(self, content):
"""
Create and return an XML node that is qualified
using the I{type}. Also, make sure all referenced namespace
prefixes are declared.
@param content: The content for which proccessing has ended.
@type content: L{Object}
@return: A new node.
@rtype: L{Element}
"""
ns = content.type.namespace()
if content.type.form_qualified:
node = Element(content.tag, ns=ns)
node.addPrefix(ns[0], ns[1])
else:
node = Element(content.tag)
self.encode(node, content)
log.debug('created - node:\n%s', node)
return node
def get_gg_details(nvic, username, password):
url = "http://eurotaxglasswebservices.com.au/GeneralGGWebService.asmx?WSDL"
imp = Import('http://www.w3.org/2001/XMLSchema',
location='http://www.w3.org/2001/XMLSchema.xsd')
imp.filter.add('http://microsoft.com/webservices/')
client = Client(url, doctor=ImportDoctor(imp))
code = Element('Username').setText(username)
pwd = Element('Password').setText(password)
reqsoapheader = Element('AuthHeader').insert(code)
reqsoapheader = reqsoapheader.append(pwd)
reqsoap_attribute = Attribute('xmlns', "http://microsoft.com/webservices/")
reqsoapheader.append(reqsoap_attribute)
client.set_options(soapheaders=reqsoapheader)
# print client # shows the details of this service
result = client.service.GetDetailsSpecificationAll('A', nvic)
details = result.diffgram.NewDataSet.DataSepcDetails
# print details
return details
def encryptMessage(self,
env,
use_encrypted_header=False,
second_pass=False):
encrypted_parts = second_pass and self.second_pass_encrypted_parts or self.encrypted_parts
elements_to_encrypt = []
encrypted_headers = []
for elements_to_encrypt_func in encrypted_parts:
addl_elements = elements_to_encrypt_func(env)
if addl_elements[0] is None:
continue
if not isinstance(addl_elements[0], list):
addl_elements = ([addl_elements[0]], addl_elements[1])
for element in addl_elements[0]:
if element not in elements_to_encrypt:
if element[0].parent.match(
'Header') and use_encrypted_header:
enc_hdr = Element('EncryptedHeader', ns=wsse11ns)
element[0].parent.replaceChild(element[0], enc_hdr)
enc_hdr.append(element[0])
elements_to_encrypt.append((enc_hdr, 'Content'))
encrypted_headers.append(enc_hdr)
else:
elements_to_encrypt.append((element, addl_elements[1]))
ref_list = xmlsec.encryptMessage(self.cert, self.symmetricKey,
elements_to_encrypt, '#' + self.keyId,
self.keyReference, self.keyTransport)
for enc_hdr in encrypted_headers:
enc_hdr.set('wsu:Id', enc_hdr[0].get('Id'))
enc_hdr[0].unset('Id')
if self.includeRefList:
self.encryptedKey.append(ref_list)
return self.encryptedKey
else:
return (self.encryptedKey, ref_list)
def xml(self):
if self.digest and self.password is None:
raise RuntimeError("Cannot generate password digest without the password.")
if self.autosetnonce:
self.setnonce()
if self.autosetcreated:
self.setcreated()
root = Element('UsernameToken', ns=WSSENS)
u = Element('Username', ns=WSSENS)
u.setText(self.username)
root.append(u)
if self.password is not None:
password = self.password
if self.digest:
password = self.get_digest()
p = Element('Password', ns=WSSENS)
p.setText(password)
p.set('Type', DIGEST_TYPE if self.digest else TEXT_TYPE)
root.append(p)
if self.nonce is not None:
n = Element('Nonce', ns=WSSENS)
n.setText(base64.encodestring(self.nonce)[:-1])
n.set('EncodingType', BASE64_ENC_TYPE)
root.append(n)
if self.created:
c = Element('Created', ns=WSUNS)
c.setText(iso_utc(self.created))
root.append(c)
return root
class Document:
""" An XML Document """
DECL = '<?xml version="1.0" encoding="UTF-8"?>'
def __init__(self, root=None):
"""
@param root: A root L{Element} or name used to build
the document root element.
@type root: (L{Element}|str|None)
"""
self.__root = None
self.append(root)
def root(self):
"""
Get the document root element (can be None)
@return: The document root.
@rtype: L{Element}
"""
return self.__root
def append(self, node):
"""
Append (set) the document root.
@param node: A root L{Element} or name used to build
the document root element.
@type node: (L{Element}|str|None)
"""
if isinstance(node, basestring):
self.__root = Element(node)
return
if isinstance(node, Element):
self.__root = node
return
def getChild(self, name, ns=None, default=None):
"""
Get a child by (optional) name and/or (optional) namespace.
@param name: The name of a child element (may contain prefix).
@type name: basestring
@param ns: An optional namespace used to match the child.
@type ns: (I{prefix}, I{name})
@param default: Returned when child not-found.
@type default: L{Element}
@return: The requested child, or I{default} when not-found.
@rtype: L{Element}
"""
if self.__root is None:
return default
if ns is None:
prefix, name = splitPrefix(name)
if prefix is None:
ns = None
else:
ns = self.__root.resolvePrefix(prefix)
if self.__root.match(name, ns):
return self.__root
else:
return default
def childAtPath(self, path):
"""
Get a child at I{path} where I{path} is a (/) separated
list of element names that are expected to be children.
@param path: A (/) separated list of element names.
@type path: basestring
@return: The leaf node at the end of I{path}
@rtype: L{Element}
"""
if self.__root is None:
return None
if path[0] == '/':
path = path[1:]
path = path.split('/',1)
if self.getChild(path[0]) is None:
return None
if len(path) > 1:
return self.__root.childAtPath(path[1])
else:
return self.__root
def childrenAtPath(self, path):
"""
Get a list of children at I{path} where I{path} is a (/) separated
list of element names that are expected to be children.
@param path: A (/) separated list of element names.
@type path: basestring
@return: The collection leaf nodes at the end of I{path}
@rtype: [L{Element},...]
"""
if self.__root is None:
return []
if path[0] == '/':
path = path[1:]
path = path.split('/',1)
if self.getChild(path[0]) is None:
return []
if len(path) > 1:
return self.__root.childrenAtPath(path[1])
else:
return [self.__root,]
def getChildren(self, name=None, ns=None):
"""
Get a list of children by (optional) name and/or (optional) namespace.
@param name: The name of a child element (may contain prefix).
@type name: basestring
@param ns: An optional namespace used to match the child.
@type ns: (I{prefix}, I{name})
@return: The list of matching children.
@rtype: [L{Element},...]
"""
if name is None:
matched = self.__root
else:
matched = self.getChild(name, ns)
if matched is None:
return []
else:
return [matched,]
def str(self):
"""
Get a string representation of this XML document.
@return: A I{pretty} string.
@rtype: basestring
"""
s = []
s.append(self.DECL)
root = self.root()
if root is not None:
s.append('\n')
s.append(root.str())
return ''.join(s)
def plain(self):
"""
Get a string representation of this XML document.
@return: A I{plain} string.
@rtype: basestring
"""
s = []
s.append(self.DECL)
root = self.root()
if root is not None:
s.append(root.plain())
return ''.join(s)
def __unicode__(self):
return self.str()
def create(cls, definitions):
root = Element('types', ns=wsdlns)
definitions.root.insert(root)
return Types(root, definitions)
def xml(self):
"""
Get xml representation of the object.
@return: The root node.
@rtype: L{Element}
"""
root = Element('UsernameToken', ns=wssens)
u = Element('Username', ns=wssens)
u.setText(self.username)
root.append(u)
p = Element('Password', ns=wssens)
p.setText(self.password)
root.append(p)
if self.nonce is not None:
n = Element('Nonce', ns=wssens)
n.setText(self.nonce)
root.append(n)
if self.created is not None:
n = Element('Created', ns=wsuns)
n.setText(self.created.isoformat())
root.append(n)
return root
def xml(self):
self.created = datetime.utcnow()
root = Element("Timestamp", ns=WSUNS)
created = Element('Created', ns=WSUNS)
created.setText(iso_utc(self.created))
root.append(created)
if self.validity is not None:
self.expires = self.created + timedelta(seconds=self.validity)
expires = Element('Expires', ns=WSUNS)
expires.setText(iso_utc(self.expires))
root.append(expires)
return root
def __init__(self, content):
Element.__init__(self, content.name, content.parent)
self.__content = content
def xml(self):
"""
Get xml representation of the object.
@return: The root node.
@rtype: L{Element}
"""
root = Element('UsernameToken', ns=wssens)
u = Element('Username', ns=wssens)
u.setText(self.username)
root.append(u)
p = Element('Password', ns=wssens)
p.setText(self.generate_digest())
p.set(wspassd[0], wspassd[1])
root.append(p)
n = Element('Nonce', ns=wssens)
nonce_bytes = self.nonce
if not isinstance(self.nonce, bytes):
nonce_bytes = self.nonce.encode('utf-8')
n.setText(base64.encodebytes(nonce_bytes)[:-1])
n.set(wsenctype[0], wsenctype[1])
root.append(n)
n = Element('Created', ns=wsuns)
n.setText(self.created)
root.append(n)
self.reset()
return root
exit(8)
print 'Found', num_layers, 'layers'
if not_found_layer1:
print 'Layer 1 not found!'
exit(9)
if not_found_layer2:
print 'Layer 2 not found!'
exit(10)
print 'GetLayers: OK'
layers = [layer1, layer2]
##### CREATE MODEL
###################################
mod_params = Element('ModelParameters')
mod_params.applyns((None, 'http://openmodeller.cria.org.br/xml/1.0'))
sampler = Element('Sampler')
env = Element('Environment')
# Layers
for ref_layer in layers:
map_element = Element('Map')
map_element.set('Id', ref_layer)
env.append(map_element)
# Mask
mask_element = Element('Mask')
mask_element.set('Id', layer1)
env.append(mask_element)
sampler.append(env)
# Points
presence = Element('Presence')
def test_init_name(name, expected_prefix, expected_name):
e = Element(name)
assert e.prefix == expected_prefix
assert e.name == expected_name
def _marshallSObjects(self, sObjects, tag='sObjects'):
'''
Marshall generic sObjects into a list of SAX elements
This code is going away ASAP
tag param is for nested objects (e.g. MergeRequest) where
key: object must be in <key/>, not <sObjects/>
'''
if not isinstance(sObjects, (tuple, list)):
sObjects = (sObjects, )
if sObjects[0].type in [
'LeadConvert', 'SingleEmailMessage', 'MassEmailMessage'
]:
nsPrefix = 'tns:'
else:
nsPrefix = 'ens:'
li = []
for obj in sObjects:
el = Element(tag)
el.set('xsi:type', nsPrefix + obj.type)
for k, v in obj:
if k == 'type':
continue
# This is here to avoid 'duplicate values' error when setting a field in fieldsToNull
# Even a tag like <FieldName/> will trigger it
if v == None:
# not going to win any awards for variable-naming scheme here
tmp = Element(k)
tmp.set('xsi:nil', 'true')
el.append(tmp)
elif isinstance(v, (list, tuple)):
for value in v:
el.append(Element(k).setText(value))
elif isinstance(v, suds.sudsobject.Object):
el.append(self._marshallSObjects(v, k))
else:
el.append(Element(k).setText(v))
li.append(el)
return li
def test_missing(self):
root = Element("root")
result = root.childAtPath("an invalid path")
assert result is None
def test_backslash_in_name(self):
root, a, _, _ = self.__create_single_branch("root", "a", "b", "c")
b_c = Element("b\\c")
a.append(b_c)
result = root.childAtPath("a/b\\c")
assert result is b_c
