def validate_transaction(self, data: dict) -> Transaction:
transaction = Transaction()
transaction.id = data["bill_id"]
transaction.meta = data
if data["state"] in ("pay", "request"):
transaction.validate_status = True
return transaction
def validate_transaction(self, data: dict) -> Transaction:
transaction = Transaction()
transaction.id = data['token']
transaction.meta = data
if 'resultCode' in data and int(data['resultCode']) == 100:
transaction.validate_status = True
return transaction
def validate_transaction(self, data: dict) -> Transaction:
transaction = Transaction()
transaction.id = data["token"]
transaction.meta = data
if "resultCode" in data and int(data["resultCode"]) == 100:
transaction.validate_status = True
return transaction
def verify_transaction(self, transaction: Transaction, data):
url = "%s/bills/%s" % (self._server_url, transaction.id)
headers = {
"access-token": self.config["access_token"],
"content-type": "application/json",
}
try:
response = request("get", url, headers=headers)
except RequestException:
raise GatewayNetworkError("Cannot connect to bahamta server.")
if response.status_code != 200:
raise TransactionError("Invalid transaction information (%s)" %
response.status_code)
response_data = response.json()
if response_data["state"] != "pay":
raise TransactionError("Transaction not paid")
if int(transaction.amount) != int(response_data["amount"]):
raise TransactionError("Amount mismatch")
transaction.pan = response_data["pay_pan"]
transaction.meta = response_data
return transaction
def verify_transaction(self, transaction: Transaction, data):
if data["id"] == "false":
raise TransactionError("Invalid transaction ID")
transaction.pan = data.get("cardNumber")
print("Transaction verified: \n%s" % transaction.__repr__())
return transaction
def verify_transaction(self, transaction: Transaction, data):
url = "https://pay.ir/pg/verify"
formdata = {
"api": "test" if self.testing else self.config["pin"],
"token": transaction.id,
}
try:
resp = request("post", url, data=formdata)
except RequestException:
raise GatewayNetworkError("Cannot connect to payir server")
try:
body = resp.json()
except Exception:
body = None
if resp.status_code != 200:
if not body:
raise TransactionError(
"Invalid transaction information (%s)" % resp.status_code
)
raise TransactionError(
"%s, code: %s" % (body["errorMessage"], body["errorCode"])
)
if int(transaction.amount) != int(body["amount"]):
raise TransactionError("Amount mismatch")
transaction.pan = body["cardNumber"]
transaction.amount = int(body["amount"])
transaction.order_id = body["factorNumber"]
transaction.meta = body
return transaction
def validate_transaction(self, data: dict) -> Transaction:
transaction = Transaction()
transaction.id = data['bill_id']
transaction.meta = data
if data['state'] in ('pay', 'request'):
transaction.validate_status = True
return transaction
def verify_transaction(self, transaction: Transaction, data):
url = '%s/bills/%s' % (self._server_url, transaction.id)
headers = {
'access-token': self.config['access_token'],
'content-type': 'application/json'
}
try:
response = request('get', url, headers=headers)
except RequestException:
raise GatewayNetworkError('Cannot connect to bahamta server.')
if response.status_code != 200:
raise TransactionError(
'Invalid transaction information (%s)' % response.status_code
)
response_data = response.json()
if response_data['state'] != 'pay':
raise TransactionError('Transaction not paid')
if int(transaction.amount) != int(response_data['amount']):
raise TransactionError('Amount mismatch')
transaction.pan = response_data['pay_pan']
transaction.meta = response_data
return transaction
def request_transaction(self, transaction: Transaction) -> Transaction:
data = {
"payer_number": transaction.meta.get("payer_number"),
"payer_name": transaction.meta.get("payer_name"),
"amount": transaction.amount,
"note": transaction.meta.get("note"),
"silent": transaction.meta.get("silent"),
}
for key in ("payer_name", "payer_number", "note"):
if data[key] is None:
raise ValueError("Transaction meta required (%s)" % key)
url = "%s/bills" % self._server_url
headers = {
"access-token": self.config["access_token"],
"content-type": "application/json",
}
try:
response = request("post", url, json=[data], headers=headers)
except RequestException:
raise GatewayNetworkError("Cannot connect to bahamta server.")
if response.status_code != 200:
raise TransactionError("Invalid transaction information (%s)" %
response.status_code)
response_data = response.json()[0]
transaction.id = response_data["bill_id"]
transaction.meta = response_data
return transaction
def verify_transaction(self, transaction: Transaction, data):
if data['id'] == 'false':
raise TransactionError('Invalid transaction ID')
transaction.pan = data.get('cardNumber')
print('Transaction verified: \n%s' % transaction.__repr__())
return transaction
def test_dummy_gateway(self):
gateway = DummyGateway(config=self._config)
transaction = gateway.request_transaction(Transaction(amount=10))
gateway.get_redirection(transaction)
valid_transaction = gateway.validate_transaction({
"id": transaction.id,
"validateStatus": True
})
self.assertEqual(valid_transaction.validate_status, True)
invalid_transaction = gateway.validate_transaction({
"id":
transaction.id,
"validateStatus":
False
})
self.assertEqual(invalid_transaction.validate_status, False)
gateway.verify_transaction(transaction, dict(id=transaction.id))
with self.assertRaises(TransactionError):
gateway.verify_transaction(transaction, dict(id="false"))
with self.assertRaises(TransactionError):
gateway.request_transaction(Transaction(amount=15220))
def validate_transaction(self, data: dict) -> Transaction:
transaction = Transaction()
transaction.id = data['transId']
transaction.meta = data
if int(data['status']) == 1:
transaction.validate_status = True
return transaction
def validate_transaction(self, data: dict) -> Transaction:
transaction = Transaction()
transaction.id = data['Authority']
transaction.meta = data
if data['Status'] == 'OK':
transaction.validate_status = True
return transaction
def validate_transaction(self, data: dict) -> Transaction:
transaction = Transaction()
transaction.id = data["RefId"]
transaction.meta = data
if int(data["ResCode"]) == 0:
transaction.validate_status = True
return transaction
def validate_transaction(self, data: dict) -> Transaction:
transaction = Transaction()
transaction.id = data['Token']
transaction.meta = data
if 'status' in data and int(data['status']) == 0:
transaction.validate_status = True
return transaction
def validate_transaction(self, data: dict) -> Transaction:
transaction = Transaction()
transaction.id = data["Authority"]
transaction.meta = data
if data["Status"] == "OK":
transaction.validate_status = True
return transaction
def validate_transaction(self, data: dict) -> Transaction:
transaction = Transaction()
transaction.id = data["Token"]
transaction.meta = data
if "status" in data and int(data["status"]) == 0:
transaction.validate_status = True
return transaction
def request_transaction(self, transaction: Transaction) -> Transaction:
data = {
'payer_number': transaction.meta.get('payer_number'),
'payer_name': transaction.meta.get('payer_name'),
'amount': transaction.amount,
'note': transaction.meta.get('note'),
'silent': transaction.meta.get('silent')
}
for key in ('payer_name', 'payer_number', 'note'):
if data[key] is None:
raise ValueError('Transaction meta required (%s)' % key)
url = '%s/bills' % self._server_url
headers = {
'access-token': self.config['access_token'],
'content-type': 'application/json'
}
try:
response = request(
'post', url, json=[data], headers=headers
)
except RequestException:
raise GatewayNetworkError('Cannot connect to bahamta server.')
if response.status_code != 200:
raise TransactionError(
'Invalid transaction information (%s)' % response.status_code
)
response_data = response.json()[0]
transaction.id = response_data['bill_id']
transaction.meta = response_data
return transaction
def test_gateway():
gateway = ParsianGateway(config=config)
with domock(get_side_effect(returned_token="4444")):
transaction = gateway.request_transaction(
Transaction(amount=1000, order_id=1)
)
gateway.get_redirection(transaction)
valid_transaction = gateway.validate_transaction(
{"Token": "4444", "status": "0"}
)
assert valid_transaction.validate_status
invalid_transaction = gateway.validate_transaction(
{"Token": "4444", "status": "300"}
)
assert not invalid_transaction.validate_status
# success verification
with domock(get_side_effect(returned_status=0)):
gateway.verify_transaction(
transaction, dict(OrderId="44441", Token="44442")
)
# failed verification
with domock(get_side_effect(returned_status=-100)):
with pytest.raises(TransactionError):
gateway.verify_transaction(
transaction, dict(OrderId="44441", Token="44442")
)
# already verified
with domock(get_side_effect(returned_status=-1533)):
with pytest.raises(TransactionAlreadyPaidError):
gateway.verify_transaction(
transaction, dict(OrderId="44441", Token="44442")
)
# network error
with domock(get_side_effect(raise_zeep_error=True)):
with pytest.raises(GatewayNetworkError):
gateway.verify_transaction(
transaction, dict(OrderId="44441", Token="44442")
)
# no token
with domock(get_side_effect(returned_token=None)):
with pytest.raises(TransactionError):
gateway.request_transaction(Transaction(amount=1000, order_id=1))
# zeep fault
with domock(get_side_effect(raise_zeep_fault=True)):
with pytest.raises(TransactionError):
gateway.request_transaction(Transaction(amount=1000, order_id=1))
# network error
with domock(get_side_effect(raise_zeep_error=True)):
with pytest.raises(GatewayNetworkError):
gateway.request_transaction(Transaction(amount=1000, order_id=1))
def test_transaction():
transaction = Transaction(
amount=1000,
order_id=1,
meta=dict(card_number="xyz"),
)
transaction_dict = transaction.to_dict()
assert transaction_dict["amount"] == transaction.amount
def validate_transaction(self, data: dict) -> Transaction:
parsed_data = self._parse_callback_data(data)
transaction = Transaction()
transaction.id = parsed_data['ref_id']
transaction.meta = parsed_data
if int(parsed_data['res_code']) == 0:
transaction.validate_status = True
return transaction
def request_transaction(self, transaction: Transaction) -> Transaction:
if int(transaction.amount) > self.maximum_amount:
raise TransactionError('Amount is larger than %s' %
self.maximum_amount)
transaction.id = int(time.time())
print('New transaction requested: \n%s' % transaction.__repr__())
return transaction
def test_gateway():
gateway = IrankishGateway(config=config)
with domock(get_side_effect()):
transaction = gateway.request_transaction(
Transaction(amount=1000, order_id=1))
gateway.get_redirection(transaction).to_dict()
valid_transaction = gateway.validate_transaction({
"token": "RETURNED_TOKEN",
"resultCode": "100"
})
assert valid_transaction.validate_status
invalid_transaction = gateway.validate_transaction({
"token": "RETURNED_TOKEN",
"resultCode": "300"
})
assert not invalid_transaction.validate_status
# success verification
with domock(get_side_effect(verify_result=1000)):
gateway.verify_transaction(transaction, dict())
# failed transaction
with domock(get_side_effect()):
with pytest.raises(TransactionError):
gateway.verify_transaction(transaction, dict())
# unknown error
with domock(get_side_effect(verify_result=-900)):
with pytest.raises(TransactionError):
gateway.verify_transaction(transaction, dict())
# network error
with domock(get_side_effect(raise_zeep_error=True)):
with pytest.raises(GatewayNetworkError):
gateway.request_transaction(Transaction(amount=1000, order_id=1))
with pytest.raises(GatewayNetworkError):
gateway.verify_transaction(transaction, dict())
# already paid
with domock(get_side_effect(verify_result=-90)):
with pytest.raises(TransactionAlreadyPaidError):
gateway.verify_transaction(transaction, dict())
# no token
with domock(get_side_effect(returned_token=None)):
with pytest.raises(TransactionError):
gateway.request_transaction(Transaction(amount=1000, order_id=1))
# zeep fault
with domock(get_side_effect(raise_zeep_fault=True)):
with pytest.raises(TransactionError):
gateway.request_transaction(Transaction(amount=1000, order_id=1))
def test_gateway():
with domock(get_side_effect()):
gateway = ZarinpalGateway(config=config)
transaction = gateway.request_transaction(
Transaction(amount=1000, order_id=1))
gateway.get_redirection(transaction)
# validation
valid_transaction = gateway.validate_transaction({
"Authority": "RETURNED_TOKEN",
"Status": "OK"
})
assert valid_transaction.validate_status
invalid_transaction = gateway.validate_transaction({
"Authority": "RETURNED_TOKEN",
"Status": "NOK"
})
assert not invalid_transaction.validate_status
# success verification
with domock(get_side_effect(returned_status=100)):
gateway.verify_transaction(transaction, dict())
# verification fails
with domock(get_side_effect(returned_status=300)):
with pytest.raises(TransactionError):
gateway.verify_transaction(transaction, dict())
# verification already done
with domock(get_side_effect(returned_status=101)):
with pytest.raises(TransactionError):
gateway.verify_transaction(transaction, dict())
# verification network error
with domock(get_side_effect(raise_zeep_error=True)):
with pytest.raises(GatewayNetworkError):
gateway.verify_transaction(transaction, dict())
# no token
with domock(get_side_effect(returned_token=None)):
with pytest.raises(TransactionError):
gateway.request_transaction(Transaction(amount=1000, order_id=1))
# transation error
with domock(get_side_effect(raise_zeep_fault=True)):
with pytest.raises(TransactionError):
gateway.request_transaction(Transaction(amount=1000, order_id=1))
# gateway error
with domock(get_side_effect(raise_zeep_error=True)):
with pytest.raises(GatewayNetworkError):
gateway.request_transaction(Transaction(amount=1000, order_id=1))
def test_gateway():
gateway = AqayepardakhtGateway(config=config)
with domock(get_side_effect(returned_text="11-22-33")):
transaction = gateway.request_transaction(
Transaction(amount=1000, order_id=1))
gateway.get_redirection(transaction)
# with optional fields
transaction = gateway.request_transaction(
Transaction(amount=1000, order_id=1, meta=dict(invoice_id="112")))
gateway.get_redirection(transaction)
valid_transaction = gateway.validate_transaction({
"transid": "RETURNED_TOKEN",
"status": "1"
})
assert valid_transaction.validate_status
invalid_transaction = gateway.validate_transaction({})
assert not invalid_transaction.validate_status
# success verification
with domock(get_side_effect(returned_text="1")):
gateway.verify_transaction(transaction, dict())
# failed verification
with domock(get_side_effect(returned_text="0")):
with pytest.raises(TransactionError):
gateway.verify_transaction(transaction, dict())
# already paid
with domock(get_side_effect(returned_text="2")):
with pytest.raises(TransactionAlreadyPaidError):
gateway.verify_transaction(transaction, dict())
# invalid transaction
with domock(get_side_effect(http_status_code=402)):
with pytest.raises(TransactionError):
gateway.request_transaction(Transaction(amount=1000))
with pytest.raises(TransactionError):
gateway.verify_transaction(transaction, dict())
# network error
with domock(get_side_effect(raise_url_error=True)):
with pytest.raises(GatewayNetworkError):
gateway.verify_transaction(transaction, dict())
with pytest.raises(GatewayNetworkError):
gateway.request_transaction(Transaction(amount=1000, order_id=1))
def request_transaction(self, transaction: Transaction) -> Transaction:
client = Client(self._server_url_request)
if 'proxies' in self.config:
client.transport.session.proxies = self.config['proxies']
try:
params = {
'merchantId': self.config['merchant'],
'invoiceNo': transaction.order_id,
'paymentId': transaction.order_id,
'specialPaymentId': transaction.order_id,
'amount': int(transaction.amount),
'description': '',
'revertURL': self.config['callback_url'],
}
result = client.service.MakeToken(**params)
token = result.token
if token:
transaction.id = token
else:
raise TransactionError('Irankish: invalid information.')
except zeep_exceptions.Fault:
raise TransactionError('Irankish: invalid information.')
except zeep_exceptions.Error:
raise GatewayNetworkError
return transaction
def verify_transaction(self, transaction: Transaction, data):
url = 'https://pay.ir/payment/verify'
data = {
'api': self.config['pin'],
'transId': transaction.id,
}
if self.testing: # pragma: nocover
url = 'https://pay.ir/payment/test/verify'
data['api'] = 'test'
try:
req = request.Request(url, data=parse.urlencode(data).encode())
resp = request.urlopen(req)
resp = json.loads(resp.read().decode())
except error.HTTPError as e:
if e.code == 422:
raise TransactionError('Invalid transaction id')
raise TransactionError('Invalid transaction information')
except error.URLError:
raise GatewayNetworkError('Cannot connect to payline server.')
if int(resp['status']) != 1:
raise TransactionError('%s, code: %s' %
(resp['errorMessage'], resp['errorCode']))
if int(transaction.amount) != int(resp['amount']):
raise TransactionError('Amount mismatch')
transaction.pan = resp['cardNumber']
return transaction
def request_transaction(self, transaction: Transaction) -> Transaction:
url = 'https://pay.ir/payment/send'
data = {
'api': self.config['pin'],
'amount': transaction.amount,
'redirect': self.config['callback_url']
}
if self.testing: # pragma: nocover
url = 'https://pay.ir/payment/test/send'
data['api'] = 'test'
try:
req = request.Request(url, data=parse.urlencode(data).encode())
resp = request.urlopen(req)
resp = json.loads(resp.read().decode())
except error.URLError:
raise GatewayNetworkError('Cannot connect to payline server.')
if resp['status'] == 1 and resp['transId']:
transaction.id = resp['transId']
else:
raise TransactionError('%s, code: %s' %
(resp['errorMessage'], resp['errorCode']))
return transaction
def request_transaction(self, transaction: Transaction) -> Transaction:
client = Client(self._server_url_request)
if "proxies" in self.config:
client.transport.session.proxies = self.config["proxies"]
try:
data = {
"LoginAccount": self.config["pin"],
"OrderId": transaction.order_id,
"Amount": int(transaction.amount),
"CallBackUrl": self.config["callback_url"],
}
result = client.service.SalePaymentRequest(requestData=data)
token = result.Token
status = int(result.Status)
if token and status == 0:
transaction.id = str(token)
else:
raise TransactionError(
"Parsian: %s-%s"
% (status, self._response_message_map[str(status)])
)
except zeep_exceptions.Fault:
raise TransactionError("Parsian: invalid information.")
except zeep_exceptions.Error:
raise GatewayNetworkError
return transaction
def verify_transaction(self, transaction: Transaction, data):
try:
data = {
"LoginAccount": self.config["pin"],
"Token": transaction.id,
}
client = Client(self._server_url_verify)
if "proxies" in self.config:
client.transport.session.proxies = self.config["proxies"]
result = client.service.ConfirmPayment(requestData=data)
status = int(result.Status)
if status == -1533:
raise TransactionAlreadyPaidError(
"Parsian: Transaction already paid"
)
elif status != 0:
raise TransactionError(
"Parsian: %s-%s"
% (status, self._response_message_map[str(status)])
)
except zeep_exceptions.Error:
raise GatewayNetworkError
transaction.pan = result.CardNumberMasked
return transaction
