[add]: transaction offer fix

app/api/helpers/response_helper.py

@@ -1,112 +1,251 @@
 from flask import jsonify
-from typing import Optional, Union, Dict, List, Any
+from typing import List, Dict, Union, Optional, Any
 
 
 class ResponseHelper:
     """
-    A helper class for building standardized JSON responses using resultCode and resultDescription.
+    A helper class for building standardized JSON responses in Flask.
     """
 
     @staticmethod
     def build_response(
-        result_code: str,
-        result_description: str,
-        data: Optional[Union[Dict, List, str]] = None
+        status: bool,
+        message: str,
+        data: Optional[Union[Dict, List, str]] = None,
+        status_code: int = 200,
+        error: Optional[Union[Dict, str]] = None,
     ) -> Dict[str, Any]:
+        """
+        Build a standardized JSON response.
+
+        Args:
+            status (bool): Indicates whether the request was successful.
+            message (str): A message describing the result of the request.
+            data (Optional[Union[Dict, List, str]]): The data to return in the response.
+            status_code (int): The HTTP status code for the response.
+            error (Optional[Union[Dict, str]]): Any error details to include in the response.
+
+        Returns:
+            Dict[str, Any]: A dictionary representing the JSON response.
+        """
         response = {
-            "resultCode": result_code,
-            "resultDescription": result_description
+            "status": status,
+            "statusCode": status_code,
+            "message": message,
+            "data": data if data is not None else {},
+            "error": error if error is not None else {},
         }
-
-        if isinstance(data, dict):
-            response.update(data)
-
-        return jsonify(response)
+        return jsonify(response), status_code
 
     @staticmethod
     def success(
-        result_description: str = "Successful",
-        result_code: str = "00",
-        data: Optional[Dict[str, Any]] = None
+        data: Optional[Union[Dict, List, str]] = None,
+        message: str = "Successful",
+        status_code: int = 200,
+        error: Optional[Union[Dict, str]] = None,
     ) -> Dict[str, Any]:
-        return ResponseHelper.build_response(result_code, result_description, data)
+        """
+        Return a success response.
+
+        Args:
+            data (Optional[Union[Dict, List, str]]): The data to return in the response.
+            message (str): A message describing the result of the request.
+            status_code (int): The HTTP status code for the response.
+            error (Optional[Union[Dict, str]]): Any error details to include in the response.
+
+        Returns:
+            Dict[str, Any]: A dictionary representing the JSON response.
+        """
+        return ResponseHelper.build_response(True, message, data, status_code, error)
 
     @staticmethod
     def error(
-        result_description: str = "An error occurred",
-        result_code: str = "01",
-        data: Optional[Dict[str, Any]] = None
+        message: str = "An error occurred",
+        status_code: int = 400,
+        data: Optional[Union[Dict, List, str]] = None,
+        error: Optional[Union[Dict, str]] = None,
     ) -> Dict[str, Any]:
-        return ResponseHelper.build_response(result_code, result_description, data)
+        """
+        Return an error response.
+
+        Args:
+            message (str): A message describing the error.
+            status_code (int): The HTTP status code for the response.
+            data (Optional[Union[Dict, List, str]]): The data to return in the response.
+            error (Optional[Union[Dict, str]]): Any error details to include in the response.
+
+        Returns:
+            Dict[str, Any]: A dictionary representing the JSON response.
+        """
+        return ResponseHelper.build_response(False, message, data, status_code, error)
 
     @staticmethod
     def created(
-        result_description: str = "Resource created successfully",
-        result_code: str = "00",
-        data: Optional[Dict[str, Any]] = None
+        data: Optional[Union[Dict, List, str]] = None,
+        message: str = "Resource created successfully",
+        error: Optional[Union[Dict, str]] = None,
     ) -> Dict[str, Any]:
-        return ResponseHelper.build_response(result_code, result_description, data)
+        """
+        Return a response for a created resource.
+
+        Args:
+            data (Optional[Union[Dict, List, str]]): The data to return in the response.
+            message (str): A message describing the result of the request.
+            error (Optional[Union[Dict, str]]): Any error details to include in the response.
+
+        Returns:
+            Dict[str, Any]: A dictionary representing the JSON response.
+        """
+        return ResponseHelper.build_response(True, message, data, 201, error)
 
     @staticmethod
     def updated(
-        result_description: str = "Resource updated successfully",
-        result_code: str = "00",
-        data: Optional[Dict[str, Any]] = None
+        data: Optional[Union[Dict, List, str]] = None,
+        message: str = "Resource updated successfully",
+        error: Optional[Union[Dict, str]] = None,
     ) -> Dict[str, Any]:
-        return ResponseHelper.build_response(result_code, result_description, data)
+        """
+        Return a response for an updated resource.
+
+        Args:
+            data (Optional[Union[Dict, List, str]]): The data to return in the response.
+            message (str): A message describing the result of the request.
+            error (Optional[Union[Dict, str]]): Any error details to include in the response.
+
+        Returns:
+            Dict[str, Any]: A dictionary representing the JSON response.
+        """
+        return ResponseHelper.build_response(True, message, data, 200, error)
 
     @staticmethod
     def internal_server_error(
-        result_description: str = "Internal Server Error",
-        result_code: str = "500",
-        data: Optional[Dict[str, Any]] = None
+        message: str = "Internal Server Error",
+        data: Optional[Union[Dict, List, str]] = None,
+        error: Optional[Union[Dict, str]] = None,
     ) -> Dict[str, Any]:
-        return ResponseHelper.build_response(result_code, result_description, data)
+        """
+        Return a response for an internal server error.
+
+        Args:
+            message (str): A message describing the error.
+            data (Optional[Union[Dict, List, str]]): The data to return in the response.
+            error (Optional[Union[Dict, str]]): Any error details to include in the response.
+
+        Returns:
+            Dict[str, Any]: A dictionary representing the JSON response.
+        """
+        return ResponseHelper.build_response(False, message, data, 500, error)
 
     @staticmethod
     def unauthorized(
-        result_description: str = "Unauthorized",
-        result_code: str = "401",
-        data: Optional[Dict[str, Any]] = None
+        message: str = "Unauthorized",
+        data: Optional[Union[Dict, List, str]] = None,
+        error: Optional[Union[Dict, str]] = None,
     ) -> Dict[str, Any]:
-        return ResponseHelper.build_response(result_code, result_description, data)
+        """
+        Return a response for an unauthorized request.
+
+        Args:
+            message (str): A message describing the error.
+            data (Optional[Union[Dict, List, str]]): The data to return in the response.
+            error (Optional[Union[Dict, str]]): Any error details to include in the response.
+
+        Returns:
+            Dict[str, Any]: A dictionary representing the JSON response.
+        """
+        return ResponseHelper.build_response(False, message, data, 401, error)
 
     @staticmethod
     def forbidden(
-        result_description: str = "Forbidden",
-        result_code: str = "403",
-        data: Optional[Dict[str, Any]] = None
+        message: str = "Forbidden",
+        data: Optional[Union[Dict, List, str]] = None,
+        error: Optional[Union[Dict, str]] = None,
     ) -> Dict[str, Any]:
-        return ResponseHelper.build_response(result_code, result_description, data)
+        """
+        Return a response for a forbidden request.
+
+        Args:
+            message (str): A message describing the error.
+            data (Optional[Union[Dict, List, str]]): The data to return in the response.
+            error (Optional[Union[Dict, str]]): Any error details to include in the response.
+
+        Returns:
+            Dict[str, Any]: A dictionary representing the JSON response.
+        """
+        return ResponseHelper.build_response(False, message, data, 403, error)
 
     @staticmethod
     def not_found(
-        result_description: str = "Resource not found",
-        result_code: str = "404",
-        data: Optional[Dict[str, Any]] = None
+        message: str = "Resource not found",
+        data: Optional[Union[Dict, List, str]] = None,
+        error: Optional[Union[Dict, str]] = None,
     ) -> Dict[str, Any]:
-        return ResponseHelper.build_response(result_code, result_description, data)
+        """
+        Return a response for a not found resource.
+
+        Args:
+            message (str): A message describing the error.
+            data (Optional[Union[Dict, List, str]]): The data to return in the response.
+            error (Optional[Union[Dict, str]]): Any error details to include in the response.
+
+        Returns:
+            Dict[str, Any]: A dictionary representing the JSON response.
+        """
+        return ResponseHelper.build_response(False, message, data, 404, error)
 
     @staticmethod
     def unprocessable_entity(
-        result_description: str = "Unprocessable entity",
-        result_code: str = "422",
-        data: Optional[Dict[str, Any]] = None
+        message: str = "Unprocessable entity",
+        data: Optional[Union[Dict, List, str]] = None,
+        error: Optional[Union[Dict, str]] = None,
     ) -> Dict[str, Any]:
