update

app/api/routes/routes.py

@@ -1,7 +1,8 @@
 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.repayment_service import RepaymentService
+from app.api.services.loan_charge_service import LoanChargeService
 from app.api.services.loan_service import LoanService
 from app.api.services.transaction_service import TransactionService
 from app.api.services.auth_service import AuthService
@@ -138,11 +139,37 @@ def get_transactions():
     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
+@api.route('/repayments', methods=['GET'])
+# @token_required
+def get_all_repayments():
+    # Extract query parameters for filtering
+    filters = {
+        'loan_id': request.args.get('loan_id'),
+        'customer_id': request.args.get('customer_id'),
+        'product_id': request.args.get('product_id'),
+        'start_date': request.args.get('start_date'),
+        'end_date': request.args.get('end_date'),
+        'page': request.args.get('page', 1),
+        'limit': request.args.get('limit', 20)
+    }
+    # logger.info(f"Get repayments request received with filters: {filters}")
+    response = RepaymentService.get_all_repayments(filters)
+    return jsonify(response)
+
+@api.route('/loan-charges', methods=['GET'])
+# @token_required
+def get_all_loan_charges():
+    # Extract query parameters for filtering
+    filters = {
+        'loan_id': request.args.get('loan_id'),
+        'code': request.args.get('code'),
+        'start_date': request.args.get('start_date'),
+        'end_date': request.args.get('end_date'),
+        'due_before': request.args.get('due_before'),
+        'due_after': request.args.get('due_after'),
+        'page': request.args.get('page', 1),
+        'limit': request.args.get('limit', 20)
+    }
+    # logger.info(f"Get loan charges request received with filters: {filters}")
+    response = LoanChargeService.get_all_loan_charges(filters)
+    return jsonify(response)

app/api/schemas/repayment.py

@@ -1,12 +0,0 @@
-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

@@ -6,3 +6,4 @@ 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_service import RepaymentService
+from app.api.services.loan_charge_service import LoanChargeService

app/api/services/customer_consent.py

@@ -2,7 +2,7 @@ from flask import request, jsonify
 from app.api.services.base_service import BaseService
 from marshmallow import ValidationError
 from app.utils.logger import logger
-from app.api.schemas.customer_consent import CustomerConsentSchema
+from app.api.schemas.customer_consent_schema import CustomerConsentSchema
 from app.api.services.base_service import BaseService
 from app.api.enums import TransactionType 
 from app.extensions import db

app/api/services/loan_charge_service.py

@@ -0,0 +1,107 @@
+import logging
+from datetime import datetime
+from flask import jsonify
+from app.models.loan_charge import LoanCharge
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+class LoanChargeService:
+    """
+    Service class for handling loan charge-related operations.
+    """
+
+    @staticmethod
+    def get_all_loan_charges(filters=None):
+        """
+        Get all loan charges with optional filtering.
+
+        Args:
+            filters (dict, optional): Filters for the loan charges query.
+
+        Returns:
+            dict: A standardized response with loan charges data.
+        """
+        try:
+            if filters is None:
+                filters = {}
+
+            # Extract filters
+            loan_id = filters.get('loan_id')
+            code = filters.get('code')
+            start_date = filters.get('start_date')
+            end_date = filters.get('end_date')
+            due_before = filters.get('due_before')
+            due_after = filters.get('due_after')
+
+            # Extract pagination parameters
+            page = int(filters.get('page', 1))
+            limit = int(filters.get('limit', 20))
+
+            # Ensure page and limit are valid
+            if page < 1:
+                page = 1
+            if limit < 1 or limit > 100:
+                limit = 20
+
+            # Convert string dates to datetime objects if provided
+            if start_date and isinstance(start_date, str):
+                start_date = datetime.fromisoformat(start_date.replace('Z', '+00:00'))
+            if end_date and isinstance(end_date, str):
+                end_date = datetime.fromisoformat(end_date.replace('Z', '+00:00'))
+            if due_before and isinstance(due_before, str):
+                due_before = datetime.fromisoformat(due_before.replace('Z', '+00:00'))
+            if due_after and isinstance(due_after, str):
+                due_after = datetime.fromisoformat(due_after.replace('Z', '+00:00'))
+
+            # Get loan charges with optional filters and pagination
+            loan_charges, total_count = LoanCharge.get_all_loan_charges(
+                loan_id=loan_id,
+                code=code,
+                start_date=start_date,
+                end_date=end_date,
+                due_before=due_before,
+                due_after=due_after,
+                page=page,
+                limit=limit
+            )
+
+            # Convert loan charges to dictionary format
+            loan_charges_data = []
+            for charge in loan_charges:
+                loan_charges_data.append({
+                    'loan_id': charge.loan_id,
+                    'code': charge.code,
+                    'amount': charge.amount,
+                    'percent': charge.percent,
+                    'description': charge.description,
+                    'due': charge.due,
+                    'transaction_id': charge.transaction_id,
+                    'due_date': charge.due_date.isoformat() if charge.due_date else None,
+                    'created_at': charge.created_at.isoformat() if charge.created_at else None,
+                    'updated_at': charge.updated_at.isoformat() if charge.updated_at else None
+                })
+
+            # Calculate total pages
+            total_pages = (total_count + limit - 1) // limit
+
+            response_data = {
+                'loan_charges': loan_charges_data,
+                'count': len(loan_charges_data),
+                'pagination': {
+                    'total_count': total_count,
+                    'total_pages': total_pages,
+                    'current_page': page,
+                    'limit': limit,
+                    'has_next': page < total_pages,
+                    'has_prev': page > 1
+                }
+            }
+
+            return response_data
+
+        except Exception as e:
+            logger.error(f"An error occurred: {str(e)}", exc_info=True)
+            return jsonify({
+                "message": "Internal Server Error"
+            }), 500

