dscf-credit 0.1.2 → 0.1.4

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

@@ -0,0 +1,50 @@
+module Dscf::Credit
+  class EligibleCreditLinesController < ApplicationController
+    include Dscf::Core::Common
+
+    before_action :set_object, only: [ :show, :apply_risk ]
+
+    def apply_risk
+      unless params[:risk].present?
+        return render_error("eligible_credit_line.errors.apply_risk", errors: [ "Risk parameter is required" ])
+      end
+
+      service = RiskApplicationService.new(@obj, params[:risk])
+      result = service.apply_risk
+
+      if result[:success]
+        render_success(data: result[:data].reload)
+      else
+        render_error(errors: result[:errors])
+      end
+    end
+
+    private
+
+    def model_params
+      params.require(:eligible_credit_line).permit(
+        :loan_profile_id,
+        :credit_line_id,
+        :credit_limit,
+        :available_limit
+      )
+    end
+
+    def eager_loaded_associations
+      [ :loan_profile, :credit_line ]
+    end
+
+    def allowed_order_columns
+      %w[id credit_limit available_limit risk created_at updated_at loan_profile_id credit_line_id]
+    end
+
+    def default_serializer_includes
+      {
+        index: [ :loan_profile, :credit_line ],
+        show: [ :loan_profile, :credit_line ],
+        create: [ :loan_profile, :credit_line ],
+        update: [ :loan_profile, :credit_line ]
+      }
+    end
+  end
+end

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

@@ -16,7 +16,7 @@ module Dscf::Credit
 
     def approve
       begin
-        FacilitatorApprovalService.new(@facilitator, current_user).approve(params[:total_limit])
+        FacilitatorApprovalService.new(@facilitator, current_user).approve
         render_success(data: @facilitator)
       rescue StandardError => e
         render_error(errors: e.message)
@@ -83,6 +83,7 @@ module Dscf::Credit
         :user_id,
         :bank_id,
         :kyc_status,
+        :total_limit,
         :kyc_review_date,
         :additional_info,
         :review_feedback

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

@@ -0,0 +1,138 @@
+module Dscf::Credit
+  class LoanProfilesController < ApplicationController
+    include Dscf::Core::Common
+    include Dscf::Credit::Reviewable
+
+    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
+      end
+    end
+
+    def calculate_score
+      loan_profile = @clazz.find(params[:id])
+      scoring_service = Dscf::Credit::ScoringService.new(loan_profile)
+
+      external_scoring_data = params[:scoring_input_data]
+
+      result = scoring_service.calculate_credit_score(external_scoring_data)
+
+      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",
+          data: {
+            loan_profile: loan_profile,
+            scoring_result: result
+          },
+          serializer_options: { include: [ :loan_profile_scoring_specs ] }
+        )
+      else
+        render_error(
+          "loan_profile.errors.calculate_score",
+          errors: [ result[:error] ],
+          status: :unprocessable_entity
+        )
+      end
+    rescue ActiveRecord::RecordNotFound
+      render_error(
+        "loan_profile.errors.not_found",
+        status: :not_found
+      )
+    end
+
+    private
+
+    def update_loan_profile_status(loan_profile, score)
+      new_status = case score
+      when 0...50
+                     "rejected"
+      when 50...60
+                     "manual_review"
+      else
+                     "approved"
+      end
+
+      loan_profile.update!(
+        status: new_status,
+        reviewed_by: current_user,
+        review_date: Time.current
+      )
+    end
+
+    private
+
+    def model_params
+      params.require(:loan_profile).permit(
+        :bank_id,
+        :review_branch_id,
+        :user_id,
+        :backer_id,
+        :backer_type,
+        :status,
+        :total_amount,
+        :available_amount
+      )
+    end
+
+    def eager_loaded_associations
+      [ :bank, :review_branch, :reviewed_by, :user, :backer, :loan_profile_scoring_specs, :loans, :eligible_credit_lines ]
+    end
+
+    def allowed_order_columns
+      %w[id status total_amount available_amount review_date 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 ]
+      }
+    end
+  end
+end

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

@@ -2,20 +2,69 @@ module Dscf::Credit
   class PaymentRequestsController < ApplicationController
     include Dscf::Core::Common
 
