dscf-credit 0.1.0

data/lib/dscf/credit/engine.rb

@@ -0,0 +1,28 @@
+module Dscf
+  module Credit
+    class Engine < ::Rails::Engine
+      isolate_namespace Dscf::Credit
+      config.api_only = true
+
+      config.generators do |g|
+        g.test_framework :rspec, routing_specs: false
+        g.fixture_replacement :factory_bot
+        g.factory_bot dir: "spec/factories"
+      end
+
+      initializer "dscf_credit.factories", after: "factory_bot.set_factory_paths" do
+        if defined?(FactoryBot)
+          FactoryBot.definition_file_paths << root.join("spec/factories").to_s
+        end
+      end
+
+      initializer :append_migrations do |app|
+        unless app.root.to_s.match?(root.to_s + File::SEPARATOR)
+          app.config.paths["db/migrate"].concat(config.paths["db/migrate"].expanded)
+        end
+      end
+
+      require "active_storage/engine"
+    end
+  end
+end

data/lib/dscf/credit/version.rb

@@ -0,0 +1,5 @@
+module Dscf
+  module Credit
+    VERSION = "0.1.0"
+  end
+end

data/lib/dscf/credit.rb

@@ -0,0 +1,9 @@
+require "dscf/credit/version"
+require "dscf/credit/engine"
+require "dscf/core"
+
+module Dscf
+  module Credit
+    # Your code goes here...
+  end
+end

data/lib/tasks/dscf/credit_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :dscf_credit do
+#   # Task goes here
+# end

data/spec/factories/dscf/credit/accounting_audit_requests.rb

@@ -0,0 +1,58 @@
+FactoryBot.define do
+  factory :accounting_audit_request, class: "Dscf::Credit::AccountingAuditRequest" do
+    transaction_type { %w[debit credit transfer adjustment].sample }
+    amount { Faker::Number.decimal(l_digits: 5, r_digits: 2) }
+    webhook_key { Faker::Internet.uuid }
+    status { "pending" }
+
+    association :source_entity, factory: :loan
+
+    trait :pending do
+      status { "pending" }
+    end
+
+    trait :processing do
+      status { "processing" }
+    end
+
+    trait :completed do
+      status { "completed" }
+    end
+
+    trait :failed do
+      status { "failed" }
+    end
+
+    trait :debit_transaction do
+      transaction_type { "debit" }
+    end
+
+    trait :credit_transaction do
+      transaction_type { "credit" }
+    end
+
+    trait :transfer_transaction do
+      transaction_type { "transfer" }
+    end
+
+    trait :adjustment_transaction do
+      transaction_type { "adjustment" }
+    end
+
+    trait :large_amount do
+      amount { Faker::Number.decimal(l_digits: 8, r_digits: 2) }
+    end
+
+    trait :small_amount do
+      amount { Faker::Number.between(from: 1.0, to: 100.0).round(2) }
+    end
+
+    trait :with_payment_source do
+      association :source_entity, factory: :payment
+    end
+
+    trait :with_loan_source do
+      association :source_entity, factory: :loan
+    end
+  end
+end

data/spec/factories/dscf/credit/accounting_entries.rb

@@ -0,0 +1,29 @@
+FactoryBot.define do
+  factory :accounting_entry, class: "Dscf::Credit::AccountingEntry" do
+    association :audit_request, factory: :accounting_audit_request
+    account_code { Faker::Alphanumeric.alphanumeric(number: 10) }
+    entry_type { %w[debit credit].sample }
+    amount { Faker::Number.decimal(l_digits: 5, r_digits: 2) }
+    status { %w[pending completed failed].sample }
+
+    trait :debit_entry do
+      entry_type { "debit" }
+    end
+
+    trait :credit_entry do
+      entry_type { "credit" }
+    end
+
+    trait :pending do
+      status { "pending" }
+    end
+
+    trait :completed do
+      status { "completed" }
+    end
+
+    trait :failed do
+      status { "failed" }
+    end
+  end
+end

