def fund(self, details):
requiredParameters = ["id", "amount", "debit_currency"]
checkIfParametersAreComplete(requiredParameters, details)
endpoint = self._baseUrl + self._endpointMap["virtual_card"]["fund"] + "/" + details['id'] + "/fund"
data = details
method = 'POST'
return self._handleCardStatusRequests("fund-virtual-card", endpoint, method, data=data)
def create(self, virtual_cardDetails):
requiredParameters = ["currency", "amount", "billing_name", "billing_address", "billing_city", "billing_state", "billing_postal_code", "billing_country"]
checkIfParametersAreComplete(requiredParameters, virtual_cardDetails)
endpoint = self._baseUrl + self._endpointMap["virtual_card"]["create"]
response = requests.post(endpoint, headers=self.headers, data=json.dumps(virtual_cardDetails))
return self._handleCreateResponse(response, virtual_cardDetails)
def withdraw(self, details):
requiredParameters = ["id", "amount"]
checkIfParametersAreComplete(requiredParameters, details)
endpoint = self._baseUrl + self._endpointMap["virtual_card"]["withdraw"] + "/" + details['id'] + "/withdraw"
data = details
method = 'POST'
return self._handleCardStatusRequests("withdraw-card-funds", endpoint, method, data=data)
def bulk(self, bulkDetails):
bulkDetails = copy.copy(bulkDetails)
# Collating request headers
headers = {
'content-type': 'application/json',
'authorization': 'Bearer ' + self._getSecretKey(),
}
# bulkDetails.update({"seckey": self._getSecretKey()})
requiredParameters = ["bulk_data"]
checkIfParametersAreComplete(requiredParameters, bulkDetails)
checkTransferParameters(requiredParameters, bulkDetails)
endpoint = self._baseUrl + self._endpointMap["transfer"]["bulk"]
# Collating request headers
headers = {
'content-type': 'application/json',
'authorization': 'Bearer ' + self._getSecretKey(),
}
response = requests.post(endpoint,
headers=headers,
data=json.dumps(bulkDetails))
return self._handleBulkResponse(response, bulkDetails)
def create(self, details):
# Performing shallow copy of planDetails to avoid public exposing payload with secret key
requiredParameters = ["phone_number", "ip", "amount", "email", "tx_ref", "country"]
checkIfParametersAreComplete(requiredParameters, details)
endpoint = self._baseUrl + self._endpointMap["ebills"]["create"]
response = requests.post(endpoint, headers=self.headers, data=json.dumps(details))
return self._handleCreateResponse(response, details)
def create(self, details):
requiredParameters = ["length", "customer", "sender", "send", "medium"]
checkIfParametersAreComplete(requiredParameters, details)
endpoint = self._baseUrl + self._endpointMap["otp"]["create"]
data = details
method = 'POST'
return self._handleStatusRequests("create-otp", endpoint, method, data = data)
def initiate(self, transferDetails):
# Performing shallow copy of transferDetails to avoid public exposing payload with secret key
transferDetails = copy.copy(transferDetails)
# adding reference if not already included
if not ("reference" in transferDetails):
transferDetails.update(
{"reference": generateTransactionReference()})
transferDetails.update({"seckey": self._getSecretKey()})
# These are the parameters required to initiate a transfer
requiredParameters = [
"amount", "currency", "account_bank", "account_number"
]
checkIfParametersAreComplete(requiredParameters, transferDetails)
checkTransferParameters(requiredParameters, transferDetails)
# Collating request headers
headers = {
'content-type': 'application/json',
'authorization': 'Bearer ' + self._getSecretKey(),
}
endpoint = self._baseUrl + self._endpointMap["transfer"]["initiate"]
response = requests.post(endpoint,
headers=headers,
data=json.dumps(transferDetails))
return self._handleInitiateResponse(response, transferDetails)
def create(self, details):
requiredParameters = ["account_number", "account_bank"]
checkIfParametersAreComplete(requiredParameters, details)
endpoint = self._baseUrl + self._endpointMap["beneficiaries"]["create"]
response = requests.post(endpoint,
headers=self.headers,
data=json.dumps(details))
return self._handleCreateResponse(response, details)
def create(self, planDetails):
# Performing shallow copy of planDetails to avoid public exposing payload with secret key
requiredParameters = ["amount", "name", "interval", "duration"]
checkIfParametersAreComplete(requiredParameters, planDetails)
endpoint = self._baseUrl + self._endpointMap["payment_plan"]["create"]
response = requests.post(endpoint,
headers=self.headers,
data=json.dumps(planDetails))
return self._handleCreateResponse(response, planDetails)
def bulk(self, details):
requiredParameters = ["bulk_reference", "callback_url", "bulk_data"]
checkIfParametersAreComplete(requiredParameters, details)
endpoint = self._baseUrl + self._endpointMap["bills"]["bulk"]
data = details
method = 'POST'
return self._handleBillStatusRequests("bulk-bill",
endpoint,
method,
data=data)
def update(self, details):
requiredParameters = ["order_id", "amount"]
checkIfParametersAreComplete(requiredParameters, details)
endpoint = self._baseUrl + self._endpointMap["bills"][
"update"] + "/" + details["order_id"]
data = details
method = 'PUT'
return self._handleBillStatusRequests("bulk-bill",
endpoint,
method,
data=data)
def create(self, accountDetails):
requiredParameters = [
"email", "duration", "frequency", "tx_ref", "amount"
]
checkIfParametersAreComplete(requiredParameters, accountDetails)
endpoint = self._baseUrl + self._endpointMap["virtual_account"][
"create"]
response = requests.post(endpoint,
headers=self.headers,
data=json.dumps(accountDetails))
return self._handleCreateResponse(response, accountDetails)
def create(self, accountDetails):
# Performing shallow copy of planDetails to avoid public exposing payload with secret key
requiredParameters = [
"account_bank", "account_number", "business_name",
"business_mobile", "country", "split_value"
]
checkIfParametersAreComplete(requiredParameters, accountDetails)
endpoint = self._baseUrl + self._endpointMap["subaccount"]["create"]
response = requests.post(endpoint,
headers=self.headers,
data=json.dumps(accountDetails))
return self._handleCreateResponse(response, accountDetails)
def createOrder(self, details):
requiredParameters = ["item_code", "code", "customer", "fields"]
checkIfParametersAreComplete(requiredParameters, details)
endpoint = self._baseUrl + self._endpointMap["bills"][
"all"] + "/" + details["item_code"] + "/products/" + details[
"code"] + "/orders"
data = details
method = 'POST'
return self._handleBillStatusRequests("get-bill-amount",
endpoint,
method,
data=data)
def create(self, details):
# Performing shallow copy of planDetails to avoid public exposing payload with secret key
# details = copy.copy(details)
# details.update({"seckey": self._getSecretKey()})
requiredParameters = [
"country", "customer", "amount", "recurrence", "type"
]
checkIfParametersAreComplete(requiredParameters, details)
endpoint = self._baseUrl + self._endpointMap["bills"]["create"]
response = requests.post(endpoint,
headers=self.headers,
data=json.dumps(details))
return self._handleCreateResponse(response, details)
def charge(self, paymentDetails, requiredParameters, endpoint, shouldReturnRequest=False, isMpesa=False):
""" This is the base charge call. It is usually overridden by implementing classes.\n
Parameters include:\n
paymentDetails (dict) -- These are the parameters passed to the function for processing\n
requiredParameters (list) -- These are the parameters required for the specific call\n
hasFailed (boolean) -- This is a flag to determine if the attempt had previously failed due to a timeout\n
shouldReturnRequest -- This determines whether a request is passed to _handleResponses\n
"""
# Checking for required components
try:
checkIfParametersAreComplete(requiredParameters, paymentDetails)
except:
raise
# Performing shallow copy of payment details to prevent tampering with original
paymentDetails = copy.copy(paymentDetails)
# Adding PBFPubKey param to paymentDetails
paymentDetails.update({"public_key": self._getPublicKey()})
# Collating request headers
headers = {
'content-type': 'application/json',
'authorization' : 'Bearer ' + self._getSecretKey(),
}
if "token" in paymentDetails:
paymentDetails.update({"SECKEY": self._getSecretKey()})
# print(json.dumps(paymentDetails))
response = requests.post(endpoint, headers=headers, data=json.dumps(paymentDetails))
elif paymentDetails["type"] != "card":
response = requests.post(endpoint, headers=headers, data=json.dumps(paymentDetails))
else:
# Encrypting payment details (_encrypt is inherited from RaveEncryption)
encryptedPaymentDetails = self._encrypt(json.dumps(paymentDetails))
# Collating the payload for the request
payload = {
"public_key": paymentDetails["public_key"],
"client": encryptedPaymentDetails
}
response = requests.post(endpoint, headers=headers, data=json.dumps(payload))
if shouldReturnRequest:
if isMpesa:
return self._handleChargeResponse(response, paymentDetails["tx_ref"], paymentDetails, True)
return self._handleChargeResponse(response, paymentDetails["tx_ref"], paymentDetails)
else:
if isMpesa:
return self._handleChargeResponse(response, paymentDetails["tx_ref"], paymentDetails, True)
return self._handleChargeResponse(response, paymentDetails["tx_ref"])
def transactions(self, details, card_id):
requiredParameters = ["from", "to", "index", "size"]
checkIfParametersAreComplete(requiredParameters, details)
endpt = self._baseUrl + self._endpointMap["virtual_card"]["transactions"] + "/" + str(card_id) + "/transactions?"
data = details
url_parts = list(urlparse.urlparse(endpt))
query = dict(urlparse.parse_qsl(url_parts[4]))
query.update(details)
url_parts[4] = urlencode(query)
endpoint = urlparse.urlunparse(url_parts)
method = 'GET'
return self._handleCardStatusRequests("get-virtual-card-transactions", endpoint, method, data=data)
def getFee(self, details):
requiredParameters = ["amount"]
checkIfParametersAreComplete(requiredParameters, details)
endpt = self._baseUrl + self._endpointMap["transaction"]["fee"] + "?"
data = details
#parse query params
url_parts = list(urlparse.urlparse(endpt))
query = dict(urlparse.parse_qsl(url_parts[4]))
query.update(details)
url_parts[4] = urlencode(query)
endpoint = urlparse.urlunparse(url_parts)
method = 'GET'
return self._handleTransferStatusRequests(endpoint, method, data=data)
def all(self, details):
requiredParameters = ["from", "to"]
checkIfParametersAreComplete(requiredParameters, details)
endpt = self._baseUrl + self._endpointMap["bills"]["create"]
data = details
url_parts = list(urlparse.urlparse(endpt))
query = dict(urlparse.parse_qsl(url_parts[4]))
query.update(details)
url_parts[4] = urlencode(query)
endpoint = urlparse.urlunparse(url_parts)
method = 'GET'
return self._handleBillStatusRequests("get_all-bills",
endpoint,
method,
data=data)
def validateService(self, details):
requiredParameters = ["item_code", "code", "customer"]
checkIfParametersAreComplete(requiredParameters, details)
endpt = self._baseUrl + self._endpointMap["bills"][
"bill-service"] + "/" + details["item_code"] + "/validate"
data = details
url_parts = list(urlparse.urlparse(endpt))
query = dict(urlparse.parse_qsl(url_parts[4]))
query.update(details)
url_parts[4] = urlencode(query)
endpoint = urlparse.urlunparse(url_parts)
method = 'GET'
return self._handleBillStatusRequests("validate-service",
endpoint,
method,
data=data)
def update(self, details, reference):
requiredParameters = ["amount"]
checkIfParametersAreComplete(requiredParameters, details)
endpoint = self._baseUrl + self._endpointMap["ebills"]["update"] + "/" + str(reference)
method = 'PUT'
return self._handleBillStatusRequests("update-ebill", endpoint, method, data = None)