update

app/api/routes/routes.py

@@ -1,5 +1,7 @@
 from flask import Blueprint, request, jsonify, send_from_directory
 from flask import Blueprint, request, jsonify
+
+from app.api.services import RepaymentService
 from app.api.services.loan_service import LoanService
 from app.api.services.transaction_service import TransactionService
 from app.api.services.auth_service import AuthService
@@ -135,3 +137,12 @@ def get_transactions():
     # logger.info(f"Get transactions request received with filters: {filters}")
     response = TransactionService.process_request(filters)
     return response
+
+# Repayment Endpoint
+@api.route("/Repayment", methods=["POST"])
+# @jwt_required()
+def repayment():
+    data = request.get_json()
+    # logger.info(f"Repayment request received: {data}")
+    response = RepaymentService.process_request(data)
+    return response

app/api/schemas/repayment.py

@@ -0,0 +1,12 @@
+from marshmallow import Schema, fields
+
+# Repayment Schema
+class RepaymentSchema(Schema):
+    type = fields.Str(required=False)
+    msisdn = fields.Str(required=False) #optional
+    debtId = fields.Str(required=True)
+    productId = fields.Str(required=True)
+    transactionId = fields.Str(required=True)
+    accountId = fields.Str(required=True)
+    customerId = fields.Str(required=True)
+    channel = fields.Str(required=True)

app/api/services/__init__.py

@@ -5,3 +5,4 @@ from app.api.services.transaction_service import TransactionService
 from app.api.services.loan_service import LoanService
 from app.api.services.auth_service import AuthService
 from app.api.services.dashboard_service import DashboardService
+from app.api.services.repayment import RepaymentService

app/api/services/repayment.py

@@ -0,0 +1,115 @@
+from flask import request, jsonify
+from marshmallow import ValidationError
+from app.api.enums.loan_status import LoanStatus
+from app.models import Repayment
+from app.models.customer import Customer
+from app.models.loan import Loan
+from app.utils.logger import logger
+from app.api.schemas.repayment import RepaymentSchema
+from app.api.services.base_service import BaseService
+from app.api.enums import TransactionType 
+from threading import Thread
+from app.extensions import db
+
+class RepaymentService(BaseService):
+    TRANSACTION_TYPE = TransactionType.REPAYMENT 
+
+    @staticmethod
+    def process_request(data):
+        """
+        Process the Repayment request.
+
+        Args:
+            data (dict): The request data.
+
+        Returns:
+            dict: A standardized response.
+        """
+        try:
+            with db.session.begin():
+                validated_data = RepaymentService.validate_data(data, RepaymentSchema())
+                customer_id =  validated_data.get('customerId')
+                request_id =  validated_data.get('requestId')
+                loan_id = validated_data.get('debtId')
+                product_id = validated_data.get('productId')
+                account_id = validated_data.get('accountId')
+                customer = Customer.get_customer(customer_id) 
+        
+                if(RepaymentService.validate_account_ownership(account_id = account_id, customer_id = customer_id)):
+
+                    # Save the repayment details  
+                    repayment = Repayment.create_repayment(
+                        customer_id = customer_id,
+                        loan_id = loan_id,
+                        product_id = product_id
+
+                    )
+
+                    if not repayment:
+                        logger.error(f"Failed to save repayment details")
+                        return jsonify({
+                            "message": "Failed to save repayment details."
+                        }), 400
+                
+                    
+                    #Update Loan status
+                    Loan.update_status(loan_id = loan_id, status = LoanStatus.REPAID)
+                    
+                    transaction = RepaymentService.log_transaction(validated_data = validated_data)
+
+                    if not transaction:
+                        logger.error(f"Failed to log transaction")
+                        return jsonify({
+                            "message": "Failed to log transaction."
+                        }), 400   
+                else: 
+                    return jsonify({
+                            "message": "Invalid Customer or Account"
+                        }), 400
+        
+
+
+                # Simulated processing logic
+                response_data = {
+                    "customerId": customer_id,
+                    "productId": product_id,
+                    "debtId": loan_id,
+                    "resultCode": "00",
+                    "resultDescription": "Successful"
+                }
+
+                # return ResponseHelper.success(
+                #     data=response_data,
+                #     message="Repayment processed successfully"
+                # )
+
+                # Call Kafka in a background thread
+                thread = Thread(target=RepaymentService.async_send_to_kafka, args=(response_data, request_id, "LOAN_REPAYMENT"))
+                thread.start()
+
+                db.session.commit()
+                return response_data
+
+        except ValidationError as err:
+
+            logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}")
+            db.session.rollback() 
+
+            return jsonify({
+                "message": "Validation exception"
+                }) , 422
+        
+        except  ValueError as err:
+            logger.error(f"{getattr(err, 'messages', str(err))}")
+            db.session.rollback() 
+
+            return jsonify({
+                "message": str(err)
+                }) , 400
+
+        except Exception as e:
+            logger.error(f"An error occurred: {str(e)}", exc_info=True)
+            db.session.rollback() 
+            return jsonify({
+                "message": "Internal Server Error"
+                }) , 500