dscf-banking 0.1.14 → 0.1.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4ca1ade5bfdb0a8bf2472275df55b6b4209c0306bcc747a8ca065637b159177
-  data.tar.gz: 2d5d05152332e6d287dbbff3b1ec9ea255714015d7d59695f67f28986ee4cddc
+  metadata.gz: 3be6cb234512da6ec3f02e719d9f3a7315c29711a1510541c4f6431bb7c2934a
+  data.tar.gz: 4e1d771356543e224441f1c68b4e8d343c755be3dbc72299e79cec4871e4fabd
 SHA512:
-  metadata.gz: b5e05d2e67811e0fb3edc22c2652cf1b0febfd34e3a9bde6c9a51facae604b90df1d14c141bc4a770a169d6b1d6e6fb2fbadbfc8a3a080bdc0ab5f61bf7077fe
-  data.tar.gz: 05fe6fd1c9d99252eba049c1eda43510d9d3dff737833945cf79c20ba2aaf0daa0e7839ceed42a1226db91a4748f3a2a2dbeaa55c86154589bfc76439eccf918
+  metadata.gz: 7b45b884c53a7fa29feb90a0d33aa584b48b961560504eaa97a2802446e32d8508169e180557947195b34fb5d02ee25fe728ae1d881180d45f13238b230ec305
+  data.tar.gz: 2f0828d64d4dee6222e155e97dfeae0f1bcfb66f9162ae7566baf34b82cd5c603821def2de710633662206993cf6055817c766a5a9706a595a069e69e16465a8

data/app/controllers/dscf/banking/transaction_types_controller.rb

@@ -0,0 +1,27 @@
+module Dscf::Banking
+  class TransactionTypesController < ApplicationController
+    include Dscf::Core::Common
+
+    private
+
+    def model_params
+      params.require(:payload).permit(
+        :code,
+        :name,
+        :description
+      )
+    end
+
+    def eager_loaded_associations
+      []
+    end
+
+    def allowed_order_columns
+      %w[id code name created_at updated_at]
+    end
+
+    def default_serializer_includes
+      {}
+    end
+  end
+end

data/app/controllers/dscf/banking/transactions_controller.rb

