dscf-credit 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0be229f7298a4e4f905fec15eae5ede2fcd755f6f56510f73f12b32e6d5b3453
-  data.tar.gz: 7de36c9ecca064d851e13b7ceb8ed7aea01cc7c6d8794fef6e203d5af63400a8
+  metadata.gz: 6588b8a4895fec7dc6cbbbaafb11bbfd06a2ccf1342c8edf6f0467b8e322ff89
+  data.tar.gz: 598e9e952de5f1c510fd95efa3a7b6686f34f29b1dd3c5cee5f24e2857e1b340
 SHA512:
-  metadata.gz: eb8742b82a81552545e811623eb176fca2a12f06fbf301aa90d060a64293ef2f77c5ad5f3e7db59a77b08e0659e81f0ee84956e0ba0d7b012cbc1cf1873de5cf
-  data.tar.gz: e8350b9ce353bf7c88992e00ca287fe7791be962449b10feefb4afbcc8b4af89157b5677957f2ec2cbccc64398fb4b58d40cf54a0896561ab58a33316ab87d54
+  metadata.gz: 9468e717d617bab5fedad24fc41429d3cae8d9eb3c66c94515ce94ce0d01a9ade439d7412fe33a9c9f6c10f19c48733b7deefda7eafa66bf17bb9969a51d6410
+  data.tar.gz: '0316249a1df4a801ab43c25dda370650516877651a5a2dd818223f24d828f7dbd9eb648ce9b77786e3326eb44cd0209c67bf945045fecb1684bdbe843cc76e31'

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

@@ -1,33 +1,37 @@
-module Dscf::Credit
-  class CategoriesController < ApplicationController
-    include Dscf::Core::Common
+module Dscf
+  module Credit
+    class CategoriesController < ApplicationController
+      include Dscf::Core::Common
 
-    private
+      private
 
-    def model_params
-      params.require(:category).permit(
-        :category_type,
-        :name,
-        :description,
-        :document_reference
-      )
-    end
+      def model_params
+        params.require(:category).permit(
+          :bank_id,
+          :category_type,
+          :name,
+          :description,
+          :document_reference,
+          :scoring_table_id
+        )
+      end
 
-    def eager_loaded_associations
-      [ :credit_lines, :scoring_parameters ]
-    end
+      def eager_loaded_associations
+        [ :bank, :scoring_table, :credit_lines, :scoring_parameters ]
+      end
 
-    def allowed_order_columns
-      %w[id type name description document_reference created_at updated_at]
-    end
+      def allowed_order_columns
+        %w[id category_type name description document_reference created_at updated_at]
+      end
 
-    def default_serializer_includes
-      {
-        index: [],
-        show: [ :credit_lines, :scoring_parameters ],
-        create: [],
-        update: [ :credit_lines, :scoring_parameters ]
-      }
+      def default_serializer_includes
+        {
+          index: [],
+          show: [ :bank, :scoring_table, :credit_lines, :scoring_parameters ],
+          create: [ :bank, :scoring_table ],
+          update: [ :bank, :scoring_table, :credit_lines, :scoring_parameters ]
+        }
+      end
     end
   end
 end

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

@@ -4,10 +4,11 @@ module Dscf::Credit
       loan_profile = Dscf::Credit::LoanProfile.find(params[:loan_profile_id])
       category = Dscf::Credit::Category.find(params[:category_id])
 
-      service = Dscf::Credit::CreditLimitCalculationService.new(loan_profile, category)
-      result = service.calculate_credit_limits
+      engine = Dscf::Credit::FacilityLimitCalculationEngine.new(loan_profile.id, category.id)
+      result = engine.calculate_facility_limits
 
       if result[:success]
