dscf-credit 0.1.2 → 0.1.3

data/app/serializers/dscf/credit/eligible_credit_line_serializer.rb

@@ -0,0 +1,8 @@
+module Dscf::Credit
+  class EligibleCreditLineSerializer < ActiveModel::Serializer
+    attributes :id, :credit_limit, :available_limit, :risk, :created_at, :updated_at
+
+    belongs_to :loan_profile, serializer: Dscf::Credit::LoanProfileSerializer
+    belongs_to :credit_line, serializer: Dscf::Credit::CreditLineSerializer
+  end
+end

data/app/serializers/dscf/credit/loan_profile_scoring_spec_serializer.rb

@@ -0,0 +1,8 @@
+module Dscf::Credit
+  class LoanProfileScoringSpecSerializer < ActiveModel::Serializer
+    attributes :id, :scoring_input_data, :score, :total_limit, :active, :created_at, :updated_at
+
+    belongs_to :loan_profile, serializer: Dscf::Credit::LoanProfileSerializer
+    belongs_to :created_by
+  end
+end

data/app/serializers/dscf/credit/loan_profile_serializer.rb

@@ -0,0 +1,15 @@
+module Dscf::Credit
+  class LoanProfileSerializer < ActiveModel::Serializer
+    attributes :id, :status, :total_amount, :available_amount, :review_date, :review_feedback, :created_at, :updated_at
+
+    belongs_to :bank, serializer: Dscf::Credit::BankSerializer
+    belongs_to :review_branch, serializer: Dscf::Credit::BankBranchSerializer
+    belongs_to :reviewed_by
+    belongs_to :backer
+    belongs_to :user, serializer: Dscf::Core::UserSerializer
+
+    has_many :loan_profile_scoring_specs, serializer: Dscf::Credit::LoanProfileScoringSpecSerializer
+    has_many :loans, serializer: Dscf::Credit::LoanSerializer
+    has_many :eligible_credit_lines, serializer: Dscf::Credit::EligibleCreditLineSerializer
+  end
+end

data/app/serializers/dscf/credit/loan_serializer.rb

@@ -0,0 +1,12 @@
+module Dscf::Credit
+  class LoanSerializer < ActiveModel::Serializer
+    attributes :id, :status, :principal_amount, :accrued_interest, :accrued_penalty, :facilitation_fee,
+               :total_loan_amount, :remaining_amount, :due_date, :disbursed_at, :created_at, :updated_at
+
+    belongs_to :loan_profile, serializer: LoanProfileSerializer
+    belongs_to :credit_line, serializer: CreditLineSerializer
+    belongs_to :payment_request, serializer: PaymentRequestSerializer
+    has_many :loan_transactions, serializer: LoanTransactionSerializer
+    has_many :daily_routine_transactions, serializer: DailyRoutineTransactionSerializer
+  end
+end

data/app/serializers/dscf/credit/loan_transaction_serializer.rb

@@ -0,0 +1,8 @@
+module Dscf::Credit
+  class LoanTransactionSerializer < ActiveModel::Serializer
+    attributes :id, :transaction_type, :amount, :transaction_reference, :status,
+               :created_at, :updated_at
+
+    belongs_to :loan, serializer: LoanSerializer
+  end
+end

data/app/serializers/dscf/credit/payment_request_serializer.rb

@@ -0,0 +1,10 @@
+module Dscf::Credit
+  class PaymentRequestSerializer < ActiveModel::Serializer
+    attributes :id, :order_id, :request_type, :amount, :receiver_account_reference,
+               :status, :failure_reason, :initiated_at, :approved_at, :created_at, :updated_at
+
+    belongs_to :user, serializer: Dscf::Core::UserSerializer
+    has_many :loans, serializer: Dscf::Credit::LoanSerializer
+    has_many :payments, serializer: Dscf::Credit::PaymentSerializer
+  end
+end

data/app/serializers/dscf/credit/payment_serializer.rb

@@ -0,0 +1,8 @@
+module Dscf::Credit
+  class PaymentSerializer < ActiveModel::Serializer
+    attributes :id, :amount, :receiver_account_reference, :transaction_reference,
+               :status, :failure_reason, :processed_at, :created_at, :updated_at
+
+    belongs_to :payment_request, serializer: PaymentRequestSerializer
+  end
+end

data/app/serializers/dscf/credit/scoring_parameter_serializer.rb