@@ -0,0 +1,275 @@
+module Dscf::Banking
+  class TransactionsController < ApplicationController
+    include Dscf::Core::Common
+
+    # Transfer money between accounts (from test cases)
+    def transfer
+      debit_account = Dscf::Banking::Account.find_by(account_number: transfer_params[:debit_account_number])
+      credit_account = Dscf::Banking::Account.find_by(account_number: transfer_params[:credit_account_number])
+
+      unless debit_account
+        return render json: {
+          success: false,
+          error: "Debit account not found",
+          errors: [ "Account with number #{transfer_params[:debit_account_number]} not found" ]
+        }, status: :not_found
+      end
+
+      unless credit_account
+        return render json: {
+          success: false,
+          error: "Credit account not found",
+          errors: [ "Account with number #{transfer_params[:credit_account_number]} not found" ]
+        }, status: :not_found
+      end
+
+      result = Dscf::Banking::TransferService.new(
+        debit_account: debit_account,
+        credit_account: credit_account,
+        amount: transfer_params[:amount],
+        description: transfer_params[:description] || "Transfer between accounts",
+        transaction_type_code: transfer_params[:transaction_type_code] || "TRANSFER"
+      ).execute
+
+      if result.success?
+        render json: {
+          success: true,
+          data: transaction_data(result.transaction),
+          message: "Transfer completed successfully"
+        }
+      else
+        render json: {
+          success: false,
+          error: "Transfer failed",
+          errors: result.errors
+        }, status: :unprocessable_entity
+      end
+    rescue StandardError => e
+      render json: {
+        success: false,
+        error: "Transfer failed",
+        errors: [ e.message ]
+      }, status: :internal_server_error
+    end
+
+    # Deposit money to account (from mobile banking - Abole)
+    def deposit
+      account = Dscf::Banking::Account.find_by(account_number: deposit_params[:account_number])
+
+      unless account
+        return render json: {
+          success: false,
+          error: "Account not found",
+          errors: [ "Account with number #{deposit_params[:account_number]} not found" ]
+        }, status: :not_found
+      end
+
+      result = Dscf::Banking::DepositService.new(
+        account: account,
+        amount: deposit_params[:amount],
+        description: deposit_params[:description] || "Deposit to account",
+        transaction_type_code: deposit_params[:transaction_type_code] || "DEPOSIT"
+      ).execute
+
+      if result.success?
+        render json: {
+          success: true,
+          data: transaction_data(result.transaction),
+          message: "Deposit completed successfully"
+        }
+      else
+        render json: {
+          success: false,
+          error: "Deposit failed",
+          errors: result.errors
+        }, status: :unprocessable_entity
+      end
+    rescue StandardError => e
+      render json: {
+        success: false,
+        error: "Deposit failed",
+        errors: [ e.message ]
+      }, status: :internal_server_error
+    end
+
+    # Withdraw money from account
+    def withdrawal
+      account = Dscf::Banking::Account.find_by(account_number: withdrawal_params[:account_number])
+
+      unless account
+        return render json: {
+          success: false,
+          error: "Account not found",
+          errors: [ "Account with number #{withdrawal_params[:account_number]} not found" ]
+        }, status: :not_found
+      end
+
+      result = Dscf::Banking::WithdrawalService.new(
+        account: account,
+        amount: withdrawal_params[:amount],
+        description: withdrawal_params[:description] || "Withdrawal from account",
+        transaction_type_code: withdrawal_params[:transaction_type_code] || "WITHDRAWAL"
+      ).execute
+
+      if result.success?
+        render json: {
+          success: true,
+          data: transaction_data(result.transaction),
+          message: "Withdrawal completed successfully"
+        }
+      else
+        render json: {
+          success: false,
+          error: "Withdrawal failed",
+          errors: result.errors
+        }, status: :unprocessable_entity
+      end
+    rescue StandardError => e
+      render json: {
+        success: false,
+        error: "Withdrawal failed",
+        errors: [ e.message ]
+      }, status: :internal_server_error
+    end
+
+    # Cancel a transaction
+    def cancel
+      transaction = Dscf::Banking::Transaction.find(params[:id])
+
+      unless transaction.status == "pending"
+        return render json: {
+          success: false,
+          error: "Cannot cancel transaction",
+          errors: [ "Only pending transactions can be cancelled" ]
+        }, status: :unprocessable_entity
+      end
+
+      if transaction.update(status: :cancelled)
+        render json: {
+          success: true,
+          data: transaction_data(transaction),
+          message: "Transaction cancelled successfully"
+        }
+      else
+        render json: {
+          success: false,
+          error: "Failed to cancel transaction",
+          errors: transaction.errors.full_messages
+        }, status: :unprocessable_entity
+      end
+    rescue ActiveRecord::RecordNotFound
+      render json: {
+        success: false,
+        error: "Transaction not found"
+      }, status: :not_found
+    end
+
+    # Get transaction details with related account information
+    def details
+      transaction = Dscf::Banking::Transaction.includes(:account, :debit_account, :credit_account, :transaction_type).find(params[:id])
+
+      render json: {
+        success: true,
+        data: transaction_data_with_details(transaction)
+      }
+    rescue ActiveRecord::RecordNotFound
+      render json: {
+        success: false,
+        error: "Transaction not found"
+      }, status: :not_found
+    end
+
+    private
+
+    def transfer_params
+      params.require(:transfer).permit(:debit_account_number, :credit_account_number, :amount, :description, :transaction_type_code)
+    end
+
+    def deposit_params
+      params.require(:deposit).permit(:account_number, :amount, :description, :transaction_type_code)
+    end
+
+    def withdrawal_params
+      params.require(:withdrawal).permit(:account_number, :amount, :description, :transaction_type_code)
+    end
+
+    def transaction_data(transaction)
+      {
+        id: transaction.id,
+        reference_number: transaction.reference_number,
+        amount: transaction.amount.to_f,
+        currency: transaction.currency,
+        description: transaction.description,
+        status: transaction.status,
+        account_id: transaction.account_id,
+        debit_account_id: transaction.debit_account_id,
+        credit_account_id: transaction.credit_account_id,
+        transaction_type_id: transaction.transaction_type_id,
+        created_at: transaction.created_at,
+        updated_at: transaction.updated_at
+      }
+    end
+
+    def transaction_data_with_details(transaction)
+      {
+        id: transaction.id,
+        reference_number: transaction.reference_number,
+        amount: transaction.amount.to_f,
+        currency: transaction.currency,
+        description: transaction.description,
+        status: transaction.status,
+        account: account_summary(transaction.account),
+        debit_account: account_summary(transaction.debit_account),
+        credit_account: account_summary(transaction.credit_account),
+        transaction_type: {
+          id: transaction.transaction_type.id,
+          code: transaction.transaction_type.code,
+          name: transaction.transaction_type.name
+        },
+        created_at: transaction.created_at,
+        updated_at: transaction.updated_at
+      }
+    end
+
+    def account_summary(account)
+      return nil unless account
+      {
+        id: account.id,
+        account_number: account.account_number,
+        name: account.name,
+        currency: account.currency,
+        current_balance: account.current_balance
+      }
+    end
+
+    def model_params
+      params.require(:payload).permit(
+        :account_id,
+        :transaction_type_id,
+        :debit_account_id,
+        :credit_account_id,
+        :amount,
+        :currency,
+        :description,
+        :status
+      )
+    end
+
+    def eager_loaded_associations
+      [ :account, :transaction_type, :debit_account, :credit_account ]
+    end
+
+    def allowed_order_columns
+      %w[id reference_number amount currency status created_at updated_at]
+    end
+
+    def default_serializer_includes
+      {
+        account: {},
+        transaction_type: {},
+        debit_account: {},
+        credit_account: {}
+      }
+    end
+  end
+end

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