+        loan_profile.reload
         render_success(
           "credit_limit_calculation.success.create",
           data: {
@@ -15,7 +16,7 @@ module Dscf::Credit
             category: category,
             eligible_credit_lines: result[:data],
             calculation_summary: {
-              total_credit_lines_processed: result[:count],
+              total_credit_lines_processed: result[:data]&.size || 0,
               calculated_at: Time.current
             }
           },

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

@@ -49,6 +49,7 @@ module Dscf::Credit
         :max_interest_calculation_days,
         :penalty_frequency,
         :penalty_income_tax,
+        :minimum_score,
         :active,
         :base_scoring_parameter_id,
         :credit_line_divider
@@ -60,7 +61,7 @@ module Dscf::Credit
     end
 
     def allowed_order_columns
-      %w[id min_amount max_amount interest_rate penalty_rate facilitation_fee_rate tax_rate credit_line_multiplier max_penalty_days loan_duration interest_frequency interest_income_tax vat max_interest_calculation_days penalty_frequency penalty_income_tax active created_at updated_at]
+      %w[id min_amount max_amount interest_rate penalty_rate facilitation_fee_rate tax_rate credit_line_multiplier max_penalty_days loan_duration interest_frequency interest_income_tax vat max_interest_calculation_days penalty_frequency penalty_income_tax minimum_score active created_at updated_at]
     end
 
     def default_serializer_includes

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

@@ -0,0 +1,93 @@
+module Dscf::Credit
+  class InformationSourcesController < ApplicationController
+    include Dscf::Core::Common
+    include Dscf::Core::ReviewableController
+    include Dscf::Core::AuditableController
+
+    before_action :set_object, only: %i[ show update activate deactivate ]
+
+    auditable associated: [ :reviews ],
+              on: %i[approve submit reject request_modification resubmit]
+
+    auditable only: [ :active ],
+              on: %i[activate deactivate]
+
+    auditable on: %i[create],
+              associated: { reviews: { only: [ :status ] } }
+
+    def create
+      super do
+        information_source = @clazz.new(model_params)
+        information_source.created_by = current_user
+        information_source.reviews.build(context: "default", status: "draft")
+        information_source
+      end
+    end
+
+    def update
+      unless @obj.editable?
+        return render_error(
+          errors: [ "Cannot update information source after submission. Use modification request workflow instead." ],
+          status: :unprocessable_entity
+        )
+      end
+      super
+    end
+
+    def activate
+      if @obj.update(active: true)
+        render_success(data: @obj)
+      else
+        render_error(errors: @obj.errors.full_messages, status: :unprocessable_entity)
+      end
+    end
+
+    def deactivate
+      if @obj.update(active: false)
+        render_success(data: @obj)
+      else
+        render_error(errors: @obj.errors.full_messages, status: :unprocessable_entity)
+      end
+    end
+
+    private
+
+    def model_params
+      params.require(:information_source).permit(
+        :bank_id,
+        :code,
+        :name,
+        :description,
+        :active
+      )
+    end
+
+    def eager_loaded_associations
+      [
+        :bank, :created_by,
+        reviews: { reviewed_by: :user_profile },
+        audit_logs: :actor
+      ]
+    end
+
+    def allowed_order_columns
+      %w[id code name active created_at updated_at]
+    end
+
+    def default_serializer_includes
+      {
+        index: [ :bank, reviews: { reviewed_by: :user_profile } ],
+        show: [
+          :bank, :created_by,
+          reviews: { reviewed_by: :user_profile },
+          audit_logs: :actor
+        ],
+        create: [ :bank, :created_by, :reviews ],
+        update: [
+          :bank, :created_by,
+          reviews: { reviewed_by: :user_profile }
+        ]
+      }
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Dscf::Credit
+  class LoanApplicationDataController < ApplicationController
+    include Dscf::Core::Common
+
+    private
+
+    def model_params
+      params.require(:loan_application_datum).permit(
+        :loan_application_id,
+        :information_source_id,
+        :submitted_by_type,
+        :submitted_by_id,
+        :submitted_at,
+        data: {}
+      )
+    end
+
+    def eager_loaded_associations
+      [ :loan_application, :information_source, :submitted_by ]
+    end
+
+    def allowed_order_columns
+      %w[id loan_application_id information_source_id submitted_at created_at updated_at]
+    end
+
+    def default_serializer_includes
+      {
+        index: [ :loan_application, :information_source, :submitted_by ],
+        show: [ :loan_application, :information_source, :submitted_by ],
+        create: [ :loan_application, :information_source, :submitted_by ],
+        update: [ :loan_application, :information_source, :submitted_by ]
+      }
+    end
+  end
+end

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

@@ -23,7 +23,26 @@ module Dscf::Credit
         after: ->(review) {
           loan_application = review.reviewable
           score = loan_application.score
-          LoanApplicationsController.new.create_loan_profile_for_approved_application(loan_application, score)
+          return unless score
+
+          # Build scoring input snapshot from loan application data
+          input_snapshot = {}
+          loan_application.loan_application_data.includes(:information_source).each do |datum|
+            input_snapshot[datum.information_source.code] = datum.data
+          end
+
+          scoring_result_data = {
+            scoring_table_id: loan_application.category&.scoring_table&.id,
+            scoring_input_data: input_snapshot,
+            breakdown: {}  # Breakdown unavailable for manually-approved pending applications
+          }
+
+          service = LoanProfileCreationService.new(loan_application, score, scoring_result_data)
+          result = service.create_loan_profile
+
+          unless result[:success]
+            raise StandardError, "Failed to create loan profile: #{result[:error]}"
+          end
         }
       },
       reject: { status: "rejected", require_feedback: true },
