dscf-banking 0.1.15 → 0.1.16

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

@@ -0,0 +1,78 @@
+module Dscf::Banking
+  class TransferService < BaseTransactionService
+    attr_reader :transaction
+
+    def initialize(debit_account:, credit_account:, amount:, description:, transaction_type_code: "TRANSFER")
+      super()
+      @debit_account = debit_account
+      @credit_account = credit_account
+      @amount = amount.to_f
+      @description = description
+      @transaction_type_code = transaction_type_code
+      @transaction = nil
+    end
+
+    def execute
+      return self unless validate_transfer
+
+      ActiveRecord::Base.transaction do
+        create_transfer_transaction
+        return self unless success?
+
+        process_transaction(@transaction)
+        return self unless success?
+      end
+
+      self
+    end
+
+    private
+
+    def validate_transfer
+      # Validate debit account
+      return false unless validate_account_active(@debit_account, "Debit account")
+
+      # Validate credit account
+      return false unless validate_account_active(@credit_account, "Credit account")
+
+      # Validate amount
+      if @amount <= 0
+        add_error("Transfer amount must be greater than zero")
+        return false
+      end
+
+      # Validate sufficient funds
+      return false unless validate_sufficient_funds(@debit_account, @amount)
+
+      # Validate different accounts
+      if @debit_account.id == @credit_account.id
+        add_error("Cannot transfer to the same account")
+        return false
+      end
+
+      # Validate currency match
+      if @debit_account.currency != @credit_account.currency
+        add_error("Currency mismatch between accounts")
+        return false
+      end
+
+      true
+    end
+
+    def create_transfer_transaction
+      transaction_type = find_or_create_transaction_type(@transaction_type_code)
+      return unless transaction_type
+
+      @transaction = create_transaction(
+        account: @debit_account, # Primary account for the transaction
+        transaction_type: transaction_type,
+        debit_account: @debit_account,
+        credit_account: @credit_account,
+        amount: @amount,
+        currency: @debit_account.currency,
+        description: @description,
+        status: :pending
+      )
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+module Dscf::Banking
+  class WithdrawalService < BaseTransactionService
+    attr_reader :transaction
+
+    def initialize(account:, amount:, description:, transaction_type_code: "WITHDRAWAL")
+      super()
+      @account = account
+      @amount = amount.to_f
+      @description = description
+      @transaction_type_code = transaction_type_code
+      @transaction = nil
+    end
+
+    def execute
+      return self unless validate_withdrawal
+
+      ActiveRecord::Base.transaction do
+        create_withdrawal_transaction
+        return self unless success?
+
+        process_withdrawal
+        return self unless success?
+      end
+
+      self
+    end
+
+    private
+
+    def validate_withdrawal
+      # Validate account
+      return false unless validate_account_active(@account, "Source account")
+
+      # Validate amount
+      if @amount <= 0
+        add_error("Withdrawal amount must be greater than zero")
+        return false
+      end
+
+      # Validate sufficient funds
+      return false unless validate_sufficient_funds(@account, @amount)
+
+      true
+    end
+
+    def create_withdrawal_transaction
+      transaction_type = find_or_create_transaction_type(@transaction_type_code)
+      return unless transaction_type
+
+      # For withdrawals, we need a system account as the credit account
+      # This represents the external destination
+      system_account = find_or_create_system_account
+
+      @transaction = create_transaction(
+        account: @account, # Primary account for the transaction
+        transaction_type: transaction_type,
+        debit_account: @account, # Customer account being debited
+        credit_account: system_account, # External destination
+        amount: @amount,
+        currency: @account.currency,
+        description: @description,
+        status: :pending
+      )
+    end
+
+    def process_withdrawal
+      @transaction.update(status: :processing)
+
+      # Update account balance (decrease for withdrawal)
+      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 withdrawals
+      system_account = Dscf::Banking::Account.system_accounts
+                                            .where(currency: @account.currency)
+                                            .where("name LIKE ?", "%Withdrawal%")
+                                            .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 withdrawal account not found for currency #{@account.currency}")
+        return nil
+      end
+
+      system_account
+    end
+  end
+end

data/config/routes.rb

@@ -22,4 +22,18 @@ Dscf::Banking::Engine.routes.draw do
       post :reject
     end
   end