@@ -1,7 +1,7 @@
 module Dscf::Banking
   class Account < ApplicationRecord
-    belongs_to :virtual_account_product
-    belongs_to :application
+    belongs_to :virtual_account_product, optional: true
+    belongs_to :application, optional: true
 
     enum :status, {
       draft: 0,
@@ -17,12 +17,16 @@ module Dscf::Banking
     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
@@ -84,5 +88,23 @@ module Dscf::Banking
       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/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/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/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

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

@@ -0,0 +1,125 @@
+# db/seeds.rb
+
+# 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..."
+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..."
+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)"
+
+  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)"
+
+  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)"
+
+  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)"
+
+  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)"
+
+  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" }
+  ]
+
+  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 "DSCF Banking Engine seed data completed successfully!"

data/lib/dscf/banking/version.rb

@@ -1,5 +1,5 @@
 module Dscf
   module Banking
-    VERSION = "0.1.14"
+    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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dscf-banking
 version: !ruby/object:Gem::Version
-  version: 0.1.14
+  version: 0.1.16
 platform: ruby
 authors:
 - Eyosiyas Mekbib
 bindir: bin
 cert_chain: []
-date: 2025-09-15 00:00:00.000000000 Z
+date: 2025-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -447,6 +447,8 @@ files:
 - app/controllers/dscf/banking/interest_rate_types_controller.rb
 - app/controllers/dscf/banking/product_approvals_controller.rb
 - app/controllers/dscf/banking/product_categories_controller.rb
+- app/controllers/dscf/banking/transaction_types_controller.rb
+- app/controllers/dscf/banking/transactions_controller.rb
 - app/controllers/dscf/banking/virtual_account_products_controller.rb
 - app/jobs/dscf/banking/application_job.rb
 - app/mailers/dscf/banking/application_mailer.rb
@@ -460,6 +462,8 @@ files:
 - app/models/dscf/banking/product_approval.rb
 - app/models/dscf/banking/product_audit_log.rb
 - app/models/dscf/banking/product_category.rb
+- app/models/dscf/banking/transaction.rb
+- app/models/dscf/banking/transaction_type.rb
 - app/models/dscf/banking/virtual_account_product.rb
 - app/serializers/dscf/banking/account_serializer.rb
 - app/serializers/dscf/banking/application_serializer.rb
@@ -468,8 +472,14 @@ files:
 - app/serializers/dscf/banking/interest_rate_type_serializer.rb
 - app/serializers/dscf/banking/product_approval_serializer.rb
 - app/serializers/dscf/banking/product_category_serializer.rb
+- app/serializers/dscf/banking/transaction_serializer.rb
+- app/serializers/dscf/banking/transaction_type_serializer.rb
 - app/serializers/dscf/banking/virtual_account_product_serializer.rb
 - app/services/dscf/banking/account_creation_service.rb
+- app/services/dscf/banking/base_transaction_service.rb
+- app/services/dscf/banking/deposit_service.rb
+- app/services/dscf/banking/transfer_service.rb
+- app/services/dscf/banking/withdrawal_service.rb
 - config/routes.rb
 - db/migrate/20250830211002_create_dscf_banking_product_categories.rb
 - db/migrate/20250830211027_create_dscf_banking_interest_rate_types.rb
@@ -482,6 +492,11 @@ files:
 - db/migrate/20250831084706_allow_null_virtual_account_product_id_in_product_audit_logs.rb
 - db/migrate/20250912193134_create_dscf_banking_applications.rb
 - db/migrate/20250912203527_create_dscf_banking_accounts.rb
+- db/migrate/20250919084147_add_account_type_to_accounts.rb
+- db/migrate/20250919084927_make_account_associations_optional.rb
+- db/migrate/20250919182831_create_dscf_banking_transaction_types.rb
+- db/migrate/20250919184220_create_dscf_banking_transactions.rb
+- db/seeds.rb
 - lib/dscf/banking.rb
 - lib/dscf/banking/engine.rb
 - lib/dscf/banking/version.rb
@@ -494,6 +509,8 @@ files:
 - spec/factories/dscf/banking/product_approvals.rb
 - spec/factories/dscf/banking/product_audit_logs.rb
 - spec/factories/dscf/banking/product_categories.rb
+- spec/factories/dscf/banking/transaction_types.rb
+- spec/factories/dscf/banking/transactions.rb
 - spec/factories/dscf/banking/virtual_account_products.rb
 homepage: https://mksaddis.com/
 licenses: []