dscf-credit 0.1.7 → 0.1.9

data/app/services/dscf/credit/loan_accrual_generator_service.rb

@@ -0,0 +1,272 @@
+module Dscf::Credit
+  # LoanAccrualGeneratorService generates daily interest and penalty accruals for active loans.
+  # This service is designed to be run daily by a background job/cron job.
+  #
+  # @example Run for all active loans
+  #   service = Dscf::Credit::LoanAccrualGeneratorService.new
+  #   result = service.generate_daily_accruals
+  #
+  # @example Run for specific loans
+  #   loan_ids = [1, 2, 3]
+  #   service = Dscf::Credit::LoanAccrualGeneratorService.new(loan_ids: loan_ids)
+  #   result = service.generate_daily_accruals
+  #
+  # @example Run for specific date (useful for backfilling)
+  #   service = Dscf::Credit::LoanAccrualGeneratorService.new(accrual_date: Date.yesterday)
+  #   result = service.generate_daily_accruals
+  #
+  # @see docs/LOAN_ACCRUAL_GENERATOR_DOCUMENTATION.md for detailed documentation
+  class LoanAccrualGeneratorService
+    attr_reader :loan_ids, :accrual_date, :force_regenerate
+
+    # Initialize the loan accrual generator service
+    #
+    # @param loan_ids [Array<Integer>, nil] Optional array of specific loan IDs to process.
+    #   If nil, processes all eligible loans.
+    # @param accrual_date [Date] The date for which to generate accruals. Defaults to today.
+    # @param force_regenerate [Boolean] If true, regenerates accruals even if they already exist
+    #   for the given date. Defaults to false.
+    def initialize(loan_ids: nil, accrual_date: Date.current, force_regenerate: false)
+      @loan_ids = loan_ids
+      @accrual_date = accrual_date
+      @force_regenerate = force_regenerate
+    end
+
+    # Generate daily accruals for eligible loans
+    #
+    # Eligible loans are those with:
+    # - Status: active, overdue, or disbursed
+    # - Have outstanding balance (remaining_amount > 0 or pending accruals exist)
+    #
+    # For each eligible loan:
+    # 1. Calculate daily interest based on principal and interest rate
+    # 2. Calculate penalty if loan is overdue
+    # 3. Create accrual records with status='pending'
+    #
+    # @return [Hash] Result hash with the following structure:
+    #   - :success [Boolean] Whether the operation succeeded
+    #   - :accruals_created [Integer] Number of accruals created
+    #   - :loans_processed [Integer] Number of loans processed
+    #   - :accrual_details [Array<Hash>] Details of each accrual created
+    #   - :errors [Array<Hash>] Any errors encountered (loan_id, error message)
+    #   - :message [String] Summary message
+    #
+    # @example Success response
+    #   {
+    #     success: true,
+    #     accruals_created: 45,
+    #     loans_processed: 30,
+    #     accrual_details: [
+    #       { loan_id: 1, accrual_type: 'interest', amount: 50.00 },
+    #       { loan_id: 1, accrual_type: 'penalty', amount: 25.00 },
+    #       ...
+    #     ],
+    #     errors: [],
+    #     message: "Successfully generated 45 accruals for 30 loans on 2025-10-03"
+    #   }
+    def generate_daily_accruals
+      loans = fetch_eligible_loans
+
+      return success_result([], []) if loans.empty?
+
+      accrual_details = []
+      errors = []
+
+      loans.each do |loan|
+        begin
+          loan_accruals = generate_accruals_for_loan(loan)
+          accrual_details.concat(loan_accruals)
+        rescue StandardError => e
+          errors << {
+            loan_id: loan.id,
+            error: e.message
+          }
+        end
+      end
+
+      success_result(accrual_details, errors)
+    rescue StandardError => e
+      error_result("Accrual generation failed: #{e.message}")
+    end
+
+    private
+
+    # Fetch loans eligible for accrual generation
+    #
+    # Eligible criteria:
+    # - Status is active, overdue, or disbursed
+    # - Has outstanding balance (remaining_amount > 0)
+    # - If loan_ids provided, only fetch those specific loans
+    #
+    # @return [ActiveRecord::Relation<Loan>] Collection of eligible loans
+    def fetch_eligible_loans
+      loans = Dscf::Credit::Loan
+                .where(status: %w[active overdue disbursed])
+                .where("remaining_amount > 0")
+                .includes(:credit_line, credit_line: :credit_line_specs)
+
+      loans = loans.where(id: loan_ids) if loan_ids.present?
+
+      loans
+    end
+
+    # Generate accruals for a single loan
+    #
+    # Generates:
+    # 1. Interest accrual based on daily interest rate and principal
+    # 2. Penalty accrual if loan is overdue
+    #
+    # @param loan [Dscf::Credit::Loan] The loan to generate accruals for
+    # @return [Array<Hash>] Array of accrual details created
+    def generate_accruals_for_loan(loan)
+      return [] if accrual_exists_for_date?(loan) && !force_regenerate
+
+      accruals = []
+
+      # Generate interest accrual
+      if loan.remaining_amount > 0
+        interest_accrual = generate_interest_accrual(loan)
+        accruals << interest_accrual if interest_accrual
+      end
+
+      # Generate penalty accrual if overdue
+      if loan_is_overdue?(loan)
+        penalty_accrual = generate_penalty_accrual(loan)
+        accruals << penalty_accrual if penalty_accrual
+      end
+
+      accruals
+    end
+
+    # Check if accruals already exist for the loan on the given date
+    #
+    # @param loan [Dscf::Credit::Loan] The loan to check
+    # @return [Boolean] True if accruals exist for the date
+    def accrual_exists_for_date?(loan)
+      loan.loan_accruals.where(applied_on: accrual_date).exists?
+    end
+
+    # Generate interest accrual for a loan
+    #
+    # Interest calculation:
+    # - Gets daily interest rate from active credit line spec
+    # - Daily interest = principal × daily_interest_rate
+    # - Note: interest_rate in credit_line_spec is already a daily rate, not annual
+    #
+    # @param loan [Dscf::Credit::Loan] The loan to generate interest for
+    # @return [Hash, nil] Accrual detail hash or nil if no interest
+    def generate_interest_accrual(loan)
+      credit_line_spec = loan.credit_line.credit_line_specs.active.first
+
+      return nil unless credit_line_spec
+
+      daily_interest_rate = credit_line_spec.interest_rate
+      return nil unless daily_interest_rate > 0
+
+      # Calculate daily interest (rate is already daily, no need to divide by 365)
+      daily_interest = (loan.remaining_amount * daily_interest_rate).round(2)
+
+      return nil if daily_interest <= 0
+
+      # Create interest accrual
+      accrual = Dscf::Credit::LoanAccrual.create!(
+        loan: loan,
+        accrual_type: "interest",
+        amount: daily_interest,
+        applied_on: accrual_date,
+        status: "pending"
+      )
+
+      {
+        loan_id: loan.id,
+        accrual_id: accrual.id,
+        accrual_type: "interest",
+        amount: daily_interest,
+        applied_on: accrual_date
+      }
+    end
+
+    # Generate penalty accrual for overdue loans
+    #
+    # Penalty calculation:
+    # - Gets daily penalty rate from active credit line spec
+    # - Daily penalty = principal × daily_penalty_rate
+    # - Only applies if loan.due_date < accrual_date
+    # - Note: penalty_rate in credit_line_spec is already a daily rate, not annual
+    #
+    # @param loan [Dscf::Credit::Loan] The loan to generate penalty for
+    # @return [Hash, nil] Accrual detail hash or nil if no penalty
+    def generate_penalty_accrual(loan)
+      credit_line_spec = loan.credit_line.credit_line_specs.active.first
+
+      return nil unless credit_line_spec
+
+      daily_penalty_rate = credit_line_spec.penalty_rate
+      return nil unless daily_penalty_rate > 0
+
+      # Calculate daily penalty (rate is already daily, no need to divide by 365)
+      daily_penalty = (loan.remaining_amount * daily_penalty_rate).round(2)
+
+      return nil if daily_penalty <= 0
+
+      # Create penalty accrual
+      accrual = Dscf::Credit::LoanAccrual.create!(
+        loan: loan,
+        accrual_type: "penalty",
+        amount: daily_penalty,
+        applied_on: accrual_date,
+        status: "pending"
+      )
+
+      {
+        loan_id: loan.id,
+        accrual_id: accrual.id,
+        accrual_type: "penalty",
+        amount: daily_penalty,
+        applied_on: accrual_date
+      }
+    end
+
+    # Check if loan is overdue based on due date and accrual date
+    #
+    # @param loan [Dscf::Credit::Loan] The loan to check
+    # @return [Boolean] True if loan is overdue
+    def loan_is_overdue?(loan)
+      loan.due_date < accrual_date || loan.status == "overdue"
+    end
+
+    # Build success result hash
+    #
+    # @param accrual_details [Array<Hash>] Details of accruals created
+    # @param errors [Array<Hash>] Any errors encountered
+    # @return [Hash] Success response
+    def success_result(accrual_details, errors)
+      loans_processed = accrual_details.map { |a| a[:loan_id] }.uniq.size
+      accruals_created = accrual_details.size
+
+      {
+        success: true,
+        accruals_created: accruals_created,
+        loans_processed: loans_processed,
+        accrual_details: accrual_details,
+        errors: errors,
+        message: "Successfully generated #{accruals_created} accruals for #{loans_processed} loans on #{accrual_date}"
+      }
+    end
+
+    # Build error result hash
+    #
+    # @param message [String] Error message
+    # @return [Hash] Error response
+    def error_result(message)
+      {
+        success: false,
+        accruals_created: 0,
+        loans_processed: 0,
+        accrual_details: [],
+        errors: [],
+        message: message
+      }
+    end
+  end
+end

