def test_can_include_imported_schemas_during_validation(self):
# In case the SOAPDispatcher would not use imported schemas for
# validation it would fail because the 'code' tag is only defined in
# the imported schema
handler, handler_state = echo_handler()
service = echo_service(handler)
class CodeType(xsd.String):
pattern = r'[0-9]{5}'
class Container(xsd.ComplexType):
value = xsd.Element(CodeType)
code_schema = xsd.Schema(
'http://soap.example/included',
location='http://soap.example/included',
elementFormDefault=xsd.ElementFormDefault.UNQUALIFIED,
simpleTypes=[CodeType],
complexTypes=[Container],
elements={'foo': xsd.Element(Container)},
)
service.methods[0].input = 'foo'
service.schemas[0].imports = [code_schema]
# The setup is a bit simplistic because the <code> tag is not parsed
# into a soapfish model element for the handler but this was enough
# to trigger the bug
dispatcher = SOAPDispatcher(service)
wsgi_environ = dict(SOAPACTION='echo', REQUEST_METHOD='POST')
soap_message = '<ns0:foo xmlns:ns0="http://soap.example/included"><value>12345</value></ns0:foo>'
request = SOAPRequest(wsgi_environ,
self._wrap_with_soap_envelope(soap_message))
response = dispatcher.dispatch(request)
self.assert_is_successful_response(response, handler_state)
assert_equals('12345', handler_state.input_.value)
def test_can_generate_schema_xml_containing_types_with_pattern_restriction(
self):
ns = 'http://soap.example/pattern.xsd'
class Container(xsd.ComplexType):
code = xsd.Element(xsd.String(pattern='[0-9]{0,5}'))
schema = xsd.Schema(
ns,
location=ns,
elementFormDefault=xsd.ElementFormDefault.QUALIFIED,
complexTypes=(Container, ),
elements={
'foo': xsd.Element(Container),
},
)
# previously this would fail
xsd_element = generate_xsd(schema)
xmlschema = etree.XMLSchema(xsd_element)
valid_xml = '<foo xmlns="%s"><code>1234</code></foo>' % ns
def is_valid(s):
return xmlschema.validate(etree.fromstring(s))
self.assertIs(is_valid(valid_xml), True)
bad_xml = '<foo xmlns="%s"><code>abc</code></foo>' % ns
self.assertIs(is_valid(bad_xml), False)
def test_can_lookup_element_by_name(self):
class CodeType(xsd.String):
pattern = r'[0-9]{5}'
ns = 'http://soap.example/schema.xsd'
schema = xsd.Schema(
ns,
location=ns,
elementFormDefault=xsd.ElementFormDefault.QUALIFIED,
simpleTypes=[CodeType],
elements={'code': xsd.Element(CodeType)},
)
schema_element = schema.get_element_by_name('code')
self.assertEqual(CodeType, schema_element._passed_type)
self.assertIsNone(schema.get_element_by_name('invalid'))
def test_parsexml_with_soapfish_schema(self):
# sometimes it comes handy that soapfish can validate some XML against a
# provided soapfish schema (instead of an etree.XMLSchema) especially in
# testing.
class A(xsd.ComplexType):
name = xsd.Element(xsd.String, nillable=True)
ns = 'http://foo.example'
soapfish_schema = xsd.Schema(ns,
imports=[],
elementFormDefault=xsd.ElementFormDefault.UNQUALIFIED,
simpleTypes=[],
attributeGroups=[],
groups=[],
complexTypes=[A],
elements={'foo': xsd.Element(A)},
)
xml = '<test:foo xmlns:test="%s"><name>bar</name></test:foo>' % ns
foo = A.parsexml(xml, schema=soapfish_schema)
assert_equals('bar', foo.name)
INDICATOR = xsd.Sequence
ElServicioEstaDisponibleResult = xsd.Element(xsd.Boolean, minOccurs=1)
@classmethod
def create(cls, ElServicioEstaDisponibleResult):
instance = cls()
instance.ElServicioEstaDisponibleResult = ElServicioEstaDisponibleResult
return instance
Schema_c49e7 = xsd.Schema(
imports=[],
includes=[],
targetNamespace=settings.FVA_HOST,
elementFormDefault='qualified',
simpleTypes=[AlgoritmoDeHash],
attributeGroups=[],
groups=[],
complexTypes=[SolicitudDeFirma, RespuestaDeLaSolicitud, SolicitudDeFirmaPdf],
elements={'RecibaLaSolicitudDeSelladoElectronicoXmlEnvelopedCoFirma': xsd.Element(RecibaLaSolicitudDeSelladoElectronicoXmlEnvelopedCoFirma()), 'RecibaLaSolicitudDeSelladoElectronicoXmlEnvelopedCoFirmaResponse': xsd.Element(RecibaLaSolicitudDeSelladoElectronicoXmlEnvelopedCoFirmaResponse()), 'RecibaLaSolicitudDeSelladoElectronicoXmlEnvelopedContraFirma': xsd.Element(RecibaLaSolicitudDeSelladoElectronicoXmlEnvelopedContraFirma()), 'RecibaLaSolicitudDeSelladoElectronicoXmlEnvelopedContraFirmaResponse': xsd.Element(RecibaLaSolicitudDeSelladoElectronicoXmlEnvelopedContraFirmaResponse()), 'RecibaLaSolicitudDeSelladoElectronicoMSOffice': xsd.Element(RecibaLaSolicitudDeSelladoElectronicoMSOffice()), 'RecibaLaSolicitudDeSelladoElectronicoMSOfficeResponse': xsd.Element(RecibaLaSolicitudDeSelladoElectronicoMSOfficeResponse()), 'RecibaLaSolicitudDeSelladoElectronicoPdf': xsd.Element(RecibaLaSolicitudDeSelladoElectronicoPdf()), 'RecibaLaSolicitudDeSelladoElectronicoPdfResponse': xsd.Element(RecibaLaSolicitudDeSelladoElectronicoPdfResponse()), 'RecibaLaSolicitudDeSelladoElectronicoOdf': xsd.Element(RecibaLaSolicitudDeSelladoElectronicoOdf()), 'RecibaLaSolicitudDeSelladoElectronicoOdfResponse': xsd.Element(RecibaLaSolicitudDeSelladoElectronicoOdfResponse()), 'ElServicioEstaDisponible': xsd.Element(ElServicioEstaDisponible()), 'ElServicioEstaDisponibleResponse': xsd.Element(ElServicioEstaDisponibleResponse())},
)
##############################################################################
# Methods
RecibaLaSolicitudDeSelladoElectronicoXmlEnvelopedCoFirma_method = xsd.Method(
soapAction=settings.FVA_HOST + 'RecibaLaSolicitudDeSelladoElectronicoXmlEnvelopedCoFirma',
input='RecibaLaSolicitudDeSelladoElectronicoXmlEnvelopedCoFirma',
inputPartName='parameters',
instance.AppliedDocument = AppliedDocument
return instance
def __str__(self):
return 'Номер: %s\nДата регистрации: %s\nУслуга: %s\n' \
'Контрольный срок: %s\nЗаявители: %s\nДокументы: %s' % \
(self.declar_number, self.register_date.strftime('%d.%m.%Y'),
self.service, self.end_date.strftime('%d.%m.%Y'),
(', '.join([l.full_name for l in self.legal_entity]) + '; '
if len(self.legal_entity) else '') +
', '.join(['%s %s %s' % (p.surname, p.first_name, p.patronymic)
for p in self.person if p.surname]),
', '.join(['%s № %s от %s' %
(d.title, d.number, d.date.strftime('%d.%m.%Y'))
for d in self.AppliedDocument]))
Schema_ef09a = xsd.Schema(
imports=[],
includes=[],
targetNamespace='urn://augo/smev/uslugi/1.0.0',
elementFormDefault='qualified',
simpleTypes=[AgentType, Sex, S6, S10, S50, S120, S1024],
attributeGroups=[],
groups=[],
complexTypes=[
Address, AppliedDocument, LegalEntity, Individual, RequestResponse
],
elements={'declar': xsd.Element(Declar())},
)
class GetWeatherByPlaceName(xsd.ComplexType):
Place = xsd.Element(Place)
class AppHeader(xsd.ComplexType):
Version = xsd.Element(xsd.String)
Message = xsd.Element(GetWeatherByPlaceName)
Schema_qualified = xsd.Schema(
targetNamespace='http://www.example.org',
elementFormDefault=xsd.ElementFormDefault.QUALIFIED,
complexTypes=[GetWeatherByPlaceName, AppHeader, Place],
elements={
'GetWeatherByPlaceName': xsd.Element(GetWeatherByPlaceName),
'AppHeader': xsd.Element(AppHeader),
'Identity': xsd.Element(xsd.String),
},
)
XMLSchema_qualified = etree.XMLSchema(generate_xsd(Schema_qualified))
class WsaAppHeader(wsa.Header):
SCHEMA = Schema_qualified
Identity = SCHEMA.get_element_by_name('Identity')
class PlaceU(xsd.ComplexType):
Name = xsd.Element(xsd.String)
xsd.String(enumeration=['INSERTED', 'UPDATED', 'EXISTS']))
id = xsd.Element(xsd.Long)
@classmethod
def create(cls, action, id):
instance = cls()
instance.action = action
instance.id = id
return instance
Schema = xsd.Schema(targetNamespace='http://flightdataservices.com/ops.xsd',
elementFormDefault='unqualified',
simpleTypes=[Pilot],
attributeGroups=[],
groups=[],
complexTypes=[Airport, Weight, Ops, Status],
elements={
'ops': xsd.Element('Ops'),
'status': xsd.Element('Status')
})
PutOps_method = xsd.Method(
soapAction='http://polaris.flightdataservices.com/ws/ops/PutOps',
input='ops', # Pointer to Schema.elements
inputPartName='body',
output='status', # Pointer to Schema.elements
outputPartName='body',
operationName='PutOps')
PutOpsPort_SERVICE = soap.Service(
name='PutOpsPort',
tagname='userProperty',
maxOccurs=xsd.UNBOUNDED)
@classmethod
def create(cls, userProperty):
instance = cls()
instance.userProperty = userProperty
return instance
Schema_e8a30 = xsd.Schema(
imports=[],
includes=[],
targetNamespace='http://pda.cineca.it/unical/anagrafe',
elementFormDefault='qualified',
simpleTypes=[],
attributeGroups=[],
groups=[],
complexTypes=[UserPropertyType],
elements={'userProperties': xsd.Element(UserProperties())},
)
# it.cineca.pda.ws.anagrafe
Schema_d14fd = xsd.Schema(
imports=[],
includes=[],
targetNamespace='it.cineca.pda.ws.anagrafe',
elementFormDefault='qualified',
simpleTypes=[],
attributeGroups=[],
xsd.String(enumeration=["INSERTED", "UPDATED", "EXISTS"]))
id = xsd.Element(xsd.Long)
@classmethod
def create(cls, action, id):
instance = cls()
instance.action = action
instance.id = id
return instance
Schema = xsd.Schema(targetNamespace="http://flightdataservices.com/ops.xsd",
elementFormDefault="unqualified",
simpleTypes=[Pilot],
attributeGroups=[],
groups=[],
complexTypes=[Airport, Weight, Ops, Status],
elements={
"ops": xsd.Element("Ops"),
"status": xsd.Element("Status")
})
PutOps_method = xsd.Method(
soapAction="http://polaris.flightdataservices.com/ws/ops/PutOps",
input="ops", # Pointer to Schema.elements
inputPartName="body",
output="status", # Pointer to Schema.elements
outputPartName="body",
operationName="PutOps")
PutOpsPort_SERVICE = soap.Service(
name="PutOpsPort",
INDICATOR = xsd.Sequence
returnMessage = xsd.Element(xsd.String, minOccurs=0)
@classmethod
def create(cls):
instance = cls()
return instance
Schema_ab251 = xsd.Schema(
imports=[],
includes=[],
targetNamespace='http://example.com/HelloWorld',
elementFormDefault='qualified',
simpleTypes=[],
attributeGroups=[],
groups=[],
complexTypes=[],
elements={
'RequestInterface': xsd.Element(RequestInterface()),
'ResponseInterface': xsd.Element(ResponseInterface())
},
)
##############################################################################
# Operations
def requestMessage(request, RequestInterface):
# FIXME 自分のものに差し替え
# TODO: Put your implementation here.
tagname="price",
minOccurs=0,
maxOccurs=xsd.UNBOUNDED,
nillable=True)
class Users(xsd.ComplexType):
INHERITANCE = None
user = xsd.ListElement(User, tagname="users", minOccurs=0)
Schema = xsd.Schema(
# Should be unique URL, can be any string.
targetNamespace="http://next.me/user.xsd",
# Register all complex types to schema.
complexTypes=[Users, User, GetUser],
elements={
"getUser": xsd.Element(GetUser),
"users": xsd.Element(Users),
"user": xsd.Element(User)
})
def get_user(request, user=None):
fid = user.id
users = Users()
for i in range(0, 10):
uu = User(name="Sandro - {}".format(i),
city="São Paulo",
email="*****@*****.**",
mobile="11991504030",
address="Rua xpto",
ValideElServicioResult = xsd.Element(xsd.Boolean, minOccurs=1)
@classmethod
def create(cls, ValideElServicioResult):
instance = cls()
instance.ValideElServicioResult = ValideElServicioResult
return instance
Schema_c49e7 = xsd.Schema(
imports=[],
includes=[],
targetNamespace=settings.FVA_HOST,
elementFormDefault='qualified',
simpleTypes=[],
attributeGroups=[],
groups=[],
complexTypes=[SolicitudDeAutenticacion,
ExtensionDataObject, RespuestaDeLaSolicitud, InformacionSuscriptorDesconectado],
elements={'RecibaLaSolicitudDeAutenticacion': xsd.Element(RecibaLaSolicitudDeAutenticacion()), 'RecibaLaSolicitudDeAutenticacionResponse': xsd.Element(
RecibaLaSolicitudDeAutenticacionResponse()), 'ValideElServicio': xsd.Element(ValideElServicio()), 'ValideElServicioResponse': xsd.Element(ValideElServicioResponse())},
)
##############################################################################
# Methods
RecibaLaSolicitudDeAutenticacion_method = xsd.Method(
soapAction=settings.FVA_HOST + 'RecibaLaSolicitudDeAutenticacion',
input='RecibaLaSolicitudDeAutenticacion',
from django.conf import settings
from soapfish import xsd
class UserNotFoundException(xsd.ComplexType):
# name = xsd.Element(xsd.String, minOccurs=1, nillable=True)
# type = xsd.Element(xsd.Integer, minOccurs=1, nillable=True)
pass
Schema_UserNotFoundException = xsd.Schema(
targetNamespace='{}/soap/User.xsd'.format(settings.FQDN),
elementFormDefault='qualified',
simpleTypes=[],
attributeGroups=[],
groups=[],
complexTypes=[
UserNotFoundException,
],
elements={'UserNotFoundException': xsd.Element(UserNotFoundException)},
)
class SystemException(xsd.ComplexType):
# name = xsd.Element(xsd.String, minOccurs=1, nillable=True)
# type = xsd.Element(xsd.Integer, minOccurs=1, nillable=True)
pass
Schema_SystemException = xsd.Schema(
imports=[],
style='document',
)
Schema_5dace = xsd.Schema(
# imports=[Schema_e65b4],
includes=[],
targetNamespace=
'urn://x-artefacts-smev-gov-ru/services/message-exchange/types/basic/1.2',
elementFormDefault='qualified',
simpleTypes=[InteractionStatusType],
attributeGroups=[],
groups=[],
complexTypes=[
XMLDSigSignatureType, AttachmentContentType, Void,
AttachmentHeaderType, RefAttachmentHeaderType, FSAuthInfo, SmevFault
],
elements={
'AckTargetMessage': xsd.Element(AckTargetMessage()),
'AttachmentContentList': xsd.Element(AttachmentContentList()),
'AttachmentHeaderList': xsd.Element(AttachmentHeaderList()),
'FSAttachmentsList': xsd.Element(FSAttachmentsList()),
'MessagePrimaryContent': xsd.Element(MessagePrimaryContent()),
'MessageReference': xsd.Element(MessageReference()),
'MessageTypeSelector': xsd.Element(MessageTypeSelector()),
'RefAttachmentHeaderList': xsd.Element(RefAttachmentHeaderList()),
'Timestamp': xsd.Element(Timestamp())
},
)
Schema_a6a2c = xsd.Schema(
imports=[Schema_5dace],
instance = cls()
instance.ValideElServicioResult = ValideElServicioResult
return instance
Schema_c49e7 = xsd.Schema(
imports=[],
includes=[],
targetNamespace=settings.FVA_HOST,
elementFormDefault='qualified',
simpleTypes=[],
attributeGroups=[],
groups=[],
complexTypes=[ResultadoDeLaSolicitud, InformacionDelCertificado],
elements={
'SoliciteLaValidacionDelCertificadoDeAutenticacion':
xsd.Element(SoliciteLaValidacionDelCertificadoDeAutenticacion()),
'SoliciteLaValidacionDelCertificadoDeAutenticacionResponse':
xsd.Element(
SoliciteLaValidacionDelCertificadoDeAutenticacionResponse()),
'ValideElServicio':
xsd.Element(ValideElServicio()),
'ValideElServicioResponse':
xsd.Element(ValideElServicioResponse())
},
)
##############################################################################
# Methods
SoliciteLaValidacionDelCertificadoDeAutenticacion_method = xsd.Method(
Schema_c49e7 = xsd.Schema(
imports=[],
includes=[],
targetNamespace=settings.FVA_HOST,
elementFormDefault='qualified',
simpleTypes=[],
attributeGroups=[],
groups=[],
complexTypes=[
ResultadoValidacionCoFirma, ArrayOfErrorDeDocumentoCoFirma,
ErrorDeDocumentoCoFirma, ArrayOfString, ArrayOfFirmante, Firmante,
ResultadoValidacionContraFirma, ArrayOfErrorDeDocumentoContraFirma,
ErrorDeDocumentoContraFirma, ResultadoValidacionMsOffice,
ArrayOfErrorDeDocumentoMsOffice, ErrorDeDocumentoMsOffice,
ResultadoValidacionOdf, ArrayOfErrorDeDocumentoOdf,
ErrorDeDocumentoOdf, ResultadoValidacionPdf,
ArrayOfErrorDeDocumentoPdf, ErrorDeDocumentoPdf
],
elements={
'ValideElDocumentoXmlEnvelopedCoFirma':
xsd.Element(ValideElDocumentoXmlEnvelopedCoFirma()),
'ValideElDocumentoXmlEnvelopedCoFirmaResponse':
xsd.Element(ValideElDocumentoXmlEnvelopedCoFirmaResponse()),
'ValideElDocumentoXmlEnvelopedContraFirma':
xsd.Element(ValideElDocumentoXmlEnvelopedContraFirma()),
'ValideElDocumentoXmlEnvelopedContraFirmaResponse':
xsd.Element(ValideElDocumentoXmlEnvelopedContraFirmaResponse()),
'ValideElDocumentoMSOffice':
xsd.Element(ValideElDocumentoMSOffice()),
'ValideElDocumentoMSOfficeResponse':
xsd.Element(ValideElDocumentoMSOfficeResponse()),
'ValideElDocumentoOdf':
xsd.Element(ValideElDocumentoOdf()),
'ValideElDocumentoOdfResponse':
xsd.Element(ValideElDocumentoOdfResponse()),
'ValideElDocumentoPdf':
xsd.Element(ValideElDocumentoPdf()),
'ValideElDocumentoPdfResponse':
xsd.Element(ValideElDocumentoPdfResponse()),
'ValideElServicio':
xsd.Element(ValideElServicio()),
'ValideElServicioResponse':
xsd.Element(ValideElServicioResponse())
},
)
@classmethod
def create(cls, ValideElServicioResult):
instance = cls()
instance.ValideElServicioResult = ValideElServicioResult
return instance
Schema_c49e7 = xsd.Schema(
imports=[],
includes=[],
targetNamespace=settings.RECEPTOR_HOST,
elementFormDefault='qualified',
simpleTypes=[],
attributeGroups=[],
groups=[],
complexTypes=[ResultadoDeFirma],
elements={
'NotifiqueLaRespuesta': xsd.Element(NotifiqueLaRespuesta()),
'NotifiqueLaRespuestaResponse':
xsd.Element(NotifiqueLaRespuestaResponse()),
'ValideElServicio': xsd.Element(ValideElServicio()),
'ValideElServicioResponse': xsd.Element(ValideElServicioResponse())
},
)
##############################################################################
# Operations
def NotifiqueLaRespuesta(request, NotifiqueLaRespuesta):
result = NotifiqueLaRespuesta.elResultado
@classmethod
def create(cls):
instance = cls()
return instance
Schema_09e57 = xsd.Schema(
imports=[],
includes=[],
targetNamespace=
'urn://x-artefacts-smev-gov-ru/services/service-adapter/types/faults',
location='${scheme}://${host}/smev-service-adapter-faults.xsd',
elementFormDefault='qualified',
simpleTypes=[String_50],
attributeGroups=[],
groups=[],
complexTypes=[Fault],
elements={
'SystemFault': xsd.Element(Fault),
'ValidationFault': xsd.Element(Fault),
'SyncFault': xsd.Element(Fault)
},
)
# XXX: Workaround for naming issues related to relative locations!
Schema_33af9 = Schema_09e57
# urn://x-artefacts-smev-gov-ru/services/service-adapter/types
V2 = xsd.Element(xsd.Integer, minOccurs=0)
Vref = xsd.Element(xsd.Integer, minOccurs=0)
Vapp = xsd.Element(xsd.Integer, minOccurs=0)
class Status(xsd.ComplexType):
INHERITANCE = None
INDICATOR = xsd.Sequence
action = xsd.Element(xsd.String(enumeration=["INSERTED", "UPDATED", "EXISTS"]))
id = xsd.Element(xsd.Long)
Schema = xsd.Schema(
targetNamespace="http://flightdataservices.com/ops.xsd",
simpleTypes=[Pilot],
attributeGroups=[],
groups=[],
complexTypes=[Airport, Weight, Ops, Status],
elements={"ops": xsd.Element(Ops), "status": xsd.Element(Status)})
XML_REQUIRED_ONLY = """
<ops:ops xmlns:ops="http://flightdataservices.com/ops.xsd">
<aircraft>N608WB</aircraft>
<flight_number>123123</flight_number>
<type>COMMERCIAL</type>
<takeoff_airport>
<code_type>ICAO</code_type>
<code>EGLL</code>
</takeoff_airport>
def create(cls, ValideElServicioResult):
instance = cls()
instance.ValideElServicioResult = ValideElServicioResult
return instance
Schema_c49e7 = xsd.Schema(
imports=[],
includes=[],
targetNamespace=settings.FVA_HOST,
elementFormDefault='qualified',
simpleTypes=[],
attributeGroups=[],
groups=[],
complexTypes=[RespuestaDeLaSolicitud],
elements={
'ExisteUnaSolicitudDeFirmaCompleta':
xsd.Element(ExisteUnaSolicitudDeFirmaCompleta()),
'ExisteUnaSolicitudDeFirmaCompletaResponse':
xsd.Element(ExisteUnaSolicitudDeFirmaCompletaResponse()),
'ValideElServicio':
xsd.Element(ValideElServicio()),
'ValideElServicioResponse':
xsd.Element(ValideElServicioResponse())
},
)
##############################################################################
# Methods
ExisteUnaSolicitudDeFirmaCompleta_method = xsd.Method(
soapAction=settings.FVA_HOST + 'ExisteUnaSolicitudDeFirmaCompleta',
class StockPrice(xsd.ComplexType):
nillable = xsd.Element(xsd.Int, nillable=True)
prices = xsd.ListElement(xsd.Decimal(fractionDigits=2),
tagname="price",
minOccurs=0,
maxOccurs=xsd.UNBOUNDED,
nillable=True)
Schema = xsd.Schema(
# Should be unique URL, can be any string.
targetNamespace="http://code.google.com/p/soapfish/stock.xsd",
# Register all complex types to schema.
complexTypes=[GetStockPrice, StockPrice],
elements={
"getStockPrice": xsd.Element(GetStockPrice),
"stockPrice": xsd.Element(StockPrice)
})
def get_stock_price(request, gsp):
print(gsp.company, gsp.datetime)
sp = StockPrice(nillable=xsd.NIL)
sp.prices.append(13.29)
sp.prices.append(4.56)
sp.prices.append(xsd.NIL)
return sp
def __repr__(self):
return '{} [{}]'.format(self.Username,
self.CodiceFiscale)
class GetUser(xsd.ComplexType):
CodiceFiscale = xsd.Element(xsd.String, minOccurs=1, nillable=True)
Username = xsd.Element(xsd.String, minOccurs=1, nillable=True)
Schema_User = xsd.Schema(
targetNamespace='{}/soap/User.xsd'.format(settings.FQDN),
elementFormDefault='unqualified',
simpleTypes=[],
attributeGroups=[],
groups=[],
complexTypes=[User, GetUser, UserNotFoundException],
elements = {
'getUser': xsd.Element(GetUser),
'User': xsd.Element(User)},
)
def get_user_details(request, user_id):
"""
Fill the method you need to get the users values
and return a User ComplexType
"""
try:
func = import_string(getattr(settings, 'SOAP_UNIREG_IDENTITY_HANDLER'))
res = func(user_id)
