schwab_rb 0.2.0

data/lib/schwab_rb/data_objects/order.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require_relative 'order_leg'
+
+module SchwabRb
+  module DataObjects
+    class ExecutionLeg
+      attr_reader :leg_id, :quantity, :mismarked_quantity, :price, :time, :instrument_id
+
+      class << self
+        def build(data)
+          new(
+            leg_id: data[:legId],
+            quantity: data[:quantity],
+            mismarked_quantity: data[:mismarkedQuantity],
+            price: data[:price],
+            time: data[:time],
+            instrument_id: data[:instrumentId]
+          )
+        end
+      end
+
+      def initialize(leg_id:, quantity:, mismarked_quantity:, price:, time:, instrument_id:)
+        @leg_id = leg_id
+        @quantity = quantity
+        @mismarked_quantity = mismarked_quantity
+        @price = price
+        @time = time
+        @instrument_id = instrument_id
+      end
+
+      def to_h
+        {
+          legId: @leg_id,
+          quantity: @quantity,
+          mismarkedQuantity: @mismarked_quantity,
+          price: @price,
+          time: @time,
+          instrumentId: @instrument_id
+        }
+      end
+    end
+
+    class OrderActivity
+      attr_reader :activity_type, :activity_id, :execution_type, :quantity, :order_remaining_quantity, :execution_legs
+
+      class << self
+        def build(data)
+          new(
+            activity_type: data[:activityType],
+            activity_id: data[:activityId],
+            execution_type: data[:executionType],
+            quantity: data[:quantity],
+            order_remaining_quantity: data[:orderRemainingQuantity],
+            execution_legs: data.fetch(:executionLegs, []).map { |leg| ExecutionLeg.build(leg) }
+          )
+        end
+      end
+
+      def initialize(activity_type:, activity_id:, execution_type:, quantity:, order_remaining_quantity:, execution_legs:)
+        @activity_type = activity_type
+        @activity_id = activity_id
+        @execution_type = execution_type
+        @quantity = quantity
+        @order_remaining_quantity = order_remaining_quantity
+        @execution_legs = execution_legs
+      end
+
+      def to_h
+        {
+          activityType: @activity_type,
+          activityId: @activity_id,
+          executionType: @execution_type,
+          quantity: @quantity,
+          orderRemainingQuantity: @order_remaining_quantity,
+          executionLegs: @execution_legs.map(&:to_h)
+        }
+      end
+    end
+
+    class Order
+      attr_reader :duration, :order_type, :complex_order_strategy_type, :quantity,
+                  :filled_quantity, :remaining_quantity, :price, :order_leg_collection, :order_strategy_type, :order_id, :status, :entered_time, :close_time, :order_activity_collection
+
+      class << self
+        def build(data)
+          # Parse datetime strings into DateTime objects
+          entered_time = parse_datetime(data[:enteredTime])
+          close_time = parse_datetime(data[:closeTime])
+
+          new(
+            duration: data[:duration],
+            order_type: data[:orderType],
+            complex_order_strategy_type: data[:complexOrderStrategyType],
+            quantity: data[:quantity],
+            filled_quantity: data[:filledQuantity],
+            remaining_quantity: data[:remainingQuantity],
+            price: data[:price],
+            order_leg_collection: data.fetch(:orderLegCollection, []).map { |leg| OrderLeg.build(leg) },
+            order_strategy_type: data[:orderStrategyType],
+            order_id: data[:orderId],
+            status: data[:status],
+            entered_time: entered_time,
+            close_time: close_time,
+            order_activity_collection: data.fetch(:orderActivityCollection, []).map do |activity|
+              OrderActivity.build(activity)
+            end
+          )
+        end
+
+        private
+
+        def parse_datetime(datetime_str)
+          return nil if datetime_str.nil? || datetime_str.empty?
+
+          begin
+            DateTime.parse(datetime_str)
+          rescue ArgumentError
+            nil
+          end
+        end
+      end
+
+      def initialize(
+        duration:, order_type:, complex_order_strategy_type:, quantity:, filled_quantity:,
+        remaining_quantity:, price:, order_strategy_type:, order_id:, status:, entered_time:, close_time:, order_leg_collection: [], order_activity_collection: []
+      )
+        @duration = duration
+        @order_type = order_type
+        @complex_order_strategy_type = complex_order_strategy_type
+        @quantity = quantity
+        @filled_quantity = filled_quantity
+        @remaining_quantity = remaining_quantity
+        @price = price
+        @order_leg_collection = order_leg_collection
+        @order_strategy_type = order_strategy_type
+        @order_id = order_id
+        @status = status
+        @entered_time = entered_time
+        @close_time = close_time
+        @order_activity_collection = order_activity_collection
+      end
+
+      def symbols
+        order_leg_collection.map(&:symbol)
+      end
+
+      def strategy
+        if %w[VERTICAL CUSTOM].include?(complex_order_strategy_type) && order_leg_collection.all?(&:call?)
+          'CALL_SPREAD'
+        elsif %w[VERTICAL CUSTOM].include?(complex_order_strategy_type) && order_leg_collection.all?(&:put?)
+          'PUT_SPREAD'
+        else
+          order_strategy_type
+        end
+      end
+
+      def close?
+        order_leg_collection.all? { |leg| leg.position_effect == 'CLOSING' }
+      end
+
+      def open?
+        order_leg_collection.all? { |leg| leg.position_effect == 'OPENING' }
+      end
+
+      def to_h
+        {
+          duration: @duration,
+          orderType: @order_type,
+          complexOrderStrategyType: @complex_order_strategy_type,
+          quantity: @quantity,
+          filledQuantity: @filled_quantity,
+          remainingQuantity: @remaining_quantity,
+          price: @price,
+          orderLegCollection: @order_leg_collection.map(&:to_h),
+          orderStrategyType: @order_strategy_type,
+          orderId: @order_id,
+          status: @status,
+          enteredTime: @entered_time&.iso8601,
+          closeTime: @close_time&.iso8601,
+          orderActivityCollection: @order_activity_collection.map(&:to_h)
+        }
+      end
+    end
+  end
+end

