[add]: loan max amount

app/api/enums/loan_status.py

@@ -3,4 +3,5 @@ from enum import Enum
 class LoanStatus(str, Enum):
     PENDING = "pending"
     ACTIVE = "active"
+    START_REPAY = "start_repay"
     REPAID = "repaid"

app/api/integrations/simbrella.py

@@ -7,15 +7,26 @@ import logging
 
 class SimbrellaIntegration:
     BASE_URL = settings.SIMBRELLA_BASE_URL
+    ENDPOINT_RAC_CHECKS = settings.SIMBRELLA_ENDPOINT_RAC_CHECKS
 
     @staticmethod
     def rac_check(customer_id, account_id, transaction_id):
         """
         Calls the RACCheck endpoit
         """
-        url = f"{SimbrellaIntegration.BASE_URL}/RACCheck"
+        url = f"{SimbrellaIntegration.BASE_URL}/{SimbrellaIntegration.ENDPOINT_RAC_CHECKS}"
+        logger.info(f"Contacting Rack Checks EndPoint: {str(url)}", exc_info=True)
 
-        payload = {
+        # {
+        #     "transactionId": "T001",
+        #     "fbnTransactionId": "Tr201712RK9232P115",
+        #     "customerId": "CN621868",
+        #     "accountId": "2017821799",
+        #     "channel": "USSD",
+        #     "countryCode": "NG"
+        # }
+        #
+        payload_old = {
             "customerId": customer_id,
             "accountId": account_id,
             "transactionId": str(transaction_id),
@@ -35,6 +46,14 @@ class SimbrellaIntegration:
             ],
         }
 
+        payload = {
+            "customerId": customer_id,
+            "accountId": account_id,
+            "transactionId": str(transaction_id),
+            "fbnTransactionId": f"FBN{transaction_id}",
+            "countryCode": "NG",
+            "channel": "USSD"
+        }
         # logger.info(f"This is PayLoad: {str(payload)}", exc_info=True)
 
         headers = {

app/api/schemas/repayment.py

@@ -5,8 +5,8 @@ class RepaymentSchema(Schema):
     type = fields.Str(required=False)
     msisdn = fields.Str(required=False) #optional
     debtId = fields.Str(required=True)
-    productId = fields.Str(required=True)
     transactionId = fields.Str(required=True)
     accountId = fields.Str(required=True)
     customerId = fields.Str(required=True)
-    channel = fields.Str(required=True)
+    loanRef = fields.Str(required=True)
+    initiatedBy = fields.Str(required=False)

app/api/services/eligibility_check.py

@@ -1,4 +1,5 @@
 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
@@ -50,6 +51,12 @@ class EligibilityCheckService(BaseService):
                     return ResponseHelper.error(result_description="Invalid Customer or Account")
                 
                 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(
@@ -58,7 +65,7 @@ class EligibilityCheckService(BaseService):
                     transaction_id = transaction.transaction_id,
                 )
 
-                # this chck for error is not valid
+                # this chek for error is not valid
                 if response.status_code != 200:
                     return ResponseHelper.error(result_description="RACCheck failed")
                 
@@ -68,12 +75,14 @@ class EligibilityCheckService(BaseService):
                     customer_id = customer_id,
                     account_id = account_id,
                     transaction_id = transaction.transaction_id,
-                    data = response['RACResponse']
+                    data = response['racResponse']
                     )
                 
                 if not rac_check:
                         logger.error(f"Failed to save RACCheck")
                         return ResponseHelper.error(result_description="Failed to save RACCheck.")
+
+                rack_checks_response = response['racResponse']
 # -----------------TIME FOR ANALYSIS TO REGISTER OFFER ----------------------
                 # eligible_offers = []
                 try:
@@ -81,7 +90,8 @@ class EligibilityCheckService(BaseService):
                         transaction_id=transactionId,
                         rac_check=rac_check,
                         validated_data=validated_data,
-                        customer_id=customer_id
+                        customer_id=customer_id,
+                        rack_checks_response =rack_checks_response
                     )
                 except ValueError as ve:
                     logger.error(str(ve))
@@ -146,4 +156,33 @@ class EligibilityCheckService(BaseService):
         except Exception as e:
             logger.error(f"An error occurred: {str(e)}", exc_info=True)
             db.session.rollback()
-            return ResponseHelper.internal_server_error()
+            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

app/api/services/loan_status.py

@@ -29,38 +29,23 @@ class LoanStatusService(BaseService):
                 # Validate data
                 validated_data = LoanStatusService.validate_data(data, LoanStatusSchema())
 