@@ -51,90 +70,123 @@ module Dscf::Credit
       super
     end
 
-    def update_bank_info
-      loan_application = @clazz.find(params[:id])
-      if loan_application.update(bank_info: bank_info_params)
-        render_success("loan_application.success.update_bank_info", data: loan_application, serializer_options: { include: [ :bank, :user ] })
-      else
-        render_error("loan_application.errors.update_bank_info", errors: loan_application.errors.full_messages[0], status: :unprocessable_entity)
-      end
-    rescue => e
-      if Rails.env.development? || Rails.env.test?
-        render_error(errors: e.message, status: :unprocessable_entity)
-      else
-        render_error(status: :unprocessable_entity)
-      end
-      Rails.logger.error("Unexpected error: #{e.class} - #{e.message}")
-    end
+    def submit_source_data
+      set_object
+      source_code = params[:source_code]
+      information_source = Dscf::Credit::InformationSource.find_by(code: source_code)
 
-    def update_facilitator_info
-      loan_application = @clazz.find(params[:id])
-      if loan_application.update(facilitator_info: facilitator_info_params)
-        render_success("loan_application.success.update_facilitator_info", data: loan_application, serializer_options: { include: [ :bank, :user ] })
-      else
-        render_error("loan_application.errors.update_facilitator_info", errors: loan_application.errors.full_messages[0], status: :unprocessable_entity)
+      unless information_source
+        return render_error(errors: [ "Information source '#{source_code}' not found" ], status: :not_found)
       end
-    rescue => e
-      if Rails.env.development? || Rails.env.test?
-        render_error(errors: e.message, status: :unprocessable_entity)
+
+      datum = @obj.loan_application_data.find_or_initialize_by(information_source: information_source)
+      datum.data = params.dig(:loan_application_datum, :data) || params[:data] || {}
+      datum.submitted_by = current_user
+      datum.submitted_at = Time.current
+
+      if datum.save
+        render_success(data: datum)
       else
-        render_error(status: :unprocessable_entity)
+        render_error(errors: datum.errors.full_messages, status: :unprocessable_entity)
       end
-      Rails.logger.error("Unexpected error: #{e.class} - #{e.message}")
     end
 
-    def update_field_assessment
-      loan_application = @clazz.find(params[:id])
-      if loan_application.update(field_assessment: field_assessment_params)
-        render_success("loan_application.success.update_field_assessment", data: loan_application, serializer_options: { include: [ :bank, :user ] })
-      else
-        render_error("loan_application.errors.update_field_assessment", errors: loan_application.errors.full_messages[0], status: :unprocessable_entity)
+    def scoring_form
+      set_object
+      source_code = params[:source_code]
+      information_source = Dscf::Credit::InformationSource.find_by(code: source_code)
+
+      unless information_source
+        return render_error(errors: [ "Information source '#{source_code}' not found" ], status: :not_found)
       end