-        return ResponseHelper.build_response(result_code, result_description, data)
+        """
+        Return a response for an unprocessable entity.
 
+        Args:
+            message (str): A message describing the error.
+            data (Optional[Union[Dict, List, str]]): The data to return in the response.
+            error (Optional[Union[Dict, str]]): Any error details to include in the response.
+
+        Returns:
+            Dict[str, Any]: A dictionary representing the JSON response.
+        """
+        return ResponseHelper.build_response(False, message, data, 422, error)
+    
     @staticmethod
     def method_not_allowed(
-        result_description: str = "Method Not Allowed",
-        result_code: str = "405",
-        data: Optional[Dict[str, Any]] = None
+        message: str = "Method Not Allowed",
+        data: Optional[Union[Dict, List, str]] = None,
+        error: Optional[Union[Dict, str]] = None,
     ) -> Dict[str, Any]:
-        return ResponseHelper.build_response(result_code, result_description, data)
+        """
+        Return a response for a method not allowed error.
 
+        Args:
+            message (str): A message describing the error.
+            data (Optional[Union[Dict, List, str]]): The data to return in the response.
+            error (Optional[Union[Dict, str]]): Any error details to include in the response.
+
+        Returns:
+            Dict[str, Any]: A dictionary representing the JSON response.
+        """
+        return ResponseHelper.build_response(False, message, data, 405, error)
+    
     @staticmethod
     def bad_request(
-        result_description: str = "Bad Request",
-        result_code: str = "400",
-        data: Optional[Dict[str, Any]] = None
+        message: str = "Bad Request",
+        data: Optional[Union[Dict, List, str]] = None,
+        error: Optional[Union[Dict, str]] = None,
     ) -> Dict[str, Any]:
-        return ResponseHelper.build_response(result_code, result_description, data)
+        """
+        Return a response for a bad request error.
+
+        Args:
+            message (str): A message describing the error.
+            data (Optional[Union[Dict, List, str]]): The data to return in the response.
+            error (Optional[Union[Dict, str]]): Any error details to include in the response.
+
+        Returns:
+            Dict[str, Any]: A dictionary representing the JSON response.
+        """
+        return ResponseHelper.build_response(False, message, data, 400, error)

app/api/integrations/simbrella.py

@@ -35,7 +35,7 @@ class SimbrellaIntegration:
             ],
         }
 
-        # logger.info(f"This is PayLoad: {str(payload)}", exc_info=True)
+        logger.info(f"This is PayLoad: {str(payload)}", exc_info=True)
 
         headers = {
             "Content-Type": "application/json",

app/api/services/authorization.py

@@ -34,7 +34,7 @@ class AuthorizationService(BaseService):
             logger.info("Processing Authorization request")
 
             if not data:
-                return ResponseHelper.bad_request(result_description="Missing JSON in request")
+                return ResponseHelper.bad_request(message="Missing JSON in request")
 
             # Validate input data using the Authorization schema
             schema = AuthorizeRequestSchema()
@@ -44,7 +44,7 @@ class AuthorizationService(BaseService):
                 validated_data["username"] != USERNAME
                 or validated_data["password"] != PASSWORD
             ):
-                return ResponseHelper.unauthorized(result_description="Invalid credentials")
+                return ResponseHelper.unauthorized(message="Invalid credentials")
 
             access_token = create_access_token(identity=validated_data["username"])
             refresh_token = create_refresh_token(identity=validated_data["username"])
@@ -56,17 +56,17 @@ class AuthorizationService(BaseService):
             }
 
             return ResponseHelper.success(
-                data={"data": response_data}, result_description="Authorization processed successfully"
+                data=response_data, message="Authorization processed successfully"
             )
 
         except ValidationError as e:
             logger.error(f"Validation error: {e}")
-            return ResponseHelper.bad_request(result_description=f"Validation error: {e}")
+            return ResponseHelper.bad_request(message=f"Validation error: {e}")
 
         except Exception as e:
             logger.error(f"Error processing Authorization request: {e}")
             return ResponseHelper.internal_server_error(
-                result_description=f"Error processing Authorization request: {e}"
+                message=f"Error processing Authorization request: {e}"
             )
 
     @staticmethod
@@ -92,11 +92,11 @@ class AuthorizationService(BaseService):
             }
 
             return ResponseHelper.success(
-                data={"data": response_data}, result_description="RefreshToken processed successfully"
+                data=response_data, message="RefreshToken processed successfully"
             )
 
         except Exception as e:
             logger.error(f"Error processing RefreshToken request: {e}")
             return ResponseHelper.internal_server_error(
-                result_description=f"Error processing RefreshToken request: {e}"
+                message=f"Error processing RefreshToken request: {e}"
             )

app/api/services/customer_consent.py

@@ -1,5 +1,4 @@
 from flask import request, jsonify
-from app.api.helpers.response_helper import ResponseHelper
 from app.api.services.base_service import BaseService
 from marshmallow import ValidationError
 from app.utils.logger import logger
@@ -35,26 +34,44 @@ class CustomerConsentService(BaseService):
 
                     if not transaction:
                         logger.error(f"Failed to log transaction")
-                        return ResponseHelper.error(result_description="Failed to log transaction.")
+                        return jsonify({
+                            "message": "Failed to log transaction."
+                        }), 400
                 else:  
-                    return ResponseHelper.error(result_description="Invalid Customer or Account")
+                    return jsonify({
+                            "message": "Invalid Customer or Account"
+                        }), 400
 
+                    
+                # Simulated processing logic
+                response_data = {
+                    "resultCode": "00",
+                    "resultDescription": "Request is received"
+                }
 
                 db.session.commit()
-                return ResponseHelper.success(result_description="Request is received")
+                return response_data
             
         except ValidationError as err:
 
             logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}")
             db.session.rollback()
-            return ResponseHelper.unprocessable_entity(result_description="Validation exception")
+
+            return jsonify({
+                "message": "Validation exception"
+                }) , 422
         
         except  ValueError as err:
             logger.error(f"{getattr(err, 'messages', str(err))}")
             db.session.rollback()
-            return ResponseHelper.error(result_description=str(err))
+
+            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 ResponseHelper.internal_server_error()
+            return jsonify({
+                "message": "Internal Server Error"
+                }) , 500

app/api/services/eligibility_check.py

@@ -1,5 +1,4 @@
 from flask import session, jsonify
-from app.models.loan import Loan
 from app.models.transaction_offers import TransactionOffer
 from app.utils.logger import logger
 from app.api.services.base_service import BaseService
@@ -9,9 +8,6 @@ from app.api.enums import TransactionType
 from app.api.integrations import SimbrellaIntegration
 from app.extensions import db
 from app.models import Offer, RACCheck
-from app.api.services.offer_analysis import OfferAnalysis
-from app.api.helpers.response_helper import ResponseHelper
-
 import random
 
 
@@ -46,17 +42,16 @@ class EligibilityCheckService(BaseService):
 
                     if not transaction:
                         logger.error(f"Failed to log transaction")
-                        return ResponseHelper.error(result_description="Failed to log transaction.")
-                else:  
-                    return ResponseHelper.error(result_description="Invalid Customer or Account")
+                        return jsonify({
+                            "message": "Failed to log transaction."
+                        }), 400
+                        
+                else: 
+                    return jsonify({
+                            "message": "Invalid Customer or Account"
+                        }), 400
                 
                 db.session.flush()
-
-                # Determine Loan count
-                is_eligible = EligibilityCheckService.check_loan_limits(customer_id)
-
-                if not is_eligible:
-                    return ResponseHelper.error(result_description="Max loan count reached")
                 
                 # Call RACCheck
                 response = SimbrellaIntegration.rac_check(
@@ -65,9 +60,9 @@ class EligibilityCheckService(BaseService):
                     transaction_id = transaction.transaction_id,
                 )
 
-                # this chek for error is not valid
+                # this chck for error is not valid
                 if response.status_code != 200:
-                    return ResponseHelper.error(result_description="RACCheck failed")
+                   return jsonify({"message": "RACCheck failed"}), 400
                 
                 response = response.json()
                 
@@ -80,52 +75,42 @@ class EligibilityCheckService(BaseService):
                 
                 if not rac_check:
                         logger.error(f"Failed to save RACCheck")
