digifi-BankEmulator/app/api/routes/routes.py

from flask import Flask, Blueprint, request, jsonify,  send_from_directory
import sys
import os
from app.api.services import (
    RACCheckService,
    DisbursementService,
    CollectLoanService,
    TransactionVerifyService,
    PenalChargeService,
    RevokeEnableConsentService,
    TokenValidationService,
    LienCheckService,
    NewTransactionCheckService,
    CompleteRACcheckService
)
from app.utils.logger import logger
from app.api.middlewares import  enforce_json
from flask_jwt_extended import (jwt_required)




api = Blueprint("api", __name__)


# Enforce json
@api.before_request
def cors_middleware():
    """Middleware applied globally to all API routes in this blueprint"""
    return enforce_json()


# Swagger JSON file
@api.route("/swagger.json", methods=['GET'])
def swagger_json():
    swagger_dir = os.path.join("swagger")
    return send_from_directory(swagger_dir, "digifi_swagger.json")



@api.route('/swagger/<path:filename>')
def serve_paths(filename):
    swagger_dir = os.path.join("swagger")
    return send_from_directory(swagger_dir, filename)

# RACCheck Endpoint
@api.route('/rac-check', methods=['POST'])
@jwt_required()
def rac_check():
    logger.info("RACCheck request received")
    try:
        logger.info("RACCheck inside try request received")
        data = request.get_json()
        response = RACCheckService.process_request(data)
        return response
    except Exception as e:
        logger.exception("Unhandled exception in /RACCheck route")
        return jsonify({"message": "Unhandled server error"}), 500

# CompleteRACcheck Endpoint
@api.route('/CompleteRACcheck', methods=['POST'])
@jwt_required()
def complete_rac_check():
    try:
        data = request.get_json()
        response = CompleteRACcheckService.process_request(data)
        return response
    except Exception as e:
        logger.exception("Unhandled exception in /CompleteRACcheck route")
        return jsonify({"message": "Unhandled server error"}), 500

# Disbursement Endpoint
@api.route('/DisburseLoan', methods=['POST'])
@jwt_required()
def disbursement():
    try:
        data = request.get_json()
        # logger.info(f"Disbursement request received: {data}")
        response = DisbursementService.process_request(data)
        return response
    except Exception as e:
        logger.exception("Unhandled exception in /Disbursement route")
        return jsonify({"message": "Unhandled server error"}), 500

# CollectLoan Endpoint
@api.route('/CollectLoan', methods=['POST'])
@jwt_required()
def collect_loan():
    try:
        data = request.get_json()
        # logger.info(f"CollectLoan request received: {data}")
        response = CollectLoanService.process_request(data)
        return response
    except Exception as e:
        logger.exception("Unhandled exception in /CollectLoan route")
        return jsonify({"message": "Unhandled server error"}), 500

# TransactionVerify Endpoint
@api.route('/TransactionVerify', methods=['POST'])
@jwt_required()
def transaction_verify():
    try:
        data = request.get_json()
        # logger.info(f"TransactionVerify request received: {data}")
        response = TransactionVerifyService.process_request(data)
        return response
    except Exception as e:
        logger.exception("Unhandled exception in /TransactionVerify route")
        return jsonify({"message": "Unhandled server error"}), 500

# PenalCharge Endpoint
@api.route('/CollectPenalFee', methods=['POST'])
@jwt_required()
def penal_charge():
    try:
        data = request.get_json()
        # logger.info(f"PenalCharge request received: {data}")
        response = PenalChargeService.process_request(data)
        return response
    except Exception as e:
        logger.exception("Unhandled exception in /PenalCharge route")
        return jsonify({"message": "Unhandled server error"}), 500


# RevokeEnableConsent Endpoint
@api.route('/RevokeEnableConsent', methods=['POST'])
@jwt_required()
def revoke_enable_consent():
    data = request.get_json()
    # logger.info(f"RevokeEnableConsent request received: {data}")
    response = RevokeEnableConsentService.process_request(data)
    return response

# TokenValidation Endpoint
@api.route('/TokenValidation', methods=['POST'])
@jwt_required()
def token_validation():
    data = request.get_json()
    # logger.info(f"TokenValidation request received: {data}")
    response = TokenValidationService.process_request(data)
    return response

# LienCheck Endpoint
@api.route('/LienCheck', methods=['POST'])
@jwt_required()
def lien_check():
    data = request.get_json()
    # logger.info(f"LienCheck request received: {data}")
    response = LienCheckService.process_request(data)
    return response

# NewTransactionCheck Endpoint
@api.route('/NewTransactionCheck', methods=['POST'])
@jwt_required()
def new_transaction_check():
    data = request.get_json()
    # logger.info(f"NewTransactionCheck request received: {data}")
    response = NewTransactionCheckService.process_request(data)
    return response


# Health Check Endpoint
@api.route('/system-health-check', methods=['GET'])
@jwt_required()
def health_check():
    """Basic system health check"""
    try:
        checks = {
            "python_version": sys.version_info >= (3, 6), 
            "disk_space": os.statvfs('/').f_bavail * os.statvfs('/').f_frsize > 500 * 1024 * 1024, 
            "system_operational": True
        }
        
        if all(checks.values()):
            return jsonify({
                "status": "Active",
                "responseCode": "00",
                "responseMessage": "Successful"
            }), 200
        else:
            return jsonify({
                "status": "Degraded",
                "responseCode": "01",
                "responseMessage": "System check failed"
            }), 200
            
    except Exception as e:
        return jsonify({
            "status": "Error",
            "responseCode": "99",
            "responseMessage": f"Health check failed: {str(e)}"
        }), 500