dscf-credit 0.1.1 → 0.1.3

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_param_types_controller.rb

@@ -0,0 +1,31 @@
+module Dscf::Credit
+  class ScoringParamTypesController < ApplicationController
+    include Dscf::Core::Common
+
+    private
+
+    def model_params
+      params.require(:scoring_param_type).permit(
+        :name,
+        :description
+      )
+    end
+
+    def eager_loaded_associations
+      [ :scoring_parameters ]
+    end
+
+    def allowed_order_columns
+      %w[id name created_at updated_at]
+    end
+
+    def default_serializer_includes
+      {
+        index: [],
+        show: [ :scoring_parameters ],
+        create: [],
+        update: [ :scoring_parameters ]
+      }
+    end
+  end
+end

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

@@ -1,12 +1,13 @@
 module Dscf::Credit
   class ScoringParametersController < ApplicationController
     include Dscf::Core::Common
+    include Dscf::Credit::Reviewable
 
     def create
       super do
         scoring_parameter = @clazz.new(model_params)
         scoring_parameter.created_by = current_user
-        scoring_parameter.approved_by = current_user
+        scoring_parameter.reviewed_by = current_user
 
         scoring_parameter
       end
@@ -20,30 +21,34 @@ module Dscf::Credit
         :name,
         :description,
         :data_type,
-        :type,
         :weight,
         :min_value,
         :max_value,
         :active,
         :previous_version_id,
-        :expires_at
+        :review_date,
+        :source,
+        :scoring_param_type_id,
+        :document_reference,
+        :status,
+        :review_feedback
       )
     end
 
     def eager_loaded_associations
-      [ :bank, :created_by, :approved_by, :previous_version, :parameter_normalizers ]
+      [ :bank, :created_by, :reviewed_by, :scoring_param_type, :previous_version, :parameter_normalizers, :scoring_tables, :categories ]
     end
 
     def allowed_order_columns
-      %w[id name data_type type weight active expires_at created_at updated_at]
+      %w[id name data_type weight active review_date created_at updated_at]
     end
 
     def default_serializer_includes
       {
         index: [ :bank ],
-        show: [ :bank, :created_by, :approved_by, :previous_version, :parameter_normalizers ],
-        create: [ :bank, :created_by, :approved_by ],
-        update: [ :bank, :created_by, :approved_by, :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, :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/system_configs_controller.rb

@@ -1,11 +1,12 @@
 module Dscf::Credit
   class SystemConfigsController < ApplicationController
     include Dscf::Core::Common
+    include Dscf::Credit::Reviewable
 
     def create
       super do
         obj = @clazz.new(model_params)
-        obj.approved_by = current_user
+        obj.reviewed_by = current_user
         obj.last_updated_by = current_user
         obj
       end
@@ -25,24 +26,26 @@ module Dscf::Credit
       params.require(:system_config).permit(
         :config_definition_id,
         :config_value,
-        :status
+        :status,
+        :review_date,
+        :review_feedback
       )
     end
 
     def eager_loaded_associations
-      [ :config_definition, :last_updated_by, :approved_by ]
+      [ :config_definition, :last_updated_by, :reviewed_by ]
     end
 
     def allowed_order_columns
-      %w[id config_value status created_at updated_at]
+      %w[id config_value status review_date created_at updated_at]
     end
 
     def default_serializer_includes
       {
         index: [ :config_definition ],
-        show: [ :config_definition, :last_updated_by, :approved_by ],
-        create: [ :config_definition, :last_updated_by, :approved_by ],
-        update: [ :config_definition, :last_updated_by, :approved_by ]
+        show: [ :config_definition, :last_updated_by, :reviewed_by ],
+        create: [ :config_definition, :last_updated_by, :reviewed_by ],
+        update: [ :config_definition, :last_updated_by, :reviewed_by ]
       }
     end
   end

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 }
@@ -11,11 +13,11 @@ module Dscf::Credit
     scope :by_type, ->(category_type) { where(type: category_type) }
 
     def self.ransackable_attributes(auth_object = nil)
-      %w[id type name description created_at updated_at]
+      %w[id type name description document_reference created_at updated_at]
     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

@@ -5,26 +5,29 @@ module Dscf::Credit
     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 :approved_by, polymorphic: true, optional: 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
-    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
-    validates :status, inclusion: { in: %w[pending approved active suspended] }
+    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 approval_date created_at updated_at]
+      %w[id name code description status review_date review_feedback document_reference created_at updated_at]
     end
 
     def self.ransackable_associations(auth_object = nil)