data/app/services/dscf/credit/repayment_service.rb

@@ -1,15 +1,74 @@
 module Dscf::Credit
+  # RepaymentService handles loan repayment processing with automatic payment allocation
+  # across facilitation fees, penalties, interest, and principal.
+  #
+  # @example Basic usage
+  #   loan = Dscf::Credit::Loan.find(loan_id)
+  #   service = Dscf::Credit::RepaymentService.new(loan, 1500.00)
+  #   result = service.process_repayment
+  #
+  #   if result[:success]
+  #     puts "Payment processed: #{result[:message]}"
+  #     puts "Remaining balance: #{result[:payment_details][:remaining_balance]}"
+  #   else
+  #     puts "Error: #{result[:error]}"
+  #   end
+  #
+  # @see docs/REPAYMENT_SERVICE_DOCUMENTATION.md for detailed documentation
   class RepaymentService
-    attr_reader :loan, :payment_amount, :current_user
+    attr_reader :loan, :payment_amount
 
-    def initialize(loan, payment_amount, current_user)
+    # Initialize the repayment service
+    #
+    # @param loan [Dscf::Credit::Loan] The loan to process repayment for
+    # @param payment_amount [Numeric] The amount being paid (converted to float)
+    def initialize(loan, payment_amount)
       @loan = loan
       @payment_amount = payment_amount.to_f