+    def create
+      super do
+        obj = @clazz.new(model_params)
+        obj.request_type = "credit"
+        obj.initiated_at = Time.current
+        obj
+      end
+    end
+
+    def approve
+      @obj = @clazz.find(params[:id])
+
+      if @obj.update(status: "approved", approved_at: Time.current)
+        @obj = @clazz.includes(eager_loaded_associations).find(@obj.id) if eager_loaded_associations.present?
+        includes = serializer_includes_for_action(:show)
+        options = includes.present? ? { include: includes } : {}
+        render_success(data: @obj, serializer_options: options)
+      else
+        render_error(errors: @obj.errors.full_messages[0], status: :unprocessable_entity)
+      end
+    rescue StandardError => e
+      render_error(error: e.message)
+    end
+
+    def eligible_credit_lines
+      payment_request = @clazz.find(params[:id])
+
+      if payment_request.user.nil?
+        return render_error(error: "Payment request has no associated user", status: :unprocessable_entity)
+      end
+
+      # 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
+        })
+        .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
+
+      render_success(
+        data: eligible_credit_lines,
+      )
+    rescue ActiveRecord::RecordNotFound
+      render_error(error: "Payment request not found", status: :not_found)
+    rescue StandardError => e
+      render_error(error: e.message)
+    end
+
     private
 
     def model_params
       params.require(:payment_request).permit(
         :user_id,
         :order_id,
-        :request_type,
         :amount,
         :receiver_account_reference,
         :status,
-        :failure_reason,
-        :initiated_at,
-        :approved_at
-      )
+        :failure_reason
+        )
     end
 
     def eager_loaded_associations

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

@@ -0,0 +1,53 @@
+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)
+      result = service.process_repayment
+
+      if result[:success]
+        render_success(
+          "repayment.success.create",
+          data: {
+            loan: result[:loan],
+            payment_details: result[:payment_details]
+          },
+          serializer_options: {
+            include: [
+              :loan_profile,
+              :credit_line,
+              :payment_request,
+              :loan_transactions
+            ]
+          }
+        )
+      else
+        render_error(
+          "repayment.errors.create",
+          errors: [ result[:error] ],
+          status: :unprocessable_entity
+        )
+      end
+    rescue ActiveRecord::RecordNotFound => e
+      render_error(
+        "repayment.errors.not_found",
+        errors: [ e.message ],
+        status: :not_found
+      )
+    rescue StandardError => e
+      render_error(
+        "repayment.errors.create",
+        errors: [ e.message ],
+        status: :internal_server_error
+      )
+    end
+
+    private
+
+    def model_params
+      params.permit(:loan_id, :amount)
+    end
+  end
+end

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

@@ -36,7 +36,7 @@ module Dscf::Credit
     end
 
     def eager_loaded_associations
-      [ :bank, :created_by, :reviewed_by, :scoring_param_type, :previous_version, :parameter_normalizers ]
+      [ :bank, :created_by, :reviewed_by, :scoring_param_type, :previous_version, :parameter_normalizers, :scoring_tables, :categories ]
     end
 
     def allowed_order_columns
@@ -46,9 +46,9 @@ module Dscf::Credit
     def default_serializer_includes
       {
         index: [ :bank ],
-        show: [ :bank, :created_by, :reviewed_by, :scoring_param_type, :previous_version, :parameter_normalizers ],
+        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 ]
+        update: [ :bank, :created_by, :reviewed_by, :scoring_param_type, :parameter_normalizers, :scoring_tables, :categories ]
       }
     end
   end

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

@@ -13,7 +13,7 @@ module Dscf::Credit
     def activate
       @obj = @clazz.find(params[:id])
       if @obj.update(active: true)
-        render_success(data: @obj, serializer_options: { include: [ :credit_line, :scoring_parameter, :created_by ] })
+        render_success(data: @obj, serializer_options: { include: [ :category, :scoring_parameter, :created_by ] })
       else
         render_error(errors: @obj.errors.full_messages[0], status: :unprocessable_entity)
       end
@@ -24,7 +24,7 @@ module Dscf::Credit
     def deactivate
       @obj = @clazz.find(params[:id])
       if @obj.update(active: false)
-        render_success(data: @obj, serializer_options: { include: [ :credit_line, :scoring_parameter, :created_by ] })
+        render_success(data: @obj, serializer_options: { include: [ :category, :scoring_parameter, :created_by ] })
       else
         render_error(errors: @obj.errors.full_messages[0], status: :unprocessable_entity)
       end
