dscf-credit 0.1.4 → 0.1.5

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

@@ -0,0 +1,258 @@
+module Dscf::Credit
+  class CreditScoringEngine
+    attr_reader :loan_application, :category_id, :errors
+
+    def initialize(loan_application_id, category_id)
+      @loan_application = find_loan_application(loan_application_id)
+      @category_id = category_id
+      @errors = []
+    end
+
+    def calculate_score
+      return error_result("Loan application not found") unless loan_application
+      return error_result("Category ID is required") unless category_id
+
+      begin
+        scoring_parameters = get_active_scoring_parameters
+
+        if scoring_parameters.empty?
+          return error_result("No active scoring parameters found for this bank for category ID #{category_id}")
+        end
+
+        # Calculate weighted score using the formula
+        score_result = calculate_weighted_score(scoring_parameters)
+
+        success_result(score_result)
+      rescue StandardError => e
+        Rails.logger.error "Credit scoring failed: #{e.message}"
+        Rails.logger.error e.backtrace.join("\n")
+        error_result("Score calculation failed: #{e.message}")
+      end
+    end
+
+    private
+
+    def find_loan_application(loan_application_id)
+      Dscf::Credit::LoanApplication.includes(
+        :bank,
+        bank: :scoring_parameters
+      ).find_by(id: loan_application_id)
+    end
+
+    def get_active_scoring_parameters
+      return [] unless loan_application&.bank
+
+      loan_application.bank
+                     .scoring_parameters
+                     .active
+                     .where(category_id: category_id)
+                     .includes(:scoring_param_type, :parameter_normalizers, :category)
+    end
+
+    def calculate_weighted_score(scoring_parameters)
+      total_weighted_score = 0.0
+      total_weight = 0.0
+      score_breakdown = []
+      parameters_processed = 0
+      parameters_skipped = 0
+
+      scoring_parameters.each do |parameter|
+        raw_value = extract_parameter_value(parameter)
+
+        if raw_value.nil?
+          parameters_skipped += 1
+          score_breakdown << {
+            parameter_id: parameter.id,
+            parameter_name: parameter.name,
+            parameter_type: parameter.scoring_param_type.name,
+            raw_value: nil,
+            normalized_value: nil,
+            weight: parameter.weight,
+            weighted_score: 0.0,
+            status: "missing"
+          }
+          next
+        end
+
+        normalized_value = normalize_parameter_value(parameter, raw_value)
+        weighted_score = normalized_value * parameter.weight
+
+        total_weighted_score += weighted_score
+        total_weight += parameter.weight
+        parameters_processed += 1
+
+        score_breakdown << {
+          parameter_id: parameter.id,
+          parameter_name: parameter.name,
+          parameter_type: parameter.scoring_param_type.name,
+          raw_value: raw_value,
+          normalized_value: normalized_value,
+          weight: parameter.weight,
+          weighted_score: weighted_score,
+          status: "processed"
+        }
+      end
+
+      # Calculate final score using the formula: (sum of normalized_value × weight) / total_weight × 100
+      final_score = total_weight > 0 ? (total_weighted_score / total_weight * 100) : 0.0
+
+      {
+        score: final_score.round(2),
+        total_weighted_score: total_weighted_score.round(4),
+        total_weight: total_weight.round(4),
+        parameters_processed: parameters_processed,
+        parameters_skipped: parameters_skipped,
+        breakdown: score_breakdown
+      }
+    end
+
+    def extract_parameter_value(parameter)
+      param_type_name = parameter.scoring_param_type.name
+      parameter_id = parameter.id.to_s
+
+      # Get the appropriate JSON field based on parameter type
+      json_field = get_json_field_for_param_type(param_type_name)
+      return nil unless json_field
+
+      # Extract value using parameter ID as key
+      param_data = json_field[parameter_id]
+      return nil unless param_data.is_a?(Hash)
+
+      # Validate that the param_name matches (optional safety check)
+      expected_param_name = param_data["param_name"]
+      if expected_param_name && expected_param_name != parameter.name
+        Rails.logger.warn "Parameter name mismatch for ID #{parameter_id}: expected '#{parameter.name}', got '#{expected_param_name}'"
+      end
+
+      param_data["value"]
+    end
+
+    def get_json_field_for_param_type(param_type_name)
+      case param_type_name.downcase
+      when "user_info"
+        loan_application.user_info || {}
+      when "bank_info"
+        loan_application.bank_info || {}
+      when "facilitator_info"
+        loan_application.facilitator_info || {}
+      when "field_assessment"
+        loan_application.field_assessment || {}
+      else
+        Rails.logger.warn "Unknown parameter type: #{param_type_name}"
+        nil
+      end
+    end
+
+    def normalize_parameter_value(parameter, raw_value)
+      return 0.0 if raw_value.nil?
+
+      normalizer = find_normalizer(parameter, raw_value)
+      if normalizer
+        normalized_val = normalizer.normalized_value.to_f
+
+        # Ensure normalized value is between 0 and 1
+        return [ [ normalized_val, 0.0 ].max, 1.0 ].min
+      end
+
+      Rails.logger.warn "No normalizer found for parameter '#{parameter.name}' with value '#{raw_value}'"
+      0.0
+    rescue StandardError => e
+      Rails.logger.error "Failed to normalize value '#{raw_value}' for parameter '#{parameter.name}': #{e.message}"
+      0.0 # Return 0 for any normalization errors
+    end
+
+    def find_normalizer(parameter, raw_value)
+      exact_match = parameter.parameter_normalizers.find { |normalizer| normalizer.raw_value == raw_value.to_s }
+      return exact_match if exact_match
+
+      if parameter.data_type.in?([ "integer", "decimal" ])
+        numeric_value = parse_numeric_value(raw_value)
+        return nil unless numeric_value
+
+        threshold_normalizer = parameter.parameter_normalizers.find do |normalizer|
+          evaluate_numeric_threshold(normalizer.raw_value, numeric_value)
+        end
+
+        return threshold_normalizer if threshold_normalizer
+      end
+
+      nil
+    end
+
+    def parse_numeric_value(raw_value)
+      return raw_value if raw_value.is_a?(Numeric)
+
+      begin
+        Float(raw_value.to_s)
+      rescue ArgumentError, TypeError
+        nil
+      end
+    end
+
+    def evaluate_numeric_threshold(threshold_expression, numeric_value)
+      # Handle threshold expressions like ">=10000", "<5000", etc.
+      case threshold_expression
+      when /^>=(.+)$/
+        numeric_value >= Float($1)
+      when /^>(.+)$/
+        numeric_value > Float($1)
+      when /^<=(.+)$/
+        numeric_value <= Float($1)
+      when /^<(.+)$/
+        numeric_value < Float($1)
+      when /^=(.+)$/, /^(.+)$/ # Exact match or just the number
+        numeric_value == Float($1)
+      else
+        false
+      end
+    rescue ArgumentError, TypeError
+      false
+    end
+
+    def success_result(score_result)
+      final_score = score_result[:score]
+      review_status = determine_review_status(final_score)
+
+      {
+        success: true,
+        loan_application_id: loan_application.id,
+        bank_id: loan_application.bank_id,
+        category_id: category_id,
+        calculated_at: Time.current,
+        score: final_score,
+        status: review_status,
+        total_weighted_score: score_result[:total_weighted_score],
+        total_weight: score_result[:total_weight],
+        parameters_processed: score_result[:parameters_processed],
+        parameters_skipped: score_result[:parameters_skipped],
+        breakdown: score_result[:breakdown],
+        message: "Credit score calculated successfully"
+      }
+    end
+
+    def error_result(message)
+      @errors << message
+      {
+        success: false,
+        loan_application_id: loan_application&.id,
+        category_id: category_id,
+        error: message,
+        errors: @errors,
+        score: 0.0,
+        status: "rejected", # Errors result in rejection
+        calculated_at: Time.current
+      }
+    end
+
+    def determine_review_status(score)
+      case score
+      when 0...50
+        "rejected"
+      when 50..60
+        "pending_review"
+      else # score > 60
+        "approved"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,159 @@
+module Dscf::Credit
+  class FacilityLimitCalculationEngine
+    attr_reader :loan_profile, :category_id, :errors
+
+    def initialize(loan_profile_id, category_id)
+      @errors = []
+      @loan_profile = LoanProfile.find(loan_profile_id)
+      @category_id = category_id
+    rescue ActiveRecord::RecordNotFound => e
+      @errors << "Loan profile not found: #{e.message}"
+    end
+
+    # Calculate facility limits for all credit lines in the category
+    def calculate_facility_limits
+      return error_result("Loan profile is required") unless loan_profile
+      return error_result("Category ID is required") unless category_id
+
+      begin
+        ActiveRecord::Base.transaction do
+          # Get all credit lines for the category and bank
+          credit_lines = get_credit_lines_for_calculation
+
+          if credit_lines.empty?
+            return error_result("No credit lines found for category #{category_id} and bank #{loan_profile.loan_application.bank_id}")
+          end
+
+          # Calculate base metric from facilitator info
+          base_metric = calculate_base_metric
+
+          if base_metric <= 0
+            return error_result("Invalid base metric calculated: #{base_metric}. Check facilitator_info avg_monthly_purchase.")
+          end
+
+          # Calculate facility limits for each credit line
+          eligible_credit_lines = []
+
+          credit_lines.each do |credit_line|
+            limit_result = calculate_credit_line_limit(credit_line, base_metric)
+
+            if limit_result[:success] && limit_result[:limit] >= 0
+              eligible_credit_line = create_eligible_credit_line(credit_line, limit_result[:limit])
+              eligible_credit_lines << eligible_credit_line
+            end
+          end
+
+          # Update loan profile total limit
+          update_loan_profile_total_limit
+
+          success_result(eligible_credit_lines, "Facility limits calculated successfully")
+        end
+      rescue StandardError => e
+        Rails.logger.error "Facility limit calculation failed: #{e.message}"
+        Rails.logger.error e.backtrace.join("\n")
+        error_result("Failed to calculate facility limits: #{e.message}")
+      end
+    end
+
+    private
+
+    # Get credit lines for the specified category and bank
+    def get_credit_lines_for_calculation
+      CreditLine.joins(:category, :credit_line_specs)
+                .where(
+                  category_id: category_id,
+                  bank_id: loan_profile.loan_application.bank_id,
+                  dscf_credit_credit_line_specs: { active: true }
+                )
+                .includes(:credit_line_specs)
+                .distinct
+    end
+
+    # Calculate base metric from facilitator info
+    def calculate_base_metric
+      facilitator_info = loan_profile.loan_application.facilitator_info || {}
+
+      # Find avg_monthly_purchase from the nested JSON structure
+      # facilitator_info structure: { "301": { "param_name": "avg_monthly_purchase", "value": 30000 } }
+      avg_monthly_purchase = nil
+
+      facilitator_info.each do |param_id, param_data|
+        if param_data.is_a?(Hash) &&
+           (param_data["param_name"] == "avg_monthly_purchase" || param_data[:param_name] == "avg_monthly_purchase")
+          avg_monthly_purchase = param_data["value"] || param_data[:value]
+          break
+        end
+      end
+
+      # Handle string and numeric values
+      if avg_monthly_purchase.is_a?(String)
+        avg_monthly_purchase = avg_monthly_purchase.to_f
+      else
+        avg_monthly_purchase = avg_monthly_purchase.to_f if avg_monthly_purchase
+      end
+
+      return 0.0 if avg_monthly_purchase.nil? || avg_monthly_purchase <= 0
+
+      avg_monthly_purchase / 30.0
+    end
+
+    # Calculate facility limit for a specific credit line
+    def calculate_credit_line_limit(credit_line, base_metric)
+      credit_line_spec = credit_line.credit_line_specs.active.order(created_at: :desc).first
+
+      unless credit_line_spec
+        return { success: false, error: "No active credit line spec found for credit line #{credit_line.id}" }
+      end
+
+      score_percentage = loan_profile.score / 100.0
+      calculated_limit = base_metric * credit_line_spec.credit_line_multiplier * score_percentage
+
+      final_limit = apply_min_max_constraints(calculated_limit, credit_line_spec)
+
+      { success: true, limit: final_limit, credit_line_spec: credit_line_spec }
+    end
+
+    def apply_min_max_constraints(calculated_limit, credit_line_spec)
+      if calculated_limit > credit_line_spec.max_amount
+        return credit_line_spec.max_amount
+      end
+
+      if calculated_limit < credit_line_spec.min_amount
+        return 0.0
+      end
+
+      calculated_limit
+    end
+
+    def create_eligible_credit_line(credit_line, limit)
+      loan_profile.eligible_credit_lines.create!(
+        credit_line: credit_line,
+        credit_limit: limit,
+        available_limit: limit,
+        risk: nil
+      )
+    end
+
+    def update_loan_profile_total_limit
+      total_limit = loan_profile.eligible_credit_lines.sum(:available_limit)
+      loan_profile.update!(total_limit: total_limit)
+    end
+
+    def success_result(data, message)
+      {
+        success: true,
+        data: data,
+        message: message
+      }
+    end
+
+    def error_result(error_message)
+      @errors << error_message unless @errors.include?(error_message)
+      {
+        success: false,
+        error: error_message,
+        errors: @errors
+      }
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+module Dscf::Credit
+  class LoanProfileCreationService
+    attr_reader :loan_application, :score, :errors
+
+    def initialize(loan_application, score)
+      @loan_application = loan_application
+      @score = score
+      @errors = []
+    end
+
+    def create_loan_profile
+      return error_result("Loan application is required") unless loan_application
+      return error_result("Score is required") unless score
+
+      if loan_application.loan_profile.present?
+        return success_result(loan_application.loan_profile, "Loan profile already exists")
+      end
+
+      begin
+        ActiveRecord::Base.transaction do
+          loan_profile = build_loan_profile
+          loan_profile.save!
+
+          create_initial_review(loan_profile)
+
+          success_result(loan_profile, "Loan profile created successfully")
+        end
+      rescue StandardError => e
+        Rails.logger.error "Loan profile creation failed: #{e.message}"
+        Rails.logger.error e.backtrace.join("\n")
+        error_result("Failed to create loan profile: #{e.message}")
+      end
+    end
+
+    private
+
+    def build_loan_profile
+      loan_application.build_loan_profile(
+        code: generate_loan_profile_code,
+        score: score,
+        total_limit: calculate_total_limit
+      )
+    end
+
+    def generate_loan_profile_code
+      # Generate unique code starting with "BB" followed by up to 6 digits
+      loop do
+        # Generate a random 6-digit number
+        random_digits = sprintf("%06d", rand(1000000))
+        code = "BB#{random_digits}"
+
+        unless Dscf::Credit::LoanProfile.exists?(code: code)
+          return code
+        end
+      end
+    end
+
+    def calculate_total_limit
+      0.0
+    end
+
+    def create_initial_review(loan_profile)
+      loan_profile.reviews.create!(
+        context: "default",
+        status: "approved",
+        reviewed_by: nil, # System created
+        reviewed_at: Time.current,
+        feedback: {
+          message: "Loan profile automatically created for approved loan application"
+        }
+      )
+    end
+
+    def success_result(loan_profile, message)
+      {
+        success: true,
+        loan_profile: loan_profile,
+        message: message
+      }
+    end
+
+    def error_result(message)
+      @errors << message
+      {
+        success: false,
+        error: message,
+        errors: @errors
+      }
+    end
+  end
+end

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

