def test_is_successful(self):
self.assertTrue(
GatewayResponse(200, b'', CaseInsensitiveDict()).is_successful())
self.assertTrue(
GatewayResponse(201, b'', CaseInsensitiveDict()).is_successful())
self.assertTrue(
GatewayResponse(302, b'', CaseInsensitiveDict()).is_successful())
self.assertTrue(
GatewayResponse(402, b'', CaseInsensitiveDict()).is_successful())
self.assertFalse(
GatewayResponse(404, b'', CaseInsensitiveDict()).is_successful())
self.assertFalse(
GatewayResponse(401, b'', CaseInsensitiveDict()).is_successful())
self.assertFalse(
GatewayResponse(403, b'', CaseInsensitiveDict()).is_successful())
self.assertFalse(
GatewayResponse(500, b'', CaseInsensitiveDict()).is_successful())
def make_request(self, request_data=None) -> GatewayResponse:
"""
Make HTTP request via Transact Pro HttpTransport
Args:
request_data (dict): Transact Pro request structure
Response tuple (HTTP Content, HTTP Status code, HTTP Headers)
Returns:
GatewayResponse
"""
if self.__client_operations['current'] == '/report':
req_url = gateway.API_BASE_URL.rstrip(
'/') + self.__client_operations['current']
elif str(self.__client_operations['current']).startswith('http'):
req_url = self.__client_operations['current']
else:
req_url = gateway.API_BASE_URL + gateway.API_VERSION + self.__client_operations[
'current']
if req_url is None:
raise RuntimeError('Transact PRO API URL Empty!')
if self.__client_operations['method'] != HTTP_GET:
if request_data is None or len(request_data) < 1:
raise RuntimeError("Request data invalid, is empty")
if type(request_data) is not dict:
raise RuntimeError('Request data invalid, must be dict')
guid = AuthorizationBuilder.get_object_guid(
self.__dict_of_auth_data_set)
secret = self.__dict_of_auth_data_set[
RequestParameters.AUTH_DATA_SECRET_KEY]
digest = RequestDigest(username=guid, secret=secret, full_url=req_url)
digest.set_body(json.dumps(request_data))
# Setup config for HTTP transport
# And make request via HTTP implemented Client
[content, status_code, headers] = new_http_client(
cli_name=gateway.HTTP_TRANSPORT_IMPLEMENTATION,
verify_ssl=gateway.HTTP_VERIFY_SSL_CERTS,
proxy=gateway.HTTP_PROXY,
timeout=gateway.HTTP_TIME_OUT).request(
http_method=self.__client_operations['method'],
http_url=req_url,
authorization_header=digest.create_header(),
request_data=request_data)
gw_response = GatewayResponse(status_code, content, headers)
if gw_response.is_successful():
response_digest = ResponseDigest(
gw_response.headers.get('authorization'))
gw_response.digest = response_digest
response_digest.set_original_uri(digest.get_uri())
response_digest.set_original_cnonce(digest.get_cnonce())
response_digest.set_body(gw_response.payload)
response_digest.verify(guid, secret)
return gw_response
def parse(response: GatewayResponse) -> PaymentResponse:
return response.parse_json(PaymentResponse)
def parse(response: GatewayResponse) -> CsvResponse:
return response.parse_csv()
def parse(response: GatewayResponse) -> LimitsResponse:
return response.parse_json(LimitsResponse)
def parse(response: GatewayResponse) -> StatusResponse:
return response.parse_json(StatusResponse)
def parse(response: GatewayResponse) -> ResultResponse:
return response.parse_json(ResultResponse)
def parse(response: GatewayResponse) -> HistoryResponse:
return response.parse_json(HistoryResponse)
def parse(response: GatewayResponse) -> RecurringTransactionsResponse:
return response.parse_json(RecurringTransactionsResponse)
def parse(response: GatewayResponse) -> EnrollmentResponse:
return response.parse_json(EnrollmentResponse)