dscf-credit 0.1.0

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

@@ -0,0 +1,31 @@
+module Dscf::Credit
+  class ParameterNormalizersController < ApplicationController
+    include Dscf::Core::Common
+
+    private
+
+    def model_params
+      params.require(:parameter_normalizer).permit(
+        :scoring_parameter_id,
+        :name,
+        :description,
+        :raw_value,
+        :normalized_value
+      )
+    end
+
+    def eager_loaded_associations
+      [ :scoring_parameter ]
+    end
+
+    def allowed_order_columns
+      %w[id name raw_value normalized_value created_at updated_at]
+    end
+
+    def default_serializer_includes
+      {
+        default: [ :scoring_parameter ]
+      }
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Dscf::Credit
+  class PaymentRequestsController < ApplicationController
+    include Dscf::Core::Common
+
+    private
+
+    def model_params
+      params.require(:payment_request).permit(
+        :user_id,
+        :order_id,
+        :request_type,
+        :amount,
+        :receiver_account_reference,
+        :status,
+        :failure_reason,
+        :initiated_at,
+        :approved_at
+      )
+    end
+
+    def eager_loaded_associations
+      [ :user, :loans, :payments ]
+    end
+
+    def allowed_order_columns
+      %w[id order_id request_type amount status initiated_at approved_at created_at updated_at]
+    end
+
+    def default_serializer_includes
+      {
+        index: [ :user ],
+        show: [ :user, :loans, :payments ],
+        create: [ :user ],
+        update: [ :user, :loans, :payments ]
+      }
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Dscf::Credit
+  class PaymentsController < ApplicationController
+    include Dscf::Core::Common
+
+    private
+
+    def model_params
+      params.require(:payment).permit(
+        :payment_request_id,
+        :amount,
+        :receiver_account_reference,
+        :transaction_reference,
+        :status,
+        :failure_reason,
+        :processed_at
+      )
+    end
+
+    def eager_loaded_associations
+      [ :payment_request ]
+    end
+
+    def allowed_order_columns
+      %w[id amount status processed_at created_at updated_at]
+    end
+
+    def default_serializer_includes
+      {
+        index: [ :payment_request ],
+        show: [ :payment_request ],
+        create: [ :payment_request ],
+        update: [ :payment_request ]
+      }
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Dscf::Credit
+  class ScoringParametersController < ApplicationController
+    include Dscf::Core::Common
+
+    def create
+      super do
+        scoring_parameter = @clazz.new(model_params)
+        scoring_parameter.created_by = current_user
+        scoring_parameter.approved_by = current_user
+
+        scoring_parameter
+      end
+    end
+
+    private
+
+    def model_params
+      params.require(:scoring_parameter).permit(
+        :bank_id,
+        :name,
+        :description,
+        :data_type,
+        :type,
+        :weight,
+        :min_value,
+        :max_value,
+        :active,
+        :previous_version_id,
+        :expires_at
+      )
+    end
+
+    def eager_loaded_associations
+      [ :bank, :created_by, :approved_by, :previous_version, :parameter_normalizers ]
+    end
+
+    def allowed_order_columns
+      %w[id name data_type type weight active expires_at 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 ]
+      }
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Dscf::Credit
+  class ScoringTablesController < ApplicationController
+    include Dscf::Core::Common
+
+    def create
+      super do
+        scoring_table = @clazz.new(model_params)
+        scoring_table.created_by = current_user
+        scoring_table
+      end
+    end
+
+    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 ] })
+      else
+        render_error(errors: @obj.errors.full_messages[0], status: :unprocessable_entity)
+      end
+    rescue StandardError => e
+      render_error(error: e.message)
+    end
+
+    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 ] })
+      else
+        render_error(errors: @obj.errors.full_messages[0], status: :unprocessable_entity)
+      end
+    rescue StandardError => e
+      render_error(error: e.message)
+    end
+
+    private
+
+    def model_params
+      params.require(:scoring_table).permit(
+        :credit_line_id,
+        :scoring_parameter_id,
+        :weight,
+        :active
+      )
+    end
+
+    def eager_loaded_associations
+      [ :credit_line, :scoring_parameter, :created_by ]
+    end
+
+    def allowed_order_columns
+      %w[id weight active created_at updated_at]
+    end
+
+    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 ]
+      }
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Dscf::Credit
+  class SystemConfigDefinitionsController < ApplicationController
+    include Dscf::Core::Common
+
+    private
+
+    def model_params
+      params.require(:system_config_definition).permit(
+        :bank_id,
+        :config_key,
+        :description,
+        :value_type,
+        :frequency
+      )
+    end
+
+    def eager_loaded_associations
+      [ :bank, :system_config ]
+    end
+
+    def allowed_order_columns
+      %w[id config_key description value_type frequency created_at updated_at]
+    end
+
+    def default_serializer_includes
+      {
+        index: [ :bank ],
+        show: [ :bank, :system_config ],
+        create: [ :bank ],
+        update: [ :bank, :system_config ]
+      }
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Dscf::Credit
+  class SystemConfigsController < ApplicationController
+    include Dscf::Core::Common
+
+    def create
+      super do
+        obj = @clazz.new(model_params)
+        obj.approved_by = current_user
+        obj.last_updated_by = current_user
+        obj
+      end
+    end
+
+    def update
+      super do
+        obj = set_object
+        obj.last_updated_by = current_user
+        obj
+      end
+    end
+
+    private
+
+    def model_params
+      params.require(:system_config).permit(
+        :config_definition_id,
+        :config_value,
+        :status
+      )
+    end
+
+    def eager_loaded_associations
+      [ :config_definition, :last_updated_by, :approved_by ]
+    end
+
+    def allowed_order_columns
+      %w[id config_value status 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 ]
+      }
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Dscf::Credit
+  class UsersController < ApplicationController
+    include Dscf::Core::Common
+
+    def index
+      super do
+        if params[:business_type].present?
+          business_type_name = params[:business_type].downcase
+
+          business_type = Dscf::Core::BusinessType.find_by(name: business_type_name)
+          unless business_type
+            return render_error(
+              "validation.invalid",
+              errors: "Invalid business type: #{params[:business_type]}",
+              status: :not_found
+            )
+          end
+
+          @clazz.joins(businesses: :business_type)
+                .where(dscf_core_business_types: { name: business_type_name })
+                .distinct
+        else
+          @clazz.all
+        end
+      end
+    end
+
+    private
+
+    def model_params
+      params.require(:user).permit(
+        :email,
+        :phone,
+        :verified_at,
+        :temp_password
+      )
+    end
+
+    def eager_loaded_associations
+      [ :user_profile, :businesses, :user_roles, businesses: :business_type ]
+    end
+
+    def allowed_order_columns
+      %w[id email phone verified_at created_at updated_at]
+    end
+
+    def default_serializer_includes
+      {
+        default: [ :user_profile, :businesses, :user_roles, "businesses.business_type" ]
+      }
+    end
+  end
+end