@@ -1,27 +1,77 @@
 module Dscf::Credit
   class RiskApplicationService
-    def initialize(eligible_credit_line, risk_value)
+    attr_reader :eligible_credit_line, :risk_factor, :errors
+
+    def initialize(eligible_credit_line, risk_factor)
       @eligible_credit_line = eligible_credit_line
-      @risk_value = risk_value.to_f
+      @risk_factor = risk_factor.nil? ? nil : risk_factor.to_f
+      @errors = []
     end
 
     def apply_risk
-      return { success: false, errors: @eligible_credit_line.errors.full_messages } unless @eligible_credit_line.valid?
+      return error_result("Eligible credit line is required") unless eligible_credit_line
+      return error_result("Risk factor is required") if risk_factor.nil?
+      return error_result("Risk factor must be between 0.0 and 0.9") unless valid_risk_factor?
+
+      begin
+        ActiveRecord::Base.transaction do
+          eligible_credit_line.risk = risk_factor
+
+          new_available_limit = calculate_available_limit_with_risk
+          eligible_credit_line.available_limit = new_available_limit
+
+          eligible_credit_line.save!
 
-      @eligible_credit_line.risk = @risk_value
-      @eligible_credit_line.available_limit = calculate_available_limit
+          update_loan_profile_total_limit
 