-
                 customer_id =  validated_data.get('customerId')
-                customer = Customer.get_customer(customer_id)
+
+                logger.info(f"Looking for customer *** {customer_id}")
+                customer = Customer.get_customer_with_loan_list(customer_id)
+                
                 transactionId = validated_data.get('transactionId')
                 account_id = validated_data.get('accountId')
 
                 if(LoanStatusService.validate_account_ownership(account_id = account_id, customer_id = customer_id)):
-
                     # Get loans
                     loans = [loan.to_dict() for loan in customer.loans if loan.status == LoanStatus.ACTIVE]
-
                     transaction = LoanStatusService.log_transaction(validated_data = validated_data)
-
                     if not transaction:
                         logger.error(f"Failed to log transaction")
                         return ResponseHelper.error(result_description="Failed to log transaction.")
                 else:  
                     return ResponseHelper.error(result_description="Invalid Customer or Account")
-        
-
-                # loans = [
-                #     {
-                #         "debtId": "123456789",
-                #         "loanDate": "2019-10-18 14:26:21.063",
-                #         "dueDate": "2019-11-20 14:26:21.063",
-                #         "currentLoanAmount": 8500,
-                #         "initialLoanAmount": 10000,
-                #         "defaultPenaltyFee": 0,
-                #         "continuousFee": 0,
-                #         "productId": "101"
-                #     }
-                # ]
 
                 total_debt_amount = sum(
                     loan.get("currentLoanAmount") or 0

app/api/services/offer_analysis.py

@@ -32,12 +32,32 @@ class OfferAnalysis:
         original_transaction =  transaction_id
 
         return transaction_offer, offer, eligible_amount, original_transaction
+    @staticmethod
+    def _analyze_rack_checks(rack_response):
+
+        # "racResponse": {
+        #     "accountStatus": true,
+        #     "bvnValidated": true,
+        #     "creditBureauCheck": false,
+        #     "crmsCheck": true,
+        #     "hasLien": false,
+        #     "hasPastDueLoan": false,
+        #     "hasSalaryAccount": true,
+        #     "isWhitelisted": true,
+        #     "noBouncedCheck": true
+        # },
+        #
+
+        return 0
 
     @staticmethod
-    def decide_offer(transaction_id, rac_check, validated_data, customer_id):
+    def decide_offer(transaction_id, rac_check, validated_data, customer_id, rack_checks_response):
         eligible_offers = []
         # if we have active offers - we have to feed off it
-        logger.info(f"LOOOOOOOOOOOOOOOOOO** {customer_id}")
+        logger.info(f"**RACK ANALYSIS** {customer_id}")
+        # Analyze Rack Checks
+        # _analyze_rack_checks(rack_checks_response)  --> We need detail analysis
+
 
         # we can now find the origin transactions
         # Find the last loan - it will have original_transaction
@@ -63,6 +83,10 @@ class OfferAnalysis:
                 logger.info(f"sum_active_loans === > {sum_active_loans}")
                 real_eligible_amount = original_loan.eligible_amount - sum_active_loans
 
+                if real_eligible_amount < original_transaction_offer.min_amount:
+                    logger.error(f"Max eligible amount ({real_eligible_amount}) is less than the minimum offer amount ({original_transaction_offer.min_amount}).")
+                    raise ValueError("You are not eligible for a loan at this time.")
+
                 transaction_offer = TransactionOffer.create_transaction_offer(
                     customer_id=customer_id,
                     transaction_id=transaction_id,

app/api/services/provide_loan.py

@@ -60,6 +60,13 @@ class ProvideLoanService(BaseService):
                     except ValueError as ve:
                         logger.error(str(ve))
                         return ResponseHelper.error(result_description=str(ve))
+
+
+                    if(amount < transaction_offer.min_amount):
+                        return ResponseHelper.error(result_description="The amount is less than the minimum allowed transaction amount.")
+                    elif amount > transaction_offer.max_amount:
+                        return ResponseHelper.error(result_description="The amount is greater than the maximum allowed transaction amount.")
+
                     
                     # transaction_offer_id =  int(offer_id[5:]) # The last part is int
 
@@ -105,6 +112,9 @@ class ProvideLoanService(BaseService):
                     insurance = charges["insurance"]
                     vat = charges["vat"]
                     
+                    padded_id = str(transaction_id).zfill(12)
+                    loan_ref = f"{padded_id}{channel}{offer.product_id}"
+
 
                     # Save the loan details
                     loan = Loan.create_loan(
@@ -122,6 +132,7 @@ class ProvideLoanService(BaseService):
                         eligible_amount=eligible_amount,
                         status = LoanStatus.ACTIVE,
                         tenor = offer.tenor,
+                        reference = loan_ref
                     )
 
                     if not loan:
@@ -151,10 +162,12 @@ class ProvideLoanService(BaseService):
                 else: 
                     return ResponseHelper.error(result_description="Invalid Customer or Account")
             
+                
             
                 response_data = {
                     "requestId": request_id,
                     "transactionId": transaction_id,
+                    "loanRef": loan_ref,
                     "customerId": customer_id,
                     "accountId": account_id,
                     "msisdn": customer.msisdn

app/api/services/repayment.py

@@ -32,30 +32,30 @@ class RepaymentService(BaseService):
                 customer_id =  validated_data.get('customerId')
                 request_id =  validated_data.get('requestId')
                 loan_id = validated_data.get('debtId')
-                product_id = validated_data.get('productId')
                 account_id = validated_data.get('accountId')
-                customer = Customer.get_customer(customer_id)
+                loan_ref = validated_data.get('loanRef')
+                # customer = Customer.get_customer_with_loan_list(customer_id)
                 transaction_id  = validated_data.get('transactionId')
+                initiated_by = validated_data.get('initiatedBy')
         
                 if(RepaymentService.validate_account_ownership(account_id = account_id, customer_id = customer_id)):
 
+                    # Check loan exists
+                    loan = Loan.get_customer_loan(loan_id = loan_id, customer_id = customer_id)
+
                     # Save the repayment details  
                     repayment = Repayment.create_repayment(
                         customer_id = customer_id,
-                        loan_id = loan_id,
-                        product_id = product_id,
-                        transaction_id=transaction_id
-
+                        loan = loan,
+                        transaction_id = transaction_id
                     )
 
                     if not repayment:
                         logger.error(f"Failed to save repayment details")
                         return ResponseHelper.error(result_description="Failed to save repayment details.")
-                
-                    
+
                     #Update Loan status
-                    Loan.update_status(loan_id = loan_id, status = LoanStatus.REPAID)
-                    
+                    Loan.update_status(loan_id = loan_id, status = LoanStatus.START_REPAY) # repay started bu user
                     transaction = RepaymentService.log_transaction(validated_data = validated_data)
 
                     if not transaction:
@@ -63,14 +63,13 @@ class RepaymentService(BaseService):
                         return ResponseHelper.error(result_description="Failed to log transaction.") 
                 else: 
                     return ResponseHelper.error(result_description="Invalid Customer or Account")
-        
-
 
                 # Simulated processing logic
                 response_data = {
                     "transactionId": transaction_id,
                     "customerId": customer_id,
-                    "productId": product_id,
+                    "productId": loan.product_id,
+                    "loanRef": loan_ref,
                     "debtId": loan_id
                 }
 

app/api/services/select_offer.py

@@ -59,6 +59,13 @@ class SelectOfferService(BaseService):
 
                 db.session.flush()
 
+                if amount < offer.min_amount:
+                    return ResponseHelper.error(result_description="The amount is less than the minimum allowed offer amount.")
+                elif amount > offer.max_amount:
+                    return ResponseHelper.error(result_description="The amount is greater than the maximum allowed offer amount.")
+
+                    
+
                 charges = SelectOfferService.calculate_charges(offer, amount)
                 upfront_payment = charges["upfront_payment"]
                 total_amount = charges["total_amount"]

app/config.py

@@ -1,7 +1,6 @@
 import os
 from datetime import timedelta
 
-
 class Config:
     """Base configuration for Flask app"""
 
@@ -9,20 +8,19 @@ class Config:
     API_URL = os.getenv("API_URL", "/swagger.json")
 
     DEBUG = True
-    VALID_APP_ID = os.getenv("VALID_APP_ID", "app1")
-    VALID_API_KEY = os.getenv("VALID_API_KEY", "test-api-key-12345")
     BASIC_AUTH_USERNAME = os.environ.get("BASIC_AUTH_USERNAME", "user")
     BASIC_AUTH_PASSWORD = os.environ.get("BASIC_AUTH_PASSWORD", "password")
 
+    # Database Configuration
     DATABASE_USER = os.environ.get("DATABASE_USER")
     DATABASE_PASSWORD = os.environ.get("DATABASE_PASSWORD")
     DATABASE_HOST = os.environ.get("DATABASE_HOST")
     DATABASE_PORT = os.environ.get("DATABASE_PORT", 10532)
     DATABASE_NAME = os.environ.get("DATABASE_NAME")
 
+    # Database Connection
     SQLALCHEMY_DATABASE_URI = f"postgresql+psycopg2://{DATABASE_USER}:{DATABASE_PASSWORD}@{DATABASE_HOST}:{DATABASE_PORT}/{DATABASE_NAME}"
     SQLALCHEMY_TRACK_MODIFICATIONS = False
-    SIMBRELLA_BASE_URL = os.getenv("SIMBRELLA_BASE_URL", "http://127.0.0.1:6337")
 
 
     JWT_SECRET_KEY = os.getenv("JWT_SECRET_KEY", "secret-key")
@@ -34,5 +32,20 @@ class Config:
     # KAFKA_BROKER = 'dev-events.simbrellang.net:9085'
     KAFKA_BROKER = os.getenv("KAFKA_BROKER", "dev-events.simbrellang.net:9085")
 
+   # SIMBRELLA_ENDPOINT_RAC_CHECKS = os.getenv("SIMBRELLA_ENDPOINT_RAC_CHECKS", "RACCheck")
+    VALID_APP_ID = os.getenv("SIMBRELLA_APP_ID", "app1")
+    VALID_API_KEY = os.getenv("SIMBRELLA_API_KEY", "testtest-api-key-12345")
+    SIMBRELLA_BASE_URL = os.getenv("SIMBRELLA_BASE_URL", "http://127.0.0.1:6337")
+    SIMBRELLA_ENDPOINT_RAC_CHECKS = os.getenv("SIMBRELLA_ENDPOINT_RAC_CHECKS","api/rac-check")
+
+    RAC_RESULT_accountStatus = os.environ.get("RAC_RESULT_accountStatus", "true")
+    RAC_RESULT_bvnValidated = os.environ.get("RAC_RESULT_bvnValidated", "true")
+    RAC_RESULT_creditBureauCheck = os.environ.get("RAC_RESULT_creditBureauCheck", "false")
+    RAC_RESULT_crmsCheck = os.environ.get("RAC_RESULT_crmsCheck", "true")
+    RAC_RESULT_hasLien = os.environ.get("RAC_RESULT_hasLien", "false")
+    RAC_RESULT_hasPastDueLoan = os.environ.get("RAC_RESULT_hasPastDueLoan", "false")
+    RAC_RESULT_hasSalaryAccount = os.environ.get("RAC_RESULT_hasSalaryAccount", "true")
+    RAC_RESULT_isWhitelisted = os.environ.get("RAC_RESULT_isWhitelisted", "true")
+    RAC_RESULT_noBouncedCheck = os.environ.get("RAC_RESULT_noBouncedCheck", "true")
 
 settings = Config()

app/models/account.py

@@ -13,7 +13,7 @@ class Account(db.Model):
     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), onupdate=func.now())
+    updated_at = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
 
     customer = relationship(
         "Customer",
@@ -27,7 +27,9 @@ class Account(db.Model):
         account = cls(
             id=id,
             customer_id=customer_id,
-            account_type=account_type
+            account_type=account_type,
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc)
         )
 
         try:

app/models/charge.py

@@ -14,7 +14,7 @@ class Charge(db.Model):
     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), onupdate=func.now())
