dscf-credit 0.1.0

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

@@ -0,0 +1,18 @@
+module Dscf::Credit
+  class DailyRoutineTransaction < ApplicationRecord
+    self.table_name = "dscf_credit_daily_routine_transactions"
+
+    belongs_to :loan, class_name: "Dscf::Credit::Loan", foreign_key: "loan_id"
+
+    validates :routine_type, :amount, :status, presence: true
+    validates :amount, numericality: { greater_than: 0 }
+    validates :status, inclusion: { in: %w[pending processing completed failed] }
+    validates :routine_type, inclusion: {
+      in: %w[interest_calculation penalty_assessment payment_due_notification],
+      message: "%{value} is not a valid routine type"
+    }
+
+    scope :by_status, ->(status) { where(status: status) }
+    scope :by_routine_type, ->(type) { where(routine_type: type) }
+  end
+end

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

@@ -0,0 +1,31 @@
+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_approved_by, polymorphic: true
+    if defined?(Dscf::Core::User)
+      belongs_to :user, class_name: "Dscf::Core::User", foreign_key: "user_id"
+    end
+    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 :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
+
+    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]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[bank user kyc_approved_by facilitator_performances]
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Dscf::Credit
+  class FacilitatorPerformance < ApplicationRecord
+    self.table_name = "dscf_credit_facilitator_performances"
+
+    belongs_to :facilitator, class_name: "Dscf::Credit::Facilitator", foreign_key: "facilitator_id"
+    belongs_to :created_by, polymorphic: true
+
+    validates :total_outstanding_loans, :total_outstanding_amount, presence: true
+    validates :total_outstanding_loans, numericality: { greater_than_or_equal_to: 0 }
+    validates :total_outstanding_amount, numericality: { greater_than_or_equal_to: 0 }
+    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) }
+  end
+end

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

@@ -0,0 +1,17 @@
+module Dscf::Credit
+  class FailedOperationsLog < ApplicationRecord
+    self.table_name = "dscf_credit_failed_operations_logs"
+
+    belongs_to :entity, polymorphic: true
+
+    validates :failure_type, :reason, presence: true
+    validates :failure_type, inclusion: {
+      in: %w[loan_disbursement payment_processing interest_calculation credit_scoring daily_routine accounting_entry]
+    }
+    validates :retry_count, numericality: { greater_than_or_equal_to: 0 }
+
+    scope :by_failure_type, ->(type) { where(failure_type: type) }
+    scope :resolved, -> { where(resolved: true) }
+    scope :unresolved, -> { where(resolved: false) }
+  end
+end

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

@@ -0,0 +1,33 @@
+module Dscf::Credit
+  class Loan < ApplicationRecord
+    self.table_name = "dscf_credit_loans"
+
+    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
+
+    validates :principal_amount, :total_loan_amount, :remaining_amount, :due_date, presence: true
+    validates :principal_amount, :total_loan_amount, :remaining_amount, numericality: { greater_than: 0 }
+    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 :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]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[loan_profile credit_line payment_request loan_transactions daily_routine_transactions]
+    end
+
+    delegate :user, to: :loan_profile, allow_nil: true
+    delegate :bank, to: :credit_line, allow_nil: true
+  end
+end

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

@@ -0,0 +1,43 @@
+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 :approved_by, polymorphic: 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
+
+    validates :status, inclusion: { in: %w[pending approved rejected kyc_approved 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 :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) }
+
+    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]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[bank user backer approved_by reviewed_by loan_profile_scoring_specs loans]
+    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
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Dscf::Credit
+  class LoanProfileScoringSpec < ApplicationRecord
+    self.table_name = "dscf_credit_loan_profile_scoring_specs"
+
+    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 }
+
+    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]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[loan_profile created_by approved_by]
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Dscf::Credit
+  class LoanTransaction < ApplicationRecord
+    self.table_name = "dscf_credit_loan_transactions"
+
+    belongs_to :loan, class_name: "Dscf::Credit::Loan", foreign_key: "loan_id"
+
+    validates :transaction_type, :amount, :transaction_reference, :status, presence: true
+    validates :amount, numericality: { greater_than: 0 }
+    validates :transaction_type, inclusion: { in: %w[disbursement repayment interest_accrual penalty fee_charge] }
+    validates :status, inclusion: { in: %w[pending processing completed failed reversed] }
+    validates :transaction_reference, uniqueness: true
+
+    scope :by_status, ->(status) { where(status: status) }
+    scope :disbursements, -> { where(transaction_type: "disbursement") }
+    scope :repayments, -> { where(transaction_type: "repayment") }
+  end
+end

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

