schwab 0.2.0

data/lib/schwab/resources/position.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Schwab
+  module Resources
+    # Resource wrapper for position objects
+    # Provides position-specific calculations and helper methods
+    class Position < Base
+      # Set up field type coercions for position fields
+      set_field_type :average_price, :float
+      set_field_type :current_day_cost, :float
+      set_field_type :current_day_profit_loss, :float
+      set_field_type :current_day_profit_loss_percentage, :float
+      set_field_type :long_quantity, :float
+      set_field_type :short_quantity, :float
+      set_field_type :settled_long_quantity, :float
+      set_field_type :settled_short_quantity, :float
+      set_field_type :market_value, :float
+      set_field_type :maintenance_requirement, :float
+      set_field_type :previous_session_long_quantity, :float
+      set_field_type :previous_session_short_quantity, :float
+
+      # Get the symbol
+      #
+      # @return [String] The position symbol
+      def symbol
+        if self[:instrument]
+          self[:instrument][:symbol] || self[:instrument][:underlying_symbol]
+        else
+          self[:symbol]
+        end
+      end
+
+      # Get the asset type
+      #
+      # @return [String] The asset type (e.g., "EQUITY", "OPTION")
+      def asset_type
+        if self[:instrument]
+          self[:instrument][:assetType] || self[:instrument][:asset_type]
+        else
+          self[:assetType] || self[:asset_type]
+        end
+      end
+
+      # Get the CUSIP
+      #
+      # @return [String] The CUSIP identifier
+      def cusip
+        if self[:instrument]
+          self[:instrument][:cusip]
+        else
+          self[:cusip]
+        end
+      end
+
+      # Get the quantity (net of long and short)
+      #
+      # @return [Float] The net quantity
+      def quantity
+        long_qty = (self[:longQuantity] || self[:long_quantity] || 0).to_f
+        short_qty = (self[:shortQuantity] || self[:short_quantity] || 0).to_f
+        long_qty - short_qty
+      end
+      alias_method :net_quantity, :quantity
+
+      # Get the average price (cost basis per share)
+      #
+      # @return [Float, nil] The average price
+      def average_price
+        self[:averagePrice] || self[:average_price]
+      end
+      alias_method :cost_basis_per_share, :average_price
+
+      # Get the current price
+      #
+      # @return [Float, nil] The current market price
+      def current_price
+        if self[:instrument] && self[:instrument][:lastPrice]
+          self[:instrument][:lastPrice]
+        elsif self[:quote]
+          self[:quote][:last] || self[:quote][:mark]
+        else
+          self[:currentPrice] || self[:current_price] || self[:lastPrice] || self[:last_price]
+        end
+      end
+      alias_method :market_price, :current_price
+      alias_method :last_price, :current_price
+
+      # Get the market value of the position
+      #
+      # @return [Float] The market value
+      def market_value
+        value = self[:marketValue] || self[:market_value]
+        return value.to_f if value
+
+        # Calculate if not provided
+        if current_price && quantity
+          (current_price * quantity.abs).round(2)
+        else
+          0.0
+        end
+      end
+
+      # Calculate the total cost basis
+      #
+      # @return [Float] The total cost basis
+      def cost_basis
+        if average_price && quantity
+          (average_price * quantity.abs).round(2)
+        else
+          0.0
+        end
+      end
+      alias_method :total_cost, :cost_basis
+
+      # Calculate unrealized P&L
+      #
+      # @return [Float] The unrealized profit/loss
+      def unrealized_pnl
+        market_value - cost_basis
+      end
+      alias_method :unrealized_profit_loss, :unrealized_pnl
+
+      # Calculate unrealized P&L percentage
+      #
+      # @return [Float, nil] The unrealized profit/loss percentage
+      def unrealized_pnl_percentage
+        return if cost_basis.zero?
+
+        ((unrealized_pnl / cost_basis) * 100).round(2)
+      end
+      alias_method :unrealized_profit_loss_percentage, :unrealized_pnl_percentage
+
+      # Get today's P&L
+      #
+      # @return [Float, nil] Today's profit/loss
+      def day_pnl
+        self[:currentDayProfitLoss] ||
+          self[:current_day_profit_loss] ||
+          self[:dayProfitLoss] ||
+          self[:day_profit_loss]
+      end
+      alias_method :todays_pnl, :day_pnl
+      alias_method :current_day_pnl, :day_pnl
+
+      # Get today's P&L percentage
+      #
+      # @return [Float, nil] Today's profit/loss percentage
+      def day_pnl_percentage
+        self[:currentDayProfitLossPercentage] ||
+          self[:current_day_profit_loss_percentage] ||
+          self[:dayProfitLossPercentage] ||
+          self[:day_profit_loss_percentage]
+      end
+      alias_method :todays_pnl_percentage, :day_pnl_percentage
+      alias_method :current_day_pnl_percentage, :day_pnl_percentage
+
+      # Check if this is a long position
+      #
+      # @return [Boolean] True if long position
+      def long?
+        quantity > 0
+      end
+
+      # Check if this is a short position
+      #
+      # @return [Boolean] True if short position
+      def short?
+        quantity < 0
+      end
+
+      # Check if this is an equity position
+      #
+      # @return [Boolean] True if equity
+      def equity?
+        asset_type == "EQUITY"
+      end
+
+      # Check if this is an option position
+      #
+      # @return [Boolean] True if option
+      def option?
+        asset_type == "OPTION"
+      end
+
+      # Check if this is a profitable position
+      #
+      # @return [Boolean] True if profitable
+      def profitable?
+        unrealized_pnl > 0
+      end
+
+      # Check if this is a losing position
+      #
+      # @return [Boolean] True if losing
+      def losing?
+        unrealized_pnl < 0
+      end
+
+      # Get maintenance requirement for this position
+      #
+      # @return [Float, nil] The maintenance requirement
+      def maintenance_requirement
+        self[:maintenanceRequirement] || self[:maintenance_requirement]
+      end
+
+      # Get the instrument details
+      #
+      # @return [Hash, nil] The instrument details
+      def instrument
+        self[:instrument]
+      end
+
+      # Get option details if this is an option position
+      #
+      # @return [Hash, nil] Option details including strike, expiration, etc.
+      def option_details
+        return unless option? && instrument
+
+        {
+          underlying_symbol: instrument[:underlyingSymbol] || instrument[:underlying_symbol],
+          strike_price: instrument[:strikePrice] || instrument[:strike_price],
+          expiration_date: instrument[:expirationDate] || instrument[:expiration_date],
+          option_type: instrument[:putCall] || instrument[:put_call] || instrument[:optionType] || instrument[:option_type],
+          contract_size: instrument[:contractSize] || instrument[:contract_size] || 100,
+        }
+      end
+
+      # Get the underlying symbol for options
+      #
+      # @return [String, nil] The underlying symbol
+      def underlying_symbol
+        return unless option?
+
+        option_details[:underlying_symbol] if option_details
+      end
+
+      # Get the strike price for options
+      #
+      # @return [Float, nil] The strike price
+      def strike_price
+        return unless option?
+
+        option_details[:strike_price] if option_details
+      end
+
+      # Get the expiration date for options
+      #
+      # @return [String, nil] The expiration date
+      def expiration_date
+        return unless option?
+
+        option_details[:expiration_date] if option_details
+      end
+
+      # Check if this is a call option
+      #
+      # @return [Boolean, nil] True if call option
+      def call?
+        return false unless option?
+
+        details = option_details
+        return false unless details
+
+        details[:option_type] == "CALL" || details[:option_type] == "call"
+      end
+
+      # Check if this is a put option
+      #
+      # @return [Boolean, nil] True if put option
+      def put?
+        return false unless option?
+
+        details = option_details
+        return false unless details
+
+        details[:option_type] == "PUT" || details[:option_type] == "put"
+      end
+
+      # Calculate the value per contract for options
+      #
+      # @return [Float, nil] Value per contract
+      def value_per_contract
+        return unless option? && market_value && quantity != 0
+
+        contracts = quantity.abs
+        market_value / contracts
+      end
+
+      # Calculate cost per contract for options
+      #
+      # @return [Float, nil] Cost per contract
+      def cost_per_contract
+        return unless option? && cost_basis != 0 && quantity != 0
+
+        contracts = quantity.abs
+        cost_basis / contracts
+      end
+
+      # Get formatted display string for the position
+      #
+      # @return [String] Formatted position string
+      def to_display_string
+        if option?
+          details = option_details
+          if details
+            "#{quantity.to_i} #{details[:underlying_symbol]} #{details[:strike_price]} #{details[:option_type]} #{details[:expiration_date]}"
+          else
+            "#{quantity.to_i} #{symbol}"
+          end
+        else
+          "#{quantity} shares of #{symbol}"
+        end
+      end
+    end
+  end
+end

