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