dscf-banking 0.1.0 → 0.1.2

data/app/models/dscf/banking/account.rb

@@ -0,0 +1,110 @@
+module Dscf::Banking
+  class Account < ApplicationRecord
+    belongs_to :virtual_account_product, optional: true
+    belongs_to :application, optional: true
+
+    enum :status, {
+      draft: 0,
+      pending_activation: 1,
+      active: 2,
+      suspended: 3,
+      closed: 4,
+      dormant: 5
+    }
+
+    validates :account_number, presence: true, uniqueness: { case_sensitive: false }
+    validates :name, presence: true
+    validates :currency, presence: true
+    validates :current_balance, :available_balance, :minimum_balance,
+              numericality: { greater_than_or_equal_to: 0 }
+    validates :system_account, inclusion: { in: [ true, false ] }
+    validate :system_account_associations
+
+    before_validation :generate_account_number, on: :create
+    before_validation :set_defaults, on: :create
+
+    scope :active_accounts, -> { where(active: true, status: :active) }
+    scope :by_currency, ->(currency) { where(currency: currency) }
+    scope :customer_accounts, -> { where(system_account: false) }
+    scope :system_accounts, -> { where(system_account: true) }
+
+    def sufficient_funds_for_withdrawal?(amount)
+      available_balance - amount >= minimum_balance
+    end
+
+    def suspend!(reason = nil)
+      update!(status: :suspended)
+    end
+
+    def activate!
+      update!(status: :active, activation_date: Date.current)
+    end
+
+    def close!(reason = nil)
+      update!(status: :closed, active: false, closure_date: Date.current)
+    end
+
+    def formatted_account_number
+      return nil unless account_number
+      account_number.gsub(/(\d{3})(\d{1})(\d{1})(\d{6})/, '\1 \2 \3 \4')
+    end
+
+    def can_be_activated?
+      draft? || pending_activation? || suspended?
+    end
+
+    def can_be_suspended?
+      active?
+    end
+
+    def can_be_closed?
+      active? || suspended? || dormant?
+    end
+
+    private
+
+    def generate_account_number
+      return if account_number.present?
+
+      branch_code = "001"
+      product_scheme = "1"
+      voucher_type = "0"
+
+      loop do
+        sequence = SecureRandom.random_number(1000000).to_s.rjust(6, "0")
+        account_num = "#{branch_code}#{product_scheme}#{voucher_type}#{sequence}"
+
+        unless self.class.exists?(account_number: account_num)
+          self.account_number = account_num
+          break
+        end
+      end
+    end
+
+    def set_defaults
+      return unless virtual_account_product
+
+      self.currency ||= "ETB"
+      self.minimum_balance ||= 0
+      self.name ||= "Account Holder"
+    end
+
+    def system_account_associations
+      if system_account?
+        if virtual_account_product.present?
+          errors.add(:virtual_account_product, "must be blank for system accounts")
+        end
+        if application.present?
+          errors.add(:application, "must be blank for system accounts")
+        end
+      else
+        unless virtual_account_product.present?
+          errors.add(:virtual_account_product, "must be present for customer accounts")
+        end
+        unless application.present?
+          errors.add(:application, "must be present for customer accounts")
+        end
+      end
+    end
+  end
+end

data/app/models/dscf/banking/application.rb

