dscf-credit 0.4.46 → 0.4.48

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f9f80c67743753180bfd10ef6eb0bc0306c52ee04eb452b3010a073e2ccd9057
-  data.tar.gz: 123b03963cd6cc6b98395ed5d6172692e293b26194da7fb58d40ba8f5fc13753
+  metadata.gz: 202f7f16da67e4370a2e290955089d9872866d8c574d3e2a8fb61a980c2dcfff
+  data.tar.gz: 3ce121d8bc09a5dcc475aed9e4376a1558a83da30032ffe4f5534cf3ddc32ba6
 SHA512:
-  metadata.gz: 83c4541282e5fb60ffb91ae403730a429e1cbceb72b0d500863582c142a551ce52eb59341b16c35b6e8842f15ff502975fe52fbd0c99a87958cfe8eae6da8612
-  data.tar.gz: 0d2467ce32293e362a67ef9ece84127d17599157cf109d95e7bd6c21671188aaf52f3f85037464ab86f94512179cea8276ba0469e500feffea973d9f89828736
+  metadata.gz: daaec706ba7d573f78a42d81e9c25c794b3db39c1c68556fdd633c3a013604c5f034f689c2ff34a3f2f0d19c4b385d3da0a14c404f1942f55beed99736917653
+  data.tar.gz: 18dfaee9c7c9b25bcf9847f1c98004e1ec2bace0bbe987613913ff7db164c98cb8b6233e3db6736a1d1dcfb7d233b801a25a145828928fd6f2d3d65ab34741c4

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

@@ -10,26 +10,24 @@ module Dscf
           :bank_id,
           :category_type,
           :name,
-          :description,
-          :document_reference,
-          :scoring_table_id
+          :description
         )
       end
 
       def eager_loaded_associations
-        [ :bank, :scoring_table, :credit_lines, :scoring_parameters ]
+        [ :bank, :scoring_parameters ]
       end
 
       def allowed_order_columns
-        %w[id category_type name description document_reference created_at updated_at]
+        %w[id category_type name description created_at updated_at]
       end
 
       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 ]
+          show: [ :bank, :scoring_parameters ],
+          create: [ :bank ],
+          update: [ :bank, :scoring_parameters ]
         }
       end
     end

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

@@ -2,9 +2,9 @@ module Dscf::Credit
   class CreditLimitCalculationsController < ApplicationController
     def create
       loan_profile = Dscf::Credit::LoanProfile.find(params[:loan_profile_id])
-      category = Dscf::Credit::Category.find(params[:category_id])
+      credit_product = Dscf::Credit::CreditProduct.find(params[:credit_product_id])
 
-      engine = Dscf::Credit::FacilityLimitCalculationEngine.new(loan_profile.id, category.id)
+      engine = Dscf::Credit::FacilityLimitCalculationEngine.new(loan_profile.id, credit_product.id)
       result = engine.calculate_facility_limits
 
       if result[:success]
