bscf-core 0.3.99 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ba4cb08d046b4bcef3b55100146f08c64fa32d7b97f59302ffdf8ef1a804737
-  data.tar.gz: da7bd6abdf23ec993e8442e998853118533d2f2d7773de25155aca33c6569c22
+  metadata.gz: ac477439e787a6451f0b7d5a92ac75e430ac8b0ddcd7a04bb5f8e57c4bd086dc
+  data.tar.gz: 4bd37eaa9562180049efec4028c438404bce7f08661c27c2c9e4018ba88a724a
 SHA512:
-  metadata.gz: 7eca0f066d06df32ff1fcbf12c1056331ada9eef7f5f5cd18d37becc26dfad27a3576e9afc97e157bd7bd133a5c28534c70aeb2c74592c325b67b51bcf42f6e4
-  data.tar.gz: 35654a8b5fab7cb7b4bfdaa124014cbf80e9c1b640079ec43a2d95800672d34db54e7ee89c3cacf31eff19f6b627b7e56f8a5f335d70a9308939a19b4932b0b3
+  metadata.gz: 37282dd5fdd0974155a6d4f05000fca63f94d897a61d16d764e3dc047a769957ec7927f99924852e7b6f12e425e71689b18f59a987e984a88d21b31d9fe6ba12
+  data.tar.gz: 7c5d5491af64a7f91ed9a951fa04358e74a7e124d6e3f4fd232c9a8ef1461be00aaa11fc296c0fdf673145618f15035756927e6ee75b1a0e2c83f80a9879ada9

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

@@ -2,6 +2,31 @@ module Bscf
   module Core
     class Address < ApplicationRecord
       has_many :user_profiles
+
+      # Add associations for delivery orders and items
+      has_many :delivery_order_pickups, class_name: "Bscf::Core::DeliveryOrder", foreign_key: "pickup_address_id"
+      has_many :delivery_order_dropoffs, class_name: "Bscf::Core::DeliveryOrder", foreign_key: "dropoff_address_id"
+      has_many :delivery_order_item_pickups, class_name: "Bscf::Core::DeliveryOrderItem", foreign_key: "pickup_address_id"
+      has_many :delivery_order_item_dropoffs, class_name: "Bscf::Core::DeliveryOrderItem", foreign_key: "dropoff_address_id"
+
+      validates :latitude, :longitude, presence: true, if: :requires_coordinates?
+
+      def coordinates
+        %i[latitude longitude] if latitude.present? && longitude.present?
+      end
+
+      def full_address
+        %i[house_number woreda sub_city city].compact.join(", ")
+      end
+
+      private
+
+      def requires_coordinates?
+        # Determine when coordinates are required
+        # For delivery addresses, they should always be required
+        delivery_order_pickups.any? || delivery_order_dropoffs.any? ||
+        delivery_order_item_pickups.any? || delivery_order_item_dropoffs.any?
+      end
     end
   end
 end

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

@@ -1,63 +1,139 @@
-module Bscf::Core
-  class DeliveryOrder < ApplicationRecord
-    has_many :orders
-    belongs_to :pickup_address, class_name: "Bscf::Core::Address"
-    belongs_to :dropoff_address, class_name: "Bscf::Core::Address"
-    belongs_to :driver, class_name: "Bscf::Core::User", optional: true
-
-    has_many :delivery_order_items, dependent: :destroy
-    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
-    validate :end_time_after_start_time, if: -> { delivery_start_time.present? && delivery_end_time.present? }
-
-    before_save :update_delivery_times
-    before_save :calculate_actual_delivery_time
-
-    # after_save :sync_items_status, if: :saved_change_to_status?
-
-    enum :status, {
-      pending: 0,
-      in_transit: 1,
-      picked_up: 2,
-      delivered: 3,
-      received: 4,
-      paid: 5,
-      failed: 6,
-      cancelled: 7
-    }
-
-    def delivery_duration
-      return nil unless delivery_start_time && delivery_end_time
-      ((delivery_end_time - delivery_start_time) / 1.hour).round(2)
-    end
+module Bscf
+  module Core
+    class DeliveryOrder < ApplicationRecord
+      has_many :orders
+      belongs_to :pickup_address, class_name: "Bscf::Core::Address"
+      belongs_to :dropoff_address, class_name: "Bscf::Core::Address"
+      belongs_to :driver, class_name: "Bscf::Core::User", optional: true
+
+      has_many :delivery_order_items, dependent: :destroy
+      has_many :order_items, through: :delivery_order_items
+      has_many :products, through: :delivery_order_items
+
+      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
+      before_save :calculate_actual_delivery_time
+
+      # after_save :sync_items_status, if: :saved_change_to_status?
 
