def __init__(self, name, session, wsdl_url, authentication, proxy_url=None, strict=True):
"""
:param name: Name of this API
:type name: ``str``
:param session: HTTP session to use for communication
:type session: :class:`requests.Session`
:param wsdl_url: Path to the WSDL
:type wsdl_url: ``str``
:param authentication: Authentication configuration
:type authentication: :class:`workday.auth.BaseAuthentication`
:param proxy_url: (Optional) HTTP Proxy URL
:type proxy_url: ``str``
"""
auth_kwargs = authentication.kwargs
settings = zeep.Settings(strict=strict)
self._client = zeep.Client(
wsdl=wsdl_url,
transport=zeep.transports.Transport(session=session),
settings=settings,
**auth_kwargs
)
def __init__(self, url, test_service):
settings = zeep.Settings(xml_huge_tree=True)
session = requests.Session()
if test_service:
session.verify = SSL_TEST_CERTIFICATE
else:
session.verify = SSL_PROD_CERTIFICATE
transport = zeep.transports.Transport(session=session)
self.client = zeep.Client(WSDL_DOC, transport=transport, settings=settings)
if url:
self.service = self.client.create_service(
"{http://www.sap.com/DWS}DWSBinding", url
)
else:
self.service = self.client.service
def _make_client(self, endpoint_type, service_name, **client_kwargs):
self.validate_service_type(endpoint_type)
url = self._make_endpoint_url(endpoint_type, service_name)
if self.cache_expiration:
cache = zeep.cache.InMemoryCache(timeout=self.cache_expiration)
else:
cache = None
session = requests.Session()
session.verify = self.verify_certificate
session.auth = requests_ntlm.HttpNtlmAuth(self.username, self.password)
transport = zeep.transports.Transport(session=session, cache=cache)
if 'settings' not in client_kwargs:
client_kwargs['settings'] = zeep.Settings(strict=False)
return self._run_capture_500(zeep.Client,
url,
transport=transport,
**client_kwargs)
def dataservice(self, dataservice, dump=False):
"""
function to set URL for dataservice to be used in other functions
Parameters
----------
dataservice: str
URL of dataservice instance (eg. 'https://tsws.hkvservices.nl/mangrove.ws/')
"""
self._dataservice = urllib.parse.urljoin(dataservice, "data.ashx")
self._call = urllib.parse.urljoin(dataservice, "entry.asmx/Call?")
self._wsdl = urllib.parse.urljoin(dataservice, "entry.asmx?WSDL")
settings = zeep.Settings(strict=False, raw_response=True)
self.client = zeep.Client(wsdl=self._wsdl, settings=settings)
if dump == False:
return print(
"Dataservice is recognized.",
self._wsdl,
"will be used as portal",
)
if dump == True:
return self.client.wsdl.dump()
import zeep
from frisr3.settings import DEFAULT_LOCALE
from frisr3.fris_utils import localize_text
WSDL_URL = 'https://frisr3.researchportal.be/ws/OrganisationServiceFRIS?wsdl'
CLIENT_SETTINGS = zeep.Settings(strict=False)
class Organisation:
def __init__(self, data):
self.data = data
def uuid(self):
return self.data.uuid
def name(self, locale=DEFAULT_LOCALE):
return localize_text(self.data.name, locale)
def acronym(self):
return self.data.acronym
def keywords(self, locale=DEFAULT_LOCALE):
if self.data.keywords is None:
return None
keywords = self.data.keywords.keyword
return [k._value_1 for k in keywords if k.locale == locale]
def research_activity(self, locale=DEFAULT_LOCALE):
return localize_text(self.data.researchActivity, locale)
def root_organisation_uuid(self):
return self.data.rootOrganisationUuid
def initClients(self, retry=False, failquick=False):
if self.trynum > 1: print("login attempt " + str(self.trynum))
self.trynum = self.trynum + 1
self.initClientsStartTime = self.edtTime()
if retry and not failquick:
if self.UIbackends:
newfqdn = self.UIbackends.pop()
print("WARN: client initialization failed against",
self.loginUrl.split("/")[2])
print("WARN: trying again with", newfqdn)
self.updateServiceUrls(newfqdn)
else:
print("ERROR: no remaining backends to try. Exiting.")
sys.exit(1)
## set up some defaults for all of the clients
self.Session = Session()
self.Session.verify = False
settings = zeep.Settings() #strict=False)
self.Transport = zeep.transports.Transport(session=self.Session)
## login, and update everything to use the returned service host
## also, record the proxy host
try:
#print "==geting client"
history = HistoryPlugin()
self.loginClient = zeep.Client(self.loginUrl,
transport=self.Transport,
settings=settings,
plugins=[history])
#print "last sent:", history.last_sent, "--"
#print "last recv:", history.last_received, "--"
#print "last sent:", history.last_sent, "--"
print("==client acquired:", self.loginClient)
#print "==logging in"
self.loginResult = self.BlLogin(self.loginClient, self.blUser,
self.blPass, self.blPassType)
#print "==login done"
# separate out just the fqdn from teh returned serviceUrl
try:
embed()
print("last_recv:", history.last_received)
self.proxyHost = self.loginResult['return'].serviceUrl.split(
"//")[1].split(":")[0]
self.serviceUrls = self.loginResult['return'].serviceUrls
if self.debug:
print("The login service is directing us from",
self.loginUrl.split("//")[1].split(":")[0],
"to BL appserver", self.proxyHost)
self.updateServiceUrls(self.proxyHost)
except:
pass
except Exception as e:
print("\nLogin failed using", self.loginUrl, ":", e)
self.emailError(self.loginUrl, e)
print("Please cut a ticket with", self.bladelogicticketurl)
print("Trying again")
return self.initClients(retry=True)
#sys.exit(1)
#record default soap headers. sessionId allows to keep one session across the client instances
self.sessionId = self.loginResult.returnSessionId
self.soapheaders = {"request_header": self.sessionId}
## init assumeRole client
print('Logged in as: ' + self.blUser, file=sys.stderr)
print('Session ID: ' + str(self.sessionId), file=sys.stderr)
print('Switching role to: ' + self.blRole, file=sys.stderr)
print("====")
#for u in self.serviceUrls:
# u=re.sub(".*//","https://",u)
# print "later we can try",u,"- maybe try preserving the ports, or the wsdl location (under wsdl:port)"
try:
self.roleClient = Client(self.roleUrl, transport=self.Transport)
self.roleClient.set_default_soapheaders(self.soapheaders)
assume_result = self.roleClient.service.assumeRole(self.blRole)
except Exception as e:
print("assumeRole exception:", e)
print("Trying again")
self.emailError(self.roleUrl, e)
return self.initClients(retry=True)
#sys.exit(1)
if assume_result != self.blRole:
print("could not switch to role:", self.blRole)
sys.exit(1)
## init runBlcli client
try:
self.blCliClient = Client(self.cliUrl, transport=self.Transport)
self.blCliClient.set_default_soapheaders(self.soapheaders)
except Exception as e:
print("initial setup of blCliClient failed against", self.cliUrl,
":", e)
self.emailError(self.cliUrl, e)
return self.initClients(retry=True)
try:
self.blCliClient2 = Client(self.cliUrl, transport=self.Transport)
self.blCliClient2.set_default_soapheaders(self.soapheaders)
except Exception as e:
print("initial setup of blCliClient2 failed against", self.cliUrl,
":", e)
self.emailError(self.cliUrl, e)
return self.initClients(retry=True)
from influxdb import InfluxDBClient
from credentials import username, password
# logging.basicConfig(level=logging.DEBUG)
RCW_GETDATA_VALUE_COUNT = 3000
WSDL = 'wsdl/RcWareDbAccess.wsdl'
MAX_CONCURRENCY = 2
loop = asyncio.get_event_loop()
loop.set_debug(False)
settings = zeep.Settings(strict=True,
xml_huge_tree=True,
force_https=False,
raw_response=False)
transport = AsyncTransport(loop)
# Available ports are HistoryAccess, HistoryAccessGZip, HistoryAccess1. Only HistoryAccess seems to be alive.
client = zeep.Client(wsdl=WSDL,
settings=settings,
port_name='HistoryAccess',
transport=transport)
factory = client.type_factory(
'http://schemas.datacontract.org/2004/07/ESG.Db.Server.Shared')
creds = factory.Credentials(Name=username, Password=password)
influxdb = InfluxDBClient('influxdb.power-hash.com', port=80)
def load_mapping(filename):
def run(self):
if self.command == 'update_news':
self.update_news()
self.message = f'- новостей: {self.count_of_news}.'
elif self.command == 'update_stocks':
# Инициализируем SOAP-клиента
settings_ = zeep.Settings(strict=False, xml_huge_tree=True)
self.client = zeep.Client(wsdl=self.url['wsdl'],
settings=settings_)
# self.update_categories()
self.update_catalog()
# Удаляем устаревшие партии
distributors.models.Party.objects.filter(
distributor=self.distributor,
created__lte=self.start_time).delete()
# Готовим оповещение о завершении
self.message = f'- продуктов: {self.count_of_products};\n' \
f'- партий: {self.count_of_parties}.'
elif self.command == 'update_content_all':
# Инициализируем SOAP-клиента
settings_ = zeep.Settings(strict=False, xml_huge_tree=True)
self.client = zeep.Client(wsdl=self.url['wsdl'],
settings=settings_)
# Получаем ключи продуктов для запросов
keys = self.get_keys_for_update_content('all')
self.update_content(keys)
# Готовим оповещение о завершении
self.message = f'- характеристик: {self.count_of_parameters};\n' \
f'- фотографий: {self.count_of_images}.'
elif self.command == 'update_content_clear':
# Инициализируем SOAP-клиента
settings_ = zeep.Settings(strict=False, xml_huge_tree=True)
self.client = zeep.Client(wsdl=self.url['wsdl'],
settings=settings_)
# Получаем ключи продуктов для запросов
keys = self.get_keys_for_update_content('clear')
self.update_content(keys)
# Готовим оповещение о завершении
self.message = f'- характеристик: {self.count_of_parameters};\n' \
f'- фотографий: {self.count_of_images}.'
elif self.command == 'all_delete':
self.distributor.delete()
else:
print('Неизвестная команда!')
# Отправляем оповещение о завершении
if self.message:
anodos.tools.send(
content=
f'{self.name}: {self.command} finish at {self.delta()}:\n'
f'{self.message}')
else:
anodos.tools.send(
content=
f'{self.name}: {self.command} finish at {self.delta()}.\n')
raise ValueError("EPS username cannot be empty")
else:
print(colored(" * Using environment variable EPS_USER_NAME",
"yellow"))
if not EPS_USER_PASSWORD:
EPS_USER_PASSWORD = getpass.getpass(
prompt=colored("EPS password: "******"yellow"))
if not EPS_USER_PASSWORD:
raise ValueError("EPS password cannot be empty")
else:
print(
colored(" * Using environment variable EPS_USER_PASSWORD",
"yellow"))
settings = zeep.Settings(strict=False, xml_huge_tree=True)
logging.info("EPS url: %s" % EPS_URL_SERVER)
logging.info("EPS username: %s" % EPS_USER_NAME)
logging.info("EPS settings: %s" % str(settings))
client = zeep.Client(EPS_URL_SERVER, settings=settings)
with client.settings():
response = client.service.Authenticate(username=EPS_USER_NAME,
password=EPS_USER_PASSWORD,
domain=EPS_USER_DOMAIN)
token = response.Token
if not token:
