bscf-core 0.3.99 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ba4cb08d046b4bcef3b55100146f08c64fa32d7b97f59302ffdf8ef1a804737
-  data.tar.gz: da7bd6abdf23ec993e8442e998853118533d2f2d7773de25155aca33c6569c22
+  metadata.gz: edbe11919e64a7d36377d85759973899a2407eb6417e7d070eb78ee9c2062bf6
+  data.tar.gz: 37375af1d5dfdf4f4703540d8e3c6d7c2d7496026421b8ae8e4c5c412cb23fd2
 SHA512:
-  metadata.gz: 7eca0f066d06df32ff1fcbf12c1056331ada9eef7f5f5cd18d37becc26dfad27a3576e9afc97e157bd7bd133a5c28534c70aeb2c74592c325b67b51bcf42f6e4
-  data.tar.gz: 35654a8b5fab7cb7b4bfdaa124014cbf80e9c1b640079ec43a2d95800672d34db54e7ee89c3cacf31eff19f6b627b7e56f8a5f335d70a9308939a19b4932b0b3
+  metadata.gz: 2de3ef4fe24d2536031b4f527a5d7ed90f958f736d255157a9e17836c50e8587d00fa06ed2128e14b35102af7b81a9ba74bcc6994047f755e728e9e6cf1d1b9c
+  data.tar.gz: 80a64d9c90c60baaf9966dee56261e41675a9fcf8e3091059b994e8fa2af36bc607caf192a22504fa74cff29b7d7fca4bc8e6061918c0db991e3556f739c590b

data/app/models/bscf/core/delivery_order.rb

@@ -9,8 +9,7 @@ module Bscf::Core
     has_many :order_items, through: :delivery_order_items
     has_many :products, through: :delivery_order_items
 
-    validates :buyer_phone, :seller_phone, :driver_phone,
-              :status, :estimated_delivery_time, presence: true
+    validates :driver_phone, :status, :estimated_delivery_time, presence: true
     validate :end_time_after_start_time, if: -> { delivery_start_time.present? && delivery_end_time.present? }
 
     before_save :update_delivery_times

data/app/models/bscf/core/delivery_order_item.rb

@@ -2,7 +2,8 @@ module Bscf::Core
   class DeliveryOrderItem < ApplicationRecord
     belongs_to :delivery_order
     belongs_to :order_item
-    belongs_to :product
+    belongs_to :pickup_address, class_name: "Bscf::Core::Address", optional: true
+    belongs_to :dropoff_address, class_name: "Bscf::Core::Address", optional: true
 
     validates :quantity, :status, presence: true
     validate :quantity_not_exceeding_order_item

data/app/models/bscf/core/virtual_account_transaction.rb

@@ -1,20 +1,27 @@
 module Bscf
   module Core
     class VirtualAccountTransaction < ApplicationRecord
-      belongs_to :from_account, class_name: "Bscf::Core::VirtualAccount", optional: true
-      belongs_to :to_account, class_name: "Bscf::Core::VirtualAccount", optional: true
+      belongs_to :account, class_name: "Bscf::Core::VirtualAccount"
+      belongs_to :paired_transaction, class_name: "Bscf::Core::VirtualAccountTransaction", optional: true
 
-      validates :from_account_id, presence: true, if: :requires_from_account?
-      validates :to_account_id, presence: true, if: :requires_to_account?
+      validates :account_id, presence: true
       validates :amount, presence: true, numericality: { greater_than: 0 }
       validates :transaction_type, presence: true