@@ -0,0 +1,11 @@
+module Dscf::Credit
+  class ParameterNormalizer < ApplicationRecord
+    self.table_name = "dscf_credit_parameter_normalizers"
+
+    belongs_to :scoring_parameter, class_name: "Dscf::Credit::ScoringParameter", foreign_key: "scoring_parameter_id"
+
+    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 }
+  end
+end

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

@@ -0,0 +1,22 @@
+module Dscf::Credit
+  class Payment < ApplicationRecord
+    self.table_name = "dscf_credit_payments"
+
+    belongs_to :payment_request, class_name: "Dscf::Credit::PaymentRequest", foreign_key: "payment_request_id"
+
+    validates :amount, :receiver_account_reference, :transaction_reference, :status, presence: true
+    validates :amount, numericality: { greater_than: 0 }
+    validates :status, inclusion: { in: %w[pending processing completed failed cancelled] }
+    validates :transaction_reference, uniqueness: true
+
+    scope :by_status, ->(status) { where(status: status) }
+
+    def self.ransackable_attributes(auth_object = nil)
+      %w[id amount receiver_account_reference transaction_reference status failure_reason processed_at created_at updated_at]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[payment_request]
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Dscf::Credit
+  class PaymentRequest < ApplicationRecord
+    self.table_name = "dscf_credit_payment_requests"
+
+    if defined?(Dscf::Core::User)
+      belongs_to :user, class_name: "Dscf::Core::User", foreign_key: "user_id"
+    end
+    has_many :loans, class_name: "Dscf::Credit::Loan", foreign_key: "payment_request_id", dependent: :destroy
+    has_many :payments, class_name: "Dscf::Credit::Payment", foreign_key: "payment_request_id", dependent: :destroy
+
+    validates :order_id, presence: true, uniqueness: true
+    validates :request_type, :amount, :receiver_account_reference, presence: true
+    validates :amount, numericality: { greater_than: 0 }
+    validates :status, inclusion: { in: %w[pending approved rejected processed failed] }
+
+    scope :pending, -> { where(status: "pending") }
+    scope :approved, -> { where(status: "approved") }
+    scope :processed, -> { where(status: "processed") }
+    scope :failed, -> { where(status: "failed") }
+
+    def self.ransackable_attributes(auth_object = nil)
+      %w[id order_id request_type amount receiver_account_reference status failure_reason initiated_at approved_at created_at updated_at]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[user loans payments]
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+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 :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
+
+    validates :name, :data_type, :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 ] }
+
+    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]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[bank created_by approved_by previous_version parameter_normalizers scoring_tables credit_lines]
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+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 :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 }
+
+    scope :active, -> { where(active: true) }
+    scope :by_credit_line, ->(credit_line_id) { where(credit_line_id: credit_line_id) }
+    scope :by_scoring_parameter, ->(scoring_parameter_id) { where(scoring_parameter_id: scoring_parameter_id) }
+
+    def self.ransackable_attributes(auth_object = nil)
+      %w[id weight active created_at updated_at]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[credit_line scoring_parameter created_by]
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Dscf::Credit
+  class SystemConfig < ApplicationRecord
+    self.table_name = "dscf_credit_system_configs"
+
+    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
+
+    validates :config_value, presence: true
+    validates :status, inclusion: { in: %w[pending approved rejected] }
+    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 created_at updated_at]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[config_definition last_updated_by approved_by]
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Dscf::Credit
+  class SystemConfigDefinition < ApplicationRecord
+    self.table_name = "dscf_credit_system_config_definitions"
+
+    belongs_to :bank, class_name: "Dscf::Credit::Bank", foreign_key: "bank_id"
+    has_one :system_config, class_name: "Dscf::Credit::SystemConfig", foreign_key: "config_definition_id", dependent: :destroy
+
+    validates :config_key, :value_type, presence: true
+    validates :config_key, uniqueness: { scope: :bank_id }
+    validates :value_type, inclusion: { in: %w[string integer decimal boolean json] }
+    validates :frequency, inclusion: { in: %w[once daily weekly monthly quarterly yearly] }, allow_blank: true
+
+    scope :by_frequency, ->(frequency) { where(frequency: frequency) }
+    scope :with_frequency, -> { where.not(frequency: [ nil, "" ]) }
+    scope :without_frequency, -> { where(frequency: [ nil, "" ]) }
+
+    def self.ransackable_attributes(auth_object = nil)
+      %w[id config_key description value_type frequency created_at updated_at]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[bank system_config]
+    end
+  end
+end