-                        return ResponseHelper.error(result_description="Failed to save RACCheck.")
-# -----------------TIME FOR ANALYSIS TO REGISTER OFFER ----------------------
-                # eligible_offers = []
-                try:
-                  eligible_offers = OfferAnalysis.decide_offer(
-                        transaction_id=transactionId,
-                        rac_check=rac_check,
-                        validated_data=validated_data,
-                        customer_id=customer_id
+                        return jsonify({
+                            "message": "Failed to save RACCheck."
+                        }), 400
+
+                offers = Offer.get_all_offers()
+
+                eligible_offers = []
+
+                for offer in offers:
+                    # Determine an approved amount
+                    random_float = random.random() # temporary to play data
+                    approved_amount = min(offer.max_amount, offer.max_amount * random_float) #temporary for now
+                    approved_amount = round(approved_amount, 2)
+
+                    transaction_offer = TransactionOffer.create_transaction_offer(
+                        customer_id = customer.id,
+                        transaction_id = transaction.transaction_id,
+                        offer_id = offer.id,
+                        min_amount = offer.min_amount,
+                        max_amount = offer.max_amount,
+                        eligible_amount = approved_amount,
+                        product_id = offer.product_id,
+                        tenor = offer.tenor
                     )
-                except ValueError as ve:
-                    logger.error(str(ve))
-                    return ResponseHelper.error(result_description= str(ve))
-# -----------------------------------------------------------------------
-#                 s = Offer.get_all_offers()
 
-                # eligible_offers = []
+                    # Visible offer ID: offer_id + padded(transaction_offer.id)
+                    padded_id = str(transaction_offer.id).zfill(6) 
+                    public_offer_id = f"{offer.id}{padded_id}"
 
-                # for offer in offers:
-                #     # Determine an approved amount
-                #     random_float = random.random() # temporary to play data
-                #     approved_amount = min(offer.max_amount, offer.max_amount * random_float) #temporary for now
-                #     approved_amount = round(approved_amount, 2)
-                #
-                #     transaction_offer = TransactionOffer.create_transaction_offer(
-                #         customer_id = customer.id,
-                #         transaction_id = transaction.transaction_id,
-                #         offer_id = offer.id,
-                #         min_amount = offer.min_amount,
-                #         max_amount = offer.max_amount,
-                #         eligible_amount = approved_amount,
-                #         product_id = offer.product_id,
-                #         tenor = offer.tenor
-                #     )
-                #
-                #     # Visible offer ID: offer_id + padded(transaction_offer.id)
-                #     padded_id = str(transaction_offer.id).zfill(6)
-                #     public_offer_id = f"{offer.id}{padded_id}"
-                #
-                #     eligible_offers.append({
-                #         "offerId": public_offer_id,
-                #         "product_id": offer.product_id,
-                #         "min_amount": offer.min_amount,
-                #         "max_amount": approved_amount,
-                #         "tenor": offer.tenor
-                #     })
+                    eligible_offers.append({
+                        "offerId": public_offer_id,
+                        "product_id": offer.product_id,
+                        "min_amount": offer.min_amount,
+                        "max_amount": approved_amount,
+                        "tenor": offer.tenor
+                    })
 
                 # Simulate processing
                 response_data = {
@@ -134,52 +119,30 @@ class EligibilityCheckService(BaseService):
                     "countryCode": "NG",
                     "msisdn": msisdn,
                     "eligibleOffers": eligible_offers,
+                    "resultDescription": "Successful",
+                    "resultCode": "00",
                     "accountId": account_id
                     }
 
-                return ResponseHelper.success(data=response_data)
+                return response_data
         
         except ValidationError as err:
 
             logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}")
-            db.session.rollback()
-            return ResponseHelper.unprocessable_entity(result_description="Validation exception")
+
+            return jsonify({
+                "message": "Validation exception"
+                }) , 422
         
         except  ValueError as err:
             logger.error(f"{getattr(err, 'messages', str(err))}")
-            db.session.rollback()
-            return ResponseHelper.error(result_description=str(err))
+
+            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 ResponseHelper.internal_server_error()
-        
-
-    @staticmethod
-    def check_loan_limits(customer_id):
-        """
-        Checks if a customer has exceeded the loan limits for given offer.
-        """  
-        loan = Loan.get_customer_last_loan(customer_id)
-
-        if not loan:
-            return True
-        
-        offer_id = loan.offer_id[:5]
-
-        offer = Offer.get_offer_by_id(offer_id)
-        if not offer:
-            logger.error(f"Offer not found for offer_id: {offer_id} (customer_id: {customer_id})")
-            return False
-
-        daily_count = TransactionOffer.get_daily_loan_count(customer_id, offer_id)
-        
-        
-        logger.error(f"daily_count: {daily_count}, Max: {offer.max_daily_loans}")
-
-        if offer.max_daily_loans is not None and daily_count >= offer.max_daily_loans:
-            return False
-        
-
-        return True
+            return jsonify({
+                "message": "Internal Server Error"
+                }) , 500

app/api/services/loan_status.py

@@ -6,8 +6,7 @@ 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
-from app.api.helpers.response_helper import ResponseHelper
+from app.extensions import db  
 
 
 class LoanStatusService(BaseService):
@@ -44,9 +43,13 @@ class LoanStatusService(BaseService):
 
                     if not transaction:
                         logger.error(f"Failed to log transaction")
-                        return ResponseHelper.error(result_description="Failed to log transaction.")
-                else:  
-                    return ResponseHelper.error(result_description="Invalid Customer or Account")
+                        return jsonify({
+                            "message": "Failed to log transaction."
+                        }), 400
+                else: 
+                    return jsonify({
+                            "message": "Invalid Customer or Account"
+                        }), 400
         
 
                 # loans = [
@@ -73,23 +76,33 @@ class LoanStatusService(BaseService):
                     "transactionId": transactionId,
                     "loans": loans,
                     "totalDebtAmount": total_debt_amount,
+                    "resultCode": "00",
+                    "resultDescription": "Successful"
                 }
 
                 db.session.commit()
-                return ResponseHelper.success(data=response_data)
+                return response_data
 
         except ValidationError as err:
 
             logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}")
             db.session.rollback()
-            return ResponseHelper.unprocessable_entity(result_description="Validation exception")
+
+            return jsonify({
+                "message": "Validation exception"
+                }) , 422
         
         except  ValueError as err:
             logger.error(f"{getattr(err, 'messages', str(err))}")
             db.session.rollback()
-            return ResponseHelper.error(result_description=str(err))
+
+            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 ResponseHelper.internal_server_error()
+            return jsonify({
+                "message": "Internal Server Error"
+                }) , 500

app/api/services/notification_callback.py

@@ -5,7 +5,6 @@ from app.api.enums import TransactionType
 from app.utils.logger import logger
 from app.api.schemas.notification_callback import NotificationCallbackSchema
 from app.extensions import db
-from app.api.helpers.response_helper import ResponseHelper
 
 class NotificationCallbackService(BaseService):
     TRANSACTION_TYPE = TransactionType.NOTIFICATION_CALLBACK 
@@ -28,20 +27,37 @@ class NotificationCallbackService(BaseService):
             schema = NotificationCallbackSchema()
             validated_data = schema.load(data)  # Raises ValidationError if invalid
 
-            return ResponseHelper.success()
+            # Simulated processing logic
+            response_data = {
+                "resultCode": "00",
+                "resultDescription": "Successful"
+            }
+
+
+            # return ResponseHelper.success(
+            #     data=response_data,
+            #     message="Notification callback processed successfully"
+            # )
+
+            return response_data
 
         except ValidationError as err:
 
             logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}")
-            db.session.rollback()
-            return ResponseHelper.unprocessable_entity(result_description="Validation exception")
+
+            return jsonify({
+                "message": "Validation exception"
+                }) , 422
         
         except  ValueError as err:
             logger.error(f"{getattr(err, 'messages', str(err))}")
-            db.session.rollback()
-            return ResponseHelper.error(result_description=str(err))
+
+            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 ResponseHelper.internal_server_error()
+            return jsonify({
+                "message": "Internal Server Error"
+                }) , 500

app/api/services/offer_analysis.py

@@ -1,6 +1,6 @@
 from app.models import Offer, TransactionOffer
 from app.models.loan import Loan
-import random
+
 import logging
 logger = logging.getLogger(__name__)
 
@@ -30,97 +30,8 @@ class OfferAnalysis:
         if not offer:
             raise ValueError("Invalid Offer.")
         original_transaction =  transaction_id
+        # we can now find the origin transactions
+        customer_loan = Loan.get_customer_current_active_loan(customer_id)
+
 
         return transaction_offer, offer, eligible_amount, original_transaction