data/lib/schwab_rb/data_objects/order_leg.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative 'instrument'
+
+module SchwabRb
+  module DataObjects
+    class OrderLeg
+      attr_reader :leg_id, :order_leg_type, :quantity, :instrument, :instruction, :position_effect
+
+      class << self
+        def build(data)
+          new(
+            leg_id: data[:legId],
+            order_leg_type: data[:orderLegType],
+            quantity: data[:quantity],
+            instrument: Instrument.build(data[:instrument]),
+            instruction: data.fetch(:instruction, nil),
+            position_effect: data[:positionEffect]
+          )
+        end
+      end
+
+      def initialize(leg_id:, order_leg_type:, quantity:, instrument:, instruction:, position_effect:)
+        @leg_id = leg_id
+        @order_leg_type = order_leg_type
+        @quantity = quantity
+        @instrument = instrument
+        @instruction = instruction
+        @position_effect = position_effect
+      end
+
+      def call?
+        put_call == 'CALL'
+      end
+
+      def close?
+        position_effect == 'CLOSING'
+      end
+
+      def open?
+        position_effect == 'OPENING'
+      end
+
+      def put?
+        put_call == 'PUT'
+      end
+
+      def put_call
+        instrument.put_call
+      end
+
+      def symbol
+        instrument.symbol
+      end
+
+      def to_h
+        {
+          legId: @leg_id,
+          orderLegType: @order_leg_type,
+          quantity: @quantity,
+          instrument: @instrument.to_h,
+          instruction: @instruction,
+          positionEffect: @position_effect
+        }
+      end
+    end
+  end
+end

