dscf-credit 0.1.4 → 0.1.6

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

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

@@ -4,7 +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
+    has_many :loan_applications, class_name: "Dscf::Credit::LoanApplication", foreign_key: "review_branch_id", dependent: :nullify
 
     validates :branch_name, presence: true
     validates :branch_name, uniqueness: { scope: :bank_id }

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

@@ -4,8 +4,7 @@ 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
+    has_many :scoring_parameters, class_name: "Dscf::Credit::ScoringParameter", foreign_key: "category_id", dependent: :nullify
 
     validates :type, :name, presence: true
     validates :name, uniqueness: { scope: :type }

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

@@ -2,10 +2,11 @@ module Dscf::Credit
   class CreditLine < ApplicationRecord
     self.table_name = "dscf_credit_credit_lines"
 
+    include Dscf::Core::ReviewableModel
+
     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 :created_by, polymorphic: true
-    belongs_to :reviewed_by, polymorphic: true, optional: 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
@@ -14,20 +15,13 @@ module Dscf::Credit
 
     validates :name, presence: true
     validates :code, uniqueness: { scope: :bank_id }, allow_blank: true
-    validates :status, inclusion: { in: %w[pending approved active suspended rejected modify] }
-    enum :status, { pending: "pending", approved: "approved", rejected: "rejected", modify: "modify", active: "active", suspended: "suspended" }
-
-
-    scope :active, -> { where(status: "active") }
-    scope :approved, -> { where(status: "approved") }
-    scope :pending, -> { where(status: "pending") }
 
     def self.ransackable_attributes(auth_object = nil)
-      %w[id name code description status review_date review_feedback document_reference created_at updated_at]
+      %w[id name code description document_reference created_at updated_at]
     end
 
     def self.ransackable_associations(auth_object = nil)
-      %w[bank category created_by reviewed_by credit_line_specs loans eligible_credit_lines scoring_parameters]
+      %w[bank category created_by credit_line_specs loans eligible_credit_lines scoring_parameters reviews]
     end
   end
 end

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

@@ -6,10 +6,10 @@ module Dscf::Credit
     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 :credit_limit, numericality: { greater_than_or_equal_to: 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
+    validates :risk, numericality: { greater_than_or_equal_to: 0.0, 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) }

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

@@ -1,32 +1,21 @@
 module Dscf::Credit
   class Facilitator < ApplicationRecord
     self.table_name = "dscf_credit_facilitators"
-    self.inheritance_column = nil  # Disable STI since 'type' is a business attribute
 
-    belongs_to :bank, class_name: "Dscf::Credit::Bank", foreign_key: "bank_id"
-    belongs_to :kyc_reviewed_by, polymorphic: true
-    if defined?(Dscf::Core::User)
-      belongs_to :user, class_name: "Dscf::Core::User", foreign_key: "user_id"
-    end
+    include Dscf::Core::ReviewableModel
+
+    belongs_to :facilitator_application, class_name: "Dscf::Credit::FacilitatorApplication", foreign_key: "facilitator_application_id"
     has_many :facilitator_performances, class_name: "Dscf::Credit::FacilitatorPerformance", foreign_key: "facilitator_id", dependent: :destroy
 
-    validates :name, :type, presence: true
-    validates :type, inclusion: { in: %w[individual corporate agent] }
-    validates :user_id, uniqueness: { scope: :bank_id }
     validates :total_limit, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true
-
-    enum :kyc_status, { pending: "pending", approved: "approved", rejected: "rejected" }
-
-    scope :approved, -> { where(kyc_status: "approved") }
-    scope :pending_kyc, -> { where(kyc_status: "pending") }
-    scope :rejected, -> { where(kyc_status: "rejected") }
+    validates :facilitator_application_id, uniqueness: true
 
     def self.ransackable_attributes(auth_object = nil)
-      %w[id name type total_limit kyc_status kyc_review_date review_feedback created_at updated_at]
+      %w[id total_limit created_at updated_at facilitator_application_id]
     end
 
     def self.ransackable_associations(auth_object = nil)
-      %w[bank user kyc_reviewed_by facilitator_performances]
+      %w[facilitator_application facilitator_performances reviews]
     end
   end
 end

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

