schwab 0.2.0

data/lib/schwab/oauth.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "oauth2"
+require "uri"
+require "securerandom"
+
+module Schwab
+  # OAuth 2.0 authentication helpers for Schwab API
+  module OAuth
+    class << self
+      # Generate the authorization URL for the OAuth 2.0 flow
+      #
+      # @param client_id [String] Your Schwab application's client ID
+      # @param redirect_uri [String] The redirect URI configured in your Schwab application
+      # @param state [String, nil] Optional state parameter for CSRF protection (will be generated if not provided)
+      # @param config [Configuration, nil] Optional configuration object (uses global config if not provided)
+      # @return [String] The authorization URL to redirect the user to
+      def authorization_url(client_id:, redirect_uri:, state: nil, config: nil)
+        config ||= Schwab.configuration || Configuration.new
+        state ||= SecureRandom.hex(16)
+
+        params = {
+          response_type: "code",
+          client_id: client_id,
+          redirect_uri: redirect_uri,
+          state: state,
+        }
+
+        uri = URI(config.oauth_authorize_url)
+        uri.query = URI.encode_www_form(params)
+        uri.to_s
+      end
+
+      # Exchange an authorization code for access and refresh tokens
+      #
+      # @param code [String] The authorization code from the OAuth callback
+      # @param client_id [String] Your Schwab application's client ID
+      # @param client_secret [String] Your Schwab application's client secret
+      # @param redirect_uri [String] The redirect URI used in the authorization request
+      # @param config [Configuration, nil] Optional configuration object (uses global config if not provided)
+      # @return [Hash] Token response with :access_token, :refresh_token, :expires_in, :expires_at
+      def get_token(code:, client_id:, client_secret:, redirect_uri:, config: nil)
+        config ||= Schwab.configuration || Configuration.new
+        client = oauth2_client(client_id: client_id, client_secret: client_secret, config: config)
+
+        token = client.auth_code.get_token(
+          code,
+          redirect_uri: redirect_uri,
+          headers: { "Content-Type" => "application/x-www-form-urlencoded" },
+        )
+
+        parse_token_response(token)
+      end
+
+      # Refresh an access token using a refresh token
+      #
+      # @param refresh_token [String] The refresh token
+      # @param client_id [String] Your Schwab application's client ID
+      # @param client_secret [String] Your Schwab application's client secret
+      # @param config [Configuration, nil] Optional configuration object (uses global config if not provided)
+      # @return [Hash] Token response with :access_token, :refresh_token, :expires_in, :expires_at
+      def refresh_token(refresh_token:, client_id:, client_secret:, config: nil)
+        config ||= Schwab.configuration || Configuration.new
+        client = oauth2_client(client_id: client_id, client_secret: client_secret, config: config)
+
+        token = OAuth2::AccessToken.new(client, nil, refresh_token: refresh_token)
+        new_token = token.refresh!
+
+        parse_token_response(new_token)
+      end
+
+      private
+
+      def oauth2_client(client_id:, client_secret:, config:)
+        OAuth2::Client.new(
+          client_id,
+          client_secret,
+          site: config.api_base_url,
+          authorize_url: config.oauth_authorize_url,
+          token_url: config.oauth_token_url,
+        )
+      end
+
+      def parse_token_response(token)
+        {
+          access_token: token.token,
+          refresh_token: token.refresh_token,
+          expires_in: token.expires_in,
+          expires_at: token.expires_at ? Time.at(token.expires_at) : nil,
+          token_type: token.params["token_type"] || "Bearer",
+        }
+      end
+    end
+  end
+end

