[add]: ref_id and ref_model for transactions. And db session and rollback for transactions

app/api/services/base_service.py

@@ -44,15 +44,16 @@ class BaseService:
         return is_valid
 
     @classmethod
-    def log_transaction(cls, validated_data):
+    def log_transaction(cls, validated_data,):
         """
         Create a new transaction.
         """
         return Transaction.create_transaction(
-            transaction_id =validated_data.get("transactionId"),
-            account_id=validated_data.get("accountId"),
-            type=cls.TRANSACTION_TYPE,
-            channel=validated_data.get("channel"),
+            transaction_id = validated_data.get("transactionId"),
+            ref_id = validated_data.get("refId") or validated_data.get("accountId"),
+            ref_model = validated_data.get("refModel", "Account"),
+            type = cls.TRANSACTION_TYPE,
+            channel = validated_data.get("channel"),
         )
     
     @classmethod

app/api/services/customer_consent.py

@@ -4,7 +4,8 @@ from marshmallow import ValidationError
 from app.utils.logger import logger
 from app.api.schemas.customer_consent import CustomerConsentSchema
 from app.api.services.base_service import BaseService
-from app.api.enums import TransactionType   
+from app.api.enums import TransactionType 
+from app.extensions import db
 
 
 class CustomerConsentService(BaseService):
@@ -28,13 +29,14 @@ class CustomerConsentService(BaseService):
             customer_id =  validated_data.get('customerId')
 
             if(CustomerConsentService.validate_account_ownership(account_id = account_id, customer_id = customer_id)):
-                transaction = CustomerConsentService.log_transaction(validated_data = validated_data)
+                 with db.session.begin():
+                    transaction = CustomerConsentService.log_transaction(validated_data = validated_data)
 
-                if not transaction:
-                    logger.error(f"Failed to log transaction")
-                    return jsonify({
-                        "message": "Failed to log transaction."
-                    }), 400
+                    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"

app/api/services/eligibility_check.py

@@ -5,6 +5,7 @@ from app.api.schemas.eligibility_check import EligibilityCheckSchema
 from marshmallow import ValidationError
 from app.api.enums import TransactionType
 from app.api.integrations import SimbrellaIntegration
+from app.extensions import db
 
 class EligibilityCheckService(BaseService):
     TRANSACTION_TYPE = TransactionType.ELIGIBILITY_CHECK 
@@ -31,13 +32,14 @@ class EligibilityCheckService(BaseService):
             customer = EligibilityCheckService.get_or_create_customer(validated_data = validated_data)
 
             if (EligibilityCheckService.validate_account_ownership(account_id = account_id, customer_id = customer_id)):
-                transaction = EligibilityCheckService.log_transaction(validated_data = validated_data)
+                with db.session.begin():
+                    transaction = EligibilityCheckService.log_transaction(validated_data = validated_data)
 
-                if not transaction:
-                    logger.error(f"Failed to log transaction")
-                    return jsonify({
-                        "message": "Failed to log transaction."
-                    }), 400
+                    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"

app/api/services/loan_status.py

@@ -3,7 +3,8 @@ from marshmallow import ValidationError
 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.api.enums import TransactionType   
+from app.extensions import db  
 
 
 class LoanStatusService(BaseService):
@@ -27,13 +28,14 @@ class LoanStatusService(BaseService):
             account = customer.accounts[0]
 
             if (LoanStatusService.validate_account_ownership(account_id = account.id, customer_id = customer_id)):
-                transaction = LoanStatusService.log_transaction(validated_data = validated_data)
+                with db.session.begin():
+                    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
+                    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"

app/api/services/notification_callback.py

@@ -3,7 +3,8 @@ from marshmallow import ValidationError
 from app.api.services.base_service import BaseService
 from app.api.enums import TransactionType   
 from app.utils.logger import logger
-from app.api.schemas.notification_callback import NotificationCallbackSchema   
+from app.api.schemas.notification_callback import NotificationCallbackSchema
+from app.extensions import db
 
 class NotificationCallbackService(BaseService):
     TRANSACTION_TYPE = TransactionType.NOTIFICATION_CALLBACK 

app/api/services/provide_loan.py

@@ -8,6 +8,7 @@ from app.api.schemas.provide_loan import ProvideLoanSchema
 from threading import Thread
 from app.models.loan import Loan
 from app.api.enums import LoanStatus
+from app.extensions import db
 
 class ProvideLoanService(BaseService):
     TRANSACTION_TYPE = TransactionType.PROVIDE_LOAN 
@@ -33,29 +34,33 @@ class ProvideLoanService(BaseService):
 
             if (ProvideLoanService.validate_account_ownership(account_id = account_id, customer_id = customer_id)):
 