@@ -9,5 +9,7 @@ module Dscf::Credit
     belongs_to :scoring_param_type, serializer: Dscf::Credit::ScoringParamTypeSerializer
     belongs_to :previous_version, serializer: Dscf::Credit::ScoringParameterSerializer
     has_many :parameter_normalizers, serializer: Dscf::Credit::ParameterNormalizerSerializer
+    has_many :scoring_tables, serializer: Dscf::Credit::ScoringTableSerializer
+    has_many :categories, serializer: Dscf::Credit::CategorySerializer
   end
 end

data/app/serializers/dscf/credit/scoring_table_serializer.rb

@@ -2,7 +2,7 @@ module Dscf::Credit
   class ScoringTableSerializer < ActiveModel::Serializer
     attributes :id, :weight, :active, :created_at, :updated_at
 
-    belongs_to :credit_line, serializer: Dscf::Credit::CreditLineSerializer
+    belongs_to :category, serializer: Dscf::Credit::CategorySerializer
     belongs_to :scoring_parameter, serializer: Dscf::Credit::ScoringParameterSerializer
     belongs_to :created_by, serializer: Dscf::Core::UserSerializer
   end

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

@@ -0,0 +1,153 @@
+module Dscf::Credit
+  class CreditLimitCalculationService
+    attr_reader :loan_profile, :category
+
+    def initialize(loan_profile, category)
+      @loan_profile = loan_profile
+      @category = category
+    end
+
+    # Calculate credit limits for all credit lines in a category for a specific loan profile
+    # @return [Hash] Result containing eligible credit lines with calculated limits
+    def calculate_credit_limits
+      return error_result("Loan profile not found") unless loan_profile
+      return error_result("Category not found") unless category
+
+      scoring_spec = loan_profile.loan_profile_scoring_specs.active.first
+      return error_result("No active scoring found for loan profile") unless scoring_spec
+
+      credit_lines = category.credit_lines.approved.includes(:bank, :category, :credit_line_specs)
+      return error_result("No approved credit lines found for category") if credit_lines.empty?
+
+      eligible_credit_lines = calculate_limits_for_credit_lines(credit_lines, scoring_spec)
+
+      success_result(eligible_credit_lines)
+    rescue StandardError => e
+      error_result("Credit limit calculation failed: #{e.message}")
+    end
+
+    private
+
+    def calculate_limits_for_credit_lines(credit_lines, scoring_spec)
+      results = []
+
+      credit_lines.each do |credit_line|
+        limit_data = calculate_individual_credit_limit(credit_line, scoring_spec)
+        next if limit_data[:credit_limit] <= 0
+
+        eligible_credit_line = find_or_create_eligible_credit_line(credit_line)
+        eligible_credit_line.assign_attributes(limit_data)
+
+        if eligible_credit_line.save
+          results << {
+            credit_line: credit_line,
+            eligible_credit_line: eligible_credit_line,
+            calculated_limit: limit_data[:credit_limit],
+            available_limit: limit_data[:available_limit],
+            risk_factor: limit_data[:risk]
+          }
+        end
+      end
+
+      results
+    end
+
+    def calculate_individual_credit_limit(credit_line, scoring_spec)
+      base_limit = scoring_spec.total_limit
+
+      credit_line_specs = credit_line.credit_line_specs.active
+      adjusted_limit = apply_credit_line_specifications(base_limit, credit_line_specs)
+
+      risk_factor = calculate_risk_factor(credit_line, loan_profile)
+      final_limit = adjusted_limit * (1 - risk_factor)
+
+      used_limit = calculate_used_limit(credit_line)
+      available_limit = [ final_limit - used_limit, 0 ].max
+
+      {
+        credit_limit: final_limit.round(2),
+        available_limit: available_limit.round(2),
+        risk: risk_factor.round(4)
+      }
+    end
+
+    def apply_credit_line_specifications(base_limit, credit_line_specs)
+      return base_limit if credit_line_specs.empty?
+
+      spec = credit_line_specs.first
+      return base_limit unless spec
+
+      if spec.credit_line_multiplier && spec.credit_line_multiplier > 0
+        adjustment_factor = spec.credit_line_multiplier / 30.0 # Normalize against default 30 days
+        adjusted_limit = base_limit * adjustment_factor
+      else
+        adjusted_limit = base_limit
+      end
+
+      if spec.max_amount && adjusted_limit > spec.max_amount
+        adjusted_limit = spec.max_amount
+      end
+
+      if spec.min_amount && adjusted_limit < spec.min_amount
+        adjusted_limit = spec.min_amount
+      end
+
+      adjusted_limit
+    end
+
+    def calculate_risk_factor(credit_line, loan_profile)
+      base_risk = 0.1 # 10% base risk
+
+      # Increase risk based on loan profile characteristics
+      risk_adjustments = 0.0
+
+      # Risk based on previous loan performance
+      if loan_profile.loans.overdue.any?
+        risk_adjustments += 0.2 # 20% additional risk for overdue loans
+      end
+
+      # Risk based on available amount vs total amount ratio
+      if loan_profile.total_amount > 0
+        utilization_ratio = (loan_profile.total_amount - loan_profile.available_amount) / loan_profile.total_amount
+        risk_adjustments += utilization_ratio * 0.1 # Up to 10% additional risk
+      end
+
+      # Risk based on credit line category
+      case credit_line.category.name.downcase
+      when "high_risk"
+        risk_adjustments += 0.15
+      when "medium_risk"
+        risk_adjustments += 0.05
+      end
+
+      # Cap total risk at 90%
+      [ base_risk + risk_adjustments, 0.9 ].min
+    end
+
+    def calculate_used_limit(credit_line)
+      credit_line.loans.where(status: [ "active", "overdue" ]).sum(:remaining_amount)
+    end
+
+    def find_or_create_eligible_credit_line(credit_line)
+      loan_profile.eligible_credit_lines.find_or_initialize_by(credit_line: credit_line)
+    end
+
+    def success_result(eligible_credit_lines)
+      {
+        success: true,
+        data: eligible_credit_lines,
+        message: "Credit limits calculated successfully",
+        count: eligible_credit_lines.size
+      }
+    end
+
+    def error_result(message)
+      {
+        success: false,
+        data: [],
+        error: message,
+        count: 0
+      }
+    end
+  end
+end

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