data/app/serializers/dscf/core/business_serializer.rb

@@ -0,0 +1,9 @@
+module Dscf::Core
+  class BusinessSerializer < ActiveModel::Serializer
+    attributes :id, :name, :description, :contact_email, :contact_phone, :tin_number,
+               :created_at, :updated_at
+
+    belongs_to :business_type, serializer: Dscf::Core::BusinessTypeSerializer
+    belongs_to :user, serializer: Dscf::Core::UserSerializer
+  end
+end

data/app/serializers/dscf/core/business_type_serializer.rb

@@ -0,0 +1,7 @@
+module Dscf::Core
+  class BusinessTypeSerializer < ActiveModel::Serializer
+    attributes :id, :name, :created_at, :updated_at
+
+    has_many :businesses, serializer: Dscf::Core::BusinessSerializer
+  end
+end

data/app/serializers/dscf/core/role_serializer.rb

@@ -0,0 +1,7 @@
+module Dscf::Core
+  class RoleSerializer < ActiveModel::Serializer
+    attributes :id, :code, :name, :created_at, :updated_at
+
+    has_many :user_roles, serializer: Dscf::Core::UserRoleSerializer
+  end
+end

data/app/serializers/dscf/core/user_profile_serializer.rb

@@ -0,0 +1,13 @@
+module Dscf::Core
+  class UserProfileSerializer < ActiveModel::Serializer
+    attributes :id, :first_name, :middle_name, :last_name, :gender, :nationality,
+               :date_of_birth, :place_of_birth, :fayda_number, :occupation,
+               :position_title, :employer_name, :avg_monthly_income, :avg_annual_income,
+               :pep_status, :risk_score, :watchlist_hit, :verification_status,
+               :created_at, :updated_at
+
+    def full_name
+      [ object.first_name, object.middle_name, object.last_name ].compact.join(" ")
+    end
+  end
+end

data/app/serializers/dscf/core/user_role_serializer.rb

@@ -0,0 +1,16 @@
+module Dscf::Core
+  class UserRoleSerializer < ActiveModel::Serializer
+    attributes :id, :created_at, :updated_at
+
+    belongs_to :user, serializer: Dscf::Core::UserSerializer
+    belongs_to :role, serializer: Dscf::Core::RoleSerializer
+
+    def role_code
+      object.role&.code
+    end
+
+    def role_name
+      object.role&.name
+    end
+  end
+end

data/app/serializers/dscf/core/user_serializer.rb

@@ -0,0 +1,17 @@
+module Dscf::Core
+  class UserSerializer < ActiveModel::Serializer
+    attributes :id, :email, :phone, :verified_at, :temp_password, :created_at, :updated_at
+
+    has_one :user_profile, serializer: Dscf::Core::UserProfileSerializer
+    has_many :user_roles, serializer: Dscf::Core::UserRoleSerializer
+    has_many :businesses, serializer: Dscf::Core::BusinessSerializer
+    has_many :roles, serializer: Dscf::Core::RoleSerializer
+
+
+    def attributes(*args)
+      data = super
+      data.except!("password_digest")
+      data
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Dscf::Credit
+  class BankBranchSerializer < ActiveModel::Serializer
+    attributes :id, :branch_name, :branch_code, :branch_address, :city, :country,
+               :contact_email, :contact_phone, :status, :created_at, :updated_at
+
+    belongs_to :bank, serializer: Dscf::Credit::BankSerializer
+    has_many :bank_staffs, serializer: Dscf::Credit::BankStaffSerializer
+  end
+end

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

@@ -0,0 +1,9 @@
+module Dscf::Credit
+  class BankSerializer < ActiveModel::Serializer
+    attributes :id, :name, :registration_number, :swift_code, :headquarters_address,
+               :city, :country, :contact_email, :contact_phone, :status, :created_at, :updated_at
+
+    belongs_to :user, serializer: Dscf::Core::UserSerializer
+    has_many :bank_branches, serializer: Dscf::Credit::BankBranchSerializer
+  end
+end

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

