def web_pc(): web_service = client.Client( url= 'http://120.24.235.105:9010/sms-service-war-1.0/ws/smsFacade.ws?wsdl') web_service = client.Client( url= 'http://120.24.235.105:9010/finance-user_info-war-1.0/ws/financeUserInfoFacade.ws?wsdl' ) print(web_service)
def __init__(self, url): self._url = url print '[INFO] Start SIGEPWEB webservice connection...' try: self._service = client.Client(url).service except client.TransportError as e: raise ErroConexaoComServidor(e.message)
def getInstance(cls, userAPIUrl=None, username=None, password=None): if cls._instance is None or (userAPIUrl is not None or username is not None or password is not None): if userAPIUrl is None: userAPIUrl = getVidyoOptionValue('userAPIURL') if username is None: username = getVidyoOptionValue('indicoUsername') if password is None: password = getVidyoOptionValue('indicoPassword') location = getVidyoOptionValue( 'baseAPILocation') + getVidyoOptionValue('userAPIService') try: cls._instance = client.Client( userAPIUrl, transport=ClientBase.getTransport(userAPIUrl, username, password), location=location, cache=ClientBase.getCache()) except Exception: Logger.get("Vidyo").exception("Problem building UserClient") raise return cls._instance
def _setup(self): plugings = [] cache_conf = NoCache() if Configuration.debug: if Configuration.log_file is not None: logging.basicConfig(filename=Configuration.log_file, level=Configuration.log_level, format=utils.get_log_format()) else: logging.basicConfig(level=Configuration.log_level, format=utils.get_log_format()) if Configuration.log_level == logging.DEBUG and Configuration.environment == constants.PRODUCTION_ENV: raise LogException plugings.append(LogPlugin()) s = requests.Session() s.mount('file://', FileAdapter()) if Configuration.proxy_url: s.proxies = utils.get_builded_proxy_url(Configuration.proxy_url, Configuration.proxy_port) if Configuration.proxy_user: s.auth= HTTPProxyAuth(Configuration.proxy_user, Configuration.proxy_pass) if Configuration.certificate and Configuration.c_key: s.cert=(Configuration.certificate, Configuration.c_key) else: s.verify = Configuration.certificate t = RequestsTransport(s, timeout=Configuration.timeout) if Configuration.cache: cache_conf = ObjectCache(location=Configuration.cache_location, seconds=Configuration.cache_duration) self._client = client.Client(Configuration.get_wsdl().strip(), plugins=plugings, transport=t, cache=cache_conf)
def __init__(self, merchant_id, callback_address): if not isinstance(merchant_id, str): raise TypeError('merchant_id is str not %s' % type(merchant_id)) if not isinstance(callback_address, str) and not isinstance(callback_address, unicode): raise TypeError('callback_address is unicode or str not %s' % type(callback_address)) self.__merchant_id__ = merchant_id self.__call_address__ = callback_address self.__cli__ = client.Client(self.SERVICE_ADDRESS)
def get_online_vso_url(api, url, port): if api is None and (url is None or port is None): for mirror in DEFAULT_URL_PORT: if check_connection(mirror['url']): api = client.Client(mirror['url'], transport=mirror['transport']()) api.set_options(port=mirror['port']) return api
def requests(self, url, interface, data): self.wsc = client.Client(url) try: response = eval("self.wsc.service.{}({})".format(interface, data)) except suds.WebFault as e: return dict(e.fault) else: return dict(response)
def __init__(self, user=None, password=None, SID=None, close_on_exit=True, lite=False): #"""Create the SOAP clients. user and password for premium access.""" self._SID = SID self._close_on_exit = close_on_exit search_wsdl = self.searchlite_url if lite else self.search_url self._auth = client.Client(self.auth_url) self._search = client.Client(search_wsdl) if user and password: auth = '%s:%s' % (user, password) auth = _b64encode(auth.encode('utf-8')).decode('utf-8') headers = {'Authorization': ('Basic %s' % auth).strip()} self._auth.set_options(headers=headers)
def __init__(self, url=None, port=None, api=None): if api is None: if url is None: url = DEFAULT_URL if port is None: port = DEFAULT_PORT api = client.Client(url) api.set_options(port=port) self.api = api
def __init__(self, url=None, port=None, api=None): if api is None: if url is None: url = DEFAULT_URL if port is None: port = DEFAULT_PORT api = client.Client(url, transport=WellBehavedHttpTransport()) api.set_options(port=port) self.api = api
def do_setup(self, context): """Create client for DISCO request manager.""" LOG.debug("Enter in DiscoDriver do_setup.") if CONF.choice_client.lower() == "rest": self.client = disco_api.DiscoApi( CONF.rest_ip, CONF.disco_src_api_port) else: path = ''.join(['file:', self.configuration.disco_wsdl_path]) init_client = client.Client(path, cache=None) self.client = init_client.service
def _create_client(self, wsdl_url, login, password, hostname, port): """ Instantiate a "suds" client to make web services calls to the DFM server. Note that the WSDL file is quite large and may take a few seconds to parse. """ self.client = client.Client(wsdl_url, username=login, password=password) soap_url = 'http://%s:%s/apis/soap/v1' % (hostname, port) self.client.set_options(location=soap_url)
def __init__(self, settings): self.settings = settings security = wsse.Security() token = wsse.UsernameToken( self.settings.get('username'), self.settings.get('password')) security.tokens.append(token) # settings faults to False makes sure we can catch the server side # exception message as well self.client = client.Client( self.settings.get('wsdl'), autoblend=True, wsse=security, faults=False)
def get_soap_client(wsdl_path, **kwargs): """ Create a soap client based on suds and python requests (to handle the AlgoSec's self-signed certificate properly :param kwargs: KWArgs that are forwarded to the suds client constructor """ session = requests.Session() session.verify = False return client.Client( wsdl_path, transport=suds_requests.RequestsTransport(session), **kwargs)
def test_report_soap_failure__detailed_transport_error(self): wsdl_path = "http://some-wsdl-path" api_error = "some error description" responses.add(responses.GET, wsdl_path, json={"error": api_error}, status=500) with pytest.raises(AlgoSecAPIError) as e: with report_soap_failure(AlgoSecAPIError): # Force an api soap call, that is destined to fail client.Client(wsdl_path, transport=suds_requests.RequestsTransport()) assert "status_code: 500" in str(e) assert api_error in str(e)
def post(self, request): try: user = request.user client = user.client except: return Response(status=status.HTTP_401_UNAUTHORIZED) serializer = PurchaseArticleSerializer(data=request.data) if serializer.is_valid(): articleId = serializer.validated_data["articleID"] platform = str(serializer.validated_data["platform"]) if Article.objects.filter(id=articleId).exists() is False: return Response(status=status.HTTP_400_BAD_REQUEST) if platform != "Android" and platform != "iOS": return Response(status=status.HTTP_400_BAD_REQUEST) article = Article.objects.get(id=articleId) if article in client.purchasedArticles.all(): return Response(status=status.HTTP_400_BAD_REQUEST) if article.price == 0: return Response(status=status.HTTP_400_BAD_REQUEST) if PurchaseBankID.objects.filter(article=article, client=client).exists(): PurchaseBankID.objects.filter(article=article, client=client).delete() price = article.price if article.isPersian: description = "خرید مقاله: " + article.title else: description = "Purchasing Article: " + article.title zarin_client = C1.Client(ZARINPAL_WEBSERVICE) absolute_url = request.build_absolute_uri('/') call_back_url = absolute_url + 'api/v1/article/purchase/callback/' result = zarin_client.service.PaymentRequest( MerchantID=MMERCHANT_ID, Amount=price, Description=description, CallbackURL=call_back_url, ) if result.Status == 100: authorizationID = str(result.Authority) PurchaseBankID.objects.create(article=article, client=client, authorityID=authorizationID, platform=platform) zarin_url = 'https://www.zarinpal.com/pg/StartPay/' + authorizationID else: return Response(status=status.HTTP_400_BAD_REQUEST) result['url'] = zarin_url return Response(result, status=status.HTTP_200_OK) else: return Response(status=status.HTTP_400_BAD_REQUEST)
def workday_client_login(*args, **kwargs): wsdl_url = kwargs['wsdl_url'] username = kwargs['username'] password = kwargs['password'] proxy = kwargs['proxy'] client_return = None print "Connecting to wsdl_url ..." try: if (proxy.strip() != ""): client_return = client.Client(wsdl_url, proxy={'https': proxy}) else: client_return = client.Client(wsdl_url) security = Security() token = UsernameToken(username, password) security.tokens.append(token) client_return.set_options(wsse=security) except Exception as e: print(e) return client_return print("Logged In to: " + wsdl_url) return client_return
def __init__(self, wsdl_url=None, soap_url=None, cacert=None, insecure=True, pool_maxsize=10): self.wsdl_url = wsdl_url self.soap_url = soap_url LOG.debug("Creating suds client with soap_url='%s' and wsdl_url='%s'", self.soap_url, self.wsdl_url) transport = RequestsTransport(cacert, insecure, pool_maxsize) self.client = client.Client(self.wsdl_url, transport=transport, location=self.soap_url, plugins=[ServiceMessagePlugin()], cache=_CACHE) self._service_content = None
def _create_client(self, **kwargs): """Instantiate a web services client. This method creates a "suds" client to make web services calls to the DFM server. Note that the WSDL file is quite large and may take a few seconds to parse. """ wsdl_url = kwargs['wsdl_url'] LOG.debug(_('Using WSDL: %s') % wsdl_url) if kwargs['cache']: self.client = client.Client(wsdl_url, username=kwargs['login'], password=kwargs['password']) else: self.client = client.Client(wsdl_url, username=kwargs['login'], password=kwargs['password'], cache=None) soap_url = 'http://%s:%s/apis/soap/v1' % (kwargs['hostname'], kwargs['port']) LOG.debug(_('Using DFM server: %s') % soap_url) self.client.set_options(location=soap_url)
def _build(self): #this is used for performance, wsdl and header will be built on initialization of object to save time and redudancy wsdl_url = 'https://wd2-impl-services1.workday.com/ccx/service/' + self.tenant + '/' + self.wws + '/' + self.version +'?wsdl' print wsdl_url print self.username +'\n' + 'building wsdl for ' + self.wws + ' object' self.client1 = client.Client(wsdl_url) # Wrapping our client call in Security() like this results in submitting # the auth request with PasswordType in headers in the format WD expects. security = Security() token = UsernameToken(self.username, self.password) security.tokens.append(token) self.client1.set_options(wsse=security) print '\n'+ ' wsdl and header has been built'
def call(self, name, **data): log.info('IARC client call: {0} from wsdl: {1}'.format(name, wsdl)) if self.client is None: self.client = sudsclient.Client(wsdl[self.wsdl_name], cache=None) # IARC requires messages be base64 encoded. for k, v in data.items(): data[k] = base64.b64encode(v) with statsd.timer('mkt.iarc.request.%s' % name.lower()): response = getattr(self.client.service, name)(**data) return base64.b64decode(response)
def get_ret(case): try: web_service = client.Client(url=case.url) string = f'web_service.service.{case.api_name}({case.request_data})' actual = eval(string) except WebFault as e: actual = { 'retCode': e.fault.faultcode, 'retInfo': e.fault.faultstring } print(e) else: actual = dict(actual) return actual
def send(url, method, *args, **kwargs): # 创建客户端对象 cli = client.Client(url=url) # 根据参数构造请求方法 request_method = eval('cli.service.{}'.format(method)) try: # 发送请求 res = request_method(*args, **kwargs) except suds.WebFault as e: # 提取请求错误信息返回 return dict(e.fault) else: # 返回正常的信息 return dict(res)
def web_request(self, url, interface, data): self.webs = client.Client( url=url) # 传入url,创建webservice对象,打印对象可查看对象内部的方法 try: response = eval('self.webs.service.{}({})'.format( interface, data)) # 拼接参数,并将str转换成python语句 except suds.WebFault as e: # 服务器返回的数据在e.fault内,可转换成dict return dict(e.fault) else: return dict(response)
def __init__(self, *args, **kwargs): self.sid = None self.username = kwargs['username'] self.password = kwargs['password'] wsdl_url = 'https://%s/wsdl/NsGroupManagement.wsdl' % (kwargs['ip']) LOG.debug('Using Nimble wsdl_url: %s', wsdl_url) self.err_string_dict = self._create_err_code_to_str_mapper(wsdl_url) self.client = client.Client(wsdl_url, username=self.username, password=self.password) soap_url = ('https://%(ip)s:%(port)s/soap' % {'ip': kwargs['ip'], 'port': SOAP_PORT}) LOG.debug('Using Nimble soap_url: %s', soap_url) self.client.set_options(location=soap_url) self.login()
def __init__(self, host, username, password, timeout): if websocket is None: msg = _("Failed to import websocket-client python module." " Please, ensure the module is installed.") raise datacore_exceptions.DataCoreException(msg) self.timeout = timeout executive_service_net_addr = datacore_utils.build_network_address( host, self.DATACORE_EXECUTIVE_PORT) executive_service_endpoint = self._build_service_endpoint( executive_service_net_addr, self.EXECUTIVE_SERVICE) security_options = wsse.Security() username_token = wsse.UsernameToken(username, password) security_options.tokens.append(username_token) self._executive_service_client = suds_client.Client( executive_service_endpoint['http_endpoint'] + '?singlewsdl', nosend=True, timeout=self.timeout, wsse=security_options, plugins=[FaultDefinitionsFilter()]) self._update_storage_services_endpoint(executive_service_endpoint) storage_services_endpoint = self._get_storage_services_endpoint() self._storage_services_client = suds_client.Client( storage_services_endpoint['http_endpoint'] + '?singlewsdl', nosend=True, timeout=self.timeout, wsse=security_options, plugins=[FaultDefinitionsFilter()]) self._update_executive_service_endpoints(storage_services_endpoint)
def call(self, name, **data): log.info('IARC client call: {0} from wsdl: {1}'.format(name, wsdl)) if self.client is None: self.client = sudsclient.Client(wsdl[self.wsdl_name], cache=None) # IARC requires messages be base64 encoded and base64 requires # byte-strings. for k, v in data.items(): if isinstance(v, unicode): # Encode it as a byte-string. v = v.encode('utf-8') data[k] = base64.b64encode(v) with statsd.timer('mkt.iarc.request.%s' % name.lower()): response = getattr(self.client.service, name)(**data) return base64.b64decode(response)
def connect(self): eds_wsdl = '%s://%s:%i/eds.wsdl' % (config.EDS_WEB_PROTOCOL,config.EDS_HOST,config.EDS_WEB_PORT) connected = False authorized = False try: self.soap_cln = client.Client(eds_wsdl) self.logger.debug('[EDS_connector] Successfully connected to EDS') connected = True except Exception as conn_error: self.logger.debug('[EDS_connector] WSDL connection error to %s, %s' % (eds_wsdl, conn_error)) if connected: try: self.auth_str = self.soap_cln.service.login(config.EDS_USER, config.EDS_PWD) self.logger.debug('[EDS_connector] Successfully authorized in EDS') authorized = True except Exception as auth_error: self.logger.debug('[EDS_connector] WebApi authorisation error with user %s and pass %s, %s' % (config.EDS_USER, config.EDS_PWD, auth_error)) if connected and authorized: self.connected = True
def __init__(self, wsdl_url=None, soap_url=None, cacert=None, insecure=True, pool_maxsize=10, connection_timeout=None, op_id_prefix='oslo.vmware'): self.wsdl_url = wsdl_url self.soap_url = soap_url self.op_id_prefix = op_id_prefix LOG.debug("Creating suds client with soap_url='%s' and wsdl_url='%s'", self.soap_url, self.wsdl_url) transport = RequestsTransport(cacert=cacert, insecure=insecure, pool_maxsize=pool_maxsize, connection_timeout=connection_timeout) self.client = client.Client(self.wsdl_url, transport=transport, location=self.soap_url, plugins=[ServiceMessagePlugin()], cache=_CACHE) self._service_content = None self._vc_session_cookie = None
def get(self, request): zarin_status = request.query_params.get('Status', None) authorizationID = str(request.query_params.get('Authority', None)) if PurchaseBankID.objects.filter( authorityID=authorizationID).exists() is False: return Response(status=status.HTTP_400_BAD_REQUEST) bankID = PurchaseBankID.objects.get(authorityID=authorizationID) platform = bankID.platform article = bankID.article if zarin_status == 'OK': zarin_client = C1.Client(ZARINPAL_WEBSERVICE) result = zarin_client.service.PaymentVerification( MerchantID=MMERCHANT_ID, Authority=authorizationID, Amount=bankID.article.price, ) if result.Status == 100: client = bankID.client article = bankID.article client.purchasedArticles.add(article) client.save() bankID.delete() platform = "Android" article = Article.objects.get(id=1) if platform == 'iOS': app_url = 'monencoinsights://?status=1&article=' + str( article.id) else: app_url = "intent://www.monencoinsights.com/#Intent;scheme=monenco;package=com.monenco.insights;i.status=1;i.article={};end".format( str(article.id)) print(app_url) response = HttpResponse("", status=302) response['Location'] = app_url return response if platform == 'iOS': app_url = 'monencoinsights://?status=0&article=' + str(article.id) else: app_url = "intent://www.monencoinsights.com/#Intent;scheme=monenco;package=com.monenco.insights;i.status=0;i.article={};end".format( str(article.id)) response = HttpResponse("", status=302) response['Location'] = app_url return response