+
+  resources :transaction_types
+
+  resources :transactions do
+    collection do
+      post :transfer
+      post :deposit
+      post :withdrawal
+    end
+    member do
+      post :cancel
+      get :details
+    end
+  end
 end

data/db/migrate/20250919084147_add_account_type_to_accounts.rb

@@ -0,0 +1,6 @@
+class AddAccountTypeToAccounts < ActiveRecord::Migration[8.0]
+  def change
+    add_column :dscf_banking_accounts, :system_account, :boolean, default: false, null: false
+    add_index :dscf_banking_accounts, :system_account
+  end
+end

data/db/migrate/20250919084927_make_account_associations_optional.rb

@@ -0,0 +1,6 @@
+class MakeAccountAssociationsOptional < ActiveRecord::Migration[8.0]
+  def change
+    change_column_null :dscf_banking_accounts, :virtual_account_product_id, true
+    change_column_null :dscf_banking_accounts, :application_id, true
+  end
+end

data/db/migrate/20250919182831_create_dscf_banking_transaction_types.rb

@@ -0,0 +1,14 @@
+class CreateDscfBankingTransactionTypes < ActiveRecord::Migration[8.0]
+  def change
+    create_table :dscf_banking_transaction_types do |t|
+      t.string :code, null: false, limit: 20
+      t.string :name, null: false, limit: 100
+      t.text :description
+
+      t.timestamps
+    end
+
+    add_index :dscf_banking_transaction_types, :code, unique: true
+    add_index :dscf_banking_transaction_types, :name, unique: true
+  end
+end

data/db/migrate/20250919184220_create_dscf_banking_transactions.rb

@@ -0,0 +1,21 @@
+class CreateDscfBankingTransactions < ActiveRecord::Migration[8.0]
+  def change
+    create_table :dscf_banking_transactions do |t|
+      t.references :account, null: false, foreign_key: { to_table: :dscf_banking_accounts }
+      t.references :transaction_type, null: false, foreign_key: { to_table: :dscf_banking_transaction_types }
+      t.decimal :amount, precision: 20, scale: 4, null: false
+      t.string :currency, null: false, default: "ETB"
+      t.string :reference_number, null: false
+      t.text :description
+      t.integer :status, default: 0, null: false
+      t.references :debit_account, null: false, foreign_key: { to_table: :dscf_banking_accounts }
+      t.references :credit_account, null: false, foreign_key: { to_table: :dscf_banking_accounts }
+
+      t.timestamps
+    end
+
+    add_index :dscf_banking_transactions, :status
+    add_index :dscf_banking_transactions, :reference_number, unique: true
+    add_index :dscf_banking_transactions, [ :account_id, :created_at ]
+  end
+end

data/db/seeds.rb

@@ -1,51 +1,125 @@
 # db/seeds.rb
-# This file should contain all the record creation needed to seed the database with its default values.
-# The data can then be loaded with the bin/rails db:seed command (or created alongside the database with db:setup).
-#
-# Examples:
-#
-#   movies = Movie.create([{ name: "Star Wars" }, { name: "Lord of the Rings" }])
-#   Character.create(name: "Luke", movie: movies.first)
-
-# Seed roles based on RBAC documentation
+
+# DEBUG: Confirm seed file execution and model availability
+puts "Seed file started"
+puts "Dscf::Core::User loaded? => #{defined?(Dscf::Core::User)}"
+puts "Dscf::Core::Role loaded? => #{defined?(Dscf::Core::Role)}"
+
+# DSCF Banking Engine Seed Data
+# This file seeds the database with sample data for all models in the correct dependency order
+
+puts "Starting DSCF Banking Engine seed data..."
+
+
+# 1. Seed roles (if model exists)
 puts "Seeding roles..."