@@ -0,0 +1,70 @@
+module Dscf::Banking
+  class Application < ApplicationRecord
+    include Dscf::Banking::Auditable
+
+    belongs_to :user, class_name: "Dscf::Core::User"
+    belongs_to :assigned_kyc_officer, class_name: "Dscf::Core::User", optional: true
+    belongs_to :assigned_branch_manager, class_name: "Dscf::Core::User", optional: true
+    belongs_to :virtual_account_product, class_name: "Dscf::Banking::VirtualAccountProduct"
+    has_one :account, class_name: "Dscf::Banking::Account"
+
+    validates :application_number, presence: true, uniqueness: true, length: { maximum: 50 }
+    validates :applicant_type, presence: true
+    validates :status, presence: true
+    validates :form_data, presence: true
+    validates :rejection_reason, presence: true, if: -> { status == "rejected" }
+
+    enum :applicant_type, { individual: 0, business: 1 }, prefix: :applicant_type
+    enum :status, { draft: 0, submitted: 1, under_review: 2, approved: 3, rejected: 4 }, prefix: :status
+
+    before_validation :generate_application_number, if: -> { new_record? && application_number.blank? }
+    before_update :set_timestamps_on_status_change
+    after_update :create_account_if_approved
+
+    def approve!(approved_by = nil)
+      update!(status: :approved, completed_at: Time.current)
+    end
+
+    def reject!(reason, rejected_by = nil)
+      update!(status: :rejected, rejection_reason: reason, completed_at: Time.current)
+    end
+
+    def can_be_approved_via_api?
+      status_submitted? || status_under_review?
+    end
+
+    def can_be_rejected_via_api?
+      status_submitted? || status_under_review?
+    end
+
+    def has_account?
+      Account.exists?(application: self)
+    end
+
+    def create_account_if_approved
+      if saved_change_to_status? && status_approved?
+        AccountCreationService.call(self)
+      end
+    end
+
+    private
+
+    def generate_application_number
+      prefix = applicant_type == "individual" ? "IND" : "BUS"
+      timestamp = Time.current.strftime("%Y%m%d")
+      random_suffix = SecureRandom.random_number(10000).to_s.rjust(4, "0")
+      self.application_number = "#{prefix}#{timestamp}#{random_suffix}"
+    end
+
+    def set_timestamps_on_status_change
+      if status_changed?
+        case status
+        when "submitted"
+          self.submitted_at = Time.current
+        when "completed"
+          self.completed_at = Time.current
+        end
+      end
+    end
+  end
+end

data/app/models/dscf/banking/transaction.rb

@@ -0,0 +1,68 @@
+module Dscf::Banking
+  class Transaction < ApplicationRecord
+    belongs_to :account, class_name: "Dscf::Banking::Account"
+    belongs_to :transaction_type, class_name: "Dscf::Banking::TransactionType"
+    belongs_to :debit_account, class_name: "Dscf::Banking::Account"
+    belongs_to :credit_account, class_name: "Dscf::Banking::Account"
+
+    enum :status, {
+      pending: 0,
+      processing: 1,
+      completed: 2,
+      failed: 3,
+      cancelled: 4
+    }
+
+    validates :amount, presence: true, numericality: { greater_than: 0 }
+    validates :currency, presence: true
+    validates :reference_number, presence: true, uniqueness: true
+
+    validate :different_debit_credit_accounts
+    validate :account_currency_consistency
+
+    before_validation :set_defaults, on: :create
+    before_validation :generate_reference_number, if: -> { reference_number.nil? }
+
+    scope :by_account, ->(account_id) { where(account_id: account_id) }
+    scope :by_type, ->(type_code) { joins(:transaction_type).where(dscf_banking_transaction_types: { code: type_code.upcase }) }
+    scope :by_status, ->(status) { where(status: status) }
+    scope :recent, -> { order(created_at: :desc) }
+
+    def settlement_transaction?
+      debit_account.system_account? || credit_account.system_account?
+    end
+
+    def customer_transaction?
+      !settlement_transaction?
+    end
+
+    private
+
+    def different_debit_credit_accounts
+      return unless debit_account_id && credit_account_id
+
+      if debit_account_id == credit_account_id
+        errors.add(:credit_account, "must be different from debit account")
+      end
+    end
+
+    def account_currency_consistency
+      return unless account && currency
+
+      if account.currency != currency
+        errors.add(:currency, "must match account currency")
+      end
+    end
+
+    def set_defaults
+      self.currency ||= account&.currency || "ETB"
+      self.status ||= :pending
+    end
+
+    def generate_reference_number
+      timestamp = Time.current.strftime("%Y%m%d%H%M%S")
+      random_suffix = SecureRandom.hex(4).upcase
+      self.reference_number = "TXN#{timestamp}#{random_suffix}"
+    end
+  end
+end

data/app/models/dscf/banking/transaction_type.rb

@@ -0,0 +1,20 @@
+module Dscf::Banking
+  class TransactionType < ApplicationRecord
+    has_many :transactions, class_name: "Dscf::Banking::Transaction", dependent: :restrict_with_error
+
+    validates :code, presence: true, uniqueness: { case_sensitive: false }
+    validates :name, presence: true
+
+    before_save :upcase_code
+
+    def self.find_by_code(code)
+      find_by(code: code.to_s.upcase)
+    end
+
+    private
+
+    def upcase_code
+      self.code = code.upcase if code.present?
+    end
+  end
+end