@@ -36,7 +36,7 @@ module Dscf::Credit
 
     def model_params
       params.require(:scoring_table).permit(
-        :credit_line_id,
+        :category_id,
         :scoring_parameter_id,
         :weight,
         :active
@@ -44,7 +44,7 @@ module Dscf::Credit
     end
 
     def eager_loaded_associations
-      [ :credit_line, :scoring_parameter, :created_by ]
+      [ :category, :scoring_parameter, :created_by ]
     end
 
     def allowed_order_columns
@@ -53,10 +53,10 @@ module Dscf::Credit
 
     def default_serializer_includes
       {
-        index: [ :credit_line, :scoring_parameter, :created_by ],
-        show: [ :credit_line, :scoring_parameter, :created_by ],
-        create: [ :credit_line, :scoring_parameter, :created_by ],
-        update: [ :credit_line, :scoring_parameter, :created_by ]
+        index: [ :category, :scoring_parameter, :created_by ],
+        show: [ :category, :scoring_parameter, :created_by ],
+        create: [ :category, :scoring_parameter, :created_by ],
+        update: [ :category, :scoring_parameter, :created_by ]
       }
     end
   end

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

@@ -25,6 +25,24 @@ module Dscf::Credit
       end
     end
 
+    def show
+      super do
+        has_retailer_business = @obj.businesses.any? do |business|
+          business.business_type&.name&.downcase == "retailer"
+        end
+
+        unless has_retailer_business
+          return render_error(
+            "errors.access_denied",
+            errors: "User does not have retailer business type",
+            status: :forbidden
+          )
+        end
+
+        @obj
+      end
+    end
+
     private
 
     def model_params

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

@@ -4,6 +4,7 @@ module Dscf::Credit
 
     belongs_to :bank, class_name: "Dscf::Credit::Bank", foreign_key: "bank_id"
     has_many :bank_staffs, class_name: "Dscf::Credit::BankStaff", foreign_key: "bank_branch_id", dependent: :destroy
+    has_many :loan_profiles, class_name: "Dscf::Credit::LoanProfile", foreign_key: "review_branch_id", dependent: :nullify
 
     validates :branch_name, presence: true
     validates :branch_name, uniqueness: { scope: :bank_id }
@@ -17,7 +18,7 @@ module Dscf::Credit
     end
 
     def self.ransackable_associations(auth_object = nil)
-      %w[bank bank_staffs]
+      %w[bank bank_staffs loan_profiles]
     end
   end
 end

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

@@ -4,6 +4,8 @@ module Dscf::Credit
     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_tables, class_name: "Dscf::Credit::ScoringTable", foreign_key: "category_id", dependent: :destroy
+    has_many :scoring_parameters, through: :scoring_tables
 
     validates :type, :name, presence: true
     validates :name, uniqueness: { scope: :type }
@@ -15,7 +17,7 @@ module Dscf::Credit
     end
 
     def self.ransackable_associations(auth_object = nil)
-      %w[credit_lines]
+      %w[credit_lines scoring_tables scoring_parameters]
     end
   end
 end

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

@@ -9,8 +9,8 @@ module Dscf::Credit
 
     has_many :credit_line_specs, class_name: "Dscf::Credit::CreditLineSpec", foreign_key: "credit_line_id", dependent: :destroy
     has_many :loans, class_name: "Dscf::Credit::Loan", foreign_key: "credit_line_id", dependent: :destroy
-    has_many :scoring_tables, class_name: "Dscf::Credit::ScoringTable", foreign_key: "credit_line_id", dependent: :destroy
-    has_many :scoring_parameters, through: :scoring_tables
+    has_many :eligible_credit_lines, class_name: "Dscf::Credit::EligibleCreditLine", foreign_key: "credit_line_id", dependent: :destroy
+    has_many :scoring_parameters, through: :category, source: :scoring_parameters
 
     validates :name, presence: true
     validates :code, uniqueness: { scope: :bank_id }, allow_blank: true
@@ -27,7 +27,7 @@ module Dscf::Credit
     end
 
     def self.ransackable_associations(auth_object = nil)
-      %w[bank category created_by reviewed_by credit_line_specs loans scoring_tables scoring_parameters]
+      %w[bank category created_by reviewed_by credit_line_specs loans eligible_credit_lines scoring_parameters]
     end
   end
 end

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

@@ -5,8 +5,8 @@ module Dscf::Credit
     belongs_to :credit_line, class_name: "Dscf::Credit::CreditLine", foreign_key: "credit_line_id"
     belongs_to :created_by, polymorphic: true
 
-    validates :min_amount, :max_amount, :interest_rate, :penalty_rate, :facilitation_fee_rate, :tax_rate, :max_penalty_days, :loan_duration, :interest_frequency, :interest_income_tax, :vat, :max_interest_calculation_days, :penalty_frequency, :penalty_income_tax, presence: true
-    validates :min_amount, :max_amount, numericality: { greater_than: 0 }
+    validates :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, presence: true
+    validates :min_amount, :max_amount, :credit_line_multiplier, numericality: { greater_than: 0 }
     validates :interest_rate, :penalty_rate, :facilitation_fee_rate, :tax_rate, :interest_income_tax, :vat, :penalty_income_tax, numericality: { greater_than_or_equal_to: 0, less_than: 10 }
     validates :max_penalty_days, :loan_duration, :max_interest_calculation_days, numericality: { greater_than: 0 }
     validates :interest_frequency, inclusion: { in: %w[daily weekly monthly quarterly annually] }
@@ -19,7 +19,7 @@ module Dscf::Credit
     scope :by_penalty_frequency, ->(frequency) { where(penalty_frequency: frequency) }
 
     def self.ransackable_attributes(auth_object = nil)
-      %w[id min_amount max_amount interest_rate penalty_rate facilitation_fee_rate tax_rate 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 active created_at updated_at]
     end
 
     def self.ransackable_associations(auth_object = nil)

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

@@ -0,0 +1,28 @@
+module Dscf::Credit
+  class EligibleCreditLine < ApplicationRecord
+    self.table_name = "dscf_credit_eligible_credit_lines"
+
+    belongs_to :loan_profile, class_name: "Dscf::Credit::LoanProfile", foreign_key: "loan_profile_id"
+    belongs_to :credit_line, class_name: "Dscf::Credit::CreditLine", foreign_key: "credit_line_id"
+
+    validates :credit_limit, presence: true
+    validates :credit_limit, numericality: { greater_than: 0 }
+    validates :available_limit, presence: true
+    validates :available_limit, numericality: { greater_than_or_equal_to: 0 }
+    validates :risk, numericality: { greater_than_or_equal_to: 0.01, less_than_or_equal_to: 0.9 }, allow_nil: true
+
+    scope :by_loan_profile, ->(loan_profile_id) { where(loan_profile_id: loan_profile_id) }
+    scope :by_credit_line, ->(credit_line_id) { where(credit_line_id: credit_line_id) }
+    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) }
+
+    def self.ransackable_attributes(auth_object = nil)
+      %w[id credit_limit available_limit risk created_at updated_at]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[loan_profile credit_line]
+    end
+  end
+end

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

