def test_send():
session = mock.Mock()
session.post.return_value.content = b'abc123'
session.post.return_value.headers = {
1: 'A',
2: 'B',
}
session.post.return_value.status_code = 200
transport = suds_requests.RequestsTransport(session)
request = suds.transport.Request(
'http://url',
'I AM SOAP! WHY AM I NOT CLEAN!!!',
)
request.headers = {
'A': 1,
'B': 2,
}
reply = transport.send(request)
session.post.assert_called_with(
'http://url',
data='I AM SOAP! WHY AM I NOT CLEAN!!!',
headers={
'A': 1,
'B': 2,
},
)
assert reply.code == 200
assert reply.headers == {
1: 'A',
2: 'B',
}
assert reply.message == b'abc123'
def __setClient(self, type):
session = requests.Session()
adapter = ForceTLSV12Adapter()
session.mount('http://', adapter)
session.mount('https://', adapter)
self.client = Client(self.__getAPIURL(type),
transport=suds_requests.RequestsTransport(session))
def _get_client(cls, environment, session, username, password, cache=None):
""" Return webservice from SOAP client (suds). """
# Endpoint URL depending on environment
assert environment in ('sandbox', 'production'), 'Unknown environment'
if environment == 'production':
webservice_url = cls.PRODUCTION_ENDPOINT_URL
else:
webservice_url = cls.SANDBOX_ENDPOINT_URL
# Setup authentication
sha1 = hashlib.sha1()
sha1.update(password)
security = suds.wsse.Security()
token = suds.wsse.UsernameToken(username, sha1.hexdigest())
security.tokens.append(token)
# Instantiate client
client = suds.client.Client(
webservice_url,
transport=suds_requests.RequestsTransport(session),
cachingpolicy=1,
cache=cache,
wsse=security)
return client
def test_open():
session = mock.Mock()
session.get.return_value.content = b'abc123'
transport = suds_requests.RequestsTransport(session)
request = suds.transport.Request('http://url')
response = transport.open(request)
assert response.read() == b'abc123'
def __init__(self, config_obj, wsdl_name, *args, **kwargs):
"""
This constructor should only be called by children of the class. As is
such, only the optional keyword arguments caught by C{**kwargs} will
be documented.
@type customer_transaction_id: L{str}
@keyword customer_transaction_id: A user-specified identifier to
differentiate this transaction from others. This value will be
returned with the response from Fedex.
"""
self.logger = logging.getLogger('fedex')
"""@ivar: Python logger instance with name 'fedex'."""
self.config_obj = config_obj
"""@ivar: The FedexConfig object to pull auth info from."""
if not self._version_info:
self._version_info = {}
"""#ivar: Set in each service class. Holds version info for the VersionId SOAP object."""
# If the config object is set to use the test server, point
# suds at the test server WSDL directory.
if config_obj.use_test_server:
self.logger.info("Using test server.")
self.wsdl_path = os.path.join(config_obj.wsdl_path,
'test_server_wsdl', wsdl_name)
else:
self.logger.info("Using production server.")
self.wsdl_path = os.path.join(config_obj.wsdl_path, wsdl_name)
import suds_requests
self.client = Client('file:///%s' % self.wsdl_path.lstrip('/'),
plugins=[GeneralSudsPlugin()],
transport=suds_requests.RequestsTransport())
# self.client.options.cache.clear() # Clear the cache, then re-init client when changing wsdl file.
self.VersionId = None
"""@ivar: Holds details on the version numbers of the WSDL."""
self.WebAuthenticationDetail = None
"""@ivar: WSDL object that holds authentication info."""
self.ClientDetail = None
"""@ivar: WSDL object that holds client account details."""
self.response = None
"""@ivar: The response from Fedex. You will want to pick what you
want out here here. This object does have a __str__() method,
you'll want to print or log it to see what possible values
you can pull."""
self.TransactionDetail = None
"""@ivar: Holds customer-specified transaction IDs."""
self.__set_web_authentication_detail()
self.__set_client_detail(*args, **kwargs)
self.__set_version_id()
self.__set_transaction_detail(*args, **kwargs)
self._prepare_wsdl_objects()
def get_client(base_url):
cache_location = '/tmp/suds'
cache = suds.cache.DocumentCache(location=cache_location)
session = requests.Session()
return suds.client.Client(
base_url,
cache=cache,
transport=suds_requests.RequestsTransport(session))
def get_authenticated_client(base_url, cert, key):
cache_location = '/tmp/suds'
cache = suds.cache.DocumentCache(location=cache_location)
session = requests.Session()
session.cert = (cert, key)
return suds.client.Client(
base_url,
cache=cache,
transport=suds_requests.RequestsTransport(session))
def test_get_soap_client(self, soap_client, mocker):
with mocker.patch.object(client, 'Client'):
with mocker.patch.object(requests, 'Session'):
wsdl_path = 'http://some-wsdl-path'
new_client = soap_client._get_soap_client(wsdl_path)
session = requests.Session()
assert session.verify == soap_client.verify_ssl
assert new_client == client.Client.return_value
assert client.Client.called_once_with(
wsdl_path,
transport=suds_requests.RequestsTransport(session))
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 _get_client(self):
cache_location = '/tmp/suds'
cache = suds.cache.DocumentCache(location=cache_location)
session = requests.Session()
key, certificate = self._preparar_temp_pem()
session.cert = (key, certificate)
return suds.client.Client(
self.base_url,
cache=cache,
transport=suds_requests.RequestsTransport(session)
)
def test_get_soap_client(self, mock_session_adapter, soap_client, mocker):
with mocker.patch.object(client, "Client"):
with mocker.patch.object(requests, "Session"):
wsdl_path = "http://some-wsdl-path"
new_client = soap_client._get_soap_client(wsdl_path)
session = requests.Session()
assert session.verify == soap_client.verify_ssl
assert new_client == client.Client.return_value
assert client.Client.called_once_with(
wsdl_path, transport=suds_requests.RequestsTransport(session)
)
mock_session_adapter.assert_called_once_with(
session, soap_client._session_adapter
)
def __init__(self,
ReportService,
ReportExecution,
user,
key_password,
domain=None,
verbose=True):
self.reportpath = ''
self.verbose = verbose
servsession = requests.Session()
execsession = requests.Session()
log.basicConfig(filename='SSRS.log', level=log.ERROR)
if domain:
user = '******'.format(domain, user)
servsession.auth = HttpNtlmAuth(user, key_password)
execsession.auth = HttpNtlmAuth(user, key_password)
else:
servsession.auth = (user, key_password)
execsession.auth = (user, key_password)
try:
self.ServiceClient = Client(
ReportService,
transport=suds_requests.RequestsTransport(servsession))
self.ExecutionClient = Client(
ReportExecution,
transport=suds_requests.RequestsTransport(execsession))
except Exception as e:
msg = "Error during connection: %s" % e.args
log.error(msg)
if self.verbose:
print(msg)
exit()
def __init__(self, **kwargs):
super(TransIP, self).__init__(**kwargs)
self.service_name = 'DomainService'
self.login = kwargs['api_email']
self.private_key_file = kwargs['api_key']
self.endpoint = 'api.transip.nl'
self.url = URI_TEMPLATE.format(self.endpoint, self.service_name)
imp = Import('http://schemas.xmlsoap.org/soap/encoding/')
doc = ImportDoctor(imp)
suds_kwargs = dict()
if suds_requests:
suds_kwargs['transport'] = suds_requests.RequestsTransport()
self.soap_client = SudsClient(self.url, doctor=doc, **suds_kwargs)
def __init__(self,
username,
password,
url=DEFAULT_STUDENT_SERVICE_WSDL_URL,
port=DEFAULT_STUDENT_SERVICE_PORT,
**kwargs):
wsse = suds.wsse.Security()
wsse.tokens.append(suds.wsse.UsernameToken(username, password))
session = requests.Session()
session.mount('file://', FileAdapter()) # For loading the local WSDL
super(SesamStudentServiceClient, self).__init__(
url=url,
port=port,
transport=suds_requests.RequestsTransport(session),
wsse=wsse,
**kwargs)
def __init__(self,
service_name,
login,
private_key_file='decrypted_key',
endpoint='api.transip.nl'):
self.service_name = service_name
self.login = login
self.private_key_file = private_key_file
self.endpoint = endpoint
self.url = URI_TEMPLATE.format(endpoint, service_name)
imp = Import('http://schemas.xmlsoap.org/soap/encoding/')
doc = ImportDoctor(imp)
suds_kwargs = dict()
if suds_requests:
suds_kwargs['transport'] = suds_requests.RequestsTransport()
self.soap_client = SudsClient(self.url, doctor=doc, **suds_kwargs)
def http_client(self):
http_session = requests.session()
response = http_session.get(self.url)
try:
if response.status_code != 503:
response.raise_for_status()
except requests.exception.HTTPError as e:
sys.stderr.write(e)
sys.exit(1)
http_session.auth = (self.user_name, self.authenticate())
self.client = Client(
self.url,
faults=False,
cachingpolicy=1,
location=self.url,
transport=suds_requests.RequestsTransport(http_session))
if self.add_sec:
self.add_security_header()
return self.client
def _get_soap_client(self, wsdl_path, **kwargs):
""".
Args:
wsdl_path (str): The url for the wsdl to connect to.
**kwargs: Keyword-arguments that are forwarded to the suds client constructor.
Returns:
suds.client.Client: A suds SOAP client.
"""
session = requests.Session()
session.verify = self.verify_ssl
# use ``requests`` based suds implementation to handle AlgoSec's self-signed certificate properly.
with report_soap_failure(AlgoSecAPIError):
return client.Client(
wsdl_path,
transport=suds_requests.RequestsTransport(session),
plugins=[LogSOAPMessages()],
cache=NoCache(),
**kwargs)
def addSecurityHeader(client, username, password):
security = Security()
userNameToken = UsernameToken(username, password)
timeStampToken = Timestamp(validity=600)
security.tokens.append(userNameToken)
security.tokens.append(timeStampToken)
client.set_options(wsse=security)
session = requests.session()
session.auth = (username, password)
client = Client(url=soap_url,
location=wsdl_url,
faults=False,
cachingpolicy=1,
transport=suds_requests.RequestsTransport(session))
print client
chN = "C5"
chN = "R4"
chN = "I1"
#pprint(client)
client = Client(soap_url)
pali = client.service.getMHPData(chN, "01/01/2016 00:03:00",
"31/12/2016 06:00:00", 5)
print 'ciccia'
paliL = list()
for i in range(0, pali.__len__()):
palii = pali.__getitem__(i)
paliL.append({
"name": palii.__getitem__(0),
"time": palii.__getitem__(4),
def get_ws_client(ws_url, ws_user, ws_password):
session = requests.Session()
session.auth = (ws_user, ws_password)
return suds.client.Client(
ws_url, transport=suds_requests.RequestsTransport(session))
def ajax_get_auth_emp_list_returns(request):
user = request.user
data = []
try:
logger.debug("##start call to get emp list.... ")
req = request.GET
nodeid = req.get('nodeid', "")
auth_type = req.get('auth_type', 'template')
obj_ids = req.getlist('obj_list[]', [])
obj_id = obj_ids[0] if obj_ids and len(obj_ids) == 1 else None
if auth_type not in PERM_PTYPE_MAP.keys():
raise Exception, u'参数错误'
req_type = PERM_PTYPE_MAP.get(auth_type)
to_users = Perm.objects.filter(
object_id=obj_id, is_delete=False,
ptype=req_type).values_list('to_user__username') if obj_id else []
to_users_names = [i[0] for i in to_users]
logger.debug("selected users for {0}_{1}: {2}".format(
auth_type, obj_id, to_users_names))
code = YW_DEPT_CODE
if nodeid != '#':
code = nodeid.split("_")[1]
client = suds.client.Client(
YW_DEPT_OA_URL, transport=suds_requests.RequestsTransport())
dept_result = json.loads(
client.service.GetGreenofficeSubDeptList(code))
emp_result = json.loads(
client.service.GetGreenOfficeEmpListByDeptCode(code))
# parent_id : [subs]
dept_dict = {}
node = None
for depart in dept_result:
parent_id = depart['parent_id']
dept_id = depart['dept_id']
index = depart['label_index']
if str(depart['status']).lower() != 'y':
logger.warning(
"##### depart status not valid,skip,{0}".format(depart))
continue
dept_code = depart["dept_code"]
if dept_code == code:
node = depart
dept_dict.setdefault(parent_id, []).append(depart)
def get_children(depart):
'''
here iterate to get all children.
'''
children = []
dept_id = depart['dept_id']
subs = dept_dict.get(dept_id) or []
# get direct employee of depart
subs = sorted(subs, key=lambda item: item['label_index'])
for item in emp_result:
if item['STATUS'] == 'y' and item['dept_id'] == depart[
'dept_id']:
username = item["NTAccount"]
if username == user.username:
continue
u, is_new = _user.get_or_create_user_by_params(
username=username)
if is_new:
u.set_password(username)
u.first_name = item['emp_name']
u.save()
children.append({
"text": item['emp_name'],
"id": "emp_" + username,
"state": {
"selected":
True if u.username in to_users_names else False,
},
"children": False
})
# get children of sub depart.
[
children.append({
"text": sub['dept_name'],
"id": "dept_" + sub["dept_code"],
"state": {
"selected": False
},
"children": get_children(sub)
}) for sub in subs
]
return children
data = []
data.append({
"text": node['dept_name'],
"id": "dept_" + node["dept_code"],
"state": {
"opened": True,
"selected": False
},
"children": get_children(node)
})
response = HttpResponse(json.dumps(data),
content_type="application/json")
except:
print traceback.format_exc()
response = HttpResponse(json.dumps([]),
content_type="application/json")
response.status_code = 408
logger.debug("##end call to get emp list.")
return response