-      %w[bank category created_by approved_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/facilitator.rb

@@ -4,7 +4,7 @@ module Dscf::Credit
     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_approved_by, polymorphic: true
+    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
@@ -12,20 +12,21 @@ module Dscf::Credit
 
     validates :name, :type, presence: true
     validates :type, inclusion: { in: %w[individual corporate agent] }
-    validates :kyc_status, inclusion: { in: %w[pending approved rejected] }
     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") }
 
     def self.ransackable_attributes(auth_object = nil)
-      %w[id name type total_limit kyc_status created_at updated_at]
+      %w[id name type total_limit kyc_status kyc_review_date review_feedback created_at updated_at]
     end
 
     def self.ransackable_associations(auth_object = nil)
-      %w[bank user kyc_approved_by facilitator_performances]
+      %w[bank user kyc_reviewed_by facilitator_performances]
     end
   end
 end

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

@@ -11,7 +11,6 @@ module Dscf::Credit
     validates :score, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true
 
     scope :requiring_approval, -> { where(approval_required: true) }
-    scope :expired, -> { where("expires_at < ?", Time.current) }
-    scope :current, -> { where("expires_at IS NULL OR expires_at > ?", Time.current) }
+    scope :current, -> { where("created_at > ?", 30.days.ago) }  # Assuming current means recent
   end
 end

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

@@ -3,21 +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 :approved_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] }
+    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") }
@@ -25,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 rejection_reason 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 approved_by 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,20 +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 :approved_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) }
-    scope :expired, -> { where("expires_at < ?", Time.current) }
 
     def self.ransackable_attributes(auth_object = nil)
-      %w[id score active expires_at 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 approved_by]
+      %w[loan_profile created_by]
     end
   end
 end

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

@@ -0,0 +1,17 @@
+module Dscf::Credit
+  class ScoringParamType < ApplicationRecord
+    self.table_name = "dscf_credit_scoring_param_types"
+
+    has_many :scoring_parameters, class_name: "Dscf::Credit::ScoringParameter", foreign_key: "scoring_param_type_id", dependent: :restrict_with_error
+
+    validates :name, presence: true, uniqueness: true
+
+    def self.ransackable_attributes(auth_object = nil)
+      %w[id name description created_at updated_at]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[scoring_parameters]
+    end
+  end
+end

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

@@ -1,30 +1,31 @@
 module Dscf::Credit
   class ScoringParameter < ApplicationRecord
     self.table_name = "dscf_credit_scoring_parameters"
-    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 :created_by, polymorphic: true
-    belongs_to :approved_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 :credit_lines, through: :scoring_tables
+    has_many :categories, through: :scoring_tables
 
-    validates :name, :data_type, :type, :weight, presence: true
+    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 :type, inclusion: { in: %w[income credit_history employment_status collateral] }
     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 type weight min_value max_value active expires_at created_at updated_at]
+      %w[id name description data_type weight min_value max_value active status review_date review_feedback source document_reference created_at updated_at]
     end
 
     def self.ransackable_associations(auth_object = nil)
-      %w[bank created_by approved_by 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/models/dscf/credit/system_config.rb

@@ -4,10 +4,11 @@ module Dscf::Credit
 
     belongs_to :config_definition, class_name: "Dscf::Credit::SystemConfigDefinition", foreign_key: "config_definition_id"
     belongs_to :last_updated_by, polymorphic: true
-    belongs_to :approved_by, polymorphic: true
+    belongs_to :reviewed_by, polymorphic: true
 
     validates :config_value, presence: true
-    validates :status, inclusion: { in: %w[pending approved rejected] }
+    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") }
@@ -15,11 +16,11 @@ module Dscf::Credit
     scope :rejected, -> { where(status: "rejected") }
 
     def self.ransackable_attributes(auth_object = nil)
-      %w[id config_value status created_at updated_at]
+      %w[id config_value status review_date review_feedback created_at updated_at]
     end
 
     def self.ransackable_associations(auth_object = nil)
-      %w[config_definition last_updated_by approved_by]
+      %w[config_definition last_updated_by reviewed_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

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

@@ -1,7 +1,9 @@
 module Dscf::Credit
   class CategorySerializer < ActiveModel::Serializer
-    attributes :id, :type, :name, :description, :created_at, :updated_at
+    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,12 +1,14 @@
 module Dscf::Credit
   class CreditLineSerializer < ActiveModel::Serializer
-    attributes :id, :name, :code, :description, :status, :approval_date,
+    attributes :id, :name, :code, :description, :status, :review_date, :review_feedback, :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 :approved_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
   end
 end

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

@@ -1,7 +1,7 @@
 module Dscf::Credit
   class CreditLineSpecSerializer < ActiveModel::Serializer
     attributes :id, :min_amount, :max_amount, :interest_rate, :penalty_rate,
-               :facilitation_fee_rate, :tax_rate, :max_penalty_days,
+               :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