dscf-credit 0.2.5 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9f8c9b62c4ec5893c8ab1b234073b103d9eb78370d133bd1e0b40b56aea1fd0
-  data.tar.gz: 12447006ba8f6896e6316cbf20093b3527454ca144659b00839e435284adea9d
+  metadata.gz: 36671cda01df2f1f1b75625ccd3bb1ba23b16f97d410c498d89f0a93af02ac84
+  data.tar.gz: d84818826abcfb81ad715806b7383c1ed3aa64672e7e58460af664e65c46ca0f
 SHA512:
-  metadata.gz: d5672372c71088c52598cc2839fd5f6b71955ad9b781b3e2c568a37407858b5cdeec1cc37029208000f77cd3bb1d66d9f21a896abda6f48aab182f21436b0fdd
-  data.tar.gz: 630a449898f52513090be1aacb501a29ec977492f67e8a2e097056360ac83188bd632ddf754baaf1a745ebc1660599c29332e1f466b2de5aafffa899888d7f5f
+  metadata.gz: df917f92170265597d7a3dacbab1f099fdcf41fb7c8c2c5c1a37733776aa650d28dd11367064a899edd2e210316c9ebacaf11576f7196dd1014f745064711b1d
+  data.tar.gz: 26b4b04ca0313bff6f1fd9d8c15116f335c57dac0489f19383b1bf7849280d648338749fedc464401943a5845996ec46cfe84024eecac3adc985ecadbbbf31a3

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

@@ -1,6 +1,10 @@
 module Dscf::Credit
   class LoanProfileSerializer < ActiveModel::Serializer
-    attributes :id, :code, :score, :total_limit, :created_at, :updated_at
+    attributes :id, :code, :score, :total_limit, :created_at, :updated_at, :user_id
+
+    attribute :user_id do
+      object.loan_application.user_id
+    end
 
     belongs_to :loan_application, serializer: Dscf::Credit::LoanApplicationSerializer
 

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

@@ -12,9 +12,14 @@ module Dscf::Credit
                :total_facilitation_fee,
                :total_outstanding,
                :active,
+               :user_id,
                :created_at,
                :updated_at
 
+    attribute :user_id do
+      object.loan_profile.loan_application.user_id
+    end
+
     belongs_to :loan_profile, serializer: LoanProfileSerializer
     belongs_to :credit_line, serializer: CreditLineSerializer
     has_many :loan_transactions, serializer: LoanTransactionSerializer

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

@@ -46,7 +46,7 @@ module Dscf::Credit
                      .scoring_parameters
                      .active
                      .where(scoring_param_type_id: scoring_param_type_id)
-                     .includes(:scoring_param_type, :parameter_normalizers, :category)
+                     .includes(:scoring_param_type, :category)
     end
 
     def calculate_weighted_score(scoring_parameters)
@@ -54,13 +54,15 @@ module Dscf::Credit
       total_weight = 0.0
       score_breakdown = []
       parameters_processed = 0
-      parameters_skipped = 0
+      validation_errors = []
 
       scoring_parameters.each do |parameter|
         raw_value = extract_parameter_value(parameter)
 
         if raw_value.nil?
-          parameters_skipped += 1
+          error_msg = "Missing required parameter: #{parameter.name} (ID: #{parameter.id})"
+          validation_errors << error_msg
+          Rails.logger.error "Credit scoring validation failed: #{error_msg}"
           score_breakdown << {
             parameter_id: parameter.id,
             parameter_name: parameter.name,
@@ -69,12 +71,54 @@ module Dscf::Credit
             normalized_value: nil,
             weight: parameter.weight,
             weighted_score: 0.0,
-            status: "missing"
+            status: "missing",
+            error: "Parameter value is required"
+          }
+          next
+        end
+
+        unless raw_value.is_a?(Numeric)
+          begin
+            Float(raw_value)
+          rescue ArgumentError, TypeError
+            error_msg = "Invalid data type for parameter: #{parameter.name} (ID: #{parameter.id}). Expected numeric, got #{raw_value.class}"
+            validation_errors << error_msg
+            Rails.logger.error "Credit scoring validation failed: #{error_msg}"
+            score_breakdown << {
+              parameter_id: parameter.id,
+              parameter_name: parameter.name,
+              parameter_type: parameter.scoring_param_type.name,
+              raw_value: raw_value,
+              normalized_value: nil,
+              weight: parameter.weight,
+              weighted_score: 0.0,
+              status: "invalid",
+              error: "Value must be numeric"
+            }
+            next
+          end
+        end
+
+        normalized_value = raw_value.to_f
+
+        unless normalized_value.between?(0.0, 1.0)
+          error_msg = "Invalid normalized value for parameter: #{parameter.name} (ID: #{parameter.id}). Value: #{raw_value}, Expected: 0.0-1.0"
+          validation_errors << error_msg
+          Rails.logger.error "Credit scoring validation failed: #{error_msg}"
+          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: 0.0,
+            status: "invalid",
+            error: "Value must be between 0.0 and 1.0"
           }
           next
         end
 