data/app/serializers/dscf/banking/account_serializer.rb

@@ -0,0 +1,11 @@
+module Dscf::Banking
+  class AccountSerializer < ActiveModel::Serializer
+    attributes :id, :account_number, :name, :status, :activation_date, :closure_date,
+               :account_properties, :current_balance, :available_balance, :minimum_balance,
+               :currency, :active, :created_at, :updated_at
+
+    belongs_to :virtual_account_product, serializer: VirtualAccountProductSerializer
+
+    attribute :application_id
+  end
+end

data/app/serializers/dscf/banking/application_serializer.rb

@@ -0,0 +1,16 @@
+module Dscf::Banking
+  class ApplicationSerializer < ActiveModel::Serializer
+    attributes :id, :application_number, :applicant_type, :status, :form_data,
+               :submitted_at, :completed_at, :rejection_reason, :created_at, :updated_at
+
+    belongs_to :user
+    belongs_to :virtual_account_product, serializer: VirtualAccountProductSerializer
+    belongs_to :assigned_kyc_officer, optional: true
+    belongs_to :assigned_branch_manager, optional: true
+    has_one :account, serializer: AccountSerializer, if: :has_account?
+
+    def has_account?
+      object.has_account?
+    end
+  end
+end

data/app/serializers/dscf/banking/transaction_serializer.rb

@@ -0,0 +1,19 @@
+module Dscf::Banking
+  class TransactionSerializer < ActiveModel::Serializer
+    attributes :id, :reference_number, :amount, :currency, :description,
+               :status, :created_at, :updated_at
+
+    belongs_to :account
+    belongs_to :transaction_type
+    belongs_to :debit_account, serializer: Dscf::Banking::AccountSerializer
+    belongs_to :credit_account, serializer: Dscf::Banking::AccountSerializer
+
+    def status
+      object.status.humanize
+    end
+
+    def amount
+      object.amount.to_f
+    end
+  end
+end

data/app/serializers/dscf/banking/transaction_type_serializer.rb

@@ -0,0 +1,9 @@
+module Dscf::Banking
+  class TransactionTypeSerializer < ActiveModel::Serializer
+    attributes :id, :code, :name, :description, :created_at, :updated_at
+
+    def code
+      object.code.upcase
+    end
+  end
+end

data/app/services/dscf/banking/account_creation_service.rb

@@ -0,0 +1,53 @@
+module Dscf::Banking
+  class AccountCreationService
+    def self.call(application)
+      new(application).call
+    end
+
+    def initialize(application)
+      @application = application
+    end
+
+    def call
+      return nil unless @application.status_approved?
+      return nil if account_already_exists?
+
+      create_account
+    rescue => e
+      Rails.logger.error "Account creation failed: #{e.message}" if defined?(Rails)
+      nil
+    end
+
+    private
+
+    attr_reader :application
+
+    def account_already_exists?
+      Account.exists?(application: @application)
+    end
+
+    def create_account
+      account = Account.new(
+        application: @application,
+        virtual_account_product: @application.virtual_account_product,
+        name: generate_account_name,
+        currency: "ETB",
+        minimum_balance: 0,
+        current_balance: 0,
+        available_balance: 0,
+        status: :draft
+      )
+
+      if account.save
+        account
+      else
+        Rails.logger.error "Account validation failed: #{account.errors.full_messages}" if defined?(Rails)
+        nil
+      end
+    end
+
+    def generate_account_name
+      "Test Account - #{@application.application_number}"
+    end
+  end
+end

data/app/services/dscf/banking/base_transaction_service.rb