-    private
+      enum :status, {
+        pending: 0,
+        in_transit: 1,
+        picked_up: 2,
+        delivered: 3,
+        received: 4,
+        paid: 5,
+        failed: 6,
+        cancelled: 7
+      }
 
-    def update_delivery_times
-      case status
-      when "in_transit"
-        self.delivery_start_time = Time.current if delivery_start_time.nil?
-      when "delivered", "failed"
-        self.delivery_end_time = Time.current if delivery_end_time.nil?
+      def delivery_duration
+        return nil unless delivery_start_time && delivery_end_time
+        ((delivery_end_time - delivery_start_time) / 1.hour).round(2)
       end
-    end
 
-    def calculate_actual_delivery_time
-      self.actual_delivery_time = delivery_end_time if status == "delivered"
-    end
+      def optimized_route
+        return nil unless pickup_address&.coordinates.present?
+
+        # Get all delivery order items with dropoff addresses
+        items_with_dropoffs = delivery_order_items.includes(:dropoff_address)
+                                                  .where.not(dropoff_address: nil)
+
+        dropoff_addresses = items_with_dropoffs.map(&:dropoff_address).compact.uniq
+        return nil if dropoff_addresses.empty?
 
-    def end_time_after_start_time
-      return unless delivery_start_time && delivery_end_time
-      if delivery_end_time <= delivery_start_time
-        errors.add(:delivery_end_time, "must be after delivery start time")
+        # Check if all dropoff addresses have coordinates
+        return nil if dropoff_addresses.any? { |addr| addr.coordinates.blank? }
+
+        # Call Gebeta Maps service
+        gebeta_service = Bscf::Core::GebetaMapsService.new
+        route_data = gebeta_service.optimize_route(pickup_address, dropoff_addresses)
+
+        # Return nil if route_data is empty or doesn't have waypoints
+        return nil if route_data.blank? || !route_data.key?("waypoints")
+
+        # Cache the result if needed
+        # Rails.cache.write("delivery_order_route_#{id}", route_data, expires_in: 1.hour)
+        route_data
       end
-    end
 
-    def sync_items_status
-      delivery_order_items.update_all(status: status)
+      # Reorder delivery items based on optimized route or provided positions
+      def reorder_items_by_route(positions = nil)
+        if positions.is_a?(Hash)
+          # Use provided positions
+          positions.each do |item_id, position|
+            if item = delivery_order_items.find_by(id: item_id)
+              item.update(position: position)
+            end
+          end
+          true
+        else
+          return false if positions && !positions.is_a?(Hash)
+
+          # Use optimized route
+          route_data = optimized_route
+
+          return false unless route_data.present? && route_data["waypoints"].present?
+
+          # Get the optimized order of waypoints
+          waypoint_order = route_data["waypoints"].map { |wp| wp["waypoint_index"] }
+
+          # Get all delivery order items with dropoff addresses
+          items_with_dropoffs = delivery_order_items.includes(:dropoff_address)
+                                                    .where.not(dropoff_address: nil)
+                                                    .to_a
+
+          # Skip if we don't have the same number of items as waypoints
+          return false if items_with_dropoffs.size != waypoint_order.size
+
+          # Reorder items based on waypoint order
+          waypoint_order.each_with_index do |original_index, new_position|
+            if item = items_with_dropoffs[original_index]
+              item.update(position: new_position + 1)
+            end
+          end
+
+          true
+        end
+      end
+
+      # Add this method to the DeliveryOrder class
+      def dropoff_addresses
+        delivery_order_items.includes(:dropoff_address)
+                            .where.not(dropoff_address: nil)
+                            .map(&:dropoff_address)
+                            .compact
+                            .uniq
+      end
+
+
+      private
+
+      def update_delivery_times
+        case status
+        when "in_transit"
+          self.delivery_start_time = Time.current if delivery_start_time.nil?
+        when "delivered", "failed"
+          self.delivery_end_time = Time.current if delivery_end_time.nil?
+        end
+      end
+
+      def calculate_actual_delivery_time
+        self.actual_delivery_time = delivery_end_time if status == "delivered"
+      end
+
+      def end_time_after_start_time
+        return unless delivery_start_time && delivery_end_time
+        if delivery_end_time <= delivery_start_time
+          errors.add(:delivery_end_time, "must be after delivery start time")
+        end
+      end
+
+      def sync_items_status
+        delivery_order_items.update_all(status: status)
+      end
     end
   end
 end

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
@@ -10,6 +11,9 @@ module Bscf::Core
 
     after_save :update_delivery_order_status
     before_save :sync_status_with_delivery_order