data/lib/schwab/resources/strategy.rb

@@ -0,0 +1,410 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Schwab
+  module Resources
+    # Resource wrapper for strategy objects (complex multi-leg orders)
+    # Provides strategy-specific helper methods for options strategies
+    class Strategy < Base
+      # Set up field type coercions for strategy fields
+      set_field_type :entered_time, :datetime
+      set_field_type :close_time, :datetime
+      set_field_type :filled_quantity, :float
+      set_field_type :remaining_quantity, :float
+      set_field_type :quantity, :float
+
+      # Get strategy type
+      #
+      # @return [String] The strategy type
+      def strategy_type
+        self[:strategyType] || self[:strategy_type] || self[:type]
+      end
+      alias_method :type, :strategy_type
+
+      # Get the strategy name/description
+      #
+      # @return [String] The strategy name
+      def name
+        self[:strategyName] || self[:strategy_name] || self[:name] || strategy_type
+      end
+
+      # Get strategy status
+      #
+      # @return [String] The strategy status
+      def status
+        self[:status] || self[:strategyStatus] || self[:strategy_status]
+      end
+
+      # Get the legs of the strategy
+      #
+      # @return [Array] Array of strategy legs
+      def legs
+        self[:legs] || self[:strategyLegs] || self[:strategy_legs] || self[:orderLegCollection] || []
+      end
+
+      # Get number of legs
+      #
+      # @return [Integer] Number of legs in strategy
+      def leg_count
+        legs.size
+      end
+
+      # Check if this is a single-leg strategy
+      #
+      # @return [Boolean] True if single leg
+      def single_leg?
+        leg_count == 1
+      end
+
+      # Check if this is a multi-leg strategy
+      #
+      # @return [Boolean] True if multi-leg
+      def multi_leg?
+        leg_count > 1
+      end
+
+      # Get the underlying symbol
+      #
+      # @return [String, nil] The underlying symbol
+      def underlying_symbol
+        # All legs should have the same underlying for a valid strategy
+        first_leg = legs.first
+        return unless first_leg
+
+        if first_leg[:instrument]
+          first_leg[:instrument][:underlyingSymbol] ||
+            first_leg[:instrument][:underlying_symbol] ||
+            first_leg[:instrument][:symbol]
+        end
+      end
+
+      # Get all strike prices in the strategy
+      #
+      # @return [Array<Float>] Array of strike prices
+      def strike_prices
+        legs.map do |leg|
+          if leg[:instrument]
+            leg[:instrument][:strikePrice] || leg[:instrument][:strike_price]
+          end
+        end.compact.uniq.sort
+      end
+
+      # Get all expiration dates in the strategy
+      #
+      # @return [Array<String>] Array of expiration dates
+      def expiration_dates
+        legs.map do |leg|
+          if leg[:instrument]
+            leg[:instrument][:expirationDate] || leg[:instrument][:expiration_date]
+          end
+        end.compact.uniq.sort
+      end
+
+      # Get net credit/debit
+      #
+      # @return [Float, nil] Net credit (positive) or debit (negative)
+      def net_premium
+        total = 0.0
+        legs.each do |leg|
+          price = leg[:price] || 0
+          quantity = leg[:quantity] || 0
+          instruction = leg[:instruction]
+
+          # Selling generates credit, buying generates debit
+          if ["SELL", "SELL_TO_OPEN", "SELL_TO_CLOSE"].include?(instruction&.upcase)
+            total += price * quantity * 100 # Options are in contracts of 100
+          else
+            total -= price * quantity * 100
+          end
+        end
+        total
+      end
+
+      # Check if this is a credit strategy
+      #
+      # @return [Boolean] True if net credit
+      def credit_strategy?
+        net_premium > 0
+      end
+
+      # Check if this is a debit strategy
+      #
+      # @return [Boolean] True if net debit
+      def debit_strategy?
+        net_premium < 0
+      end
+
+      # Strategy type identification methods
+
+      # Check if this is a vertical spread
+      #
+      # @return [Boolean] True if vertical spread
+      def vertical_spread?
+        return false unless leg_count == 2
+
+        expirations = expiration_dates
+        strikes = strike_prices
+
+        # Same expiration, different strikes
+        expirations.size == 1 && strikes.size == 2
+      end
+      alias_method :vertical?, :vertical_spread?
+
+      # Check if this is a calendar spread
+      #
+      # @return [Boolean] True if calendar spread
+      def calendar_spread?
+        return false unless leg_count == 2
+
+        expirations = expiration_dates
+        strikes = strike_prices
+
+        # Different expirations, same strike
+        expirations.size == 2 && strikes.size == 1
+      end
+      alias_method :calendar?, :calendar_spread?
+      alias_method :horizontal?, :calendar_spread?
+
+      # Check if this is a diagonal spread
+      #
+      # @return [Boolean] True if diagonal spread
+      def diagonal_spread?
+        return false unless leg_count == 2
+
+        expirations = expiration_dates
+        strikes = strike_prices
+
+        # Different expirations and strikes
+        expirations.size == 2 && strikes.size == 2
+      end
+      alias_method :diagonal?, :diagonal_spread?
+
+      # Check if this is a butterfly spread
+      #
+      # @return [Boolean] True if butterfly
+      def butterfly?
+        return false unless leg_count == 4
+
+        strikes = strike_prices
+        # Butterfly has 3 unique strikes
+        strikes.size == 3
+      end
+
+      # Check if this is an iron butterfly
+      #
+      # @return [Boolean] True if iron butterfly
+      def iron_butterfly?
+        return false unless butterfly?
+
+        # Iron butterfly uses both puts and calls
+        has_puts = legs.any? { |leg| leg_is_put?(leg) }
+        has_calls = legs.any? { |leg| leg_is_call?(leg) }
+
+        has_puts && has_calls
+      end
+
+      # Check if this is a condor
+      #
+      # @return [Boolean] True if condor
+      def condor?
+        return false unless leg_count == 4
+
+        strikes = strike_prices
+        # Condor has 4 unique strikes
+        strikes.size == 4
+      end
+
+      # Check if this is an iron condor
+      #
+      # @return [Boolean] True if iron condor
+      def iron_condor?
+        return false unless condor?
+
+        # Iron condor uses both puts and calls
+        has_puts = legs.any? { |leg| leg_is_put?(leg) }
+        has_calls = legs.any? { |leg| leg_is_call?(leg) }
+
+        has_puts && has_calls
+      end
+
+      # Check if this is a straddle
+      #
+      # @return [Boolean] True if straddle
+      def straddle?
+        return false unless leg_count == 2
+
+        strikes = strike_prices
+        expirations = expiration_dates
+
+        # Same strike and expiration, one put and one call
+        if strikes.size == 1 && expirations.size == 1
+          has_put = legs.any? { |leg| leg_is_put?(leg) }
+          has_call = legs.any? { |leg| leg_is_call?(leg) }
+          has_put && has_call
+        else
+          false
+        end
+      end
+
+      # Check if this is a strangle
+      #
+      # @return [Boolean] True if strangle
+      def strangle?
+        return false unless leg_count == 2
+
+        strikes = strike_prices
+        expirations = expiration_dates
+
+        # Different strikes, same expiration, one put and one call
+        if strikes.size == 2 && expirations.size == 1
+          has_put = legs.any? { |leg| leg_is_put?(leg) }
+          has_call = legs.any? { |leg| leg_is_call?(leg) }
+          has_put && has_call
+        else
+          false
+        end
+      end
+
+      # Check if this is a collar
+      #
+      # @return [Boolean] True if collar
+      def collar?
+        return false unless leg_count == 3 || leg_count == 2
+
+        # Collar: long stock + long put + short call
+        # Or just long put + short call (if stock is held separately)
+
+        has_long_put = legs.any? { |leg| leg_is_put?(leg) && leg_is_long?(leg) }
+        has_short_call = legs.any? { |leg| leg_is_call?(leg) && leg_is_short?(leg) }
+
+        has_long_put && has_short_call
+      end
+
+      # Check if this is a ratio spread
+      #
+      # @return [Boolean] True if ratio spread
+      def ratio_spread?
+        return false unless multi_leg?
+
+        # Ratio spread has unequal quantities
+        quantities = legs.map { |leg| leg[:quantity].to_i.abs }.uniq
+        quantities.size > 1
+      end
+
+      # Get max profit for the strategy
+      #
+      # @return [Float, nil] Maximum profit potential
+      def max_profit
+        # This would require complex calculations based on strategy type
+        # Placeholder for strategy-specific calculations
+        nil
+      end
+
+      # Get max loss for the strategy
+      #
+      # @return [Float, nil] Maximum loss potential
+      def max_loss
+        # This would require complex calculations based on strategy type
+        # Placeholder for strategy-specific calculations
+        nil
+      end
+
+      # Get breakeven points
+      #
+      # @return [Array<Float>] Breakeven points
+      def breakeven_points
+        # This would require complex calculations based on strategy type
+        # Placeholder for strategy-specific calculations
+        []
+      end
+
+      # Get strategy description
+      #
+      # @return [String] Human-readable strategy description
+      def description
+        if vertical_spread?
+          "Vertical Spread"
+        elsif calendar_spread?
+          "Calendar Spread"
+        elsif diagonal_spread?
+          "Diagonal Spread"
+        elsif iron_butterfly?
+          "Iron Butterfly"
+        elsif butterfly?
+          "Butterfly Spread"
+        elsif iron_condor?
+          "Iron Condor"
+        elsif condor?
+          "Condor Spread"
+        elsif straddle?
+          "Straddle"
+        elsif strangle?
+          "Strangle"
+        elsif collar?
+          "Collar"
+        elsif ratio_spread?
+          "Ratio Spread"
+        elsif multi_leg?
+          "Multi-leg Strategy"
+        else
+          "Single Option"
+        end
+      end
+
+      # Get formatted display string for the strategy
+      #
+      # @return [String] Formatted strategy string
+      def to_display_string
+        parts = []
+        parts << description
+        parts << underlying_symbol if underlying_symbol
+
+        if strike_prices.any?
+          parts << "Strikes: #{strike_prices.join("/")}"
+        end
+
+        if expiration_dates.any?
+          parts << "Exp: #{expiration_dates.first}"
+        end
+
+        premium = net_premium
+        if premium != 0
+          parts << (premium > 0 ? "Credit: $#{premium.abs}" : "Debit: $#{premium.abs}")
+        end
+
+        parts.compact.join(" - ")
+      end
+
+      private
+
+      # Check if a leg is a put option
+      def leg_is_put?(leg)
+        return false unless leg[:instrument]
+
+        put_call = leg[:instrument][:putCall] || leg[:instrument][:put_call]
+        put_call&.upcase == "PUT"
+      end
+
+      # Check if a leg is a call option
+      def leg_is_call?(leg)
+        return false unless leg[:instrument]
+
+        put_call = leg[:instrument][:putCall] || leg[:instrument][:put_call]
+        put_call&.upcase == "CALL"
+      end
+
+      # Check if a leg is long (buy)
+      def leg_is_long?(leg)
+        instruction = leg[:instruction]
+        ["BUY", "BUY_TO_OPEN", "BUY_TO_CLOSE"].include?(instruction&.upcase)
+      end
+
+      # Check if a leg is short (sell)
+      def leg_is_short?(leg)
+        instruction = leg[:instruction]
+        ["SELL", "SELL_TO_OPEN", "SELL_TO_CLOSE"].include?(instruction&.upcase)
+      end
+    end
+  end
+end