digifi-EventManager/app/integrations/simbrella.py

import requests
from app.config import settings
from app.helpers.response_helper import ResponseHelper
from app.services.loan import LoanService
from app.utils.auth import get_headers
from app.utils.extras import preprocess_loan_charges_data
from app.utils.logger import logger
from flask import jsonify, current_app
from app.services.transactions import TransactionService
from app.services.repayment import RepaymentService


class SimbrellaClient:

    BANK_CALL_BASE_URL = settings.BANK_CALL_BASE_URL
    BANK_CALL_DISBURSE_LOAN_ENDPOINT =  settings.BANK_CALL_DISBURSE_LOAN_ENDPOINT
    BANK_CALL_COLLECT_LOAN_ENDPOINT =  settings.BANK_CALL_COLLECT_LOAN_ENDPOINT

    @staticmethod
    def disburse_loan(data):
        api_url = f"{SimbrellaClient.BANK_CALL_BASE_URL}/{SimbrellaClient.BANK_CALL_DISBURSE_LOAN_ENDPOINT}"
        logger.info(f"Calling DisburseLoan        api_url==> : {api_url}")
        logger.info(f"Calling DisburseLoan endpoint with data: {data}")

        # Check if the transaction exists
        logger.info(f"Checking if transaction exists")
        transaction = TransactionService.get_transaction_by_transaction_id(transaction_id=data['transactionId'])
        logger.info(f"Loan Response From Database ** : {transaction}")

        # If transaction is not found
        if not transaction:
            logger.info(f"Transaction id: {data['transactionId']}, was not found")
            return 0

        # Fetch the loan based on the transaction_id
        logger.info(f"Fetching the loan with transaction ID: {data['transactionId']}")
        loan = LoanService.get_loan_by_transaction_id(transaction_id=data['transactionId'])
        logger.info(f"Response from database: {loan}")

        # If loan is not found
        if not loan:
            logger.info(f"Could not find loan with transaction id: {data['transactionId']}")
            return 0

        loan_data = loan.to_dict()
        logger.info(f"Here is your loan data: {loan_data}")

        loan_charges = preprocess_loan_charges_data([loan_charge.to_dict() for loan_charge in loan.loan_charges])
        logger.info(f"Here are your loan_charges: {loan_charges}")

        mgt_fee = loan_charges.get("MGTFEE")['amount']
        vat_fee = loan_charges.get("VAT")['amount']
        interest_fee = loan_charges.get("INTEREST")['amount']
        insurance_fee = loan_charges.get("INSURANCE")['amount']

        disbursement_data ={
            "requestId": data['requestId'],
            "transactionId": data['transactionId'],
            "debtId": loan_data['debtId'],
            "customerId": data['customerId'],
            "accountId": data['accountId'],
            "productId": loan_data['productId'],
            "provideAmount": loan_data['currentLoanAmount'],
            "collectAmountInterest": interest_fee,
            "collectAmountMgtFee": mgt_fee,
            "collectAmountInsurance": insurance_fee,
            "collectAmountVAT": vat_fee,
            "countryId": "01",
            "comment": "Loan Disbursement",
        }

        try:
            logger.info(f"Here is your Disbursement Request data ****** : {disbursement_data}")
            response = requests.post(api_url, json=disbursement_data, timeout=10, headers=get_headers())
            logger.info(f"Disbursement response: {response.json()}")


        except Exception as e:
            logger.info(f"Failed to call Disbursement endpoint: {e}")
            return 0

        return 1
#Calling CollectLoan endpoint with data: {'transactionId': 'TRX1747960765928545', 'customerId': 'CID0000055362', 'productId': '101', 'debtId': '9590'}

    @staticmethod
    def collect_loan(data):
        api_url = f"{SimbrellaClient.BANK_CALL_BASE_URL}/{SimbrellaClient.BANK_CALL_COLLECT_LOAN_ENDPOINT}"
        logger.info(f"Calling CollectLoan endpoint with data: {data}")

        # Check if the repayment exists
        logger.info(f"Checking if repayment exists")
        repayment = RepaymentService.get_repayment_by_transaction_id(transaction_id=data['transactionId'])
        logger.info(f"Repayment Response From Database ** : {repayment}")
        loan  = LoanService.get_loan_by_debt_id(debt_id=repayment.loan_id)

        # If repayment is not found
        if not repayment:
            logger.info(f"Repayment id: {data['transactionId']}, was not found")
            return 0

        repayAmount = loan.repayment_amount

        collectAmount =  repayAmount

        collect_loan_data = {
                "transactionId": repayment.transaction_id,
                "fbnTransactionId": loan.reference,
                "debtId": repayment.loan_id,
                "customerId": repayment.customer_id,
                "accountId": loan.account,
                "productId": repayment.product_id,
                "collectAmount": collectAmount,
                "penalCharge": 0,
                "channel": "USSD",
                "collectionMethod": 1,
                "lienAmount": 0,
                "countryId": "01",
                "comment": "Testing CollectionLoanRequest"
            }

        try:
            logger.info(f"Here is your CollectLoan Request data ***** : {collect_loan_data}")
            response = requests.post(api_url, json=collect_loan_data, headers=get_headers())
            logger.info(f"CollectLoan response: {response.json()}")

        except Exception as e:
            logger.info(f"Failed to call CollectLoan endpoint: {e}")
            return 0

        return 1

    @staticmethod
    def verify_transaction():
        try:

            data = {
                "status": "00",
                "message": "Transaction verified"
            }
            return ResponseHelper.success(data, "Successful")

        except Exception as e:
            logger.info(f"Failed to call TransactionVerify endpoint: {e}")
            raise

    @staticmethod
    def refresh_disbursement(data):

        try:
            logger.info(f"Here is your Disbursement Request data ***** : {data}")

            return ResponseHelper.success(data, "Successful")

        except Exception as e:
            logger.info(f"Failed to call Disbursement endpoint: {e}")
            raise

    @staticmethod
    def payment_callback(data):

        try:
            logger.info(f"Here is your Payment Callback Request data ***** : {data}")

            return ResponseHelper.success(data, "Successful")

        except Exception as e:
            logger.info(f"Failed to call Payment Callback endpoint: {e}")
            raise

    @staticmethod
    def penal_charge(data):

        api_url = f"{SimbrellaClient.BANK_CALL_BASE_URL}/PenalCharge"
        logger.info(f"Calling Penal Charge endpoint with data: {data}")

        try:
            logger.info(f"Here is your Penal Charge Request data ***** : {data}")

            try:
                logger.info(f"Here is your Penal Charge Request data ****** : {data}")
                response = requests.post(api_url, json=data, timeout=10, headers=get_headers())
                logger.info(f"Penal Charge response: {response.json()}")
                return ResponseHelper.success(response.json(), "Successful")

            except Exception as e:
                logger.info(f"Failed to call Penal Charge endpoint: {e}")
                return ResponseHelper.error("An error occurred", 500)

        except Exception as e:
            logger.info(f"Failed to call Penal Charge endpoint: {e}")
            raise