@@ -13,7 +13,7 @@ module Dscf::Credit
           "credit_limit_calculation.success.create",
           data: {
             loan_profile: loan_profile,
-            category: category,
+            credit_product: credit_product,
             eligible_credit_lines: result[:data],
             calculation_summary: {
               total_credit_lines_processed: result[:data]&.size || 0,

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

@@ -34,7 +34,7 @@ module Dscf::Credit
     def model_params
       params.require(:credit_line).permit(
         :bank_id,
-        :category_id,
+        :credit_product_id,
         :name,
         :code,
         :description,
@@ -44,7 +44,7 @@ module Dscf::Credit
 
     def eager_loaded_associations
       [
-        :bank, :category, :created_by, :loans, :eligible_credit_lines,
+        :bank, :credit_product, :created_by, :loans, :eligible_credit_lines,
         credit_line_specs: :base_scoring_parameter,
         reviews: { reviewed_by: :user_profile },
         audit_logs: :actor
@@ -52,21 +52,21 @@ module Dscf::Credit
     end
 
     def allowed_order_columns
-      %w[id name code created_at updated_at category_id]
+      %w[id name code created_at updated_at credit_product_id]
     end
 
     def default_serializer_includes
       {
-        index: [ :bank, :category, reviews: { reviewed_by: :user_profile } ],
+        index: [ :bank, :credit_product, reviews: { reviewed_by: :user_profile } ],
         show: [
-          :bank, :category, :created_by, :loans, :eligible_credit_lines,
+          :bank, :credit_product, :created_by, :loans, :eligible_credit_lines,
           credit_line_specs: :base_scoring_parameter,
           reviews: { reviewed_by: :user_profile },
           audit_logs: :actor
         ],
-        create: [ :bank, :category, :created_by, :reviews ],
+        create: [ :bank, :credit_product, :created_by, :reviews ],
         update: [
-          :bank, :category, :created_by, :credit_line_specs, :loans, :eligible_credit_lines,
+          :bank, :credit_product, :created_by, :credit_line_specs, :loans, :eligible_credit_lines,
           reviews: { reviewed_by: :user_profile }
         ]
       }

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

@@ -0,0 +1,66 @@
+module Dscf
+  module Credit
+    class CreditProductsController < ApplicationController
+      include Dscf::Core::Common
+      include Dscf::Core::ReviewableController
+      include Dscf::Core::AuditableController
+
+      auditable associated: [ :reviews ],
+                on: %i[approve submit reject request_modification resubmit]
+
+      auditable on: %i[create],
+                associated: { reviews: { only: [ :status ] } }
+
+      def create
+        super do
+          credit_product = @clazz.new(model_params)
+          credit_product.reviews.build(status: "draft", context: "default")
+          credit_product
+        end
+      end
+
+      def update
+        unless @obj.editable?
+          return render_error(
+            errors: [ "Cannot update credit product after submission. Use modification request workflow instead." ],
+            status: :unprocessable_entity
+          )
+        end
+        super
+      end
+
+      private
+
+      def model_params
+        params.require(:credit_product).permit(
+          :bank_id,
+          :scoring_table_id,
+          :name,
+          :description,
+          :document_reference
+        )
+      end
+
+      def eager_loaded_associations
+        [
+          :bank, :scoring_table, :credit_lines,
+          reviews: { reviewed_by: :user_profile },
+          audit_logs: :actor
+        ]
+      end
+
+      def allowed_order_columns
+        %w[id name description created_at updated_at bank_id]
+      end
+
+      def default_serializer_includes
+        {
+          index: [ :bank, reviews: { reviewed_by: :user_profile } ],
+          show: [ :bank, :scoring_table, :credit_lines, reviews: { reviewed_by: :user_profile }, audit_logs: :actor ],
+          create: [ :bank, :reviews ],
+          update: [ :bank, :scoring_table, reviews: { reviewed_by: :user_profile }, audit_logs: :actor ]
+        }
+      end
+    end
+  end
+end

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

@@ -32,7 +32,7 @@ module Dscf::Credit
           end
 
           scoring_result_data = {
-            scoring_table_id: loan_application.category&.scoring_table&.id,
+            scoring_table_id: loan_application.credit_product&.scoring_table&.id,
             scoring_input_data: input_snapshot,
             breakdown: {}  # Breakdown unavailable for manually-approved pending applications
           }
@@ -100,11 +100,11 @@ module Dscf::Credit
         return render_error(errors: [ "Information source '#{source_code}' not found" ], status: :not_found)
       end
 
-      category = @obj.category
-      scoring_table = category&.scoring_table
+      credit_product = @obj.credit_product
+      scoring_table = credit_product&.scoring_table
 
       unless scoring_table
-        return render_error(errors: [ "No scoring table configured for this loan application's category" ], status: :unprocessable_entity)
+        return render_error(errors: [ "No scoring table configured for this loan application's credit product" ], status: :unprocessable_entity)
       end
 
       # Load parameters for this source with normalizers
@@ -156,7 +156,7 @@ module Dscf::Credit
 
       if result[:success]
         scoring_result_data = {
-          scoring_table_id: loan_application.category&.scoring_table&.id,
+            scoring_table_id: loan_application.credit_product&.scoring_table&.id,
           breakdown: result[:breakdown],
           scoring_input_data: build_scoring_input_snapshot(loan_application)
         }
@@ -249,7 +249,7 @@ module Dscf::Credit
 
     # Build feedback message based on status and score
     def build_review_feedback(status, score, loan_application = nil)
-      scoring_table = loan_application&.category&.scoring_table || @obj&.category&.scoring_table
+      scoring_table = loan_application&.credit_product&.scoring_table || @obj&.credit_product&.scoring_table
       passing = scoring_table&.passing_score || 60.0
       pending_thresh = scoring_table&.pending_threshold || 50.0
 
@@ -275,13 +275,13 @@ module Dscf::Credit
     end
 
     def build_eligibility_response(loan_application)
-      category = loan_application.category
-      return [] unless category
+      credit_product = loan_application.credit_product
+      return [] unless credit_product
 
       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|
+      credit_product.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
 
@@ -326,7 +326,7 @@ module Dscf::Credit
     def model_params
       params.require(:loan_application).permit(
         :bank_id,
-        :category_id,
+        :credit_product_id,
         :backer_type,
         :backer_id,
         :review_branch_id,
@@ -337,7 +337,7 @@ module Dscf::Credit
 
     def eager_loaded_associations
       [
-        :bank, :user, :backer, :review_branch, :loan_profile, :category,
+        :bank, :user, :backer, :review_branch, :loan_profile, :credit_product,
         loan_application_data: [ :information_source ],
         reviews: { reviewed_by: :user_profile },
         audit_logs: :actor
@@ -351,22 +351,22 @@ module Dscf::Credit
     def default_serializer_includes
       {
         index: [
-          :bank, :user, :backer, :review_branch, :loan_profile, :category,
+          :bank, :user, :backer, :review_branch, :loan_profile, :credit_product,
           loan_application_data: [ :information_source ],
           reviews: { reviewed_by: :user_profile }
         ],
         show: [
-          :bank, :user, :backer, :review_branch, :loan_profile, :category,
+          :bank, :user, :backer, :review_branch, :loan_profile, :credit_product,
           loan_application_data: [ :information_source ],
           reviews: { reviewed_by: :user_profile },
           audit_logs: :actor
         ],
         create: [
-          :bank, :user, :backer, :review_branch, :loan_profile, :category, :reviews,
+          :bank, :user, :backer, :review_branch, :loan_profile, :credit_product, :reviews,
           { loan_application_data: [ :information_source ] }
         ],
         update: [
-          :bank, :user, :backer, :review_branch, :loan_profile, :category,
+          :bank, :user, :backer, :review_branch, :loan_profile, :credit_product,
           loan_application_data: [ :information_source ],
           reviews: { reviewed_by: :user_profile }
         ]

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

@@ -27,15 +27,15 @@ module Dscf::Credit
 
     def calculate_facility_limits
       loan_profile = @clazz.find(params[:id])
-      category_id = facility_params[:category_id]
+      credit_product_id = facility_params[:credit_product_id]
 
       return render_error(
         "loan_profile.errors.calculate_facility_limits",
-        errors: [ "Category ID is required" ],
+        errors: [ "Credit Product ID is required" ],
         status: :unprocessable_entity
-      ) unless category_id
+      ) unless credit_product_id
 
-      facility_engine = FacilityLimitCalculationEngine.new(loan_profile.id, category_id)
+      facility_engine = FacilityLimitCalculationEngine.new(loan_profile.id, credit_product_id)
       result = facility_engine.calculate_facility_limits
 
       if result[:success]
@@ -110,7 +110,7 @@ module Dscf::Credit
     end
 
     def facility_params
-      params.permit(:category_id)
+      params.permit(:credit_product_id)
     end
 
     def eager_loaded_associations

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

@@ -69,7 +69,7 @@ module Dscf::Credit
 
     def eager_loaded_associations
       [
-        :bank, :created_by, :parent_template, :scoring_table_parameters, :categories,
+        :bank, :created_by, :parent_template, :scoring_table_parameters, :credit_products,
         reviews: { reviewed_by: :user_profile },
         audit_logs: :actor
       ]
@@ -81,15 +81,15 @@ module Dscf::Credit
 
     def default_serializer_includes
       {
-        index: [ :bank, :categories, reviews: { reviewed_by: :user_profile } ],
+        index: [ :bank, :credit_products, reviews: { reviewed_by: :user_profile } ],
         show: [
-          :bank, :created_by, :parent_template, :scoring_table_parameters, :categories,
+          :bank, :created_by, :parent_template, :scoring_table_parameters, :credit_products,
           reviews: { reviewed_by: :user_profile },
           audit_logs: :actor
         ],
         create: [ :bank, :created_by, :reviews ],
         update: [
-          :bank, :created_by, :categories,
+          :bank, :created_by, :credit_products,
           reviews: { reviewed_by: :user_profile }
         ]
       }

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

@@ -4,10 +4,6 @@ module Dscf
       self.table_name = "dscf_credit_categories"
 
       belongs_to :bank, class_name: "Dscf::Credit::Bank", optional: true
-      belongs_to :scoring_table, class_name: "Dscf::Credit::ScoringTable",
-                 foreign_key: "scoring_table_id", optional: true
-      has_many :credit_lines, class_name: "Dscf::Credit::CreditLine",
-               foreign_key: "category_id", dependent: :nullify
       has_many :scoring_parameters, class_name: "Dscf::Credit::ScoringParameter",
                foreign_key: "category_id", dependent: :nullify
 
@@ -18,11 +14,11 @@ module Dscf
       scope :by_bank, ->(bank_id) { where(bank_id: bank_id) }
 
       def self.ransackable_attributes(auth_object = nil)
-        %w[id category_type name description document_reference bank_id created_at updated_at]
+        %w[id category_type name description bank_id created_at updated_at]
       end
 
       def self.ransackable_associations(auth_object = nil)
-        %w[bank credit_lines scoring_table scoring_parameters]
+        %w[bank scoring_parameters]
       end
     end
   end

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

@@ -6,23 +6,33 @@ module Dscf::Credit
     include Dscf::Core::AuditableModel
 
     belongs_to :bank, class_name: "Dscf::Credit::Bank", foreign_key: "bank_id"
-    belongs_to :category, class_name: "Dscf::Credit::Category", foreign_key: "category_id"
+    belongs_to :credit_product, class_name: "Dscf::Credit::CreditProduct", foreign_key: "credit_product_id"
     belongs_to :created_by, polymorphic: true
 
     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 :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
+    validate :credit_product_must_be_approved, if: -> { credit_product_id_changed? || new_record? }
 
     def self.ransackable_attributes(auth_object = nil)
       %w[id name code description document_reference created_at updated_at]
     end
 
     def self.ransackable_associations(auth_object = nil)
-      %w[bank category created_by credit_line_specs loans eligible_credit_lines scoring_parameters reviews]
+      %w[bank credit_product created_by credit_line_specs loans eligible_credit_lines reviews]
+    end
+
+    private
+
+    def credit_product_must_be_approved
+      return unless credit_product
+
+      unless credit_product.approved?
+        errors.add(:credit_product, "must be approved before creating a credit line")
+      end
     end
   end
 end

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

@@ -0,0 +1,26 @@
+module Dscf
+  module Credit
+    class CreditProduct < ApplicationRecord
+      self.table_name = "dscf_credit_credit_products"
+
+      include Dscf::Core::ReviewableModel
+      include Dscf::Core::AuditableModel
+
+      belongs_to :bank, class_name: "Dscf::Credit::Bank"
+      belongs_to :scoring_table, class_name: "Dscf::Credit::ScoringTable", optional: true
+      has_many :credit_lines, class_name: "Dscf::Credit::CreditLine",
+               foreign_key: :credit_product_id, dependent: :nullify
+
+      validates :name, presence: true, uniqueness: { scope: :bank_id }
+      validates :bank, presence: true
+
+      def self.ransackable_attributes(auth_object = nil)
+        %w[id name description document_reference bank_id scoring_table_id created_at updated_at]
+      end
+
+      def self.ransackable_associations(auth_object = nil)
+        %w[bank scoring_table credit_lines reviews audit_logs]
+      end
+    end
+  end
+end

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

@@ -11,7 +11,7 @@ module Dscf::Credit
     end
     belongs_to :backer, polymorphic: true
     belongs_to :review_branch, class_name: "Dscf::Credit::BankBranch", foreign_key: "review_branch_id"
-    belongs_to :category, class_name: "Dscf::Credit::Category", foreign_key: "category_id", optional: true
+    belongs_to :credit_product, class_name: "Dscf::Credit::CreditProduct", foreign_key: "credit_product_id", optional: true
 
     has_one :loan_profile, class_name: "Dscf::Credit::LoanProfile", foreign_key: "loan_application_id", dependent: :destroy
     has_many :loan_application_data, class_name: "Dscf::Credit::LoanApplicationDatum", foreign_key: "loan_application_id", dependent: :destroy
@@ -26,7 +26,7 @@ module Dscf::Credit
     end
 
     def self.ransackable_associations(auth_object = nil)
-      %w[bank user backer review_branch category loan_profile loan_application_data reviews audit_logs]
+      %w[bank user backer review_branch credit_product loan_profile loan_application_data reviews audit_logs]
     end
   end
 end

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

@@ -11,7 +11,7 @@ module Dscf::Credit
     has_many :scoring_table_parameters, class_name: "Dscf::Credit::ScoringTableParameter", foreign_key: "scoring_table_id", dependent: :destroy
     has_many :scoring_parameters, through: :scoring_table_parameters
     has_many :scoring_results, class_name: "Dscf::Credit::ScoringResult", foreign_key: "scoring_table_id"
-    has_many :categories, class_name: "Dscf::Credit::Category", foreign_key: "scoring_table_id"
+    has_many :credit_products, class_name: "Dscf::Credit::CreditProduct", foreign_key: "scoring_table_id"
 
     validates :code, presence: true, uniqueness: true
     validates :name, presence: true, uniqueness: { scope: :bank_id }
@@ -28,7 +28,7 @@ module Dscf::Credit
     end
 
     def self.ransackable_associations(auth_object = nil)
-      %w[bank created_by parent_template scoring_table_parameters scoring_parameters scoring_results categories reviews audit_logs]
+      %w[bank created_by parent_template scoring_table_parameters scoring_parameters scoring_results credit_products reviews audit_logs]
     end
 
     private

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

@@ -1,11 +1,9 @@
 module Dscf
   module Credit
     class CategorySerializer < ActiveModel::Serializer
-      attributes :id, :category_type, :name, :description, :document_reference, :created_at, :updated_at
+      attributes :id, :category_type, :name, :description, :created_at, :updated_at
 
       belongs_to :bank, serializer: Dscf::Credit::BankSerializer
-      belongs_to :scoring_table, serializer: Dscf::Credit::ScoringTableSerializer
-      has_many :credit_lines, serializer: Dscf::Credit::CreditLineSerializer
       has_many :scoring_parameters, serializer: Dscf::Credit::ScoringParameterSerializer
     end
   end

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

@@ -4,7 +4,7 @@ module Dscf::Credit
                :created_at, :updated_at
 
     belongs_to :bank, serializer: Dscf::Credit::BankSerializer
-    belongs_to :category, serializer: Dscf::Credit::CategorySerializer
+    belongs_to :credit_product, serializer: Dscf::Credit::CreditProductSerializer
     belongs_to :created_by, serializer: Dscf::Core::UserSerializer
     has_many :credit_line_specs, serializer: Dscf::Credit::CreditLineSpecSerializer
     has_many :loans, serializer: Dscf::Credit::LoanSerializer

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

@@ -0,0 +1,13 @@
+module Dscf
+  module Credit
+    class CreditProductSerializer < ActiveModel::Serializer
+      attributes :id, :name, :description, :document_reference, :created_at, :updated_at
+
+      belongs_to :bank, serializer: Dscf::Credit::BankSerializer
+      belongs_to :scoring_table, serializer: Dscf::Credit::ScoringTableSerializer
+      has_many :credit_lines, serializer: Dscf::Credit::CreditLineSerializer
+      has_many :reviews, serializer: Dscf::Core::ReviewSerializer
+      has_many :audit_logs, serializer: Dscf::Core::AuditLogSerializer
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module Dscf::Credit
     belongs_to :user, serializer: Dscf::Core::UserSerializer
     belongs_to :backer, polymorphic: true
     belongs_to :review_branch, serializer: Dscf::Credit::BankBranchSerializer
-    belongs_to :category, serializer: Dscf::Credit::CategorySerializer
+    belongs_to :credit_product, serializer: Dscf::Credit::CreditProductSerializer
     has_many :reviews, serializer: Dscf::Core::ReviewSerializer
     has_many :audit_logs, serializer: Dscf::Core::AuditLogSerializer
     has_many :loan_application_data, serializer: Dscf::Credit::LoanApplicationDatumSerializer

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

@@ -7,7 +7,7 @@ module Dscf::Credit
     belongs_to :bank, serializer: Dscf::Credit::BankSerializer
     belongs_to :created_by, polymorphic: true
     belongs_to :parent_template, serializer: Dscf::Credit::ScoringTableSerializer
-    has_many :categories, serializer: Dscf::Credit::CategorySerializer
+    has_many :credit_products, serializer: Dscf::Credit::CreditProductSerializer
     has_many :scoring_table_parameters
     has_many :reviews, serializer: Dscf::Core::ReviewSerializer
     has_many :audit_logs, serializer: Dscf::Core::AuditLogSerializer

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

@@ -2,14 +2,14 @@ module Dscf::Credit
   class CreditScoringEngine
     def initialize(loan_application)
       @loan_application = loan_application
-      @category = loan_application.category
-      @scoring_table = @category&.scoring_table
+      @credit_product = loan_application.credit_product
+      @scoring_table = @credit_product&.scoring_table
       @data_by_source_id = load_data_by_source
     end
 
     def calculate_score
-      return failure("No category assigned to loan application") unless @category
-      return failure("No scoring table configured for category '#{@category.name}'") unless @scoring_table
+      return failure("No credit product assigned to loan application") unless @credit_product
+      return failure("No scoring table configured for credit product '#{@credit_product.name}'") unless @scoring_table
 
       parameters = @scoring_table.scoring_table_parameters
                                   .includes(:scoring_parameter, :scoring_table_normalizers, :information_source)

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

@@ -1,18 +1,18 @@
 module Dscf::Credit
   class FacilityLimitCalculationEngine
-    attr_reader :loan_profile, :category_id, :errors
+    attr_reader :loan_profile, :credit_product_id, :errors
 
-    def initialize(loan_profile_id, category_id)
+    def initialize(loan_profile_id, credit_product_id)
       @errors = []
       @loan_profile = LoanProfile.find(loan_profile_id)
-      @category_id = category_id
+      @credit_product_id = credit_product_id
     rescue ActiveRecord::RecordNotFound => e
       @errors << "Loan profile not found: \#{e.message}"
     end
 
     def calculate_facility_limits
       return error_result("Loan profile is required") unless loan_profile
-      return error_result("Category ID is required") unless category_id
+      return error_result("Credit Product ID is required") unless credit_product_id
 
       begin
         ActiveRecord::Base.transaction do
@@ -22,7 +22,7 @@ module Dscf::Credit
 
           credit_lines = get_credit_lines_for_calculation
           if credit_lines.empty?
-            return error_result("No credit lines found for category \#{category_id} and bank \#{loan_profile.loan_application.bank_id}")
+            return error_result("No credit lines found for credit product #{credit_product_id} and bank #{loan_profile.loan_application.bank_id}")
           end
 
           eligible_credit_lines = []
@@ -67,9 +67,9 @@ module Dscf::Credit
     private
 
     def get_credit_lines_for_calculation
-      CreditLine.joins(:category, :credit_line_specs)
+      CreditLine.joins(:credit_product, :credit_line_specs)
                 .where(
-                  category_id: category_id,
+                  credit_product_id: credit_product_id,
                   bank_id: loan_profile.loan_application.bank_id,
                   dscf_credit_credit_line_specs: { active: true }
                 )
@@ -161,9 +161,9 @@ module Dscf::Credit
     end
 
     def get_scoring_table
-      category = Category.find_by(id: category_id)
-      return nil unless category&.scoring_table_id
-      ScoringTable.find_by(id: category.scoring_table_id)
+      credit_product = CreditProduct.find_by(id: credit_product_id)
+      return nil unless credit_product&.scoring_table_id
+      ScoringTable.find_by(id: credit_product.scoring_table_id)
     end
 
     def update_loan_profile_total_limit

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

@@ -82,10 +82,10 @@ module Dscf::Credit
     end
 
     def calculate_facility_limits(loan_profile)
-      category = @loan_application.category
-      return unless category
+      credit_product = @loan_application.credit_product
+      return unless credit_product
 
-      engine = FacilityLimitCalculationEngine.new(loan_profile.id, category.id)
+      engine = FacilityLimitCalculationEngine.new(loan_profile.id, credit_product.id)
       result = engine.calculate_facility_limits
 
       unless result[:success]

data/config/locales/en.yml

@@ -179,6 +179,30 @@ en:
       update: "Failed to update credit line specification"
       destroy: "Failed to delete credit line specification"
 
+  credit_product:
+    success:
+      index: "Credit products retrieved successfully"
+      show: "Credit product details retrieved successfully"
+      create: "Credit product created successfully"
+      update: "Credit product updated successfully"
+      submit: "Credit product submitted for review successfully"
+      approve: "Credit product approved successfully"
+      reject: "Credit product rejected successfully"
+      destroy: "Credit product deleted successfully"
+      request_modification: "Modification requested for credit product successfully"
+      resubmit: "Credit product resubmitted successfully"
+    errors:
+      index: "Failed to retrieve credit products"
+      show: "Failed to retrieve credit product details"
+      create: "Failed to create credit product"
+      update: "Failed to update credit product"
+      submit: "Failed to submit credit product for review"
+      approve: "Failed to approve credit product"
+      reject: "Failed to reject credit product"
+      destroy: "Failed to delete credit product"
+      request_modification: "Failed to request modification for credit product"
+      resubmit: "Failed to resubmit credit product"
+
   credit_line:
     success:
       index: "Credit lines retrieved successfully"