-      @current_user = current_user
     end
 
-    # Process loan repayment by decreasing loan balance and updating related records
-    # @return [Hash] Result containing payment details and updated loan status
+    # Process loan repayment with automatic allocation and status updates
+    #
+    # Payment allocation priority (waterfall method):
+    # 1. Facilitation Fee (from loan_accruals where accrual_type='facilitation_fee' and status='pending')
+    # 2. Penalties (from loan_accruals where accrual_type='penalty' and status='pending')
+    # 3. Interest (from loan_accruals where accrual_type='interest' and status='pending')
+    # 4. Principal (from loan.remaining_amount)
+    #
+    # Process steps:
+    # 1. Calculate payment allocation across loan components
+    # 2. Update loan record (remaining_amount only)
+    # 3. Mark accruals as paid (with splitting for partial payments)
+    # 4. Update loan status based on remaining balance
+    # 5. Reactivate credit facilities if loan fully paid
+    #
+    # @return [Hash] Result hash with the following structure:
+    #   - :success [Boolean] Whether the operation succeeded
+    #   - :loan [Dscf::Credit::Loan, nil] Updated loan object (nil on failure)
+    #   - :payment_details [Hash] Detailed payment allocation information
+    #   - :message [String] Success message
+    #   - :error [String] Error message (only present on failure)
+    #
+    # @example Success response
+    #   {
+    #     success: true,
+    #     loan: #<Dscf::Credit::Loan>,
+    #     payment_details: {
+    #       payment_amount: 1500.00,
+    #       allocation: { ... },
+    #       new_loan_status: "active",
+    #       paid_off: false,
+    #       remaining_balance: 3600.00
+    #     },
+    #     message: "Payment processed successfully"
+    #   }
+    #
+    # @example Error response
+    #   {
+    #     success: false,
+    #     loan: nil,
+    #     error: "Payment amount exceeds total outstanding balance"
+    #   }
     def process_repayment
       return error_result("Loan not found") unless loan
       return error_result("Invalid payment amount") unless payment_amount > 0
