dscf-credit 0.1.4 → 0.1.6

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

@@ -1,11 +1,10 @@
 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
+               :total_loan_amount, :remaining_amount, :due_date, :disbursed_at, :active, :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

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

@@ -1,15 +1,14 @@
 module Dscf::Credit
   class ScoringParameterSerializer < ActiveModel::Serializer
     attributes :id, :name, :description, :data_type, :weight, :min_value,
-               :max_value, :active, :status, :review_date, :review_feedback, :source, :document_reference, :created_at, :updated_at
+               :max_value, :active, :source, :document_reference, :created_at, :updated_at
 
     belongs_to :bank, serializer: Dscf::Credit::BankSerializer
+    belongs_to :category, serializer: Dscf::Credit::CategorySerializer
     belongs_to :created_by, polymorphic: true
-    belongs_to :reviewed_by, polymorphic: true
     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
+    has_many :reviews, serializer: Dscf::Core::ReviewSerializer
   end
 end

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

@@ -1,6 +1,6 @@
 module Dscf::Credit
   class SystemConfigSerializer < ActiveModel::Serializer
-    attributes :id, :config_value, :status, :review_date, :review_feedback, :created_at, :updated_at
+    attributes :id, :config_value, :created_at, :updated_at
 
     attribute :config_definition do
       {
@@ -13,6 +13,6 @@ module Dscf::Credit
     end
 
     belongs_to :last_updated_by, serializer: Dscf::Core::UserSerializer
-    belongs_to :reviewed_by, serializer: Dscf::Core::UserSerializer
+    has_many :reviews, serializer: Dscf::Core::ReviewSerializer
   end
 end

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

@@ -1,34 +1,35 @@
 module Dscf::Credit
   class DisbursementService
-    attr_reader :credit_line, :payment_request, :current_user
+    attr_reader :amount, :loan_profile, :eligible_credit_line
 
-    def initialize(credit_line, payment_request, current_user)
-      @credit_line = credit_line
-      @payment_request = payment_request
-      @current_user = current_user
+    def initialize(amount:, loan_profile:, eligible_credit_line:)
+      @amount = amount.to_f
+      @loan_profile = loan_profile
+      @eligible_credit_line = eligible_credit_line
     end
 
-    # Process disbursement by creating a loan record from selected credit line
+    # Process disbursement by creating a loan record from eligible credit line
     # @return [Hash] Result containing created loan and disbursement details
     def process_disbursement
+      return error_result("Loan profile not found") unless loan_profile
+      return error_result("Eligible credit line not found") unless eligible_credit_line
+      return error_result("Invalid amount") unless amount > 0
+
+      credit_line = eligible_credit_line.credit_line
       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
+      credit_line_status = credit_line.current_status_for(:default)
+      return error_result("Credit line is not approved") unless credit_line_status == "approved"
 
-      loan_profile = eligible_credit_line.loan_profile
-      return error_result("Loan profile not approved") unless loan_profile.status == "approved"
+      loan_profile_status = loan_profile.current_status_for(:default)
+      return error_result("Loan profile not approved") unless loan_profile_status == "approved"
 
-      validation_result = validate_disbursement_amount(eligible_credit_line)
+      validation_result = validate_disbursement_amount
       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)
+        loan = create_loan_record(credit_line)
+        update_credit_line_limits(loan)
 
         success_result(loan)
       end
@@ -38,36 +39,27 @@ module Dscf::Credit
 
     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
+    def validate_disbursement_amount
       available_limit = eligible_credit_line.available_limit
 
-      if requested_amount <= 0
+      if amount <= 0
         return error_result("Invalid disbursement amount")
       end
 
-      if requested_amount > available_limit
+      if 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)
+    def create_loan_record(credit_line)
+      loan_terms = calculate_loan_terms(credit_line)
 
       loan = Dscf::Credit::Loan.new(
         loan_profile: loan_profile,
         credit_line: credit_line,
-        payment_request: payment_request,
-        principal_amount: payment_request.amount,
+        principal_amount: amount,
         facilitation_fee: loan_terms[:facilitation_fee],
         total_loan_amount: loan_terms[:total_amount],
         remaining_amount: loan_terms[:total_amount],
@@ -75,7 +67,8 @@ module Dscf::Credit
         accrued_penalty: 0,
         status: "disbursed",
         due_date: loan_terms[:due_date],
-        disbursed_at: Time.current
+        disbursed_at: Time.current,
+        active: true
       )
 
       raise "Failed to create loan: #{loan.errors.full_messages.join(', ')}" unless loan.save
@@ -83,21 +76,20 @@ module Dscf::Credit
       loan
     end
 
-    def calculate_loan_terms(eligible_credit_line)
-      principal = payment_request.amount
+    def calculate_loan_terms(credit_line)
+      principal = 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
+      unless credit_line_spec
+        raise "No active credit line specification found for credit line #{credit_line.id}. " \
+              "Please configure a CreditLineSpec before processing disbursements."
       end
 
+      facilitation_rate = credit_line_spec.facilitation_fee_rate
+      vat_rate = credit_line_spec.vat
+      loan_duration = credit_line_spec.loan_duration
+
       facilitation_fee = principal * facilitation_rate
       vat_amount = facilitation_fee * vat_rate
       total_amount = principal + facilitation_fee + vat_amount
@@ -112,46 +104,9 @@ module Dscf::Credit
       }
     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)
+    def update_credit_line_limits(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)
@@ -159,9 +114,9 @@ module Dscf::Credit
         success: true,
         loan: loan,
         disbursement_details: {
-          principal_amount: loan.principal_amount,
-          facilitation_fee: loan.facilitation_fee,
-          total_loan_amount: loan.total_loan_amount,
+          principal_amount: loan.principal_amount.to_f,
+          facilitation_fee: loan.facilitation_fee.to_f,
+          total_loan_amount: loan.total_loan_amount.to_f,
           due_date: loan.due_date,
           disbursed_at: loan.disbursed_at
         },

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