@@ -0,0 +1,20 @@
+module Dscf::Credit
+  class FacilitatorApplication < ApplicationRecord
+    self.table_name = "dscf_credit_facilitator_applications"
+
+    include Dscf::Core::ReviewableModel
+
+    belongs_to :user, class_name: "Dscf::Core::User", foreign_key: "user_id"
+    belongs_to :bank, class_name: "Dscf::Credit::Bank", foreign_key: "bank_id"
+
+    validates :facilitator_info, presence: true
+
+    def self.ransackable_attributes(auth_object = nil)
+      %w[id user_id bank_id created_at updated_at]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[user bank reviews]
+    end
+  end
+end

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

@@ -4,7 +4,6 @@ module Dscf::Credit
 
     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"
-    belongs_to :payment_request, class_name: "Dscf::Credit::PaymentRequest", foreign_key: "payment_request_id"
     has_many :loan_transactions, class_name: "Dscf::Credit::LoanTransaction", foreign_key: "loan_id", dependent: :destroy
     has_many :daily_routine_transactions, class_name: "Dscf::Credit::DailyRoutineTransaction", foreign_key: "loan_id", dependent: :destroy
 
@@ -13,18 +12,19 @@ module Dscf::Credit
     validates :accrued_interest, :accrued_penalty, :facilitation_fee, numericality: { greater_than_or_equal_to: 0 }
     validates :status, inclusion: { in: %w[pending approved disbursed active overdue paid closed] }
 
-    scope :active, -> { where(status: "active") }
+    scope :active, -> { where(active: true) }
+    scope :inactive, -> { where(active: false) }
     scope :overdue, -> { where(status: "overdue") }
     scope :paid, -> { where(status: "paid") }
     scope :due_today, -> { where(due_date: Date.current) }
     scope :past_due, -> { where("due_date < ? AND status IN (?)", Date.current, [ "active", "overdue" ]) }
 
     def self.ransackable_attributes(auth_object = nil)
-      %w[id status principal_amount accrued_interest accrued_penalty facilitation_fee total_loan_amount remaining_amount due_date disbursed_at created_at updated_at]
+      %w[id status principal_amount accrued_interest accrued_penalty facilitation_fee total_loan_amount remaining_amount due_date disbursed_at active created_at updated_at]
     end
 
     def self.ransackable_associations(auth_object = nil)
-      %w[loan_profile credit_line payment_request loan_transactions daily_routine_transactions]
+      %w[loan_profile credit_line loan_transactions daily_routine_transactions]
     end
 
     delegate :user, to: :loan_profile, allow_nil: true

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

@@ -0,0 +1,30 @@
+module Dscf::Credit
+  class LoanApplication < ApplicationRecord
+    self.table_name = "dscf_credit_loan_applications"
+
+    include Dscf::Core::ReviewableModel
+
+    belongs_to :bank, class_name: "Dscf::Credit::Bank", foreign_key: "bank_id"
+    if defined?(Dscf::Core::User)
+      belongs_to :user, class_name: "Dscf::Core::User", foreign_key: "user_id"
+    end
+    belongs_to :backer, polymorphic: true
+    belongs_to :review_branch, class_name: "Dscf::Credit::BankBranch", foreign_key: "review_branch_id"
+
+    has_one :loan_profile, class_name: "Dscf::Credit::LoanProfile", foreign_key: "loan_application_id", dependent: :destroy
+
+    has_many_attached :bank_statement_attachments
+
+    validates :bank_statement_source, presence: true, inclusion: { in: %w[internal external] }
+    validates :user_info, presence: true
+    validates :score, numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 100 }, allow_nil: true
+
+    def self.ransackable_attributes(auth_object = nil)
+      %w[id bank_statement_source score created_at updated_at]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[bank user backer review_branch loan_profile reviews]
+    end
+  end
+end

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

@@ -2,46 +2,26 @@ module Dscf::Credit
   class LoanProfile < ApplicationRecord
     self.table_name = "dscf_credit_loan_profiles"
 
-    belongs_to :bank, class_name: "Dscf::Credit::Bank", foreign_key: "bank_id"
-    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
+    include Dscf::Core::ReviewableModel
+
+    belongs_to :loan_application, class_name: "Dscf::Credit::LoanApplication", foreign_key: "loan_application_id"
     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 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
+    validates :score, numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 100 }, allow_nil: true
+    validates :total_limit, numericality: { greater_than_or_equal_to: 0 }
+    validates :code, presence: true, uniqueness: true, length: { maximum: 8 }, format: { with: /\ABB\d{0,6}\z/, message: "must start with BB followed by up to 6 digits" }
 