@@ -24,8 +83,6 @@ module Dscf::Credit
 
         update_loan_status
 
-        create_payment_transaction(payment_allocation)
-
         reactivate_facilities_if_paid_off
 
         success_result(payment_allocation)
@@ -36,10 +93,23 @@ module Dscf::Credit
 
     private
 
+    # Calculate how the payment should be allocated across loan components
+    #
+    # Uses waterfall allocation: payment is applied in priority order until exhausted.
+    # Queries loan_accruals table for current pending penalties and interest.
+    #
+    # @return [Hash] Allocation details including:
+    #   - :total_outstanding - Total amount owed
+    #   - :payment_amount - Amount being paid
+    #   - :facilitation_payment - Amount applied to facilitation fee
+    #   - :penalty_payment - Amount applied to penalties
+    #   - :interest_payment - Amount applied to interest
+    #   - :principal_payment - Amount applied to principal
+    #   - :remaining_* - Amounts still owed for each component
     def calculate_payment_allocation
-      current_facilitation_fee = loan.facilitation_fee || 0
-      current_penalty = loan.accrued_penalty || 0
-      current_interest = loan.accrued_interest || 0
+      current_facilitation_fee = loan.loan_accruals.pending.by_type("facilitation_fee").sum(:amount)
+      current_penalty = loan.loan_accruals.pending.by_type("penalty").sum(:amount)
+      current_interest = loan.loan_accruals.pending.by_type("interest").sum(:amount)
       current_principal = loan.remaining_amount || 0
 
       total_outstanding = current_facilitation_fee + current_penalty + current_interest + current_principal
@@ -71,86 +141,138 @@ module Dscf::Credit
       }
     end
 
+    # Apply the calculated payment allocation to the loan and accruals
+    #
+    # Updates:
+    # 1. Loan record (remaining_amount only)
+    # 2. Loan accruals (marks facilitation_fee, penalties, and interest as paid)
+    #
+    # @param allocation [Hash] The allocation hash from calculate_payment_allocation
+    # @return [void]
     def process_payment_allocation(allocation)
+      # Update loan record (only remaining_amount now)
       loan.update!(
-        facilitation_fee: allocation[:remaining_facilitation_fee],
-        accrued_penalty: allocation[:remaining_penalty],
-        accrued_interest: allocation[:remaining_interest],
         remaining_amount: allocation[:remaining_principal]
       )
-    end
-
-    def update_loan_status
-      total_remaining = (loan.facilitation_fee || 0) +
-                       (loan.accrued_penalty || 0) +
-                       (loan.accrued_interest || 0) +
-                       (loan.remaining_amount || 0)
-
-      if total_remaining <= 0.01
-        loan.update!(status: "paid")
-      else
-        loan.update!(status: "active") if loan.status == "overdue"
-      end
-    end
-
-    def create_payment_transaction(allocation)
-      Dscf::Credit::LoanTransaction.create!(
-        loan: loan,
-        transaction_type: "repayment",
-        amount: payment_amount,
-        transaction_reference: "REPAY-#{loan.id}-#{Time.current.to_i}",
-        status: "completed"
-      )
-
-      create_allocation_transactions(allocation) if payment_amount > 100 # Only for significant payments
-    end
-
-    def create_allocation_transactions(allocation)
-      transactions = []
 
+      # Mark paid facilitation fee accruals
       if allocation[:facilitation_payment] > 0
-        transactions << {
-          transaction_type: "fee_charge",
-          amount: allocation[:facilitation_payment],
-          reference_suffix: "FEE"
-        }
+        mark_accruals_as_paid("facilitation_fee", allocation[:facilitation_payment])
       end
 
+      # Mark paid penalty accruals
       if allocation[:penalty_payment] > 0
-        transactions << {
-          transaction_type: "penalty",
-          amount: allocation[:penalty_payment],
-          reference_suffix: "PENALTY"
-        }
+        mark_accruals_as_paid("penalty", allocation[:penalty_payment])
       end
 
+      # Mark paid interest accruals
       if allocation[:interest_payment] > 0
-        transactions << {
-          transaction_type: "interest_accrual",
-          amount: allocation[:interest_payment],
-          reference_suffix: "INTEREST"
-        }
+        mark_accruals_as_paid("interest", allocation[:interest_payment])
       end
