dscf-credit 0.1.1 → 0.1.3

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

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

@@ -0,0 +1,297 @@
+module Dscf::Credit
+  class ScoringService
+    attr_reader :loan_profile
+
+    def initialize(loan_profile)
+      @loan_profile = loan_profile
+    end
+
+    # Calculate credit score for a loan profile using the eligibility category scoring table
+    # @param external_scoring_data [Hash] Optional external scoring input data
+    # @return [Hash] Result containing score, total_limit, and success status
+    def calculate_credit_score(external_scoring_data = nil)
+      eligibility_category = find_eligibility_category
+      return error_result("Eligibility category not found") unless eligibility_category
+
+      scoring_tables = eligibility_category.scoring_tables.active.includes(:scoring_parameter)
+      return error_result("No active scoring parameters found for eligibility category") if scoring_tables.empty?
+
+      scoring_data = get_scoring_data(external_scoring_data)
+      score = calculate_weighted_score(scoring_tables, scoring_data)
+      facility_limit = calculate_facility_limit(score, scoring_data)
+
+      success_result(score, facility_limit)
+    rescue StandardError => e
+      error_result("Score calculation failed: #{e.message}")
+    end
+
+    private
+
+    def get_scoring_data(external_scoring_data)
+      if external_scoring_data.present?
+        external_scoring_data
+      else
+        extract_scoring_data_from_profile
+      end
+    end
+
+    def extract_scoring_data_from_profile
+      latest_spec = loan_profile.loan_profile_scoring_specs.order(created_at: :desc).first
+
+      if latest_spec&.scoring_input_data.present? && !latest_spec.scoring_input_data.empty?
+        default_data = prepare_scoring_data
+        default_data.merge(latest_spec.scoring_input_data.symbolize_keys)
+      else
+        prepare_scoring_data
+      end
+    end
+
+    def find_eligibility_category
+      Dscf::Credit::Category.find_by(type: "eligibility", name: "default") ||
+        Dscf::Credit::Category.find_by(type: "eligibility")
+    end
+
+    def prepare_scoring_data
+      {
+        average_daily_purchase: extract_average_daily_purchase,
+        years_at_location: extract_years_at_location,
+        marital_status: extract_marital_status,
+        dependents_count: extract_dependents_count,
+        education_level: extract_education_level,
+        bill_payment_timing: extract_bill_payment_timing,
+        other_accounts: extract_other_accounts,
+        money_preference: extract_money_preference,
+        business_license: extract_business_license,
+        bank_statements: extract_bank_statements,
+        transaction_frequency: extract_transaction_frequency,
+        purchase_volume: extract_purchase_volume,
+        cancellation_rate: extract_cancellation_rate,
+        reliability_score: extract_reliability_score
+      }
+    end
+
+    # Calculate weighted score based on scoring parameters
+    def calculate_weighted_score(scoring_tables, scoring_data)
+      total_score = 0.0
+      total_weight = 0.0
+
+      scoring_tables.each do |table|
+        parameter = table.scoring_parameter
+        raw_value = find_parameter_value(parameter, scoring_data)
+
+        next if raw_value.nil?
+
+        normalized_score = normalize_parameter_value(parameter, raw_value)
+        weighted_score = normalized_score * table.weight
+
+        total_score += weighted_score
+        total_weight += table.weight
+      end
+
+      return 0.0 if total_weight.zero?
+
+      (total_score / total_weight) * 100
+    end
+
+    # Find parameter value from scoring data using flexible key matching
+    def find_parameter_value(parameter, scoring_data)
+      param_name = parameter.name
+
+      # Try exact match first
+      if scoring_data.key?(param_name.to_sym)
+        return scoring_data[param_name.to_sym]
+      end
+
+      if scoring_data.key?(param_name)
+        return scoring_data[param_name]
+      end
+
+      # Try snake_case version
+      snake_case_name = param_name.downcase.gsub(/\s+/, "_")
+      if scoring_data.key?(snake_case_name.to_sym)
+        return scoring_data[snake_case_name.to_sym]
+      end
+
+      if scoring_data.key?(snake_case_name)
+        return scoring_data[snake_case_name]
+      end
+
+      # Try common mappings
+      case param_name.downcase
+      when "monthly income"
+        scoring_data[:monthly_income] || scoring_data["monthly_income"]
+      when "credit history score"
+        scoring_data[:credit_history_score] || scoring_data["credit_history_score"]
+      when "employment type"
+        scoring_data[:employment_type] || scoring_data["employment_type"]
+      else
+        nil
+      end
+    end
+
+    # Calculate facility limit based on score and business metrics
+    def calculate_facility_limit(score, scoring_data)
+      return 0 if score < 50 # Below 50% score = no facility
+
+      average_daily_purchase = scoring_data[:average_daily_purchase] || 0
+
+      credit_line_multiplier = get_default_credit_line_multiplier
+
+      base_limit = average_daily_purchase * credit_line_multiplier * (score / 100.0)
+
+      apply_limit_constraints(base_limit)
+    end
+
+    # Get default credit line multiplier from the bank's approved credit line specs
+    def get_default_credit_line_multiplier
+      return 30.0 unless loan_profile.bank
+
+      credit_line_spec = loan_profile.bank.credit_lines.approved
+                                     .joins(:credit_line_specs)
+                                     .merge(Dscf::Credit::CreditLineSpec.active)
+                                     .select("dscf_credit_credit_line_specs.credit_line_multiplier")
+                                     .first&.credit_line_specs&.active&.first
+
+      credit_line_spec&.credit_line_multiplier || 30.0
+    end
+
+    def apply_limit_constraints(base_limit)
+      min_limit = get_bank_config("min_credit_limit", 0)
+      max_limit = get_bank_config("max_credit_limit", 1000000)
+
+      return 0 if base_limit < min_limit
+      return max_limit if base_limit > max_limit
+
+      base_limit
+    end
+
+    # Get bank configuration value from system configs
+    def get_bank_config(config_key, default_value)
+      return default_value unless loan_profile.bank
+
+      config_definition = loan_profile.bank.system_config_definitions
+                                          .find_by(config_key: config_key)
+      return default_value unless config_definition
+
+      system_config = Dscf::Credit::SystemConfig.approved
+                                                .find_by(config_definition: config_definition)
+
+      if system_config&.config_value
+        numeric_value = system_config.config_value.to_f
+        numeric_value > 0 ? numeric_value : default_value
+      else
+        default_value
+      end
+    end
+
+    # Normalize parameter value to 0-1 scale
+    def normalize_parameter_value(parameter, raw_value)
+      case parameter.data_type
+      when "boolean"
+        raw_value ? 1.0 : 0.0
+      when "integer", "decimal"
+        normalize_numeric_value(parameter, raw_value.to_f)
+      when "string"
+        normalize_string_value(parameter, raw_value)
+      else
+        0.5 # Default neutral score
+      end
+    end
+
+    def normalize_numeric_value(parameter, value)
+      min_val = parameter.min_value || 0
+      max_val = parameter.max_value || 100
+
+      return 0.0 if value < min_val
+      return 1.0 if value > max_val
+
+      (value - min_val) / (max_val - min_val)
+    end
+
+    def normalize_string_value(parameter, value)
+      normalizer = parameter.parameter_normalizers.find { |n| n.raw_value == value }
+      return normalizer.normalized_value if normalizer
+
+      case value.downcase
+      when "excellent", "high", "good" then 1.0
+      when "fair", "medium", "average" then 0.7
+      when "poor", "low", "bad" then 0.3
+      else 0.5
+      end
+    end
+
+    def extract_average_daily_purchase
+      5000.0 # Default average daily purchase
+    end
+
+    def extract_years_at_location
+      2 # Default years at current location
+    end
+
+    def extract_marital_status
+      "single" # Default marital status
+    end
+
+    def extract_dependents_count
+      0 # Default number of dependents
+    end
+
+    def extract_education_level
+      "bachelor" # Default education level
+    end
+
+    def extract_bill_payment_timing
+      "on_time" # Default payment timing
+    end
+
+    def extract_other_accounts
+      false # Default: no other active accounts
+    end
+
+    def extract_money_preference
+      "save" # Default money preference
+    end
+
+    def extract_business_license
+      false # Default: no business license
+    end
+
+    def extract_bank_statements
+      true # Default: bank statements available
+    end
+
+    def extract_transaction_frequency
+      15 # Default monthly transaction frequency
+    end
+
+    def extract_purchase_volume
+      50000.0 # Default monthly purchase volume
+    end
+
+    def extract_cancellation_rate
+      0.05 # Default 5% cancellation rate
+    end
+
+    def extract_reliability_score
+      75.0 # Default reliability score (0-100)
+    end
+
+    def success_result(score, facility_limit)
+      {
+        success: true,
+        score: score.round(2),
+        facility_limit: facility_limit.round(2),
+        message: "Credit score calculated successfully"
+      }
+    end
+
+    def error_result(message)
+      {
+        success: false,
+        score: 0,
+        facility_limit: 0,
+        error: message
+      }
+    end
+  end
+end