dscf-banking 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3bc685fe54cfe3ac3a4eaa5f241c70e71fabbb659daed56ff93ba9d40762c262
-  data.tar.gz: 7ba510d6818243bded3582c1ddaa66e87a92f3ebcf7bf7a1f393d83064ff811c
+  metadata.gz: 0e4889491f1e8d88b8355eb069e349a28b386c19ceb0b24ad31c106568e9ac46
+  data.tar.gz: 9c9a3692230d26e79093a1fad8ad6efced44e35682155608cf7d172c3d843d16
 SHA512:
-  metadata.gz: 4ddabc45b7019977470f880cb364e853ba7269319ecede9d7d2f75db6c6e99fed19ca6bc915e7f613b6367d5abe0360850e2aeaf84312db58c8197091a6114ed
-  data.tar.gz: 7e038bfe9f2a4558e05971d4cc11374e779553fd72a953d7db25a743c7f334ed6ea758126aeaa30a9f8c63684be617178ab0f6d64eb57560f01c4ad7fbd48730
+  metadata.gz: f691b1c9f323255accfc2bc3bd910b0eba87518fd2cdec4839f4f611a9338de25a65e5886bec16a8e5f13904d7223c34ab7b4f0f4a0f6d73905e19097386a441
+  data.tar.gz: 616b0ea1fbfcb0e939e424ebddaa4c5f23391bf29177df480dc064884e83c2e6bfdac14069b5e2411ed2cc5355a412ff5ecd4e160ba350e14cf759dcffc86099

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