data/app/jobs/dscf/credit/application_job.rb

@@ -0,0 +1,6 @@
+module Dscf
+  module Credit
+    class ApplicationJob < ActiveJob::Base
+    end
+  end
+end

data/app/mailers/dscf/credit/application_mailer.rb

@@ -0,0 +1,8 @@
+module Dscf
+  module Credit
+    class ApplicationMailer < ActionMailer::Base
+      default from: ENV.fetch("MAILER_FROM_EMAIL", "noreply@dscf-credit.com")
+      layout "mailer"
+    end
+  end
+end

data/app/mailers/dscf/credit/bank_staff_welcome_mailer.rb

@@ -0,0 +1,15 @@
+module Dscf::Credit
+  class BankStaffWelcomeMailer < ApplicationMailer
+    def welcome_email(user, generated_password, bank_staff = nil)
+      @user = user
+      @generated_password = generated_password
+      @bank_staff = bank_staff
+      @login_url = ENV["FRONTEND_BASE_URL"] || "http://localhost:3000"
+
+      mail(
+        to: user.email,
+        subject: "Welcome to DSCF Banking System - Your Account Details"
+      )
+    end
+  end
+end

data/app/mailers/dscf/credit/facilitator_mailer.rb

@@ -0,0 +1,54 @@
+module Dscf::Credit
+  class FacilitatorMailer < ApplicationMailer
+    def approval_notification(facilitator, additional_info_token)
+      @facilitator = facilitator
+      @merchant = facilitator.user
+      @additional_info_url = generate_additional_info_url(additional_info_token)
+      @total_limit = facilitator.total_limit
+
+      mail(
+        to: @merchant.email,
+        subject: "Facilitator Application Approved - Submit Additional Information"
+      )
+    end
+
+    def rejection_notification(facilitator, rejection_reason = nil)
+      @facilitator = facilitator
+      @merchant = facilitator.user
+      @rejection_reason = rejection_reason
+
+      mail(
+        to: @merchant.email,
+        subject: "Facilitator Application Update"
+      )
+    end
+
+    def limit_update_notification(facilitator)
+      @facilitator = facilitator
+      @merchant = facilitator.user
+      @total_limit = facilitator.total_limit
+
+      mail(
+        to: @merchant.email,
+        subject: "Facilitator Limit Updated"
+      )
+    end
+
+    def additional_info_received(facilitator)
+      @facilitator = facilitator
+      @merchant = facilitator.user
+
+      mail(
+        to: @merchant.email,
+        subject: "Additional Information Received"
+      )
+    end
+
+    private
+
+    def generate_additional_info_url(token)
+      frontend_base_url = ENV["FRONTEND_BASE_URL"] || "https://test-frontend.com"
+      "#{frontend_base_url}/facilitator/additional-info?token=#{token}"
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Dscf::Credit
+  class AccountingAuditRequest < ApplicationRecord
+    self.table_name = "dscf_credit_accounting_audit_requests"
+
+    belongs_to :source_entity, polymorphic: true
+
+    validates :transaction_type, :amount, :webhook_key, :status, presence: true
+    validates :transaction_type, inclusion: { in: %w[debit credit transfer adjustment] }
+    validates :status, inclusion: { in: %w[pending processing completed failed] }
+    validates :amount, numericality: { greater_than: 0 }
+    validates :webhook_key, uniqueness: true
+
+    scope :by_status, ->(status) { where(status: status) }
+    scope :by_transaction_type, ->(type) { where(transaction_type: type) }
+    scope :by_amount_range, ->(min, max) { where(amount: min..max) }
+  end
+end

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