-user_role = Role.find_or_create_by(name: 'User')
-officer_role = Role.find_or_create_by(name: 'Virtual Account Officer')
-manager_role = Role.find_or_create_by(name: 'Virtual Account Manager')
-kyc_officer_role = Role.find_or_create_by(name: 'KYC Officer')
-branch_manager_role = Role.find_or_create_by(name: 'Branch Manager')
-puts "Roles seeded successfully."
-
-# Seed users with roles
+if defined?(Dscf::Core::Role)
+  user_role = Dscf::Core::Role.find_or_create_by(code: 'user') do |role|
+    role.name = 'User'
+  end
+  officer_role = Dscf::Core::Role.find_or_create_by(code: 'virtual_account_officer') do |role|
+    role.name = 'Virtual Account Officer'
+  end
+  manager_role = Dscf::Core::Role.find_or_create_by(code: 'virtual_account_manager') do |role|
+    role.name = 'Virtual Account Manager'
+  end
+  kyc_officer_role = Dscf::Core::Role.find_or_create_by(code: 'kyc_officer') do |role|
+    role.name = 'KYC Officer'
+  end
+  branch_manager_role = Dscf::Core::Role.find_or_create_by(code: 'branch_manager') do |role|
+    role.name = 'Branch Manager'
+  end
+  puts "✓ Roles created/found"
+else
+  puts "Warning: Dscf::Core::Role model not found. Skipping role seeding."
+end
+# 2. Seed users with roles (if model exists)
 puts "Seeding users..."
-# Create users and assign roles
-user1 = User.create(name: "Abebe Kebede", email: "abebe@example.com", password: "SecurePassword123!")
-user1.roles << user_role
-puts "Created user: #{user1.name}"
+if defined?(Dscf::Core::User)
+  user1 = Dscf::Core::User.find_or_create_by(email: "user@banking.com") do |u|
+    u.phone = "+251911123456"
+    u.password = "SecurePassword123!"
+    u.verified_at = Time.current
+    u.temp_password = false
+  end
+  user1.roles << user_role if defined?(user_role)
+  puts "Created user: #{user1.email} (user@banking.com)"
+
+  user2 = Dscf::Core::User.find_or_create_by(email: "virtual_account_officer@banking.com") do |u|
+    u.phone = "+251922123456"
+    u.password = "SecurePassword123!"
+    u.verified_at = Time.current
+    u.temp_password = false
+  end
+  user2.roles << officer_role if defined?(officer_role)
+  puts "Created user: #{user2.email} (virtual_account_officer@banking.com)"
 
-user2 = User.create(name: "Tigist Haile", email: "tigist@example.com", password: "SecurePassword123!")
-user2.roles << officer_role
-puts "Created user: #{user2.name}"
+  user3 = Dscf::Core::User.find_or_create_by(email: "virtual_account_manager@banking.com") do |u|
+    u.phone = "+251933123456"
+    u.password = "SecurePassword123!"
+    u.verified_at = Time.current
+    u.temp_password = false
+  end
+  user3.roles << manager_role if defined?(manager_role)
+  puts "Created user: #{user3.email} (virtual_account_manager@banking.com)"
 
-user3 = User.create(name: "Dawit Mekonnen", email: "dawit@example.com", password: "SecurePassword123!")
-user3.roles << manager_role
-puts "Created user: #{user3.name}"
+  user4 = Dscf::Core::User.find_or_create_by(email: "user_virtual_account_officer@banking.com") do |u|
+    u.phone = "+251944123456"
+    u.password = "SecurePassword123!"
+    u.verified_at = Time.current
+    u.temp_password = false
+  end
+  user4.roles << user_role if defined?(user_role)
+  user4.roles << officer_role if defined?(officer_role)
+  puts "Created user: #{user4.email} (user_virtual_account_officer@banking.com)"
 
-# Additional users for testing
-user4 = User.create(name: "Hirut Assefa", email: "hirut@example.com", password: "SecurePassword123!")
-user4.roles << [user_role, officer_role]  # User with multiple roles if supported
-puts "Created user: #{user4.name}"
+  user5 = Dscf::Core::User.find_or_create_by(email: "virtual_account_manager2@banking.com") do |u|
+    u.phone = "+251955123456"
+    u.password = "SecurePassword123!"
+    u.verified_at = Time.current
+    u.temp_password = false
+  end
+  user5.roles << manager_role if defined?(manager_role)
+  puts "Created user: #{user5.email} (virtual_account_manager2@banking.com)"
 
-user5 = User.create(name: "Solomon Tesfaye", email: "solomon@example.com", password: "SecurePassword123!")
-user5.roles << manager_role
-puts "Created user: #{user5.name}"
+  user6 = Dscf::Core::User.find_or_create_by(email: "kyc_officer@banking.com") do |u|
+    u.phone = "+251966123456"
+    u.password = "SecurePassword123!"
+    u.verified_at = Time.current
+    u.temp_password = false
+  end
+  user6.roles << kyc_officer_role if defined?(kyc_officer_role)
+  puts "Created user: #{user6.email} (kyc_officer@banking.com)"
 