data/spec/factories/dscf/credit/bank_branches.rb

@@ -0,0 +1,21 @@
+FactoryBot.define do
+  factory :bank_branch, class: "Dscf::Credit::BankBranch" do
+    association :bank, factory: :bank
+    branch_name { "#{Faker::Address.city} Branch" }
+    sequence(:branch_code) { |n| "BR#{n.to_s.rjust(3, '0')}" }
+    branch_address { Faker::Address.full_address }
+    city { Faker::Address.city }
+    country { Faker::Address.country }
+    contact_email { Faker::Internet.email }
+    contact_phone { Faker::PhoneNumber.phone_number }
+    status { %w[active inactive].sample }
+
+    trait :active do
+      status { "active" }
+    end
+
+    trait :inactive do
+      status { "inactive" }
+    end
+  end
+end

data/spec/factories/dscf/credit/bank_staffs.rb

@@ -0,0 +1,19 @@
+FactoryBot.define do
+  factory :bank_staff, class: "Dscf::Credit::BankStaff" do
+    association :user, factory: :user if defined?(Dscf::Core::User)
+    association :bank_branch, factory: :bank_branch
+    status { %w[active inactive terminated].sample }
+
+    trait :active do
+      status { "active" }
+    end
+
+    trait :inactive do
+      status { "inactive" }
+    end
+
+    trait :terminated do
+      status { "terminated" }
+    end
+  end
+end

data/spec/factories/dscf/credit/banks.rb

@@ -0,0 +1,30 @@
+FactoryBot.define do
+  factory :bank, class: "Dscf::Credit::Bank" do
+    association :user, factory: :user if defined?(Dscf::Core::User)
+    name { Faker::Bank.name }
+    sequence(:registration_number) { |n| "REG#{n.to_s.rjust(8, '0')}" }
+    sequence(:swift_code) { |n| "#{Faker::Bank.swift_bic[0..3]}#{n.to_s.rjust(4, '0')}" }
+    headquarters_address { Faker::Address.full_address }
+    city { Faker::Address.city }
+    country { Faker::Address.country }
+    contact_email { Faker::Internet.email }
+    contact_phone { Faker::PhoneNumber.phone_number }
+    status { %w[active inactive suspended].sample }
+
+    trait :active do
+      status { "active" }
+    end
+
+    trait :inactive do
+      status { "inactive" }
+    end
+
+    trait :suspended do
+      status { "suspended" }
+    end
+
+    trait :without_user do
+      user { nil }
+    end
+  end
+end

data/spec/factories/dscf/credit/categories.rb

@@ -0,0 +1,27 @@
+FactoryBot.define do
+  factory :category, class: "Dscf::Credit::Category" do
+    type { %w[scoring loan_profile payment risk_assessment].sample }
+    sequence(:name) { |n| "#{type.humanize} Category #{n}" }
+    description { Faker::Lorem.paragraph }
+
+    trait :scoring do
+      type { "scoring" }
+      name { "Scoring Category" }
+    end
+
+    trait :loan_profile do
+      type { "loan_profile" }
+      name { "Loan Profile Category" }
+    end
+
+    trait :payment do
+      type { "payment" }
+      name { "Payment Category" }
+    end
+
+    trait :risk_assessment do
+      type { "risk_assessment" }
+      name { "Risk Assessment Category" }
+    end
+  end
+end

data/spec/factories/dscf/credit/credit_line_specs.rb