+    updated_at = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
     offer = relationship(
         "Offer",
         primaryjoin="Charge.offer_id == Offer.id",
@@ -57,7 +57,9 @@ class Charge(db.Model):
                 code = code,
                 percent = percent,
                 description = description,
-                due = due_days
+                due = due_days,
+                created_at=datetime.now(timezone.utc),
+                updated_at=datetime.now(timezone.utc)
             )
 
             db.session.add(charge_obj)

app/models/customer.py

@@ -1,9 +1,12 @@
 from datetime import datetime, timezone
 from sqlalchemy.orm import relationship
+#
+# from app.api.services.offer_analysis import logger
 from app.extensions import db
 from app.models.account import Account
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.sql import func
+# from app.utils.logger import logger
 
 class Customer(db.Model):
     __tablename__ = 'customers'
@@ -12,7 +15,7 @@ class Customer(db.Model):
     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), onupdate=func.now())
+    updated_at = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
     accounts = relationship(
         "Account",
         primaryjoin="Customer.id == Account.customer_id",
@@ -45,9 +48,19 @@ class Customer(db.Model):
     def create_customer(cls, id, msisdn, country_code, account_id, account_type='savings'):
         if cls.query.filter_by(id=id).first():
             raise ValueError("Customer already exists")
+        elif Account.query.filter_by(id=account_id).first():
+            raise ValueError("Account already exists")
+        elif cls.query.filter_by(msisdn=msisdn).first():
+            raise ValueError("msisdn already exists")
         
         # Create the customer
-        customer = cls(id=id, msisdn=msisdn, country_code=country_code)
+        customer = cls(
+            id=id,
+            msisdn=msisdn,
+            country_code=country_code,
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc)
+            )
         try: 
             db.session.add(customer)
             