-
-    @staticmethod
-    def decide_offer(transaction_id, rac_check, validated_data, customer_id):
-        eligible_offers = []
-        # if we have active offers - we have to feed off it
-        logger.info(f"LOOOOOOOOOOOOOOOOOO** {customer_id}")
-
-        # we can now find the origin transactions
-        # Find the last loan - it will have original_transaction
-        last_customer_loan = Loan.get_customer_last_loan(customer_id)
-        # logger.info(f"{last_customer_loan}")
-
-        new_eligible_amount = 0
-
-        if last_customer_loan:
-            original_transaction = last_customer_loan.original_transaction or last_customer_loan.transaction_id
-            logger.info(f"transaction_id |-| original_transaction === > {transaction_id} {original_transaction}")
-            original_loan  = Loan.get_customer_original_loan(customer_id, original_transaction)
-            if original_loan is not None:
-                logger.info(f"original_loan === > {original_loan}")
-                logger.info(f"loan_offer_id === > {original_loan.offer_id}")
-
-                original_offer_id = str(original_loan.offer_id[:5])  # The last part is str
-                transaction_offer_id = int(original_loan.offer_id[5:])  # The last part is int
-                original_transaction_offer = TransactionOffer.is_valid_transaction_offer(transaction_offer_id, customer_id, original_loan.product_id)
-
-                active_loans = Loan.get_active_loans_by_original_transaction(original_transaction)
-                sum_active_loans = sum(loan.current_loan_amount for loan in active_loans)
-                logger.info(f"sum_active_loans === > {sum_active_loans}")
-                real_eligible_amount = original_loan.eligible_amount - sum_active_loans
-
-                transaction_offer = TransactionOffer.create_transaction_offer(
-                    customer_id=customer_id,
-                    transaction_id=transaction_id,
-                    original_transaction=original_transaction,
-                    offer_id=original_offer_id,
-                    min_amount=original_transaction_offer.min_amount,
-                    max_amount=original_transaction_offer.max_amount,
-                    eligible_amount=real_eligible_amount,
-                    product_id=original_loan.product_id,
-                    tenor=original_loan.tenor
-                )
-
-                # Visible offer ID: offer_id + padded(transaction_offer.id)
-                padded_id = str(transaction_offer.id).zfill(6)
-                public_offer_id = f"{original_offer_id}{padded_id}"
-
-                eligible_offers.append({
-                    "offerId": public_offer_id,
-                    "product_id": original_transaction_offer.product_id,
-                    "min_amount": original_transaction_offer.min_amount,
-                    "max_amount": round(real_eligible_amount, 2),
-                    "tenor": original_loan.tenor
-                })
-                return eligible_offers
-
-
-        offers = Offer.get_all_offers()
-
-
-        for offer in offers:
-            # Get approved amount
-            random_float = random.random()  # temporary to play data
-
-            approved_amount = new_eligible_amount if new_eligible_amount > 0 else min(offer.max_amount, offer.max_amount * random_float) 
-            approved_amount = round(approved_amount, 2)
-
-            transaction_offer = TransactionOffer.create_transaction_offer(
-                customer_id=customer_id,
-                transaction_id=transaction_id,
-                original_transaction=transaction_id,
-                offer_id=offer.id,
-                min_amount=offer.min_amount,
-                max_amount=offer.max_amount,
-                eligible_amount=approved_amount,
-                product_id=offer.product_id,
-                tenor=offer.tenor
-            )
-
-            # Visible offer ID: offer_id + padded(transaction_offer.id)
-            padded_id = str(transaction_offer.id).zfill(6)
-            public_offer_id = f"{offer.id}{padded_id}"
-
-            eligible_offers.append({
-                "offerId": public_offer_id,
-                "product_id": offer.product_id,
-                "min_amount": offer.min_amount,
-                "max_amount": approved_amount,
-                "tenor": offer.tenor
-            })
-
-        return eligible_offers

app/api/services/provide_loan.py

@@ -15,7 +15,6 @@ from datetime import datetime, timezone
 from dateutil.relativedelta import relativedelta
 from app.models import LoanRepaymentSchedule 
 from app.api.services.offer_analysis import OfferAnalysis
-from app.api.helpers.response_helper import ResponseHelper
 
 class ProvideLoanService(BaseService):
     TRANSACTION_TYPE = TransactionType.PROVIDE_LOAN 
@@ -43,7 +42,6 @@ class ProvideLoanService(BaseService):
                 offer_id = validated_data.get('offerId')
                 amount = validated_data.get("requestedAmount")
                 product_id = validated_data.get("productId")
-                channel = validated_data.get('channel')
 
                 customer = Customer.is_valid_customer(customer_id)
 
@@ -59,7 +57,9 @@ class ProvideLoanService(BaseService):
                         )
                     except ValueError as ve:
                         logger.error(str(ve))
-                        return ResponseHelper.error(result_description=str(ve))
+                        return jsonify({
+                            "message": str(ve)
+                        }), 400
                     
                     # transaction_offer_id =  int(offer_id[5:]) # The last part is int
 
@@ -86,7 +86,9 @@ class ProvideLoanService(BaseService):
 
                     if not transaction:
                         logger.error(f"Failed to log transaction")
-                        return ResponseHelper.error(result_description="Failed to log transaction.")
+                        return jsonify({
+                            "message": "Failed to log transaction."
+                        }), 400
                     
 
                     db.session.flush()
@@ -106,6 +108,7 @@ class ProvideLoanService(BaseService):
                     vat = charges["vat"]
                     
 
+
                     # Save the loan details
                     loan = Loan.create_loan(
                         customer_id = customer_id,
@@ -114,7 +117,7 @@ class ProvideLoanService(BaseService):
                         product_id = offer.product_id,
                         collection_type = collection_type,
                         transaction_id = validated_data.get('transactionId'),
-                        original_transaction = transaction_offer.original_transaction,
+                        original_transaction = validated_data.get('transactionId'),
                         initial_loan_amount = validated_data.get('requestedAmount'),
                         upfront_fee = upfront_fee,
                         repayment_amount = repayment_amount,
@@ -122,25 +125,29 @@ class ProvideLoanService(BaseService):
                         eligible_amount=eligible_amount,
                         status = LoanStatus.ACTIVE,
                         tenor = offer.tenor,
+
                     )
 
                     if not loan:
                         logger.error(f"Failed to save loan details")
-                        
-                        return ResponseHelper.error(result_description="Failed to save loan details.")
+                        return jsonify({
+                            "message": "Failed to save loan details."
+                        }), 400
 
                     db.session.flush()
-                    current_product_id = offer.product_id
+
                     schedule = LoanRepaymentSchedule.add_repayment_schedule(loan = loan, num_schedules = num_schedules, transaction_id = transaction_id)
 
 
                     if not schedule:
                         logger.error(f"Failed to create repayment schedule for loan ID {loan.id}")
-                        return ResponseHelper.error(result_description="Failed to generate loan repayment schedule.")
+                        return jsonify({
+                            "message": "Failed to generate loan repayment schedule."
+                        }), 400
 
                     # charges = Charge.get_offer_charges(offer.id)
 
-                    # logger.info(f"{charges}")
+                    logger.info(f"{charges}")
                     
                     loan_id = loan.id
 
@@ -149,7 +156,9 @@ class ProvideLoanService(BaseService):
 
                     
                 else: 
-                    return ResponseHelper.error(result_description="Invalid Customer or Account")
+                    return jsonify({
+                            "message": "Invalid Customer or Account"
+                        }), 400
             
             
                 response_data = {
@@ -157,29 +166,40 @@ class ProvideLoanService(BaseService):
                     "transactionId": transaction_id,
                     "customerId": customer_id,
                     "accountId": account_id,
-                    "msisdn": customer.msisdn
+                    "msisdn": customer.msisdn,
+                    "resultCode": "00",
+                    "resultDescription": "Successful"
                     }
 
+
                 # KafkaIntegration.send_loan_request(loan_data = response_data, request_id = request_id)
                 # Call Kafka in a background thread
                 thread = Thread(target=ProvideLoanService.async_send_to_kafka, args=(response_data, request_id, "PROCESS_PAYMENT"))
                 thread.start()
 
                 db.session.commit()
-                return ResponseHelper.success(data=response_data)
+                return response_data
 
         except ValidationError as err:
 
             logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}")
-            db.session.rollback()
-            return ResponseHelper.unprocessable_entity(result_description="Validation exception")
+            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 ResponseHelper.error(result_description=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 ResponseHelper.internal_server_error()
+            db.session.rollback() 
+            return jsonify({
+                "message": "Internal Server Error"
+                }) , 500

app/api/services/repayment.py

@@ -1,7 +1,6 @@
 from flask import request, jsonify
 from marshmallow import ValidationError
 from app.api.enums.loan_status import LoanStatus
-from app.api.helpers.response_helper import ResponseHelper
 from app.models import Repayment
 from app.models.customer import Customer
 from app.models.loan import Loan
@@ -50,7 +49,9 @@ class RepaymentService(BaseService):
 
                     if not repayment:
                         logger.error(f"Failed to save repayment details")
-                        return ResponseHelper.error(result_description="Failed to save repayment details.")
+                        return jsonify({
+                            "message": "Failed to save repayment details."
+                        }), 400
                 
                     
                     #Update Loan status
@@ -60,9 +61,13 @@ class RepaymentService(BaseService):
 
                     if not transaction:
                         logger.error(f"Failed to log transaction")
-                        return ResponseHelper.error(result_description="Failed to log transaction.") 
+                        return jsonify({
+                            "message": "Failed to log transaction."
+                        }), 400   
                 else: 
-                    return ResponseHelper.error(result_description="Invalid Customer or Account")
+                    return jsonify({
+                            "message": "Invalid Customer or Account"
+                        }), 400
         
 
 
@@ -71,28 +76,43 @@ class RepaymentService(BaseService):
                     "transactionId": transaction_id,
                     "customerId": customer_id,
                     "productId": product_id,
-                    "debtId": loan_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 ResponseHelper.success(data=response_data)
+                return response_data
 
         except ValidationError as err:
 
             logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}")