-      if @eligible_credit_line.save
-        { success: true, data: @eligible_credit_line }
-      else
-        { success: false, errors: @eligible_credit_line.errors.full_messages }
+          success_result(eligible_credit_line, "Risk factor applied successfully")
+        end
+      rescue StandardError => e
+        Rails.logger.error "Risk application failed: #{e.message}"
+        Rails.logger.error e.backtrace.join("\n")
+        error_result("Failed to apply risk factor: #{e.message}")
       end
     end
 
     private
 
-    def calculate_available_limit
-      @eligible_credit_line.credit_limit * (1 - @risk_value)
+    def valid_risk_factor?
+      risk_factor >= 0.0 && risk_factor <= 0.9
+    end
+
+    def calculate_available_limit_with_risk
+      # available_limit = credit_limit × (1 - risk_factor)
+      # If risk_factor is 0.0 (0%), available_limit = credit_limit
+      # If risk_factor is 0.9 (90%), available_limit = credit_limit × 0.1
+      result = eligible_credit_line.credit_limit * (1 - risk_factor)
+      result.round(2)
+    end
+
+    def update_loan_profile_total_limit
+      loan_profile = eligible_credit_line.loan_profile
+      return unless loan_profile
+
+      total_available_limit = loan_profile.eligible_credit_lines.sum(:available_limit)
+
+      loan_profile.update!(total_limit: total_available_limit)
+
+      Rails.logger.info "Updated loan profile #{loan_profile.id} total limit to #{total_available_limit}"
+    end
+
+    def success_result(data, message)
+      {
+        success: true,
+        data: data,
+        message: message
+      }
+    end
+
+    def error_result(message)
+      {
+        success: false,
+        error: message,
+        errors: [ message ]
+      }
     end
   end
 end