def _get_soap_headers(self):
import oasis_200401_wss_wssecurity_secext_1_0_xsd_types
from ZSI.schema import GED
security = GED("http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd", "Security").pyclass()
token = GED("http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd", "UsernameToken").pyclass()
security.Any = [token]
token.Username = '******'
klass = GED("http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd", "Password").pyclass
token.Any = [klass('guest'),]
return (security,)
def test_dispatch_Echo_MIH_EPR(self):
epr = GED('http://schemas.xmlsoap.org/ws/2004/03/addressing','EndpointReference').pyclass()
epr.Address = 'urn:whatever'
loc = self.client_module.EchoWSAddr200403ServerLocator()
port = loc.getport(endPointReference=epr, **self.getPortKWArgs())
msg = self.client_module.EchoRequest()
msg.EchoIn = 1
rsp = port.Echo(msg)
self.failUnless(rsp.EchoResult == msg.EchoIn, "Bad Echo")
def test_dispatch_Echo_MIH_EPR3_BadHeader(self):
"""Unqualified element "mystr" in Header
"""
epr = GED('http://schemas.xmlsoap.org/ws/2004/03/addressing','EndpointReference').pyclass()
epr.Address = 'urn:whatever'
epr.ReferenceProperties = epr.new_ReferenceProperties()
class Xstr(str):
typecode = TC.String('mystr')
epr.ReferenceProperties.Any = [Xstr('whatever'),]
loc = self.client_module.EchoWSAddr200403ServerLocator()
self._setUpDispatch()
port = loc.getport(endPointReference=epr, **self.getPortKWArgs())
msg = self.client_module.EchoRequest()
self.failUnlessRaises(FaultException, port.Echo,msg)
def test_dispatch_Echo_MIH_EPR3(self):
epr = GED('http://schemas.xmlsoap.org/ws/2004/03/addressing','EndpointReference').pyclass()
epr.Address = 'urn:whatever'
epr.ReferenceProperties = epr.new_ReferenceProperties()
class Xstr(str):
typecode = TC.String(('urn:josh','mystr'))
epr.ReferenceProperties.Any = [Xstr('whatever'),]
loc = self.client_module.EchoWSAddr200403ServerLocator()
self._setUpDispatch()
port = loc.getport(endPointReference=epr, **self.getPortKWArgs())
msg = self.client_module.EchoRequest()
epr2 = GTD('http://schemas.xmlsoap.org/ws/2004/03/addressing','EndpointReferenceType')(None).pyclass()
epr2.Address = epr.Address
epr2.ReferenceProperties = epr.ReferenceProperties
msg.EchoIn = epr2
rsp = port.Echo(msg)
self.failUnless(rsp.EchoResult.Address == msg.EchoIn.Address, "Bad Echo")
self.failUnless(rsp.EchoResult.ReferenceProperties.Any == msg.EchoIn.ReferenceProperties.Any, "Bad Echo")
getAllAsynchronousHashResultsResponse.typecode)
return response
# op: removeAsynchronousHashRequest
def removeAsynchronousHashRequest(self, request, **kw):
if isinstance(request, removeAsynchronousHashRequest) is False:
raise TypeError, "%s incorrect request type" % (request.__class__)
# no input wsaction
self.binding.Send(None, None, request, soapaction="", **kw)
# no output wsaction
response = self.binding.Receive(
removeAsynchronousHashRequestResponse.typecode)
return response
hashAsynchronously = GED("http://hasher.ws.lockss.org/",
"hashAsynchronously").pyclass
hashAsynchronouslyResponse = GED("http://hasher.ws.lockss.org/",
"hashAsynchronouslyResponse").pyclass
hash = GED("http://hasher.ws.lockss.org/", "hash").pyclass
hasherParams = GTD("http://hasher.ws.lockss.org/",
"hasherWsParams",
lazy=False)
hashResponse = GED("http://hasher.ws.lockss.org/", "hashResponse").pyclass
getAsynchronousHashResult = GED("http://hasher.ws.lockss.org/",
"getAsynchronousHashResult").pyclass
raise TypeError, "%s incorrect request type" % (request.__class__)
# no input wsaction
self.binding.Send(
None,
None,
request,
soapaction=
"http://service.apollo.pitt.edu/simulatorservice/v3_0_2/terminateRun",
**kw)
# no output wsaction
response = self.binding.Receive(terminateRunResponse.typecode)
return response
runSimulationRequest = GED(
"http://service.apollo.pitt.edu/simulatorservice/v3_0_2/",
"runSimulation").pyclass
runSimulationResponse = GED(
"http://service.apollo.pitt.edu/simulatorservice/v3_0_2/",
"runSimulationResponse").pyclass
getScenarioLocationCodesSupportedBySimulatorRequest = GED(
"http://service.apollo.pitt.edu/simulatorservice/v3_0_2/",
"getScenarioLocationCodesSupportedBySimulator").pyclass
getScenarioLocationCodesSupportedBySimulatorResponse = GED(
"http://service.apollo.pitt.edu/simulatorservice/v3_0_2/",
"getScenarioLocationCodesSupportedBySimulatorResponse").pyclass
runSimulationsRequest = GED(
# op: createItem
def createItem(self, request, **kw):
if isinstance(request, createItemRequest) is False:
raise TypeError, "%s incorrect request type" % (request.__class__)
# no input wsaction
self.binding.Send(None,
None,
request,
soapaction="http://ws4pm.imio.be/createItem",
**kw)
# no output wsaction
response = self.binding.Receive(createItemResponse.typecode)
return response
testConnectionRequest = GED("http://ws4pm.imio.be",
"testConnectionRequest").pyclass
testConnectionResponse = GED("http://ws4pm.imio.be",
"testConnectionResponse").pyclass
checkIsLinkedRequest = GED("http://ws4pm.imio.be",
"checkIsLinkedRequest").pyclass
checkIsLinkedResponse = GED("http://ws4pm.imio.be",
"checkIsLinkedResponse").pyclass
getConfigInfosRequest = GED("http://ws4pm.imio.be",
"getConfigInfosRequest").pyclass
getConfigInfosResponse = GED("http://ws4pm.imio.be",
"getConfigInfosResponse").pyclass
if isinstance(request, getSupportedLocationsRequest) is False:
raise TypeError, "%s incorrect request type" % (request.__class__)
# no input wsaction
self.binding.Send(
None,
None,
request,
soapaction=
"http://service.apollo.pitt.edu/simulatorservice/getSupportedLocations",
**kw)
# no output wsaction
response = self.binding.Receive(getSupportedLocationsResponse.typecode)
return response
runRequest = GED("http://service.apollo.pitt.edu/simulatorservice/",
"run").pyclass
runResponse = GED("http://service.apollo.pitt.edu/simulatorservice/",
"runResponse").pyclass
getRunStatusRequest = GED("http://service.apollo.pitt.edu/simulatorservice/",
"getRunStatus").pyclass
getRunStatusResponse = GED("http://service.apollo.pitt.edu/simulatorservice/",
"getRunStatusResponse").pyclass
getSupportedLocationsRequest = GED(
"http://service.apollo.pitt.edu/simulatorservice/",
"getSupportedLocations").pyclass
getSupportedLocationsResponse = GED(
##################################################
# file: smsclould_server.py
#
# skeleton generated by "ZSI.generate.wsdl2dispatch.WSAServiceModuleWriter"
# C:\Python27\Scripts\wsdl2py-script.py -a http://114.80.200.100:8081/axis2/services/smsclould?wsdl
#
##################################################
from ZSI.schema import GED, GTD
from ZSI.TCcompound import ComplexType, Struct
from smsclould_types import *
from ZSI.ServiceContainer import WSAResource
# Messages
getStatusByTimeRequest = GED("http://yupsms.com", "getStatusByTime").pyclass
getStatusByTimeResponse = GED("http://yupsms.com", "getStatusByTimeResponse").pyclass
getStatusByIdRequest = GED("http://yupsms.com", "getStatusById").pyclass
getStatusByIdResponse = GED("http://yupsms.com", "getStatusByIdResponse").pyclass
sendsmsRequest = GED("http://yupsms.com", "sendsms").pyclass
sendsmsResponse = GED("http://yupsms.com", "sendsmsResponse").pyclass
checkBalanceRequest = GED("http://yupsms.com", "checkBalance").pyclass
checkBalanceResponse = GED("http://yupsms.com", "checkBalanceResponse").pyclass
getReplyByTimeRequest = GED("http://yupsms.com", "getReplyByTime").pyclass
##################################################
# file: AuthService_server.py
#
# skeleton generated by "ZSI.generate.wsdl2dispatch.ServiceModuleWriter"
# /usr/bin/wsdl2py -bw http://redalert3pc.auth.pubsvs.gamespy.com/AuthService/AuthService.asmx?wsdl
#
##################################################
from ZSI.schema import GED, GTD
from ZSI.TCcompound import ComplexType, Struct
from AuthService_types import *
from ZSI.twisted.WSresource import WSResource
# Messages
LoginUserSoapIn = GED("http://gamespy.net/AuthService/", "LoginUser").pyclass
LoginUserSoapOut = GED("http://gamespy.net/AuthService/",
"LoginUserResponse").pyclass
LoginUniqueNickSoapIn = GED("http://gamespy.net/AuthService/",
"LoginUniqueNick").pyclass
LoginUniqueNickSoapOut = GED("http://gamespy.net/AuthService/",
"LoginUniqueNickResponse").pyclass
LoginProfileSoapIn = GED("http://gamespy.net/AuthService/",
"LoginProfile").pyclass
LoginProfileSoapOut = GED("http://gamespy.net/AuthService/",
"LoginProfileResponse").pyclass
response = self.binding.Receive(getResultSetXMLByIDResponse.typecode)
return response
# op: getResultSetXMLByTitle
def getResultSetXMLByTitle(self, request, **kw):
if isinstance(request, getResultSetXMLByTitleRequest) is False:
raise TypeError, "%s incorrect request type" % (request.__class__)
# no input wsaction
self.binding.Send(None, None, request, soapaction="", **kw)
# no output wsaction
response = self.binding.Receive(
getResultSetXMLByTitleResponse.typecode)
return response
findContourLevelByAccessionCodeRequest = GED(
"http://service.emsearch.rcsb", "findContourLevelByAccessionCode").pyclass
findContourLevelByAccessionCodeResponse = GED(
"http://service.emsearch.rcsb",
"findContourLevelByAccessionCodeResponse").pyclass
findFittedPDBidsByAccessionCodeRequest = GED(
"http://service.emsearch.rcsb", "findFittedPDBidsByAccessionCode").pyclass
findFittedPDBidsByAccessionCodeResponse = GED(
"http://service.emsearch.rcsb",
"findFittedPDBidsByAccessionCodeResponse").pyclass
getResultSetXMLByAuthorRequest = GED("http://service.emsearch.rcsb",
"getResultSetXMLByAuthor").pyclass
def __init__(self,
pname,
ofwhat=(),
attributes=None,
extend=False,
restrict=False,
**kw):
ns = wsu.TimestampType_Def.schema
TClist = [
GED(NS.WSU.UTILITY, "Created", lazy=False,
isref=True)(minOccurs=0,
maxOccurs=1,
nillable=False,
encoded=kw.get("encoded")),
GED(NS.WSU.UTILITY, "Expires", lazy=False,
isref=True)(minOccurs=0,
maxOccurs=1,
nillable=False,
encoded=kw.get("encoded")),
GED(NS.WSU.UTILITY, "Received", lazy=False,
isref=True)(minOccurs=0,
maxOccurs="unbounded",
nillable=False,
encoded=kw.get("encoded")),
ZSI.TC.AnyElement(aname="_any",
minOccurs=0,
maxOccurs="unbounded",
nillable=False,
processContents="lax")
]
self.attribute_typecode_dict = attributes or {}
if extend: TClist += ofwhat
if restrict: TClist = ofwhat
else:
# attribute handling code
self.attribute_typecode_dict[(NS.WSU.UTILITY,
"Id")] = ZSI.TC.AnyType()
self.attribute_typecode_dict[(
NS.SCHEMA.BASE, "anyAttribute")] = ZSI.TC.AnyElement()
self.attribute_typecode_dict[(NS.WSU.UTILITY,
"Id")] = ZSI.TC.AnyType()
self.attribute_typecode_dict[(
NS.SCHEMA.BASE, "anyAttribute")] = ZSI.TC.AnyElement()
self.attribute_typecode_dict[(NS.WSU.UTILITY,
"Id")] = ZSI.TC.AnyType()
self.attribute_typecode_dict[(
NS.SCHEMA.BASE, "anyAttribute")] = ZSI.TC.AnyElement()
ZSI.TCcompound.ComplexType.__init__(self,
None,
TClist,
pname=pname,
inorder=0,
**kw)
class Holder:
__metaclass__ = pyclass_type
typecode = self
def __init__(self):
# pyclass
self._Created = None
self._Expires = None
self._Received = None
self._any = []
return
Holder.__name__ = "TimestampType_Holder"
self.pyclass = Holder
self.binding.RPC(None, None, request, soapaction="http://www.msn.com/webservices/AddressBook/DeleteMember", soapheaders=soapheaders,
callback = callback,
**kw)
# op: CreateCircle
@callbacks.callsback
def CreateCircle(self, request, soapheaders=(), callback = None, **kw):
if isinstance(request, CreateCircleMessage) is False:
raise TypeError, "%s incorrect request type" % (request.__class__)
# no input wsaction
# TODO: Check soapheaders
self.binding.RPC(None, None, request, soapaction="http://www.msn.com/webservices/AddressBook/CreateCircle", soapheaders=soapheaders,
callback = callback,
**kw)
FindMembershipMessage = GED(MSNS.MSWS.ADDRESS, "FindMembership").pyclass
FindMembershipResponseMessage = GED(MSNS.MSWS.ADDRESS, "FindMembershipResponse").pyclass
AddMemberMessage = GED(MSNS.MSWS.ADDRESS, "AddMember").pyclass
AddMemberResponseMessage = GED(MSNS.MSWS.ADDRESS, "AddMemberResponse").pyclass
DeleteMemberMessage = GED(MSNS.MSWS.ADDRESS, "DeleteMember").pyclass
DeleteMemberResponseMessage = GED(MSNS.MSWS.ADDRESS, "DeleteMemberResponse").pyclass
CreateCircleMessage = GED(MSNS.MSWS.ADDRESS, "CreateCircle").pyclass
CreateCircleResponseMessage = GED(MSNS.MSWS.ADDRESS, "CreateCircleResponse").pyclass
# Locator
class ABServiceLocator:
ABFindAllPort_address = "https://contacts.msn.com/abservice/abservice.asmx"
def getABFindAllPortAddress(self):
return ABServiceLocator.ABFindAllPort_address
def getABFindAllPort(self, url=None, **kw):
return ABServiceBindingSOAP(url or ABServiceLocator.ABFindAllPort_address, **kw)
if isinstance(request, ServerContractorResponseSoapIn) is False:
raise TypeError, "%s incorrect request type" % (request.__class__)
# no input wsaction
self.binding.Send(
None,
None,
request,
soapaction="http://tempuri.org/ServerContractorResponse",
**kw)
# no output wsaction
response = self.binding.Receive(
ServerContractorResponseSoapOut.typecode)
return response
RemainRequestSoapIn = GED("http://tempuri.org/", "RemainRequest").pyclass
RemainRequestSoapOut = GED("http://tempuri.org/",
"RemainRequestResponse").pyclass
RemainResponseSoapIn = GED("http://tempuri.org/", "RemainResponse").pyclass
RemainResponseSoapOut = GED("http://tempuri.org/",
"RemainResponseResponse").pyclass
RemainDownloadSoapIn = GED("http://tempuri.org/", "RemainDownload").pyclass
RemainDownloadSoapOut = GED("http://tempuri.org/",
"RemainDownloadResponse").pyclass
ShipmentRequestSoapIn = GED("http://tempuri.org/", "ShipmentRequest").pyclass
def __init__(self,
pname,
ofwhat=(),
attributes=None,
extend=False,
restrict=False,
**kw):
ns = psf.ppHeaderType_Def.schema
TClist = [
GED(MSNS.PPCRL.FAULT, "serverVersion", lazy=False,
isref=True)(minOccurs=1,
maxOccurs=1,
nillable=False,
encoded=kw.get("encoded")),
GED(MSNS.PPCRL.FAULT, "PUID", lazy=False,
isref=True)(minOccurs=1,
maxOccurs=1,
nillable=False,
encoded=kw.get("encoded")),
GED(MSNS.PPCRL.FAULT, "configVersion", lazy=False,
isref=True)(minOccurs=1,
maxOccurs=1,
nillable=False,
encoded=kw.get("encoded")),
GED(MSNS.PPCRL.FAULT, "uiVersion", lazy=False,
isref=True)(minOccurs=1,
maxOccurs=1,
nillable=False,
encoded=kw.get("encoded")),
GED(MSNS.PPCRL.FAULT, "authstate", lazy=False,
isref=True)(minOccurs=1,
maxOccurs=1,
nillable=False,
encoded=kw.get("encoded")),
GED(MSNS.PPCRL.FAULT, "reqstatus", lazy=False,
isref=True)(minOccurs=1,
maxOccurs=1,
nillable=False,
encoded=kw.get("encoded")),
GED(MSNS.PPCRL.FAULT, "serverInfo", lazy=False,
isref=True)(minOccurs=1,
maxOccurs=1,
nillable=False,
encoded=kw.get("encoded")),
GED(MSNS.PPCRL.FAULT, "cookies", lazy=False,
isref=True)(minOccurs=1,
maxOccurs=1,
nillable=False,
encoded=kw.get("encoded")),
GED(MSNS.PPCRL.FAULT, "browserCookies", lazy=False,
isref=True)(minOccurs=0,
maxOccurs=1,
nillable=False,
encoded=kw.get("encoded")),
GED(MSNS.PPCRL.FAULT, "credProperties", lazy=False,
isref=True)(minOccurs=1,
maxOccurs=1,
nillable=False,
encoded=kw.get("encoded")),
GED(MSNS.PPCRL.FAULT, "extProperties", lazy=False,
isref=True)(minOccurs=1,
maxOccurs=1,
nillable=False,
encoded=kw.get("encoded")),
GED(MSNS.PPCRL.FAULT, "response", lazy=False,
isref=True)(minOccurs=1,
maxOccurs=1,
nillable=False,
encoded=kw.get("encoded"))
]
self.attribute_typecode_dict = attributes or {}
if extend: TClist += ofwhat
if restrict: TClist = ofwhat
ZSI.TCcompound.ComplexType.__init__(self,
None,
TClist,
pname=pname,
inorder=0,
**kw)
class Holder:
__metaclass__ = pyclass_type
typecode = self
def __init__(self):
# pyclass
self._serverVersion = None
self._PUID = None
self._configVersion = None
self._uiVersion = None
self._authstate = None
self._reqstatus = None
self._serverInfo = None
self._cookies = None
self._browserCookies = None
self._credProperties = None
self._extProperties = None
self._response = None
return
Holder.__name__ = "ppHeaderType_Holder"
self.pyclass = Holder
if isinstance(request, FEConsultaCAERequestSoapIn) is False:
raise TypeError, "%s incorrect request type" % (request.__class__)
# no input wsaction
self.binding.Send(
None,
None,
request,
soapaction=
"http://ar.gov.afip.dif.facturaelectronica/FEConsultaCAERequest",
**kw)
# no output wsaction
response = self.binding.Receive(FEConsultaCAERequestSoapOut.typecode)
return response
FERecuperaQTYRequestSoapIn = GED("http://ar.gov.afip.dif.facturaelectronica/",
"FERecuperaQTYRequest").pyclass
FERecuperaQTYRequestSoapOut = GED("http://ar.gov.afip.dif.facturaelectronica/",
"FERecuperaQTYRequestResponse").pyclass
FEDummySoapIn = GED("http://ar.gov.afip.dif.facturaelectronica/",
"FEDummy").pyclass
FEDummySoapOut = GED("http://ar.gov.afip.dif.facturaelectronica/",
"FEDummyResponse").pyclass
FERecuperaLastCMPRequestSoapIn = GED(
"http://ar.gov.afip.dif.facturaelectronica/",
"FERecuperaLastCMPRequest").pyclass
FERecuperaLastCMPRequestSoapOut = GED(
##################################################
# file: CompetitionService_server.py
#
# skeleton generated by "ZSI.generate.wsdl2dispatch.ServiceModuleWriter"
# /usr/bin/wsdl2py -bw http://redalert3pc.comp.pubsvs.gamespy.com/competitionservice/competitionservice.asmx?wsdl
#
##################################################
from ZSI.schema import GED, GTD
from ZSI.TCcompound import ComplexType, Struct
from CompetitionService_types import *
from ZSI.twisted.WSresource import WSResource
# Messages
CreateSessionSoapIn = GED("http://gamespy.net/competition/", "CreateSession").pyclass
CreateSessionSoapOut = GED("http://gamespy.net/competition/", "CreateSessionResponse").pyclass
CreateMatchlessSessionSoapIn = GED("http://gamespy.net/competition/", "CreateMatchlessSession").pyclass
CreateMatchlessSessionSoapOut = GED("http://gamespy.net/competition/", "CreateMatchlessSessionResponse").pyclass
SetReportIntentionSoapIn = GED("http://gamespy.net/competition/", "SetReportIntention").pyclass
SetReportIntentionSoapOut = GED("http://gamespy.net/competition/", "SetReportIntentionResponse").pyclass
SubmitReportSoapIn = GED("http://gamespy.net/competition/", "SubmitReport").pyclass
SubmitReportSoapOut = GED("http://gamespy.net/competition/", "SubmitReportResponse").pyclass
return TimeServerLocator.TimeServer_address
def getTimeServer(self, url=None, **kw):
return TimeServerSOAP(url or TimeServerLocator.TimeServer_address,
**kw)
# Methods
class TimeServerSOAP:
def __init__(self, url, **kw):
kw.setdefault("readerclass", None)
kw.setdefault("writerclass", None)
# no resource properties
self.binding = client.Binding(url=url, **kw)
# no ws-addressing
# op: Time
def Time(self, request, **kw):
if isinstance(request, TimeRequest) is False:
raise TypeError, "%s incorrect request type" % (request.__class__)
# no input wsaction
self.binding.Send(None, None, request, soapaction="Time", **kw)
# no output wsaction
response = self.binding.Receive(TimeResponse.typecode)
return response
TimeRequest = GED("urn:ZSI", "Time").pyclass
TimeResponse = GED("urn:ZSI", "Time").pyclass
##################################################
# file: IoPService_server.py
#
# skeleton generated by "ZSI.generate.wsdl2dispatch.ServiceModuleWriter"
# /usr/bin/wsdl2py -b http://localhost:8080/sis/IoPEndpoint?wsdl
#
##################################################
from ZSI.schema import GED, GTD
from ZSI.TCcompound import ComplexType, Struct
from IoPService_types import *
from ZSI.ServiceContainer import ServiceSOAPBinding
# Messages
SisIoPPort_activeInTorrents = GED("http://iop.ws.sis.smoothit.eu/",
"activeInTorrents").pyclass
SisIoPPort_activeInTorrentsResponse = GED("http://iop.ws.sis.smoothit.eu/",
"activeInTorrentsResponse").pyclass
SisIoPPort_getConfigParams = GED("http://iop.ws.sis.smoothit.eu/",
"getConfigParams").pyclass
SisIoPPort_getConfigParamsResponse = GED("http://iop.ws.sis.smoothit.eu/",
"getConfigParamsResponse").pyclass
SisIoPPort_getTorrentStats = GED("http://iop.ws.sis.smoothit.eu/",
"getTorrentStats").pyclass
SisIoPPort_getTorrentStatsResponse = GED("http://iop.ws.sis.smoothit.eu/",
"getTorrentStatsResponse").pyclass
##################################################
# file: AppService_server.py
#
# skeleton generated by "ZSI.generate.wsdl2dispatch.ServiceModuleWriter"
# /usr/local/bin/wsdl2py wsdl/opal.wsdl
#
##################################################
from ZSI.schema import GED, GTD
from ZSI.TCcompound import ComplexType, Struct
from AppService_types import *
from ZSI.ServiceContainer import ServiceSOAPBinding
# Messages
getAppMetadataRequest = GED("http://nbcr.sdsc.edu/opal/types",
"getAppMetadataInput").pyclass
getAppMetadataResponse = GED("http://nbcr.sdsc.edu/opal/types",
"getAppMetadataOutput").pyclass
getAppConfigRequest = GED("http://nbcr.sdsc.edu/opal/types",
"getAppConfigInput").pyclass
getAppConfigResponse = GED("http://nbcr.sdsc.edu/opal/types",
"getAppConfigOutput").pyclass
launchJobRequest = GED("http://nbcr.sdsc.edu/opal/types",
"launchJobInput").pyclass
launchJobResponse = GED("http://nbcr.sdsc.edu/opal/types",
"launchJobOutput").pyclass
def __init__(self,
pname,
ofwhat=(),
attributes=None,
extend=False,
restrict=False,
**kw):
ns = wsrm.SequenceType_Def.schema
TClist = [
GED(NS.WSU.UTILITY, "Identifier", lazy=False,
isref=True)(minOccurs=1,
maxOccurs=1,
nillable=False,
encoded=kw.get("encoded")),
ZSI.TCnumbers.IunsignedLong(pname=(ns, "MessageNumber"),
aname="_MessageNumber",
minOccurs=1,
maxOccurs=1,
nillable=False,
typed=False,
encoded=kw.get("encoded")),
ZSI.TC.AnyType(pname=(ns, "LastMessage"),
aname="_LastMessage",
minOccurs=0,
maxOccurs=1,
nillable=False,
typed=False,
encoded=kw.get("encoded")),
ZSI.TC.AnyElement(aname="_any",
minOccurs=0,
maxOccurs="unbounded",
nillable=False,
processContents="lax")
]
self.attribute_typecode_dict = attributes or {}
if extend: TClist += ofwhat
if restrict: TClist = ofwhat
else:
# attribute handling code
self.attribute_typecode_dict[(
NS.SCHEMA.BASE, "anyAttribute")] = ZSI.TC.AnyElement()
ZSI.TCcompound.ComplexType.__init__(self,
None,
TClist,
pname=pname,
inorder=0,
**kw)
class Holder:
__metaclass__ = pyclass_type
typecode = self
def __init__(self):
# pyclass
self._Identifier = None
self._MessageNumber = None
self._LastMessage = None
self._any = []
return
Holder.__name__ = "SequenceType_Holder"
self.pyclass = Holder
def setRequest(self, endPointReference, action):
'''Call For Request
'''
self._action = action
self.header_pyobjs = None
pyobjs = []
namespaceURI = self.wsAddressURI
addressTo = self._addressTo
messageID = self._messageID = "uuid:%s" % time.time()
# Set Message Information Headers
# MessageID
typecode = GED(namespaceURI, "MessageID")
pyobjs.append(typecode.pyclass(messageID))
# Action
typecode = GED(namespaceURI, "Action")
pyobjs.append(typecode.pyclass(action))
# To
typecode = GED(namespaceURI, "To")
pyobjs.append(typecode.pyclass(addressTo))
# From
typecode = GED(namespaceURI, "From")
mihFrom = typecode.pyclass()
mihFrom._Address = self.anonymousURI
pyobjs.append(mihFrom)
if endPointReference:
if hasattr(endPointReference, 'typecode') is False:
raise EvaluateException(
'endPointReference must have a typecode attribute')
if isinstance(endPointReference.typecode, \
GTD(namespaceURI ,'EndpointReferenceType')) is False:
raise EvaluateException(
'endPointReference must be of type %s' %
GTD(namespaceURI, 'EndpointReferenceType'))
ReferenceProperties = getattr(endPointReference,
'_ReferenceProperties', None)
if ReferenceProperties is None: # In recent WS-A attribute name changed
ReferenceProperties = getattr(endPointReference,
'_ReferenceParameters', None)
if ReferenceProperties is not None:
for v in getattr(ReferenceProperties, '_any', ()):
if not hasattr(v, 'typecode'):
raise EvaluateException(
'<any> element, instance missing typecode attribute'
)
pyobjs.append(v)
self.header_pyobjs = tuple(pyobjs)
##################################################
# file: EMSRNExchange_server.py
#
# skeleton generated by "ZSI.generate.wsdl2dispatch.ServiceModuleWriter"
# C:\pydev\Python25\wsdl2py.bat -b https://webservice.ktsz.spb.ru:4443/EMSRNExchange.asmx?WSDL
#
##################################################
from ZSI.schema import GED
from EMSRNExchange_types import *
from ZSI.ServiceContainer import ServiceSOAPBinding
# Messages
MessageList_XMLSoapIn = GED("http://webservice.ktsz.spb.ru/",
"MessageList_XML").pyclass
MessageList_XMLSoapOut = GED("http://webservice.ktsz.spb.ru/",
"MessageList_XMLResponse").pyclass
Message_XMLSoapIn = GED("http://webservice.ktsz.spb.ru/",
"Message_XML").pyclass
Message_XMLSoapOut = GED("http://webservice.ktsz.spb.ru/",
"Message_XMLResponse").pyclass
MessageObtained_XMLSoapIn = GED("http://webservice.ktsz.spb.ru/",
"MessageObtained_XML").pyclass
MessageObtained_XMLSoapOut = GED("http://webservice.ktsz.spb.ru/",
"MessageObtained_XMLResponse").pyclass
def test_local_bug_1525567(self):
element = GED(TargetNamespace, 'Items')
# Make sure this is a GED
self.failUnless(isinstance(element, ElementDeclaration),
'"%s" not a GED' % element)
##################################################
# file: VisualizerService_v3_0_0_server.py
#
# skeleton generated by "ZSI.generate.wsdl2dispatch.ServiceModuleWriter"
# /usr/local/bin/wsdl2py --complexType --lazy visualizerservice300.wsdl
#
##################################################
from ZSI.schema import GED, GTD
from ZSI.TCcompound import ComplexType, Struct
from VisualizerService_v3_0_0_types import *
from ZSI.ServiceContainer import ServiceSOAPBinding
# Messages
runVisualizationRequest = GED(
"http://service.apollo.pitt.edu/visualizerservice/v3_0_0/",
"runVisualization").pyclass
runVisualizationResponse = GED(
"http://service.apollo.pitt.edu/visualizerservice/v3_0_0/",
"runVisualizationResponse").pyclass
# Service Skeletons
class VisualizerService_v3_0_0(ServiceSOAPBinding):
soapAction = {}
root = {}
def __init__(self,
post='/visualizerservice202/services/visualizerservice',
**kw):
def call_closure(*args, **kwargs):
"""Call the named remote web service method."""
if len(args) and len(kwargs):
raise TypeError, 'Use positional or keyword argument only.'
if len(args) > 0:
raise TypeError, 'Not supporting SOAPENC:Arrays or XSD:List'
if len(kwargs):
args = kwargs
callinfo = getattr(self, name).callinfo
# go through the list of defined methods, and look for the one with
# the same number of arguments as what was passed. this is a weak
# check that should probably be improved in the future to check the
# types of the arguments to allow for polymorphism
for method in self._methods[name]:
if len(method.callinfo.inparams) == len(kwargs):
callinfo = method.callinfo
binding = _Binding(url=self._url or callinfo.location,
soapaction=callinfo.soapAction,
**self._kw)
kw = dict(unique=True)
if callinfo.use == 'encoded':
kw['unique'] = False
if callinfo.style == 'rpc':
request = TC.Struct(None, ofwhat=[],
pname=(callinfo.namespace, name), **kw)
response = TC.Struct(None, ofwhat=[],
pname=(callinfo.namespace, name+"Response"), **kw)
if len(callinfo.getInParameters()) != len(args):
raise RuntimeError('expecting "%s" parts, got %s' %(
str(callinfo.getInParameters(), str(args))))
for msg,pms in ((request,callinfo.getInParameters()),
(response,callinfo.getOutParameters())):
msg.ofwhat = []
for part in pms:
klass = GTD(*part.type)
if klass is None:
if part.type:
klass = filter(lambda gt: part.type==gt.type,TC.TYPES)
if len(klass) == 0:
klass = filter(lambda gt: part.type[1]==gt.type[1],TC.TYPES)
if not len(klass):klass = [TC.Any]
if len(klass) > 1: #Enumerations, XMLString, etc
klass = filter(lambda i: i.__dict__.has_key('type'), klass)
klass = klass[0]
else:
klass = TC.Any
msg.ofwhat.append(klass(part.name))
msg.ofwhat = tuple(msg.ofwhat)
if not args: args = {}
else:
# Grab <part element> attribute
ipart,opart = callinfo.getInParameters(),callinfo.getOutParameters()
if ( len(ipart) != 1 or not ipart[0].element_type or
ipart[0].type is None ):
raise RuntimeError, 'Bad Input Message "%s"' %callinfo.name
if ( len(opart) not in (0,1) or not opart[0].element_type or
opart[0].type is None ):
raise RuntimeError, 'Bad Output Message "%s"' %callinfo.name
# if ( len(args) > 1 ):
# raise RuntimeError, 'Message has only one part: %s' %str(args)
ipart = ipart[0]
request,response = GED(*ipart.type),None
if opart: response = GED(*opart[0].type)
msg = args
if self._asdict:
if not msg: msg = dict()
self._nullpyclass(request)
elif request.pyclass is not None:
if type(args) is dict:
msg = request.pyclass()
msg.__dict__.update(args)
elif type(args) is list and len(args) == 1:
msg = request.pyclass(args[0])
else:
msg = request.pyclass()
binding.Send(None, None, msg,
requesttypecode=request,
soapheaders=soapheaders,
encodingStyle=callinfo.encodingStyle)
if response is None:
return None
if self._asdict: self._nullpyclass(response)
return binding.Receive(replytype=response,
encodingStyle=callinfo.encodingStyle)
##################################################
# file: FileService_server.py
#
# skeleton generated by "ZSI.generate.wsdl2dispatch.ServiceModuleWriter"
# C:\pydev\Python25\wsdl2py.bat -s http://portal:8000/StattalonFileService.svc?wsdl
#
##################################################
from ZSI.schema import GED
from ZSI.ServiceContainer import ServiceSOAPBinding
# Messages
IFileService_ServiceReady_InputMessage = GED("http://tempuri.org/", "ServiceReady").pyclass
IFileService_ServiceReady_OutputMessage = GED("http://tempuri.org/", "ServiceReadyResponse").pyclass
IFileService_Testing_InputMessage = GED("http://tempuri.org/", "Testing").pyclass
IFileService_Testing_OutputMessage = GED("http://tempuri.org/", "TestingResponse").pyclass
UploadFileData = GED("http://tempuri.org/", "UploadFileData").pyclass
# Service Skeletons
class FileService(ServiceSOAPBinding):
soapAction = {}
root = {}
def __init__(self, post='/StattalonFileService.svc', **kw):
ServiceSOAPBinding.__init__(self, post)
