def read_multiple_soap_records(self,
soap_object,
filter_field_string,
filter_type_string,
filter_data=[{
'property': '',
'value': ''
}]):
session = Session()
session.auth = HTTPBasicAuth(self.nav_user, self.nav_password)
soap_service_url = self.nav_soap_service + self.nav_company + "/Page/" + soap_object
client = Client(soap_service_url,
transport=Transport(session=session,
cache=SqliteCache()))
filter_field = client.get_type(f"ns0:{filter_field_string}")
filter_type = client.get_type(f"ns0:{filter_type_string}")
# Build the search filters from the filter_data
# Notice the default values for the filter_data arguement are empty
# so we bring back all of the records as a default
filters = [
filter_type(filter_field(item['property']), item['value'])
for item in filter_data
]
# setService tells the service how many records to return
soap_response = client.service.ReadMultiple(filter=filters, setSize=0)
serialized_response = serialize_object(soap_response)
return serialized_response
def __init__(self,
username,
password,
server_ip,
service,
tls_verify=True):
dir = os.path.dirname(__file__)
if (service == 'HardwareInformation'):
wsdl = os.path.join(dir, 'paws/hardware_information_service.wsdl')
binding = "{http://services.api.platform.vos.cisco.com}HardwareInformationServiceSoap11Binding"
endpoint = "https://{0}:8443/platform-services/services/HardwareInformationService.HardwareInformationServiceHttpsSoap11Endpoint/".format(
server_ip)
elif (service == 'ClusterNodesService'):
wsdl = 'https://{0}:8443/platform-services/services/ClusterNodesService?wsdl'.format(
server_ip)
binding = "{http://services.api.platform.vos.cisco.com}ClusterNodesServiceHttpBinding"
endpoint = "https://{0}:8443/platform-services/services/ClusterNodesService.ClusterNodesServiceHttpsEndpoint/".format(
server_ip)
self.session = Session()
self.session.auth = HTTPBasicAuth(username, password)
self.session.verify = tls_verify
self.cache = SqliteCache(path='/tmp/sqlite_logcollection.db',
timeout=60)
self.client = Client(wsdl=wsdl,
transport=Transport(cache=self.cache,
session=self.session))
self.service = self.client.create_service(binding, endpoint)
enable_logging()
def main():
transport = Transport(cache=SqliteCache())
client = Client('http://localhost:8000/?wsdl', transport=transport)
print('#-=-# Biblioteca Musical #-=-#')
while True:
print('\nMENU:')
print('1) Inserir album')
print('2) Listar albuns')
print('0) Sair')
op = str(input('> '))
if op.strip() == '1':
#album = novoAlbum()
print client.service.addAlbumInData()
elif op.strip() == '2':
ls = client.service.getAlbuns()
for i in range(len(ls)):
print '====================================='
print 'ID:', ls[i]["_id"]
print 'Titulo:', ls[i]["titulo"]
print 'Artista:', ls[i]["artista"]
print 'Gravadora:', ls[i]["gravadora"]
print 'Ano:', ls[i]["ano"]
elif op.strip() == '0':
break
else:
print('Opcao invalida! insira novamente.')
def __init__(self, username, password, cucm, cucm_version):
cwd = os.path.dirname(os.path.abspath(__file__))
if os.name == "posix":
wsdl = Path(f"{cwd}/schema/{cucm_version}/AXLAPI.wsdl").as_uri()
else:
wsdl = str(
Path(f"{cwd}/schema/{cucm_version}/AXLAPI.wsdl").absolute())
session = Session()
session.verify = False
session.auth = HTTPBasicAuth(username, password)
settings = Settings(strict=False,
xml_huge_tree=True,
xsd_ignore_sequence_order=True)
transport = Transport(session=session, timeout=10, cache=SqliteCache())
axl_client = Client(wsdl, settings=settings, transport=transport)
self.wsdl = wsdl
self.username = username
self.password = password
self.wsdl = wsdl
self.cucm = cucm
self.cucm_version = cucm_version
self.UUID_PATTERN = re.compile(
r"^[\da-f]{8}-([\da-f]{4}-){3}[\da-f]{12}$", re.IGNORECASE)
self.client = axl_client.create_service(
"{http://www.cisco.com/AXLAPIService/}AXLAPIBinding",
f"https://{cucm}:8443/axl/",
)
def sql_getmodel():
path = Path('C:\\shared\\API\\credentials')
wsdl = 'file://C://shared//API//axlsqltoolkit//schema//11.5//AXLAPI.wsdl'
platform = 'CUCM'
role = 'r'
urllib3.disable_warnings(InsecureRequestWarning)
server = path / REGION / platform / ('fqdn' + '.txt')
binding_name = '{http://www.cisco.com/AXLAPIService/}AXLAPIBinding'
address = 'https://{fqdn}:8443/axl/'.format(fqdn=read(server)[0])
session = Session()
session.verify = False
session.auth = HTTPBasicAuth(read(file(path, platform, role)[0])[0], crypto(file(path, platform, role)[1], file(path, platform, role)[2]))
transport = Transport(cache=SqliteCache(), session=session, timeout=60)
client = Client(wsdl=wsdl, transport=transport)
axl = client.create_service(binding_name, address)
sql_statement = \
"SELECT " \
"name, enum " \
"FROM " \
"typemodel "
axl_resp = axl.executeSQLQuery(sql=sql_statement)
table = [OrderedDict((element.tag, element.text) for element in row) for row in
serialize_object(axl_resp)["return"]["row"]]
locale = [(items['name'], items['enum']) for items in table]
dict_variable = {enum: name for (name, enum) in locale}
return dict_variable
def main():
path = Path('C:\\shared\\API\\credentials')
wsdl = 'file://C://shared//API//axlsqltoolkit//schema//11.5//AXLAPI.wsdl'
platform = 'CUCM'
role = 'rwx'
urllib3.disable_warnings(InsecureRequestWarning)
server = path / REGION / platform / ('fqdn' + '.txt')
binding_name = '{http://www.cisco.com/AXLAPIService/}AXLAPIBinding'
address = 'https://{fqdn}:8443/axl/'.format(fqdn=read(server)[0])
session = Session()
session.verify = False
session.auth = HTTPBasicAuth(
read(file(path, platform, role)[0])[0],
crypto(file(path, platform, role)[1],
file(path, platform, role)[2]))
transport = Transport(cache=SqliteCache(), session=session, timeout=60)
client = Client(wsdl=wsdl, transport=transport)
axl = client.create_service(binding_name, address)
for items in listCSS(axl, CSS)['return']['css']:
print('\n####################Before adding the partition')
print(getCSS(axl, items['name'])['return']['css']['name'])
print(getCSS(axl, items['name'])['return']['css']['clause'])
print('Adding the partition {}'.format(PT))
#addptCSS(axl, items['name'], PT, '0')
#rmptCSS(axl, items['name'], PT, '0')
print('********************After adding the partition {}'.format(PT))
print(getCSS(axl, items['name'])['return']['css']['name'])
print(getCSS(axl, items['name'])['return']['css']['clause'])
def connector(CUCM_IP,
AXL_Username,
AXL_Password,
CUCM_Version='11.5',
debug=False):
"""Returns a standalone connector. No class methods. For testing purposes"""
WSDL = f'schema/{CUCM_Version}/AXLAPI.wsdl'
if ('9.' in CUCM_Version):
urllib3.disable_warnings()
urllib3.util.ssl_.DEFAULT_CIPHERS += 'HIGH:!DH:!aNULL'
WSDL = 'schema/9.1/AXLAPI.wsdl'
try:
urllib3.contrib.pyopenssl.DEFAULT_SSL_CIPHER_LIST += 'HIGH:!DH:!aNULL'
except AttributeError:
pass
else:
urllib3.disable_warnings(InsecureRequestWarning)
BINDING_NAME = "{http://www.cisco.com/AXLAPIService/}AXLAPIBinding"
ADDRESS = "https://{ip}:8443/axl/".format(ip=CUCM_IP)
session = Session()
session.verify = False
session.auth = HTTPBasicAuth(AXL_Username, AXL_Password)
transport = Transport(cache=SqliteCache(), session=session, timeout=10)
if debug:
client = Client(wsdl=WSDL,
transport=transport,
plugins=[ZeepDebugPlugin()])
else:
client = Client(wsdl=WSDL, transport=transport)
return client.create_service(BINDING_NAME, ADDRESS)
def setupserviceconnection(self, ip):
#print (threading.currentThread().getName())
## setup Session
session = Session()
session.verify = False
session.auth = HTTPBasicAuth(self.axluser, self.axlpass)
transport = CustomTransport(cache=SqliteCache(),
session=session,
timeout=60)
history = HistoryPlugin()
# import required WSDL's
servicewsdl = 'file://' + os.getcwd() + '//Files//ServiceWSDL.wsdl'
SERVICE_BINDING_NAME = "{http://cisco.com/ccm/serviceability/soap/ControlCenterServices/}ControlCenterServicesBinding"
SERVICE_ADDR = "https://" + ip + ":8443/controlcenterservice/services/ControlCenterServicesPort"
try:
print("Fetching Services Status from " + ip)
client = Client(wsdl=servicewsdl,
transport=transport,
plugins=[history])
Servicexl = client.create_service(SERVICE_BINDING_NAME,
SERVICE_ADDR)
result = Servicexl.soapGetServiceStatus([''])
return result
except (Fault, Exception) as error:
print(error)
return None
def __init__(self, username, password, cucm, cucm_version):
"""
:param username: ris username
:param password: ris password
:param cucm: UCM IP address
:param cucm_version: UCM version
example usage:
>>> from ris import RIS
>>> ucm = RIS('ris_user', 'ris_pass', '192.168.200.10', '11.5')
"""
wsdl = 'https://' + cucm + ':8443/realtimeservice2/services/RISService70?wsdl'
session = Session()
session.verify = False
session.auth = HTTPBasicAuth(username, password)
settings = Settings(strict=False, xml_huge_tree=True)
transport = Transport(session=session, timeout=10, cache=SqliteCache())
ris_client = Client(wsdl, settings=settings, transport=transport)
self.wsdl = wsdl
self.username = username
self.password = password
self.cucm = cucm
self.cucm_version = cucm_version
self.UUID_PATTERN = re.compile(
r'^[\da-f]{8}-([\da-f]{4}-){3}[\da-f]{12}$', re.IGNORECASE)
self.client = ris_client.create_service(
"{http://schemas.cisco.com/ast/soap}RisBinding",
f"https://{cucm}:8443/realtimeservice2/services/RISService70")
def main(api_key, mastr_number, limit, step, start, filter_type, units_file):
wsdl = 'https://www.marktstammdatenregister.de/MaStRAPI/wsdl/mastr.wsdl'
transport = Transport(cache=SqliteCache())
settings = Settings(strict=False, xml_huge_tree=True)
client = Client(wsdl=wsdl, transport=transport, settings=settings)
client_bind = client.bind('Marktstammdatenregister','Anlage')
writer = csv.DictWriter(units_file, field_names)
writer.writeheader()
total = total_filtered = 0
logging.getLogger('zeep').setLevel(logging.CRITICAL)
for current_step in range(start, math.ceil(limit/step)):
try:
try:
c = client_bind.GetListeAlleEinheiten(apiKey=api_key, marktakteurMastrNummer=mastr_number,
startAb=step*current_step, limit=step)
respond = serialize_object(c)
except Fault as e:
print('Probably reached the end, saving file: ' + e.message)
break
filtered = [dict(x) for x in respond['Einheiten'] if x['Einheittyp'] == filter_type]
print(f'[{current_step}] Fetched {len(respond["Einheiten"])} entries out of which {len(filtered)} was used')
writer.writerows(filtered)
total += len(respond["Einheiten"])
total_filtered += len(filtered)
except KeyboardInterrupt:
print('Aborting fetching!')
break
print(f'Fetched in total {total} entries which {total_filtered} was used.')
def __init__(self, username, password, server_ip, version='12.5', tls_verify=True, timeout=10, logging_enabled=False):
self.session = Session()
self.session.auth = HTTPBasicAuth(username, password)
self.session.verify = tls_verify
filedir = os.path.dirname(__file__)
self.cache = SqliteCache(path=Path(tempfile.gettempdir()+'/sqlite_{0}.db'.format(server_ip)), timeout=60)
if version == '12.5':
self.wsdl = os.path.join(filedir, 'schema/12.5/AXLAPI.wsdl')
elif version == '12.0':
self.wsdl = os.path.join(filedir, 'schema/12.0/AXLAPI.wsdl')
elif version == '11.5':
self.wsdl = os.path.join(filedir, 'schema/11.5/AXLAPI.wsdl')
elif version == '11.0':
self.wsdl = os.path.join(filedir, 'schema/11.0/AXLAPI.wsdl')
elif version == '10.5':
self.wsdl = os.path.join(filedir, 'schema/10.5/AXLAPI.wsdl')
elif version == '10.0':
self.wsdl = os.path.join(filedir, 'schema/10.0/AXLAPI.wsdl')
else:
self.wsdl = os.path.join(filedir, 'schema/12.5/AXLAPI.wsdl')
self.client = Client(wsdl=self.wsdl, plugins=[self.history], transport=Transport(timeout=timeout,
operation_timeout=timeout,
cache=self.cache,
session=self.session))
self.service = self.client.create_service("{http://www.cisco.com/AXLAPIService/}AXLAPIBinding",
"https://{0}:8443/axl/".format(server_ip))
if logging_enabled:
enable_logging()
def __init__(
self,
client_id: str,
client_secret: str,
base_url: str,
settings: Optional[Settings] = None,
storage_url: Optional[str] = None,
timeout: Optional[int] = 60,
) -> None:
"""Init function."""
self.base_url = base_url
self.client_id = client_id
self.client_secret = client_secret
self._cache = []
self._settings = settings
self._session = Session()
self._session.auth = HTTPBasicAuth(self.client_id, self.client_secret)
self.storage_url = storage_url
cache = None
if self.storage_url:
cache = SqliteCache(path=storage_url, timeout=timeout)
try:
self._client = Client(
self.base_url,
transport=Transport(session=self._session, cache=cache),
settings=self._settings,
)
except requests.exceptions.HTTPError as e:
if e.response.status_code == 401:
raise Unauthorized(e)
raise BadRequest(e)
except requests.exceptions.ConnectionError:
raise ResourceDoesNotExist()
def populate_transport():
transport = None
try:
session = None
if api.config.sslVerificationPath:
session = Session()
session.verify = api.config.sslVerificationPath
if api.config.httpAuthUser:
user = api.config.httpAuthUser
password = api.config.httpAuthPassword
if not session:
session = Session()
session.auth = HTTPBasicAuth(user, password)
session_timeout = None
if api.config.sessionTimeout:
session_timeout = int(api.config.sessionTimeout)
cache_path = None
if api.config.cachePath:
cache_path = api.config.cachePath
if session or session_timeout or cache_path:
transport = Transport(
cache=SqliteCache(path=cache_path) if cache_path else None,
timeout=session_timeout if session_timeout else 300,
session=session)
except Exception as excp:
api.send("debug", str(excp))
return transport
def __init__(self, url, username, password):
self.IdToPropType = dict()
self.IdtoObjectType = dict()
self.PropIdToDict = dict()
self.RNEFnameToPropType = dict()
from requests.auth import HTTPBasicAuth
from requests import Session
from zeep.cache import SqliteCache
from zeep.transports import Transport
session = Session()
session.auth = HTTPBasicAuth(username, password)
transport = Transport(cache=SqliteCache(), session=session)
from zeep import Client, Settings
settings = Settings(strict=False, xml_huge_tree=True)
#settings = zeep.Settings(extra_http_headers={'Authorization': 'Bearer ' + token})
self.logger = configure_logging(logging.getLogger(__name__))
try:
self.SOAPclient = Client(wsdl=url,
transport=transport,
settings=settings)
self.__load_model()
print('Connected to Resnet API server:\n%s as %s' %
(url, username))
except Exception as error:
self.logger.error(
"Pathway Studio server connection failed: {error}".format(
error=error))
raise ConnectionError(
f"Server connection failed. Wrong or inaccessible url: {url}"
) from None
def __init__(self,
cache=NotSet,
timeout=300,
operation_timeout=None,
verify=True,
http_auth=None):
"""The transport object handles all communication to the SOAP server.
:param cache: The cache object to be used to cache GET requests
:param timeout: The timeout for loading wsdl and xsd documents.
:param operation_timeout: The timeout for operations (POST/GET). By
default this is None (no timeout).
:param verify: Boolean to indicate if the SSL certificate needs to be
verified.
:param http_auth: HTTP authentication, passed to requests.
"""
self.cache = SqliteCache() if cache is NotSet else cache
self.load_timeout = timeout
self.operation_timeout = None
self.verify = verify
self.http_auth = http_auth
self.logger = logging.getLogger(__name__)
self.session = self.create_session()
self.session.verify = verify
self.session.auth = http_auth
self.session.headers['User-Agent'] = ('Zeep/%s (www.python-zeep.org)' %
(get_version()))
def main():
path = Path('C:\\shared\\API\\credentials')
wsdl = 'file://C://shared//API//axlsqltoolkit//schema//11.5//AXLAPI.wsdl'
platform = 'CUCM'
role = 'r'
urllib3.disable_warnings(InsecureRequestWarning)
server = path / REGION / platform / ('fqdn' + '.txt')
binding_name = '{http://www.cisco.com/AXLAPIService/}AXLAPIBinding'
address = 'https://{fqdn}:8443/axl/'.format(fqdn=read(server)[0])
session = Session()
session.verify = False
session.auth = HTTPBasicAuth(
read(file(path, platform, role)[0])[0],
crypto(file(path, platform, role)[1],
file(path, platform, role)[2]))
transport = Transport(cache=SqliteCache(), session=session, timeout=60)
client = Client(wsdl=wsdl, transport=transport)
axl = client.create_service(binding_name, address)
udps = [
udps['name'] for udps in listudp(axl, UDP)['return']['deviceProfile']
]
phones = [
phones['name'] for phones in listphone(axl, PHONE)['return']['phone']
]
for udp in udps:
if getudp(axl, udp)['return']['deviceProfile']['speeddials'] is None:
pass
else:
sddirn = [
sddirn['dirn'] for sddirn in getudp(axl, udp)['return']
['deviceProfile']['speeddials']['speeddial']
]
upddesc = getudp(axl,
udp)['return']['deviceProfile']['description']
for sd in sddirn:
if sd == RMSD:
print('User Profile Name: ' + udp + ' with description ' +
upddesc + ' has the speed dial ' + RMSD)
else:
pass
for phone in phones:
if getphone(axl, phone)['return']['phone']['speeddials'] is None:
pass
else:
sddirn = [
sddirn['dirn'] for sddirn in getphone(axl, phone)['return']
['phone']['speeddials']['speeddial']
]
phonedesc = getphone(axl, phone)['return']['phone']['description']
for sd in sddirn:
if sd == RMSD:
print('Phone Name: ' + phone + ' with description ' +
phonedesc + ' has the speed dial ' + RMSD)
break
else:
pass
def __init__(self, *args, **kwargs):
# Don't use setdefault since we want to lazily init the Transport cls
from zeep.cache import SqliteCache
kwargs["transport"] = kwargs.get("transport") or Transport(cache=SqliteCache())
super().__init__(*args, **kwargs)
def __init__(self, *args, **kwargs):
# Don't use setdefault since we want to lazily init the Transport cls
from zeep.cache import SqliteCache
kwargs['transport'] = (
kwargs.get('transport') or Transport(cache=SqliteCache()))
super(CachingClient, self).__init__(*args, **kwargs)
def __init__(self,
version=DEFAULT_B2B_VERSION,
service_group="FlightServices",
dataset=DEFAULT_DATASET,
how_to_auth='proxy',
*args,
**kwargs):
self.wsdl = ''
self.service_group = service_group
self.version = version
self.session = Session()
self.available_services = []
self.available_operations = {}
self._default_params_for_queries = {
'requestedFlightFields': [],
'dataset': get_dataset(dataset),
'trafficType': 'LOAD',
'includeProposalFlights': True,
'includeForecastFlights': True,
'sendTime': utils.sendTime(),
}
self.params_for_queries = self._default_params_for_queries
# ------------- certificat ou proxy ? ------------- #
if how_to_auth == 'cert':
# Si authentification par certificat
self.wsdl = f"data/wsdl/{self.version}/{self.service_group}_PREOPS_{self.version}.wsdl"
self.session.cert = (glob.glob("cert/crt.pem")[0],
glob.glob("cert/key.pem")[0])
elif how_to_auth == 'proxy':
# Si authentification via proxy (défaut)
NM_B2B_API_KEY_ID = os.environ.get(
'NM_B2B_API_KEY_ID') # default is None
NM_B2B_API_SECRET = os.environ.get(
'NM_B2B_API_SECRET') # default is None
if not NM_B2B_API_KEY_ID or not NM_B2B_API_SECRET:
print(
f"Impossible de définir un couple clé/pass pour le proxy b2b.\
Vérifiez que NM_B2B_API_KEY_ID et NM_B2B_API_SECRET sont bien définis dans votre environnement."
)
exit(1)
self.wsdl = WSDL_PROXY + self.service_group + "_PREOPS_" + version + ".wsdl"
self.session.auth = HTTPBasicAuth(NM_B2B_API_KEY_ID,
NM_B2B_API_SECRET)
else:
print(
"Le mode d'authentification que vous avez spécifié n'existe pas (pour l'instant : 'cert' ou 'proxy')."
)
exit(1)
# -------------
self.cache = SqliteCache(path='./data/sqlite.db')
self.transport = Transport(session=self.session, cache=self.cache)
self.conf = {'wsdl': self.wsdl, 'transport': self.transport}
self.tmp_data = None
def client_soap(config_file):
logger.debug('Ha entrado en la funcion client_soap()')
csp_cmserver = cspconfigfile['CUCM']['server']
csp_username = cspconfigfile['CUCM']['user']
csp_password = cspconfigfile['CUCM']['pass']
csp_version = cspconfigfile['CUCM']['version']
if platform.system() == 'Windows':
logger.debug('El sistema operativo es: %s' % (platform.system()))
wsdl = 'file://' + os.getcwd().replace ("\\","//") + '//Schema//CUCM//' + csp_version + '//AXLAPI.wsdl'
else:
logger.debug('El sistema operativo es: %s' % (platform.system()))
wsdl = 'file://' + os.getcwd() + '/Schema/CUCM/' + csp_version + '/AXLAPI.wsdl'
csp_location = 'https://' + csp_cmserver + '/axl/'
logger.debug('El valor de csp_cmserver es: %s' % (csp_cmserver))
logger.debug('El valor de csp_username es: %s' % (csp_username))
logger.debug('El valor de csp_version es: %s' % (csp_version))
logger.debug('El valor de csp_location es: %s' % (csp_location))
logger.debug('El valor de wsdl es: %s' % (wsdl))
# history shows http_headers
global history
history = HistoryPlugin()
# The first step is to create a SOAP client session
session = Session()
# We avoid certificate verification by default, but you can uncomment and set
# your certificate here, and comment out the False setting
#session.verify = CERT
session.verify = False
session.auth = HTTPBasicAuth(csp_username, csp_password)
transport = Transport(session=session, timeout=10, cache=SqliteCache())
# strict=False is not always necessary, but it allows zeep to parse imperfect XML
settings = Settings(strict=False, xml_huge_tree=True)
try:
csp_soap_client = Client(wsdl,
settings=settings,
transport=transport,
plugins=[MyLoggingPlugin(),history],
)
service = csp_soap_client.create_service("{http://www.cisco.com/AXLAPIService/}AXLAPIBinding", csp_location)
except:
logger.error('Se ha producido un error al crear el cliente soap')
logger.debug(sys.exc_info())
logger.error(sys.exc_info()[1])
sys.exit()
else:
logger.info('Se ha creado el cliente SOAP.')
return service
def __init__(self, cache=NotSet, timeout=300, verify=True, http_auth=None):
self.cache = SqliteCache() if cache is NotSet else cache
self.timeout = timeout
self.verify = verify
self.http_auth = http_auth
self.session = self.create_session()
self.session.verify = verify
self.session.auth = http_auth
def main():
path = Path('C:\\shared\\API\\credentials')
wsdl = 'file://C://shared//API//axlsqltoolkit//schema//11.5//AXLAPI.wsdl'
platform = 'CUCM'
role = 'rwx'
urllib3.disable_warnings(InsecureRequestWarning)
server = path / REGION / platform / ('fqdn' + '.txt')
binding_name = '{http://www.cisco.com/AXLAPIService/}AXLAPIBinding'
address = 'https://{fqdn}:8443/axl/'.format(fqdn=read(server)[0])
session = Session()
session.verify = False
session.auth = HTTPBasicAuth(
read(file(path, platform, role)[0])[0],
crypto(file(path, platform, role)[1],
file(path, platform, role)[2]))
transport = Transport(cache=SqliteCache(), session=session, timeout=60)
client = Client(wsdl=wsdl, transport=transport)
axl = client.create_service(binding_name, address)
##Search and Update Phone
for phoneitem in listPhone(axl, PHONE)['return']['phone']:
for template in readCSV(TEMPLATE):
if template[0] == phoneitem['phoneTemplateName']['_value_1']:
print('current phone template',
phoneitem['phoneTemplateName']['_value_1'])
print('new phone template', template[1])
print('affected device', phoneitem['name'])
updatePhone(axl, phoneitem['name'], template[1])
print(
'#####The End#########The End#########The End#########The End####'
)
else:
pass
##Search and Update UDP
for udpitem in listUDP(axl, UDP)['return']['deviceProfile']:
for template in readCSV(TEMPLATE):
if template[0] == udpitem['phoneTemplateName']['_value_1']:
print('current phone template',
udpitem['phoneTemplateName']['_value_1'])
print('new phone template', template[1])
print('affected device', udpitem['name'])
updateUDP(axl, udpitem['name'], template[1])
try:
for em_items in sql_get_em_items(axl, udpitem['name']):
print(em_items['phone'])
print(em_items['userid'])
em_logout(axl, em_items['phone'])
em_login(axl, udpitem['name'], em_items['phone'],
em_items['userid'])
except TypeError:
pass
print(
'#####The End#########The End#########The End#########The End####'
)
else:
pass
def getAuthenticationWithServer(username, password, wsdl):
disable_warnings(InsecureRequestWarning)
session = Session()
session.verify = False
session.auth = HTTPBasicAuth(username, password)
transport = Transport(cache=SqliteCache(), session=session, timeout=20)
history = HistoryPlugin()
ssl._create_default_https_context = ssl._create_unverified_context
return (Client(wsdl=wsdl, transport=transport, plugins=[history]))
def __init__(self, username, password, hostname, tls_verify=True, timeout=10):
self.last_exception = None
wsdl = f'https://{hostname}/perfmonservice/services/PerfmonPort?wsdl'
session = Session()
session.verify = tls_verify
session.auth = HTTPBasicAuth(username, password)
cache = SqliteCache()
transport = Transport(cache=cache, session=session, timeout=timeout, operation_timeout=timeout)
history = HistoryPlugin()
self.client = Client(wsdl=wsdl, transport=transport, plugins=[history])
def __init__(self,
account=None,
caching=True,
caching_timeout=2592000,
search_body_fields_only=True,
page_size: int = 100):
"""
Initialize the Zeep SOAP client, parse the xsd specifications
of Netsuite and store the complex types as attributes of this
instance.
:param str account_id: Account ID to connect to
:param str caching: If caching = 'sqlite', setup Sqlite caching
:param int caching_timeout: Timeout in seconds for caching.
If None, defaults to 30 days
"""
self.logger = logging.getLogger(self.__class__.__name__)
assert account, 'Invalid account'
assert '-' not in account, 'Account cannot have hyphens, it is likely an underscore'
self._account = account
self._wsdl_url = self.WSDL_URL_TEMPLATE.format(
account=account.replace('_', '-'))
self._datacenter_url = self.DATACENTER_URL_TEMPLATE.format(
account=account.replace('_', '-'))
if caching:
path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'cache.db')
timeout = caching_timeout
cache = SqliteCache(path=path, timeout=timeout)
transport = Transport(cache=cache)
else:
transport = None
# Initialize the Zeep Client
self._client = Client(self._wsdl_url, transport=transport)
# default service points to wrong data center. need to create a new service proxy and replace the default one
self._service_proxy = self._client.create_service(
'{urn:platform_2019_1.webservices.netsuite.com}NetSuiteBinding',
self._datacenter_url)
# Parse all complex types specified in :const:`~netsuitesdk.netsuite_types.COMPLEX_TYPES`
# and store them as attributes of this instance. Same for simple types.
self._namespaces = {}
self._init_complex_types()
self._init_simple_types()
self._app_info = None
self._is_authenticated = False
self.set_search_preferences(
page_size=page_size,
search_body_fields_only=search_body_fields_only)
def soapinfo(CUCM_URL, USERNAME, PASSWD, WSDL_URL):
#Create SOAP Session
session = Session()
session.verify = False
session.auth = HTTPBasicAuth(USERNAME, PASSWD)
transport = Transport(session=session, timeout=10, cache=SqliteCache())
settings = Settings(strict=False, xml_huge_tree=True)
client = Client(WSDL_URL, settings=settings, transport=transport)
service = client.create_service(
"{http://www.cisco.com/AXLAPIService/}AXLAPIBinding", CUCM_URL)
return service
def get_pseudonym(settings: CzNiaAppSettings, user_data: Dict[str,
Any]) -> str:
"""Get pseudonym from NIA servers for given user data."""
transport = Transport(cache=SqliteCache(path=settings.CACHE_PATH,
timeout=settings.CACHE_TIMEOUT),
timeout=settings.TRANSPORT_TIMEOUT)
fp_assertion = _call_identity(settings, transport)
sub_assertion = _call_federation(settings, transport, fp_assertion)
message = IdentificationMessage(user_data)
body = _call_submission(settings, transport, sub_assertion, message)
return message.unpack(body)
def __init__(self, cache=NotSet, timeout=300, verify=True, http_auth=None):
self.cache = SqliteCache() if cache is NotSet else cache
self.timeout = timeout
self.verify = verify
self.http_auth = http_auth
self.logger = logging.getLogger(__name__)
self.session = self.create_session()
self.session.verify = verify
self.session.auth = http_auth
self.session.headers['User-Agent'] = ('Zeep/%s (www.python-zeep.org)' %
(get_version()))
def change_authenticator(settings: CzNiaAppSettings, data: Dict[str, str]):
"""Write a change to the VIP."""
transport = Transport(cache=SqliteCache(path=settings.CACHE_PATH,
timeout=settings.CACHE_TIMEOUT),
timeout=settings.TRANSPORT_TIMEOUT)
fp_assertion = _call_identity(settings, transport)
sub_assertion = _call_federation(settings, transport, fp_assertion)
# Create the request
message = ChangeAuthenticatorMessage(data)
body = _call_submission(settings, transport, sub_assertion, message)
return message.unpack(body)
def _setup(self):
"""Initialise this lazy object with a celery app instance."""
session = Session()
# For each WSDL, extract the domain, and add it as an exception:
for url in WSDLS.values():
parsed = urlparse(url)
base_url = f"{parsed.scheme}://{parsed.netloc}"
session.mount(base_url, AFIPAdapter())
self._wrapped = Transport(cache=SqliteCache(timeout=86400),
session=session)