+    end
+
+    # Mark loan accruals as paid, handling partial payments by splitting accruals
+    #
+    # Processes accruals in chronological order (oldest first by applied_on date).
+    # When payment is insufficient to cover an entire accrual:
+    # 1. Updates the original accrual to "paid" status with the paid amount
+    # 2. Creates a new "pending" accrual for the remaining unpaid amount
+    #
+    # @param accrual_type [String] Type of accrual to pay ('penalty' or 'interest')
+    # @param payment_amount [Float] Amount available to pay towards these accruals
+    # @return [void]
+    #
+    # @example Full payment
+    #   # Accrual: { id: 1, amount: 100, status: 'pending' }
+    #   # Payment: 100
+    #   # Result: { id: 1, amount: 100, status: 'paid' }
+    #
+    # @example Partial payment with split
+    #   # Accrual: { id: 1, amount: 100, status: 'pending' }
+    #   # Payment: 60
+    #   # Result:
+    #   #   { id: 1, amount: 60, status: 'paid' }      # Paid portion
+    #   #   { id: 2, amount: 40, status: 'pending' }   # New accrual for remainder
+    def mark_accruals_as_paid(accrual_type, payment_amount)
+      pending_accruals = loan.loan_accruals.pending.by_type(accrual_type).order(:applied_on)
+      remaining_payment = payment_amount
 
-      if allocation[:principal_payment] > 0
-        transactions << {
-          transaction_type: "repayment",
-          amount: allocation[:principal_payment],
-          reference_suffix: "PRINCIPAL"
-        }
+      pending_accruals.each do |accrual|
+        break if remaining_payment <= 0
+
+        if remaining_payment >= accrual.amount
+          accrual.update!(status: "paid")
+          remaining_payment -= accrual.amount
+        else
+          # Partial payment: split the accrual
+          paid_amount = remaining_payment
+          remaining_amount = accrual.amount - paid_amount
+
+          # Update original accrual to paid status with reduced amount
+          accrual.update!(amount: paid_amount, status: "paid")
+
+          # Create a new pending accrual for the remaining amount
+          Dscf::Credit::LoanAccrual.create!(
+            loan: loan,
+            accrual_type: accrual_type,
+            amount: remaining_amount,
+            applied_on: accrual.applied_on,
+            status: "pending"
+          )
+
+          remaining_payment = 0
+        end
       end
+    end
 
-      transactions.each_with_index do |transaction_data, index|
-        Dscf::Credit::LoanTransaction.create!(
-          loan: loan,
-          transaction_type: transaction_data[:transaction_type],
-          amount: transaction_data[:amount],
-          transaction_reference: "#{transaction_data[:reference_suffix]}-#{loan.id}-#{Time.current.to_i}-#{index}",
-          status: "completed"
-        )
+    # Update loan status based on remaining balance
+    #
+    # Status transitions:
+    # - If total remaining ≤ 0.01 ETB → status: "paid"
+    # - If was "overdue" and balance > 0 → status: "active"
+    # - Otherwise → status unchanged
+    #
+    # Total remaining includes:
+    # - Facilitation fee (from loan_accruals)
+    # - Pending penalties (from loan_accruals)
+    # - Pending interest (from loan_accruals)
+    # - Remaining principal (from loan record)
+    #
+    # @return [void]
+    def update_loan_status
+      pending_facilitation_fee = loan.loan_accruals.pending.by_type("facilitation_fee").sum(:amount)
+      pending_penalty = loan.loan_accruals.pending.by_type("penalty").sum(:amount)
+      pending_interest = loan.loan_accruals.pending.by_type("interest").sum(:amount)
+
+      total_remaining = pending_facilitation_fee +
+                       pending_penalty +
+                       pending_interest +
+                       (loan.remaining_amount || 0)
+
+      if total_remaining <= 0.01
+        loan.update!(status: "paid")
+      else
+        loan.update!(status: "active") if loan.status == "overdue"
       end
     end
 
+    # Reactivate locked credit facilities when loan is fully paid off
+    #
+    # Only runs if loan.status == "paid"
+    #
+    # Process:
+    # 1. Find all eligible credit lines with 0 available_limit (locked)
+    # 2. For each locked line, recalculate available_limit based on:
+    #    - Credit limit (total allowed)
+    #    - Minus current usage from other active loans
+    #
+    # This allows the borrower to access credit again after repayment.
+    #
+    # @return [void]
+    #
+    # @example
+    #   # Before: eligible_line.available_limit = 0 (locked)
+    #   # After payment: eligible_line.available_limit = 7000 (reactivated)
     def reactivate_facilities_if_paid_off
       return unless loan.status == "paid"
 