@@ -63,7 +76,7 @@ class Customer(db.Model):
         return customer
     
     @classmethod
-    def get_customer(cls, customer_id):
+    def get_customer_with_loan_list(cls, customer_id):
         """
         Get customer by  ID.
         """

app/models/loan.py

@@ -1,4 +1,5 @@
 from datetime import datetime, timezone
+from itertools import product
 from app.extensions import db
 from app.models.customer import Customer
 from app.models.account import Account
@@ -39,10 +40,11 @@ class Loan(db.Model):
     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), onupdate=func.now())
+    updated_at = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
     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)
+    reference = db.Column(db.String(50), nullable=True)
 
     customer = relationship(
         "Customer",
@@ -82,6 +84,7 @@ class Loan(db.Model):
         installment_amount,
         tenor,
         eligible_amount,
+        reference,
         status = "pending",
     ):
         # Check if customer exists
@@ -109,7 +112,10 @@ class Loan(db.Model):
             due_date=due_date,
             tenor = tenor,
             status = status,
-            eligible_amount =eligible_amount
+            eligible_amount =eligible_amount,
+            reference = reference,
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc)
         )
         
         try:
@@ -211,6 +217,9 @@ class Loan(db.Model):
         """
         return {
             'debtId': self.id,
+            'transactionId': self.transaction_id,
+            'loanRef': self.reference,
+            'productId': self.product_id,
             'initialLoanAmount': self.initial_loan_amount,
             'currentLoanAmount': self.current_loan_amount,
             'defaultPenaltyFee': self.default_penalty_fee,
@@ -220,6 +229,7 @@ class Loan(db.Model):
             'repaymentAmount': self.repayment_amount,
             'installmentAmount': self.installment_amount,
             'status': self.status,
+            'tenor': self.tenor,
             'dueDate': self.due_date.isoformat() if self.due_date else None,
             'loanDate': self.created_at.isoformat() if self.created_at else None,
         }

app/models/loan_charge.py

@@ -18,7 +18,7 @@ class LoanCharge(db.Model):
     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), onupdate=func.now())
+    updated_at = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
     loan = relationship(
         "Loan",
         primaryjoin="LoanCharge.loan_id == Loan.id",
@@ -63,7 +63,9 @@ class LoanCharge(db.Model):
                 percent = percent,
                 description = description,
                 due = due_days,
-                due_date = now + timedelta(days=due_days)
+                due_date = now + timedelta(days=due_days),
+                created_at=datetime.now(timezone.utc),
+                updated_at=datetime.now(timezone.utc)
             )
 
             db.session.add(charge_obj)

app/models/loan_repayment_schedule.py

@@ -19,7 +19,7 @@ class LoanRepaymentSchedule(db.Model):
     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), onupdate=func.now())
+    updated_at = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
     loan = relationship(
         "Loan",
         primaryjoin="LoanRepaymentSchedule.loan_id == Loan.id",
@@ -45,7 +45,9 @@ 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
+                transaction_id = transaction_id,
+                created_at=datetime.now(timezone.utc),
+                updated_at=datetime.now(timezone.utc)
             )
             
             db.session.add(schedule)

app/models/offer.py

@@ -18,8 +18,12 @@ 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), onupdate=func.now())
+    updated_at = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
+
     charges = relationship(
         "Charge",
         primaryjoin="Offer.id == Charge.offer_id",
@@ -79,7 +83,11 @@ class Offer(db.Model):
             "interest_rate": self.interest_rate,
             "management_rate": self.management_rate,
             "insurance_rate": self.insurance_rate,
-            "vat_rate": self.vat_rate
+            "vat_rate": self.vat_rate,
+            "maxDailyLoans": self.max_daily_loans,
+            "maxActiveLoans": self.max_active_loans,
+            "maxLifeLoans": self.max_life_loans
+
         }
     
     def __repr__(self):

app/models/rac_checks.py

@@ -15,7 +15,7 @@ class RACCheck(db.Model):
     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), onupdate=func.now())
+    updated_at = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
     @classmethod
     def add_rac_check(cls, customer_id, account_id, transaction_id, data = None):
     
@@ -25,7 +25,9 @@ class RACCheck(db.Model):
             customer_id = customer_id,
             account_id = account_id,
             transaction_id = transaction_id,
-            rac_response = data
+            rac_response = data,
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc)
         )
         
         try:

app/models/repayment.py

@@ -19,30 +19,24 @@ class Repayment(db.Model):
     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), onupdate=func.now())
+    updated_at = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
     transaction_id = db.Column(db.String(50), nullable=True)
 
     @classmethod
-    def create_repayment(cls, customer_id, loan_id, product_id, transaction_id):
-
-
-        # Check customer exists
-        if not Customer.is_valid_customer(customer_id):
-            raise ValueError("Invalid customer")
-
-        # Check loan exists
-        loan = Loan.get_customer_loan(loan_id = loan_id, customer_id = customer_id)
+    def create_repayment(cls, customer_id, loan, transaction_id):
         
         # Check that the loan is active
-        if loan.status != LoanStatus.ACTIVE:
+        if loan.status not in [LoanStatus.ACTIVE, LoanStatus.START_REPAY]:
             raise ValueError(f"Repayment cannot be processed. Loan status: ({loan.status})")
         
 
         repayment = cls(
             customer_id=customer_id,
-            loan_id=loan_id,
-            product_id=product_id,
-            transaction_id = transaction_id
+            loan_id=loan.id,
+            product_id=loan.product_id,
+            transaction_id = transaction_id,
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc)
         )
 
         try:

app/models/transaction.py

@@ -18,7 +18,7 @@ class Transaction(db.Model):
     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), onupdate=func.now())
+    updated_at = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
     def __repr__(self):
         return f'<Transaction {self.id}>'
 
@@ -38,7 +38,9 @@ class Transaction(db.Model):
             customer_id = customer_id,
             account_id = account_id,
             type = type,
-            channel = channel
+            channel = channel,
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc)
         )
 
         try:

app/models/transaction_offers.py

@@ -1,4 +1,5 @@
-from datetime import datetime, timezone
+from datetime import datetime, timezone, timedelta
+from app.api.enums.loan_status import LoanStatus
 from app.extensions import db
 from sqlalchemy.orm import relationship
 from sqlalchemy.sql import func
@@ -22,7 +23,7 @@ class TransactionOffer(db.Model):
     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), onupdate=func.now())
+    updated_at = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
     customer = relationship(
         "Customer",
         primaryjoin="Customer.id == TransactionOffer.customer_id",
@@ -31,12 +32,11 @@ class TransactionOffer(db.Model):
     )
 
     @classmethod
-
     def is_valid_transaction_offer(cls, transaction_offer, customer_id, product_id):
         transaction_offer = cls.query.filter_by(
             id = transaction_offer,
             customer_id = customer_id,
-            product_id = product_id
+            # product_id = product_id
             # transaction_id = transaction_id,
             ).first()
 
@@ -59,7 +59,9 @@ class TransactionOffer(db.Model):
             max_amount=max_amount,
             eligible_amount=eligible_amount,
             product_id=product_id,
-            tenor=tenor
+            tenor=tenor,
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc)
         )
 
         db.session.add(transaction_offer)
@@ -67,6 +69,43 @@ 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/RepaymentRequest.json

@@ -9,10 +9,6 @@
             "type": "string",
             "example": "10"
         },
-        "productId": {
-            "type": "string",
-            "example": "101"
-        },
         "transactionId": {
             "type": "string",
             "example": "20171209232115"
@@ -21,9 +17,9 @@
             "type": "string",
             "example": "CID0000025585"
         },
-        "channel": {
+        "loanRef": {
             "type": "string",
-            "example": "USSD"
+            "example": "Trx5847365252USSD3MPC"
         },
         "accountId": {
             "type": "string",

migrations/versions/b3a5e10bc77e_.py

@@ -0,0 +1,32 @@
+"""empty message
+
+Revision ID: b3a5e10bc77e
+Revises: e8dd9b841ad7
+Create Date: 2025-05-27 01:52:48.538333
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = 'b3a5e10bc77e'
+down_revision = 'e8dd9b841ad7'
+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('reference', sa.String(length=50), 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('reference')
+
+    # ### end Alembic commands ###

migrations/versions/e8dd9b841ad7_.py

@@ -0,0 +1,36 @@
+"""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 ###