-            db.session.rollback()
-            return ResponseHelper.unprocessable_entity(result_description="Validation exception")
+            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 ResponseHelper.error(result_description=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 ResponseHelper.internal_server_error()
+            db.session.rollback() 
+            return jsonify({
+                "message": "Internal Server Error"
+                }) , 500

app/api/services/select_offer.py

@@ -1,6 +1,5 @@
 from flask import request, jsonify
 from marshmallow import ValidationError
-from app.api.helpers.response_helper import ResponseHelper
 from app.api.services.base_service import BaseService
 from app.api.enums import TransactionType
 from app.utils.logger import logger
@@ -36,10 +35,10 @@ class SelectOfferService(BaseService):
                 transaction_offer_id = validated_data.get("offerId")
                 transaction_id = validated_data.get("transactionId")
                 request_id = validated_data.get("requestId")
+                
 
                 offer_id = int(transaction_offer_id[5:])  # The last part is int
 
-                #"offerId": "SAL30001129",
 
                 if SelectOfferService.validate_account_ownership(
                     account_id=account_id, customer_id=customer_id
@@ -50,9 +49,9 @@ class SelectOfferService(BaseService):
 
                     if not transaction:
                         logger.error(f"Failed to log transaction")
-                        return ResponseHelper.error(result_description="Failed to log transaction.")
-                else:  
-                    return ResponseHelper.error(result_description="Invalid Customer or Account")
+                        return jsonify({"message": "Failed to log transaction."}), 400
+                else:
+                    return jsonify({"message": "Invalid Customer or Account"}), 400
 
                 # Get the offer by product ID
                 offer = Offer.get_offer_by_product_id(product_id)
@@ -92,7 +91,7 @@ class SelectOfferService(BaseService):
                         "amount": amount,
                         "upfrontPayment": upfront_payment,
                         "interestRate": offer.interest_rate,
-                        "interestFee": interest_amount,
+                        "interestAmount": interest_amount,
                         "managementRate": offer.management_rate,
                         "managementFee": management["fee"],
                         "insuranceRate": offer.insurance_rate,
@@ -129,24 +128,26 @@ class SelectOfferService(BaseService):
                     "customerId": customer_id,
                     "accountId": account_id,
                     "loan": offers,
+                    "resultCode": "00",
+                    "resultDescription": "Successful",
                 }
 
                 db.session.commit()
-                return ResponseHelper.success(data=response_data)
+                return response_data
 
         except ValidationError as err:
 
             logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}")
