from zeep import Client, Transport
index_movie = None
index_screening = None
indexs_seats = []
index_reservation = None
pom_index = None
user = None
url = 'http://localhost:8080'
session = Session()
session.proxies = {
"http": 'http://localhost:4040',
"https": 'https://localhost:4040'
}
movie_Service = Client(url + '/movie/service?wsdl',
transport=Transport(session=session)).service
image_Service = Client(url + '/image/service?wsdl',
transport=Transport(session=session)).service
screening_Service = Client(url + '/screening/service?wsdl',
transport=Transport(session=session)).service
reservation_Service = Client(url + '/reservation/service?wsdl',
transport=Transport(session=session)).service
user_Service = Client(url + '/user/service?wsdl',
transport=Transport(session=session)).service
loop = asyncio.get_event_loop()
@eel.expose
def create_view_list_movies():
movies = movie_Service.getAllMovie()
from requests.auth import HTTPBasicAuth # or HTTPDigestAuth, or OAuth1, etc.
from requests import Session
from zeep import Client
from zeep.transports import Transport
import zipfile
import io
from lxml import etree
import config
user, sifre, vk = config.foriba_test_api.values()
session = Session()
session.auth = HTTPBasicAuth(user, sifre)
client = Client(
'https://earsivwstest.fitbulut.com/ClientEArsivServicesPort.svc?singleWsdl',
transport=Transport(session=session))
result = client.service.getInvoiceDocument(
'c99a79fb-151e-4abb-82de-8d9dfa831ee9', vk, None, 'HTML')
print('UUID: ', result.UUID, 'Hash: ', result.Hash, 'invoiceNumber: ',
result.invoiceNumber, 'StatusCode: ', result.StatusCode)
print(result.binaryData.decode('utf8'))
def __init__(self, l10n_br_zip_record):
self.obj_zip = l10n_br_zip_record
self.client = Client(
'https://apps.correios.com.br/SigepMasterJPA/AtendeClienteService/AtendeCliente?wsdl'
) # noqa
db = None
eb = None
napit = False
jouk = {}
joukn = []
jouki = []
lajit = {}
lajitn = []
lajiti = []
try:
from zeep import Client, Settings
settings = Settings(strict=False, xml_huge_tree=True)
client = Client("http://taitaja9.gradia.fi/julkaistu5/Service1.svc?wsdl",
settings=settings)
print("Yhteys saatu")
result = client.service.lajit()
result2 = client.service.joukkueet()
#print(result2)
for i in range(len(result2._value_1._value_1)):
jouk[result2._value_1._value_1[i]["Table"]
["Joukkue"]] = result2._value_1._value_1[i]["Table"]["Id"]
#joukn=list(jouk.keys())
joukn = list(("Mikromekaanikot", "NeJaNe", "Golden magic", "Foxtrot",
"Jöröjukat", "Bluefox", "Norpat", "KYK8b", "Konnat",
"Lennin enkelit", "Friends Without Benefits", "ESA",
"Jasun Mussukat", "Sepät", "Lumiukot", "Välkyt"))
jouki = list(jouk.values())
@login_required(login_url='/login')
def remove_order_detail(request, *args, **kwargs):
detail_id = kwargs.get('detail_id')
if detail_id is not None:
order_detail = OrderDetail.objects.get_queryset().get(
id=detail_id, order__owner_id=request.user.id)
if order_detail is not None:
order_detail.delete()
return redirect('/open-order')
raise Http404()
MERCHANT = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
client = Client('https://www.zarinpal.com/pg/services/WebGate/wsdl')
amount = 1000 # Toman / Required
description = "توضیحات مربوط به تراکنش را در این قسمت وارد کنید" # Required
email = '*****@*****.**' # Optional
mobile = '09123456789' # Optional
CallbackURL = 'http://localhost:8000/verify' # Important: need to edit for realy server.
def send_request(request, *args, **kwargs):
total_price = 0
open_order: Order = Order.objects.filter(is_paid=False,
owner_id=request.user.id).first()
if open_order is not None:
total_price = open_order.get_total_price()
result = client.service.PaymentRequest(
MERCHANT, total_price, description, email, mobile,
def __init__(self, wsdl, settings):
session = Session()
transport = Transport(session=session, cache=ZeepCache())
session.auth = HTTPBasicAuth(settings.get('username'), settings.get('password'))
self.client = Client(wsdl, transport=transport)
self.factory = self.client.type_factory('ns0')
def get_ordered_certificates(self, pending_certs):
pending = []
certs = []
for pending_cert in pending_certs:
rejected = False
expired = False
try:
authority = get_authority(pending_cert.authority_id)
authority_name = authority.name.upper()
# print("AUTHORITYNAME**** " + authority_name)
session = requests.Session()
session.mount('https://', HttpsAdapter())
session.cert = current_app.config.get(
"EJBCA_PEM_PATH_{0}".format(authority_name))
session.verify = current_app.config.get("EJBCA_TRUSTSTORE")
session.hooks = dict(response=log_status_code)
transport = Transport(session=session)
url = current_app.config.get(
"EJBCA_URL") + "/ejbca/ejbcaws/ejbcaws?wsdl"
client = Client(url, transport=transport)
csr_x509 = load_certificate_request(FILETYPE_PEM,
pending_cert.csr)
# get SubjectDN string from CSR
subject_dn = get_subject_dn_string(
csr_x509.get_subject().get_components())
# print("*****DN:" + subject_dn)
end_entity_username = pending_cert.name
if end_entity_username is None:
end_entity_username = "******"
# Strip -[digit]+ from pending cert name to obtain end entity username
end_entity_username = re.sub('-\d+$', '', end_entity_username)
response = client.service.getRemainingNumberOfApprovals(
pending_cert.external_id)
num_remaining = response
current_app.logger.debug(
f"Remaining check: {str(num_remaining)}")
if num_remaining == -1:
# print("Rejected!")
rejected = True
certs.append({
"cert": False,
"pending_cert": pending_cert,
"last_error": "Request was rejected",
"rejected": rejected,
"expired": expired
})
elif num_remaining > 0:
current_app.logger.debug(
f"Remaining Approvals: {num_remaining}")
# print("Approvals Remaining")
remain_message = "Remaining approvals: " + str(
num_remaining)
certs.append({
"cert": False,
"pending_cert": pending_cert,
"last_error": remain_message,
"rejected": rejected,
"expired": expired
})
elif num_remaining == 0:
#ready to issue cert
csr_b64 = dump_certificate_request(FILETYPE_PEM, csr_x509)
csr_b64 = csr_b64.decode()
request_data = {
'arg0': end_entity_username,
'arg1': 'foo123',
'arg2': csr_b64,
'arg3': None,
'arg4': 'CERTIFICATE'
}
try:
response = client.service.pkcs10Request(**request_data)
# print(response)
# print(response.data)
cert_data_str = response.data.decode("utf-8")
# print("CERT DATA")
# print(cert_data_str)
#cert_data = base64.b64decode(cert_data_str).decode("utf-8")
cert_data_str.replace('\\n', '\n')
# print("decoded:")
# print(cert_data_str)
external_id = None
#reconstruct certificate from json array
pem = "-----BEGIN CERTIFICATE-----\n"
pem += cert_data_str
pem += "\n-----END CERTIFICATE-----"
#authority = get_authority(pending_cert.authority_id)
#authority_name = authority.name.upper()
chain = current_app.config.get(
"EJBCA_INTERMEDIATE_{0}".format(authority_name),
current_app.config.get("EJBCA_INTERMEDIATE"))
cert = {
"body": pem,
"chain": "\n".join(str(chain).splitlines()),
"external_id": str(pending_cert.external_id),
"authority_id": str(pending_cert.authority_id),
}
certs.append({
"cert": cert,
"pending_cert": pending_cert
})
except zeep.exceptions.Fault as fault:
sentry.captureException()
metrics.send(
"get_ordered_certificates_pending_creation_error",
"counter", 1)
current_app.logger.error(
f"Unable to resolve EJBCA pending cert: {pending_cert}",
exc_info=True)
certs.append({
"cert": False,
"pending_cert": pending_cert,
"last_error": fault.message,
"rejected": rejected,
"expired": expired
})
except zeep.exceptions.Fault as fault:
strdet = fault.detail[0]
m = re.search('^\{.*\}(.*)$', strdet.tag)
exceptname = m.group(1)
if (exceptname == "ApprovalRequestExpiredException"):
expired = True
certs.append({
"cert": False,
"pending_cert": pending_cert,
"last_error": fault.message,
"rejected": rejected,
"expired": expired
})
return certs
download_wsdl_url = download_url + '/CommandWebService.asmx?WSDL'
upload_url = copy_urls[1]
if not upload_url:
exit_code = 2
raise RuntimeError(
'Backup mode ' + backup_mode +
' is incorrect. Missing upload_url in tag: copy_url')
upload_wsdl_url = upload_url + '/CommandWebService.asmx?WSDL'
logger.info('Download from URL = ' + download_url)
logger.info('Upload to URL = ' + upload_url)
logger.info(' ')
# Create zeep client from download wsdl
soap_client = Client(wsdl=download_wsdl_url)
login_token = soap_client.service.Login(user_name, password)
logger.info('Login ' + download_url + ' with zeep Successful')
logger.info('Retrieving space info on ' + download_url)
# get the list of spaces using the listspaces ws
array_of_download_spaces = soap_client.service.listSpaces(login_token)
# Logout from Birst
if login_token:
logger.info('Logout zeep ...')
try:
soap_client.service.Logout(login_token)
time.sleep(5)
except Exception as e:
logger.error('Logout zeep failed')
MAX_INPUT_LINES = 100
# setup tkinter
root = tk.Tk()
root.withdraw()
# get the file path from the user
input_path = filedialog.askopenfilename(title="Select File for VAT-ID check",
filetypes=[("text files", ".txt")])
# if file dialog canceled, quit
if not input_path:
print("No file was chosen. Closing the program.")
quit()
# setting up the wsdl
print("Setting up WSDL Client")
client = Client(wsdl="http://ec.europa.eu/taxation_customs/vies/"
"checkVatService.wsdl")
# create output path in the same folder as input_path
output_path = f"{os.path.split(input_path)[0]}/vatcheck_output.txt"
# creating a results file
with open(output_path, "w") as write_file:
# opening the check file (has to be one ID per line)
with open(input_path, "r") as read_file:
# checking amount of lines in the file and preserve to much lines
lines = read_file.readlines()
if len(lines) > MAX_INPUT_LINES:
print(f"Input file is too long. Maximum lines: {MAX_INPUT_LINES}")
quit()
print("Checking the VAT-IDs...")
def connect(self):
self.client = Client(self.mantis_soap_url)
self.version = self.request_version()
def request_apple_pay_authorization(self, basket, billing_address,
payment_token):
"""
Authorizes an Apple Pay payment.
For details on the process, see the CyberSource Simple Order API documentation at
https://www.cybersource.com/developers/integration_methods/apple_pay/.
Args:
basket (Basket)
billing_address (BillingAddress)
payment_token (dict)
Returns:
HandledProcessorResponse
Raises:
GatewayError
"""
try:
client = Client(self.soap_api_url,
wsse=UsernameToken(self.merchant_id,
self.transaction_key))
card_type = APPLE_PAY_CYBERSOURCE_CARD_TYPE_MAP[
payment_token['paymentMethod']['network'].lower()]
bill_to = {
'firstName': billing_address.first_name,
'lastName': billing_address.last_name,
'street1': billing_address.line1,
'street2': billing_address.line2,
'city': billing_address.line4,
'state': billing_address.state,
'postalCode': billing_address.postcode,
'country': billing_address.country.iso_3166_1_a2,
'email': basket.owner.email,
}
purchase_totals = {
'currency': basket.currency,
'grandTotalAmount': str(basket.total_incl_tax),
}
encrypted_payment = {
'descriptor':
'RklEPUNPTU1PTi5BUFBMRS5JTkFQUC5QQVlNRU5U',
'data':
base64.b64encode(
json.dumps(payment_token['paymentData']).encode('utf-8')),
'encoding':
'Base64',
}
card = {
'cardType': card_type,
}
auth_service = {
'run': 'true',
}
capture_service = {
'run': 'true',
}
# Enable Export Compliance for SDN validation, amongst other checks.
# See https://www.cybersource.com/products/fraud_management/export_compliance/
export_service = {
'run': 'true',
}
item = [{
'id': index,
'productCode': line.product.get_product_class().slug,
'productName': clean_field_value(line.product.title),
'quantity': line.quantity,
'productSKU': line.stockrecord.partner_sku,
'taxAmount': str(line.line_tax),
'unitPrice': str(line.unit_price_incl_tax),
} for index, line in enumerate(basket.all_lines())]
response = client.service.runTransaction(
merchantID=self.merchant_id,
merchantReferenceCode=basket.order_number,
billTo=bill_to,
purchaseTotals=purchase_totals,
encryptedPayment=encrypted_payment,
card=card,
ccAuthService=auth_service,
ccCaptureService=capture_service,
exportService=export_service,
paymentSolution='001',
item=item,
)
except:
msg = 'An error occurred while authorizing an Apple Pay (via CyberSource) for basket [{}]'.format(
basket.id)
logger.exception(msg)
raise GatewayError(msg)
request_id = response.requestID
ppr = self.record_processor_response(serialize_object(response),
transaction_id=request_id,
basket=basket)
if response.decision == 'ACCEPT':
currency = basket.currency
total = basket.total_incl_tax
transaction_id = request_id
return HandledProcessorResponse(
transaction_id=transaction_id,
total=total,
currency=currency,
card_number='Apple Pay',
card_type=CYBERSOURCE_CARD_TYPE_MAP.get(card_type))
msg = (
'CyberSource rejected an Apple Pay authorization request for basket [{basket_id}]. '
'Complete response has been recorded in entry [{response_id}]')
msg = msg.format(basket_id=basket.id, response_id=ppr.id)
logger.warning(msg)
raise GatewayError(msg)
parser.add_argument("--pdf", help="Le fichier pdf a signer, chemin absolue")
parser.add_argument("--wsdl", help="url vers SignServer")
parser.add_argument("--password", help="mot de passe de pdf s'il est protégé")
args = parser.parse_args()
if [args.password]:
password = args.password
else:
password = ""
worker = "PDFSigner"
with open(args.pdf, "rb") as file:
data = file.read()
client = Client(wsdl=args.wsdl)
metadata_type = client.get_type('ns0:metadata')
metadata = metadata_type(password, 'pdfPassword')
result = client.service.processData(worker, metadata, data)
print("Archive ID: ", result.archiveId)
print("Metadata :", result.metadata)
print("Request ID ", result.requestId)
print("Signer's Certificates", result.signerCertificate.hex())
file = open("out.pdf", "wb")
file.write(result.data)
file.close()
import logging
logger = logging.getLogger()
logging.getLogger('zeep').setLevel(logging.WARNING)
logging.getLogger('urllib3').setLevel(logging.WARNING)
handler = logging.FileHandler('./twinfield.log')
formatter = logging.Formatter(
'%(asctime)s %(name)-12s %(levelname)-8s %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)
#setup connection to Twinfields, provide credentials and receive cluster:
sessionlogin = r'https://login.twinfield.com/webservices/session.asmx?wsdl'
login = Client(sessionlogin)
auth = login.service.Logon(authentication.username, authentication.password,
authentication.organisation)
auth_header = auth['header']['Header']
cluster = auth['body']['cluster']
#Use cluster to create a session:
url_session = cluster + r'/webservices/session.asmx?wsdl'
session = Client(url_session)
#Select a company for the session:
session.service.SelectCompany('NLA000311',
from zeep import Client
from zeep.cache import SqliteCache
from zeep.transports import Transport
from hashlib import sha1 as SHA1
from python_netsuite.api.common.utils import get_next_soap_app
import time
import urllib.parse
import hmac
import oauth2 as oauth
import ns_config
import base64
import itertools
cache = SqliteCache(timeout=606024 * 365)
transport = Transport(cache=cache)
client = Client(ns_config.WSDL_URL, transport=transport)
applications = itertools.cycle(ns_config.NS_APPS)
def hmac_sha1(key, data):
hashed = hmac.new(bytes(key, 'utf-8'), bytes(data, 'utf-8'), SHA1)
return base64.b64encode(hashed.digest())
def generate_signature(account_id, consumer_key, consumer_secret, token_key,
token_secret, nonce, timestamp):
# create base string
basestring = urllib.parse.quote(account_id) + "&" +\
urllib.parse.quote(consumer_key) + "&" +\
urllib.parse.quote(token_key) + "&" +\
from zeep import Client
url = "http://pelon1.lospelones.me:9090/ws/urls?wsdl"
client = Client(url)
print ("Introduzca 1 para listar urls, 2 para crear url y 3 para consultar urls publicadas por un usuario")
opcion = raw_input()
if opcion == "1":
# Listar urls
urls = client.service.getAllUrls()
print (urls)
if opcion == "2":
print ("Digite id de usuario: ")
id = raw_input()
print ("Digite la url: ")
url = raw_input()
link = client.service.addUrl(url, id)
print (link)
if opcion == "3":
print ("Digite id de usuario: ")
id = raw_input()
urls = client.service.getUrls(id)
print (urls)
# along with this program. If not, see <https://www.gnu.org/licenses/>.
#
from zeep import Client
from zeep import xsd
from zeep.plugins import HistoryPlugin
LDB_TOKEN = 'cba8b56f-eac7-44cc-9df7-9b615eb5b0e9'
WSDL = 'http://lite.realtime.nationalrail.co.uk/OpenLDBWS/wsdl.aspx?ver=2017-10-01'
if LDB_TOKEN == '':
raise Exception("Please configure your OpenLDBWS token in getDepartureBoardExample!")
history = HistoryPlugin()
client = Client(wsdl=WSDL, plugins=[history])
header = xsd.Element(
'{http://thalesgroup.com/RTTI/2013-11-28/Token/types}AccessToken',
xsd.ComplexType([
xsd.Element(
'{http://thalesgroup.com/RTTI/2013-11-28/Token/types}TokenValue',
xsd.String()),
])
)
header_value = header(TokenValue=LDB_TOKEN)
res = client.service.GetDepartureBoard(numRows=10, crs='ACT', _soapheaders=[header_value])
print("Trains at " + res.locationName)
print("===============================================================================")
"8", "DataTraveler", "Pen Drive Kingston DataTraveler USB 3.0 32GB",
"Periferico", "DT100G3", "Kingston", "38.71", "20"
]]
lista = lista + [[
"9", "Calculadora Vinik",
"Calculadora Científica Vinik 10 + 2 Dígitos 240 Funções CC20 - 26096 Preta",
"Eletronico", "26096", "Vinik", "18.71", "30"
]]
lista = lista + [[
"10", "SSD WD",
"SSD WD Green, 240GB, SATA, Leitura 545MB / s, Gravação 465MB / s", "SSD",
"WDS240G2G0A", "Western Digital", "246.94", "7"
]]
#
client = Client(wsdl='http://localhost:54202/WebService.asmx?wsdl')
for i in lista:
cadastroDeProduto = ('{"id":' + str(i[0]) + ', "nome":"' + str(i[1]) +
'", "descricao":"' + str(i[2]) + '", "categoria":"' +
str(i[3]) + '", "modelo":"' + str(i[4]) +
'", "marca":"' + str(i[5]) + '", "valor":' +
str(i[6]) + ', "quantidade":' + str(i[7]) + '}')
#print(cadastroDeProduto)
produtoCadastro = json.loads(cadastroDeProduto)
x = client.service.addProdut(cadastroDeProduto)
#print('\n',x,'\n')
#print(produtoCadastro)
#print(lista)
#print(lista)
from zeep import Client
from lxml import rtree
client = Client('http://www.pttor.com/oilPrice.asmx?WSDL')
resoult = client.service.CurrentOilPrice(Language="en")
root = etree.formstring(result)
n = len(root)
name = ['none']
price = [0]
y = 1
while y == 1:
print(
'################################################################################'
)
print(
'# #'
)
print(
'# #'
)
print(
'# #'
)
print(
'# #'
)
print(
'# #'
)
print(
def create_certificate(self, csr, issuer_options):
"""
Creates a Verisign certificate.
:param csr:
:param issuer_options:
:return: :raise Exception:
"""
authority_obj = issuer_options.get("authority")
authority_options = {}
for option in json.loads(authority_obj.options):
authority_options[option["name"]] = option.get("value")
certificate_profile = authority_options.get("certificateProfile")
end_entity_profile = authority_options.get("endEntityProfile")
issuer_ca = authority_options.get("issuer_ca")
authority_const = issuer_options.get("authority").name.upper()
session = requests.Session()
session.mount('https://', HttpsAdapter())
session.cert = current_app.config.get(
"EJBCA_PEM_PATH_{0}".format(authority_const),
current_app.config.get("EJBCA_PEM_PATH"))
session.verify = current_app.config.get("EJBCA_TRUSTSTORE")
session.hooks = dict(response=log_status_code)
transport = Transport(session=session)
url = current_app.config.get(
"EJBCA_URL") + "/ejbca/ejbcaws/ejbcaws?wsdl"
client = Client(url, transport=transport)
#csr_x509 = x509.load_pem_x509_csr(csr.encode("utf-8"), default_backend())
csr_x509 = load_certificate_request(FILETYPE_PEM, csr)
# get SubjectDN string from CSR
subject_dn = get_subject_dn_string(
csr_x509.get_subject().get_components())
# print("*****DN:" + subject_dn)
subject_alt_names = get_subjectaltname_string(csr)
end_entity_username = issuer_options.get("name")
if end_entity_username is None:
end_entity_username = "******"
# compose userDataVOWS object
user_data_vows_type = client.get_type('ns0:userDataVOWS')
user_data_vows = user_data_vows_type(
username=end_entity_username,
password='******',
clearPwd='false',
subjectDN=subject_dn,
caName=issuer_ca,
certificateProfileName=certificate_profile,
endEntityProfileName=end_entity_profile,
sendNotification='false',
keyRecoverable='false',
status='10',
tokenType='USERGENERATED',
email=None,
subjectAltName=subject_alt_names)
try:
response = client.service.editUser(user_data_vows)
csr_b64 = dump_certificate_request(FILETYPE_PEM, csr_x509)
csr_b64 = csr_b64.decode()
request_data = {
'arg0': end_entity_username,
'arg1': 'foo123',
'arg2': csr_b64,
'arg3': None,
'arg4': 'CERTIFICATE'
}
try:
response = client.service.pkcs10Request(**request_data)
# print(response)
# print(response.data)
cert_data_str = response.data.decode("utf-8")
# print("CERT DATA")
# print(cert_data_str)
#cert_data = base64.b64decode(cert_data_str).decode("utf-8")
cert_data_str.replace('\\n', '\n')
# print("decoded:")
# print(cert_data_str)
# External ID required for revocation
# Generate a random ID
rand_external_id = random.randrange(10**11, 10**12)
external_id = str(rand_external_id)
#reconstruct certificate from json array
pem = "-----BEGIN CERTIFICATE-----\n"
pem += cert_data_str
pem += "\n-----END CERTIFICATE-----"
authority = issuer_options.get("authority").name.upper()
chain = current_app.config.get(
"EJBCA_INTERMEDIATE_{0}".format(authority),
current_app.config.get("EJBCA_INTERMEDIATE"))
return pem, chain, external_id
except zeep.exceptions.Fault as fault:
raise Exception(fault.message)
except zeep.exceptions.Fault as fault:
parsed_fault_detail = client.wsdl.types.deserialize(
fault.detail[0])
# print(len(fault.detail))
# print(parsed_fault_detail)
if hasattr(parsed_fault_detail, 'requestId'):
# print("has details:" + str(parsed_fault_detail.requestId))
request_id = parsed_fault_detail.requestId
return None, None, request_id
else:
raise Exception(fault.message)
def setUpClass(cls):
global client
client = ''
cls.base_uri = config_parser("ConfigData", "calc_ws_uri")
client = Client(cls.base_uri)
def get_certificates(self, options, **kwargs):
certs = []
issuer_dn = self.get_option("issuerdn", options)
source_const = self.get_option("source_const", options)
if source_const is not None:
source_const = source_const.upper()
# print("SOURCE**** " +str(source_const))
session = requests.Session()
session.mount('https://', HttpsAdapter())
session.cert = current_app.config.get(
"EJBCA_PEM_PATH_{0}".format(source_const),
current_app.config.get("EJBCA_PEM_PATH"))
session.verify = current_app.config.get("EJBCA_TRUSTSTORE")
session.hooks = dict(response=log_status_code)
source_expire_days = current_app.config.get("EJBCA_SOURCE_EXPIRE_DAYS",
7300)
source_max_results = current_app.config.get("EJBCA_SOURCE_MAX_RESULTS",
100000)
request_data = {
'arg0': source_expire_days,
'arg1': issuer_dn,
'arg2': source_max_results,
}
transport = Transport(session=session)
url = current_app.config.get(
"EJBCA_URL") + "/ejbca/ejbcaws/ejbcaws?wsdl"
client = Client(url, transport=transport)
response = client.service.getCertificatesByExpirationTimeAndIssuer(
**request_data)
num_certs = len(response)
for x in range(num_certs):
encoded_cert = response[x].certificateData
decoded_cert = encoded_cert.decode('utf-8')
pem = "-----BEGIN CERTIFICATE-----\n"
pem += decoded_cert
pem += "\n-----END CERTIFICATE-----"
x509 = load_certificate(FILETYPE_PEM, pem)
# get SubjectDN string from CSR
serial = x509.get_serial_number()
# External ID required for revocation
# Generate a random ID
rand_external_id = random.randrange(10**11, 10**12)
external_id = str(rand_external_id)
chain = '{}\n{}'.format(
current_app.config.get('EJBCA_INTERMEDIATE', '').strip(),
current_app.config.get('EJBCA_ROOT', '').strip())
cert = {
"body": "\n".join(str(pem).splitlines()),
"serial": serial,
"external_id": external_id,
"chain": chain,
}
certs.append(cert)
return certs
def get(self, request, format=None, service=None, business_id=None):
required_settings = ('VIRRE_API_URL', 'VIRRE_USERNAME',
'VIRRE_PASSWORD')
if not are_settings_available(required_settings):
return HttpResponseServerError(
"Please set all required settings: {}".format(
', '.join(required_settings)))
known_services = {
'company_extended': 'CompanyExtendedInfo',
'company_represent': 'CompanyRepresentInfo',
'company_notice': 'CompanyNoticeInfo',
'trade_register_entry': 'TradeRegisterEntryInfo',
'statute': 'StatuteInfoV2',
}
known_pdf_services = {
'trade_register_entry': {
'response_key': 'tradeRegisterEntryInfoResponseDetails',
'pdf_key': 'extract',
},
'statute': {
'response_key': 'statuteInfoResponseTypeDetails',
'pdf_key': 'statute',
}
}
if service not in known_services.keys():
raise APIException(_('service parameter is not valid'))
session = Session()
session.auth = HTTPBasicAuth(settings.VIRRE_USERNAME,
settings.VIRRE_PASSWORD)
soap_settings = Settings(strict=False)
wsdl_service = '{}Service'.format(known_services[service])
client = Client(
'{host}/IDSServices11/{wsdl_service}?wsdl'.format(
host=settings.VIRRE_API_URL, wsdl_service=wsdl_service),
transport=Transport(session=session),
settings=soap_settings,
)
data = {
"userId": settings.VIRRE_USERNAME,
"businessId": business_id,
}
action = 'get{}'.format(known_services[service])
result = getattr(client.service, action)(**data)
if service in known_pdf_services.keys():
response_key = known_pdf_services[service]['response_key']
pdf_key = known_pdf_services[service]['pdf_key']
if response_key not in result:
raise APIException(_('business id is invalid'))
try:
response = HttpResponse(result[response_key][pdf_key],
content_type='application/pdf')
except KeyError:
raise APIException(_('File not available'))
response['Content-Disposition'] = (
'attachment; filename={}_{}.pdf'.format(service, business_id))
return response
else:
return JsonResponse(serialize_object(result))
# session.verify = CERT
session.auth = HTTPBasicAuth(os.getenv('AXL_USERNAME'),
os.getenv('AXL_PASSWORD'))
transport = Transport(session=session, timeout=10)
# strict=False is not always necessary, but it allows Zeep to parse imperfect XML
settings = Settings(strict=False, xml_huge_tree=True)
# If debug output is requested, add the MyLoggingPlugin callback
plugin = [MyLoggingPlugin()] if DEBUG else []
# Create the Zeep client with the specified settings
client = Client(WSDL_FILE,
settings=settings,
transport=transport,
plugins=plugin)
# Create the Zeep service binding to AXL at the specified CUCM
service = client.create_service(
'{http://www.cisco.com/AXLAPIService/}AXLAPIBinding',
f'https://{os.getenv("CUCM_ADDRESS")}:8443/axl/')
# Make the initial listChange request.
# No <startChange> or <objectList> provided so we get the
# first/last/queue baseline data
# Execute the listChange request
try:
resp = service.listChange()
# To enabled SSL cert checking (production)
# place the CUCM Tomcat cert .pem file in the root of the project
# and uncomment the two lines below
# CERT = 'changeme.pem'
# session.verify = CERT
session.auth = HTTPBasicAuth(USERNAME, PASSWD)
transport = Transport(session=session, timeout=10)
# strict=False is not always necessary, but it allows zeep to parse imperfect XML
settings = Settings(strict=False, xml_huge_tree=True)
client = Client(WSDL_FILE,
settings=settings,
transport=transport,
plugins=[MyLoggingPlugin()])
service = client.create_service(
"{http://www.cisco.com/AXLAPIService/}AXLAPIBinding",
'https://{}:8443/axl/'.format(CUCM_LOCATION))
device_pool_data = {'name': DEVICE_POOL_NAME, 'localRouteGroup': []}
device_pool_data['localRouteGroup'].append({
'name': 'Standard Local Route Group',
'value': STANDARD_ROUTE_GROUP_NAME
})
device_pool_data['localRouteGroup'].append({
'name': 'test Local Route Group',
'value': TEST_ROUTE_GROUP_NAME
#!/usr/bin/env python
# encoding: utf-8
import xml.etree.ElementTree as et
from zeep import Client
# pip install zeep
book = 'John'
chapter = 7
client = Client('http://www.webservicex.net/BibleWebservice.asmx?WSDL')
result = client.service.GetBibleWordsByBookTitleAndChapter(book, chapter)
xml_response = et.fromstring(result)
verses = xml_response.findall('.//Table')
for verse in verses:
number = verse.find('Verse').text
text = verse.find('BibleWords').text
print('{} {}:{}\t{}'.format(book, chapter, number, text))
from zeep import Client
# Username and license code
LOGIN = '******'
LICENSE = '2C556A14-C5CC-4DE9-A1B5-018C276C98B1'
# Service URL
client = Client(
'http://www.ocrwebservice.com/services/OCRWebService.asmx?WSDL')
FilePath = "img/efroimson-geniusgenetic-p10-part.png"
with open(FilePath, 'rb') as image_file:
image_data = image_file.read()
InputImage = {
'fileName': 'efroimson-geniusgenetic-p10-part.png',
'fileData': image_data,
}
# Specify coordinates for zones (only from these zone text will be extracted)
# To extract text from all page you do not need setup any zones
ocrZones = {
'OCRWSZone': [{
'Top': 0,
'Left': 0,
'Height': 900,
'Width': 1600,
'ZoneType': 0
}, {
'Top': 500,
'Left': 1000,
['application/soap+xml', 'charset=utf-8'] +
(['action="%s"' %
operation.soapaction] if operation.soapaction is not None else []))
Soap12Binding._set_http_headers = _set_http_headers
def _set_http_headers(self, serialized, operation):
serialized.headers['Content-Type'] = '; '.join(
['application/soap+xml', 'charset=utf-8'] +
(['action="%s"' %
operation.soapaction] if operation.soapaction is not None else []))
soap = Client('config/drv.wsdl')
query = soap.bind('GetPSService', 'PSPort')
keys = [
'PS_Area', 'PS_CommissionAdr', 'PS_CommissionLocation', 'PS_Desc',
'PS_GeoDVK', 'PS_GeoData', 'PS_GeoPG', 'PS_Num', 'PS_PlaceVotingAdr',
'PS_PlaceVotingLocation', 'PS_Size', 'PS_Type', 'Region_Id'
]
geokeys = {'PS_GeoDVK', 'PS_GeoData', 'PS_GeoPG'}
def mapper(entry, key, geokeys):
"""
Extract the necessary output from a data record from the server response
:param entry: data record (one polling station)
def __init__(self):
session = Session()
session.auth = HTTPBasicAuth(client_id, client_secret)
self.client = Client(api_url, transport=Transport(session=session))
from zeep.wsse.username import UsernameToken
app = Flask(__name__)
import pyodbc
server = 'dbserveranasight.database.windows.net'
database = 'warehouse'
username = '******'
password = '******'
cnxn = pyodbc.connect('DRIVER={ODBC Driver 17 for SQL Server};DRIVER={SQL Server};SERVER='+server+';DATABASE='+database+';UID='+username+';PWD='+ password)
cursor = cnxn.cursor()
session = Session()
session.auth = HTTPBasicAuth('veten1', 'bshyWs')
client = Client('https://sthservices.ozsoft.com.au/ANS_API/VT_API.asmx?wsdl',
transport=Transport(session=session))
# print(client.service.ValidateClient('veten1', 'bshyWs'))
# sys.exit()
# print(client.service.GetDivisions('\'\'7%.8"!2()(36\'0=;<4'))
# print(client.service.GetClientAVDetails("&-7%(9,!3((+;6'2?344",'VT00152'))
# sys.exit()
tokenContainer = []
# def get_token():
token = client.service.ValidateClient('veten1', 'bshyWs').Token
tokenContainer.clear()
tokenContainer.append(token.encode('ascii'))
#Get Locations
@app.route("/GetLocations",methods = ['POST', 'GET'])
def connect(self):
self.client = Client('{}'.format(self.wsdl_url))
self.login = self.client.service.login(self.username, self.password)
# TODO: non torna più OK bensì una stringa b64, da aggiornare qui
assert self.login.DST
return self.login.DST