@@ -0,0 +1,99 @@
+module Dscf::Banking
+  class BaseTransactionService
+    attr_reader :errors
+
+    def initialize
+      @errors = []
+    end
+
+    def success?
+      errors.empty?
+    end
+
+    def failure?
+      !success?
+    end
+
+    private
+
+    def add_error(message)
+      @errors << message
+    end
+
+    def validate_account_active(account, account_type = "Account")
+      unless account.active? && account.status == "active"
+        add_error("#{account_type} is not active")
+        return false
+      end
+      true
+    end
+
+    def validate_sufficient_funds(account, amount)
+      unless account.sufficient_funds_for_withdrawal?(amount)
+        add_error("Insufficient funds. Available balance: #{account.available_balance}, Required: #{amount}")
+        return false
+      end
+      true
+    end
+
+    def find_or_create_transaction_type(code)
+      transaction_type = Dscf::Banking::TransactionType.find_by_code(code)
+      unless transaction_type
+        add_error("Transaction type '#{code}' not found")
+        return nil
+      end
+      transaction_type
+    end
+
+    def create_transaction(params)
+      transaction = Dscf::Banking::Transaction.new(params)
+      unless transaction.save
+        transaction.errors.full_messages.each { |msg| add_error(msg) }
+        return nil
+      end
+      transaction
+    end
+
+    def update_account_balances(debit_account, credit_account, amount)
+      ActiveRecord::Base.transaction do
+        # Update debit account (decrease balance)
+        new_debit_balance = debit_account.current_balance - amount
+        new_debit_available = debit_account.available_balance - amount
+
+        unless debit_account.update(
+          current_balance: new_debit_balance,
+          available_balance: new_debit_available
+        )
+          debit_account.errors.full_messages.each { |msg| add_error("Debit account: #{msg}") }
+          raise ActiveRecord::Rollback
+        end
+
+        # Update credit account (increase balance)
+        new_credit_balance = credit_account.current_balance + amount
+        new_credit_available = credit_account.available_balance + amount
+
+        unless credit_account.update(
+          current_balance: new_credit_balance,
+          available_balance: new_credit_available
+        )
+          credit_account.errors.full_messages.each { |msg| add_error("Credit account: #{msg}") }
+          raise ActiveRecord::Rollback
+        end
+      end
+
+      success?
+    end
+
+    def process_transaction(transaction)
+      transaction.update(status: :processing)
+
+      if update_account_balances(transaction.debit_account, transaction.credit_account, transaction.amount)
+        transaction.update(status: :completed)
+        true
+      else
+        transaction.update(status: :failed)
+        false
+      end
+    end
+  end
+end

data/app/services/dscf/banking/deposit_service.rb

@@ -0,0 +1,97 @@
+module Dscf::Banking
+  class DepositService < BaseTransactionService
+    attr_reader :transaction
+
+    def initialize(account:, amount:, description:, transaction_type_code: "DEPOSIT")
+      super()
+      @account = account
+      @amount = amount.to_f
+      @description = description
+      @transaction_type_code = transaction_type_code
+      @transaction = nil
+    end
+
+    def execute
+      return self unless validate_deposit
+
+      ActiveRecord::Base.transaction do
+        create_deposit_transaction
+        return self unless success?
+
+        process_deposit
+        return self unless success?
+      end
+
+      self
+    end
+
+    private
+
+    def validate_deposit
+      # Validate account
+      return false unless validate_account_active(@account, "Target account")
+
+      # Validate amount
+      if @amount <= 0
+        add_error("Deposit amount must be greater than zero")
+        return false
+      end
+
+      true
+    end
+
+    def create_deposit_transaction
+      transaction_type = find_or_create_transaction_type(@transaction_type_code)
+      return unless transaction_type
+
+      # For deposits, we need a system account as the debit account
+      # This represents the external source (like mobile banking - Abole)
+      system_account = find_or_create_system_account
+
+      @transaction = create_transaction(
+        account: @account, # Primary account for the transaction
+        transaction_type: transaction_type,
+        debit_account: system_account, # External source
+        credit_account: @account, # Customer account receiving the deposit
+        amount: @amount,
+        currency: @account.currency,
+        description: @description,
+        status: :pending
+      )
+    end
+
+    def process_deposit
+      @transaction.update(status: :processing)
+
+      # Update account balance (increase for deposit)
+      new_balance = @account.current_balance + @amount
+      new_available = @account.available_balance + @amount
+
+      if @account.update(current_balance: new_balance, available_balance: new_available)
+        @transaction.update(status: :completed)
+        true
+      else
+        @account.errors.full_messages.each { |msg| add_error(msg) }
+        @transaction.update(status: :failed)
+        false
+      end
+    end
+
+    def find_or_create_system_account
+      # Find or create a system account for external deposits
+      system_account = Dscf::Banking::Account.system_accounts
+                                            .where(currency: @account.currency)
+                                            .where("name LIKE ?", "%Deposit%")
+                                            .first
+
+      unless system_account
+        # In a real system, this would be pre-created during setup
+        # For now, we'll assume it exists or create a placeholder
+        add_error("System deposit account not found for currency #{@account.currency}")
+        return nil
+      end
+
+      system_account
+    end
+  end
+end