dscf-credit 0.1.4 → 0.1.5

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_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

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

@@ -1,15 +1,14 @@
 module Dscf::Credit
   class ScoringParameterSerializer < ActiveModel::Serializer
     attributes :id, :name, :description, :data_type, :weight, :min_value,
-               :max_value, :active, :status, :review_date, :review_feedback, :source, :document_reference, :created_at, :updated_at
+               :max_value, :active, :source, :document_reference, :created_at, :updated_at
 
     belongs_to :bank, serializer: Dscf::Credit::BankSerializer
+    belongs_to :category, serializer: Dscf::Credit::CategorySerializer
     belongs_to :created_by, polymorphic: true
-    belongs_to :reviewed_by, polymorphic: true
     belongs_to :scoring_param_type, serializer: Dscf::Credit::ScoringParamTypeSerializer
     belongs_to :previous_version, serializer: Dscf::Credit::ScoringParameterSerializer
     has_many :parameter_normalizers, serializer: Dscf::Credit::ParameterNormalizerSerializer
-    has_many :scoring_tables, serializer: Dscf::Credit::ScoringTableSerializer
-    has_many :categories, serializer: Dscf::Credit::CategorySerializer
+    has_many :reviews, serializer: Dscf::Core::ReviewSerializer
   end
 end

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

@@ -1,6 +1,6 @@
 module Dscf::Credit
   class SystemConfigSerializer < ActiveModel::Serializer
-    attributes :id, :config_value, :status, :review_date, :review_feedback, :created_at, :updated_at
+    attributes :id, :config_value, :created_at, :updated_at
 
     attribute :config_definition do
       {
@@ -13,6 +13,6 @@ module Dscf::Credit
     end
 
     belongs_to :last_updated_by, serializer: Dscf::Core::UserSerializer
-    belongs_to :reviewed_by, serializer: Dscf::Core::UserSerializer
+    has_many :reviews, serializer: Dscf::Core::ReviewSerializer
   end
 end