def _handlePlanStatusRequests(self,
type,
endpoint,
isPostRequest=False,
data=None):
# Checks if it is a post request
if isPostRequest:
response = requests.post(endpoint,
headers=self.headers,
data=json.dumps(data))
else:
response = requests.get(endpoint, headers=self.headers)
# Checks if it can be parsed to json
try:
responseJson = response.json()
except:
raise ServerError({"error": True, "errMsg": response.text})
# Checks if it returns a 2xx code
if response.ok:
return {"error": False, "returnedData": responseJson}
else:
raise PlanStatusError(type, {
"error": True,
"returnedData": responseJson
})
def _handleTransferStatusRequests(self,
endpoint,
isPostRequest=False,
data=None):
# Request headers
headers = {
'content-type': 'application/json',
}
# Checks if it is a post request
if isPostRequest:
response = requests.post(endpoint,
headers=headers,
data=json.dumps(data))
else:
response = requests.get(endpoint, headers=headers)
# Checks if it can be parsed to json
try:
responseJson = response.json()
except:
raise ServerError({"error": True, "errMsg": response.text})
# Checks if it returns a 2xx code
if response.ok:
return {"error": False, "returnedData": responseJson}
else:
raise TransferFetchError({
"error": True,
"returnedData": responseJson
})
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 _handleCardStatusRequests(self,
type,
endpoint,
isPostRequest=False,
data=None):
#check if resposnse is a post response
if isPostRequest:
response = requests.post(endpoint,
headers=self.headers,
data=json.dumps(data))
else:
response = requests.get(endpoint, headers=self.headers)
#check if it can be parsed to JSON
try:
responseJson = response.json()
except:
raise ServerError({"error": True, "errMsg": response.text})
if response.ok:
return {"error": False, "returnedData": responseJson}
else:
raise RecepientStatusError(type, {
"error": True,
"returnedData": responseJson
})
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 refund(self, flwRef):
""" This is used to refund a transaction from any of Rave's component objects.\n
Parameters include:\n
flwRef (string) -- This is the flutterwave reference returned from a successful call from any component. You can access this from action["flwRef"] returned from the charge call
"""
payload = {
"ref": flwRef,
"seckey": self._getSecretKey(),
}
headers = {"Content-Type": "application/json"}
endpoint = self._baseUrl + self._endpointMap["refund"]
response = requests.post(endpoint,
headers=headers,
data=json.dumps(payload))
try:
responseJson = response.json()
except ValueError:
raise ServerError(response)
if responseJson.get("status", None) == "error":
raise RefundError(responseJson.get("message", None))
elif responseJson.get("status", None) == "success":
return True, responseJson.get("data", None)
def validate(self, flwRef, otp, endpoint=None):
""" This is the base validate call.\n
Parameters include:\n
flwRef (string) -- This is the flutterwave reference returned from a successful charge call. You can access this from action["flwRef"] returned from the charge call\n
otp (string) -- This is the otp sent to the user \n
"""
if not endpoint:
endpoint = self._baseUrl + self._endpointMap["account"]["validate"]
# Collating request headers
headers = {
'content-type': 'application/json',
}
payload = {
"PBFPubKey": self._getPublicKey(),
"transactionreference": flwRef,
"transaction_reference": flwRef,
"otp": otp
}
response = requests.post(endpoint,
headers=headers,
data=json.dumps(payload))
return self._handleValidateResponse(response, flwRef)
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):
# 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 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["recepient"]["create"]
response = requests.post(endpoint,
headers=self.headers,
data=json.dumps(details))
return self._handleCreateResponse(response, details)
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 create(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 capture(self, flwRef):
""" This is called to complete the transaction.\n
Parameters include:
flwRef (string) -- This is the flutterwave reference you receive from action["flwRef"]
"""
payload = {
"SECKEY": self._getSecretKey(),
"flwRef": flwRef
}
headers ={
"Content-Type":"application/json"
}
endpoint = self._baseUrl + self._endpointMap["preauth"]["capture"]
response = requests.post(endpoint, headers=headers, data=json.dumps(payload))
return self._handleCaptureResponse(response, '')
def void(self, flwRef):
""" This is called to void a transaction.\n
Parameters include:\n
flwRef (string) -- This is the flutterwave reference you receive from action["flwRef"]\n
"""
payload = {
"SECKEY": self._getSecretKey(),
"ref": flwRef,
"action":"void"
}
headers ={
"Content-Type":"application/json"
}
endpoint = self._baseUrl + self._endpointMap["preauth"]["refundorvoid"]
response = requests.post(endpoint, headers=headers, data=json.dumps(payload))
return self._handleRefundorVoidResponse(response, endpoint)
def verify(self, txRef, endpoint=None):
""" This is used to check the status of a transaction.\n
Parameters include:\n
txRef (string) -- This is the transaction reference that you passed to your charge call. If you didn't define a reference, you can access the auto-generated one from payload["txRef"] or action["txRef"] from the charge call\n
"""
if not endpoint:
endpoint = self._baseUrl + self._endpointMap["verify"]
# Collating request headers
headers = {
'content-type': 'application/json',
}
# Payload for the request headers
payload = {"txref": txRef, "SECKEY": self._getSecretKey()}
response = requests.post(endpoint,
headers=headers,
data=json.dumps(payload))
return self._handleVerifyResponse(response, txRef)
def refund(self, flwRef, amount=None):
""" This is called to refund the transaction.\n
Parameters include:\n
flwRef (string) -- This is the flutterwave reference you receive from action["flwRef"]\n
amount (Number) -- (optional) This is called if you want a partial refund
"""
payload = {
"SECKEY": self._getSecretKey(),
"ref": flwRef,
"action":"refund"
}
if amount:
payload["amount"] = amount
headers ={
"Content-Type":"application/json"
}
endpoint = self._baseUrl + self._endpointMap["preauth"]["refundorvoid"]
response = requests.post(endpoint, headers=headers, data=json.dumps(payload))
return self._handleRefundorVoidResponse(response, endpoint)
def _handleVerifyStatusRequests(self,
endpoint,
isPostRequest=False,
data=None):
self.headers = {'content-type': 'application/json'}
#check if resposnse is a post response
if isPostRequest:
response = requests.post(endpoint,
headers=self.headers,
data=json.dumps(data))
else:
response = requests.get(endpoint, headers=self.headers)
#check if it can be parsed to JSON
try:
responseJson = response.json()
except:
raise ServerError({"error": True, "errMsg": response.text})
if response.ok:
return {"error": False, "returnedData": responseJson}
else:
raise BVNFetchError({"error": True, "returnedData": responseJson})
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"])
