dscf-banking 0.1.15 → 0.1.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f53a3bc93d277dada58412069b4fbd4e5dda1878b4ebb361d55377ad1aa60338
-  data.tar.gz: 3b0890dcb58acccbe42e6edf620c0835a37a64fd5ce3f86ca0fc16ac2b723fd1
+  metadata.gz: 3be6cb234512da6ec3f02e719d9f3a7315c29711a1510541c4f6431bb7c2934a
+  data.tar.gz: 4e1d771356543e224441f1c68b4e8d343c755be3dbc72299e79cec4871e4fabd
 SHA512:
-  metadata.gz: 66bfaaba90120d6a43baa41839b3d705aa6a2c923a82f28316253b0762ff3b2036dfe340df5c82c1898fb489184acd4764129b47e4f6f1da29ab396c89c1fac8
-  data.tar.gz: 62dedb335c91073a61d023b804d7e9b5e2ccb6c392097911640535484caa88fbbb58030bcdab05459ed32e389a5dcfab4d06991f4dd75c603a76097b1b120dbc
+  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