-    rescue => e
-      if Rails.env.development? || Rails.env.test?
-        render_error(errors: e.message, status: :unprocessable_entity)
-      else
-        render_error(status: :unprocessable_entity)
+
+      category = @obj.category
+      scoring_table = category&.scoring_table
+
+      unless scoring_table
+        return render_error(errors: [ "No scoring table configured for this loan application's category" ], status: :unprocessable_entity)
       end
+
+      # Load parameters for this source with normalizers
+      parameters = scoring_table.scoring_table_parameters
+        .where(information_source: information_source)
+        .includes(:scoring_parameter, :scoring_table_normalizers)
+        .order(:order)
+
+      # Load existing submitted data for this source
+      existing_datum = @obj.loan_application_data.find_by(information_source: information_source)
+      existing_data = existing_datum&.data || {}
+
+      # Build response
+      form_data = {
+        source: {
+          code: information_source.code,
+          name: information_source.name
+        },
+        scoring_table: {
+          id: scoring_table.id,
+          name: scoring_table.name,
+          code: scoring_table.code
+        },
+        submitted: existing_datum&.submitted_at.present? || false,
+        submitted_at: existing_datum&.submitted_at,
+        fields: parameters.map do |stp|
+          param = stp.scoring_parameter
+          {
+            parameter_id: param.id,
+            code: param.code,
+            name: param.name,
+            data_type: param.data_type,
+            required: stp.required,
+            min_value: stp.min_value,
+            max_value: stp.max_value,
+            current_value: existing_data[param.id.to_s],
+            options: extract_options(stp, param.data_type)
+          }
+        end
+      }
+
+      render_success(data: form_data)
     end
 
     def calculate_credit_score
       loan_application = @clazz.find(params[:id])
-      scoring_param_type_id = score_params[:scoring_param_type_id]
 
-      unless scoring_param_type_id
-        return render_error(
-          "loan_application.errors.calculate_credit_score",
-          errors: [ "Scoring parameter type ID is required for credit scoring" ],
-          status: :unprocessable_entity
-        )
-      end
-
-      scoring_engine = CreditScoringEngine.new(loan_application.id, scoring_param_type_id)
-      result = scoring_engine.calculate_score
+      result = CreditScoringEngine.new(loan_application).calculate_score
 
       if result[:success]
+        scoring_result_data = {
+          scoring_table_id: loan_application.category&.scoring_table&.id,
+          breakdown: result[:breakdown],
+          scoring_input_data: build_scoring_input_snapshot(loan_application)
+        }
+
         ActiveRecord::Base.transaction do
           loan_application.update!(score: result[:score])
 
           update_review_status(loan_application, result[:status])
 
           if result[:status] == "approved"
-            create_loan_profile_for_approved_application(loan_application, result[:score])
+            create_loan_profile_for_approved_application(loan_application, result[:score], scoring_result_data)
           end
 
           loan_application.reload
         end
 
+        eligibility = build_eligibility_response(loan_application)
+
         render_success(
           "loan_application.success.calculate_credit_score",
-          data: result.merge(loan_application: loan_application),
+          data: result.merge(
+            loan_application: loan_application,
+            eligibility: eligibility
+          ),
           status: :ok
         )
       else
         render_error(
           "loan_application.errors.calculate_credit_score",
-          errors: result[:errors] || [ result[:error] ],
+          errors: result[:errors],
           status: :unprocessable_entity
         )
       end
@@ -148,29 +200,20 @@ module Dscf::Credit
       Rails.logger.error("Credit scoring error: #{e.class} - #{e.message}")
       Rails.logger.error(e.backtrace.join("\n"))
 