-            db.session.rollback()
-            return ResponseHelper.unprocessable_entity(result_description="Validation exception")
-        
-        except  ValueError as 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 ResponseHelper.error(result_description=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 ResponseHelper.internal_server_error()
+            db.session.rollback() 
+            return jsonify({"message": "Internal Server Error"}), 500
         

app/errors/handlers.py

@@ -5,20 +5,20 @@ from app.api.helpers.response_helper import ResponseHelper
 def register_error_handlers(app):
     @app.errorhandler(HTTPException)
     def handle_http_exception(e):
-        return ResponseHelper.error(result_description=e.description, result_code=e.code )
+        return jsonify({'error': e.description}), e.code
     
     @app.errorhandler(405)
     def method_not_allowed(error):
-        return ResponseHelper.method_not_allowed()
+        return jsonify({"message": "Method Not Allowed"}), 405
 
     @app.errorhandler(404)
     def not_found(error):
-        return ResponseHelper.not_found()
+        return jsonify({"message": "Resource not found"}), 404
 
     @app.errorhandler(400)
     def bad_request(error):
-        return ResponseHelper.bad_request()
+        return jsonify({"message": "Bad Request"}), 400
 
     @app.errorhandler(415)
     def unsupported_media_type(error):
-        return ResponseHelper.error(result_description="Unsupported Media Type", result_code="415")
+        return jsonify({"message": "Unsupported Media Type"}), 415

app/models/account.py

@@ -2,7 +2,6 @@ from datetime import datetime, timezone
 from sqlalchemy.orm import relationship
 from app.extensions import db
 from sqlalchemy.exc import IntegrityError
-from sqlalchemy.sql import func
 
 class Account(db.Model):
     __tablename__ = 'accounts'
@@ -12,8 +11,8 @@ class Account(db.Model):
     account_type = db.Column(db.String(50))
     status = db.Column(db.String(20), default='active')
     lien_amount = db.Column(db.Float, default=0.0)
-    created_at = db.Column(db.DateTime(timezone=True), server_default=func.now())
-    updated_at = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
+    created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
+    updated_at = db.Column(db.DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
 
     customer = relationship(
         "Customer",
@@ -27,9 +26,7 @@ class Account(db.Model):
         account = cls(
             id=id,
             customer_id=customer_id,
-            account_type=account_type,
-            created_at=datetime.now(timezone.utc),
-            updated_at=datetime.now(timezone.utc)
+            account_type=account_type
         )
 
         try:

app/models/charge.py

@@ -1,7 +1,6 @@
 from datetime import datetime, timezone, timedelta
 from app.extensions import db
 from sqlalchemy.orm import relationship
-from sqlalchemy.sql import func
 
 
 class Charge(db.Model):
@@ -13,8 +12,9 @@ class Charge(db.Model):
     percent = db.Column(db.Float, default=0.0)
     description = db.Column(db.Text, nullable=True)
     due = db.Column(db.Integer, nullable=False)
-    created_at = db.Column(db.DateTime(timezone=True), server_default=func.now())
-    updated_at = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
+    created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
+    updated_at = db.Column(db.DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
+
     offer = relationship(
         "Offer",
         primaryjoin="Charge.offer_id == Offer.id",
@@ -57,9 +57,7 @@ class Charge(db.Model):
                 code = code,
                 percent = percent,
                 description = description,
-                due = due_days,
-                created_at=datetime.now(timezone.utc),
-                updated_at=datetime.now(timezone.utc)
+                due = due_days
             )
 
             db.session.add(charge_obj)

app/models/customer.py

@@ -3,7 +3,6 @@ from sqlalchemy.orm import relationship
 from app.extensions import db
 from app.models.account import Account
 from sqlalchemy.exc import IntegrityError
-from sqlalchemy.sql import func
 
 class Customer(db.Model):
     __tablename__ = 'customers'
@@ -11,8 +10,9 @@ class Customer(db.Model):
     id = db.Column(db.String(50), primary_key=True) 
     msisdn = db.Column(db.String(20), unique=True, nullable=False)
     country_code = db.Column(db.String(3), nullable=False)
-    created_at = db.Column(db.DateTime(timezone=True), server_default=func.now())
-    updated_at = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
+    created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
+    updated_at = db.Column(db.DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
+
     accounts = relationship(
         "Account",
         primaryjoin="Customer.id == Account.customer_id",
@@ -47,13 +47,7 @@ class Customer(db.Model):
             raise ValueError("Customer already exists")
         
         # Create the customer
-        customer = cls(
-            id=id,
-            msisdn=msisdn,
-            country_code=country_code,
-            created_at=datetime.now(timezone.utc),
-            updated_at=datetime.now(timezone.utc)
-            )
+        customer = cls(id=id, msisdn=msisdn, country_code=country_code)
         try: 
             db.session.add(customer)
             

app/models/loan.py

@@ -7,9 +7,6 @@ from sqlalchemy.orm import relationship
 from dateutil.relativedelta import relativedelta 
 from datetime import timedelta
 import logging
-from sqlalchemy import and_, or_, not_
-from sqlalchemy.sql import func
-
 logger = logging.getLogger(__name__)
 
 
@@ -38,11 +35,9 @@ class Loan(db.Model):
     status = db.Column(db.String(20), default='pending')
     tenor = db.Column(db.Integer, nullable=True)
     due_date = db.Column(db.DateTime, nullable=True) 
-    created_at = db.Column(db.DateTime(timezone=True), server_default=func.now())
-    updated_at = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
+    created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
+    updated_at = db.Column(db.DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
     eligible_amount = db.Column(db.Float, nullable=True, default=0.0)
-    disburse_date = db.Column(db.DateTime, nullable=True)
-    disburse_verify = db.Column(db.DateTime, nullable=True)
 
     customer = relationship(
         "Customer",
@@ -109,9 +104,7 @@ class Loan(db.Model):
             due_date=due_date,
             tenor = tenor,
             status = status,
-            eligible_amount =eligible_amount,
-            created_at=datetime.now(timezone.utc),
-            updated_at=datetime.now(timezone.utc)
+            eligible_amount =eligible_amount
         )
         
         try:
@@ -143,53 +136,24 @@ class Loan(db.Model):
         return loan
 
     @classmethod
-    def get_customer_original_loan(cls, customer_id, original_transaction):
-        """
-        Get customer's original loan  offer.
-        """
-        original_loan = cls.query.filter(and_( cls.customer_id ==customer_id, cls.original_transaction==original_transaction, cls.transaction_id==original_transaction )).first()
-        if not original_loan:
-            return None
-
-        logger.info(f" get_customer_original_loan ==>>>>  {original_loan}")
-        return original_loan
-
-    @classmethod
-    def get_customer_last_loan(cls, customer_id):
+    def get_customer_current_active_loan(cls, customer_id):
         """
         Get customer's active loans.
         """
-        logger.info(f"get_customer_last_loan [customer_id] ==>>>>  {customer_id}")
-        # loan = cls.query.filter_by( cls.customer_id == customer_id).first()
-        loan = cls.query.filter(and_( cls.customer_id ==customer_id, cls.status=='active')).first()
-
+        loan = cls.query.filter_by( customer_id = customer_id).first()
         if not loan:
-            return None
-            # loan = {
-            #     "original_transaction":"",
-            #     "eligible_amount": 0,
-            #     "loan_amount": 0,
-            #     "customer_id": customer_id,
-            #     "transaction_id": "",
-            #     "resultDescription": "No Active Loan"
-            # }
-        logger.info(f" get_customer_last_loan ==>>>>  {loan}")
+            loan = {
+                "eligible_amount": 0,
+                "loan_amount": 0,
+                "customer_id": customer_id,
+                "transaction_id": "",
+                "resultDescription": "No Active Loan"
+            }
+
+            logger.info(f" Active Loan ==>>>>  {loan}")
+
         return loan
 
-    @classmethod
-    def get_active_loans_by_original_transaction(cls, original_transaction_id):
-        """
-        Get all active loans with the same original_transaction ID.
-        """
-
-        active_loans = cls.query.filter_by(
-        original_transaction=original_transaction_id,
-        # status='active'
-        ).all()
-
-        return active_loans
-
-
     @classmethod
     def update_status(cls, loan_id, status):
         """

app/models/loan_charge.py

@@ -2,7 +2,6 @@ from datetime import datetime, timezone, timedelta
 from app.extensions import db
 from sqlalchemy.orm import relationship
 from app.utils.logger import logger
-from sqlalchemy.sql import func
 
 
 class LoanCharge(db.Model):
@@ -17,8 +16,9 @@ class LoanCharge(db.Model):
     description = db.Column(db.Text, nullable=True)
     due = db.Column(db.Integer, nullable=False)
     due_date = db.Column(db.DateTime, nullable=True)
-    created_at = db.Column(db.DateTime(timezone=True), server_default=func.now())
-    updated_at = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
+    created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
+    updated_at = db.Column(db.DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
+
     loan = relationship(
         "Loan",
         primaryjoin="LoanCharge.loan_id == Loan.id",
@@ -63,9 +63,7 @@ class LoanCharge(db.Model):
                 percent = percent,
                 description = description,
                 due = due_days,
-                due_date = now + timedelta(days=due_days),
-                created_at=datetime.now(timezone.utc),
-                updated_at=datetime.now(timezone.utc)
+                due_date = now + timedelta(days=due_days)
             )
 
             db.session.add(charge_obj)

app/models/loan_repayment_schedule.py

@@ -2,7 +2,6 @@ from datetime import datetime, timezone
 from app.extensions import db
 from sqlalchemy.orm import relationship
 from dateutil.relativedelta import relativedelta
-from sqlalchemy.sql import func
 
 class LoanRepaymentSchedule(db.Model):
     __tablename__ = 'loan_repayment_schedules'
@@ -18,8 +17,9 @@ class LoanRepaymentSchedule(db.Model):
     paid = db.Column(db.Boolean, default=False)
     paid_at = db.Column(db.DateTime, nullable=True)
 
-    created_at = db.Column(db.DateTime(timezone=True), server_default=func.now())
-    updated_at = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
+    created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
+    updated_at = db.Column(db.DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
+
     loan = relationship(
         "Loan",
         primaryjoin="LoanRepaymentSchedule.loan_id == Loan.id",
@@ -45,9 +45,7 @@ class LoanRepaymentSchedule(db.Model):
                 total_repayment_amount = round(loan.repayment_amount, 2),
                 installment_amount=round(loan.installment_amount, 2),
                 product_id = loan.product_id,
-                transaction_id = transaction_id,
-                created_at=datetime.now(timezone.utc),
-                updated_at=datetime.now(timezone.utc)
+                transaction_id = transaction_id
             )
             
             db.session.add(schedule)

app/models/offer.py

@@ -2,7 +2,6 @@ from datetime import datetime, timezone
 from app.extensions import db
 from app.models.charge import Charge
 from sqlalchemy.orm import relationship
-from sqlalchemy.sql import func
 
 class Offer(db.Model):
     __tablename__ = 'offers'
@@ -18,11 +17,8 @@ class Offer(db.Model):
     insurance_rate = db.Column(db.Float, default=1.0)
     vat_rate = db.Column(db.Float, default=7.5)
     list_order = db.Column(db.Integer, nullable=True)
-    max_daily_loans = db.Column(db.Integer, nullable=True)
-    max_active_loans = db.Column(db.Integer, nullable=True)
-    max_life_loans = db.Column(db.Integer, nullable=True)
-    created_at = db.Column(db.DateTime(timezone=True), server_default=func.now())
-    updated_at = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
+    created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
+    updated_at = db.Column(db.DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
 
     charges = relationship(
         "Charge",
@@ -83,11 +79,7 @@ class Offer(db.Model):
             "interest_rate": self.interest_rate,
             "management_rate": self.management_rate,
             "insurance_rate": self.insurance_rate,
-            "vat_rate": self.vat_rate,
-            "maxDailyLoans": self.max_daily_loans,
-            "maxActiveLoans": self.max_active_loans,
-            "maxLifeLoans": self.max_life_loans
-
+            "vat_rate": self.vat_rate
         }
     
     def __repr__(self):

app/models/rac_checks.py

@@ -4,7 +4,6 @@ from sqlalchemy.orm import relationship
 from sqlalchemy.exc import IntegrityError
 from uuid import uuid4
 from sqlalchemy.types import JSON
-from sqlalchemy.sql import func
 
 class RACCheck(db.Model):
     __tablename__ = 'rac_checks'
@@ -14,8 +13,9 @@ class RACCheck(db.Model):
     customer_id = db.Column(db.String, nullable=False)
     account_id = db.Column(db.String, nullable=False)
     rac_response = db.Column(db.JSON, nullable=False)
-    created_at = db.Column(db.DateTime(timezone=True), server_default=func.now())
-    updated_at = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
+    created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
+    updated_at = db.Column(db.DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
+
     @classmethod
     def add_rac_check(cls, customer_id, account_id, transaction_id, data = None):
     
@@ -25,9 +25,7 @@ class RACCheck(db.Model):
             customer_id = customer_id,
             account_id = account_id,
             transaction_id = transaction_id,
-            rac_response = data,
-            created_at=datetime.now(timezone.utc),
-            updated_at=datetime.now(timezone.utc)
+            rac_response = data
         )
         
         try:

app/models/repayment.py

@@ -4,7 +4,6 @@ from app.extensions import db
 from app.models.customer import Customer
 from app.models.loan import Loan
 from sqlalchemy.exc import IntegrityError
-from sqlalchemy.sql import func
 
 
 class Repayment(db.Model):
@@ -18,8 +17,8 @@ class Repayment(db.Model):
     loan_id = db.Column(db.String(50), nullable=False)
     customer_id = db.Column(db.String(50), nullable=False)
     product_id = db.Column(db.String(20), nullable=True)
-    created_at = db.Column(db.DateTime(timezone=True), server_default=func.now())
-    updated_at = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
+    created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
+    updated_at = db.Column(db.DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
     transaction_id = db.Column(db.String(50), nullable=True)
 
     @classmethod
@@ -42,9 +41,7 @@ class Repayment(db.Model):
             customer_id=customer_id,
             loan_id=loan_id,
             product_id=product_id,
-            transaction_id = transaction_id,
-            created_at=datetime.now(timezone.utc),
-            updated_at=datetime.now(timezone.utc)
+            transaction_id = transaction_id
         )
 
         try:

app/models/transaction.py

@@ -3,7 +3,6 @@ from app.extensions import db
 from app.models import account
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy import and_, or_, not_
-from sqlalchemy.sql import func
 
 class Transaction(db.Model):
     __tablename__ = 'transactions'
@@ -17,8 +16,9 @@ class Transaction(db.Model):
     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(timezone=True), server_default=func.now())
-    updated_at = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
+    created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
+    updated_at = db.Column(db.DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
+
     def __repr__(self):
         return f'<Transaction {self.id}>'
 
@@ -38,9 +38,7 @@ class Transaction(db.Model):
             customer_id = customer_id,
             account_id = account_id,
             type = type,
-            channel = channel,
-            created_at=datetime.now(timezone.utc),
-            updated_at=datetime.now(timezone.utc)
+            channel = channel
         )
 
         try:

app/models/transaction_offers.py

@@ -1,12 +1,6 @@
-from datetime import datetime, timezone, timedelta
-from app.api.enums.loan_status import LoanStatus
+from datetime import datetime, timezone
 from app.extensions import db
 from sqlalchemy.orm import relationship
-from sqlalchemy.sql import func
-import logging
-logger = logging.getLogger(__name__)
-
-
 
 class TransactionOffer(db.Model):
     __tablename__ = 'transaction_offers'
@@ -14,7 +8,6 @@ class TransactionOffer(db.Model):
     id = db.Column(db.Integer, primary_key=True, autoincrement=True)
     customer_id = db.Column(db.String(50), nullable=False)
     transaction_id = db.Column(db.String(50), nullable=False)
-    original_transaction = db.Column(db.String(50), nullable=True)
     offer_id = db.Column(db.String(20), nullable=False)
     product_id = db.Column(db.String(20), nullable=True)
     min_amount = db.Column(db.Float, nullable=False)
@@ -22,8 +15,9 @@ class TransactionOffer(db.Model):
     eligible_amount = db.Column(db.Float, nullable=True)
     tenor = db.Column(db.Integer, nullable=True)  # tenor in months, typically
 
-    created_at = db.Column(db.DateTime(timezone=True), server_default=func.now())
-    updated_at = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
+    created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
+    updated_at = db.Column(db.DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
+
     customer = relationship(
         "Customer",
         primaryjoin="Customer.id == TransactionOffer.customer_id",
@@ -32,9 +26,9 @@ class TransactionOffer(db.Model):
     )
 
     @classmethod
-    def is_valid_transaction_offer(cls, transaction_offer, customer_id, product_id):
+    def is_valid_transaction_offer(cls, transaction_offer_id, customer_id, product_id):
         transaction_offer = cls.query.filter_by(
-            id = transaction_offer,
+            id = transaction_offer_id,
             customer_id = customer_id,
             # product_id = product_id
             # transaction_id = transaction_id,
@@ -46,22 +40,19 @@ class TransactionOffer(db.Model):
         return transaction_offer
 
     @classmethod
-    def create_transaction_offer(cls, customer_id, transaction_id, original_transaction, offer_id, min_amount, max_amount, eligible_amount=None, product_id=None, tenor=None):
+    def create_transaction_offer(cls, customer_id, transaction_id, offer_id, min_amount, max_amount, eligible_amount=None, product_id=None, tenor=None):
         """
         Class method to create and save a TransactionOffer.
         """
         transaction_offer = cls(
             customer_id=customer_id,
             transaction_id=transaction_id,
-            original_transaction=original_transaction,
             offer_id=offer_id,
             min_amount=min_amount,
             max_amount=max_amount,
             eligible_amount=eligible_amount,
             product_id=product_id,
-            tenor=tenor,
-            created_at=datetime.now(timezone.utc),
-            updated_at=datetime.now(timezone.utc)
+            tenor=tenor
         )
 
         db.session.add(transaction_offer)
@@ -69,43 +60,6 @@ class TransactionOffer(db.Model):
 
         return transaction_offer
     
-    @classmethod
-    def get_lifetime_loan_count(cls, customer_id):
-        """
-        Returns the total number of loans ever created for a customer.
-        """
-        return cls.query.filter_by(customer_id=customer_id).count()
-
-    @classmethod
-    def get_daily_loan_count(cls, customer_id, offer_id):
-        """
-        Returns the count of loans created today for a customer.
-        """
-
-        start_of_day = datetime.now(timezone.utc).replace(hour=0, minute=0, second=0, microsecond=0)
-        end_of_day = start_of_day + timedelta(days=1)
-
-        return cls.query.filter_by(
-            customer_id=customer_id,
-            offer_id=offer_id
-            ).filter(
-            cls.created_at >= start_of_day,
-            cls.created_at < end_of_day
-        ).count()
-
-
-    @classmethod
-    def get_latest_transaction_offer(cls, customer_id):
-        """
-        Returns the most recent transaction offer for the given customer based on creation time.
-        """
-        return cls.query.filter_by(customer_id=customer_id) \
-            .order_by(cls.created_at.desc()) \
-            .first()
-
-
-    
-
     def to_dict(self):
         return {
             'id': self.id,

app/swagger/schemas/ProvideLoanResponse.json

@@ -9,10 +9,6 @@
             "type": "string",
             "example": "Tr201712RK9232P115"
         },
-        "loanRef": {
-            "type": "string",
-            "example": "1620029887USSDAMPC"
-        },
         "customerId": {
             "type": "string",
             "example": "CN621868"

app/swagger/schemas/SelectOfferRequest.json

@@ -28,7 +28,7 @@
         },
         "productId": {
             "type": "string",
-            "example": "3MPC"
+            "example": "2090"
         },
         "offerId": {
             "type": "string",

app/swagger/schemas/SelectOfferResponse.json

@@ -28,7 +28,7 @@
                     },
                     "productId": {
                         "type": "string",
-                        "example": "3MPC"
+                        "example": "2030"
                     },
                     "amount": {
                         "type": "number",
@@ -49,7 +49,7 @@
                         "format": "float",
                         "example": 3.0
                     },
-                    "interestFee": {
+                    "interestAmount": {
                         "type": "number",
                         "format": "float",
                         "example": 3000.00

migrations/versions/173ea45db189_migration_on_sat_may_10_09_54_34_utc_.py

@@ -1,32 +0,0 @@
-"""Migration on Sat May 10 09:54:34 UTC 2025
-
-Revision ID: 173ea45db189
-Revises: 3105abd795d4
-Create Date: 2025-05-10 09:54:39.380499
-
-"""
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = '173ea45db189'
-down_revision = '3105abd795d4'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table('transaction_offers', schema=None) as batch_op:
-        batch_op.add_column(sa.Column('original_transaction', sa.String(length=50), nullable=True))
-
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table('transaction_offers', schema=None) as batch_op:
-        batch_op.drop_column('original_transaction')
-
-    # ### end Alembic commands ###

migrations/versions/2eee4157505f_.py

@@ -1,250 +0,0 @@
-"""empty message
-
-Revision ID: 2eee4157505f
-Revises: 565bc3d0ba6e
-Create Date: 2025-05-16 13:24:41.914400
-
-"""
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import postgresql
-
-# revision identifiers, used by Alembic.
-revision = '2eee4157505f'
-down_revision = '565bc3d0ba6e'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table('accounts', schema=None) as batch_op:
-        batch_op.alter_column('created_at',
-               existing_type=postgresql.TIMESTAMP(),
-               type_=sa.DateTime(timezone=True),
-               existing_nullable=True)
-        batch_op.alter_column('updated_at',
-               existing_type=postgresql.TIMESTAMP(),
-               type_=sa.DateTime(timezone=True),
-               existing_nullable=True)
-
-    with op.batch_alter_table('charges', schema=None) as batch_op:
-        batch_op.alter_column('created_at',
-               existing_type=postgresql.TIMESTAMP(),
-               type_=sa.DateTime(timezone=True),
-               existing_nullable=True)
-        batch_op.alter_column('updated_at',
-               existing_type=postgresql.TIMESTAMP(),
-               type_=sa.DateTime(timezone=True),
-               existing_nullable=True)
-
-    with op.batch_alter_table('customers', schema=None) as batch_op:
-        batch_op.alter_column('created_at',
-               existing_type=postgresql.TIMESTAMP(),
-               type_=sa.DateTime(timezone=True),
-               existing_nullable=True)
-        batch_op.alter_column('updated_at',
-               existing_type=postgresql.TIMESTAMP(),
-               type_=sa.DateTime(timezone=True),
-               existing_nullable=True)
-
-    with op.batch_alter_table('loan_charges', schema=None) as batch_op:
-        batch_op.alter_column('created_at',
-               existing_type=postgresql.TIMESTAMP(),
-               type_=sa.DateTime(timezone=True),
-               existing_nullable=True)
-        batch_op.alter_column('updated_at',
-               existing_type=postgresql.TIMESTAMP(),
-               type_=sa.DateTime(timezone=True),
-               existing_nullable=True)
-
-    with op.batch_alter_table('loan_repayment_schedules', schema=None) as batch_op:
-        batch_op.alter_column('created_at',
-               existing_type=postgresql.TIMESTAMP(),
-               type_=sa.DateTime(timezone=True),
-               existing_nullable=True)
-        batch_op.alter_column('updated_at',
-               existing_type=postgresql.TIMESTAMP(),
-               type_=sa.DateTime(timezone=True),
-               existing_nullable=True)
-
-    with op.batch_alter_table('loans', schema=None) as batch_op:
-        batch_op.alter_column('created_at',
-               existing_type=postgresql.TIMESTAMP(),
-               type_=sa.DateTime(timezone=True),
-               existing_nullable=True)
-        batch_op.alter_column('updated_at',
-               existing_type=postgresql.TIMESTAMP(),
-               type_=sa.DateTime(timezone=True),
-               existing_nullable=True)
-
-    with op.batch_alter_table('offers', schema=None) as batch_op:
-        batch_op.alter_column('created_at',
-               existing_type=postgresql.TIMESTAMP(),
-               type_=sa.DateTime(timezone=True),
-               existing_nullable=True)
-        batch_op.alter_column('updated_at',
-               existing_type=postgresql.TIMESTAMP(),
-               type_=sa.DateTime(timezone=True),
-               existing_nullable=True)
-
-    with op.batch_alter_table('rac_checks', schema=None) as batch_op:
-        batch_op.alter_column('created_at',
-               existing_type=postgresql.TIMESTAMP(),
-               type_=sa.DateTime(timezone=True),
-               existing_nullable=True)
-        batch_op.alter_column('updated_at',
-               existing_type=postgresql.TIMESTAMP(),
-               type_=sa.DateTime(timezone=True),
-               existing_nullable=True)
-
-    with op.batch_alter_table('repayments', schema=None) as batch_op:
-        batch_op.alter_column('created_at',
-               existing_type=postgresql.TIMESTAMP(),
-               type_=sa.DateTime(timezone=True),
-               existing_nullable=True)
-        batch_op.alter_column('updated_at',
-               existing_type=postgresql.TIMESTAMP(),
-               type_=sa.DateTime(timezone=True),
-               existing_nullable=True)
-
-    with op.batch_alter_table('transaction_offers', schema=None) as batch_op:
-        batch_op.alter_column('created_at',
-               existing_type=postgresql.TIMESTAMP(),
-               type_=sa.DateTime(timezone=True),
-               existing_nullable=True)
-        batch_op.alter_column('updated_at',
-               existing_type=postgresql.TIMESTAMP(),
-               type_=sa.DateTime(timezone=True),
-               existing_nullable=True)
-
-    with op.batch_alter_table('transactions', schema=None) as batch_op:
-        batch_op.alter_column('created_at',
-               existing_type=postgresql.TIMESTAMP(),
-               type_=sa.DateTime(timezone=True),
-               existing_nullable=True,
-               existing_server_default=sa.text('now()'))
-        batch_op.alter_column('updated_at',
-               existing_type=postgresql.TIMESTAMP(),
-               type_=sa.DateTime(timezone=True),
-               existing_nullable=True,
-               existing_server_default=sa.text('now()'))
-
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table('transactions', schema=None) as batch_op:
-        batch_op.alter_column('updated_at',
-               existing_type=sa.DateTime(timezone=True),
-               type_=postgresql.TIMESTAMP(),
-               existing_nullable=True,
-               existing_server_default=sa.text('now()'))
-        batch_op.alter_column('created_at',
-               existing_type=sa.DateTime(timezone=True),
-               type_=postgresql.TIMESTAMP(),
-               existing_nullable=True,
-               existing_server_default=sa.text('now()'))
-
-    with op.batch_alter_table('transaction_offers', schema=None) as batch_op:
-        batch_op.alter_column('updated_at',
-               existing_type=sa.DateTime(timezone=True),
-               type_=postgresql.TIMESTAMP(),
-               existing_nullable=True)
-        batch_op.alter_column('created_at',
-               existing_type=sa.DateTime(timezone=True),
-               type_=postgresql.TIMESTAMP(),
-               existing_nullable=True)
-
-    with op.batch_alter_table('repayments', schema=None) as batch_op:
-        batch_op.alter_column('updated_at',
-               existing_type=sa.DateTime(timezone=True),
-               type_=postgresql.TIMESTAMP(),
-               existing_nullable=True)
-        batch_op.alter_column('created_at',
-               existing_type=sa.DateTime(timezone=True),
-               type_=postgresql.TIMESTAMP(),
-               existing_nullable=True)
-
-    with op.batch_alter_table('rac_checks', schema=None) as batch_op:
-        batch_op.alter_column('updated_at',
-               existing_type=sa.DateTime(timezone=True),
-               type_=postgresql.TIMESTAMP(),
-               existing_nullable=True)
-        batch_op.alter_column('created_at',
-               existing_type=sa.DateTime(timezone=True),
-               type_=postgresql.TIMESTAMP(),
-               existing_nullable=True)
-
-    with op.batch_alter_table('offers', schema=None) as batch_op:
-        batch_op.alter_column('updated_at',
-               existing_type=sa.DateTime(timezone=True),
-               type_=postgresql.TIMESTAMP(),
-               existing_nullable=True)
-        batch_op.alter_column('created_at',
-               existing_type=sa.DateTime(timezone=True),
-               type_=postgresql.TIMESTAMP(),
-               existing_nullable=True)
-
-    with op.batch_alter_table('loans', schema=None) as batch_op:
-        batch_op.alter_column('updated_at',
-               existing_type=sa.DateTime(timezone=True),
-               type_=postgresql.TIMESTAMP(),
-               existing_nullable=True)
-        batch_op.alter_column('created_at',
-               existing_type=sa.DateTime(timezone=True),
-               type_=postgresql.TIMESTAMP(),
-               existing_nullable=True)
-
-    with op.batch_alter_table('loan_repayment_schedules', schema=None) as batch_op:
-        batch_op.alter_column('updated_at',
-               existing_type=sa.DateTime(timezone=True),
-               type_=postgresql.TIMESTAMP(),
-               existing_nullable=True)
-        batch_op.alter_column('created_at',
-               existing_type=sa.DateTime(timezone=True),
-               type_=postgresql.TIMESTAMP(),
-               existing_nullable=True)
-
-    with op.batch_alter_table('loan_charges', schema=None) as batch_op:
-        batch_op.alter_column('updated_at',
-               existing_type=sa.DateTime(timezone=True),
-               type_=postgresql.TIMESTAMP(),
-               existing_nullable=True)
-        batch_op.alter_column('created_at',
-               existing_type=sa.DateTime(timezone=True),
-               type_=postgresql.TIMESTAMP(),
-               existing_nullable=True)
-
-    with op.batch_alter_table('customers', schema=None) as batch_op:
-        batch_op.alter_column('updated_at',
-               existing_type=sa.DateTime(timezone=True),
-               type_=postgresql.TIMESTAMP(),
-               existing_nullable=True)
-        batch_op.alter_column('created_at',
-               existing_type=sa.DateTime(timezone=True),
-               type_=postgresql.TIMESTAMP(),
-               existing_nullable=True)
-
-    with op.batch_alter_table('charges', schema=None) as batch_op:
-        batch_op.alter_column('updated_at',
-               existing_type=sa.DateTime(timezone=True),
-               type_=postgresql.TIMESTAMP(),
-               existing_nullable=True)
-        batch_op.alter_column('created_at',
-               existing_type=sa.DateTime(timezone=True),
-               type_=postgresql.TIMESTAMP(),
-               existing_nullable=True)
-
-    with op.batch_alter_table('accounts', schema=None) as batch_op:
-        batch_op.alter_column('updated_at',
-               existing_type=sa.DateTime(timezone=True),
-               type_=postgresql.TIMESTAMP(),
-               existing_nullable=True)
-        batch_op.alter_column('created_at',
-               existing_type=sa.DateTime(timezone=True),
-               type_=postgresql.TIMESTAMP(),
-               existing_nullable=True)
-
-    # ### end Alembic commands ###

migrations/versions/565bc3d0ba6e_migration_on_sat_may_10_12_54_52_utc_.py

@@ -1,34 +0,0 @@
-"""Migration on Sat May 10 12:54:52 UTC 2025
-
-Revision ID: 565bc3d0ba6e
-Revises: 173ea45db189
-Create Date: 2025-05-10 12:54:56.683215
-
-"""
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = '565bc3d0ba6e'
-down_revision = '173ea45db189'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table('loans', schema=None) as batch_op:
-        batch_op.add_column(sa.Column('disburse_date', sa.DateTime(), nullable=True))
-        batch_op.add_column(sa.Column('disburse_verify', sa.DateTime(), nullable=True))
-
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table('loans', schema=None) as batch_op:
-        batch_op.drop_column('disburse_verify')
-        batch_op.drop_column('disburse_date')
-
-    # ### end Alembic commands ###

migrations/versions/e8dd9b841ad7_.py

@@ -1,36 +0,0 @@
-"""empty message
-
-Revision ID: e8dd9b841ad7
-Revises: 2eee4157505f
-Create Date: 2025-05-19 11:46:19.204637
-
-"""
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = 'e8dd9b841ad7'
-down_revision = '2eee4157505f'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table('offers', schema=None) as batch_op:
-        batch_op.add_column(sa.Column('max_daily_loans', sa.Integer(), nullable=True))
-        batch_op.add_column(sa.Column('max_active_loans', sa.Integer(), nullable=True))
-        batch_op.add_column(sa.Column('max_life_loans', sa.Integer(), nullable=True))
-
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table('offers', schema=None) as batch_op:
-        batch_op.drop_column('max_life_loans')
-        batch_op.drop_column('max_active_loans')
-        batch_op.drop_column('max_daily_loans')
-
-    # ### end Alembic commands ###