dscf-credit 0.1.2 → 0.1.4

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

@@ -3,5 +3,7 @@ module Dscf::Credit
     attributes :id, :type, :name, :description, :document_reference, :created_at, :updated_at
 
     has_many :credit_lines, serializer: Dscf::Credit::CreditLineSerializer
+    has_many :scoring_tables, serializer: Dscf::Credit::ScoringTableSerializer
+    has_many :scoring_parameters, serializer: Dscf::Credit::ScoringParameterSerializer
   end
 end

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

@@ -8,5 +8,7 @@ module Dscf::Credit
     belongs_to :created_by, serializer: Dscf::Core::UserSerializer
     belongs_to :reviewed_by, serializer: Dscf::Core::UserSerializer
     has_many :credit_line_specs, serializer: Dscf::Credit::CreditLineSpecSerializer
+    has_many :loans, serializer: Dscf::Credit::LoanSerializer
+    has_many :eligible_credit_lines, serializer: Dscf::Credit::EligibleCreditLineSerializer
   end
 end

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

@@ -1,7 +1,7 @@
 module Dscf::Credit
   class CreditLineSpecSerializer < ActiveModel::Serializer
     attributes :id, :min_amount, :max_amount, :interest_rate, :penalty_rate,
-               :facilitation_fee_rate, :tax_rate, :max_penalty_days,
+               :facilitation_fee_rate, :tax_rate, :credit_line_multiplier, :max_penalty_days,
                :loan_duration, :interest_frequency, :interest_income_tax,
                :vat, :max_interest_calculation_days, :penalty_frequency,
                :penalty_income_tax, :active, :created_at, :updated_at

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

@@ -0,0 +1,8 @@
+module Dscf::Credit
+  class DailyRoutineTransactionSerializer < ActiveModel::Serializer
+    attributes :id, :routine_type, :amount, :status, :processed_at,
+               :failure_reason, :created_at, :updated_at
+
+    belongs_to :loan, serializer: LoanSerializer
+  end
+end

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/facilitator_approval_service.rb

@@ -7,12 +7,11 @@ module Dscf::Credit
       @approver = approver
     end
 
-    def approve(total_limit = nil)
+    def approve
       ActiveRecord::Base.transaction do
         facilitator.update!(
           kyc_status: "approved",
-          kyc_approved_by: approver,
-          total_limit: total_limit
+          kyc_reviewed_by: approver
         )
 
         token = generate_additional_info_token
@@ -33,7 +32,7 @@ module Dscf::Credit
       ActiveRecord::Base.transaction do
         facilitator.update!(
           kyc_status: "rejected",
-          kyc_approved_by: approver,
+          kyc_reviewed_by: approver,
           review_feedback: review_feedback
         )