def _get_send_status(self, track_id, signature_d, token):
url = server_url[
self.company_id.dte_service_provider] + 'QueryEstUp.jws?WSDL'
ns = 'urn:' + server_url[
self.company_id.dte_service_provider] + 'QueryEstUp.jws'
_server = Client(url, ns)
rut = self.format_rut(self.company_id.main_id_number)
respuesta = _server.getEstUp(rut[:8], str(rut[-1]), track_id, token)
self.sii_message = respuesta
resp = xmltodict.parse(respuesta)
status = False
if resp['SII:RESPUESTA']['SII:RESP_HDR']['ESTADO'] == "-11":
status = {
'warning': {
'title':
_('Error -11'),
'message':
_("Error -11: Espere a que sea aceptado por el SII, intente en 5s más"
)
}
}
if resp['SII:RESPUESTA']['SII:RESP_HDR']['ESTADO'] == "EPR":
self.state = "Proceso"
if resp['SII:RESPUESTA']['SII:RESP_BODY']['RECHAZADOS'] == "1":
self.sii_result = "Rechazado"
elif resp['SII:RESPUESTA']['SII:RESP_HDR']['ESTADO'] == "RCT":
self.state = "Rechazado"
status = {
'warning': {
'title': _('Error RCT'),
'message': _(resp['SII:RESPUESTA']['GLOSA'])
}
}
return status
class OnVif:
"""In subclasses, re-define class variables
"""
namespace = None # this is also your link to specifications
wsdl_file = None # local file
sub_xaddr = None # http://ipaddr:port/onvif/sub_xaddr
port = None # as defined in the wsdl file
def __init__(self,
ip=None,
port=80,
user="******",
password="******",
use_async=False,
sub_xaddr_=None):
assert (isinstance(port, int))
if sub_xaddr_ is not None: # overwrite xaddr
self.xaddr = "http://%s:%i/onvif/%s" % (ip, port, sub_xaddr_)
else:
self.xaddr = "http://%s:%i/onvif/%s" % (ip, port, self.sub_xaddr)
self.user = user
self.password = password
self.use_async = use_async
self.service_addr = "{%s}%s" % (self.namespace, self.port)
if self.use_async:
self.async_transport = AsyncTransport(asyncio.get_event_loop(),
cache=None)
self.zeep_client = Client(wsdl=self.wsdl_file,
wsse=UsernameToken(self.user,
self.password,
use_digest=True),
settings=settings,
transport=self.async_transport)
else:
self.zeep_client = Client(wsdl=self.wsdl_file,
wsse=UsernameToken(self.user,
self.password,
use_digest=True),
settings=settings)
self.ws_client = self.zeep_client.create_service(
self.service_addr, self.xaddr)
self.factory = self.zeep_client.type_factory(
"http://www.onvif.org/ver10/schema")
async def close(self):
await self.async_transport.session.close()
def openSpecs(self):
os.system("firefox %s" % (self.namespace))
def getVariable(self, name):
return self.factory.CapabilityCategory(name)
def __init__(self, ecc_url):
"""A wrapper around the Zeep library's SOAP client.
This exists to help prevent future problems if the Client class from zeep changes. That
library is under heavy development, so it might break things in the future.
The methods of this class are implemented by overriding `__getattr__` to pass along calls to
the `self.service` attribute. The available methods are those defined by the SOAP protocol,
and they are listed below.
Methods
-------
GetConfigIDs()
Get a list of the config files known to the ECC server.
GetState()
Fetch the current state of the ECC state machine.
Describe(config_xml, datasource_xml)
Perform the Describe transition.
Prepare(config_xml, datasource_xml)
Perform the Prepare transition.
Configure(config_xml, datasource_xml)
Perform the Configure transition.
Start()
Start acquisition.
Stop()
Stop acquisition.
Breakup()
Performs the inverse of Configure.
Undo()
Performs the inverse of Prepare or Describe.
Parameters
----------
ecc_url : str
The full URL of the ECC server (i.e. "http://{address}:{port}").
"""
wsdl_url = os.path.join(settings.BASE_DIR, 'attpcdaq', 'daq',
'ecc.wsdl')
client = SoapClient(
wsdl_url) # Loads the service definition from ecc.wsdl
self.service = client.create_service(
'{urn:ecc}ecc',
ecc_url) # This overrides the default URL from the file
# This is a list of valid operations which is used in __getattr__ below.
self.operations = [
'GetState', 'Describe', 'Prepare', 'Configure', 'Start', 'Stop',
'Undo', 'Breakup', 'GetConfigIDs'
]
def fetch_version_info(update_all=False):
pre_fetch_version.send(object.__class__)
client = Client(url=wsdl_source)
result = client.service.GetAllDownloadFileInfo()
for item in result.DownloadFileInfo:
ver, created = Version.objects.get_or_create(
ver=item['VersionId'],
dumpdate=datetime.datetime.strptime(item['TextVersion'][-10:], "%d.%m.%Y").date(),
)
if created or update_all:
setattr(ver, 'complete_xml_url', item['FiasCompleteXmlUrl'])
setattr(ver, 'complete_dbf_url', item['FiasCompleteDbfUrl'])
if hasattr(item, 'FiasDeltaXmlUrl'):
setattr(ver, 'delta_xml_url', item['FiasDeltaXmlUrl'])
else:
setattr(ver, 'delta_xml_url', None)
if hasattr(item, 'FiasDeltaDbfUrl'):
setattr(ver, 'delta_dbf_url', item['FiasDeltaDbfUrl'])
else:
setattr(ver, 'delta_dbf_url', None)
ver.save()
post_fetch_version.send(object.__class__)
def _get_dte_status(self):
for r in self:
if not r.sii_xml_request or r.sii_xml_request.state not in ['Aceptado', 'Reparo']:
continue
partner_id = r.partner_id or r.company_id.partner_id
token = r.sii_xml_request.get_token(self.env.user, r.company_id)
signature_d = self.env.user.get_digital_signature(r.company_id)
url = server_url[r.company_id.dte_service_provider] + 'QueryEstDte.jws?WSDL'
_server = Client(url)
receptor = r.format_rut(partner_id.commercial_partner_id.main_id_number)
scheduled_date = datetime.strptime(r.scheduled_date[:10], "%Y-%m-%d").strftime("%d-%m-%Y")
total = str(int(round(r.amount_total,0)))
sii_code = str(r.location_id.document_type_id.code)
response = None
retry = 0
while response is None and retry < 1000:
try:
response = _server.service.getEstDte(signature_d['subject_serial_number'][:8],
str(signature_d['subject_serial_number'][-1]),
r.company_id.vat[2:-1],
r.company_id.vat[-1],
receptor[:8],
receptor[-1],
sii_code,
str(r.sii_document_number),
scheduled_date,
total,token)
r.sii_message = response
except Exception:
continue
finally:
retry += 1
def process_data(self, payment, request, **kwargs):
# Verifying the payment
amount = int(payment.total // 10)
pay = payment.change_status(PaymentStatus.CONFIRMED)
client = Client(self._web_service)
if request.GET.get('Status') == 'OK':
result = client.service.PaymentVerification(self._merchant_code,
request.GET['Authority'],
amount)
if result.Status == 100:
payment.change_status(PaymentStatus.CONFIRMED)
# return HttpResponse('Transaction success. RefID: ' + str(result.RefID))
elif result.Status == 101:
payment.change_status(PaymentStatus.WAITING)
# return HttpResponse('Transaction submitted : ' + str(result.Status))
else:
payment.change_status(PaymentStatus.REJECTED)
# return HttpResponse('Transaction failed. Status: ' + str(result.Status))
else:
# return HttpResponse('Transaction failed or canceled by user')
payment_track_id = result.RefID
payment.save()
return
def __init__(self, *args, **kwargs):
self.cert = kwargs.get('cert', self.cert)
self.ca_cert = kwargs.get('ca_cert', self.ca_cert)
self.key = kwargs.get('key', self.key)
self.company = kwargs.get('company', self.company)
self.username = kwargs.get('username', self.username)
self.timeout = kwargs.get('timeout', self.timeout)
session = Session()
if self.cert and self.key and self.ca_cert:
session.cert = (self.cert, self.key)
session.verify = self.ca_cert
elif self.cert or self.key or self.ca_cert:
raise ValueError("Must provide cert, ca_cert and key")
self.client = Client(self.endpoint,
transport=Transport(session=session,
timeout=self.timeout))
def _get_dte_status(self, signature_d, token):
url = server_url[
self.company_id.dte_service_provider] + 'QueryEstDte.jws?WSDL'
ns = 'urn:' + server_url[
self.company_id.dte_service_provider] + 'QueryEstDte.jws'
_server = Client(url, ns)
receptor = self.format_rut(
self.partner_id.vat or self.company_id.partner_id.main_id_number)
date_invoice = datetime.strptime(self.date_invoice,
"%Y-%m-%d").strftime("%d-%m-%Y")
response = None
retry = 0
while response is None and retry < 1000:
try:
response = _server.getEstDte(
signature_d['subject_serial_number'][:8],
str(signature_d['subject_serial_number'][-1]),
self.company_id.vat[2:-1], self.company_id.vat[-1],
receptor[:8], receptor[2:-1],
str(self.document_class_id.code),
str(self.sii_document_number), date_invoice,
str(self.amount_total), token)
except Exception:
continue
finally:
retry += 1
self.sii_message = response
resp = xmltodict.parse(response)
if resp['SII:RESPUESTA']['SII:RESP_HDR']['ESTADO'] == '2':
status = {
'warning': {
'title': _("Error code: 2"),
'message':
_(resp['SII:RESPUESTA']['SII:RESP_HDR']['GLOSA'])
}
}
return status
if resp['SII:RESPUESTA']['SII:RESP_HDR']['ESTADO'] == "EPR":
self.state = "Proceso"
if resp['SII:RESPUESTA']['SII:RESP_BODY']['RECHAZADOS'] == "1":
self.state = "Rechazado"
if resp['SII:RESPUESTA']['SII:RESP_BODY']['REPARO'] == "1":
self.state = "Reparo"
elif resp['SII:RESPUESTA']['SII:RESP_HDR']['ESTADO'] == "RCT":
self.state = "Rechazado"
def setWormsClient(self, url):
"""
Creates a WORMS WebServices client with the provided url.
Parameters:
url: string with the URL of the WORMS WebService
"""
try:
self.worms_client = Client(url)
except:
self.worms_client = None
def setDatrasClient(self, url):
"""
Creates a ICES/CIEM DATRAS WebServices client with the provided url.
Parameters:
url: string with the URL of the ICES/CIEM DATRAS WebService
"""
try:
# It seems that DATRAS web service doesn't support strict
self.datras_client = Client(url, settings=Settings(strict=False))
except:
self.datras_client = None
def get_synonyms(self, word):
all_syns = []
syn_url = 'http://farsnet.nlp.sbu.ac.ir/WebAPI/services/SynsetService?WSDL'
sen_url = 'http://farsnet.nlp.sbu.ac.ir/WebAPI/services/SenseService?WSDL'
client = Client(syn_url)
syns = client.service.getSynsetsByWord(searchStyle='EXACT',
searchKeyword=word,
userKey=self.userkey)
client = Client(sen_url)
for val in syns:
if val['id'] != None:
senses = client.service.getSensesBySynset(synsetId=val['id'],
userKey=self.userkey)
for s in senses:
all_syns.append(s['word']['defaultValue'])
return list(set(all_syns))
def __init__(self,
ip=None,
port=80,
user="******",
password="******",
use_async=False,
sub_xaddr_=None):
assert (isinstance(port, int))
if sub_xaddr_ is not None: # overwrite xaddr
self.xaddr = "http://%s:%i/onvif/%s" % (ip, port, sub_xaddr_)
else:
self.xaddr = "http://%s:%i/onvif/%s" % (ip, port, self.sub_xaddr)
self.user = user
self.password = password
self.use_async = use_async
self.service_addr = "{%s}%s" % (self.namespace, self.port)
if self.use_async:
self.async_transport = AsyncTransport(asyncio.get_event_loop(),
cache=None)
self.zeep_client = Client(wsdl=self.wsdl_file,
wsse=UsernameToken(self.user,
self.password,
use_digest=True),
settings=settings,
transport=self.async_transport)
else:
self.zeep_client = Client(wsdl=self.wsdl_file,
wsse=UsernameToken(self.user,
self.password,
use_digest=True),
settings=settings)
self.ws_client = self.zeep_client.create_service(
self.service_addr, self.xaddr)
self.factory = self.zeep_client.type_factory(
"http://www.onvif.org/ver10/schema")
def main(args):
if args.verbose:
logging.config.dictConfig({
"version": 1,
"formatters": {
"verbose": {
"format": "%(name)20s: %(message)s"
}
},
"handlers": {
"console": {
"level": "DEBUG",
"class": "logging.StreamHandler",
"formatter": "verbose",
}
},
"loggers": {
"zeep": {
"level": "DEBUG",
"propagate": True,
"handlers": ["console"],
}
},
})
if args.profile:
import cProfile
profile = cProfile.Profile()
profile.enable()
cache = SqliteCache() if args.cache else None
session = requests.Session()
if args.no_verify:
session.verify = False
result = urlparse(args.wsdl_file)
if result.username or result.password:
session.auth = (result.username, result.password)
transport = Transport(cache=cache, session=session)
st = time.time()
settings = Settings(strict=not args.no_strict)
client = Client(args.wsdl_file, transport=transport, settings=settings)
logger.debug("Loading WSDL took %sms", (time.time() - st) * 1000)
if args.profile:
profile.disable()
profile.dump_stats(args.profile)
client.wsdl.dump()
def __init__(self,
xaddr,
wsse: UsernameDigestTokenDtDiff,
url: Path,
*,
bindingName='',
transport=None):
if not url.is_file():
raise ONVIFError('%s doesn`t exist!' % url)
self.url = url
self.xaddr = xaddr
if not transport:
transport = AsyncTransport(None)
self.client = Client(wsdl=str(url),
wsse=wsse,
transport=transport,
settings=Settings(strict=False,
xml_huge_tree=True))
self.wsClient = self.client.create_service(bindingName, xaddr)
self.bindingName = bindingName
def __init__(self, client: dict, **kwargs):
"""
Initialize and cache the current SOAP client.
:param kwargs:
"""
fields = {
key: value for key, value in client.items()
if client and key in ClientSerializer.Meta.fields
}
self.client = Client(**fields)
self.client_pk = client['pk']
self.context = kwargs['context']
def main(args):
if args.verbose:
logging.config.dictConfig({
'version': 1,
'formatters': {
'verbose': {
'format': '%(name)20s: %(message)s'
}
},
'handlers': {
'console': {
'level': 'DEBUG',
'class': 'logging.StreamHandler',
'formatter': 'verbose',
},
},
'loggers': {
'zeep': {
'level': 'DEBUG',
'propagate': True,
'handlers': ['console'],
},
}
})
if args.profile:
import cProfile
profile = cProfile.Profile()
profile.enable()
cache = SqliteCache() if args.cache else None
session = requests.Session()
if args.no_verify:
session.verify = False
result = urlparse(args.wsdl_file)
if result.username or result.password:
session.auth = (result.username, result.password)
transport = Transport(cache=cache, session=session)
st = time.time()
strict = not args.no_strict
client = Client(args.wsdl_file, transport=transport, strict=strict)
logger.debug("Loading WSDL took %sms", (time.time() - st) * 1000)
if args.profile:
profile.disable()
profile.dump_stats(args.profile)
client.wsdl.dump()
def get_send_status(token, dte_service_provider, track_id, company_vat):
url = SERVER_URL[dte_service_provider] + 'QueryEstUp.jws?WSDL'
_server = Client(url)
status = None
retry = 0
while status is None and retry < RETRIES:
try:
status = _server.service.getEstUp(company_vat[2:-1],
company_vat[-1], track_id, token)
except Exception:
continue
finally:
retry += 1
return status
def main(args):
if args.verbose:
logging.config.dictConfig({
'version': 1,
'formatters': {
'verbose': {
'format': '%(name)20s: %(message)s'
}
},
'handlers': {
'console': {
'level': 'DEBUG',
'class': 'logging.StreamHandler',
'formatter': 'verbose',
},
},
'loggers': {
'zeep': {
'level': 'DEBUG',
'propagate': True,
'handlers': ['console'],
},
}
})
if args.profile:
import cProfile
profile = cProfile.Profile()
profile.enable()
cache = SqliteCache() if args.cache else InMemoryCache()
transport_kwargs = {'cache': cache}
if args.no_verify:
transport_kwargs['verify'] = False
result = urlparse(args.wsdl_file)
if result.username or result.password:
transport_kwargs['http_auth'] = (result.username, result.password)
transport = Transport(**transport_kwargs)
st = time.time()
client = Client(args.wsdl_file, transport=transport)
logger.debug("Loading WSDL took %sms", (time.time() - st) * 1000)
if args.profile:
profile.disable()
profile.dump_stats(args.profile)
client.wsdl.dump()
async def initialize(self) -> bool:
try:
logging.getLogger('urllib3.connectionpool').setLevel(logging.WARNING)
logging.getLogger('zeep.wsdl.wsdl').setLevel(logging.WARNING)
logging.getLogger('zeep.xsd.schema').setLevel(logging.WARNING)
logging.getLogger('zeep.transports').setLevel(logging.WARNING)
self.__server_url = f"{self.server_address}"
self.logger.info(
f"Trying to connect.\nURL: {self.__server_url}\nClient supported protocols: {json.dumps(self.protocols)}"
)
wsdl_file_path = f"{os.path.dirname(os.path.realpath(__file__))}/wsdl/server-201206.wsdl"
self._client = Client(
wsdl=wsdl_file_path,
settings=Settings(
raw_response=False,
),
plugins=[WsAddressingExtensionPlugin(self.from_address)]
)
self._client_service = self._client.create_service(
'{urn://Ocpp/Cs/2012/06/}CentralSystemServiceSoap',
self.__server_url
)
await asyncio.sleep(1)
if self.register_on_initialize:
await self.action_register()
await self.action_heart_beat()
return True
except ValueError as err:
await self.handle_error(ErrorMessage(err).get(), ErrorReasons.InvalidResponse)
return False
except BaseException as err:
await self.handle_error(ErrorMessage(err).get(), ErrorReasons.InvalidResponse)
return False
def query_REGON_api(
wsdl_path, key,
query_params) -> Union[RegonApiSuccess, RegonApiNotFoundFailure]:
client = Client(wsdl_path) # 1. Create zeep client with wsdl url
sid = client.service.Zaloguj(
key) # 2. Pass the access key to login endpoint
with client.settings(extra_http_headers={"sid": sid}):
# 4. Token must be passed as a HTTP header.
# "HTTP" is an important word here, as SOAP
# has a damn hell of different headers.
response: str = client.service.DaneSzukajPodmioty(
pParametryWyszukiwania=query_params)
parsed_response: Union[OrderedDict, None] = xmltodict.parse(response)
if parsed_response is None:
raise HTTPException(
400, f"Response is malformed. RESPONSE = '{response}'")
elif response_body := parsed_response.get("root", {}).get("dane", {}):
if isinstance(response_body, list):
to_parse = response_body[0]
elif response_body.get("Regon"):
to_parse = response_body
else:
error_response_reformatted = {
key: response_body.get(value, None)
for key, value in parsing_error_dict.items()
}
return RegonApiNotFoundFailure(**error_response_reformatted)
response_reformatted = {
key: to_parse.get(value, None)
for key, value in parsing_dict.items()
}
return RegonApiSuccess(**response_reformatted)
else:
def get_seed(mode):
url = SERVER_URL[mode] + 'CrSeed.jws?WSDL'
_server = Client(wsdl=url)
seed = None
retry = 0
while seed is None and retry < 1000:
try:
resp = _server.service.getSeed().replace(
'<?xml version="1.0" encoding="UTF-8"?>', '')
root = etree.fromstring(resp)
seed = root[0][0].text
except Exception:
continue
finally:
retry += 1
return seed
def main():
os.system('clear')
global name
global start
print("Digite o seu nome: ")
name = input()
client = Client('http://192.168.100.7:9998/WSHello?wsdl')
start = client.service.chatConnect(name)
ct = Thread(target=threadGet, args=(client, ))
ct.start()
chat(client)
def get_seed(self, company_id):
# En caso de que haya un problema con la validación de certificado del
# sii ( por una mala implementación de ellos)
# esto omite la validacion
try:
import ssl
ssl._create_default_https_context = ssl._create_unverified_context
except:
pass
url = server_url[company_id.dte_service_provider] + 'CrSeed.jws?WSDL'
ns = 'urn:'+server_url[company_id.dte_service_provider] + 'CrSeed.jws'
# _server = Client(url, ns)
_server = Client(url)
root = etree.fromstring(_server.service.getSeed().replace(
'<?xml version="1.0" encoding="UTF-8"?>', ''))
seed = root[0][0].text
return seed
def set_dte_claim(token, dte_service_provider, rut_emisor, sii_document_number,
document_type_id, claim):
url = CLAIM_URL[dte_service_provider] + '?wsdl'
settings = Settings(strict=False,
extra_http_headers={'Cookie': 'TOKEN=' + token})
_server = Client(url, settings=settings)
retry = 0
response = None
while response is None and retry < RETRIES:
try:
response = _server.service.ingresarAceptacionReclamoDoc(
rut_emisor[:-2], rut_emisor[-1], str(document_type_id.code),
str(sii_document_number), claim)
except:
continue
finally:
retry += 1
return response
def get_dte_claim(token, dte_service_provider, company_vat, document_type_code,
sii_document_number):
url = CLAIM_URL[dte_service_provider] + '?wsdl'
settings = Settings(strict=False,
extra_http_headers={'Cookie': 'TOKEN=' + token})
retry = 0
response = None
_server = Client(url, settings=settings)
while response is None and retry < RETRIES:
try:
response = _server.service.listarEventosHistDoc(
company_vat[2:-1], company_vat[-1], str(document_type_code),
str(sii_document_number))
except:
continue
finally:
retry += 1
return response
def __init__(self, *args, **kwargs):
super(IBabsBaseExtractor, self).__init__(*args, **kwargs)
try:
ibabs_wsdl = self.source_definition['wsdl']
except Exception:
ibabs_wsdl = settings.IBABS_WSDL
soap_settings = Settings(
strict=False,
xml_huge_tree=True,
xsd_ignore_sequence_order=True,
extra_http_headers={'User-Agent': settings.USER_AGENT},
)
try:
self.client = Client(ibabs_wsdl,
port_name='BasicHttpsBinding_IPublic',
settings=soap_settings)
except Error as e:
log.error('Unable to instantiate iBabs client: ' + str(e))
def main(args):
if args.verbose:
logging.config.dictConfig({
'version': 1,
'formatters': {
'verbose': {
'format': '%(name)s: %(message)s'
}
},
'handlers': {
'console': {
'level': 'DEBUG',
'class': 'logging.StreamHandler',
'formatter': 'verbose',
},
},
'loggers': {
'zeep': {
'level': 'DEBUG',
'propagate': True,
'handlers': ['console'],
},
}
})
if args.profile:
import cProfile
profile = cProfile.Profile()
profile.enable()
cache = SqliteCache(persistent=args.cache)
transport = Transport(cache=cache)
st = time.time()
client = Client(args.wsdl_file, transport=transport)
logger.debug("Loading WSDL took %sms", (time.time() - st) * 1000)
if args.profile:
profile.disable()
profile.dump_stats(args.profile)
client.wsdl.dump()
def get_form(self, payment, data=None):
client = Client(self._web_service)
# converting rial to tooman
amount = int(payment.total // 10)
description = payment.description
CallbackURL = payment.get_return_url()
result = client.service.PaymentRequest(MerchantID=self._merchant_code,
Amount=amount,
# email,
# mobile,
Description=description,
CallbackURL=CallbackURL)
redirect_url = 'https://www.zarinpal.com/pg/StartPay/' + str(result.Authority)
if result.Status == 100:
payment.change_status(PaymentStatus.INPUT)
raise RedirectNeeded(redirect_url)
def get_dte_status(signature_d, service_provider, **kwargs):
response = None
retry = 0
token = sii_token(service_provider, signature_d['priv_key'],
signature_d['cert'])
url = SERVER_URL[service_provider] + 'QueryEstDte.jws?WSDL'
_server = Client(url)
while response is None and retry < RETRIES:
try:
response = _server.service.getEstDte(
kwargs.get('rut')[:8],
kwargs.get('rut')[-1],
kwargs.get('company_vat')[2:-1],
kwargs.get('company_vat')[-1],
kwargs.get('receptor')[:8],
kwargs.get('receptor')[-1], kwargs.get('document_type_code'),
kwargs.get('sii_document_number'), kwargs.get('invoice_date'),
kwargs.get('amount_total'), token)
except Exception as error:
continue
finally:
retry += 1
return response
def get_token(mode, private_key, cert, seed):
template_string = u'''<getToken>
<item>
<Semilla>{}</Semilla>
</item>
</getToken>
'''.format(seed)
doc = etree.fromstring(template_string)
signed_node = XMLSigner(method=methods.enveloped,
digest_algorithm='sha1').sign(
doc,
key=private_key.encode('ascii'),
cert=cert)
seed_file = etree.tostring(signed_node,
pretty_print=True).decode().replace('ds:', '')
_logger.debug('######------- seed file %s' % seed_file)
resp = None
retry = 0
while resp is None and retry < 1000:
try:
url = SERVER_URL[mode] + 'GetTokenFromSeed.jws?WSDL'
_server = Client(wsdl=url)
tree = etree.fromstring(seed_file)
ss = etree.tostring(tree, pretty_print=True,
encoding='iso-8859-1').decode()
resp = _server.service.getToken(ss)
except:
continue
finally:
retry += 1
try:
response = etree.fromstring(
resp.replace('<?xml version="1.0" encoding="UTF-8"?>', ''))
except AttributeError:
raise UserError(
'El servidor del SII no está disponible. Intente nuevamente')
return response[0][0].text