@@ -0,0 +1,152 @@
+module Dscf::Banking
+  class AccountsController < ApplicationController
+    include Dscf::Core::Common
+
+    def activate
+      account = Dscf::Banking::Account.find(params[:id])
+
+      unless account.can_be_activated?
+        return render json: {
+          success: false,
+          error: "Failed to activate account",
+          errors: [ "Account cannot be activated from current status: #{account.status}" ]
+        }, status: :unprocessable_entity
+      end
+
+      if account.activate!
+        render json: {
+          success: true,
+          data: account_data(account),
+          message: "Account activated successfully"
+        }
+      else
+        render json: {
+          success: false,
+          error: "Failed to activate account",
+          errors: account.errors.full_messages
+        }, status: :unprocessable_entity
+      end
+    rescue ActiveRecord::RecordNotFound
+      render json: {
+        success: false,
+        error: "Account not found"
+      }, status: :not_found
+    end
+
+    def suspend
+      account = Dscf::Banking::Account.find(params[:id])
+
+      unless account.can_be_suspended?
+        return render json: {
+          success: false,
+          error: "Failed to suspend account",
+          errors: [ "Account cannot be suspended from current status: #{account.status}" ]
+        }, status: :unprocessable_entity
+      end
+
+      if account.suspend!
+        render json: {
+          success: true,
+          data: account_data(account),
+          message: "Account suspended successfully"
+        }
+      else
+        render json: {
+          success: false,
+          error: "Failed to suspend account",
+          errors: account.errors.full_messages
+        }, status: :unprocessable_entity
+      end
+    rescue ActiveRecord::RecordNotFound
+      render json: {
+        success: false,
+        error: "Account not found"
+      }, status: :not_found
+    end
+
+    def close
+      account = Dscf::Banking::Account.find(params[:id])
+
+      unless account.can_be_closed?
+        return render json: {
+          success: false,
+          error: "Failed to close account",
+          errors: [ "Account cannot be closed from current status: #{account.status}" ]
+        }, status: :unprocessable_entity
+      end
+
+      if account.close!
+        render json: {
+          success: true,
+          data: account_data(account),
+          message: "Account closed successfully"
+        }
+      else
+        render json: {
+          success: false,
+          error: "Failed to close account",
+          errors: account.errors.full_messages
+        }, status: :unprocessable_entity
+      end
+    rescue ActiveRecord::RecordNotFound
+      render json: {
+        success: false,
+        error: "Account not found"
+      }, status: :not_found
+    end
+
+    private
+
+    def account_data(account)
+      {
+        id: account.id,
+        account_number: account.account_number,
+        name: account.name,
+        status: account.status,
+        activation_date: account.activation_date,
+        closure_date: account.closure_date,
+        current_balance: account.current_balance,
+        available_balance: account.available_balance,
+        minimum_balance: account.minimum_balance,
+        currency: account.currency,
+        active: account.active,
+        application_id: account.application_id,
+        virtual_account_product_id: account.virtual_account_product_id,
+        created_at: account.created_at,
+        updated_at: account.updated_at
+      }
+    end
+
+    def model_params
+      params.require(:payload).permit(
+        :application_id,
+        :virtual_account_product_id,
+        :name,
+        :status,
+        :activation_date,
+        :closure_date,
+        :current_balance,
+        :available_balance,
+        :minimum_balance,
+        :currency,
+        :active,
+        account_properties: {}
+      )
+    end
+
+    def eager_loaded_associations
+      [ :application, :virtual_account_product ]
+    end
+
+    def allowed_order_columns
+      %w[id account_number name status activation_date closure_date current_balance created_at updated_at]
+    end
+
+    def default_serializer_includes
+      {
+        application: {},
+        virtual_account_product: {}
+      }
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+module Dscf::Banking
+  class ApplicationsController < ApplicationController
+    include Dscf::Core::Common
+
+    def approve
+      application = Dscf::Banking::Application.find(params[:id])
+
+      unless application.can_be_approved_via_api?
+        return render json: {
+          success: false,
+          error: "Failed to approve application",
+          errors: [ "Application cannot be approved from current status: #{application.status}" ]
+        }, status: :unprocessable_entity
+      end
+
+      if application.approve!
+        render json: {
+          success: true,
+          data: application_data(application),
+          message: "Application approved successfully"
+        }
+      else
+        render json: {
+          success: false,
+          error: "Failed to approve application",
+          errors: application.errors.full_messages
+        }, status: :unprocessable_entity
+      end
+    rescue ActiveRecord::RecordNotFound
+      render json: {
+        success: false,
+        error: "Application not found"
+      }, status: :not_found
+    end
+
+    def reject
+      application = Dscf::Banking::Application.find(params[:id])
+      rejection_reason = params[:rejection_reason]
+
+      unless application.can_be_rejected_via_api?
+        return render json: {
+          success: false,
+          error: "Failed to reject application",
+          errors: [ "Application cannot be rejected from current status: #{application.status}" ]
+        }, status: :unprocessable_entity
+      end
+
+      if application.reject!(rejection_reason)
+        render json: {
+          success: true,
+          data: application_data(application),
+          message: "Application rejected successfully"
+        }
+      else
+        render json: {
+          success: false,
+          error: "Failed to reject application",
+          errors: application.errors.full_messages
+        }, status: :unprocessable_entity
+      end
+    rescue ActiveRecord::RecordNotFound
+      render json: {
+        success: false,
+        error: "Application not found"
+      }, status: :not_found
+    end
+
+    private
+
+    def application_data(application)
+      {
+        id: application.id,
+        application_number: application.application_number,
+        applicant_type: application.applicant_type,
+        status: application.status,
+        user_id: application.user_id,
+        virtual_account_product_id: application.virtual_account_product_id,
+        form_data: application.form_data,
+        submitted_at: application.submitted_at,
+        completed_at: application.completed_at,
+        rejection_reason: application.rejection_reason,
+        created_at: application.created_at,
+        updated_at: application.updated_at
+      }
+    end
+
+    def model_params
+      params.require(:payload).permit(
+        :user_id,
+        :virtual_account_product_id,
+        :applicant_type,
+        :status,
+        form_data: {}
+      )
+    end
+
+    def eager_loaded_associations
+      [ :user, :virtual_account_product ]
+    end
+
+    def allowed_order_columns
+      %w[id application_number status submitted_at completed_at created_at updated_at]
+    end
+
+    def default_serializer_includes
+      {
+        user: {},
+        virtual_account_product: {},
+        account: {}
+      }
+    end
+  end
+end

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