-        normalized_value = normalize_parameter_value(parameter, raw_value)
         weighted_score = normalized_value * parameter.weight
 
         total_weighted_score += weighted_score
@@ -93,15 +137,38 @@ module Dscf::Credit
         }
       end
 
+      if validation_errors.any?
+        return {
+          success: false,
+          error: "Validation failed: #{validation_errors.size} parameter(s) failed validation",
+          validation_errors: validation_errors,
+          parameters_processed: parameters_processed,
+          parameters_failed: validation_errors.size,
+          breakdown: score_breakdown
+        }
+      end
+
+      if parameters_processed == 0
+        return {
+          success: false,
+          error: "No valid parameters available for scoring",
+          validation_errors: [ "All parameters failed validation or are missing" ],
+          parameters_processed: 0,
+          parameters_failed: scoring_parameters.size,
+          breakdown: score_breakdown
+        }
+      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
 
       {
+        success: true,
         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,
+        parameters_failed: 0,
         breakdown: score_breakdown
       }
     end
@@ -148,74 +215,24 @@ module Dscf::Credit
       raw_value
     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
+    def success_result(score_result)
+      if score_result[:success] == false
+        return {
+          success: false,
+          loan_application_id: loan_application.id,
+          bank_id: loan_application.bank_id,
+          scoring_param_type_id: scoring_param_type_id,
+          calculated_at: Time.current,
+          error: score_result[:error],
+          validation_errors: score_result[:validation_errors],
+          parameters_processed: score_result[:parameters_processed],
+          parameters_failed: score_result[:parameters_failed],
+          breakdown: score_result[:breakdown],
+          score: 0.0,
+          status: "rejected"
+        }
       end
-    rescue ArgumentError, TypeError
-      false
-    end
 
-    def success_result(score_result)
       final_score = score_result[:score]
       review_status = determine_review_status(final_score)
 
@@ -230,7 +247,8 @@ module Dscf::Credit
         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],
+        parameters_skipped: 0,
+        parameters_failed: score_result[:parameters_failed],
         breakdown: score_result[:breakdown],
         message: "Credit score calculated successfully"
       }

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

@@ -30,6 +30,7 @@ module Dscf::Credit
       ActiveRecord::Base.transaction do
         loan = create_loan_record(credit_line)
         update_credit_line_limits(loan)
+        lock_other_credit_lines(loan_profile, credit_line)
 
         success_result(loan)
       end
@@ -37,6 +38,15 @@ module Dscf::Credit
       error_result("Disbursement processing failed: #{e.message}")
     end
 
+    # Lock other eligible credit lines for the loan profile except the specified credit line
+    # @param loan_profile [Dscf::Credit::LoanProfile] The loan profile
+    # @param credit_line [Dscf::Credit::CreditLine] The credit line to exclude from locking
+    def lock_other_credit_lines(loan_profile, credit_line)
+      loan_profile.eligible_credit_lines
+        .where.not(credit_line: credit_line)
+        .update_all(locked: true)
+    end
+
     private
 
     def validate_disbursement_amount
@@ -72,9 +82,6 @@ module Dscf::Credit
       # Create facilitator fee accrual
       create_facilitator_fee_accrual(loan, loan_terms[:facilitation_fee])
 
-      # Create VAT accrual if applicable
-      create_vat_accrual(loan, loan_terms[:vat_amount]) if loan_terms[:vat_amount] > 0
-
       loan
     end
 
@@ -89,18 +96,15 @@ module Dscf::Credit
       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
+      total_amount = principal + facilitation_fee
 
       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
       }