@@ -0,0 +1,15 @@
+module Dscf::Credit
+  class AccountingEntry < ApplicationRecord
+    self.table_name = "dscf_credit_accounting_entries"
+
+    belongs_to :audit_request, class_name: "Dscf::Credit::AccountingAuditRequest", foreign_key: "audit_request_id"
+
+    validates :account_code, :entry_type, :amount, :status, presence: true
+    validates :amount, numericality: { greater_than: 0 }
+    validates :entry_type, inclusion: { in: %w[debit credit] }
+    validates :status, inclusion: { in: %w[pending completed failed] }
+
+    scope :by_entry_type, ->(type) { where(entry_type: type) }
+    scope :by_status, ->(status) { where(status: status) }
+  end
+end

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

@@ -0,0 +1,7 @@
+module Dscf
+  module Credit
+    class ApplicationRecord < ActiveRecord::Base
+      self.abstract_class = true
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Dscf::Credit
+  class Bank < ApplicationRecord
+    self.table_name = "dscf_credit_banks"
+
+    if defined?(Dscf::Core::User)
+      belongs_to :user, class_name: "Dscf::Core::User", foreign_key: "user_id", optional: true
+    end
+    has_many :bank_branches, class_name: "Dscf::Credit::BankBranch",
+             foreign_key: "bank_id", dependent: :destroy
+    has_many :credit_lines, class_name: "Dscf::Credit::CreditLine",
+             foreign_key: "bank_id", dependent: :destroy
+    has_many :system_config_definitions, class_name: "Dscf::Credit::SystemConfigDefinition",
+             foreign_key: "bank_id", dependent: :destroy
+    has_many :scoring_parameters, class_name: "Dscf::Credit::ScoringParameter",
+             foreign_key: "bank_id", dependent: :destroy
+    has_many :loan_profiles, class_name: "Dscf::Credit::LoanProfile",
+             foreign_key: "bank_id", dependent: :destroy
+    has_many :facilitators, class_name: "Dscf::Credit::Facilitator",
+             foreign_key: "bank_id", dependent: :destroy
+    has_many :bank_staffs, through: :bank_branches, class_name: "Dscf::Credit::BankStaff"
+
+    validates :name, presence: true
+    validates :registration_number, uniqueness: true, allow_blank: true
+    validates :swift_code, uniqueness: true, allow_blank: true
+    validates :status, inclusion: { in: %w[active inactive suspended] }
+
+    scope :active, -> { where(status: "active") }
+    scope :inactive, -> { where(status: "inactive") }
+
+    def self.ransackable_attributes(auth_object = nil)
+      %w[id name registration_number swift_code headquarters_address city country contact_email contact_phone status created_at updated_at]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[user bank_branches credit_lines system_config_definitions scoring_parameters loan_profiles facilitators bank_staffs]
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Dscf::Credit
+  class BankBranch < ApplicationRecord
+    self.table_name = "dscf_credit_bank_branches"
+
+    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
+
+    validates :branch_name, presence: true
+    validates :branch_name, uniqueness: { scope: :bank_id }
+    validates :branch_code, uniqueness: { scope: :bank_id }, allow_blank: true
+    validates :status, inclusion: { in: %w[active inactive] }
+
+    scope :active, -> { where(status: "active") }
+
+    def self.ransackable_attributes(auth_object = nil)
+      %w[id branch_name branch_code branch_address city country contact_email contact_phone status created_at updated_at]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[bank bank_staffs]
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Dscf::Credit
+  class BankStaff < ApplicationRecord
+    self.table_name = "dscf_credit_bank_staffs"
+
+    if defined?(Dscf::Core::User)
+      belongs_to :user, class_name: "Dscf::Core::User", foreign_key: "user_id"
+    end
+    belongs_to :bank_branch, class_name: "Dscf::Credit::BankBranch", foreign_key: "bank_branch_id"
+
+    validates :status, inclusion: { in: %w[active inactive terminated] }
+    validates :user_id, uniqueness: { scope: :bank_branch_id }
+
+    scope :active, -> { where(status: "active") }
+    scope :inactive, -> { where(status: "inactive") }
+
+    def self.ransackable_attributes(auth_object = nil)
+      %w[id status created_at updated_at]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[user bank_branch]
+    end
+
+    delegate :bank, to: :bank_branch, allow_nil: true
+  end
+end

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