-    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") }
-    scope :by_total_amount_range, ->(min, max) { where(total_amount: min..max) }
-    scope :by_available_amount_range, ->(min, max) { where(available_amount: min..max) }
+    scope :with_score_range, ->(min, max) { where(score: min..max) }
+    scope :by_total_limit_range, ->(min, max) { where(total_limit: 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 review_branch_id]
+      %w[id code score total_limit created_at updated_at loan_application_id]
     end
 
     def self.ransackable_associations(auth_object = nil)
-      %w[bank user backer reviewed_by review_branch loan_profile_scoring_specs loans eligible_credit_lines]
-    end
-
-    private
-
-    def available_amount_not_greater_than_total_amount
-      return unless total_amount && available_amount
-
-      errors.add(:available_amount, "cannot be greater than total amount") if available_amount > total_amount
+      %w[loan_application loan_profile_scoring_specs loans eligible_credit_lines reviews]
     end
   end
 end

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

@@ -6,6 +6,6 @@ module Dscf::Credit
 
     validates :name, :raw_value, :normalized_value, presence: true
     validates :raw_value, uniqueness: { scope: :scoring_parameter_id }
-    validates :normalized_value, numericality: { greater_than_or_equal_to: 0 }
+    validates :normalized_value, numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 1 }
   end
 end

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

@@ -2,30 +2,28 @@ module Dscf::Credit
   class ScoringParameter < ApplicationRecord
     self.table_name = "dscf_credit_scoring_parameters"
 
+    include Dscf::Core::ReviewableModel
+
     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 :created_by, polymorphic: true
-    belongs_to :reviewed_by, polymorphic: true
     belongs_to :scoring_param_type, class_name: "Dscf::Credit::ScoringParamType", foreign_key: "scoring_param_type_id"
     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 :categories, through: :scoring_tables
 
     validates :name, :data_type, :weight, presence: true
     validates :weight, numericality: { greater_than: 0, less_than_or_equal_to: 1 }
     validates :data_type, inclusion: { in: %w[integer decimal boolean string] }
     validates :name, uniqueness: { scope: [ :bank_id, :active ] }
-    validates :status, inclusion: { in: %w[pending approved rejected modify] }
-    enum :status, { pending: "pending", approved: "approved", rejected: "rejected", modify: "modify" }
 
     scope :active, -> { where(active: true) }
 
     def self.ransackable_attributes(auth_object = nil)
-      %w[id name description data_type weight min_value max_value active status review_date review_feedback source document_reference created_at updated_at]
+      %w[id name description data_type weight min_value max_value active source document_reference created_at updated_at]
     end
 
     def self.ransackable_associations(auth_object = nil)
-      %w[bank created_by reviewed_by scoring_param_type previous_version parameter_normalizers scoring_tables categories]
+      %w[bank created_by scoring_param_type previous_version parameter_normalizers categories reviews]
     end
   end
 end

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

@@ -2,25 +2,20 @@ module Dscf::Credit
   class SystemConfig < ApplicationRecord
     self.table_name = "dscf_credit_system_configs"
 
+    include Dscf::Core::ReviewableModel
+
     belongs_to :config_definition, class_name: "Dscf::Credit::SystemConfigDefinition", foreign_key: "config_definition_id"
     belongs_to :last_updated_by, polymorphic: true
-    belongs_to :reviewed_by, polymorphic: true
 
     validates :config_value, presence: true
-    validates :status, inclusion: { in: %w[pending approved rejected modify] }
-    enum :status, { pending: "pending", approved: "approved", rejected: "rejected", modify: "modify" }
     validates :config_definition_id, uniqueness: true
 
-    scope :pending, -> { where(status: "pending") }
-    scope :approved, -> { where(status: "approved") }
-    scope :rejected, -> { where(status: "rejected") }
-
     def self.ransackable_attributes(auth_object = nil)
-      %w[id config_value status review_date review_feedback created_at updated_at]
+      %w[id config_value created_at updated_at]
     end
 
     def self.ransackable_associations(auth_object = nil)
-      %w[config_definition last_updated_by reviewed_by]
+      %w[config_definition last_updated_by reviews]
     end
   end
 end

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

@@ -3,7 +3,6 @@ module Dscf::Credit
     attributes :id, :type, :name, :description, :document_reference, :created_at, :updated_at
 
     has_many :credit_lines, serializer: Dscf::Credit::CreditLineSerializer