@@ -118,23 +122,10 @@ module Dscf::Credit
       )
     end
 
-    def create_vat_accrual(loan, vat_amount)
-      return if vat_amount <= 0
-
-      Dscf::Credit::LoanAccrual.create!(
-        loan: loan,
-        accrual_type: "tax",
-        amount: vat_amount,
-        applied_on: Date.current,
-        status: "pending"
-      )
-    end
-
     def update_credit_line_limits(loan)
-      # Calculate total amount from accruals: principal + facilitation_fee + vat
+      # Calculate total amount from accruals: principal + facilitation_fee
       facilitation_fee = loan.loan_accruals.find_by(accrual_type: "facilitation_fee")&.amount || 0
-      vat = loan.loan_accruals.find_by(accrual_type: "tax")&.amount || 0
-      total_amount = loan.principal_amount + facilitation_fee + vat
+      total_amount = loan.principal_amount + facilitation_fee
 
       new_available_limit = eligible_credit_line.available_limit - total_amount
       eligible_credit_line.update!(available_limit: [ new_available_limit, 0 ].max)
@@ -145,11 +136,9 @@ module Dscf::Credit
       loan.reload
 
       facilitation_fee_accrual = loan.loan_accruals.find_by(accrual_type: "facilitation_fee")
-      vat_accrual = loan.loan_accruals.find_by(accrual_type: "tax")
 
       facilitation_fee = facilitation_fee_accrual&.amount&.to_f || 0.0
-      vat_amount = vat_accrual&.amount&.to_f || 0.0
-      total_amount = loan.principal_amount.to_f + facilitation_fee + vat_amount
+      total_amount = loan.principal_amount.to_f + facilitation_fee
 
       {
         success: true,
@@ -157,7 +146,6 @@ module Dscf::Credit
         disbursement_details: {
           principal_amount: loan.principal_amount.to_f,
           facilitation_fee: facilitation_fee,
-          vat_amount: vat_amount,
           total_loan_amount: total_amount,
           due_date: loan.due_date,
           disbursed_at: loan.disbursed_at

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

@@ -250,7 +250,7 @@ module Dscf::Credit
                        (loan.remaining_amount || 0)
 
       if total_remaining <= 0.01
-        loan.update!(status: "paid")
+        loan.update!(status: "paid", active: false)
       else
         loan.update!(status: "active") if loan.status == "overdue"
       end
@@ -261,46 +261,30 @@ module Dscf::Credit
     # Only runs if loan.status == "paid"
     #
     # Process:
-    # 1. Find all eligible credit lines with 0 available_limit (locked)
+    # 1. Find all locked eligible credit lines (locked during disbursement)
     # 2. For each locked line, recalculate available_limit based on:
     #    - Credit limit (total allowed)
     #    - Minus current usage from other active loans
+    # 3. Unlock the credit line by setting locked: false
     #
     # This allows the borrower to access credit again after repayment.
     #
     # @return [void]
     #
     # @example
-    #   # Before: eligible_line.available_limit = 0 (locked)
-    #   # After payment: eligible_line.available_limit = 7000 (reactivated)
+    #   # Before: eligible_line.locked = true
+    #   # After payment: eligible_line.locked = false
     def reactivate_facilities_if_paid_off
       return unless loan.status == "paid"
 
       loan_profile = loan.loan_profile
+      credit_line = loan.credit_line
 
-      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
-    end
-
-    # Calculate total current usage for a credit line from all active loans
-    #
-    # Excludes the current loan (the one being paid off) from calculation.
-    #
-    # @param credit_line [Dscf::Credit::CreditLine] The credit line to check
-    # @return [Float] Sum of remaining_amount from active loans
-    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)
+      # Unlock other eligible credit lines that were locked during disbursement
+      loan_profile.eligible_credit_lines
+        .where.not(credit_line: credit_line)
+        .where(locked: true)
+        .update_all(locked: false)
     end
 
     # Build success result hash

data/lib/dscf/credit/version.rb

@@ -1,5 +1,5 @@
 module Dscf
   module Credit
-    VERSION = "0.2.5"
+    VERSION = "0.2.7"
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dscf-credit
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.7
 platform: ruby
 authors:
 - Adoniyas
 bindir: bin
 cert_chain: []
-date: 2025-10-08 00:00:00.000000000 Z
+date: 2025-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dscf-core