@@ -0,0 +1,57 @@
+FactoryBot.define do
+  factory :credit_line_spec, class: "Dscf::Credit::CreditLineSpec" do
+    association :credit_line, factory: :credit_line
+    association :created_by, factory: :user if defined?(Dscf::Core::User)
+    min_amount { Faker::Number.decimal(l_digits: 4, r_digits: 2).to_f }
+    max_amount { min_amount + Faker::Number.decimal(l_digits: 5, r_digits: 2).to_f }
+    interest_rate { Faker::Number.decimal(l_digits: 1, r_digits: 4).to_f }
+    penalty_rate { Faker::Number.decimal(l_digits: 1, r_digits: 4).to_f }
+    facilitation_fee_rate { Faker::Number.decimal(l_digits: 1, r_digits: 4).to_f }
+    tax_rate { Faker::Number.decimal(l_digits: 1, r_digits: 4).to_f }
+    max_penalty_days { Faker::Number.between(from: 30, to: 90) }
+    loan_duration { Faker::Number.between(from: 30, to: 365) }
+    interest_frequency { %w[daily weekly monthly quarterly annually].sample }
+    interest_income_tax { Faker::Number.decimal(l_digits: 1, r_digits: 4).to_f }
+    vat { Faker::Number.decimal(l_digits: 1, r_digits: 4).to_f }
+    max_interest_calculation_days { Faker::Number.between(from: 30, to: 365) }
+    penalty_frequency { %w[daily weekly monthly].sample }
+    penalty_income_tax { Faker::Number.decimal(l_digits: 1, r_digits: 4).to_f }
+    active { true }
+
+    trait :active do
+      active { true }
+    end
+
+    trait :inactive do
+      active { false }
+    end
+
+    trait :short_term do
+      loan_duration { Faker::Number.between(from: 30, to: 90) }
+      interest_frequency { 'monthly' }
+      penalty_frequency { 'weekly' }
+    end
+
+    trait :medium_term do
+      loan_duration { Faker::Number.between(from: 91, to: 180) }
+      interest_frequency { 'monthly' }
+      penalty_frequency { 'monthly' }
+    end
+
+    trait :long_term do
+      loan_duration { Faker::Number.between(from: 181, to: 365) }
+      interest_frequency { 'quarterly' }
+      penalty_frequency { 'monthly' }
+    end
+
+    trait :daily_interest do
+      interest_frequency { 'daily' }
+      penalty_frequency { 'daily' }
+    end
+
+    trait :monthly_interest do
+      interest_frequency { 'monthly' }
+      penalty_frequency { 'weekly' }
+    end
+  end
+end

data/spec/factories/dscf/credit/credit_lines.rb

@@ -0,0 +1,32 @@
+FactoryBot.define do
+  factory :credit_line, class: "Dscf::Credit::CreditLine" do
+    association :bank, factory: :bank
+    association :category, factory: :category
+    association :created_by, factory: :user if defined?(Dscf::Core::User)
+    association :approved_by, factory: :user if defined?(Dscf::Core::User)
+    name { "#{Faker::Finance.credit_card(:visa)} Credit Line" }
+    sequence(:code) { |n| "CL#{n.to_s.rjust(4, '0')}" }
+    description { Faker::Lorem.paragraph }
+    status { %w[pending approved active suspended].sample }
+    approval_date { Faker::Date.between(from: 6.months.ago, to: Date.current) if status.in?(%w[approved active]) }
+
+    trait :pending do
+      status { "pending" }
+      approval_date { nil }
+    end
+
+    trait :approved do
+      status { "approved" }
+      approval_date { Faker::Date.between(from: 6.months.ago, to: Date.current) }
+    end
+
+    trait :active do
+      status { "active" }
+      approval_date { Faker::Date.between(from: 6.months.ago, to: Date.current) }
+    end
+
+    trait :suspended do
+      status { "suspended" }
+    end
+  end
+end

data/spec/factories/dscf/credit/daily_routine_transactions.rb