-    has_many :scoring_tables, serializer: Dscf::Credit::ScoringTableSerializer
     has_many :scoring_parameters, serializer: Dscf::Credit::ScoringParameterSerializer
   end
 end

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

@@ -1,14 +1,14 @@
 module Dscf::Credit
   class CreditLineSerializer < ActiveModel::Serializer
-    attributes :id, :name, :code, :description, :status, :review_date, :review_feedback, :document_reference,
+    attributes :id, :name, :code, :description, :document_reference,
                :created_at, :updated_at
 
     belongs_to :bank, serializer: Dscf::Credit::BankSerializer
     belongs_to :category, serializer: Dscf::Credit::CategorySerializer
     belongs_to :created_by, serializer: Dscf::Core::UserSerializer
-    belongs_to :reviewed_by, serializer: Dscf::Core::UserSerializer
     has_many :credit_line_specs, serializer: Dscf::Credit::CreditLineSpecSerializer
     has_many :loans, serializer: Dscf::Credit::LoanSerializer
     has_many :eligible_credit_lines, serializer: Dscf::Credit::EligibleCreditLineSerializer
+    has_many :reviews, serializer: Dscf::Core::ReviewSerializer
   end
 end

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

@@ -0,0 +1,7 @@
+class Dscf::Credit::FacilitatorApplicationSerializer < ActiveModel::Serializer
+  attributes :id, :user_id, :bank_id, :facilitator_info, :created_at, :updated_at
+
+  belongs_to :user, serializer: Dscf::Core::UserSerializer
+  belongs_to :bank, serializer: Dscf::Credit::BankSerializer
+  has_many :reviews, serializer: Dscf::Core::ReviewSerializer
+end

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

@@ -1,11 +1,8 @@
 module Dscf::Credit
   class FacilitatorSerializer < ActiveModel::Serializer
-    attributes :id, :name, :type, :total_limit, :kyc_status, :kyc_review_date, :review_feedback,
-               :created_at, :updated_at
+    attributes :id, :total_limit, :created_at, :updated_at
 
-    belongs_to :user, serializer: Dscf::Core::UserSerializer
-    belongs_to :bank, serializer: Dscf::Credit::BankSerializer
-    belongs_to :kyc_reviewed_by, polymorphic: true
-    has_many :facilitator_performances, serializer: Dscf::Credit::FacilitatorPerformanceSerializer
+    belongs_to :facilitator_application, serializer: Dscf::Credit::FacilitatorApplicationSerializer
+    has_many :reviews, serializer: Dscf::Core::ReviewSerializer
   end
 end

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

@@ -0,0 +1,12 @@
+module Dscf::Credit
+  class LoanApplicationSerializer < ActiveModel::Serializer
+    attributes :id, :bank_statement_source, :score, :user_info, :facilitator_info,
+               :bank_info, :field_assessment, :created_at, :updated_at
+
+    belongs_to :bank, serializer: Dscf::Credit::BankSerializer
+    belongs_to :user, serializer: Dscf::Core::UserSerializer
+    belongs_to :backer, polymorphic: true
+    belongs_to :review_branch, serializer: Dscf::Credit::BankBranchSerializer
+    has_many :reviews, serializer: Dscf::Core::ReviewSerializer
+  end
+end

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

@@ -1,13 +1,10 @@
 module Dscf::Credit
   class LoanProfileSerializer < ActiveModel::Serializer
-    attributes :id, :status, :total_amount, :available_amount, :review_date, :review_feedback, :created_at, :updated_at
+    attributes :id, :code, :score, :total_limit, :created_at, :updated_at
 
-    belongs_to :bank, serializer: Dscf::Credit::BankSerializer
-    belongs_to :review_branch, serializer: Dscf::Credit::BankBranchSerializer
-    belongs_to :reviewed_by
-    belongs_to :backer
-    belongs_to :user, serializer: Dscf::Core::UserSerializer
+    belongs_to :loan_application, serializer: Dscf::Credit::LoanApplicationSerializer
 
+    has_many :reviews, serializer: Dscf::Core::ReviewSerializer
     has_many :loan_profile_scoring_specs, serializer: Dscf::Credit::LoanProfileScoringSpecSerializer
     has_many :loans, serializer: Dscf::Credit::LoanSerializer
     has_many :eligible_credit_lines, serializer: Dscf::Credit::EligibleCreditLineSerializer