@@ -0,0 +1,21 @@
+module Dscf::Credit
+  class Category < ApplicationRecord
+    self.table_name = "dscf_credit_categories"
+    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
+
+    validates :type, :name, presence: true
+    validates :name, uniqueness: { scope: :type }
+
+    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]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[credit_lines]
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Dscf::Credit
+  class CreditLine < ApplicationRecord
+    self.table_name = "dscf_credit_credit_lines"
+
+    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
+    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
+
+    validates :name, presence: true
+    validates :code, uniqueness: { scope: :bank_id }, allow_blank: true
+    validates :status, inclusion: { in: %w[pending approved active 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]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[bank category created_by approved_by credit_line_specs loans scoring_tables scoring_parameters]
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Dscf::Credit
+  class CreditLineSpec < ApplicationRecord
+    self.table_name = "dscf_credit_credit_line_specs"
+
+    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 :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] }
+    validates :penalty_frequency, inclusion: { in: %w[daily weekly monthly] }
+    validate :max_amount_greater_than_min_amount
+
+    scope :active, -> { where(active: true) }
+    scope :by_duration, ->(duration) { where(loan_duration: duration) }
+    scope :by_interest_frequency, ->(frequency) { where(interest_frequency: frequency) }
+    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]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[credit_line created_by]
+    end
+
+    private
+
+    def max_amount_greater_than_min_amount
+      return unless min_amount && max_amount
+
+      errors.add(:max_amount, "must be greater than minimum amount") if max_amount <= min_amount
+    end
+  end
+end