@@ -0,0 +1,36 @@
+FactoryBot.define do
+  factory :daily_routine_transaction, class: "Dscf::Credit::DailyRoutineTransaction" do
+    association :loan, factory: :loan
+    routine_type { %w[interest_calculation penalty_assessment payment_due_notification].sample }
+    amount { Faker::Number.decimal(l_digits: 5, r_digits: 2) }
+    status { %w[pending processing completed failed].sample }
+    failure_reason { Faker::Lorem.sentence if status == "failed" }
+    initiated_at { Faker::Time.between(from: 1.month.ago, to: Time.current) }
+    approved_at { initiated_at + rand(1..6).hours if status.in?(%w[completed failed]) }
+
+    trait :pending do
+      status { "pending" }
+      started_at { nil }
+      completed_at { nil }
+      processed_records_count { 0 }
+      failed_records_count { 0 }
+    end
+
+    trait :in_progress do
+      status { "in_progress" }
+      completed_at { nil }
+    end
+
+    trait :completed do
+      status { "completed" }
+      completed_at { started_at + rand(1..6).hours }
+      error_details { nil }
+    end
+
+    trait :failed do
+      status { "failed" }
+      completed_at { started_at + rand(1..6).hours }
+      error_details { Faker::Json.shallow_json(width: 3) }
+    end
+  end
+end

data/spec/factories/dscf/credit/facilitator_performances.rb

@@ -0,0 +1,30 @@
+FactoryBot.define do
+  factory :facilitator_performance, class: "Dscf::Credit::FacilitatorPerformance" do
+    association :facilitator, factory: :facilitator
+    association :created_by, factory: :user if defined?(Dscf::Core::User)
+    score { Faker::Number.decimal(l_digits: 2, r_digits: 2) }
+    total_outstanding_loans { Faker::Number.between(from: 0, to: 50) }
+    total_outstanding_amount { Faker::Number.decimal(l_digits: 6, r_digits: 2) }
+    approval_required { [ true, false ].sample }
+    input_data { Faker::Json.shallow_json(width: 3, options: { key: 'Name.name', value: 'Number.number' }) }
+    expires_at { Faker::Date.between(from: 1.month.from_now, to: 1.year.from_now) }
+
+    trait :high_performance do
+      score { Faker::Number.between(from: 80.0, to: 100.0) }
+      total_outstanding_loans { Faker::Number.between(from: 20, to: 50) }
+    end
+
+    trait :low_performance do
+      score { Faker::Number.between(from: 0.0, to: 30.0) }
+      total_outstanding_loans { Faker::Number.between(from: 0, to: 5) }
+    end
+
+    trait :requiring_approval do
+      approval_required { true }
+    end
+
+    trait :expired do
+      expires_at { Faker::Date.between(from: 1.year.ago, to: 1.month.ago) }
+    end
+  end
+end

data/spec/factories/dscf/credit/facilitators.rb

@@ -0,0 +1,35 @@
+FactoryBot.define do
+  factory :facilitator, class: "Dscf::Credit::Facilitator" do
+    association :bank, factory: :bank
+    association :user, factory: :user if defined?(Dscf::Core::User)
+    association :kyc_approved_by, factory: :user if defined?(Dscf::Core::User)
+    name { Faker::Name.name }
+    type { %w[individual corporate agent].sample }
+    total_limit { Faker::Number.decimal(l_digits: 6, r_digits: 2) }
+    kyc_status { %w[pending approved rejected].sample }
+
+    trait :pending_kyc do
+      kyc_status { "pending" }
+    end
+
+    trait :approved do
+      kyc_status { "approved" }
+    end
+
+    trait :rejected do
+      kyc_status { "rejected" }
+    end
+
+    trait :individual do
+      type { "individual" }
+    end
+
+    trait :corporate do
+      type { "corporate" }
+    end
+
+    trait :agent do
+      type { "agent" }
+    end
+  end
+end

data/spec/factories/dscf/credit/failed_operations_logs.rb