+    before_save :set_default_pickup_address, if: -> { pickup_address.nil? && delivery_order.present? }
+    # Add default scope for ordering by position
+    default_scope { order(position: :asc) }
 
     enum :status, {
       pending: 0,
@@ -21,6 +25,10 @@ module Bscf::Core
 
     private
 
+    def set_default_pickup_address
+      self.pickup_address = delivery_order.pickup_address
+    end
+
     def quantity_not_exceeding_order_item
       return unless quantity && order_item&.quantity
       if quantity > order_item.quantity

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/gebeta_maps_service.rb

@@ -0,0 +1,59 @@
+  require "httparty"
+
+  module Bscf
+    module Core
+      class GebetaMapsService
+        include HTTParty
+        base_uri "https://api.gebeta.app/api/v1"
+
+        def initialize
+          @api_key = ENV["GEBETA_API_KEY"]
+        end
+
+        # One-to-Many (ONM) API for route optimization
+        def optimize_route(origin_address, destination_addresses)
+          return {} if destination_addresses.empty?
+
+          # Extract coordinates
+          origin = origin_address.coordinates
+          destinations = destination_addresses.map(&:coordinates).compact
+
+          return {} if origin.nil? || destinations.empty?
+
+          # Prepare destinations in the format expected by Gebeta Maps
+          destinations_json = destinations.map.with_index do |coords, index|
+            {
+              id: index,
+              point: {
+                lat: coords[0],
+                lng: coords[1]
+              }
+            }
+          end.to_json
+
+          # Make API request
+          response = self.class.get(
+            "/direction/onm",
+            query: {
+              origin: "#{origin[0]},#{origin[1]}",
+              json: destinations_json,
+              key: @api_key
+            }
+          )
+
+          handle_response(response)
+        end
+
+        private
+
+        def handle_response(response)
+          if response.success?
+            JSON.parse(response.body)
+          else
+            Rails.logger.error("Gebeta Maps API error: #{response.code} - #{response.body}")
+            {}
+          end
+        end
+      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/config/master.key

@@ -0,0 +1 @@
+3009aef5af3ca1ddb654f74ad2ac7d5a

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/db/migrate/20250616134209_update_address_coordinates_type.rb

@@ -0,0 +1,6 @@
+class UpdateAddressCoordinatesType < ActiveRecord::Migration[8.0]
+  def change
+    change_column :bscf_core_addresses, :latitude, :decimal, precision: 10, scale: 6, using: 'latitude::numeric(10,6)'
+    change_column :bscf_core_addresses, :longitude, :decimal, precision: 10, scale: 6, using: 'longitude::numeric(10,6)'
+   end
+end

data/db/migrate/20250616145522_add_position_to_delivery_order_items.rb

@@ -0,0 +1,6 @@
+class AddPositionToDeliveryOrderItems < ActiveRecord::Migration[8.0]
+  def change
+    add_column :bscf_core_delivery_order_items, :position, :integer
+    add_index :bscf_core_delivery_order_items, :position
+  end
+end

data/lib/bscf/core/version.rb

@@ -1,5 +1,5 @@
 module Bscf
   module Core
-    VERSION = "0.3.99"
+    VERSION = "0.4.1"
   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.1
 platform: ruby
 authors:
 - Asrat
@@ -310,8 +310,11 @@ files:
 - app/models/bscf/core/virtual_account_transaction.rb
 - app/models/bscf/core/voucher.rb
 - app/models/bscf/core/wholesaler_product.rb
+- app/services/bscf/core/gebeta_maps_service.rb
 - app/services/bscf/core/token_service.rb
+- app/services/bscf/core/transaction_service.rb
 - config/database.yml
+- config/master.key
 - config/routes.rb
 - db/migrate/20250326065606_create_bscf_core_users.rb
 - db/migrate/20250326075111_create_bscf_core_roles.rb
@@ -345,6 +348,10 @@ 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
+- db/migrate/20250616134209_update_address_coordinates_type.rb
+- db/migrate/20250616145522_add_position_to_delivery_order_items.rb
 - lib/bscf/core.rb
 - lib/bscf/core/engine.rb
 - lib/bscf/core/version.rb