-      if Rails.env.development? || Rails.env.test?
-        render_error(
-          "loan_application.errors.calculate_credit_score",
-          errors: [ e.message ],
-          status: :unprocessable_entity
-        )
-      else
-        render_error(
-          "loan_application.errors.calculate_credit_score",
-          errors: [ "An error occurred while calculating credit score" ],
-          status: :unprocessable_entity
-        )
-      end
+      render_error(
+        "loan_application.errors.calculate_credit_score",
+        errors: [ "An error occurred while calculating credit score" ],
+        status: :unprocessable_entity
+      )
     end
 
-    def create_loan_profile_for_approved_application(loan_application, score)
-      profile_service = LoanProfileCreationService.new(loan_application, score)
+    def create_loan_profile_for_approved_application(loan_application, score, scoring_result_data = {})
+      profile_service = LoanProfileCreationService.new(loan_application, score, scoring_result_data)
       profile_result = profile_service.create_loan_profile
 
       unless profile_result[:success]
         error_message = "Failed to create loan profile for approved application #{loan_application.id}: #{profile_result[:error]}"
         Rails.logger.error error_message
-        # Raise error to rollback the entire transaction including score and review status
         raise StandardError, error_message
       else
         Rails.logger.info "Loan profile created successfully for approved application #{loan_application.id}"
@@ -191,7 +234,7 @@ module Dscf::Credit
           status: status,
           reviewed_by: current_user,
           reviewed_at: Time.current,
-          feedback: build_review_feedback(status, loan_application.score)
+          feedback: build_review_feedback(status, loan_application.score, loan_application)
         )
       else
         loan_application.reviews.create!(
@@ -199,89 +242,103 @@ module Dscf::Credit
           status: status,
           reviewed_by: current_user,
           reviewed_at: Time.current,
-          feedback: build_review_feedback(status, loan_application.score)
+          feedback: build_review_feedback(status, loan_application.score, loan_application)
         )
       end
     end
 
     # Build feedback message based on status and score
-    def build_review_feedback(status, score)
+    def build_review_feedback(status, score, loan_application = nil)
+      scoring_table = loan_application&.category&.scoring_table || @obj&.category&.scoring_table
+      passing = scoring_table&.passing_score || 60.0
+      pending_thresh = scoring_table&.pending_threshold || 50.0
+
       case status
       when "approved"
-        {
-          message: "Automatically approved based on credit score: #{score}% (>60%)"
-        }
+        { message: "Automatically approved based on credit score: #{score}% (>=#{passing}%)" }
       when "rejected"
-        {
-          message: "Automatically rejected based on credit score: #{score}% (<50%)"
-        }
+        { message: "Automatically rejected based on credit score: #{score}% (<#{pending_thresh}%)" }
       when "pending"
-        {
-          message: "Manual review required based on credit score: #{score}% (50%-60%)"
-        }
+        { message: "Manual review required based on credit score: #{score}% (#{pending_thresh}%-#{passing}%)" }
       else
-        {
-          message: "Status determined by credit scoring system"
-        }
+        { message: "Status determined by credit scoring system" }
       end
     end
 
-    # Create loan profile for approved applications
-    def create_loan_profile_from_review(review)
-      loan_application = review.reviewable # Assumes Review belongs_to :reviewable (polymorphic or direct association to LoanApplication)
-      score = loan_application.score # Assumes score is already set on the loan application
-
-      unless score
-        Rails.logger.warn "No score available for loan application #{loan_application.id} during approve callback"
-        return
+    def build_scoring_input_snapshot(loan_application)
+      snapshot = {}
+      loan_application.loan_application_data.includes(:information_source).each do |datum|
+        source_code = datum.information_source.code
+        snapshot[source_code] = datum.data
       end
+      snapshot
+    end
 