data/lib/schwab_rb/data_objects/order_preview.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require_relative 'order_leg'
+
+module SchwabRb
+  module DataObjects
+    class OrderPreview
+      attr_reader :order_id, :order_value, :order_strategy, :order_balance, :order_validation_result, :projected_commission
+
+      class << self
+        def build(data)
+          new(data)
+        end
+      end
+
+      def initialize(attrs)
+        @order_id = attrs[:orderId]
+        @order_value = attrs[:orderValue]
+        @order_strategy = attrs[:orderStrategy] ? OrderStrategy.new(attrs[:orderStrategy]) : nil
+        @order_balance = attrs[:orderBalance] ? OrderBalance.new(attrs[:orderBalance]) : nil
+        @order_validation_result = attrs[:orderValidationResult] ? OrderValidationResult.new(attrs[:orderValidationResult]) : nil
+        @projected_commission = attrs[:projectedCommission] ? CommissionAndFee.new(attrs[:projectedCommission]) : nil
+      end
+
+      def status
+        @order_strategy&.status
+      end
+
+      def price
+        @order_strategy&.price
+      end
+
+      def quantity
+        @order_strategy&.quantity
+      end
+
+      def accepted?
+        status == 'ACCEPTED'
+      end
+
+      def commission
+        return 0.0 unless @projected_commission
+
+        @projected_commission.commission.to_f
+      end
+
+      def fees
+        return 0.0 unless @projected_commission
+
+        @projected_commission.fee.to_f
+      end
+
+      def to_h
+        {
+          orderId: @order_id,
+          orderValue: @order_value,
+          orderStrategy: @order_strategy&.to_h,
+          orderBalance: @order_balance&.to_h,
+          orderValidationResult: @order_validation_result&.to_h,
+          projectedCommission: @projected_commission&.to_h
+        }
+      end
+
+      class OrderStrategy
+        attr_reader :account_number, :status, :price, :quantity, :order_type, :type, :strategy_id, :order_legs
+
+        def initialize(attrs)
+          @account_number = attrs[:accountNumber]
+          @status = attrs[:status]
+          @price = attrs[:price]
+          @quantity = attrs[:quantity]
+          @order_type = attrs[:orderType]
+          @type = attrs[:type]
+          @strategy_id = attrs[:strategyId]
+          @order_legs = attrs[:orderLegs]&.map { |leg| OrderLeg.build(leg) } || []
+        end
+
+        def to_h
+          {
+            accountNumber: @account_number,
+            status: @status,
+            price: @price,
+            quantity: @quantity,
+            orderType: @order_type,
+            type: @type,
+            strategyId: @strategy_id,
+            orderLegs: @order_legs.map(&:to_h)
+          }
+        end
+      end
+
+      class OrderBalance
+        attr_reader :order_value, :projected_available_fund, :projected_buying_power, :projected_commission
+
+        def initialize(attrs)
+          @order_value = attrs[:orderValue]
+          @projected_available_fund = attrs[:projectedAvailableFund]
+          @projected_buying_power = attrs[:projectedBuyingPower]
+          @projected_commission = attrs[:projectedCommission]
+        end
+
+        def to_h
+          {
+            orderValue: @order_value,
+            projectedAvailableFund: @projected_available_fund,
+            projectedBuyingPower: @projected_buying_power,
+            projectedCommission: @projected_commission
+          }
+        end
+      end
+
+      class OrderValidationResult
+        attr_reader :is_valid, :warning_message, :rejects
+
+        def initialize(attrs)
+          @is_valid = attrs[:isValid]
+          @warning_message = attrs[:warningMessage]
+          @rejects = attrs[:rejects]&.map { |reject| Reject.new(reject) } || []
+        end
+
+        def to_h
+          {
+            isValid: @is_valid,
+            warningMessage: @warning_message,
+            rejects: @rejects.map(&:to_h)
+          }
+        end
+
+        class Reject
+          attr_reader :reject_code, :reject_message
+
+          def initialize(attrs)
+            @reject_code = attrs[:rejectCode]
+            @reject_message = attrs[:rejectMessage]
+          end
+
+          def to_h
+            {
+              rejectCode: @reject_code,
+              rejectMessage: @reject_message
+            }
+          end
+        end
+      end
+
+      class CommissionAndFee
+        attr_reader :commission_data, :fee_data
+
+        def initialize(attrs)
+          # Handle the flattened structure (from API)
+          if attrs[:commissions]
+            @commission_data = attrs[:commissions]
+            @fee_data = attrs[:fees] || []
+            @true_commission_data = []
+            @direct_commission = attrs[:commission]
+            @direct_fee = attrs[:fee]
+            @direct_true_commission = attrs[:trueCommission]
+          # Handle the nested structure (from test data)
+          else
+            @commission_data = attrs.dig(:commission, :commissionLegs) || []
+            @fee_data = attrs.dig(:fee, :feeLegs) || []
+            @true_commission_data = attrs.dig(:trueCommission, :commissionLegs) || []
+            @direct_commission = nil
+            @direct_fee = nil
+            @direct_true_commission = nil
+          end
+        end
+
+        def commission_total
+          calculate_total_from_legs(@commission_data, 'COMMISSION')
+        end
+
+        def commission
+          @direct_commission || sprintf("%.2f", commission_total)
+        end
+
+        def fee_total
+          calculate_total_from_legs(@fee_data, ['OPT_REG_FEE', 'INDEX_OPTION_FEE'])
+        end
+
+        def fee
+          @direct_fee || sprintf("%.2f", fee_total)
+        end
+
+        def true_commission
+          if @direct_true_commission
+            @direct_true_commission
+          else
+            # For nested structure, calculate from true commission legs
+            if @true_commission_data.any?
+              true_commission_total = calculate_total_from_legs(@true_commission_data, 'COMMISSION')
+              sprintf("%.2f", true_commission_total * 2)
+            else
+              sprintf("%.2f", commission_total * 2)
+            end
+          end
+        end
+
+        def commissions
+          @commission_data
+        end
+
+        def fees
+          @fee_data
+        end
+
+        def to_h
+          {
+            commission: commission,
+            fee: fee,
+            trueCommission: true_commission,
+            commissions: commissions,
+            fees: fees
+          }
+        end
+
+        private
+
+        def calculate_total_from_legs(legs, types)
+          total = 0.0
+          types = [types] unless types.is_a?(Array)
+
+          legs.each do |leg|
+            values = leg[:commissionValues] || leg[:feeValues] || []
+            values.each do |value_item|
+              if types.include?(value_item[:type])
+                total += (value_item[:value] || 0.0)
+              end
+            end
+          end
+
+          total.round(2)
+        end
+      end
+    end
+  end
+end

