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["id"]
transaction.meta = data
transaction.validate_status = data.get("validateStatus", True)
print("Transaction validated: \n%s" % transaction.__repr__())
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:
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 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 request_transaction(self, transaction: Transaction) -> Transaction:
client = Client(self._server_url)
if 'proxies' in self.config:
client.transport.session.proxies = self.config['proxies']
try:
params = {
'terminalId': self.config['terminal_id'],
'userName': self.config['username'],
'userPassword': self.config['password'],
'orderId': transaction.order_id,
'amount': int(transaction.amount),
'localDate': datetime.now().strftime('%Y%m%d'),
'localTime': datetime.now().strftime('%H%M%S'),
'additionalData': '',
'callBackUrl': self.config['callback_url'],
'payerId': 0,
}
result = client.service.bpPayRequest(**params)
if not result:
raise TransactionError('Mellat: invalid information. %s' % result)
res = str(result).split(',')
res_code = res[0]
if int(res_code) == 0:
transaction.id = res[1]
else:
raise TransactionError('Mellat: invalid information. %s' % res_code)
except zeep_exceptions.Fault:
raise TransactionError('Mellat: invalid information.')
except zeep_exceptions.Error:
raise GatewayNetworkError
return transaction
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['bill_id']
transaction.meta = data
if data['state'] in ('pay', 'request'):
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 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["RefId"]
transaction.meta = data
if int(data["ResCode"]) == 0:
transaction.validate_status = True
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)
if "proxies" in self.config:
client.transport.session.proxies = self.config["proxies"]
try:
params = {
"merchantConfigurationID": self.config["merchant_config_id"],
"encryptedRequest": self._get_encrypted_request(transaction),
}
result = client.service.RequestOperation(**params)
if not result:
raise TransactionError("AsanPardakht: invalid information.")
if result[0:1] == "0":
exploded_result = str(result).split(
",") # Should have two part [XX,YY]
transaction.id = exploded_result[1]
else:
raise TransactionError(
"AsanPardakht: invalid information. code: %s" %
str(result))
except zeep_exceptions.Fault:
raise TransactionError("AsanPardakht: invalid information.")
except zeep_exceptions.Error:
raise GatewayNetworkError
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['id']
transaction.meta = data
transaction.validate_status = data.get('validateStatus', True)
print('Transaction validated: \n%s' % transaction.__repr__())
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:
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 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 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 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 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 request_transaction(self, transaction: Transaction) -> Transaction:
formdata = {
"pin": self.config["pin"],
"amount": irr_to_irt(transaction.amount),
"callback": self.config["callback_url"],
}
optional_fields = (
"card_number",
"invoice_id",
"mobile",
"description",
)
for field in optional_fields:
if field not in transaction.meta:
continue
formdata[field] = transaction.meta[field]
try:
response = request(
method="post",
url="%s/create" % self._server_url,
data=formdata,
)
except RequestException:
raise GatewayNetworkError("Cannot connect to aqayepardakht server")
if response.status_code != 200:
raise TransactionError("Invalid transaction information (%s)" %
response.status_code)
transaction.id = response.text
return transaction
def request_transaction(self, transaction: Transaction) -> Transaction:
client = Client(self._server_url)
if 'proxies' in self.config:
client.transport.session.proxies = self.config['proxies']
try:
params = {
'merchantConfigurationID': self.config['merchant_config_id'],
'encryptedRequest': self._get_encrypted_request(transaction)
}
result = client.service.RequestOperation(**params)
if not result:
raise TransactionError('AsanPardakht: invalid information.')
if result[0:1] == '0':
exploded_result = str(result).split(
',') # Should have two part [XX,YY]
transaction.id = exploded_result[1]
else:
raise TransactionError(
'AsanPardakht: invalid information. code: %s' %
str(result))
except zeep_exceptions.Fault:
raise TransactionError('AsanPardakht: invalid information.')
except zeep_exceptions.Error:
raise GatewayNetworkError
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 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 validate_transaction(self, data: dict) -> Transaction:
transaction = Transaction()
transaction.id = data.get("transid")
transaction.amount = int(data.get("amount", 0))
transaction.pan = data.get("cardnumber")
transaction.meta = data
transaction.validate_status = transaction.id is not None
return transaction
def request_transaction(self, transaction: Transaction) -> Transaction:
url = "https://pay.ir/pg/send"
formdata = {
"api": "test" if self.testing else self.config["pin"],
"amount": transaction.amount,
"redirect": self.config["callback_url"],
}
if transaction.order_id:
formdata["factorNumber"] = transaction.order_id
optional_fields = (
"mobile",
"validCardNumber",
"description",
)
for field in optional_fields:
if field not in transaction.meta:
continue
formdata[field] = transaction.meta[field]
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"])
)
transaction.id = body["token"]
return transaction
def request_transaction(self, transaction: Transaction) -> Transaction:
client = Client(self._server_url)
try:
result = client.service.PaymentRequest(
self.config['merchant'],
self._convert_iranian_rial_to_toman(transaction.amount),
self.config['description'], '', '',
self.config['callback_url'])
except zeep_exceptions.Fault:
raise TransactionError('Zarinpal: invalid information')
except zeep_exceptions.Error:
raise GatewayNetworkError
if result.Status == 100 and result.Authority:
transaction.id = result.Authority
else:
raise TransactionError('Zarinpal: invalid information')
return transaction
def request_transaction(self, transaction: Transaction) -> Transaction:
client = Client(self._server_url)
if "proxies" in self.config:
client.transport.session.proxies = self.config["proxies"]
try:
params = {
"terminalId": self.config["terminal_id"],
"userName": self.config["username"],
"userPassword": self.config["password"],
"orderId": transaction.order_id,
"amount": int(transaction.amount),
"localDate": datetime.now().strftime("%Y%m%d"),
"localTime": datetime.now().strftime("%H%M%S"),
"additionalData": "",
"callBackUrl": self.config["callback_url"],
"payerId": 0,
}
result = client.service.bpPayRequest(**params)
if not result:
raise TransactionError(
"Mellat: invalid information. %s" % result
)
res = str(result).split(",")
res_code = res[0]
if int(res_code) == 0:
transaction.id = res[1]
else:
raise TransactionError(
"Mellat: invalid information. %s" % res_code
)
except zeep_exceptions.Fault:
raise TransactionError("Mellat: invalid information.")
except zeep_exceptions.Error:
raise GatewayNetworkError
return transaction
def request_transaction(self, transaction: Transaction) -> Transaction:
client = Client(self._server_url)
try:
result = client.service.PaymentRequest(
self.config["merchant"],
irr_to_irt(transaction.amount),
self.config["description"],
"",
"",
self.config["callback_url"],
)
except zeep_exceptions.Fault:
raise TransactionError("Zarinpal: invalid information")
except zeep_exceptions.Error:
raise GatewayNetworkError
if result.Status == 100 and result.Authority:
transaction.id = result.Authority
else:
raise TransactionError("Zarinpal: invalid information")
return transaction