@@ -3,22 +3,25 @@ module Dscf::Credit
     self.table_name = "dscf_credit_loan_profiles"
 
     belongs_to :bank, class_name: "Dscf::Credit::Bank", foreign_key: "bank_id"
-    belongs_to :reviewed_by, polymorphic: true
+    belongs_to :review_branch, class_name: "Dscf::Credit::BankBranch", foreign_key: "review_branch_id", optional: true
+    belongs_to :reviewed_by, polymorphic: true, optional: true
     belongs_to :backer, polymorphic: true, optional: true
     if defined?(Dscf::Core::User)
       belongs_to :user, class_name: "Dscf::Core::User", foreign_key: "user_id"
     end
     has_many :loan_profile_scoring_specs, class_name: "Dscf::Credit::LoanProfileScoringSpec", foreign_key: "loan_profile_id", dependent: :destroy
     has_many :loans, class_name: "Dscf::Credit::Loan", foreign_key: "loan_profile_id", dependent: :destroy
+    has_many :eligible_credit_lines, class_name: "Dscf::Credit::EligibleCreditLine", foreign_key: "loan_profile_id", dependent: :destroy
 
-    validates :status, inclusion: { in: %w[pending approved rejected kyc_approved kyc_rejected] }
-    enum :status, { pending: "pending", approved: "approved", rejected: "rejected", kyc_approved: "kyc_approved", kyc_rejected: "kyc_rejected" }
+    validates :status, inclusion: { in: %w[pending approved rejected manual_review kyc_approved kyc_rejected] }
+    enum :status, { pending: "pending", approved: "approved", rejected: "rejected", manual_review: "manual_review", kyc_approved: "kyc_approved", kyc_rejected: "kyc_rejected" }
     validates :total_amount, :available_amount, numericality: { greater_than_or_equal_to: 0 }
     validate :available_amount_not_greater_than_total_amount
 
     scope :pending, -> { where(status: "pending") }
     scope :approved, -> { where(status: "approved") }
     scope :rejected, -> { where(status: "rejected") }
+    scope :manual_review, -> { where(status: "manual_review") }
     scope :kyc_approved, -> { where(status: "kyc_approved") }
     scope :kyc_rejected, -> { where(status: "kyc_rejected") }
     scope :with_available_amount, -> { where("available_amount > 0") }
