dscf-credit 0.2.4 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0883e69edbfba633fb3b886139de199303da27bfaa0ed9402c39d7ed036fb778'
-  data.tar.gz: e1ea1f2d623086de0e807c1e986cb340b41d10501056960a1f4c7f8b03b84192
+  metadata.gz: 5df5b3471a83e6efbe5e76b6fe3849eddaaae14bf80d833fff1d9cd6acc2b75f
+  data.tar.gz: 96f5816a3eece048974871298895351bb925f1ba75043819759a3b3ddbadad8b
 SHA512:
-  metadata.gz: f624bce3e341b942f97bc54201f94f995db7dc8a507083c8061d6fdfc58e982f0f2c2f13b573c881b37ffc5e1170184db026c9ae247473a05aef86620620117f
-  data.tar.gz: ba02250152266b20ecca88cf929b2379b3931fd7d1f0dd9561d632e1928a6c15c7b83deaac2ffa8930601f8bd6de9969b7578a140a08d43aeb272070a95f5138
+  metadata.gz: 595f5b367c1fef07dc381b5c0e7932a4a7c65cfd1c8b282b9b0ac6bd25ed05da5b76ad7d037f6f0858a3afd86b7a6da89e4285c4089b4f8be0aab9ec0b9f2bff
+  data.tar.gz: fd794ca8544b99ff9277dd5580ea9d36415308f606dca66db785a9b7970500ff52b825c06743c318b05272e9daae2fb70c578f859b5c3b706efc5e9686ddd2bc

data/app/controllers/dscf/credit/categories_controller.rb

@@ -6,7 +6,7 @@ module Dscf::Credit
 
     def model_params
       params.require(:category).permit(
-        :type,
+        :category_type,
         :name,
         :description,
         :document_reference

data/app/controllers/dscf/credit/eligible_credit_lines_controller.rb

@@ -68,7 +68,8 @@ module Dscf::Credit
         :credit_line_id,
         :credit_limit,
         :available_limit,
-        :risk
+        :risk,
+        :locked
       )
     end
 
@@ -77,7 +78,7 @@ module Dscf::Credit
     end
 
     def allowed_order_columns
-      %w[id credit_limit available_limit risk created_at updated_at loan_profile_id credit_line_id]
+      %w[id credit_limit available_limit risk locked created_at updated_at loan_profile_id credit_line_id]
     end
 
     def default_serializer_includes

data/app/controllers/dscf/credit/loan_applications_controller.rb

@@ -197,7 +197,7 @@ module Dscf::Credit
         {
           message: "Automatically rejected based on credit score: #{score}% (<50%)"
         }
-      when "pending_review"
+      when "pending"
         {
           message: "Manual review required based on credit score: #{score}% (50%-60%)"
         }

data/app/models/dscf/credit/category.rb

@@ -1,18 +1,17 @@
 module Dscf::Credit
   class Category < ApplicationRecord
     self.table_name = "dscf_credit_categories"
-    self.inheritance_column = nil  # Disable STI since 'type' is a business attribute
 
     has_many :credit_lines, class_name: "Dscf::Credit::CreditLine", foreign_key: "category_id", dependent: :nullify
     has_many :scoring_parameters, class_name: "Dscf::Credit::ScoringParameter", foreign_key: "category_id", dependent: :nullify
 
-    validates :type, :name, presence: true
-    validates :name, uniqueness: { scope: :type }
+    validates :category_type, :name, presence: true
+    validates :name, uniqueness: { scope: :category_type }
 
-    scope :by_type, ->(category_type) { where(type: category_type) }
+    scope :by_type, ->(category_type) { where(category_type: category_type) }
 
     def self.ransackable_attributes(auth_object = nil)
-      %w[id type name description document_reference created_at updated_at]
+      %w[id category_type name description document_reference created_at updated_at]
     end
 
     def self.ransackable_associations(auth_object = nil)

data/app/models/dscf/credit/eligible_credit_line.rb

@@ -16,9 +16,11 @@ module Dscf::Credit
     scope :by_risk_range, ->(min, max) { where(risk: min..max) }
     scope :by_credit_limit_range, ->(min, max) { where(credit_limit: min..max) }
     scope :by_available_limit_range, ->(min, max) { where(available_limit: min..max) }
+    scope :locked, -> { where(locked: true) }
+    scope :unlocked, -> { where(locked: false) }
 
     def self.ransackable_attributes(auth_object = nil)
-      %w[id credit_limit available_limit risk created_at updated_at]
+      %w[id credit_limit available_limit risk locked created_at updated_at]
     end
 
     def self.ransackable_associations(auth_object = nil)

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

@@ -1,6 +1,6 @@
 module Dscf::Credit
   class CategorySerializer < ActiveModel::Serializer
-    attributes :id, :type, :name, :description, :document_reference, :created_at, :updated_at
+    attributes :id, :category_type, :name, :description, :document_reference, :created_at, :updated_at
 
     has_many :credit_lines, serializer: Dscf::Credit::CreditLineSerializer
     has_many :scoring_parameters, serializer: Dscf::Credit::ScoringParameterSerializer

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

