dscf-credit 0.1.4 → 0.1.5

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

@@ -0,0 +1,252 @@
+module Dscf::Credit
+  class LoanApplicationsController < ApplicationController
+    include Dscf::Core::Common
+    include Dscf::Core::ReviewableController
+
+    def create
+      super do
+        loan_application = @clazz.new(model_params)
+        loan_application.user = current_user
+        loan_application.reviews.build(context: "default", status: "pending")
+
+        loan_application
+      end
+    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 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)
+      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 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)
+      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
+    end
+
+    def calculate_credit_score
+      loan_application = @clazz.find(params[:id])
+      category_id = score_params[:category_id]
+
+      unless category_id
+        return render_error(
+          "loan_application.errors.calculate_credit_score",
+          errors: [ "Category ID is required for credit scoring" ],
+          status: :unprocessable_entity
+        )
+      end
+
+      scoring_engine = CreditScoringEngine.new(loan_application.id, category_id)
+      result = scoring_engine.calculate_score
+
+      if result[:success]
+        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])
+          end
+
+          loan_application.reload
+        end
+
+        render_success(
+          "loan_application.success.calculate_credit_score",
+          data: result.merge(loan_application: loan_application),
+          status: :ok
+        )
+      else
+        render_error(
+          "loan_application.errors.calculate_credit_score",
+          errors: result[:errors] || [ result[:error] ],
+          status: :unprocessable_entity
+        )
+      end
+    rescue ActiveRecord::RecordNotFound
+      render_error(
+        "loan_application.errors.not_found",
+        errors: [ "Loan application not found" ],
+        status: :not_found
+      )
+    rescue => e
+      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
+    end
+
+    private
+
+    def update_review_status(loan_application, status)
+      current_review = loan_application.current_review_for(:default)
+
+      if current_review
+        current_review.update!(
+          status: status,
+          reviewed_by: current_user,
+          reviewed_at: Time.current,
+          feedback: build_review_feedback(status, loan_application.score)
+        )
+      else
+        loan_application.reviews.create!(
+          context: "default",
+          status: status,
+          reviewed_by: current_user,
+          reviewed_at: Time.current,
+          feedback: build_review_feedback(status, loan_application.score)
+        )
+      end
+    end
+
+    # Build feedback message based on status and score
+    def build_review_feedback(status, score)
+      case status
+      when "approved"
+        {
+          message: "Automatically approved based on credit score: #{score}% (>60%)"
+        }
+      when "rejected"
+        {
+          message: "Automatically rejected based on credit score: #{score}% (<50%)"
+        }
+      when "pending_review"
+        {
+          message: "Manual review required based on credit score: #{score}% (50%-60%)"
+        }
+      else
+        {
+          message: "Status determined by credit scoring system"
+        }
+      end
+    end
+
+    # Create loan profile for approved applications
+    def create_loan_profile_for_approved_application(loan_application, score)
+      profile_service = LoanProfileCreationService.new(loan_application, score)
+      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}"
+      end
+
+      profile_result
+    end
+
+    def model_params
+      params.require(:loan_application).permit(
+        :bank_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(:category_id)
+    end
+
+    def eager_loaded_associations
+      [
+        :bank, :user, :backer, :review_branch, :loan_profile,
+        reviews: { reviewed_by: :user_profile }
+      ]
+    end
+
+    def allowed_order_columns
+      %w[id bank_statement_source created_at updated_at]
+    end
+
+    def default_serializer_includes
+      {
+        index: [
+          :bank, :user, :backer, :review_branch, :loan_profile,
+          reviews: { reviewed_by: :user_profile }
+        ],
+        show: [
+          :bank, :user, :backer, :review_branch, :loan_profile,
+          reviews: { reviewed_by: :user_profile }
+        ],
+        create: [
+          :bank, :user, :backer, :review_branch, :loan_profile, :reviews
+        ],
+        update: [
+          :bank, :user, :backer, :review_branch, :loan_profile,
+          reviews: { reviewed_by: :user_profile }
+        ]
+      }
+    end
+  end
+end

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

@@ -1,78 +1,46 @@
 module Dscf::Credit
   class LoanProfilesController < ApplicationController
     include Dscf::Core::Common
-    include Dscf::Credit::Reviewable
+    include Dscf::Core::ReviewableController
 
     def create
       super do
         loan_profile = @clazz.new(model_params)
-
-        ActiveRecord::Base.transaction do
-          loan_profile.save!
-
-          if loan_profile.user.present?
-            loan_profile.loan_profile_scoring_specs.create!(
-              created_by: loan_profile.user
-            )
-          end
-        end
-
+        loan_profile.reviews.build(
+          status: "pending",
+          context: "default",
+        )
         loan_profile
       end
     end
 
-    def calculate_score
+
+    def calculate_facility_limits
       loan_profile = @clazz.find(params[:id])
-      scoring_service = Dscf::Credit::ScoringService.new(loan_profile)
+      category_id = facility_params[:category_id]
 
-      external_scoring_data = params[:scoring_input_data]
+      return render_error(
+        "loan_profile.errors.calculate_facility_limits",
+        errors: [ "Category ID is required" ],
+        status: :unprocessable_entity
+      ) unless category_id
 
-      result = scoring_service.calculate_credit_score(external_scoring_data)
+      facility_engine = FacilityLimitCalculationEngine.new(loan_profile.id, category_id)
+      result = facility_engine.calculate_facility_limits
 
       if result[:success]
-        ActiveRecord::Base.transaction do
-          scoring_spec = if external_scoring_data.present?
-                           loan_profile.loan_profile_scoring_specs.find_or_initialize_by(
-                             scoring_input_data: external_scoring_data
-                           )
-          else
-                           # If no external data, find existing spec with input data or latest one
-                           loan_profile.loan_profile_scoring_specs
-                                      .where.not(scoring_input_data: [ nil, {} ])
-                                      .order(created_at: :desc)
-                                      .first ||
-                           loan_profile.loan_profile_scoring_specs.order(created_at: :desc).first ||
-                           loan_profile.loan_profile_scoring_specs.build
-          end
-
-          loan_profile.loan_profile_scoring_specs.where.not(id: scoring_spec.id).update_all(active: false)
-
-          scoring_spec.assign_attributes(
-            score: result[:score],
-            total_limit: result[:facility_limit],
-            scoring_input_data: result[:scoring_input_data] || scoring_spec.scoring_input_data || {},
-            active: true,
-            created_by: scoring_spec.new_record? ? current_user : scoring_spec.created_by
-          )
-
-          scoring_spec.save!
-
-          update_loan_profile_status(loan_profile, result[:score])
-        end
-
         loan_profile.reload
-
         render_success(
-          "loan_profile.success.calculate_score",
+          "loan_profile.success.calculate_facility_limits",
           data: {
             loan_profile: loan_profile,
-            scoring_result: result
+            facility_result: result
           },
-          serializer_options: { include: [ :loan_profile_scoring_specs ] }
+          serializer_options: { include: [ :eligible_credit_lines ] }
         )
       else
         render_error(
-          "loan_profile.errors.calculate_score",
+          "loan_profile.errors.calculate_facility_limits",
           errors: [ result[:error] ],
           status: :unprocessable_entity
         )
@@ -82,6 +50,23 @@ module Dscf::Credit
         "loan_profile.errors.not_found",
         status: :not_found
       )