@@ -0,0 +1,8 @@
+module Dscf::Credit
+  class BankStaffSerializer < ActiveModel::Serializer
+    attributes :id, :status, :created_at, :updated_at
+
+    belongs_to :user, serializer: Dscf::Core::UserSerializer
+    belongs_to :bank_branch, serializer: Dscf::Credit::BankBranchSerializer
+  end
+end

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

@@ -0,0 +1,7 @@
+module Dscf::Credit
+  class CategorySerializer < ActiveModel::Serializer
+    attributes :id, :type, :name, :description, :created_at, :updated_at
+
+    has_many :credit_lines, serializer: Dscf::Credit::CreditLineSerializer
+  end
+end

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

@@ -0,0 +1,12 @@
+module Dscf::Credit
+  class CreditLineSerializer < ActiveModel::Serializer
+    attributes :id, :name, :code, :description, :status, :approval_date,
+               :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
+    has_many :credit_line_specs, serializer: Dscf::Credit::CreditLineSpecSerializer
+  end
+end

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

@@ -0,0 +1,12 @@
+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,
+               :loan_duration, :interest_frequency, :interest_income_tax,
+               :vat, :max_interest_calculation_days, :penalty_frequency,
+               :penalty_income_tax, :active, :created_at, :updated_at
+
+    belongs_to :credit_line, serializer: Dscf::Credit::CreditLineSerializer
+    belongs_to :created_by, serializer: Dscf::Core::UserSerializer
+  end
+end

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

@@ -0,0 +1,8 @@
+module Dscf::Credit
+  class ParameterNormalizerSerializer < ActiveModel::Serializer
+    attributes :id, :name, :description, :raw_value, :normalized_value,
+               :created_at, :updated_at
+
+    belongs_to :scoring_parameter, serializer: Dscf::Credit::ScoringParameterSerializer
+  end
+end

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

@@ -0,0 +1,12 @@
+module Dscf::Credit
+  class ScoringParameterSerializer < ActiveModel::Serializer
+    attributes :id, :name, :description, :data_type, :type, :weight, :min_value,
+               :max_value, :active, :expires_at, :created_at, :updated_at
+
+    belongs_to :bank, serializer: Dscf::Credit::BankSerializer
+    belongs_to :created_by, polymorphic: true
+    belongs_to :approved_by, polymorphic: true
+    belongs_to :previous_version, serializer: Dscf::Credit::ScoringParameterSerializer
+    has_many :parameter_normalizers, serializer: Dscf::Credit::ParameterNormalizerSerializer
+  end
+end

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

@@ -0,0 +1,9 @@
+module Dscf::Credit
+  class ScoringTableSerializer < ActiveModel::Serializer
+    attributes :id, :weight, :active, :created_at, :updated_at
+
+    belongs_to :credit_line, serializer: Dscf::Credit::CreditLineSerializer
+    belongs_to :scoring_parameter, serializer: Dscf::Credit::ScoringParameterSerializer
+    belongs_to :created_by, serializer: Dscf::Core::UserSerializer
+  end
+end

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

@@ -0,0 +1,9 @@
+module Dscf::Credit
+  class SystemConfigDefinitionSerializer < ActiveModel::Serializer
+    attributes :id, :config_key, :description, :value_type, :frequency,
+               :created_at, :updated_at
+
+    belongs_to :bank, serializer: Dscf::Credit::BankSerializer
+    has_one :system_config, serializer: Dscf::Credit::SystemConfigSerializer
+  end
+end

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

@@ -0,0 +1,18 @@
+module Dscf::Credit
+  class SystemConfigSerializer < ActiveModel::Serializer
+    attributes :id, :config_value, :status, :created_at, :updated_at
+
+    attribute :config_definition do
+      {
+        id: object.config_definition&.id,
+        config_key: object.config_definition&.config_key,
+        description: object.config_definition&.description,
+        value_type: object.config_definition&.value_type,
+        frequency: object.config_definition&.frequency
+      }
+    end
+
+    belongs_to :last_updated_by, serializer: Dscf::Core::UserSerializer
+    belongs_to :approved_by, serializer: Dscf::Core::UserSerializer
+  end
+end