dscf-credit 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 447633e68d0087ea77917d1630137c52d138096a52039af3c67c577ce3c5edd9
-  data.tar.gz: 5f4b38640b2adf043787cca20d5138b3e40185333f04bb9d747203bd14abf575
+  metadata.gz: 1e5ce384f2229c93db978e4eff5599a0d0fb9fe74e586da8bab5209a63dcb9f6
+  data.tar.gz: 889029fa9ee854b75198eed3a539215139d59914f09f8337674583ea153b3703
 SHA512:
-  metadata.gz: 02ad7c0149c073efb33bbc55e318d6cee9f6096aa29af50ef7316f3caf80ee7396c5cd3fdc7387287e88152e5af9b5854b90620b436fc6487c8c241ec8c1a98a
-  data.tar.gz: '099dd81a6c2f8f788fb38fb6c4f2d8b7f636a0853fbbed972b1078e0da5ef8e6cfe4c7b7fdec5d4bd1d5965e68f93cc8861a3122b20c1f670ebea186dba7c67b'
+  metadata.gz: b0772af1d0a922a4826de14d34c8d18f78480fe17a8c7db23d22e1e2e463ccb8e95cc7a6db8d6ff8ffb178036239316c26b8e2b8c18c2808e03f2639bae028b2
+  data.tar.gz: 27587c70165aeda76c4577ef9e109b03539f0a5188681a3108408724e84fa39a681e7ba699cc6e213c886df5344f8cd196717947b83a882f7db43e49c80909e2

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

@@ -4,12 +4,95 @@ module Dscf::Credit
     include Dscf::Core::ReviewableController
 
     def create
-      super
-      facilitator_application = @clazz.new(model_params)
-      facilitator_application.user = current_user
-      facilitator_application.reviews.build(context: "default", status: "pending")
+      super do
+        facilitator_application = @clazz.new(model_params)
 
-      facilitator_application
+        user = Dscf::Core::User.find(model_params[:user_id])
+        facilitator_application.user = user
+        facilitator_application.reviews.build(context: "default", status: "pending")
+
+        facilitator_application
+      end
+    end
+
+    def bulk_create
+      if params[:facilitator_applications].blank?
+        return render_error(
+          "facilitator_application.errors.bulk_create",
+          errors: [ "At least one facilitator application is required" ],
+          status: :unprocessable_entity
+        )
+      end
+
+      applications_params = params.require(:facilitator_applications)
+
+      unless applications_params.is_a?(Array)
+        return render_error(
+          "facilitator_application.errors.bulk_create",
+          errors: [ "Expected an array of facilitator applications" ],
+          status: :unprocessable_entity
+        )
+      end
+
+      results = {
+        successful: [],
+        failed: [],
+        total_count: applications_params.length,
+        success_count: 0,
+        failure_count: 0
+      }
+
+      applications_params.each_with_index do |app_params, index|
+        begin
+          facilitator_application = @clazz.new(app_params.permit(:user_id, :bank_id))
+
+          if app_params[:user_id].present?
+            facilitator_application.user = Dscf::Core::User.find(app_params[:user_id])
+          else
+            raise ActiveRecord::RecordInvalid.new(facilitator_application), "User ID is required"
+          end
+
+          facilitator_application.reviews.build(context: "default", status: "pending")
+
+          if facilitator_application.save
+            results[:successful] << {
+              index: index,
+              id: facilitator_application.id,
+              user_id: facilitator_application.user_id,
+              bank_id: facilitator_application.bank_id,
+              message: "Successfully created"
+            }
+            results[:success_count] += 1
+          else
+            results[:failed] << {
+              index: index,
+              user_id: app_params[:user_id],
+              errors: facilitator_application.errors.full_messages
+            }
+            results[:failure_count] += 1
+          end
+        rescue ActiveRecord::RecordNotFound => e
+          results[:failed] << {
+            index: index,
+            user_id: app_params[:user_id],
+            errors: [ "User not found: #{e.message}" ]
+          }
+          results[:failure_count] += 1
+        rescue StandardError => e
+          results[:failed] << {
+            index: index,
+            user_id: app_params[:user_id],
+            errors: [ e.message ]
+          }
+          results[:failure_count] += 1
+        end
+      end
+
+      render_success(
+        "facilitator_application.success.bulk_create",
+        data: results,
+        status: :created
+      )
     end
 
     private

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

