update

app/api/schemas/loan_status.py

@@ -0,0 +1,9 @@
+from marshmallow import Schema, fields
+
+# Loan Information Schema
+class LoanStatusSchema(Schema):
+    transactionId = fields.Str(required=True)
+    accountId = fields.Str(required=True)
+    customerId = fields.Str(required=True)
+    msisdn = fields.Str(required=False)
+    channel = fields.Str(required=True)

app/api/services/__init__.py

@@ -1,10 +1,5 @@
-# from app.api.services.eligibility_check import EligibilityCheckService
-# from app.api.services.select_offer import SelectOfferService
-# from app.api.services.provide_loan import ProvideLoanService
-# from app.api.services.loan_status import LoanStatusService
-# from app.api.services.repayment import RepaymentService
+from app.api.services.loan_status import LoanStatusService
 from app.api.services.customer_consent import CustomerConsentService
-# from app.api.services.notification_callback import NotificationCallbackService
 from app.api.services.authorization import AuthorizationService
 from app.api.services.transaction import TransactionService
 from app.api.services.loan import LoanService

app/api/services/loan_status.py

@@ -0,0 +1,108 @@
+from flask import request, jsonify
+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.services.base_service import BaseService
+from app.api.enums import TransactionType   
+from app.extensions import db  
+
+
+class LoanStatusService(BaseService):
+    TRANSACTION_TYPE = TransactionType.LOAN_STATUS 
+
+    @staticmethod
+    def process_request(data):
+        """
+        Process the Loan Information request.
+
+        Args:
+            data (dict): The request data.
+
+        Returns:
+            dict: A standardized response.
+        """
+        try:
+            with db.session.begin():
+                # Validate data
+                validated_data = LoanStatusService.validate_data(data, LoanStatusSchema())
+
+
+                customer_id =  validated_data.get('customerId')
+                customer = Customer.get_customer(customer_id)
+                transactionId = validated_data.get('transactionId')
+                account_id = validated_data.get('accountId')
+
+                if(LoanStatusService.validate_account_ownership(account_id = account_id, customer_id = customer_id)):
+
+                    # Get loans
+                    loans = [loan.to_dict() for loan in customer.loans if loan.status == LoanStatus.ACTIVE]
+
+                    transaction = LoanStatusService.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
+        
+
+                # loans = [
+                #     {
+                #         "debtId": "123456789",
+                #         "loanDate": "2019-10-18 14:26:21.063",
+                #         "dueDate": "2019-11-20 14:26:21.063",
+                #         "currentLoanAmount": 8500,
+                #         "initialLoanAmount": 10000,
+                #         "defaultPenaltyFee": 0,
+                #         "continuousFee": 0,
+                #         "productId": "101"
+                #     }
+                # ]
+
+                total_debt_amount = sum(
+                    loan.get("currentLoanAmount") or 0
+                    for loan in loans
+                    )
+
+                # Simulated processing logic
+                response_data = {
+                    "customerId": customer_id,
+                    "transactionId": transactionId,
+                    "loans": loans,
+                    "totalDebtAmount": total_debt_amount,
+                    "resultCode": "00",
+                    "resultDescription": "Successful"
+                }
+
+                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

app/models/__init__.py

@@ -1,5 +1,6 @@
 from .customer import Customer
+from .account import Account
 from .loan import Loan
 from .transaction import Transaction
 
-__all__ = ['Customer', 'Loan', 'Transaction']
+__all__ = ['Customer', 'Account', 'Loan', 'Transaction']

app/models/transaction.py

@@ -3,7 +3,6 @@ from app.extensions import db
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy import and_, or_, not_
 
-
 class Transaction(db.Model):
     __tablename__ = 'transactions'
     id = db.Column(
@@ -11,9 +10,9 @@ class Transaction(db.Model):
         primary_key=True,
         autoincrement=True,
     )
-    # id = db.Column(db.Int, primary_key=True)
     transaction_id = db.Column(db.String(50), nullable=False)
-    account_id = db.Column(db.String(50), nullable=False)
+    account_id = db.Column(db.String(50), nullable=True)
+    customer_id = db.Column(db.String(50), nullable=True)
     type = db.Column(db.String(50), nullable=False)
     channel = db.Column(db.String(50), nullable=False)
     created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
@@ -23,26 +22,25 @@ class Transaction(db.Model):
         return f'<Transaction {self.id}>'
 
     @classmethod
-    def create_transaction(cls, transaction_id, account_id, type, channel):
+    def create_transaction(cls, transaction_id, account_id, customer_id, type, channel):
 
         # if cls.query.filter_by(transaction_id=transaction_id).first():
         #     raise ValueError("Duplicate Transaction")
 
-        if cls.query.filter(and_(cls.transaction_id == transaction_id, cls.type == type)).first():
+        if cls.query.filter( and_( cls.transaction_id ==transaction_id, cls.type==type) ).first():
             raise ValueError("Duplicate Transaction")
 
         transaction = cls(
-            transaction_id=transaction_id,
-            account_id=account_id,
-            type=type,
-            channel=channel
+            transaction_id = transaction_id,
+            customer_id = customer_id,
+            account_id = account_id,
+            type = type,
+            channel = channel
         )
 
         try:
             db.session.add(transaction)
-            db.session.commit()
         except IntegrityError as err:
-            db.session.rollback()
             raise ValueError(f"Database integrity error: {err}")
 
         return transaction