digifi-EventManager/app/routes/autocall.py

from flask import Blueprint, request, jsonify, current_app
import requests
from app.config import settings
from app.helpers.response_helper import ResponseHelper
from app.utils.auth import get_headers
from app.utils.logger import logger
from app.integrations.simbrella import SimbrellaClient
from app.services.loan import LoanService
from app.services.repayment import RepaymentService
from app.services.salary import SalaryService

autocall_bp = Blueprint("autocall", __name__)

@autocall_bp.route("/refresh-verify-disbursement", methods=["GET"])
def verify_transaction():
    logger.info(f"Calling VerifyTransaction Components")

    loan = LoanService.get_latest_loan_with_disburse_date()
    if not loan:
        logger.info(f"No loan found without disbursement date")
        return 0
    logger.info(f"Calling VerifyTransaction endpoint with data: {loan}")
    loan_data = loan.to_dict()

    data = {
        "transactionId": loan_data.get('transactionId'),
        "FbnTransactionId": loan_data.get('transactionId'),
        "debtId": str(loan_data.get('debtId')),
        "customerId": loan_data.get('customerId'),
        "accountId": loan_data.get('accountId'),
        "productId": str(loan_data.get('productId', "")),
        "provideAmount": loan_data.get('currentLoanAmount'),
    }
    response = SimbrellaClient.verify_transaction(data)
    return response

@autocall_bp.route("/refresh-disbursement", methods=["GET"])
def disbursement():
    # data = request.json()
    logger.info(f"Calling Disbursement Components")
    loan = LoanService.get_latest_loan_without_disburse_date()
    if not loan:
        logger.info(f"No loan found without disbursement date")
        return 0
    logger.info(f"Calling DisburseLoan endpoint with data: {loan}")
    loan_data = loan.to_dict()

    data = {
        "transactionId": loan_data.get('transactionId'),
        "FbnTransactionId": loan_data.get('transactionId'),
        "debtId": str(loan_data.get('debtId')),
        "customerId": loan_data.get('customerId'),
        "accountId": loan_data.get('accountId'),
        "productId": str(loan_data.get('productId', "")),
        "provideAmount": loan_data.get('currentLoanAmount'),
    }
    response = SimbrellaClient.disburse_loan(data)
    return response


@autocall_bp.route("/refresh-verify-collection", methods=["GET"])
def refresh_verify_collection():
    data = request.get_json()
    logger.info(f"Calling Verify Collection")

    response = SimbrellaClient.collect_loan(data)

    return response

@autocall_bp.route("/refresh-collection", methods=["GET"])
def refresh_collection():
    #data = request.get_json()
    logger.info(f"Calling Collection ")
    #grab the last repayments with repay date is none
    repayment = RepaymentService.get_latest_repayment_without_repay_date()
    #repayment = RepaymentService.get_latest_repayment_with_loanId(13735)
    if not repayment:
        logger.info(f"No repayment found without disbursement date")
        return 0
    logger.info(f"Calling repay loan endpoint with data: {repayment}")
    repayment_data = repayment.to_dict()
    logger.info(f"here is the dict form of repayment {repayment_data}")

    data = {
        "transactionId": repayment_data['transactionId'],
        "debtId": repayment_data['loanId'],
        "customerId": repayment_data['customerId'],
        "productId": repayment_data['productId'],
    }
    logger.info(f"Data being sent to Simbrella: {data}")
    logger.info(f"calling simbrella")
    response = SimbrellaClient.collect_loan_user_initiated(data)

    return response

@autocall_bp.route("/payment-callback", methods=["POST"])
def payment_callback():
    data = request.get_json()
    logger.info(f"Calling Callback Components")

    response = SimbrellaClient.payment_callback(data)

    return response

@autocall_bp.route("/penal-charge", methods=["POST"])
def penal_charge():
    data = request.get_json()
    logger.info(f"Calling Penal Charge Endpoints")

    response = SimbrellaClient.penal_charge(data[0])

    return response

@autocall_bp.route("/analytic-salary-detect", methods=["POST"])
def salary_detect():
    payload = request.get_json()
    logger.info(f"Calling Salary Detect endpoint")

    # Attempt to add the incoming salary data
    try:
        new_salary = SalaryService.add_salary_data(payload)
        if new_salary:
            logger.info(f"Salary added: {new_salary.id}" )
    except Exception as e:
        logger.info(f"Failed to save salary: ", e)

    # Fetch all pending salaries
    pending_salaries = SalaryService.get_pending_salaries()
    if not pending_salaries:
        logger.info(f"No pending salaries found")
        return ResponseHelper.success([], "No pending salaries")

    logger.info(f"Found  pending salaries {len(pending_salaries)}" )

    for pending_salary in pending_salaries:
        logger.info(f"Processing salary ID: {pending_salary.id}" )

        # Step 1: Update status to PROCESSING early to avoid race condition
        try:
            SalaryService.update_status(pending_salary.id, "PROCESSING")
        except Exception as e:
            logger.info(f"Failed to update status to PROCESSING for salary ID : {pending_salary.id} {e}" )
            continue

        # Step 2: Fetch loans for this salary's customer
        try:
            loans = LoanService.get_customer_loans(pending_salary.customer_id)
            if not loans:
                logger.warning(f"No loans found for customer ID: {pending_salary.customer_id}" )
                continue
        except Exception as e:
            logger.info(f"Error fetching loans for customer ID : {pending_salary.customer_id} {e}")
            continue

        # Step 3: Loop through loans and create repayment entries
        for loan in loans:
            try:
                loan_dict = loan.to_dict()
                repayment_data = {
                    "customerId": pending_salary.customer_id,
                    "loanId": loan_dict["debtId"],
                    "productId": loan_dict["productId"],
                    "transactionId": loan_dict["transactionId"],
                    "initiatedBy": "SALARY_DETECT",
                    "salaryAmount": pending_salary.amount,
                }
                logger.info(f"Creating repayment for loan ID  {loan_dict["debtId"]}")
                repayment = RepaymentService.add_repayment(repayment_data)
                logger.info(f"Created repayment ID: {repayment.id}", )
            except Exception as e:
                logger.info(f"Error creating repayment for loan ID : {loan.id} {e}" )
                continue

        # Step 4: Optionally update salary to DONE after all loan processing
        try:
            SalaryService.update_status(pending_salary.id, "DONE")
        except Exception as e:
            logger.info(f"Failed to mark salary ID  as DONE: {pending_salary.id} {e}")

    # Step 5: Call Simbrella integration after processing all salaries
    try:
        SimbrellaClient.collect_loan_user_salary_detect(payload)
    except Exception as e:
        logger.info(f"Failed to call Simbrella client: {e}")

    return ResponseHelper.success([], "AutoCall Successful")