dscf-banking 0.1.2 → 0.1.12

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

@@ -1,275 +0,0 @@
-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/transaction.rb

@@ -1,68 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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