data/lib/schwab/resources/account.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Schwab
+  module Resources
+    # Resource wrapper for account objects
+    # Provides account-specific helper methods and type coercions
+    class Account < Base
+      # Set up field type coercions for account fields
+      set_field_type :created_time, :datetime
+      set_field_type :opened_date, :date
+      set_field_type :closed_date, :date
+      set_field_type :last_updated, :datetime
+      set_field_type :day_trader, :boolean
+      set_field_type :closing_only_restricted, :boolean
+      set_field_type :pdt_flag, :boolean
+      set_field_type :round_trips, :integer
+
+      # Get the account number/ID (plain text)
+      #
+      # @return [String] The account number
+      def account_number
+        self[:accountNumber] || self[:account_number]
+      end
+      alias_method :id, :account_number
+
+      # Get the encrypted hash value for this account
+      #
+      # @return [String, nil] The encrypted hash value used in API calls
+      def hash_value
+        self[:hashValue] || self[:hash_value]
+      end
+      alias_method :encrypted_id, :hash_value
+
+      # Get the appropriate account identifier for API calls
+      # Returns hash_value if available, otherwise account_number
+      #
+      # @return [String] The account identifier to use in API calls
+      def api_identifier
+        hash_value || account_number
+      end
+
+      # Get the account type
+      #
+      # @return [String] The account type (e.g., "CASH", "MARGIN")
+      def account_type
+        self[:type] || self[:accountType] || self[:account_type]
+      end
+
+      # Check if this is a margin account
+      #
+      # @return [Boolean] True if margin account
+      def margin_account?
+        account_type == "MARGIN"
+      end
+
+      # Check if this is a cash account
+      #
+      # @return [Boolean] True if cash account
+      def cash_account?
+        account_type == "CASH"
+      end
+
+      # Get account status
+      #
+      # @return [String] The account status
+      def status
+        self[:status] || self[:accountStatus]
+      end
+
+      # Check if account is active
+      #
+      # @return [Boolean] True if account is active
+      def active?
+        status == "ACTIVE"
+      end
+
+      # Get the current balances
+      #
+      # @return [Schwab::Resources::Base] The current balances object
+      def current_balances
+        self[:currentBalances] || self[:current_balances]
+      end
+
+      # Get the initial balances
+      #
+      # @return [Schwab::Resources::Base] The initial balances object
+      def initial_balances
+        self[:initialBalances] || self[:initial_balances]
+      end
+
+      # Get projected balances
+      #
+      # @return [Schwab::Resources::Base] The projected balances object
+      def projected_balances
+        self[:projectedBalances] || self[:projected_balances]
+      end
+
+      # Get positions
+      #
+      # @return [Array<Schwab::Resources::Position>] Array of positions
+      def positions
+        positions_data = self[:positions] || []
+        positions_data.map do |position_data|
+          if position_data.is_a?(Position)
+            position_data
+          else
+            Position.new(position_data, client)
+          end
+        end
+      end
+
+      # Get account value (net liquidation value)
+      #
+      # @return [Float, nil] The total account value
+      def account_value
+        return unless current_balances
+
+        current_balances[:liquidationValue] ||
+          current_balances[:liquidation_value] ||
+          current_balances[:totalValue] ||
+          current_balances[:total_value]
+      end
+      alias_method :net_liquidation_value, :account_value
+      alias_method :total_value, :account_value
+
+      # Get cash balance
+      #
+      # @return [Float, nil] The cash balance
+      def cash_balance
+        return unless current_balances
+
+        current_balances[:cashBalance] ||
+          current_balances[:cash_balance] ||
+          current_balances[:availableFunds] ||
+          current_balances[:available_funds]
+      end
+
+      # Get buying power
+      #
+      # @return [Float, nil] The buying power
+      def buying_power
+        return unless current_balances
+
+        current_balances[:buyingPower] ||
+          current_balances[:buying_power] ||
+          current_balances[:availableFundsTrade] ||
+          current_balances[:available_funds_trade]
+      end
+
+      # Get day trading buying power
+      #
+      # @return [Float, nil] The day trading buying power
+      def day_trading_buying_power
+        return unless current_balances
+
+        current_balances[:dayTradingBuyingPower] ||
+          current_balances[:day_trading_buying_power]
+      end
+
+      # Get maintenance requirement
+      #
+      # @return [Float, nil] The maintenance requirement
+      def maintenance_requirement
+        return unless current_balances
+
+        current_balances[:maintenanceRequirement] ||
+          current_balances[:maintenance_requirement] ||
+          current_balances[:maintReq] ||
+          current_balances[:maint_req]
+      end
+
+      # Get margin balance if applicable
+      #
+      # @return [Float, nil] The margin balance
+      def margin_balance
+        return unless margin_account? && current_balances
+
+        current_balances[:marginBalance] ||
+          current_balances[:margin_balance]
+      end
+
+      # Check if account is in margin call
+      #
+      # @return [Boolean, nil] True if in margin call
+      def margin_call?
+        return false unless margin_account? && current_balances
+
+        in_call = current_balances[:isInCall] ||
+          current_balances[:is_in_call] ||
+          current_balances[:inCall] ||
+          current_balances[:in_call]
+
+        !!in_call
+      end
+
+      # Get account equity
+      #
+      # @return [Float, nil] The account equity
+      def equity
+        return unless current_balances
+
+        current_balances[:equity] ||
+          current_balances[:accountEquity] ||
+          current_balances[:account_equity]
+      end
+
+      # Calculate total P&L for all positions
+      #
+      # @return [Float] Total profit/loss
+      def total_pnl
+        positions.sum { |position| position.unrealized_pnl || 0 }
+      end
+
+      # Calculate today's P&L for all positions
+      #
+      # @return [Float] Today's profit/loss
+      def todays_pnl
+        positions.sum { |position| position.day_pnl || 0 }
+      end
+
+      # Get positions filtered by asset type
+      #
+      # @param asset_type [String, Symbol] The asset type (e.g., :equity, :option)
+      # @return [Array<Schwab::Resources::Position>] Filtered positions
+      def positions_by_type(asset_type)
+        type_str = asset_type.to_s.upcase
+        positions.select do |position|
+          position.asset_type == type_str ||
+            position[:assetType] == type_str ||
+            position[:asset_type] == type_str
+        end
+      end
+
+      # Get equity positions
+      #
+      # @return [Array<Schwab::Resources::Position>] Equity positions
+      def equity_positions
+        positions_by_type(:equity)
+      end
+
+      # Get option positions
+      #
+      # @return [Array<Schwab::Resources::Position>] Option positions
+      def option_positions
+        positions_by_type(:option)
+      end
+
+      # Calculate total market value of positions
+      #
+      # @return [Float] Total market value
+      def total_market_value
+        positions.sum { |position| position.market_value || 0 }
+      end
+
+      # Check if account has positions
+      #
+      # @return [Boolean] True if account has positions
+      def has_positions?
+        !positions.empty?
+      end
+
+      # Get number of positions
+      #
+      # @return [Integer] Number of positions
+      def position_count
+        positions.size
+      end
+    end
+  end
+end