@@ -0,0 +1,113 @@
+module Dscf::Credit
+  class LoanAccrualsController < ApplicationController
+    include Dscf::Core::Common
+
+    def generate
+      service = LoanAccrualGeneratorService.new(
+        loan_ids: params[:loan_ids],
+        accrual_date: parse_accrual_date,
+        force_regenerate: ActiveModel::Type::Boolean.new.cast(params[:force_regenerate])
+      )
+
+      result = service.generate_daily_accruals
+
+      if result[:success]
+        render_success(
+          result[:message],
+          data: result,
+          status: :created
+        )
+      else
+        render_error(
+          result[:message],
+          errors: result[:errors],
+          status: :unprocessable_entity
+        )
+      end
+    end
+
+    def statistics
+      loan = Loan.find(params[:loan_id])
+
+      stats = {
+        loan_id: loan.id,
+        principal_amount: loan.principal_amount,
+        remaining_amount: loan.remaining_amount,
+        total_facilitation_fee: loan.total_facilitation_fee,
+        total_interest: loan.total_interest,
+        total_penalty: loan.total_penalty,
+        total_vat: loan.total_vat,
+        total_outstanding: loan.total_outstanding,
+        accrual_breakdown: {
+          facilitation_fee: {
+            pending: loan.loan_accruals.where(accrual_type: 'facilitation_fee', status: 'pending').sum(:amount),
+            paid: loan.loan_accruals.where(accrual_type: 'facilitation_fee', status: 'paid').sum(:amount)
+          },
+          tax: {
+            pending: loan.loan_accruals.where(accrual_type: 'tax', status: 'pending').sum(:amount),
+            paid: loan.loan_accruals.where(accrual_type: 'tax', status: 'paid').sum(:amount)
+          },
+          interest: {
+            pending: loan.loan_accruals.where(accrual_type: 'interest', status: 'pending').sum(:amount),
+            paid: loan.loan_accruals.where(accrual_type: 'interest', status: 'paid').sum(:amount)
+          },
+          penalty: {
+            pending: loan.loan_accruals.where(accrual_type: 'penalty', status: 'pending').sum(:amount),
+            paid: loan.loan_accruals.where(accrual_type: 'penalty', status: 'paid').sum(:amount)
+          }
+        },
+        accrual_count: {
+          total: loan.loan_accruals.count,
+          pending: loan.loan_accruals.where(status: 'pending').count,
+          paid: loan.loan_accruals.where(status: 'paid').count,
+          cancelled: loan.loan_accruals.where(status: 'cancelled').count
+        }
+      }
+
+      render_success(
+        'Loan accrual statistics retrieved successfully',
+        data: stats
+      )
+    end
+
+    private
+
+    # Parse accrual_date parameter
+    #
+    # @return [Date] Parsed date or Date.current
+    def parse_accrual_date
+      return Date.current unless params[:accrual_date].present?
+
+      Date.parse(params[:accrual_date].to_s)
+    rescue ArgumentError
+      Date.current
+    end
+
+    def model_params
+      params.require(:loan_accrual).permit(
+        :loan_id,
+        :accrual_type,
+        :amount,
+        :applied_on,
+        :status
+      )
+    end
+
+    def eager_loaded_associations
+      [:loan]
+    end
+
+    def allowed_order_columns
+      %w[id accrual_type amount applied_on status created_at updated_at]
+    end
+
+    def default_serializer_includes
+      {
+        index: [:loan],
+        show: [:loan],
+        create: [:loan],
+        update: [:loan]
+      }
+    end
+  end
+end

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

@@ -62,17 +62,17 @@ module Dscf::Credit
 
     def calculate_credit_score
       loan_application = @clazz.find(params[:id])
-      category_id = score_params[:category_id]
+      scoring_param_type_id = score_params[:scoring_param_type_id]
 
-      unless category_id
+      unless scoring_param_type_id
         return render_error(
           "loan_application.errors.calculate_credit_score",
-          errors: [ "Category ID is required for credit scoring" ],
+          errors: [ "Scoring parameter type ID is required for credit scoring" ],
           status: :unprocessable_entity
         )
       end
 