+      validates :entry_type, presence: true
       validates :status, presence: true
       validates :reference_number, presence: true, uniqueness: true
 
       enum :transaction_type, {
         transfer: 0,
         deposit: 1,
-        withdrawal: 2
+        withdrawal: 2,
+        fee: 3,
+        adjustment: 4
+      }
+
+      enum :entry_type, {
+        debit: 0,
+        credit: 1
       }
 
       enum :status, {
@@ -27,122 +34,76 @@ module Bscf
       before_validation :generate_reference_number, on: :create
       validate :validate_transaction, on: :create
 
+      scope :debits, -> { where(entry_type: :debit) }
+      scope :credits, -> { where(entry_type: :credit) }
+      scope :for_account, ->(account_id) { where(account_id: account_id) }
+      scope :by_type, ->(type) { where(transaction_type: type) }
+      scope :by_status, ->(status) { where(status: status) }
+
       def process!
         return false unless pending?
 
         ActiveRecord::Base.transaction do
-          process_transaction
+          update_account_balance
+
           update!(status: :completed)
+          paired_transaction&.update!(status: :completed)
         end
         true
       rescue StandardError => e
         update(status: :failed)
+        paired_transaction&.update(status: :failed)
+        Rails.logger.error("Transaction processing failed: #{e.message}")
         false
       end
 
       def cancel!
         return false unless pending?
-        update(status: :cancelled)
-      end
-
-      private
-
-      def requires_from_account?
-        return false if transaction_type.nil?
-        %w[transfer withdrawal].include?(transaction_type)
-      end
 
-      def requires_to_account?
-        return false if transaction_type.nil?
-        %w[transfer deposit].include?(transaction_type)
-      end
-
-      def validate_transaction
-        case transaction_type.to_sym
-        when :transfer
-          validate_transfer
-        when :withdrawal
-          validate_withdrawal
-        when :deposit
-          validate_deposit
+        ActiveRecord::Base.transaction do
+          update(status: :cancelled)
+          paired_transaction&.update(status: :cancelled)
         end
-
-        validate_account_requirements
-      end
-
-      def validate_transfer
-        return unless from_account && to_account
-
-        errors.add(:from_account, "must be active") unless from_account.active?
-        errors.add(:to_account, "must be active") unless to_account.active?
-        errors.add(:from_account, "insufficient balance") if from_account.balance.to_d < amount.to_d
+        true
       end
 
       private
 
-      def validate_account_requirements
-        case transaction_type.to_sym
-        when :transfer
-          return if from_account_id.present? && to_account_id.present?
-          errors.add(:base, "Both accounts are required for transfer")
-        when :withdrawal
-          return if from_account_id.present?
-          errors.add(:base, "Source account is required for withdrawal")
-          errors.add(:to_account_id, "must be blank for withdrawal")
-        when :deposit
-          return if to_account_id.present?
-          errors.add(:base, "Destination account is required for deposit")
-          errors.add(:from_account_id, "must be blank for deposit")
-        end
-      end
-
-      def validate_withdrawal
-        return unless from_account
-        errors.add(:from_account, "must be active") unless from_account.active?
-        errors.add(:from_account, "insufficient balance") if from_account.balance.to_d < amount.to_d
-      end
+      def validate_transaction
+        errors.add(:account, "must be active") unless account.active?
 
-      def validate_deposit
-        return unless to_account
-        errors.add(:to_account, "must be active") unless to_account.active?
-      end
+        if debit? && !adjustment? && account.balance.to_d < amount.to_d
+          errors.add(:account, "insufficient balance")
+        end
 
-      def process_transaction
-        case transaction_type.to_sym
-        when :transfer
-          process_transfer
-        when :withdrawal
-          process_withdrawal
-        when :deposit
-          process_deposit
+        if transfer? && paired_transaction.blank?
+          errors.add(:paired_transaction, "must be present for transfers")
         end
       end
 
-      def process_transfer
-        ActiveRecord::Base.transaction do
-          from_account.with_lock do
-            to_account.with_lock do
-              new_from_balance = (from_account.balance - amount).round(2)
-              new_to_balance = (to_account.balance + amount).round(2)
-
-              from_account.update!(balance: new_from_balance)
-              to_account.update!(balance: new_to_balance)
-            end
+      def update_account_balance
+        account.with_lock do
+          new_balance = if debit?
+                          (account.balance - amount).round(2)
+          else
+                          (account.balance + amount).round(2)
           end
-        end
-      end
 
-      def process_withdrawal
-        from_account.with_lock do
-          new_balance = (from_account.balance - amount).round(2)
-          from_account.update!(balance: new_balance)
+          account.update!(balance: new_balance)
+          update!(running_balance: new_balance)
         end
-      end
 
-      def process_deposit
-        to_account.with_lock do
-          new_balance = (to_account.balance + amount).round(2)
-          to_account.update!(balance: new_balance)
+        if paired_transaction.present?
+          paired_transaction.account.with_lock do
+            new_balance = if paired_transaction.debit?
+                            (paired_transaction.account.balance - paired_transaction.amount).round(2)
+            else
+                            (paired_transaction.account.balance + paired_transaction.amount).round(2)
+            end
+
+            paired_transaction.account.update!(balance: new_balance)
+            paired_transaction.update!(running_balance: new_balance)
+          end
         end
       end
 

data/app/services/bscf/core/transaction_service.rb

@@ -0,0 +1,185 @@
+module Bscf
+  module Core
+    class TransactionService
+      # Create a transfer between two accounts
+      # @param from_account_id [Integer] Source account ID
+      # @param to_account_id [Integer] Destination account ID
+      # @param amount [Decimal] Amount to transfer
+      # @param description [String] Optional description
+      # @return [Array<VirtualAccountTransaction>] The created transaction pair
+      def self.create_transfer(from_account_id:, to_account_id:, amount:, description: nil)
+        create_paired_transaction(
+          from_account_id: from_account_id,
+          to_account_id: to_account_id,
+          amount: amount,
+          transaction_type: :transfer,
+          description: description
+        )
+      end
+
+      # Create a deposit to an account
+      # @param to_account_id [Integer] Destination account ID
+      # @param amount [Decimal] Amount to deposit
+      # @param description [String] Optional description
+      # @return [Array<VirtualAccountTransaction>] The created transaction pair
+      def self.create_deposit(to_account_id:, amount:, description: nil)
+        system_account = find_or_create_system_account("DEPOSIT_ACCOUNT")
+
+        # Ensure system account has sufficient balance for deposits
+        ensure_system_account_balance(system_account, amount)
+
+        create_paired_transaction(
+          from_account_id: system_account.id,
+          to_account_id: to_account_id,
+          amount: amount,
+          transaction_type: :deposit,
+          description: description
+        )
+      end
+
+      # Create a withdrawal from an account
+      # @param from_account_id [Integer] Source account ID
+      # @param amount [Decimal] Amount to withdraw
+      # @param description [String] Optional description
+      # @return [Array<VirtualAccountTransaction>] The created transaction pair
+      def self.create_withdrawal(from_account_id:, amount:, description: nil)
+        system_account = find_or_create_system_account("WITHDRAWAL_ACCOUNT")
+
+        create_paired_transaction(
+          from_account_id: from_account_id,
+          to_account_id: system_account.id,
+          amount: amount,
+          transaction_type: :withdrawal,
+          description: description
+        )
+      end
+
+      # Create a fee transaction
+      # @param from_account_id [Integer] Account to charge
+      # @param amount [Decimal] Fee amount
+      # @param description [String] Optional description
+      # @return [Array<VirtualAccountTransaction>] The created transaction pair
+      def self.create_fee(from_account_id:, amount:, description: nil)
+        fee_account = find_or_create_system_account("FEE_ACCOUNT")
+
+        create_paired_transaction(
+          from_account_id: from_account_id,
+          to_account_id: fee_account.id,
+          amount: amount,
+          transaction_type: :fee,
+          description: description
+        )
+      end
+
+      # Create an adjustment to an account
+      # @param account_id [Integer] Account to adjust
+      # @param amount [Decimal] Adjustment amount
+      # @param is_debit [Boolean] Whether this is a debit (true) or credit (false)
+      # @param description [String] Optional description
+      # @return [VirtualAccountTransaction] The created adjustment transaction
+      def self.create_adjustment(account_id:, amount:, is_debit: true, description: nil)
+        reference_number = generate_reference_number
+
+        VirtualAccountTransaction.create!(
+          transaction_type: :adjustment,
+          entry_type: is_debit ? :debit : :credit,
+          account_id: account_id,
+          amount: amount,
+          reference_number: reference_number,
+          description: description,
+          status: :pending
+        )
+      end
+
+      # Process a transaction
+      # @param transaction [VirtualAccountTransaction] Transaction to process
+      # @return [Boolean] Success or failure
+      def self.process(transaction)
+        transaction.process!
+      end
+
+      # Cancel a transaction
+      # @param transaction [VirtualAccountTransaction] Transaction to cancel
+      # @return [Boolean] Success or failure
+      def self.cancel(transaction)
+        transaction.cancel!
+      end
+
+      private
+
+      def self.create_paired_transaction(from_account_id:, to_account_id:, amount:, transaction_type:, description: nil)
+        reference_number = generate_reference_number
+
+        ActiveRecord::Base.transaction do
+          # Debit entry (from account)
+          debit = VirtualAccountTransaction.create!(
+            transaction_type: transaction_type,
+            entry_type: :debit,
+            account_id: from_account_id,
+            amount: amount,
+            reference_number: reference_number,
+            description: description,
+            status: :pending
+          )
+
+          # Credit entry (to account)
+          credit = VirtualAccountTransaction.create!(
+            transaction_type: transaction_type,
+            entry_type: :credit,
+            account_id: to_account_id,
+            amount: amount,
+            reference_number: reference_number,
+            description: description,
+            status: :pending,
+            paired_transaction_id: debit.id
+          )
+
+          # Update the paired_transaction_id for the debit entry
+          debit.update!(paired_transaction_id: credit.id)
+
+          [ debit, credit ]
+        end
+      end
+
+      def self.find_or_create_system_account(account_identifier)
+        # Find or create a system account for external transactions
+        account = VirtualAccount.find_or_create_by!(account_number: account_identifier) do |account|
+          # Set default values for a new system account
+          account.user_id = find_or_create_system_user.id
+          account.cbs_account_number = account_identifier
+          account.branch_code = "SYSTEM"
+          account.product_scheme = "SAVINGS"
+          account.voucher_type = "REGULAR"
+          account.interest_rate = 0
+          account.interest_type = :simple
+          account.balance = 100000.00  # Initialize with a large balance
+          account.locked_amount = 0
+          account.status = :active
+        end
+
+        account
+      end
+
+      def self.ensure_system_account_balance(account, required_amount)
+        # Top up the system account if needed
+        if account.balance < required_amount
+          account.update!(balance: account.balance + required_amount * 2)
+        end
+      end
+
+      def self.find_or_create_system_user
+        User.find_or_create_by!(phone_number: "SYSTEM_USER") do |user|
+          user.first_name = "System"
+          user.last_name = "User"
+          user.password = SecureRandom.hex(8)
+        end
+      end
+
+      def self.generate_reference_number
+        timestamp = Time.current.strftime("%Y%m%d%H%M%S")
+        random = SecureRandom.hex(3)
+        "TXN#{timestamp}#{random}"
+      end
+    end
+  end
+end

data/db/migrate/20250609180530_add_accounting_fields_to_virtual_account_transactions.rb

@@ -0,0 +1,20 @@
+class AddAccountingFieldsToVirtualAccountTransactions < ActiveRecord::Migration[8.0]
+  def change
+    # Add new accounting fields
+    add_column :bscf_core_virtual_account_transactions, :entry_type, :integer
+    add_reference :bscf_core_virtual_account_transactions, :account, null: false, foreign_key: { to_table: :bscf_core_virtual_accounts }
+    add_column :bscf_core_virtual_account_transactions, :running_balance, :decimal, precision: 10, scale: 2
+    add_reference :bscf_core_virtual_account_transactions, :paired_transaction, null: true, foreign_key: { to_table: :bscf_core_virtual_account_transactions }
+    add_column :bscf_core_virtual_account_transactions, :value_date, :datetime
+
+    # Add new indexes
+    add_index :bscf_core_virtual_account_transactions, [ :account_id, :reference_number ]
+    add_index :bscf_core_virtual_account_transactions, :entry_type
+
+    # Remove old fields and indexes
+    remove_index :bscf_core_virtual_account_transactions, [ :from_account_id, :reference_number ], if_exists: true
+    remove_index :bscf_core_virtual_account_transactions, [ :to_account_id, :reference_number ], if_exists: true
+    remove_reference :bscf_core_virtual_account_transactions, :from_account
+    remove_reference :bscf_core_virtual_account_transactions, :to_account
+  end
+end

data/db/migrate/20250610120351_update_delivery_tables.rb

@@ -0,0 +1,15 @@
+class UpdateDeliveryTables < ActiveRecord::Migration[8.0]
+  def up
+    remove_column :bscf_core_delivery_orders, :buyer_phone
+    remove_column :bscf_core_delivery_orders, :seller_phone
+
+    add_column :bscf_core_delivery_orders, :estimated_delivery_price, :float
+
+    rename_column :bscf_core_delivery_orders, :delivery_price, :actual_delivery_price
+
+    add_reference :bscf_core_delivery_order_items, :pickup_address, foreign_key: { to_table: :bscf_core_addresses }
+    add_reference :bscf_core_delivery_order_items, :dropoff_address, foreign_key: { to_table: :bscf_core_addresses }
+
+    remove_reference :bscf_core_delivery_order_items, :product
+  end
+end

data/lib/bscf/core/version.rb

@@ -1,5 +1,5 @@
 module Bscf
   module Core
-    VERSION = "0.3.99"
+    VERSION = "0.4.0"
   end
 end

data/spec/factories/bscf/core/delivery_order_items.rb

@@ -2,7 +2,8 @@ FactoryBot.define do
   factory :delivery_order_item, class: 'Bscf::Core::DeliveryOrderItem' do
     association :delivery_order
     association :order_item
-    association :product
+    association :pickup_address, factory: :address
+    association :dropoff_address, factory: :address
     quantity { order_item.quantity }
     status { :pending }
     notes { Faker::Lorem.paragraph }

data/spec/factories/bscf/core/delivery_orders.rb

@@ -2,38 +2,15 @@ FactoryBot.define do
   factory :delivery_order, class: 'Bscf::Core::DeliveryOrder' do
     association :pickup_address, factory: :address
     association :dropoff_address, factory: :address
-    driver { nil }
+    association :driver, factory: :user
 
-    buyer_phone { Faker::PhoneNumber.phone_number }
-    seller_phone { Faker::PhoneNumber.phone_number }
     driver_phone { Faker::PhoneNumber.phone_number }
     delivery_notes { Faker::Lorem.paragraph }
     estimated_delivery_time { 2.days.from_now }
+    estimated_delivery_price { Faker::Number.decimal(l_digits: 2, r_digits: 2) }
+    actual_delivery_price { Faker::Number.decimal(l_digits: 2, r_digits: 2) }
     delivery_start_time { nil }
     delivery_end_time { nil }
     status { :pending }
-
-    trait :with_driver do
-      association :driver, factory: :user
-    end
-
-    trait :in_transit do
-      with_driver
-      status { :in_transit }
-      delivery_start_time { Time.current }
-    end
-
-    trait :delivered do
-      with_driver
-      status { :delivered }
-      delivery_start_time { 2.hours.ago }
-      delivery_end_time { Time.current }
-    end
-
-    trait :with_orders do
-      after(:create) do |delivery_order|
-        create_list(:order, 2, delivery_order: delivery_order)
-      end
-    end
   end
 end

data/spec/factories/bscf/core/virtual_account_transactions.rb

@@ -1,34 +1,49 @@
 FactoryBot.define do
   factory :virtual_account_transaction, class: 'Bscf::Core::VirtualAccountTransaction' do
-    association :from_account, factory: :virtual_account, status: :active, balance: 10000
-    association :to_account, factory: :virtual_account, status: :active, balance: 5000
+    association :account, factory: :virtual_account, status: :active, balance: 10000
     amount { 100.0 }
-    transaction_type { :transfer }
+    transaction_type { :adjustment }
+    entry_type { :debit }
     status { :pending }
+    value_date { Time.current }
     description { Faker::Lorem.sentence }
+    running_balance { nil }
 
-    trait :completed do
-      status { :completed }
-    end
-
-    trait :failed do
-      status { :failed }
-    end
+    factory :paired_transaction do
+      transient do
+        paired_account { create(:virtual_account, status: :active, balance: 10000) }
+        is_credit { false }
+      end
 
-    trait :cancelled do
-      status { :cancelled }
-    end
+      after(:build) do |transaction, evaluator|
+        if transaction.transaction_type == 'transfer'
+          paired_entry_type = transaction.entry_type == 'debit' ? :credit : :debit
+        elsif transaction.transaction_type == 'deposit'
+          paired_entry_type = transaction.entry_type == 'debit' ? :credit : :debit
+        elsif transaction.transaction_type == 'withdrawal'
+          paired_entry_type = transaction.entry_type == 'debit' ? :credit : :debit
+        else
+          paired_entry_type = evaluator.is_credit ? :credit : :debit
+        end
 
-    trait :deposit do
-      transaction_type { :deposit }
-    end
+        paired = build(:virtual_account_transaction,
+          transaction_type: transaction.transaction_type,
+          entry_type: paired_entry_type,
+          account: evaluator.paired_account,
+          amount: transaction.amount,
+          reference_number: transaction.reference_number,
+          value_date: transaction.value_date,
+          status: transaction.status
+        )
 
-    trait :withdrawal do
-      transaction_type { :withdrawal }
-    end
+        transaction.paired_transaction = paired
+        paired.paired_transaction = transaction
+      end
 
-    trait :with_large_amount do
-      amount { 5000.0 }
+      after(:create) do |transaction, evaluator|
+        # Save the paired transaction after the main transaction is created
+        transaction.paired_transaction.save! if transaction.paired_transaction&.new_record?
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bscf-core
 version: !ruby/object:Gem::Version
-  version: 0.3.99
+  version: 0.4.0
 platform: ruby
 authors:
 - Asrat
@@ -311,6 +311,7 @@ files:
 - app/models/bscf/core/voucher.rb
 - app/models/bscf/core/wholesaler_product.rb
 - app/services/bscf/core/token_service.rb
+- app/services/bscf/core/transaction_service.rb
 - config/database.yml
 - config/routes.rb
 - db/migrate/20250326065606_create_bscf_core_users.rb
@@ -345,6 +346,8 @@ files:
 - db/migrate/20250524081221_create_bscf_core_vouchers.rb
 - db/migrate/20250524151346_add_locked_amount_to_virtual_accounts.rb
 - db/migrate/20250606100158_add_product_to_market_place_listings.rb
+- db/migrate/20250609180530_add_accounting_fields_to_virtual_account_transactions.rb
+- db/migrate/20250610120351_update_delivery_tables.rb
 - lib/bscf/core.rb
 - lib/bscf/core/engine.rb
 - lib/bscf/core/version.rb