-                # Save the loan details  
-                loan = Loan.create_loan(
-                    customer_id=customer_id,
-                    account_id=account_id,
-                    offer_id=validated_data.get('offerId'),
-                    principal_amount=validated_data.get('requestedAmount'),
-                    status=LoanStatus.ACTIVE
-                )
+                with db.session.begin():
+                    # Save the loan details  
+                    loan = Loan.create_loan(
+                        customer_id=customer_id,
+                        account_id=account_id,
+                        offer_id=validated_data.get('offerId'),
+                        principal_amount=validated_data.get('requestedAmount'),
+                        status=LoanStatus.ACTIVE
+                    )
 
-                if not loan:
-                    logger.error(f"Failed to save loan details")
-                    return jsonify({
-                        "message": "Failed to save loan details."
-                    }), 400
-                
-                # Log Transaction
-                transaction = ProvideLoanService.log_transaction(validated_data = validated_data)
+                    if not loan:
+                        logger.error(f"Failed to save loan details")
+                        return jsonify({
+                            "message": "Failed to save loan details."
+                        }), 400
+                    
+                    validated_data['refId'] = loan.id
+                    validated_data['refModel'] = "loan"
+                    
+                    # Log Transaction
+                    transaction = ProvideLoanService.log_transaction(validated_data = validated_data)
 
-                if not transaction:
-                    logger.error(f"Failed to log transaction")
-                    return jsonify({
-                        "message": "Failed to log transaction."
-                    }), 400
+                    if not transaction:
+                        logger.error(f"Failed to log transaction")
+                        return jsonify({
+                            "message": "Failed to log transaction."
+                        }), 400
 
             
                 

app/api/services/repayment.py

@@ -7,7 +7,8 @@ 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 threading import Thread
+from app.extensions import db
 
 class RepaymentService(BaseService):
     TRANSACTION_TYPE = TransactionType.REPAYMENT 
@@ -26,20 +27,17 @@ class RepaymentService(BaseService):
         try:
             validated_data = RepaymentService.validate_data(data, RepaymentSchema())
             customer_id =  validated_data.get('customerId')
-            customer = RepaymentService.get_or_create_customer(validated_data)
-            account = customer.accounts[0]
-            validated_data['accountId'] = account.id
             request_id =  validated_data.get('requestId')
             loan_id = validated_data.get('debtId')
+            product_id = validated_data.get('productId')
 
-
-            if (RepaymentService.validate_account_ownership(account_id = account.id, customer_id = customer_id)):
-
-                # Save the repayment details  
+  
+            with db.session.begin():
+            # Save the repayment details  
                 repayment = Repayment.create_repayment(
                     customer_id = customer_id,
                     loan_id = loan_id,
-                    product_id = validated_data.get('productId')
+                    product_id = product_id
 
                 )
 
@@ -49,6 +47,9 @@ class RepaymentService(BaseService):
                         "message": "Failed to save repayment details."
                     }), 400
                 
+                validated_data['refId'] = repayment.id
+                validated_data['refModel'] = "repayment"
+                
                 #Update Loan status
                 Loan.update_status(loan_id = loan_id, status = LoanStatus.REPAID)
                 
@@ -59,16 +60,13 @@ class RepaymentService(BaseService):
                     return jsonify({
                         "message": "Failed to log transaction."
                     }), 400
-            else: 
-                return jsonify({
-                        "message": "Invalid Customer or Account"
-                    }), 400
+
 
             # Simulated processing logic
             response_data = {
-                "customerId": "CN621868",
-                "productId": "101",
-                "debtId": "273194670",
+                "customerId": customer_id,
+                "productId": product_id,
+                "debtId": loan_id,
                 "resultCode": "00",
                 "resultDescription": "Successful"
             }

app/api/services/select_offer.py

@@ -4,6 +4,7 @@ from app.api.services.base_service import BaseService
 from app.api.enums import TransactionType   
 from app.utils.logger import logger
 from app.api.schemas.select_offer import SelectOfferSchema
+from app.extensions import db
 
 class SelectOfferService(BaseService):
     TRANSACTION_TYPE = TransactionType.SELECT_OFFER 
@@ -25,13 +26,14 @@ class SelectOfferService(BaseService):
             customer_id =  validated_data.get('customerId')
 
             if (SelectOfferService.validate_account_ownership(account_id = account_id, customer_id = customer_id)):
-                transaction = SelectOfferService.log_transaction(validated_data = validated_data)
+                with db.session.begin():
+                    transaction = SelectOfferService.log_transaction(validated_data = validated_data)
 
-                if not transaction:
-                    logger.error(f"Failed to log transaction")
-                    return jsonify({
-                        "message": "Failed to log transaction."
-                    }), 400
+                    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"