app/api/services/loan_status.py

@@ -3,7 +3,7 @@ from marshmallow import ValidationError
 from app.api.enums.loan_status import LoanStatus
 from app.models import Customer
 from app.utils.logger import logger
-from app.api.schemas.loan_status import LoanStatusSchema 
+from app.api.schemas.loan_status_schema import LoanStatusSchema
 from app.api.services.base_service import BaseService
 from app.api.enums import TransactionType   
 from app.extensions import db  

app/api/services/repayment_service.py

@@ -1,115 +1,97 @@
-from flask import request, jsonify
-from marshmallow import ValidationError
-from app.api.enums.loan_status import LoanStatus
-from app.models.customer import Customer
-from app.models.loan import Loan
+import logging
+from datetime import datetime
+from flask import jsonify
 from app.models.repayment import Repayment
-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 
+# Configure logging
+logger = logging.getLogger(__name__)
+
+class RepaymentService:
+    """
+    Service class for handling repayment-related operations.
+    """
 
     @staticmethod
-    def process_request(data):
+    def get_all_repayments(filters=None):
         """
-        Process the Repayment request.
+        Get all repayments with optional filtering.
 
         Args:
-            data (dict): The request data.
+            filters (dict, optional): Filters for the repayments query.
 
         Returns:
-            dict: A standardized response.
+            dict: A standardized response with repayments data.
         """
         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)):
+            if filters is None:
+                filters = {}
 
-                    # Save the repayment details  
-                    repayment = Repayment.create_repayment(
-                        customer_id = customer_id,
-                        loan_id = loan_id,
-                        product_id = product_id
+            # Extract filters
+            loan_id = filters.get('loan_id')
+            customer_id = filters.get('customer_id')
+            product_id = filters.get('product_id')
+            start_date = filters.get('start_date')
+            end_date = filters.get('end_date')
 
-                    )
+            # Extract pagination parameters
+            page = int(filters.get('page', 1))
+            limit = int(filters.get('limit', 20))
 
-                    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)
+            # Ensure page and limit are valid
+            if page < 1:
+                page = 1
+            if limit < 1 or limit > 100:
+                limit = 20
 
-                    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
-        
+            # Convert string dates to datetime objects if provided
+            if start_date and isinstance(start_date, str):
+                start_date = datetime.fromisoformat(start_date.replace('Z', '+00:00'))
+            if end_date and isinstance(end_date, str):
+                end_date = datetime.fromisoformat(end_date.replace('Z', '+00:00'))
 
+            # Get repayments with optional filters and pagination
+            repayments, total_count = Repayment.get_all_repayments(
+                loan_id=loan_id,
+                customer_id=customer_id,
+                product_id=product_id,
+                start_date=start_date,
+                end_date=end_date,
+                page=page,
+                limit=limit
+            )
 
-                # Simulated processing logic
-                response_data = {
-                    "customerId": customer_id,
-                    "productId": product_id,
-                    "debtId": loan_id,
-                    "resultCode": "00",
-                    "resultDescription": "Successful"
+            # Convert repayments to dictionary format
+            repayments_data = []
+            for repayment in repayments:
+                repayments_data.append({
+                    'loan_id': repayment.loan_id,
+                    'customer_id': repayment.customer_id,
+                    'product_id': repayment.product_id,
+                    'transaction_id': repayment.transaction_id,
+                    'created_at': repayment.created_at.isoformat() if repayment.created_at else None,
+                    'updated_at': repayment.updated_at.isoformat() if repayment.updated_at else None
+                })
+
+            # Calculate total pages
+            total_pages = (total_count + limit - 1) // limit
+
+            response_data = {
+                'repayments': repayments_data,
+                'count': len(repayments_data),
+                'pagination': {
+                    'total_count': total_count,
+                    'total_pages': total_pages,
+                    'current_page': page,
+                    'limit': limit,
+                    'has_next': page < total_pages,
+                    'has_prev': page > 1
                 }
+            }
 
-                # 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
+            return response_data
 
         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
+            }), 500