dscf-banking 0.3.5 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 033d842004e5e6c779e391bb9dca2e43925b3858212b50a94db2f3d8853a0dc1
-  data.tar.gz: eb48ab4b6287afbf75f93801f033c08327d284f127142e7199a7678ee74b3acc
+  metadata.gz: 1d9aebfb57294bdeee3240fe4079565174e97a172b44aaf93c4d93f3be94573d
+  data.tar.gz: f7acfa8939c35b2ce39f99a787772712ee886be3ed89326247948edf6f4b8a9e
 SHA512:
-  metadata.gz: f7bcc179bc00d1f81d16394e521b1d54188bd41efc89a0c0d1f9c076648eebc223a9642d3c21790bcb1270d649741b2692f54b74f7b6ec33cded00c44802d122
-  data.tar.gz: b915c7adccc0fcde6e40717023d0f9fe849c5e81298d1797371a4876d5c9dce9dec294b1b08065d23873dd3c210d61b54922d33024ea23fbaf6f3adefe5dad04
+  metadata.gz: 714c5cdb80e79dea3fd95842f9ef2ddb5e1f39c49af9f08ffee40625157ec2147fb0676430316885f8c28534811982a48ada4c471aef0c91a338d9c3fc068b5a
+  data.tar.gz: b1b6079ab0ad3d70f2c9c1076f70b06f6cefe57c118a1fa001710319a29054808bede0b95dfada63702968a6310ca74190d7013444c72889c7a1eca8ac034255

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

@@ -30,18 +30,12 @@ module Dscf::Banking
 
     def full_name
       account = Dscf::Banking::Account.find_by(account_number: params[:id])
-      if account && account.application && account.application.user
-        user = account.application.user
-        profile = user.respond_to?(:user_profile) ? user.user_profile : nil
-        if profile
-          full_name = [profile.first_name, profile.middle_name, profile.last_name].compact.join(" ")
-          render json: { success: true, data: { full_name: full_name } }
-        else
-          render json: { success: false, error: "User profile not found" }, status: :not_found
-        end
-      else
-        render json: { success: false, error: "Account not found" }, status: :not_found
-      end
+      return render json: { success: false, error: "Account not found" }, status: :not_found unless account
+
+      full_name = account.name.to_s.strip
+      full_name = "Unnamed" if full_name.empty?
+
+      render json: { success: true, data: { full_name: full_name } }
     end
 
     def show
@@ -231,29 +225,29 @@ module Dscf::Banking
 
     def transactions
       account = Dscf::Banking::Account.find(params[:id])
-      
+
       transactions = Dscf::Banking::Transaction
         .where("account_id = ? OR debit_account_id = ? OR credit_account_id = ?", account.id, account.id, account.id)
         .includes(:account, :transaction_type, :debit_account, :credit_account)
-      
+
       # Apply pagination if requested
       page = params[:page].to_i
       per_page = (params[:per_page] || 10).to_i
-      
+
       # Apply filters
       transactions = transactions.where(status: params[:status]) if params[:status].present?
       transactions = transactions.where(transaction_type_id: params[:transaction_type_id]) if params[:transaction_type_id].present?
-      
+
       # Apply ordering
       order_column = %w[id reference_number amount currency status created_at updated_at].include?(params[:order_by]) ? params[:order_by] : "created_at"
       order_direction = %w[asc desc].include?(params[:order_direction]) ? params[:order_direction] : "desc"
       transactions = transactions.order("#{order_column} #{order_direction}")
-      
+
       if page.positive?
         total_count = transactions.count
         total_pages = (total_count.to_f / per_page).ceil
         transactions = transactions.offset((page - 1) * per_page).limit(per_page)