@@ -0,0 +1,180 @@
+module Dscf::Credit
+  class DisbursementService
+    attr_reader :credit_line, :payment_request, :current_user
+
+    def initialize(credit_line, payment_request, current_user)
+      @credit_line = credit_line
+      @payment_request = payment_request
+      @current_user = current_user
+    end
+
+    # Process disbursement by creating a loan record from selected credit line
+    # @return [Hash] Result containing created loan and disbursement details
+    def process_disbursement
+      return error_result("Credit line not found") unless credit_line
+      return error_result("Payment request not found") unless payment_request
+      return error_result("Credit line is not approved") unless credit_line.status == "approved"
+
+      eligible_credit_line = find_eligible_credit_line
+      return error_result("No eligible credit line found") unless eligible_credit_line
+
+      loan_profile = eligible_credit_line.loan_profile
+      return error_result("Loan profile not approved") unless loan_profile.status == "approved"
+
+      validation_result = validate_disbursement_amount(eligible_credit_line)
+      return validation_result unless validation_result[:success]
+
+      ActiveRecord::Base.transaction do
+        loan = create_loan_record(loan_profile, eligible_credit_line)
+        process_payment_and_charges(loan)
+        update_credit_line_limits(eligible_credit_line, loan)
+        lock_other_credit_lines(loan_profile, credit_line)
+
+        success_result(loan)
+      end
+    rescue StandardError => e
+      error_result("Disbursement processing failed: #{e.message}")
+    end
+
+    private
+
+    def find_eligible_credit_line
+      credit_line.eligible_credit_lines
+                 .joins(:loan_profile)
+                 .where(dscf_credit_loan_profiles: { status: "approved" })
+                 .first
+    end
+
+    def validate_disbursement_amount(eligible_credit_line)
+      requested_amount = payment_request.amount
+      available_limit = eligible_credit_line.available_limit
+
+      if requested_amount <= 0
+        return error_result("Invalid disbursement amount")
+      end
+
+      if requested_amount > available_limit
+        return error_result("Requested amount exceeds available credit limit")
+      end
+
+      { success: true }
+    end
+
+    def create_loan_record(loan_profile, eligible_credit_line)
+      loan_terms = calculate_loan_terms(eligible_credit_line)
+
+      loan = Dscf::Credit::Loan.new(
+        loan_profile: loan_profile,
+        credit_line: credit_line,
+        payment_request: payment_request,
+        principal_amount: payment_request.amount,
+        facilitation_fee: loan_terms[:facilitation_fee],
+        total_loan_amount: loan_terms[:total_amount],
+        remaining_amount: loan_terms[:total_amount],
+        accrued_interest: 0,
+        accrued_penalty: 0,
+        status: "disbursed",
+        due_date: loan_terms[:due_date],
+        disbursed_at: Time.current
+      )
+
+      raise "Failed to create loan: #{loan.errors.full_messages.join(', ')}" unless loan.save
+
+      loan
+    end
+
+    def calculate_loan_terms(eligible_credit_line)
+      principal = payment_request.amount
+
+      credit_line_spec = credit_line.credit_line_specs.active.first
+
+      if credit_line_spec
+        facilitation_rate = credit_line_spec.facilitation_fee_rate
+        vat_rate = credit_line_spec.vat
+        loan_duration = credit_line_spec.loan_duration
+      else
+        facilitation_rate = 0.02  # 2%
+        vat_rate = 0.15          # 15%
+        loan_duration = 30       # 30 days
+      end
+
+      facilitation_fee = principal * facilitation_rate
+      vat_amount = facilitation_fee * vat_rate
+      total_amount = principal + facilitation_fee + vat_amount
+
+      due_date = Date.current + loan_duration.days
+
+      {
+        facilitation_fee: facilitation_fee.round(2),
+        vat_amount: vat_amount.round(2),
+        total_amount: total_amount.round(2),
+        due_date: due_date
+      }
+    end
+
+    def process_payment_and_charges(loan)
+      payment_request.update!(
+        status: "processed",
+        approved_at: Time.current
+      )
+
+      Dscf::Credit::LoanTransaction.create!(
+        loan: loan,
+        transaction_type: "disbursement",
+        amount: loan.principal_amount,
+        transaction_reference: "DISB-#{payment_request.order_id}-#{Time.current.to_i}",
+        status: "completed"
+      )
+
+      if loan.facilitation_fee > 0
+        Dscf::Credit::LoanTransaction.create!(
+          loan: loan,
+          transaction_type: "fee_charge",
+          amount: loan.facilitation_fee,
+          transaction_reference: "FEE-#{loan.id}-#{Time.current.to_i}",
+          status: "completed"
+        )
+      end
+    end
+
+    def update_credit_line_limits(eligible_credit_line, loan)
+      new_available_limit = eligible_credit_line.available_limit - loan.total_loan_amount
+      eligible_credit_line.update!(available_limit: [ new_available_limit, 0 ].max)
+
+      # Update loan profile available amount
+      loan_profile = eligible_credit_line.loan_profile
+      new_profile_available = loan_profile.available_amount - loan.total_loan_amount
+      loan_profile.update!(available_amount: [ new_profile_available, 0 ].max)
+    end
+
+    def lock_other_credit_lines(loan_profile, current_credit_line)
+      other_eligible_lines = loan_profile.eligible_credit_lines
+                                        .where.not(credit_line: current_credit_line)
+
+      other_eligible_lines.update_all(available_limit: 0)
+    end
+
+    def success_result(loan)
+      {
+        success: true,
+        loan: loan,
+        disbursement_details: {
+          principal_amount: loan.principal_amount,
+          facilitation_fee: loan.facilitation_fee,
+          total_loan_amount: loan.total_loan_amount,
+          due_date: loan.due_date,
+          disbursed_at: loan.disbursed_at
+        },
+        message: "Disbursement processed successfully"
+      }
+    end
+
+    def error_result(message)
+      {
+        success: false,
+        loan: nil,
+        error: message
+      }
+    end
+  end
+end

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