-user6 = User.create(name: "Mulugeta Bekele", email: "mulugeta@example.com", password: "SecurePassword123!")
-user6.roles << kyc_officer_role
-puts "Created user: #{user6.name}"
+  user7 = Dscf::Core::User.find_or_create_by(email: "branch_manager@banking.com") do |u|
+    u.phone = "+251977123456"
+    u.password = "SecurePassword123!"
+    u.verified_at = Time.current
+    u.temp_password = false
+  end
+  user7.roles << branch_manager_role if defined?(branch_manager_role)
+  puts "Created user: #{user7.email} (branch_manager@banking.com)"
+else
+  puts "Warning: Dscf::Core::User model not found. Skipping user seeding."
+end# 3. Seed transaction types (engine model)
+puts "Seeding transaction types..."
+if defined?(Dscf::Banking::TransactionType)
+  transaction_types = [
+    { name: "Deposit", code: "DEP" },
+    { name: "Withdrawal", code: "WDL" },
+    { name: "Transfer", code: "TRF" },
+    { name: "Interest Credit", code: "INTC" },
+    { name: "Fee Debit", code: "FEED" }
+  ]
 
-user7 = User.create(name: "Fikirte Alemayehu", email: "fikirte@example.com", password: "SecurePassword123!")
-user7.roles << branch_manager_role
-puts "Created user: #{user7.name}"
+  transaction_types.each do |attrs|
+    Dscf::Banking::TransactionType.find_or_create_by(code: attrs[:code]) do |tt|
+      tt.name = attrs[:name]
+    end
+  end
+  puts "✓ Transaction types created/found"
+else
+  puts "Warning: Dscf::Banking::TransactionType not found. Skipping transaction type seeding."
+end
 
-puts "Seeding completed successfully."
+puts "DSCF Banking Engine seed data completed successfully!"

data/lib/dscf/banking/version.rb

@@ -1,5 +1,5 @@
 module Dscf
   module Banking
-    VERSION = "0.1.15"
+    VERSION = "0.1.16"
   end
 end

data/spec/factories/dscf/banking/accounts.rb

@@ -10,6 +10,7 @@ FactoryBot.define do
     minimum_balance { 0 }
     status { :draft }
     active { true }
+    system_account { false }
     account_properties { {} }
 
     trait :active do
@@ -32,6 +33,33 @@ FactoryBot.define do
       available_balance { 1000 }
       minimum_balance { 100 }
     end
+
+    trait :system_account do
+      system_account { true }
+      virtual_account_product { nil }
+      application { nil }
+    end
+
+    trait :settlement_account do
+      system_account { true }
+      name { "Core Banking Settlement Account" }
+      virtual_account_product { nil }
+      application { nil }
+    end
+
+    trait :interest_expense_account do
+      system_account { true }
+      name { "Interest Expense Account" }
+      virtual_account_product { nil }
+      application { nil }
+    end
+
+    trait :tax_liability_account do
+      system_account { true }
+      name { "Interest Tax Payable Account" }
+      virtual_account_product { nil }
+      application { nil }
+    end
   end
 
   # Alias for shared spec compatibility

data/spec/factories/dscf/banking/applications.rb

@@ -4,6 +4,7 @@ FactoryBot.define do
     association :virtual_account_product
     applicant_type { :individual }
     status { :draft }