-      scoring_engine = CreditScoringEngine.new(loan_application.id, category_id)
+      scoring_engine = CreditScoringEngine.new(loan_application.id, scoring_param_type_id)
       result = scoring_engine.calculate_score
 
       if result[:success]
@@ -215,7 +215,7 @@ module Dscf::Credit
     end
 
     def score_params
-      params.permit(:category_id)
+      params.permit(:scoring_param_type_id)
     end
 
     def eager_loaded_associations

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

@@ -105,7 +105,7 @@ module Dscf::Credit
 
     def eager_loaded_associations
       [
-        :loan_application, :loan_profile_scoring_specs, :loans, :eligible_credit_lines,
+        :loan_application, :loan_profile_scoring_specs, :loans, eligible_credit_lines: { credit_line: :credit_line },
         reviews: { reviewed_by: :user_profile }
       ]
     end
@@ -118,7 +118,7 @@ module Dscf::Credit
       {
         index: [ :loan_application, reviews: { reviewed_by: :user_profile } ],
         show: [
-          :loan_application, :loan_profile_scoring_specs, :loans, :eligible_credit_lines, reviews: { reviewed_by: :user_profile }
+          :loan_application, :loan_profile_scoring_specs, :loans, eligible_credit_lines: { credit_line: :credit_line }, reviews: { reviewed_by: :user_profile }
         ],
         create: [ :loan_application, :loan_profile_scoring_specs, :reviews ],
         update: [

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

@@ -10,10 +10,6 @@ module Dscf::Credit
         :credit_line_id,
         :status,
         :principal_amount,
-        :accrued_interest,
-        :accrued_penalty,
-        :facilitation_fee,
-        :total_loan_amount,
         :remaining_amount,
         :due_date,
         :disbursed_at,
@@ -22,11 +18,11 @@ module Dscf::Credit
     end
 
     def eager_loaded_associations
-      [ :loan_profile, :credit_line, :loan_transactions ]
+      [ :loan_profile, :credit_line, :loan_transactions, :loan_accruals ]
     end
 
     def allowed_order_columns
-      %w[id status principal_amount total_loan_amount remaining_amount due_date disbursed_at created_at updated_at]
+      %w[id status principal_amount remaining_amount due_date disbursed_at created_at updated_at]
     end
 
     def default_serializer_includes

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

@@ -1,10 +1,11 @@
 module Dscf::Credit
   class RepaymentsController < ApplicationController
+
     def create
       loan = Dscf::Credit::Loan.find(params[:loan_id])
       payment_amount = params[:amount].to_f
 
-      service = Dscf::Credit::RepaymentService.new(loan, payment_amount, current_user)
+      service = Dscf::Credit::RepaymentService.new(loan, payment_amount)
       result = service.process_repayment
 
       if result[:success]
@@ -18,8 +19,7 @@ module Dscf::Credit
             include: [
               :loan_profile,
               :credit_line,
-              :payment_request,
-              :loan_transactions
+              :loan_accruals
             ]
           }
         )

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

@@ -9,10 +9,10 @@ module Dscf::Credit
         scoring_parameter.created_by = current_user
         scoring_parameter.reviews.build(context: "default", status: "pending")
 
-        if validate_category_weight_limit(scoring_parameter)
+        if validate_scoring_param_type_weight_limit(scoring_parameter)
           scoring_parameter
         else
-          scoring_parameter.errors.add(:weight, "would exceed the total weight limit of 1.0 for this category")
+          scoring_parameter.errors.add(:weight, "would exceed the total weight limit of 1.0 for this scoring parameter type")
           render_error(errors: scoring_parameter.errors.full_messages, status: :unprocessable_entity)
           return
         end
@@ -20,8 +20,8 @@ module Dscf::Credit
     end
 
     def update
-      unless validate_category_weight_limit(@obj, exclude_current: true)
-        @obj.errors.add(:weight, "would exceed the total weight limit of 1.0 for this category")
+      unless validate_scoring_param_type_weight_limit(@obj, exclude_current: true)
+        @obj.errors.add(:weight, "would exceed the total weight limit of 1.0 for this scoring parameter type")
         render_error(errors: @obj.errors.full_messages, status: :unprocessable_entity)
         return
       end