data/lib/schwab_rb/data_objects/position.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative 'instrument'
+
+module SchwabRb
+  module DataObjects
+    class Position
+      attr_reader :short_quantity, :average_price, :current_day_profit_loss, :current_day_profit_loss_percentage,
+                  :long_quantity, :settled_long_quantity, :settled_short_quantity, :instrument, :market_value,
+                  :maintenance_requirement, :average_long_price, :average_short_price, :long_open_profit_loss, :short_open_profit_loss, :current_day_cost, :strike, :delta, :mark
+
+      class << self
+        def build(data)
+          new(
+            short_quantity: data[:shortQuantity],
+            average_price: data[:averagePrice],
+            current_day_profit_loss: data[:currentDayProfitLoss],
+            current_day_profit_loss_percentage: data[:currentDayProfitLossPercentage],
+            long_quantity: data[:longQuantity],
+            settled_long_quantity: data[:settledLongQuantity],
+            settled_short_quantity: data[:settledShortQuantity],
+            instrument: Instrument.build(data[:instrument]),
+            market_value: data[:marketValue],
+            maintenance_requirement: data[:maintenanceRequirement],
+            average_long_price: data[:averageLongPrice],
+            average_short_price: data[:averageShortPrice],
+            long_open_profit_loss: data[:longOpenProfitLoss],
+            short_open_profit_loss: data[:shortOpenProfitLoss],
+            current_day_cost: data[:currentDayCost]
+          )
+        end
+      end
+
+      def initialize(
+        short_quantity: nil, average_price: nil, current_day_profit_loss: nil, current_day_profit_loss_percentage: nil,
+        long_quantity: nil, settled_long_quantity: nil, settled_short_quantity: nil, instrument: nil, market_value: nil, maintenance_requirement: nil, average_long_price: nil, average_short_price: nil, long_open_profit_loss: nil, short_open_profit_loss: nil, current_day_cost: nil, strike: nil, delta: nil, mark: nil
+      )
+        @short_quantity = short_quantity
+        @average_price = average_price
+        @current_day_profit_loss = current_day_profit_loss
+        @current_day_profit_loss_percentage = current_day_profit_loss_percentage
+        @long_quantity = long_quantity
+        @settled_long_quantity = settled_long_quantity
+        @settled_short_quantity = settled_short_quantity
+        @instrument = instrument
+        @market_value = market_value
+        @maintenance_requirement = maintenance_requirement
+        @average_long_price = average_long_price
+        @average_short_price = average_short_price
+        @long_open_profit_loss = long_open_profit_loss
+        @short_open_profit_loss = short_open_profit_loss
+        @current_day_cost = current_day_cost
+        @strike = strike
+        @delta = delta
+        @mark = mark
+      end
+
+      def symbol
+        instrument&.symbol
+      end
+
+      def underlying_symbol
+        instrument.underlying_symbol
+      end
+
+      def long?
+        long_quantity.positive?
+      end
+
+      def short?
+        short_quantity.positive?
+      end
+
+      def long_short
+        if long?
+          'LONG'
+        elsif short?
+          'SHORT'
+        else
+          'NONE'
+        end
+      end
+
+      def put_call
+        instrument.put_call
+      end
+
+      def to_h
+        {
+          symbol: symbol,
+          underlying_symbol: underlying_symbol,
+          average_price: average_price,
+          market_value: market_value,
+          put_call: put_call,
+          long_short: long_short
+        }
+      end
+    end
+  end
+end