@@ -26,11 +29,11 @@ module Dscf::Credit
     scope :by_available_amount_range, ->(min, max) { where(available_amount: min..max) }
 
     def self.ransackable_attributes(auth_object = nil)
-      %w[id status total_amount available_amount review_feedback review_date created_at updated_at reviewed_by_type reviewed_by_id]
+      %w[id status total_amount available_amount review_feedback review_date created_at updated_at reviewed_by_type reviewed_by_id review_branch_id]
     end
 
     def self.ransackable_associations(auth_object = nil)
-      %w[bank user backer reviewed_by loan_profile_scoring_specs loans]
+      %w[bank user backer reviewed_by review_branch loan_profile_scoring_specs loans eligible_credit_lines]
     end
 
     private

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

@@ -4,19 +4,18 @@ module Dscf::Credit
 
     belongs_to :loan_profile, class_name: "Dscf::Credit::LoanProfile", foreign_key: "loan_profile_id"
     belongs_to :created_by, polymorphic: true
-    belongs_to :reviewed_by, polymorphic: true
 
-    validates :scoring_input_data, :score, presence: true
-    validates :score, numericality: { greater_than_or_equal_to: 0 }
+    validates :score, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true
+    validates :total_limit, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true
 
     scope :active, -> { where(active: true) }
 
     def self.ransackable_attributes(auth_object = nil)
-      %w[id score active review_date review_feedback created_at updated_at]
+      %w[id score total_limit active created_at updated_at]
     end
 
     def self.ransackable_associations(auth_object = nil)
-      %w[loan_profile created_by reviewed_by]
+      %w[loan_profile created_by]
     end
   end
 end

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

@@ -9,7 +9,7 @@ module Dscf::Credit
     belongs_to :previous_version, class_name: "Dscf::Credit::ScoringParameter", optional: true
     has_many :parameter_normalizers, class_name: "Dscf::Credit::ParameterNormalizer", foreign_key: "scoring_parameter_id", dependent: :destroy
     has_many :scoring_tables, class_name: "Dscf::Credit::ScoringTable", foreign_key: "scoring_parameter_id", dependent: :destroy
-    has_many :credit_lines, through: :scoring_tables
+    has_many :categories, through: :scoring_tables
 
     validates :name, :data_type, :weight, presence: true
     validates :weight, numericality: { greater_than: 0, less_than_or_equal_to: 1 }
@@ -25,7 +25,7 @@ module Dscf::Credit
     end
 
     def self.ransackable_associations(auth_object = nil)
-      %w[bank created_by reviewed_by scoring_param_type previous_version parameter_normalizers scoring_tables credit_lines]
+      %w[bank created_by reviewed_by scoring_param_type previous_version parameter_normalizers scoring_tables categories]
     end
   end
 end

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

@@ -2,15 +2,15 @@ module Dscf::Credit
   class ScoringTable < ApplicationRecord
     self.table_name = "dscf_credit_scoring_tables"
 
-    belongs_to :credit_line, class_name: "Dscf::Credit::CreditLine", foreign_key: "credit_line_id"
+    belongs_to :category, class_name: "Dscf::Credit::Category", foreign_key: "category_id"
     belongs_to :scoring_parameter, class_name: "Dscf::Credit::ScoringParameter", foreign_key: "scoring_parameter_id"
     belongs_to :created_by, polymorphic: true
 
     validates :weight, presence: true, numericality: { greater_than: 0, less_than_or_equal_to: 1 }
-    validates :credit_line_id, uniqueness: { scope: :scoring_parameter_id }
+    validates :category_id, uniqueness: { scope: :scoring_parameter_id }
 
     scope :active, -> { where(active: true) }
-    scope :by_credit_line, ->(credit_line_id) { where(credit_line_id: credit_line_id) }
+    scope :by_category, ->(category_id) { where(category_id: category_id) }
     scope :by_scoring_parameter, ->(scoring_parameter_id) { where(scoring_parameter_id: scoring_parameter_id) }
 
     def self.ransackable_attributes(auth_object = nil)
@@ -18,7 +18,7 @@ module Dscf::Credit
     end
 
     def self.ransackable_associations(auth_object = nil)
-      %w[credit_line scoring_parameter created_by]
+      %w[category scoring_parameter created_by]
     end
   end
 end

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

@@ -5,5 +5,6 @@ module Dscf::Credit
 
     belongs_to :bank, serializer: Dscf::Credit::BankSerializer
     has_many :bank_staffs, serializer: Dscf::Credit::BankStaffSerializer
+    has_many :loan_profiles, serializer: Dscf::Credit::LoanProfileSerializer
   end
 end