@@ -62,7 +62,7 @@ module Dscf::Credit
 
     def default_serializer_includes
       {
-        index: [ :bank, :category, reviews: { reviewed_by: :user_profile } ],
+        index: [ :bank, :category, :parameter_normalizers, reviews: { reviewed_by: :user_profile } ],
         show: [
           :bank, :category, :created_by, :scoring_param_type, :previous_version, :parameter_normalizers,
           reviews: { reviewed_by: :user_profile }
@@ -75,27 +75,23 @@ module Dscf::Credit
       }
     end
 
-    def validate_category_weight_limit(scoring_parameter, exclude_current: false)
-      return true unless scoring_parameter.category_id && scoring_parameter.weight
+    def validate_scoring_param_type_weight_limit(scoring_parameter, exclude_current: false)
+      return true unless scoring_parameter.scoring_param_type_id && scoring_parameter.weight
 
-      # Get existing parameters in the same category for the same bank
       existing_params = ScoringParameter.where(
         bank_id: scoring_parameter.bank_id,
-        category_id: scoring_parameter.category_id,
+        scoring_param_type_id: scoring_parameter.scoring_param_type_id,
         active: true
       )
 
-      # Exclude current parameter from the calculation when updating
       if exclude_current && scoring_parameter.persisted?
         existing_params = existing_params.where.not(id: scoring_parameter.id)
       end
 
-      # Calculate total weight
       current_total_weight = existing_params.sum(:weight)
       new_total_weight = current_total_weight + scoring_parameter.weight.to_f
 
-      # Allow small floating point tolerance (e.g., 1.0001 should be acceptable)
-      new_total_weight <= 1.001
+      new_total_weight <= 1.00
     end
   end
 end

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

@@ -16,8 +16,14 @@ module Dscf::Credit
             )
           end
 
+          rejected_user_ids = Dscf::Credit::FacilitatorApplication.joins(:reviews)
+                                                                 .where(dscf_core_reviews: { status: 'rejected' })
+                                                                 .pluck(:user_id)
+                                                                 .uniq
+
           @clazz.joins(businesses: :business_type)
                 .where(dscf_core_business_types: { name: business_type_name })
+                .where(id: rejected_user_ids)
                 .distinct
         else
           @clazz.all

data/app/jobs/dscf/credit/generate_daily_accruals_job.rb

@@ -0,0 +1,78 @@
+module Dscf::Credit
+  # Background job to generate daily loan accruals
+  #
+  # This job should be scheduled to run daily (typically at midnight or early morning)
+  # to generate interest and penalty accruals for all active loans.
+  #
+  # @example Schedule with Sidekiq (config/sidekiq.yml)
+  #   :schedule:
+  #     generate_daily_accruals:
+  #       cron: '0 1 * * *'  # Run at 1 AM daily
+  #       class: Dscf::Credit::GenerateDailyAccrualsJob
+  #
+  # @example Schedule with whenever gem (config/schedule.rb)
+  #   every 1.day, at: '1:00 am' do
+  #     runner "Dscf::Credit::GenerateDailyAccrualsJob.perform_later"
+  #   end
+  #
+  # @example Manual execution
+  #   Dscf::Credit::GenerateDailyAccrualsJob.perform_now
+  #
+  # @example With specific parameters
+  #   Dscf::Credit::GenerateDailyAccrualsJob.perform_later(
+  #     loan_ids: [1, 2, 3],
+  #     accrual_date: Date.yesterday
+  #   )
+  class GenerateDailyAccrualsJob < ApplicationJob
+    queue_as :default
+
+    # Perform the job to generate daily accruals
+    #
+    # @param loan_ids [Array<Integer>, nil] Optional specific loan IDs to process
+    # @param accrual_date [String, Date] Date for accrual generation (defaults to today)
+    # @param force_regenerate [Boolean] Whether to regenerate existing accruals
+    def perform(loan_ids: nil, accrual_date: nil, force_regenerate: false)
+      date = accrual_date ? Date.parse(accrual_date.to_s) : Date.current
+
+      service = LoanAccrualGeneratorService.new(
+        loan_ids: loan_ids,
+        accrual_date: date,
+        force_regenerate: force_regenerate
+      )
+
+      result = service.generate_daily_accruals
+
+      log_result(result)
+
+      result
+    end
+
+    private
+
+    # Log the result of accrual generation
+    #
+    # @param result [Hash] The result from the service
+    def log_result(result)
+      if result[:success]
+        Rails.logger.info(
+          "Loan Accrual Generation: #{result[:message]}"
+        )
+
+        if result[:errors].any?
+          Rails.logger.warn(
+            "Loan Accrual Generation Warnings: #{result[:errors].size} loans had errors"
+          )
+          result[:errors].each do |error|
+            Rails.logger.warn(
+              "Loan #{error[:loan_id]}: #{error[:error]}"
+            )
+          end
+        end
+      else
+        Rails.logger.error(
+          "Loan Accrual Generation Failed: #{result[:message]}"
+        )
+      end
+    end
+  end
+end

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