+    sequence(:application_number) { |n| "IND#{Date.current.strftime('%Y%m%d')}#{n.to_s.rjust(4, '0')}" }
 
     form_data do
       {
@@ -23,7 +24,7 @@ FactoryBot.define do
 
     trait :business do
       applicant_type { :business }
-      application_type { :current }
+      sequence(:application_number) { |n| "BUS#{Date.current.strftime('%Y%m%d')}#{n.to_s.rjust(4, '0')}" }
       form_data do
         {
           business_name: Faker::Company.name,
@@ -44,21 +45,21 @@ FactoryBot.define do
     trait :under_review do
       status { :under_review }
       submitted_at { 2.days.ago }
-      association :assigned_kyc_officer, factory: [ :user, :dscf_core ]
+      association :assigned_kyc_officer, factory: :user
     end
 
     trait :approved do
       status { :approved }
       submitted_at { 3.days.ago }
-      association :assigned_kyc_officer, factory: [ :user, :dscf_core ]
-      association :assigned_branch_manager, factory: [ :user, :dscf_core ]
+      association :assigned_kyc_officer, factory: :user
+      association :assigned_branch_manager, factory: :user
     end
 
     trait :rejected do
       status { :rejected }
       submitted_at { 3.days.ago }
       rejection_reason { "Incomplete documentation" }
-      association :assigned_kyc_officer, factory: [ :user, :dscf_core ]
+      association :assigned_kyc_officer, factory: :user
     end
   end
 end

data/spec/factories/dscf/banking/transaction_types.rb

@@ -0,0 +1,56 @@
+FactoryBot.define do
+  factory :dscf_banking_transaction_type, class: "Dscf::Banking::TransactionType" do
+    sequence(:code) { |n| "TXN_TYPE_#{n}" }
+    sequence(:name) { |n| "Transaction Type #{n}" }
+    description { "Test transaction type description" }
+
+    trait :deposit do
+      code { "DEPOSIT" }
+      name { "Deposit" }
+      description { "Customer deposit from external source" }
+    end
+
+    trait :withdrawal do
+      code { "WITHDRAWAL" }
+      name { "Withdrawal" }
+      description { "Customer withdrawal to external destination" }
+    end
+
+    trait :transfer do
+      code { "TRANSFER" }
+      name { "Transfer" }
+      description { "Transfer between customer accounts" }
+    end
+
+    trait :interest_credit do
+      code { "INTEREST_CREDIT" }
+      name { "Interest Credit" }
+      description { "Interest payment to customer account" }
+    end
+
+    trait :interest_expense do
+      code { "INTEREST_EXPENSE" }
+      name { "Interest Expense" }
+      description { "Interest expense booking" }
+    end
+
+    trait :tax_withholding do
+      code { "TAX_WITHHOLDING" }
+      name { "Tax Withholding" }
+      description { "Tax withholding on interest payments" }
+    end
+
+    trait :settlement do
+      code { "SETTLEMENT" }
+      name { "Settlement" }
+      description { "Settlement transaction with core banking system" }
+    end
+  end
+
+  # Alias for shared spec compatibility
+  factory :transaction_type, class: "Dscf::Banking::TransactionType" do
+    sequence(:code) { |n| "TXN_TYPE_#{n}" }
+    sequence(:name) { |n| "Transaction Type #{n}" }
+    description { "Test transaction type description" }
+  end
+end

data/spec/factories/dscf/banking/transactions.rb

@@ -0,0 +1,52 @@
+FactoryBot.define do
+  factory :dscf_banking_transaction, class: "Dscf::Banking::Transaction" do
+    association :account, factory: :dscf_banking_account
+    association :transaction_type, factory: [ :dscf_banking_transaction_type, :deposit ]
+    association :debit_account, factory: :dscf_banking_account
+    association :credit_account, factory: :dscf_banking_account
+
+    amount { 1000.00 }
+    currency { "ETB" }
+    description { "Test transaction" }
+    status { :pending }
+
+    trait :deposit do
+      association :transaction_type, factory: [ :dscf_banking_transaction_type, :deposit ]
+
+      after(:build) do |transaction|
+        transaction.credit_account = transaction.account
+        transaction.debit_account = create(:dscf_banking_account, :settlement_account, currency: transaction.currency)
+      end
+    end
+
+    trait :withdrawal do
+      association :transaction_type, factory: [ :dscf_banking_transaction_type, :withdrawal ]
+
+      after(:build) do |transaction|
+        transaction.debit_account = transaction.account
+        transaction.credit_account = create(:dscf_banking_account, :settlement_account, currency: transaction.currency)
+      end
+    end
+
+    trait :completed do
+      status { :completed }
+    end
+
+    trait :failed do
+      status { :failed }
+    end
+  end
+
+  # Alias for shared spec compatibility
+  factory :transaction, class: "Dscf::Banking::Transaction" do
+    association :account, factory: :dscf_banking_account
+    association :transaction_type, factory: [ :dscf_banking_transaction_type, :deposit ]
+    association :debit_account, factory: :dscf_banking_account
+    association :credit_account, factory: :dscf_banking_account
+
+    amount { 1000.00 }
+    currency { "ETB" }
+    description { "Test transaction" }
+    status { :pending }
+  end
+end