@@ -0,0 +1,216 @@
+module Dscf::Credit
+  class RepaymentService
+    attr_reader :loan, :payment_amount, :current_user
+
+    def initialize(loan, payment_amount, current_user)
+      @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
+    def process_repayment
+      return error_result("Loan not found") unless loan
+      return error_result("Invalid payment amount") unless payment_amount > 0
+      return error_result("Loan is not active") unless loan.status.in?([ "active", "overdue", "disbursed" ])
+
+      payment_allocation = calculate_payment_allocation
+
+      return error_result("Payment amount exceeds total outstanding balance") if payment_amount > payment_allocation[:total_outstanding]
+
+      ActiveRecord::Base.transaction do
+        process_payment_allocation(payment_allocation)
+
+        update_loan_status
+
+        create_payment_transaction(payment_allocation)
+
+        reactivate_facilities_if_paid_off
+
+        success_result(payment_allocation)
+      end
+    rescue StandardError => e
+      error_result("Repayment processing failed: #{e.message}")
+    end
+
+    private
+
+    def calculate_payment_allocation
+      current_facilitation_fee = loan.facilitation_fee || 0
+      current_penalty = loan.accrued_penalty || 0
+      current_interest = loan.accrued_interest || 0
+      current_principal = loan.remaining_amount || 0
+
+      total_outstanding = current_facilitation_fee + current_penalty + current_interest + current_principal
+
+      remaining_payment = payment_amount
+
+      facilitation_payment = [ remaining_payment, current_facilitation_fee ].min
+      remaining_payment -= facilitation_payment
+
+      penalty_payment = [ remaining_payment, current_penalty ].min
+      remaining_payment -= penalty_payment
+
+      interest_payment = [ remaining_payment, current_interest ].min
+      remaining_payment -= interest_payment
+
+      principal_payment = [ remaining_payment, current_principal ].min
+
+      {
+        total_outstanding: total_outstanding,
+        payment_amount: payment_amount,
+        facilitation_payment: facilitation_payment,
+        penalty_payment: penalty_payment,
+        interest_payment: interest_payment,
+        principal_payment: principal_payment,
+        remaining_facilitation_fee: current_facilitation_fee - facilitation_payment,
+        remaining_penalty: current_penalty - penalty_payment,
+        remaining_interest: current_interest - interest_payment,
+        remaining_principal: current_principal - principal_payment
+      }
+    end
+
+    def process_payment_allocation(allocation)
+      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 = []
+
+      if allocation[:facilitation_payment] > 0
+        transactions << {
+          transaction_type: "fee_charge",
+          amount: allocation[:facilitation_payment],
+          reference_suffix: "FEE"
+        }
+      end
+
+      if allocation[:penalty_payment] > 0
+        transactions << {
+          transaction_type: "penalty",
+          amount: allocation[:penalty_payment],
+          reference_suffix: "PENALTY"
+        }
+      end
+
+      if allocation[:interest_payment] > 0
+        transactions << {
+          transaction_type: "interest_accrual",
+          amount: allocation[:interest_payment],
+          reference_suffix: "INTEREST"
+        }
+      end
+
+      if allocation[:principal_payment] > 0
+        transactions << {
+          transaction_type: "repayment",
+          amount: allocation[:principal_payment],
+          reference_suffix: "PRINCIPAL"
+        }
+      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"
+        )
+      end
+    end
+
+    def reactivate_facilities_if_paid_off
+      return unless loan.status == "paid"
+
+      loan_profile = loan.loan_profile
+
+      locked_eligible_lines = loan_profile.eligible_credit_lines
+                                         .where(available_limit: 0)
+                                         .includes(:credit_line)
+
+      locked_eligible_lines.each do |eligible_line|
+        current_usage = calculate_current_usage_for_credit_line(eligible_line.credit_line)
+        new_available_limit = [ eligible_line.credit_limit - current_usage, 0 ].max
+
+        eligible_line.update!(available_limit: new_available_limit)
+      end
+
+      update_loan_profile_available_amount(loan_profile)
+    end
+
+    def calculate_current_usage_for_credit_line(credit_line)
+      credit_line.loans
+                 .where(status: [ "active", "overdue", "disbursed" ])
+                 .where.not(id: loan.id)
+                 .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
+
+    def success_result(allocation)
+      {
+        success: true,
+        loan: loan.reload,
+        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) +
+                           (loan.remaining_amount || 0)
+        },
+        message: loan.status == "paid" ? "Loan fully paid off" : "Payment processed successfully"
+      }
+    end
+
+    def error_result(message)
+      {
+        success: false,
+        loan: nil,
+        error: message
+      }
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Dscf::Credit
+  class RiskApplicationService
+    def initialize(eligible_credit_line, risk_value)
+      @eligible_credit_line = eligible_credit_line
+      @risk_value = risk_value.to_f
+    end
+
+    def apply_risk
+      return { success: false, errors: @eligible_credit_line.errors.full_messages } unless @eligible_credit_line.valid?
+
+      @eligible_credit_line.risk = @risk_value
+      @eligible_credit_line.available_limit = calculate_available_limit
+
+      if @eligible_credit_line.save
+        { success: true, data: @eligible_credit_line }
+      else
+        { success: false, errors: @eligible_credit_line.errors.full_messages }
+      end
+    end
+
+    private
+
+    def calculate_available_limit
+      @eligible_credit_line.credit_limit * (1 - @risk_value)
+    end
+  end
+end