-        
+
         render json: {
           success: true,
           message: "Account transactions retrieved successfully",

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

@@ -24,7 +24,7 @@ module Dscf::Banking
 
     private
 
-  def application_data(application)
+    def application_data(application)
       {
         id: application.id,
         application_number: application.application_number,
@@ -52,7 +52,7 @@ module Dscf::Banking
     end
 
     def eager_loaded_associations
-      [ :user, :virtual_account_product, :account, :documents, reviews: { reviewed_by: :user_profile } ]
+      [ :user, :virtual_account_product, :documents, reviews: { reviewed_by: :user_profile } ]
     end
 
     def allowed_order_columns

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

@@ -6,7 +6,7 @@ module Dscf::Banking
       render json: {
         success: false,
         error: "Transaction not found",
-        errors: [ "Transaction with ID #{params[:id]} not found" ]
+        errors: ["Transaction with ID #{params[:id]} not found"]
       }, status: :not_found
     end
 

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

@@ -83,10 +83,10 @@ module Dscf::Banking
 
     def default_serializer_includes
       {
-        index: [ :product_category, :created_by, :approved_by, reviews: { reviewed_by: :user_profile } ],
-        show: [ :product_category, :created_by, :approved_by, reviews: { reviewed_by: :user_profile } ],
-        create: [ :reviews ],
-        update: [ :product_category, :created_by, :approved_by, reviews: { reviewed_by: :user_profile } ]
+        index: [:product_category, :created_by, :approved_by, reviews: { reviewed_by: :user_profile }],
+        show: [:product_category, :created_by, :approved_by, reviews: { reviewed_by: :user_profile }],
+        create: [:reviews],
+        update: [:product_category, :created_by, :approved_by, reviews: { reviewed_by: :user_profile }]
       }
     end
   end

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

@@ -0,0 +1,133 @@
+module Dscf
+  module Banking
+    class VouchersController < ApplicationController
+      include Dscf::Core::Common
+
+      def create
+        parent_account = Dscf::Banking::Account.find_by(account_number: model_params[:parent_account_number])
+
+        unless parent_account
+          return render_error(errors: "Parent account not found", status: :not_found)
+        end
+
+        service = Dscf::Banking::VoucherService.new
+        service.generate_voucher(
+          parent_account: parent_account,
+          amount: model_params[:amount],
+          recipient_mobile: model_params[:recipient_mobile],
+          recipient_name: model_params[:recipient_name],
+          message: model_params[:message],
+          expires_at: model_params[:expires_at]
+        )
+
+        if service.success?
+          render_success(data: service.voucher, serializer_options: { include: default_serializer_includes[:default] }, status: :created)
+        else
+          render_error(errors: service.errors, status: :unprocessable_entity)
+        end
+      end
+
+      def redeem
+        service = Dscf::Banking::VoucherService.new
+        destination_account = nil
+
+        if redeem_params[:destination_account_number].present?
+          destination_account = Dscf::Banking::Account.find_by(account_number: redeem_params[:destination_account_number])
+          unless destination_account
+            return render_error(errors: "Destination account not found", status: :not_found)
+          end
+        end
+
+        service.redeem_voucher(
+          code: redeem_params[:code] || params[:code],
+          amount: redeem_params[:amount],
+          recipient_mobile: redeem_params[:recipient_mobile],
+          destination_account: destination_account
+        )
+
+        if service.success?
+          render_success(
+            data: {
+              voucher: service.voucher,
+              redemption: service.redemption
+            },
+            serializer_options: {
+              voucher: { include: default_serializer_includes[:default] },
+              redemption: { include: [ :destination_account ] }
+            }
+          )
+        else
+          render_error(errors: service.errors, status: :unprocessable_entity)
+        end
+      end
+
+      def show
+        voucher = Dscf::Banking::Voucher.find_by(code: params[:id].to_s.strip.upcase)
+        return render_error(errors: "Voucher not found", status: :not_found) unless voucher
+
+        if voucher.active? && voucher.expired?
+          Dscf::Banking::VoucherService.new.expire_voucher(voucher)
+          voucher.reload
+        end
+
+        render_success(data: voucher, serializer_options: { include: default_serializer_includes[:default] })
+      end
+
+      def cancel
+        service = Dscf::Banking::VoucherService.new
+        service.cancel_voucher(code: params[:code])
+
+        if service.success?
+          render_success(data: service.voucher, serializer_options: { include: default_serializer_includes[:default] })
+        else
+          render_error(errors: service.errors, status: :unprocessable_entity)
+        end
+      end
+
+      def account_vouchers
+        account = Dscf::Banking::Account.find(params[:account_id])
+        vouchers = account.vouchers.order(created_at: :desc)
+
+        render_success(data: vouchers, serializer_options: { include: default_serializer_includes[:default] })
+      rescue ActiveRecord::RecordNotFound
+        render_error(errors: "Account not found", status: :not_found)
+      end
+
+      private
+
+      def model_params
+        params.require(:voucher).permit(
+          :parent_account_number,
+          :amount,
+          :recipient_mobile,
+          :recipient_name,
+          :message,
+          :expires_at
+        )
+      end
+
+      def redeem_params
+        params.require(:redemption).permit(
+          :code,
+          :amount,
+          :recipient_mobile,
+          :destination_account_number
+        )
+      end
+
+      def eager_loaded_associations
+        []
+      end
+
+      def allowed_order_columns
+        %w[id code status amount remaining_amount recipient_mobile created_at updated_at]
+      end
+
+      def default_serializer_includes
+        {
+          default: [ :parent_account, :redemptions ]
+        }
+      end
+    end
+  end
+end

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

@@ -3,6 +3,9 @@ module Dscf::Banking
     belongs_to :virtual_account_product, optional: true
     belongs_to :application, optional: true
 
+    has_many :vouchers, class_name: "Dscf::Banking::Voucher", foreign_key: :parent_account_id, dependent: :restrict_with_error
+    has_many :voucher_redemptions, through: :vouchers, class_name: "Dscf::Banking::VoucherRedemption"
+
     enum :status, {
       draft: 0,
       pending_activation: 1,
@@ -16,7 +19,7 @@ module Dscf::Banking
     validates :name, presence: true
     validates :currency, presence: true
     validates :current_balance, :available_balance, :minimum_balance,
-              numericality: { greater_than_or_equal_to: 0 }
+      numericality: { greater_than_or_equal_to: 0 }
     validates :system_account, inclusion: { in: [ true, false ] }
     validate :system_account_associations
 

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

@@ -0,0 +1,76 @@
+module Dscf
+  module Banking
+    class Voucher < ApplicationRecord
+      self.table_name = "dscf_banking_vouchers"
+
+      belongs_to :parent_account, class_name: "Dscf::Banking::Account"
+      has_many :redemptions, class_name: "Dscf::Banking::VoucherRedemption", dependent: :restrict_with_error
+
+      enum :status, {
+        pending: 0,
+        active: 1,
+        redeemed: 2,
+        expired: 3,
+        cancelled: 4
+      }
+
+      validates :parent_account, presence: true
+      validates :amount, presence: true, numericality: { greater_than: 0 }
+      validates :remaining_amount, presence: true, numericality: { greater_than_or_equal_to: 0 }
+      validates :currency, presence: true
+      validates :code, presence: true, uniqueness: { case_sensitive: false }
+      validates :recipient_mobile, presence: true
+      validate :remaining_amount_not_exceed_amount
+      validate :expires_at_in_future, if: -> { expires_at.present? }
+
+      before_validation :set_defaults, on: :create
+      before_validation :normalize_code, if: -> { code.present? }
+
+      scope :by_status, ->(status) { where(status: status) }
+      scope :active_now, -> { where(status: :active).where("expires_at IS NULL OR expires_at > ?", Time.current) }
+      scope :expired_now, -> { where(status: :active).where("expires_at IS NOT NULL AND expires_at <= ?", Time.current) }
+
+      def expired?
+        expires_at.present? && expires_at <= Time.current
+      end
+
+      def fully_redeemed?
+        remaining_amount.to_f.zero?
+      end
+
+      def mark_expired!
+        update!(status: :expired) if expired? && !expired_status?
+      end
+
+      def expired_status?
+        status == "expired"
+      end
+
+      private
+
+      def set_defaults
+        self.currency ||= parent_account&.currency
+        self.remaining_amount = amount if remaining_amount.nil? && amount
+        self.status ||= :pending
+      end
+
+      def normalize_code
+        self.code = code.to_s.strip.upcase
+      end
+
+      def remaining_amount_not_exceed_amount
+        return if amount.nil? || remaining_amount.nil?
+
+        if remaining_amount > amount
+          errors.add(:remaining_amount, "cannot exceed voucher amount")
+        end
+      end
+
+      def expires_at_in_future
+        if expires_at <= Time.current
+          errors.add(:expires_at, "must be in the future")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Dscf
+  module Banking
+    class VoucherRedemption < ApplicationRecord
+      self.table_name = "dscf_banking_voucher_redemptions"
+
+      belongs_to :voucher, class_name: "Dscf::Banking::Voucher"
+      belongs_to :destination_account, class_name: "Dscf::Banking::Account", optional: true
+
+      validates :voucher, presence: true
+      validates :amount, presence: true, numericality: { greater_than: 0 }
+      validates :recipient_mobile, presence: true
+      validates :currency, presence: true
+      validates :redeemed_at, presence: true
+
+      before_validation :set_defaults, on: :create
+
+      scope :by_voucher, ->(voucher_id) { where(voucher_id: voucher_id) }
+
+      private
+
+      def set_defaults
+        self.currency ||= voucher&.currency
+        self.recipient_mobile ||= voucher&.recipient_mobile
+      end
+    end
+  end
+end

data/app/serializers/dscf/banking/account_serializer.rb

@@ -1,11 +1,12 @@
 module Dscf::Banking
   class AccountSerializer < ActiveModel::Serializer
     attributes :id, :account_number, :name, :status, :activation_date, :closure_date,
-               :account_properties, :current_balance, :available_balance, :minimum_balance,
-               :currency, :active, :created_at, :updated_at
+      :account_properties, :current_balance, :available_balance, :minimum_balance,
+      :currency, :active, :created_at, :updated_at
 
     belongs_to :virtual_account_product, serializer: VirtualAccountProductSerializer
 
     attribute :application_id
+    attribute :system_account
   end
 end

data/app/serializers/dscf/banking/application_serializer.rb

@@ -9,7 +9,7 @@ module Dscf::Banking
     belongs_to :assigned_branch_manager, optional: true
     has_one :account, serializer: AccountSerializer, if: :has_account?
     has_many :reviews, serializer: Dscf::Core::ReviewSerializer
-    has_many :documents, serializer: Dscf::Banking::DocumentSerializer
+    has_many :documents, serializer: DocumentSerializer
 
     def has_account?
       object.has_account?

data/app/serializers/dscf/banking/document_serializer.rb

@@ -2,6 +2,8 @@ module Dscf::Banking
   class DocumentSerializer < ActiveModel::Serializer
     attributes :id, :document_type, :is_verified, :verified_at, :metadata, :file_urls, :created_at, :updated_at
 
+    belongs_to :documentable, polymorphic: true
+
     def file_urls
       return [] unless object.files.attached?
 
@@ -14,7 +16,7 @@ module Dscf::Banking
           object.files.map(&:url)
         end
       end
-    rescue StandardError
+    rescue
       []
     end
   end

data/app/serializers/dscf/banking/voucher_redemption_serializer.rb

@@ -0,0 +1,10 @@
+module Dscf
+  module Banking
+    class VoucherRedemptionSerializer < ActiveModel::Serializer
+      attributes :id, :voucher_id, :destination_account_id, :amount, :currency,
+        :recipient_mobile, :redeemed_at, :created_at, :updated_at
+
+      belongs_to :destination_account, serializer: AccountSerializer
+    end
+  end
+end

data/app/serializers/dscf/banking/voucher_serializer.rb

@@ -0,0 +1,20 @@
+module Dscf
+  module Banking
+    class VoucherSerializer < ActiveModel::Serializer
+      attributes :id, :parent_account_id, :code, :status, :amount, :remaining_amount,
+        :currency, :recipient_mobile, :recipient_name, :message, :expires_at,
+        :redeemed_at, :created_at, :updated_at
+
+      attribute :amount do
+        object.amount.to_f
+      end
+
+      attribute :remaining_amount do
+        object.remaining_amount.to_f
+      end
+
+      belongs_to :parent_account, serializer: AccountSerializer
+      has_many :redemptions, serializer: VoucherRedemptionSerializer
+    end
+  end
+end

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

@@ -0,0 +1,317 @@
+module Dscf
+  module Banking
+    class VoucherService < BaseTransactionService
+      attr_reader :voucher, :redemption
+
+      def initialize
+        super
+        @voucher = nil
+        @redemption = nil
+      end
+
+      def generate_voucher(parent_account:, amount:, recipient_mobile:, recipient_name: nil, message: nil, expires_at: nil)
+        amount = amount.to_f
+        return self unless validate_generate_params(parent_account, amount, recipient_mobile)
+
+        expires_at ||= default_expiration
+
+        settlement_account = find_or_create_voucher_settlement_account(parent_account.currency)
+        return self unless success?
+
+        voucher_code = generate_code
+
+        ActiveRecord::Base.transaction do
+          transaction = create_voucher_transaction(
+            debit_account: parent_account,
+            credit_account: settlement_account,
+            amount: amount,
+            description: "Voucher issuance #{voucher_code}"
+          )
+
+          return self unless success?
+
+          @voucher = Dscf::Banking::Voucher.create(
+            parent_account: parent_account,
+            amount: amount,
+            remaining_amount: amount,
+            currency: parent_account.currency,
+            recipient_mobile: recipient_mobile,
+            recipient_name: recipient_name,
+            message: message,
+            expires_at: expires_at,
+            status: :active,
+            code: voucher_code
+          )
+
+          unless @voucher.persisted?
+            @voucher.errors.full_messages.each { |msg| add_error(msg) }
+            raise ActiveRecord::Rollback
+          end
+
+          transaction&.update(description: "Voucher issuance #{@voucher.code}")
+        end
+
+        self
+      end
+
+      def redeem_voucher(code:, amount:, recipient_mobile:, destination_account: nil)
+        amount = amount.to_f
+        code = code.to_s.strip.upcase
+        @voucher = Dscf::Banking::Voucher.find_by(code: code)
+
+        unless @voucher
+          add_error("Voucher not found")
+          return self
+        end
+
+        return self unless validate_redeem_params(amount, recipient_mobile)
+        return self unless validate_voucher_state(@voucher, amount, recipient_mobile)
+        return self unless ensure_voucher_settlement_funds(@voucher.currency, amount)
+
+        if destination_account
+          return self unless validate_account_active(destination_account, "Destination account")
+          unless destination_account.currency == @voucher.currency
+            add_error("Currency mismatch between voucher and destination account")
+            return self
+          end
+        end
+
+        ActiveRecord::Base.transaction do
+          @voucher.lock!
+          remaining_after = @voucher.remaining_amount.to_f - amount
+
+          @redemption = Dscf::Banking::VoucherRedemption.create(
+            voucher: @voucher,
+            amount: amount,
+            currency: @voucher.currency,
+            recipient_mobile: recipient_mobile,
+            destination_account: destination_account,
+            redeemed_at: Time.current
+          )
+
+          unless @redemption.persisted?
+            @redemption.errors.full_messages.each { |msg| add_error(msg) }
+            raise ActiveRecord::Rollback
+          end
+
+          update_voucher_balance_and_status(@voucher, remaining_after)
+          return self unless success?
+
+          if destination_account
+            create_voucher_transaction(
+              debit_account: find_or_create_voucher_settlement_account(@voucher.currency),
+              credit_account: destination_account,
+              amount: amount,
+              description: "Voucher redemption #{@voucher.code}"
+            )
+          end
+        end
+
+        self
+      end
+
+      def cancel_voucher(code:)
+        @voucher = Dscf::Banking::Voucher.find_by(code: code.to_s.strip.upcase)
+
+        unless @voucher
+          add_error("Voucher not found")
+          return self
+        end
+
+        if @voucher.redeemed? || @voucher.cancelled?
+          add_error("Voucher cannot be cancelled")
+          return self
+        end
+
+        ActiveRecord::Base.transaction do
+          @voucher.lock!
+          refundable = @voucher.remaining_amount.to_f
+          @voucher.update!(status: :cancelled, remaining_amount: 0)
+
+          if refundable.positive?
+            create_voucher_transaction(
+              debit_account: find_or_create_voucher_settlement_account(@voucher.currency),
+              credit_account: @voucher.parent_account,
+              amount: refundable,
+              description: "Voucher cancellation #{@voucher.code}"
+            )
+          end
+        end
+
+        self
+      end
+
+      def expire_voucher(voucher)
+        return self unless voucher
+
+        ActiveRecord::Base.transaction do
+          voucher.lock!
+          return self unless voucher.active?
+          return self unless voucher.expired?
+
+          refundable = voucher.remaining_amount.to_f
+          voucher.update!(status: :expired, remaining_amount: 0)
+
+          if refundable.positive?
+            create_voucher_transaction(
+              debit_account: find_or_create_voucher_settlement_account(voucher.currency),
+              credit_account: voucher.parent_account,
+              amount: refundable,
+              description: "Voucher expiration #{voucher.code}"
+            )
+          end
+        end
+
+        self
+      end
+
+      def expire_due_vouchers
+        Dscf::Banking::Voucher.active_now.find_each do |voucher|
+          expire_voucher(voucher) if voucher.expired?
+        end
+
+        self
+      end
+
+      private
+
+      def validate_generate_params(parent_account, amount, recipient_mobile)
+        return false unless validate_account_active(parent_account, "Parent account")
+
+        if amount <= 0
+          add_error("Voucher amount must be greater than zero")
+          return false
+        end
+
+        if recipient_mobile.to_s.strip.empty?
+          add_error("Recipient mobile is required")
+          return false
+        end
+
+        return false unless validate_sufficient_funds(parent_account, amount)
+
+        true
+      end
+
+      def default_expiration
+        30.days.from_now
+      end
+
+      def validate_redeem_params(amount, recipient_mobile)
+        if amount <= 0
+          add_error("Redemption amount must be greater than zero")
+          return false
+        end
+
+        if recipient_mobile.to_s.strip.empty?
+          add_error("Recipient mobile is required")
+          return false
+        end
+
+        true
+      end
+
+      def validate_voucher_state(voucher, amount, recipient_mobile)
+        if voucher.cancelled?
+          add_error("Voucher is cancelled")
+          return false
+        end
+
+        if voucher.expired?
+          add_error("Voucher is expired")
+          return false
+        end
+
+        if voucher.redeemed?
+          add_error("Voucher already redeemed")
+          return false
+        end
+
+        if voucher.recipient_mobile != recipient_mobile
+          add_error("Recipient mobile does not match")
+          return false
+        end
+
+        if voucher.remaining_amount.to_f < amount
+          add_error("Insufficient voucher balance")
+          return false
+        end
+
+        true
+      end
+
+      def ensure_voucher_settlement_funds(currency, amount)
+        settlement_account = find_or_create_voucher_settlement_account(currency)
+        return false unless settlement_account
+
+        if settlement_account.current_balance.to_f < amount
+          add_error("Insufficient voucher settlement funds")
+          return false
+        end
+
+        true
+      end
+
+      def update_voucher_balance_and_status(voucher, remaining_after)
+        new_status = remaining_after.zero? ? :redeemed : :active
+        updates = { remaining_amount: remaining_after, status: new_status }
+        updates[:redeemed_at] = Time.current if remaining_after.zero?
+
+        unless voucher.update(updates)
+          voucher.errors.full_messages.each { |msg| add_error(msg) }
+        end
+      end
+
+      def generate_code
+        loop do
+          code = "VCH#{SecureRandom.hex(6).upcase}"
+          break code unless Dscf::Banking::Voucher.exists?(code: code)
+        end
+      end
+
+      def create_voucher_transaction(debit_account:, credit_account:, amount:, description:)
+        return unless debit_account && credit_account
+
+        transaction_type = find_or_create_transaction_type("VOUCHER")
+        unless transaction_type
+          raise ActiveRecord::Rollback
+        end
+
+        transaction = create_transaction(
+          account: debit_account,
+          transaction_type: transaction_type,
+          debit_account: debit_account,
+          credit_account: credit_account,
+          amount: amount,
+          currency: debit_account.currency,
+          description: description,
+          status: :pending
+        )
+
+        unless transaction
+          raise ActiveRecord::Rollback
+        end
+
+        unless process_transaction(transaction)
+          raise ActiveRecord::Rollback
+        end
+
+        transaction
+      end
+
+      def find_or_create_voucher_settlement_account(currency)
+        account = Dscf::Banking::Account.system_accounts
+          .where(currency: currency)
+          .where("name LIKE ?", "%Voucher Settlement%")
+          .first
+
+        unless account
+          add_error("Voucher settlement account not found for currency #{currency}")
+          return nil
+        end
+
+        account
+      end
+    end
+  end
+end

data/config/routes.rb

@@ -1,6 +1,5 @@
 Dscf::Banking::Engine.routes.draw do
-    resources :accounts do
-      get "full_name", to: "accounts#full_name", on: :member
+  resources :accounts do
     collection do
       get :me
     end
@@ -9,6 +8,7 @@ Dscf::Banking::Engine.routes.draw do
       post :suspend
       post :close
       get :transactions
+      get :full_name
     end
   end
   resources :product_categories

data/db/migrate/20260210120000_create_dscf_banking_vouchers.rb

@@ -0,0 +1,23 @@
+class CreateDscfBankingVouchers < ActiveRecord::Migration[8.0]
+  def change
+    create_table :dscf_banking_vouchers do |t|
+      t.references :parent_account, null: false, foreign_key: { to_table: :dscf_banking_accounts }
+      t.string :code, null: false
+      t.integer :status, null: false, default: 0
+      t.decimal :amount, precision: 20, scale: 4, null: false
+      t.decimal :remaining_amount, precision: 20, scale: 4, null: false
+      t.string :currency, null: false, default: "ETB"
+      t.string :recipient_mobile, null: false
+      t.string :recipient_name
+      t.text :message
+      t.datetime :expires_at
+      t.datetime :redeemed_at
+
+      t.timestamps
+    end
+
+    add_index :dscf_banking_vouchers, :code, unique: true
+    add_index :dscf_banking_vouchers, :status
+    add_index :dscf_banking_vouchers, :recipient_mobile
+  end
+end

data/db/migrate/20260210120010_create_dscf_banking_voucher_redemptions.rb

@@ -0,0 +1,16 @@
+class CreateDscfBankingVoucherRedemptions < ActiveRecord::Migration[8.0]
+  def change
+    create_table :dscf_banking_voucher_redemptions do |t|
+      t.references :voucher, null: false, foreign_key: { to_table: :dscf_banking_vouchers }
+      t.references :destination_account, foreign_key: { to_table: :dscf_banking_accounts }
+      t.decimal :amount, precision: 20, scale: 4, null: false
+      t.string :currency, null: false, default: "ETB"
+      t.string :recipient_mobile, null: false
+      t.datetime :redeemed_at, null: false
+
+      t.timestamps
+    end
+
+    add_index :dscf_banking_voucher_redemptions, :recipient_mobile
+  end
+end

data/db/seeds.rb

@@ -9,42 +9,42 @@
 
 # Seed roles based on RBAC documentation
 puts "Seeding roles..."
-user_role = Role.find_or_create_by(name: 'User')
-officer_role = Role.find_or_create_by(name: 'Virtual Account Officer')
-manager_role = Role.find_or_create_by(name: 'Virtual Account Manager')
-kyc_officer_role = Role.find_or_create_by(name: 'KYC Officer')
-branch_manager_role = Role.find_or_create_by(name: 'Branch Manager')
+user_role = Dscf::Core::Role.find_or_create_by(name: "User")
+officer_role = Dscf::Core::Role.find_or_create_by(name: "Virtual Account Officer")
+manager_role = Dscf::Core::Role.find_or_create_by(name: "Virtual Account Manager")
+kyc_officer_role = Dscf::Core::Role.find_or_create_by(name: "KYC Officer")
+branch_manager_role = Dscf::Core::Role.find_or_create_by(name: "Branch Manager")
 puts "Roles seeded successfully."
 
 # Seed users with roles
 puts "Seeding users..."
 # Create users and assign roles
-user1 = User.create(name: "Abebe Kebede", email: "abebe@example.com", password: "SecurePassword123!")
+user1 = Dscf::Core::User.create(name: "Abebe Kebede", email: "abebe@example.com", password: "SecurePassword123!")
 user1.roles << user_role
 puts "Created user: #{user1.name}"
 
-user2 = User.create(name: "Tigist Haile", email: "tigist@example.com", password: "SecurePassword123!")
+user2 = Dscf::Core::User.create(name: "Tigist Haile", email: "tigist@example.com", password: "SecurePassword123!")
 user2.roles << officer_role
 puts "Created user: #{user2.name}"
 
-user3 = User.create(name: "Dawit Mekonnen", email: "dawit@example.com", password: "SecurePassword123!")
+user3 = Dscf::Core::User.create(name: "Dawit Mekonnen", email: "dawit@example.com", password: "SecurePassword123!")
 user3.roles << manager_role
 puts "Created user: #{user3.name}"
 
 # Additional users for testing
-user4 = User.create(name: "Hirut Assefa", email: "hirut@example.com", password: "SecurePassword123!")
+user4 = Dscf::Core::User.create(name: "Hirut Assefa", email: "hirut@example.com", password: "SecurePassword123!")
 user4.roles << [ user_role, officer_role ]  # User with multiple roles if supported
 puts "Created user: #{user4.name}"
 
-user5 = User.create(name: "Solomon Tesfaye", email: "solomon@example.com", password: "SecurePassword123!")
+user5 = Dscf::Core::User.create(name: "Solomon Tesfaye", email: "solomon@example.com", password: "SecurePassword123!")
 user5.roles << manager_role
 puts "Created user: #{user5.name}"
 
-user6 = User.create(name: "Mulugeta Bekele", email: "mulugeta@example.com", password: "SecurePassword123!")
+user6 = Dscf::Core::User.create(name: "Mulugeta Bekele", email: "mulugeta@example.com", password: "SecurePassword123!")
 user6.roles << kyc_officer_role
 puts "Created user: #{user6.name}"
 
-user7 = User.create(name: "Fikirte Alemayehu", email: "fikirte@example.com", password: "SecurePassword123!")
+user7 = Dscf::Core::User.create(name: "Fikirte Alemayehu", email: "fikirte@example.com", password: "SecurePassword123!")
 user7.roles << branch_manager_role
 puts "Created user: #{user7.name}"
 
@@ -68,6 +68,12 @@ transfer_type = Dscf::Banking::TransactionType.find_or_create_by(code: "TRANSFER
 end
 puts "Created transaction type: #{transfer_type.name}"
 
+voucher_type = Dscf::Banking::TransactionType.find_or_create_by(code: "VOUCHER") do |tt|
+  tt.name = "Voucher"
+  tt.description = "Voucher issuance and redemption transactions"
+end
+puts "Created transaction type: #{voucher_type.name}"
+
 # Seed system accounts for transaction processing
 puts "Seeding system accounts..."
 system_deposit_account = Dscf::Banking::Account.find_or_create_by(
@@ -94,4 +100,16 @@ system_withdrawal_account = Dscf::Banking::Account.find_or_create_by(
 end
 puts "Created system withdrawal account: #{system_withdrawal_account.name}"
 
+voucher_settlement_account = Dscf::Banking::Account.find_or_create_by(
+  name: "Voucher Settlement Account",
+  system_account: true
+) do |account|
+  account.currency = "ETB"
+  account.status = :active
+  account.current_balance = 0
+  account.available_balance = 0
+  account.minimum_balance = 0
+end
+puts "Created voucher settlement account: #{voucher_settlement_account.name}"
+
 puts "Seeding completed successfully."

data/lib/dscf/banking/version.rb

@@ -1,5 +1,5 @@
 module Dscf
   module Banking
-    VERSION = "0.3.5"
+    VERSION = "0.3.7"
   end
 end

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

@@ -43,6 +43,8 @@ FactoryBot.define do
     trait :settlement_account do
       system_account { true }
       name { "Core Banking Settlement Account" }
+      current_balance { 0 }
+      available_balance { 0 }
       virtual_account_product { nil }
       application { nil }
     end

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

@@ -0,0 +1,9 @@
+FactoryBot.define do
+  factory :voucher_redemption, class: "Dscf::Banking::VoucherRedemption" do
+    association :voucher, factory: :voucher
+    amount { 25.0 }
+    currency { voucher.currency }
+    recipient_mobile { voucher.recipient_mobile }
+    redeemed_at { Time.current }
+  end
+end

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

@@ -0,0 +1,14 @@
+FactoryBot.define do
+  factory :voucher, class: "Dscf::Banking::Voucher" do
+    parent_account { create(:dscf_banking_account, :active, :with_balance) }
+    amount { 100.0 }
+    remaining_amount { amount }
+    currency { parent_account.currency }
+    recipient_mobile { "0912345678" }
+    recipient_name { "Voucher Recipient" }
+    message { "Enjoy your voucher" }
+    expires_at { 30.days.from_now }
+    status { :active }
+    sequence(:code) { |n| "VCH#{n.to_s.rjust(6, "0")}" }
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dscf-banking
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.7
 platform: ruby
 authors:
-- Eyosiyas Mekbib
+- Asrat Efrem
 bindir: bin
 cert_chain: []
-date: 2025-10-17 00:00:00.000000000 Z
+date: 2026-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -219,20 +219,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: bullet
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: database_cleaner-active_record
   requirement: !ruby/object:Gem::Requirement
@@ -431,7 +417,7 @@ dependencies:
         version: '0'
 description: An engine which contains core models for Supply Chain Financing.
 email:
-- eyosi9000@gmail.com
+- asratextras77@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -451,6 +437,7 @@ files:
 - 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/controllers/dscf/banking/vouchers_controller.rb
 - app/jobs/dscf/banking/application_job.rb
 - app/mailers/dscf/banking/application_mailer.rb
 - app/models/concerns/dscf/banking/auditable.rb
@@ -466,6 +453,8 @@ files:
 - app/models/dscf/banking/transaction.rb
 - app/models/dscf/banking/transaction_type.rb
 - app/models/dscf/banking/virtual_account_product.rb
+- app/models/dscf/banking/voucher.rb
+- app/models/dscf/banking/voucher_redemption.rb
 - app/serializers/dscf/banking/account_serializer.rb
 - app/serializers/dscf/banking/application_serializer.rb
 - app/serializers/dscf/banking/document_serializer.rb
@@ -477,13 +466,14 @@ files:
 - 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/serializers/dscf/banking/voucher_redemption_serializer.rb
+- app/serializers/dscf/banking/voucher_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/voucher_service.rb
 - app/services/dscf/banking/withdrawal_service.rb
-- config/initializers/review_callbacks.rb
-- config/initializers/review_extensions.rb
 - config/locales/en.yml
 - config/routes.rb
 - db/migrate/20250830211002_create_dscf_banking_product_categories.rb
@@ -501,6 +491,8 @@ files:
 - 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/migrate/20260210120000_create_dscf_banking_vouchers.rb
+- db/migrate/20260210120010_create_dscf_banking_voucher_redemptions.rb
 - db/seeds.rb
 - lib/dscf/banking.rb
 - lib/dscf/banking/engine.rb
@@ -518,6 +510,8 @@ files:
 - spec/factories/dscf/banking/transaction_types.rb
 - spec/factories/dscf/banking/transactions.rb
 - spec/factories/dscf/banking/virtual_account_products.rb
+- spec/factories/dscf/banking/voucher_redemptions.rb
+- spec/factories/dscf/banking/vouchers.rb
 homepage: https://mksaddis.com/
 licenses: []
 metadata:

data/config/initializers/review_callbacks.rb

@@ -1,23 +0,0 @@
-Rails.application.config.to_prepare do
-  ActiveSupport::Notifications.subscribe("review.created") do |name, start, finish, id, payload|
-    reviewable = payload[:reviewable]
-    
-    if reviewable.is_a?(Dscf::Banking::Application)
-      reviewable.reload
-      review_status = reviewable.review_status
-      
-      status_map = {
-        "submitted" => "submitted",
-        "under_review" => "under_review",
-        "approved" => "approved",
-        "rejected" => "rejected",
-        "request_modification" => "request_modification"
-      }
-      
-      mapped_status = status_map[review_status]
-      if mapped_status && reviewable.status != mapped_status
-        reviewable.update!(status: mapped_status)
-      end
-    end
-  end
-end

data/config/initializers/review_extensions.rb

@@ -1,36 +0,0 @@
-module Dscf::Banking
-  module ReviewExtensions
-    extend ActiveSupport::Concern
-
-    included do
-      after_create :sync_application_status, if: -> { reviewable.is_a?(Dscf::Banking::Application) }
-    end
-
-    private
-
-    def sync_application_status
-      return unless reviewable.is_a?(Dscf::Banking::Application)
-
-      application = reviewable
-      review_status = application.review_status
-
-      status_map = {
-        "submitted" => "submitted",
-        "under_review" => "under_review",
-        "approved" => "approved",
-        "rejected" => "rejected",
-        "request_modification" => "request_modification"
-      }
-
-      mapped_status = status_map[review_status]
-      if mapped_status && application.status != mapped_status
-        application.update!(status: mapped_status)
-      end
-    end
-  end
-end
-
-# Extend the Dscf::Core::Review model with our extensions
-Rails.application.config.to_prepare do
-  Dscf::Core::Review.include(Dscf::Banking::ReviewExtensions) if defined?(Dscf::Core::Review)
-end