@@ -0,0 +1,34 @@
+FactoryBot.define do
+  factory :failed_operations_log, class: "Dscf::Credit::FailedOperationsLog" do
+    association :entity, factory: :loan
+    failure_type { %w[loan_disbursement payment_processing interest_calculation credit_scoring daily_routine accounting_entry].sample }
+    reason { Faker::Lorem.sentence }
+    retry_count { Faker::Number.between(from: 0, to: 5) }
+    resolved { [ true, false ].sample }
+    resolved_at { resolved ? Faker::Time.between(from: 1.day.ago, to: Time.current) : nil }
+
+    trait :resolved do
+      resolved { true }
+      resolved_at { Faker::Time.between(from: 1.day.ago, to: Time.current) }
+    end
+
+    trait :unresolved do
+      resolved { false }
+      resolved_at { nil }
+    end
+
+    trait :with_retries do
+      retry_count { 3 }
+    end
+
+    trait :payment_failure do
+      failure_type { "payment_processing" }
+      association :entity, factory: :payment
+    end
+
+    trait :loan_failure do
+      failure_type { "loan_disbursement" }
+      association :entity, factory: :loan
+    end
+  end
+end

data/spec/factories/dscf/credit/loan_profile_scoring_specs.rb

@@ -0,0 +1,31 @@
+FactoryBot.define do
+  factory :loan_profile_scoring_spec, class: "Dscf::Credit::LoanProfileScoringSpec" do
+    association :loan_profile, factory: :loan_profile
+    association :created_by, factory: :user if defined?(Dscf::Core::User)
+    association :approved_by, factory: :user if defined?(Dscf::Core::User)
+    scoring_input_data { Faker::Json.shallow_json(width: 5, options: { key: 'Name.name', value: 'Number.number' }) }
+    score { Faker::Number.decimal(l_digits: 2, r_digits: 2) }
+    active { true }
+    expires_at { Faker::Date.between(from: 3.months.from_now, to: 1.year.from_now) }
+
+    trait :active do
+      active { true }
+    end
+
+    trait :inactive do
+      active { false }
+    end
+
+    trait :high_score do
+      score { Faker::Number.between(from: 80.0, to: 100.0) }
+    end
+
+    trait :low_score do
+      score { Faker::Number.between(from: 0.0, to: 30.0) }
+    end
+
+    trait :expired do
+      expires_at { Faker::Date.between(from: 1.year.ago, to: 1.month.ago) }
+    end
+  end
+end

data/spec/factories/dscf/credit/loan_profiles.rb

@@ -0,0 +1,49 @@
+FactoryBot.define do
+  factory :loan_profile, class: "Dscf::Credit::LoanProfile" do
+    association :bank, factory: :bank
+    association :approved_by, factory: :user if defined?(Dscf::Core::User)
+    association :user, factory: :user if defined?(Dscf::Core::User)
+    association :backer, factory: :user if defined?(Dscf::Core::User)
+    status { %w[pending approved rejected].sample }
+    total_amount { Faker::Number.decimal(l_digits: 6, r_digits: 2).to_f }
+    available_amount { total_amount - Faker::Number.decimal(l_digits: 4, r_digits: 2).to_f }
+    rejection_reason { Faker::Lorem.sentence if status == "rejected" }
+
+    trait :pending do
+      status { "pending" }
+      rejection_reason { nil }
+    end
+
+    trait :approved do
+      status { "approved" }
+      rejection_reason { nil }
+    end
+
+    trait :rejected do
+      status { "rejected" }
+      rejection_reason { Faker::Lorem.sentence }
+    end
+
+    trait :fully_available do
+      available_amount { total_amount }
+    end
+
+    trait :fully_utilized do
+      available_amount { 0 }
+    end
+
+    trait :partially_utilized do
+      available_amount { total_amount * 0.5 }
+    end
+
+    trait :small_amount do
+      total_amount { Faker::Number.between(from: 1000, to: 10000) }
+      available_amount { total_amount * rand(0.1..1.0) }
+    end
+
+    trait :large_amount do
+      total_amount { Faker::Number.between(from: 100000, to: 1000000) }
+      available_amount { total_amount * rand(0.1..1.0) }
+    end
+  end
+end

data/spec/factories/dscf/credit/loan_transactions.rb