-      profile_service = LoanProfileCreationService.new(loan_application, score)
-      profile_result = profile_service.create_loan_profile
+    def build_eligibility_response(loan_application)
+      category = loan_application.category
+      return [] unless category
+
+      score = loan_application.score.to_f
+      loan_profile = loan_application.loan_profile
+
+      category.credit_lines.includes(credit_line_specs: :base_scoring_parameter).map do |credit_line|
+        spec = credit_line.credit_line_specs.active.order(created_at: :desc).first
+        next unless spec
+
+        # If a loan profile exists, check the actual EligibleCreditLine record
+        if loan_profile
+          ecl = loan_profile.eligible_credit_lines.find_by(credit_line: credit_line)
+          eligible = ecl.present?
+          credit_limit = ecl&.credit_limit
+          reason = eligible ? nil : "Score #{score} below minimum #{spec.minimum_score}"
+        else
+          # No loan profile yet (pending/rejected) — evaluate purely on score vs minimum_score
+          eligible = false
+          credit_limit = nil
+          reason = if score < spec.minimum_score.to_f
+                     "Score #{score} below minimum #{spec.minimum_score}"
+          else
+                     "Not yet evaluated (application not approved)"
+          end
+        end
 
-      unless profile_result[:success]
-        error_message = "Failed to create loan profile for approved application #{loan_application.id}: #{profile_result[:error]}"
-        Rails.logger.error error_message
-        raise StandardError, error_message # This will rollback the transaction in perform_review_action
-      else
-        Rails.logger.info "Loan profile created successfully for approved application #{loan_application.id} via review callback"
-      end
+        {
+          credit_line_id: credit_line.id,
+          credit_line_name: credit_line.name,
+          eligible: eligible,
+          credit_limit: credit_limit,
+          minimum_score: spec.minimum_score,
+          reason: reason
+        }
+      end.compact
+    end
+
+    def extract_options(scoring_table_parameter, data_type)
+      return nil unless %w[string boolean].include?(data_type)
+
+      text_normalizers = scoring_table_parameter.scoring_table_normalizers
+        .where.not(text_value: nil)
+        .pluck(:text_value)
+
+      text_normalizers.presence
     end
 
     def model_params
       params.require(:loan_application).permit(
         :bank_id,
+        :category_id,
         :backer_type,
         :backer_id,
         :review_branch_id,
         :bank_statement_source,
-        user_info: {},
-        facilitator_info: {},
-        bank_info: {},
-        field_assessment: {},
         bank_statement_attachments: []
       )
     end
 
-    def bank_info_params
-      params.require(:loan_application).require(:bank_info)
-    end
-
-    def facilitator_info_params
-      params.require(:loan_application).require(:facilitator_info)
-    end
-
-    def field_assessment_params
-      params.require(:loan_application).require(:field_assessment)
-    end
-
-    def score_params
-      params.permit(:scoring_param_type_id)
-    end
-
     def eager_loaded_associations
       [
-        :bank, :user, :backer, :review_branch, :loan_profile,
+        :bank, :user, :backer, :review_branch, :loan_profile, :category,
+        loan_application_data: [ :information_source ],
         reviews: { reviewed_by: :user_profile },
         audit_logs: :actor
       ]
@@ -294,19 +351,23 @@ module Dscf::Credit
     def default_serializer_includes
       {
         index: [
-          :bank, :user, :backer, :review_branch, :loan_profile,
+          :bank, :user, :backer, :review_branch, :loan_profile, :category,
+          loan_application_data: [ :information_source ],
           reviews: { reviewed_by: :user_profile }
         ],
         show: [
-          :bank, :user, :backer, :review_branch, :loan_profile,
+          :bank, :user, :backer, :review_branch, :loan_profile, :category,
+          loan_application_data: [ :information_source ],
           reviews: { reviewed_by: :user_profile },
           audit_logs: :actor
         ],
         create: [
-          :bank, :user, :backer, :review_branch, :loan_profile, :reviews
+          :bank, :user, :backer, :review_branch, :loan_profile, :category, :reviews,
+          { loan_application_data: [ :information_source ] }
         ],
         update: [
-          :bank, :user, :backer, :review_branch, :loan_profile,
+          :bank, :user, :backer, :review_branch, :loan_profile, :category,
+          loan_application_data: [ :information_source ],
           reviews: { reviewed_by: :user_profile }
         ]
       }