@@ -7,7 +7,6 @@ module Dscf::Credit
     belongs_to :user, class_name: "Dscf::Core::User", foreign_key: "user_id"
     belongs_to :bank, class_name: "Dscf::Credit::Bank", foreign_key: "bank_id"
 
-    validates :facilitator_info, presence: true
 
     def self.ransackable_attributes(auth_object = nil)
       %w[id user_id bank_id created_at updated_at]

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

@@ -6,10 +6,11 @@ module Dscf::Credit
     belongs_to :credit_line, class_name: "Dscf::Credit::CreditLine", foreign_key: "credit_line_id"
     has_many :loan_transactions, class_name: "Dscf::Credit::LoanTransaction", foreign_key: "loan_id", dependent: :destroy
     has_many :daily_routine_transactions, class_name: "Dscf::Credit::DailyRoutineTransaction", foreign_key: "loan_id", dependent: :destroy
+    has_many :loan_accruals, class_name: "Dscf::Credit::LoanAccrual", foreign_key: "loan_id", dependent: :destroy
 
-    validates :principal_amount, :total_loan_amount, :remaining_amount, :due_date, presence: true
-    validates :principal_amount, :total_loan_amount, :remaining_amount, numericality: { greater_than: 0 }
-    validates :accrued_interest, :accrued_penalty, :facilitation_fee, numericality: { greater_than_or_equal_to: 0 }
+    validates :principal_amount, :remaining_amount, :due_date, presence: true
+    validates :principal_amount, numericality: { greater_than: 0 }
+    validates :remaining_amount, numericality: { greater_than_or_equal_to: 0 }
     validates :status, inclusion: { in: %w[pending approved disbursed active overdue paid closed] }
 
     scope :active, -> { where(active: true) }
@@ -20,14 +21,34 @@ module Dscf::Credit
     scope :past_due, -> { where("due_date < ? AND status IN (?)", Date.current, [ "active", "overdue" ]) }
 
     def self.ransackable_attributes(auth_object = nil)
-      %w[id status principal_amount accrued_interest accrued_penalty facilitation_fee total_loan_amount remaining_amount due_date disbursed_at active created_at updated_at]
+      %w[id status principal_amount remaining_amount due_date disbursed_at active created_at updated_at]
     end
 
     def self.ransackable_associations(auth_object = nil)
-      %w[loan_profile credit_line loan_transactions daily_routine_transactions]
+      %w[loan_profile credit_line loan_transactions daily_routine_transactions loan_accruals]
     end
 
     delegate :user, to: :loan_profile, allow_nil: true
     delegate :bank, to: :credit_line, allow_nil: true
+
+    def total_facilitation_fee
+      loan_accruals.where(accrual_type: 'facilitation_fee', status: 'pending').sum(:amount)
+    end
+
+    def total_interest
+      loan_accruals.where(accrual_type: 'interest', status: 'pending').sum(:amount)
+    end
+
+    def total_penalty
+      loan_accruals.where(accrual_type: 'penalty', status: 'pending').sum(:amount)
+    end
+
+    def total_vat
+      loan_accruals.where(accrual_type: 'tax', status: 'pending').sum(:amount)
+    end
+
+    def total_outstanding
+      remaining_amount + loan_accruals.where(status: 'pending').sum(:amount)
+    end
   end
 end

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