+    rescue => e
+      Rails.logger.error("Facility limit calculation error: #{e.class} - #{e.message}")
+      Rails.logger.error(e.backtrace.join("\n"))
+
+      if Rails.env.development? || Rails.env.test?
+        render_error(
+          "loan_profile.errors.calculate_facility_limits",
+          errors: [ e.message ],
+          status: :unprocessable_entity
+        )
+      else
+        render_error(
+          "loan_profile.errors.calculate_facility_limits",
+          errors: [ "An error occurred while calculating facility limits" ],
+          status: :unprocessable_entity
+        )
+      end
     end
 
     private
@@ -96,10 +81,10 @@ module Dscf::Credit
                      "approved"
       end
 
-      loan_profile.update!(
+      loan_profile.reviews.create!(
         status: new_status,
-        reviewed_by: current_user,
-        review_date: Time.current
+        context: "default",
+        reviewed_by: current_user
       )
     end
 
@@ -107,31 +92,39 @@ module Dscf::Credit
 
     def model_params
       params.require(:loan_profile).permit(
-        :bank_id,
-        :review_branch_id,
-        :user_id,
-        :backer_id,
-        :backer_type,
-        :status,
-        :total_amount,
-        :available_amount
+        :loan_application_id,
+        :code,
+        :score,
+        :total_limit
       )
     end
 
+    def facility_params
+      params.permit(:category_id)
+    end
+
     def eager_loaded_associations
-      [ :bank, :review_branch, :reviewed_by, :user, :backer, :loan_profile_scoring_specs, :loans, :eligible_credit_lines ]
+      [
+        :loan_application, :loan_profile_scoring_specs, :loans, :eligible_credit_lines,
+        reviews: { reviewed_by: :user_profile }
+      ]
     end
 
     def allowed_order_columns
-      %w[id status total_amount available_amount review_date created_at updated_at]
+      %w[id code score total_limit created_at updated_at]
     end
 
     def default_serializer_includes
       {
-        index: [ :bank, :review_branch, :reviewed_by, :user, :backer ],
-        show: [ :bank, :review_branch, :reviewed_by, :user, :backer, :loan_profile_scoring_specs, :loans, :eligible_credit_lines ],
-        create: [ :bank, :review_branch, :reviewed_by, :user, :backer, :loan_profile_scoring_specs ],
-        update: [ :bank, :review_branch, :reviewed_by, :user, :backer, :loan_profile_scoring_specs, :loans, :eligible_credit_lines ]
+        index: [ :loan_application, reviews: { reviewed_by: :user_profile } ],
+        show: [
+          :loan_application, :loan_profile_scoring_specs, :loans, :eligible_credit_lines, reviews: { reviewed_by: :user_profile }
+        ],
+        create: [ :loan_application, :loan_profile_scoring_specs, :reviews ],
+        update: [
+          :loan_application, :loan_profile_scoring_specs, :loans, :eligible_credit_lines,
+          reviews: { reviewed_by: :user_profile }
+        ]
       }
     end
   end

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

@@ -36,11 +36,9 @@ module Dscf::Credit
       # Find all eligible credit lines for the user through their approved loan profiles
       # Only include credit lines with available credit
       eligible_credit_lines = Dscf::Credit::EligibleCreditLine
-        .joins(loan_profile: :user)
-        .where(dscf_credit_loan_profiles: {
-          user_id: payment_request.user_id,
-          status: [ "approved", "kyc_approved" ]  # Only approved loan profiles
-        })
+        .joins(loan_profile: [ { loan_application: :user }, :reviews ])
+        .where(dscf_credit_loan_applications: { user_id: payment_request.user_id })
+        .where(dscf_core_reviews: { status: "approved" })  # Only approved loan profiles via reviews
         .where("dscf_credit_eligible_credit_lines.available_limit > 0")  # Only with available credit
         .includes(:loan_profile, :credit_line)
         .order("dscf_credit_eligible_credit_lines.available_limit DESC")  # Order by available limit

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

@@ -1,23 +1,40 @@
 module Dscf::Credit
   class ScoringParametersController < ApplicationController
     include Dscf::Core::Common
-    include Dscf::Credit::Reviewable
+    include Dscf::Core::ReviewableController
 
     def create
       super do
         scoring_parameter = @clazz.new(model_params)
         scoring_parameter.created_by = current_user
-        scoring_parameter.reviewed_by = current_user
+        scoring_parameter.reviews.build(context: "default", status: "pending")
 
-        scoring_parameter
+        if validate_category_weight_limit(scoring_parameter)
+          scoring_parameter
+        else
+          scoring_parameter.errors.add(:weight, "would exceed the total weight limit of 1.0 for this category")
+          render_error(errors: scoring_parameter.errors.full_messages, status: :unprocessable_entity)
+          return
+        end
       end
     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")
+        render_error(errors: @obj.errors.full_messages, status: :unprocessable_entity)
+        return
+      end
+
+      super
+    end
+
     private
 
     def model_params
       params.require(:scoring_parameter).permit(
         :bank_id,
+        :category_id,
         :name,
         :description,
         :data_type,
@@ -26,30 +43,59 @@ module Dscf::Credit
         :max_value,
         :active,
         :previous_version_id,
-        :review_date,
         :source,
         :scoring_param_type_id,
-        :document_reference,
-        :status,
-        :review_feedback
+        :document_reference
       )
     end
 
     def eager_loaded_associations
-      [ :bank, :created_by, :reviewed_by, :scoring_param_type, :previous_version, :parameter_normalizers, :scoring_tables, :categories ]
+      [
+        :bank, :category, :created_by, :scoring_param_type, :previous_version, :parameter_normalizers,
+        reviews: { reviewed_by: :user_profile }
+      ]
     end
 
     def allowed_order_columns
-      %w[id name data_type weight active review_date created_at updated_at]
+      %w[id name data_type weight active created_at updated_at]
     end
 
     def default_serializer_includes
       {
-        index: [ :bank ],
-        show: [ :bank, :created_by, :reviewed_by, :scoring_param_type, :previous_version, :parameter_normalizers, :scoring_tables, :categories ],
-        create: [ :bank, :created_by, :reviewed_by, :scoring_param_type ],
-        update: [ :bank, :created_by, :reviewed_by, :scoring_param_type, :parameter_normalizers, :scoring_tables, :categories ]
+        index: [ :bank, :category, reviews: { reviewed_by: :user_profile } ],
+        show: [
+          :bank, :category, :created_by, :scoring_param_type, :previous_version, :parameter_normalizers,
+          reviews: { reviewed_by: :user_profile }
+        ],
+        create: [ :bank, :category, :created_by, :scoring_param_type ],
+        update: [
+          :bank, :category, :created_by, :scoring_param_type, :parameter_normalizers,
+          reviews: { reviewed_by: :user_profile }
+        ]
       }
     end
+
+    def validate_category_weight_limit(scoring_parameter, exclude_current: false)
+      return true unless scoring_parameter.category_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,
+        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
+    end
   end
 end

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

@@ -1,13 +1,14 @@
 module Dscf::Credit
   class SystemConfigsController < ApplicationController
     include Dscf::Core::Common
-    include Dscf::Credit::Reviewable
+    include Dscf::Core::ReviewableController
 
     def create
       super do
         obj = @clazz.new(model_params)
-        obj.reviewed_by = current_user
         obj.last_updated_by = current_user
+        obj.reviews.build(context: "default", status: "pending")
+
         obj
       end
     end
@@ -25,27 +26,44 @@ module Dscf::Credit
     def model_params
       params.require(:system_config).permit(
         :config_definition_id,
-        :config_value,
-        :status,
-        :review_date,
-        :review_feedback
+        :config_value
       )
     end
 
     def eager_loaded_associations
-      [ :config_definition, :last_updated_by, :reviewed_by ]
+      [
+        :config_definition,
+        :last_updated_by,
+        reviews: { reviewed_by: :user_profile }
+      ]
     end
 
     def allowed_order_columns
-      %w[id config_value status review_date created_at updated_at]
+      %w[id config_value created_at updated_at]
     end
 
     def default_serializer_includes
       {
-        index: [ :config_definition ],
-        show: [ :config_definition, :last_updated_by, :reviewed_by ],
-        create: [ :config_definition, :last_updated_by, :reviewed_by ],
-        update: [ :config_definition, :last_updated_by, :reviewed_by ]
+        index: [
+          :config_definition,
+          reviews: { reviewed_by: :user_profile }
+        ],
+        show: [
+          :config_definition,
+          :last_updated_by,
+          reviews: { reviewed_by: :user_profile }
+        ],
+        create: [
+          :config_definition,
+          :last_updated_by,
+          :reviews
+
+        ],
+        update: [
+          :config_definition,
+          :last_updated_by,
+          reviews: { reviewed_by: :user_profile }
+        ]
       }
     end
   end

data/app/models/concerns/core/reviewable_model.rb

@@ -0,0 +1,31 @@
+module Dscf
+  module Core
+    module ReviewableModel
+      extend ActiveSupport::Concern
+
+      included do
+        has_many :reviews, as: :reviewable, class_name: "Dscf::Core::Review", dependent: :destroy
+      end
+
+      def review_for(context = :default)
+        reviews.with_context(context).order(created_at: :desc)
+      end
+
+      def current_review_for(context = :default)
+        review_for(context).first
+      end
+
+      def current_status_for(context = :default)
+        current_review = current_review_for(context)
+        return current_review.status if current_review
+
+        # Return default initial status for zero-config
+        "pending"
+      end
+
+      def build_review_for(context = :default)
+        reviews.build(context: context.to_s)
+      end
+    end
+  end
+end

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

@@ -13,10 +13,10 @@ module Dscf::Credit
              foreign_key: "bank_id", dependent: :destroy
     has_many :scoring_parameters, class_name: "Dscf::Credit::ScoringParameter",
              foreign_key: "bank_id", dependent: :destroy
-    has_many :loan_profiles, class_name: "Dscf::Credit::LoanProfile",
-             foreign_key: "bank_id", dependent: :destroy
-    has_many :facilitators, class_name: "Dscf::Credit::Facilitator",
+    has_many :loan_applications, class_name: "Dscf::Credit::LoanApplication",
              foreign_key: "bank_id", dependent: :destroy
+    has_many :facilitators, through: :facilitator_applications, class_name: "Dscf::Credit::Facilitator"
+    has_many :facilitator_applications, class_name: "Dscf::Credit::FacilitatorApplication"
     has_many :bank_staffs, through: :bank_branches, class_name: "Dscf::Credit::BankStaff"
 
     validates :name, presence: true