@@ -0,0 +1,37 @@
+FactoryBot.define do
+  factory :loan_transaction, class: "Dscf::Credit::LoanTransaction" do
+    association :loan, factory: :loan
+    transaction_type { %w[disbursement repayment interest_accrual penalty fee_charge].sample }
+    amount { Faker::Number.decimal(l_digits: 5, r_digits: 2) }
+    transaction_reference { Faker::Alphanumeric.alphanumeric(number: 20).upcase }
+    status { %w[pending processing completed failed reversed].sample }
+
+    trait :disbursement do
+      transaction_type { "disbursement" }
+    end
+
+    trait :repayment do
+      transaction_type { "repayment" }
+    end
+
+    trait :interest_accrual do
+      transaction_type { "interest_accrual" }
+    end
+
+    trait :penalty do
+      transaction_type { "penalty" }
+    end
+
+    trait :fee_charge do
+      transaction_type { "fee_charge" }
+    end
+
+    trait :completed do
+      status { "completed" }
+    end
+
+    trait :failed do
+      status { "failed" }
+    end
+  end
+end

data/spec/factories/dscf/credit/loans.rb

@@ -0,0 +1,37 @@
+FactoryBot.define do
+  factory :loan, class: "Dscf::Credit::Loan" do
+    association :loan_profile, factory: :loan_profile
+    association :credit_line, factory: :credit_line
+    association :payment_request, factory: :payment_request
+    status { %w[pending approved disbursed active overdue paid closed].sample }
+    principal_amount { Faker::Number.decimal(l_digits: 5, r_digits: 2) }
+    accrued_interest { Faker::Number.decimal(l_digits: 3, r_digits: 2) }
+    accrued_penalty { Faker::Number.decimal(l_digits: 3, r_digits: 2) }
+    facilitation_fee { Faker::Number.decimal(l_digits: 3, r_digits: 2) }
+    total_loan_amount { principal_amount + accrued_interest + facilitation_fee }
+    remaining_amount { Faker::Number.decimal(l_digits: 5, r_digits: 2) }
+    due_date { Faker::Date.between(from: 1.month.from_now, to: 6.months.from_now) }
+    disbursed_at { Faker::Time.between(from: 2.months.ago, to: Time.current) if status.in?(%w[disbursed active overdue paid closed]) }
+
+    trait :pending do
+      status { "pending" }
+      disbursed_at { nil }
+    end
+
+    trait :active do
+      status { "active" }
+      disbursed_at { Faker::Time.between(from: 2.months.ago, to: 1.month.ago) }
+    end
+
+    trait :overdue do
+      status { "overdue" }
+      due_date { Faker::Date.between(from: 1.month.ago, to: Date.current) }
+      disbursed_at { Faker::Time.between(from: 3.months.ago, to: 2.months.ago) }
+    end
+
+    trait :paid do
+      status { "paid" }
+      remaining_amount { 0 }
+    end
+  end
+end

data/spec/factories/dscf/credit/parameter_normalizers.rb

@@ -0,0 +1,24 @@
+FactoryBot.define do
+  factory :parameter_normalizer, class: "Dscf::Credit::ParameterNormalizer" do
+    association :scoring_parameter, factory: :scoring_parameter
+    name { Faker::Lorem.words(number: 2).join(' ').titlecase }
+    description { Faker::Lorem.sentence }
+    raw_value { Faker::Lorem.word }
+    normalized_value { Faker::Number.decimal(l_digits: 1, r_digits: 2) }
+
+    trait :high_value do
+      raw_value { "excellent" }
+      normalized_value { Faker::Number.between(from: 8.0, to: 10.0) }
+    end
+
+    trait :medium_value do
+      raw_value { "good" }
+      normalized_value { Faker::Number.between(from: 5.0, to: 7.9) }
+    end
+
+    trait :low_value do
+      raw_value { "poor" }
+      normalized_value { Faker::Number.between(from: 0.0, to: 4.9) }
+    end
+  end
+end