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", "beneficiary_name"]
checkIfParametersAreComplete(requiredParameters, transferDetails)
checkTransferParameters(requiredParameters, transferDetails)
# Collating request headers
headers = {
'content-type': 'application/json',
}
endpoint = self._baseUrl + self._endpointMap["transfer"]["initiate"]
response = requests.post(endpoint,
headers=headers,
data=json.dumps(transferDetails))
return self._handleInitiateResponse(response, transferDetails)
def bulk(self, bulkDetails):
# feature logic
bulkDetails = copy.copy(bulkDetails)
bulkDetails.update({"seckey": self._getSecretKey()})
requiredParameters = ["title", "bulk_data"]
checkIfParametersAreComplete(requiredParameters, bulkDetails)
checkTransferParameters(requiredParameters, bulkDetails)
endpoint = self._baseUrl + self._endpointMap["transfer"]["bulk"]
# Collating request headers
headers = {
'content-type': 'application/json',
}
response = requests.post(endpoint, headers=headers, data=json.dumps(bulkDetails))
if response.ok == False:
#feature logging
tracking_endpoint = self._trackingMap
responseTime = response.elapsed.total_seconds()
tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.13", "title": "Initiate-Bulk-error","message": responseTime}
tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
else:
tracking_endpoint = self._trackingMap
responseTime = response.elapsed.total_seconds()
tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.13", "title": "Initiate-Bulk","message": responseTime}
tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
return self._handleBulkResponse(response, bulkDetails)
def bulk(self, bulkDetails):
bulkDetails = copy.copy(bulkDetails)
# Collating request headers
headers = {
'content-type': 'application/json',
}
bulkDetails.update({"seckey": self._getSecretKey()})
requiredParameters = ["title", "bulk_data"]
checkIfParametersAreComplete(requiredParameters, bulkDetails)
checkTransferParameters(requiredParameters, bulkDetails)
endpoint = self._baseUrl + self._endpointMap["transfer"]["bulk"]
# Collating request headers
headers = {
'content-type': 'application/json',
}
response = requests.post(endpoint,
headers=headers,
data=json.dumps(bulkDetails))
return self._handleBulkResponse(response, bulkDetails)
def create(self, vcardDetails):
vcardDetails = copy.copy(vcardDetails)
vcardDetails.update({"seckey": self._getSecretKey()})
requiredParameters = ["currency", "amount", "billing_name", "billing_address", "billing_city", "billing_state", "billing_postal_code", "billing_country"]
checkIfParametersAreComplete(requiredParameters, vcardDetails)
endpoint = self._baseUrl + self._endpointMap["virtual_card"]["create"]
response = requests.post(endpoint, headers=self.headers, data=json.dumps(vcardDetails))
return self._handleCreateResponse(response, vcardDetails)
def Create(self, accountDetails):
accountDetails = copy.copy(accountDetails)
accountDetails.update({"seckey": self._getSecretKey()})
requiredParameters = ["email", "narration"]
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 createSubaccount(self, accountDetails):
# Performing shallow copy of planDetails to avoid public exposing payload with secret key
accountDetails = copy.copy(accountDetails)
accountDetails.update({"seckey": self._getSecretKey()})
requiredParameters = ["account_bank", "account_number", "business_name", "business_email", "business_contact", "business_contact_mobile", "business_mobile", "split_type", "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 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 = ["service", "service_method", "service_version", "service_channel"]
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 createPlan(self, planDetails):
# Performing shallow copy of planDetails to avoid public exposing payload with secret key
planDetails = copy.copy(planDetails)
planDetails.update({"seckey": self._getSecretKey()})
requiredParameters = ["amount", "name", "interval"]
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 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 = ["numberofunits", "currency", "amount", "email", "txRef", "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):
details = copy.copy(details)
details.update({"seckey": self._getSecretKey()})
requiredParameters = ["account_number", "account_bank"]
checkIfParametersAreComplete(requiredParameters, details)
endpoint = self._baseUrl + self._endpointMap["recipient"]["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({"PBFPubKey": self._getPublicKey()})
# Collating request headers
headers = {
'content-type': 'application/json',
}
if "token" in paymentDetails:
paymentDetails.update({"SECKEY": self._getSecretKey()})
# print(json.dumps(paymentDetails))
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 = {
"PBFPubKey": paymentDetails["PBFPubKey"],
"client": encryptedPaymentDetails,
"alg": "3DES-24"
}
response = requests.post(endpoint, headers=headers, data=json.dumps(payload))
if shouldReturnRequest:
if isMpesa:
return self._handleChargeResponse(response, paymentDetails["txRef"], paymentDetails, True)
return self._handleChargeResponse(response, paymentDetails["txRef"], paymentDetails)
else:
if isMpesa:
return self._handleChargeResponse(response, paymentDetails["txRef"], paymentDetails, True)
return self._handleChargeResponse(response, paymentDetails["txRef"])
def create(self, vcardDetails):
#card creating logic
vcardDetails = copy.copy(vcardDetails)
vcardDetails.update({"seckey": self._getSecretKey()})
requiredParameters = [
"currency", "amount", "billing_name", "billing_address",
"billing_city", "billing_state", "billing_postal_code",
"billing_country"
]
checkIfParametersAreComplete(requiredParameters, vcardDetails)
endpoint = self._baseUrl + self._endpointMap["virtual_card"]["create"]
response = requests.post(endpoint,
headers=self.headers,
data=json.dumps(vcardDetails))
#feature logging
if response.ok == False:
tracking_endpoint = self._trackingMap
responseTime = response.elapsed.total_seconds()
tracking_payload = {
"publicKey": self._getPublicKey(),
"language": "Python v2",
"version": "1.2.13",
"title": "Create-card-error",
"message": responseTime
}
tracking_response = requests.post(
tracking_endpoint, data=json.dumps(tracking_payload))
else:
tracking_endpoint = self._trackingMap
responseTime = response.elapsed.total_seconds()
tracking_payload = {
"publicKey": self._getPublicKey(),
"language": "Python v2",
"version": "1.2.13",
"title": "Create-card",
"message": responseTime
}
tracking_response = requests.post(
tracking_endpoint, data=json.dumps(tracking_payload))
return self._handleCreateResponse(response, vcardDetails)
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 = [
"service", "service_method", "service_version", "service_channel"
]
checkIfParametersAreComplete(requiredParameters, details)
endpoint = self._baseUrl + self._endpointMap["bills"]["create"]
response = requests.post(endpoint,
headers=self.headers,
data=json.dumps(details))
# feature logging
if response.ok == False:
tracking_endpoint = self._trackingMap
responseTime = response.elapsed.total_seconds()
tracking_payload = {
"publicKey": self._getPublicKey(),
"language": "Python v2",
"version": "1.2.13",
"title": "Create-Bills-error",
"message": responseTime
}
tracking_response = requests.post(
tracking_endpoint, data=json.dumps(tracking_payload))
else:
tracking_endpoint = self._trackingMap
responseTime = response.elapsed.total_seconds()
tracking_payload = {
"publicKey": self._getPublicKey(),
"language": "Python v2",
"version": "1.2.13",
"title": "Create-Bills",
"message": responseTime
}
tracking_response = requests.post(
tracking_endpoint, data=json.dumps(tracking_payload))
return self._handleCreateResponse(response, details)
def create(self, accountDetails):
# feature logic
accountDetails = copy.copy(accountDetails)
accountDetails.update({"seckey": self._getSecretKey()})
requiredParameters = ["email", "narration"]
checkIfParametersAreComplete(requiredParameters, accountDetails)
endpoint = self._baseUrl + self._endpointMap["virtual_account"][
"create"]
response = requests.post(endpoint,
headers=self.headers,
data=json.dumps(accountDetails))
#feature logging
if response.ok == False:
tracking_endpoint = self._trackingMap
responseTime = response.elapsed.total_seconds()
tracking_payload = {
"publicKey": self._getPublicKey(),
"language": "Python v2",
"version": "1.2.13",
"title": "Create-virtual-account-error",
"message": responseTime
}
tracking_response = requests.post(
tracking_endpoint, data=json.dumps(tracking_payload))
else:
tracking_endpoint = self._trackingMap
responseTime = response.elapsed.total_seconds()
tracking_payload = {
"publicKey": self._getPublicKey(),
"language": "Python v2",
"version": "1.2.13",
"title": "Create-virtual-account",
"message": responseTime
}
tracking_response = requests.post(
tracking_endpoint, data=json.dumps(tracking_payload))
return self._handleCreateResponse(response, accountDetails)
def initiate(self, transferDetails):
## feature logic
# 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","beneficiary_name"]
checkIfParametersAreComplete(requiredParameters, transferDetails)
checkTransferParameters(requiredParameters, transferDetails)
# Collating request headers
headers = {
'content-type': 'application/json',
}
endpoint = self._baseUrl + self._endpointMap["transfer"]["initiate"]
response = requests.post(endpoint, headers=headers, data=json.dumps(transferDetails))
if response.ok == False:
#feature logging
tracking_endpoint = self._trackingMap
responseTime = response.elapsed.total_seconds()
tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.13", "title": "Initiate-Transfer-error","message": responseTime}
tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
else:
tracking_endpoint = self._trackingMap
responseTime = response.elapsed.total_seconds()
tracking_payload = {"publicKey": self._getPublicKey(),"language": "Python v2", "version": "1.2.13", "title": "Initiate-Transfer","message": responseTime}
tracking_response = requests.post(tracking_endpoint, data=json.dumps(tracking_payload))
return self._handleInitiateResponse(response, transferDetails)