data/lib/schwab/resources/base.rb

@@ -0,0 +1,300 @@
+# frozen_string_literal: true
+
+require "time"
+require "date"
+
+module Schwab
+  # Resource objects for wrapping API responses with convenient access patterns
+  module Resources
+    # Base class for resource objects that wrap API response hashes
+    # Provides Sawyer::Resource-like functionality for method access to hash data
+    #
+    # @example Creating a resource
+    #   data = { name: "John", age: 30, address: { city: "NYC" } }
+    #   resource = Schwab::Resources::Base.new(data)
+    #   resource.name # => "John"
+    #   resource[:age] # => 30
+    #   resource.address.city # => "NYC"
+    class Base
+      class << self
+        # Define fields that should be coerced to specific types
+        # Subclasses can override this to specify their field types
+        def field_types
+          @field_types ||= {}
+        end
+
+        # Set field types for automatic coercion
+        def set_field_type(field, type)
+          field_types[field.to_sym] = type
+        end
+      end
+
+      # Initialize a new resource with data
+      #
+      # @param data [Hash] The data to wrap
+      # @param client [Schwab::Client, nil] Optional client for API calls
+      def initialize(data = {}, client = nil)
+        @data = data || {}
+        @client = client
+        @_nested_resources = {}
+      end
+
+      # Access data via method calls
+      #
+      # @param method_name [Symbol] The method name
+      # @param args [Array] Method arguments
+      # @param block [Proc] Optional block
+      # @return [Object] The value from the data hash
+      def method_missing(method_name, *args, &block)
+        key = method_name.to_s
+
+        # Check for setter methods
+        if key.end_with?("=")
+          key = key[0...-1]
+          @data[key.to_sym] = args.first
+          @data[key] = args.first
+          return args.first
+        end
+
+        # Try symbol key first, then string key
+        if @data.key?(method_name)
+          wrap_value(@data[method_name], method_name)
+        elsif @data.key?(key)
+          wrap_value(@data[key], key.to_sym)
+        else
+          super
+        end
+      end
+
+      # Check if method exists
+      #
+      # @param method_name [Symbol] The method name
+      # @param include_private [Boolean] Include private methods
+      # @return [Boolean] True if method exists
+      def respond_to_missing?(method_name, include_private = false)
+        key = method_name.to_s
+        is_setter = key.end_with?("=")
+        key = key[0...-1] if is_setter
+
+        # Always respond to setters, or check if key exists for getters
+        is_setter || @data.key?(method_name) || @data.key?(key.to_sym) || @data.key?(key) || super
+      end
+
+      # Hash-style access to data
+      #
+      # @param key [Symbol, String] The key to access
+      # @return [Object] The value
+      def [](key)
+        value = @data[key.to_sym] || @data[key.to_s]
+        wrap_value(value, key.to_sym)
+      end
+
+      # Hash-style setter
+      #
+      # @param key [Symbol, String] The key to set
+      # @param value [Object] The value to set
+      def []=(key, value)
+        @data[key.to_sym] = value
+        @data[key.to_s] = value
+      end
+
+      # Check if key exists
+      #
+      # @param key [Symbol, String] The key to check
+      # @return [Boolean] True if key exists
+      def key?(key)
+        @data.key?(key.to_sym) || @data.key?(key.to_s)
+      end
+      alias_method :has_key?, :key?
+
+      # Get all keys
+      #
+      # @return [Array] Array of keys
+      def keys
+        @data.keys
+      end
+
+      # Convert to hash
+      #
+      # @return [Hash] The underlying data hash
+      def to_h
+        @data
+      end
+      alias_method :to_hash, :to_h
+
+      # Get attributes as hash
+      #
+      # @return [Hash] The underlying data hash
+      def attributes
+        @data
+      end
+
+      # Inspect the resource
+      #
+      # @return [String] String representation
+      def inspect
+        "#<#{self.class.name} #{@data.inspect}>"
+      end
+
+      # Convert to string
+      #
+      # @return [String] String representation
+      def to_s
+        @data.to_s
+      end
+
+      # Equality comparison
+      #
+      # @param other [Object] Object to compare
+      # @return [Boolean] True if equal
+      def ==(other)
+        case other
+        when self.class
+          @data == other.to_h
+        when Hash
+          @data == other
+        else
+          false
+        end
+      end
+
+      # Iterate over data
+      #
+      # @yield [key, value] Yields each key-value pair
+      def each(&block)
+        @data.each(&block)
+      end
+
+      # Check if resource has no data
+      #
+      # @return [Boolean] True if empty
+      def empty?
+        @data.empty?
+      end
+
+      protected
+
+      # Get the client instance
+      attr_reader :client
+
+      private
+
+      # Wrap nested hashes in resource objects and coerce types
+      #
+      # @param value [Object] The value to wrap
+      # @param field_name [Symbol, nil] The field name for type coercion
+      # @return [Object] The wrapped and coerced value
+      def wrap_value(value, field_name = nil)
+        # First apply type coercion if field type is defined
+        if field_name && self.class.field_types[field_name.to_sym]
+          value = coerce_value(value, self.class.field_types[field_name.to_sym])
+        end
+
+        case value
+        when Hash
+          # Cache nested resources to maintain object identity
+          @_nested_resources[value.object_id] ||= self.class.new(value, @client)
+        when Array
+          value.map { |item| wrap_value(item) }
+        else
+          value
+        end
+      end
+
+      # Coerce a value to a specific type
+      #
+      # @param value [Object] The value to coerce
+      # @param type [Symbol, Class] The target type
+      # @return [Object] The coerced value
+      def coerce_value(value, type)
+        return if value.nil?
+
+        case type
+        when :time, Time
+          coerce_to_time(value)
+        when :date, Date
+          coerce_to_date(value)
+        when :datetime, DateTime
+          coerce_to_datetime(value)
+        when :integer, Integer
+          value.to_i
+        when :float, Float
+          value.to_f
+        when :decimal, BigDecimal
+          require "bigdecimal"
+          BigDecimal(value.to_s)
+        when :boolean
+          coerce_to_boolean(value)
+        when :symbol, Symbol
+          value.to_sym
+        else
+          value
+        end
+      rescue StandardError
+        value # Return original value if coercion fails
+      end
+
+      # Coerce to Time
+      def coerce_to_time(value)
+        case value
+        when Time
+          value
+        when Date, DateTime
+          value.to_time
+        when String
+          Time.parse(value)
+        when Integer, Float
+          # Assume milliseconds timestamp if large number
+          value > 9999999999 ? Time.at(value / 1000.0) : Time.at(value)
+        else
+          value
+        end
+      end
+
+      # Coerce to Date
+      def coerce_to_date(value)
+        case value
+        when Date
+          value
+        when Time, DateTime
+          value.to_date
+        when String
+          Date.parse(value)
+        else
+          value
+        end
+      end
+
+      # Coerce to DateTime
+      def coerce_to_datetime(value)
+        case value
+        when DateTime, Time
+          value
+        when Date
+          value.to_time
+        when String
+          Time.parse(value)
+        when Integer, Float
+          # Assume milliseconds timestamp if large number
+          value > 9999999999 ? Time.at(value / 1000.0) : Time.at(value)
+        else
+          value
+        end
+      end
+
+      # Coerce to boolean
+      def coerce_to_boolean(value)
+        case value
+        when TrueClass, FalseClass
+          value
+        when String
+          value.downcase == "true" || value == "1"
+        when Integer
+          value == 1
+        else
+          !!value
+        end
+      end
+    end
+  end
+end