@@ -0,0 +1,25 @@
+module Dscf::Credit
+  class LoanAccrual < ApplicationRecord
+    self.table_name = "dscf_credit_loan_accruals"
+
+    belongs_to :loan, class_name: "Dscf::Credit::Loan", foreign_key: "loan_id"
+
+    validates :accrual_type, :amount, :applied_on, presence: true
+    validates :amount, numericality: { greater_than: 0 }
+    validates :accrual_type, inclusion: { in: %w[interest penalty tax facilitation_fee late_fee other] }
+    validates :status, inclusion: { in: %w[pending paid cancelled] }
+
+    scope :pending, -> { where(status: "pending") }
+    scope :paid, -> { where(status: "paid") }
+    scope :by_type, ->(type) { where(accrual_type: type) }
+    scope :for_date_range, ->(start_date, end_date) { where(applied_on: start_date..end_date) }
+
+    def self.ransackable_attributes(auth_object = nil)
+      %w[id accrual_type amount applied_on status created_at updated_at]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[loan]
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Dscf::Credit
+  class LoanAccrualSerializer < ActiveModel::Serializer
+    attributes :id, :accrual_type, :amount, :applied_on, :status, :created_at, :updated_at
+
+    belongs_to :loan, serializer: LoanSerializer
+  end
+end

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

@@ -1,11 +1,33 @@
 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, :active, :created_at, :updated_at
+    attributes :id, :status, :principal_amount, :remaining_amount, :due_date, :disbursed_at, :total_interest, :total_penalty,
+               :total_vat, :total_facilitation_fee, :total_outstanding, :active, :created_at, :updated_at
 
     belongs_to :loan_profile, serializer: LoanProfileSerializer
     belongs_to :credit_line, serializer: CreditLineSerializer
     has_many :loan_transactions, serializer: LoanTransactionSerializer
     has_many :daily_routine_transactions, serializer: DailyRoutineTransactionSerializer
+    has_many :loan_accruals, serializer: LoanAccrualSerializer
+
+    def total_interest
+      object.total_interest
+    end
+
+    def total_penalty
+      object.total_penalty
+    end
+
+    def total_vat
+      object.total_vat
+    end
+
+    def total_facilitation_fee
+      object.total_facilitation_fee
+    end
+
+    def total_outstanding
+      object.total_outstanding
+    end
+
   end
 end

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

@@ -1,22 +1,22 @@
 module Dscf::Credit
   class CreditScoringEngine
-    attr_reader :loan_application, :category_id, :errors
+    attr_reader :loan_application, :scoring_param_type_id, :errors
 
-    def initialize(loan_application_id, category_id)
+    def initialize(loan_application_id, scoring_param_type_id)
       @loan_application = find_loan_application(loan_application_id)
-      @category_id = category_id
+      @scoring_param_type_id = scoring_param_type_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
+      return error_result("Scoring parameter type ID is required") unless scoring_param_type_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}")
+          return error_result("No active scoring parameters found for this bank for scoring parameter type ID #{scoring_param_type_id}")
         end
 
         # Calculate weighted score using the formula
@@ -45,7 +45,7 @@ module Dscf::Credit
       loan_application.bank
                      .scoring_parameters
                      .active
-                     .where(category_id: category_id)
+                     .where(scoring_param_type_id: scoring_param_type_id)
                      .includes(:scoring_param_type, :parameter_normalizers, :category)
     end
 
@@ -217,7 +217,7 @@ module Dscf::Credit
         success: true,
         loan_application_id: loan_application.id,
         bank_id: loan_application.bank_id,
-        category_id: category_id,
+        scoring_param_type_id: scoring_param_type_id,
         calculated_at: Time.current,
         score: final_score,
         status: review_status,
@@ -235,7 +235,7 @@ module Dscf::Credit
       {
         success: false,
         loan_application_id: loan_application&.id,
-        category_id: category_id,
+        scoring_param_type_id: scoring_param_type_id,
         error: message,
         errors: @errors,
         score: 0.0,