@@ -1,6 +1,6 @@
 module Dscf::Credit
   class EligibleCreditLineSerializer < ActiveModel::Serializer
-    attributes :id, :credit_limit, :available_limit, :risk, :created_at, :updated_at
+    attributes :id, :credit_limit, :available_limit, :risk, :locked, :created_at, :updated_at
 
     belongs_to :loan_profile, serializer: Dscf::Credit::LoanProfileSerializer
     belongs_to :credit_line, serializer: Dscf::Credit::CreditLineSerializer

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

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/db/migrate/20250822091011_create_dscf_credit_categories.rb

@@ -1,7 +1,7 @@
 class CreateDscfCreditCategories < ActiveRecord::Migration[8.0]
   def change
     create_table :dscf_credit_categories do |t|
-      t.string :type, null: false
+      t.string :category_type, null: false
       t.string :name, null: false
       t.text :description
       t.string :document_reference
@@ -9,9 +9,9 @@ class CreateDscfCreditCategories < ActiveRecord::Migration[8.0]
       t.timestamps
     end
 
-    add_index :dscf_credit_categories, :type
+    add_index :dscf_credit_categories, :category_type
     add_index :dscf_credit_categories, :name
     add_index :dscf_credit_categories, :document_reference
-    add_index :dscf_credit_categories, [ :type, :name ], unique: true
+    add_index :dscf_credit_categories, [ :category_type, :name ], unique: true
   end
 end

data/db/migrate/20250917120000_create_dscf_credit_eligible_credit_lines.rb

@@ -6,6 +6,7 @@ class CreateDscfCreditEligibleCreditLines < ActiveRecord::Migration[8.0]
       t.decimal :credit_limit, precision: 15, scale: 2, null: false
       t.decimal :available_limit, precision: 15, scale: 2, null: false
       t.decimal :risk, precision: 5, scale: 4, null: true
+      t.boolean :locked, default: false, null: false
 
       t.timestamps
     end

data/db/seeds.rb

@@ -340,24 +340,24 @@ end
 
 # 4.5. Categories (independent)
 puts "Seeding categories..."
-sme_category = Dscf::Credit::Category.find_or_create_by(type: 'credit_line', name: 'SME') do |category|
+sme_category = Dscf::Credit::Category.find_or_create_by(category_type: 'credit_line', name: 'SME') do |category|
   category.description = 'Small and Medium Enterprise credit category'
 end
 
-personal_category = Dscf::Credit::Category.find_or_create_by(type: 'credit_line', name: 'Personal') do |category|
+personal_category = Dscf::Credit::Category.find_or_create_by(category_type: 'credit_line', name: 'Personal') do |category|
   category.description = 'Personal credit category for individuals'
 end
 
-agricultural_category = Dscf::Credit::Category.find_or_create_by(type: 'credit_line', name: 'Agricultural') do |category|
+agricultural_category = Dscf::Credit::Category.find_or_create_by(category_type: 'credit_line', name: 'Agricultural') do |category|
   category.description = 'Agricultural sector credit category'
 end
 
-corporate_category = Dscf::Credit::Category.find_or_create_by(type: 'credit_line', name: 'Corporate') do |category|
+corporate_category = Dscf::Credit::Category.find_or_create_by(category_type: 'credit_line', name: 'Corporate') do |category|
   category.description = 'Corporate credit category for large businesses'
 end
 
 # Add eligibility category for scoring
-eligibility_category = Dscf::Credit::Category.find_or_create_by(type: 'eligibility', name: 'default') do |category|
+eligibility_category = Dscf::Credit::Category.find_or_create_by(category_type: 'eligibility', name: 'default') do |category|
   category.description = 'Default eligibility category for credit scoring'
 end
 

data/lib/dscf/credit/version.rb

@@ -1,5 +1,5 @@
 module Dscf
   module Credit
-    VERSION = "0.2.4"
+    VERSION = "0.2.6"
   end
 end

data/spec/factories/dscf/credit/categories.rb

@@ -1,27 +1,27 @@
 FactoryBot.define do
   factory :category, class: "Dscf::Credit::Category" do
-    type { %w[scoring loan_profile payment risk_assessment].sample }
-    sequence(:name) { |n| "#{type.humanize} Category #{n}" }
+    category_type { %w[scoring loan_profile payment risk_assessment].sample }
+    sequence(:name) { |n| "#{category_type.humanize} Category #{n}" }
     description { Faker::Lorem.paragraph }
     document_reference { Faker::Alphanumeric.alphanumeric(number: 10).upcase }
 
     trait :scoring do
-      type { "scoring" }
+      category_type { "scoring" }
       name { "Scoring Category" }
     end
 
     trait :loan_profile do
-      type { "loan_profile" }
+      category_type { "loan_profile" }
       name { "Loan Profile Category" }
     end
 
     trait :payment do
-      type { "payment" }
+      category_type { "payment" }
       name { "Payment Category" }
     end
 
     trait :risk_assessment do
-      type { "risk_assessment" }
+      category_type { "risk_assessment" }
       name { "Risk Assessment Category" }
     end
   end

metadata

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