@@ -166,10 +288,14 @@ module Dscf::Credit
 
         eligible_line.update!(available_limit: new_available_limit)
       end
-
-      update_loan_profile_available_amount(loan_profile)
     end
 
+    # Calculate total current usage for a credit line from all active loans
+    #
+    # Excludes the current loan (the one being paid off) from calculation.
+    #
+    # @param credit_line [Dscf::Credit::CreditLine] The credit line to check
+    # @return [Float] Sum of remaining_amount from active loans
     def calculate_current_usage_for_credit_line(credit_line)
       credit_line.loans
                  .where(status: [ "active", "overdue", "disbursed" ])
@@ -177,34 +303,37 @@ module Dscf::Credit
                  .sum(:remaining_amount)
     end
 
-    def update_loan_profile_available_amount(loan_profile)
-      # Recalculate available amount based on total limit minus current usage
-      total_usage = loan_profile.loans
-                               .where(status: [ "active", "overdue", "disbursed" ])
-                               .sum(:remaining_amount)
-
-      new_available_amount = [ loan_profile.total_amount - total_usage, 0 ].max
-      loan_profile.update!(available_amount: new_available_amount)
-    end
-
+    # Build success result hash
+    #
+    # @param allocation [Hash] The allocation hash with payment details
+    # @return [Hash] Success response with loan, payment details, and message
     def success_result(allocation)
+      loan.reload
+      pending_facilitation_fee = loan.loan_accruals.pending.by_type("facilitation_fee").sum(:amount)
+      pending_penalty = loan.loan_accruals.pending.by_type("penalty").sum(:amount)
+      pending_interest = loan.loan_accruals.pending.by_type("interest").sum(:amount)
+
       {
         success: true,
-        loan: loan.reload,
+        loan: loan,
         payment_details: {
           payment_amount: payment_amount,
           allocation: allocation,
           new_loan_status: loan.status,
           paid_off: loan.status == "paid",
-          remaining_balance: (loan.facilitation_fee || 0) +
-                           (loan.accrued_penalty || 0) +
-                           (loan.accrued_interest || 0) +
+          remaining_balance: pending_facilitation_fee +
+                           pending_penalty +
+                           pending_interest +
                            (loan.remaining_amount || 0)
         },
         message: loan.status == "paid" ? "Loan fully paid off" : "Payment processed successfully"
       }
     end
 
+    # Build error result hash
+    #
+    # @param message [String] Error message describing what went wrong
+    # @return [Hash] Error response with success: false and error message
     def error_result(message)
       {
         success: false,

data/config/locales/en.yml

@@ -102,6 +102,40 @@ en:
       calculate_facility_limits: "Failed to calculate facility limits"
       apply_risk_factor: "Failed to apply risk factor"
 
+  loan_accrual:
+    success:
+      index: "Loan accruals retrieved successfully"
+      show: "Loan accrual details retrieved successfully"
+      create: "Loan accrual created successfully"
+      update: "Loan accrual updated successfully"
+      destroy: "Loan accrual deleted successfully"
+      mark_paid: "Loan accrual marked as paid successfully"
+      generate: "Loan accruals generated successfully"
+      statistics: "Loan accrual statistics retrieved successfully"
+    errors:
+      index: "Failed to retrieve loan accruals"
+      show: "Failed to retrieve loan accrual details"
+      create: "Failed to create loan accrual"
+      update: "Failed to update loan accrual"
+      destroy: "Failed to delete loan accrual"
+      mark_paid: "Failed to mark loan accrual as paid"
+      invalid_accrual_type: "Invalid accrual type"
+      amount_must_be_positive: "Accrual amount must be positive"
+      generate: "Failed to generate loan accruals"
+      statistics: "Failed to retrieve loan accrual statistics"
+
+  loan:
+    success:
+      index: "Loans retrieved successfully"
+      show: "Loan details retrieved successfully"
+      create: "Loan created successfully"
+      update: "Loan updated successfully"
+    errors:
+      index: "Failed to retrieve loans"
+      show: "Failed to retrieve loan details"
+      create: "Failed to create loan"
+      update: "Failed to update loan"
+
   parameter_normalizer:
     success:
       index: "Parameter normalizers retrieved successfully"