schwab_rb 0.2.0

data/lib/schwab_rb/clients/client.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+require_relative "base_client"
+require_relative "../utils/logger"
+require_relative "../utils/redactor"
+
+module SchwabRb
+  class Client < BaseClient
+    BASE_URL = "https://api.schwabapi.com"
+
+    private
+
+    def get(path, params = {})
+      dest = URI(URI::DEFAULT_PARSER.escape("#{BASE_URL}#{path}"))
+      dest.query = URI.encode_www_form(params) if params.any?
+
+      req_num = req_num()
+      log_request("GET", req_num, dest, params)
+      response = session.get(dest)
+
+      log_response(response, req_num)
+      response
+    end
+
+    def post(path, data = {})
+      dest = URI(URI::DEFAULT_PARSER.escape("#{BASE_URL}#{path}"))
+
+      req_num = req_num()
+      log_request("POST", req_num, dest, data)
+
+      response = session.post(
+        dest,
+        {
+          :body => data.to_json,
+          :headers => { "Content-Type" => "application/json" }
+        }
+      )
+      log_response(response, req_num)
+      response
+    end
+
+    def put(path, data = {})
+      dest = URI(URI::DEFAULT_PARSER.escape("#{BASE_URL}#{path}"))
+
+      req_num = req_num()
+      log_request("PUT", req_num, dest, data)
+
+      response = session.put(
+        dest,
+        {
+          :body => data.to_json,
+          :headers => { "Content-Type" => "application/json" }
+        }
+      )
+      log_response(response, req_num)
+      response
+    end
+
+    def delete(path)
+      dest = URI(URI::DEFAULT_PARSER.escape("#{BASE_URL}#{path}"))
+
+      req_num = req_num()
+      log_request("DELETE", req_num, dest)
+
+      response = session.delete(dest)
+      log_response(response, req_num)
+      response
+    end
+
+    def log_request(method, req_num, dest, data = nil)
+      redacted_dest = SchwabRb::Redactor.redact_url(dest.to_s)
+      SchwabRb::Logger.logger.info("Req #{req_num}: #{method} to #{redacted_dest}")
+      
+      if data
+        redacted_data = SchwabRb::Redactor.redact_data(data)
+        SchwabRb::Logger.logger.debug("Payload: #{JSON.pretty_generate(redacted_data)}")
+      end
+    end
+
+    def log_response(response, req_num)
+      SchwabRb::Logger.logger.info("Resp #{req_num}: Status #{response.status}")
+      
+      if SchwabRb::Logger.logger.level == ::Logger::DEBUG
+        redacted_body = SchwabRb::Redactor.redact_response_body(response)
+        SchwabRb::Logger.logger.debug("Response body: #{JSON.pretty_generate(redacted_body)}") if redacted_body
+      end
+    end
+
+    def req_num
+      @request_counter ||= 0
+      @request_counter += 1
+    end
+  end
+end

data/lib/schwab_rb/configuration.rb

@@ -0,0 +1,39 @@
+module SchwabRb
+  class Configuration
+    attr_accessor :logger, :log_file, :log_level, :silence_output
+
+    def initialize
+      @logger = nil
+      @log_file = ENV['SCHWAB_LOGFILE']
+      @log_level = ENV.fetch('SCHWAB_LOG_LEVEL', 'WARN').upcase
+      @silence_output = ENV.fetch('SCHWAB_SILENCE_OUTPUT', 'false').downcase == 'true'
+    end
+
+    def has_external_logger?
+      !@logger.nil?
+    end
+
+    def should_create_logger?
+      !has_external_logger? && !@silence_output
+    end
+
+    def effective_log_file
+      @log_file || (ENV['LOGFILE'] if ENV['LOGFILE'] && !ENV['LOGFILE'].empty?)
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration) if block_given?
+      SchwabRb::Logger.reset! if defined?(SchwabRb::Logger)
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end

data/lib/schwab_rb/constants.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module SchwabRb::Constants
+  SCHWAB_BASE_URL="https://api.schwabapi.com"
+  TOKEN_ENDPOINT="https://api.schwabapi.com/v1/oauth/token"
+  DEFAULT_TOKEN_PATH="./token.json"
+end

data/lib/schwab_rb/data_objects/account.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+require_relative 'instrument'
+require_relative 'position'
+
+module SchwabRb
+  module DataObjects
+    class InitialBalances
+      attr_reader :accrued_interest, :cash_balance,
+                  :cash_receipts, :long_option_market_value,
+                  :liquidation_value, :money_market_fund,
+                  :available_funds_non_marginable_trade,
+                  :bond_value, :buying_power, :cash_available_for_trading,
+                  :day_trading_buying_power, :day_trading_buying_power_call,
+                  :day_trading_equity_call, :equity, :equity_percentage,
+                  :long_margin_value, :long_stock_value, :maintenance_call, :maintenance_requirement,
+                  :margin, :margin_equity, :mutual_fund_value, :reg_t_call, :short_margin_value,
+                  :short_option_market_value, :short_stock_value, :total_cash, :is_in_call,
+                  :pending_deposits, :margin_balance, :short_balance, :account_value
+
+      class << self
+        def build(data)
+          new(
+            accrued_interest: data[:accruedInterest],
+            cash_balance: data[:cashBalance],
+            cash_receipts: data[:cashReceipts],
+            long_option_market_value: data[:longOptionMarketValue],
+            liquidation_value: data[:liquidationValue],
+            money_market_fund: data[:moneyMarketFund],
+            available_funds_non_marginable_trade: data[:availableFundsNonMarginableTrade],
+            bond_value: data[:bondValue],
+            buying_power: data[:buyingPower],
+            cash_available_for_trading: data[:cashAvailableForTrading],
+            day_trading_buying_power: data[:dayTradingBuyingPower],
+            day_trading_buying_power_call: data[:dayTradingBuyingPowerCall],
+            day_trading_equity_call: data[:dayTradingEquityCall],
+            equity: data[:equity],
+            equity_percentage: data[:equityPercentage],
+            long_margin_value: data[:longMarginValue],
+            long_stock_value: data[:longStockValue],
+            maintenance_call: data[:maintenanceCall],
+            maintenance_requirement: data[:maintenanceRequirement],
+            margin: data[:margin],
+            margin_equity: data[:marginEquity],
+            mutual_fund_value: data[:mutualFundValue],
+            reg_t_call: data[:regTCall],
+            short_margin_value: data[:shortMarginValue],
+            short_option_market_value: data[:shortOptionMarketValue],
+            short_stock_value: data[:shortStockValue],
+            total_cash: data[:totalCash],
+            is_in_call: data[:isInCall],
+            pending_deposits: data[:pendingDeposits],
+            margin_balance: data[:marginBalance],
+            short_balance: data[:shortBalance],
+            account_value: data[:accountValue]
+          )
+        end
+      end
+
+      def initialize(
+        accrued_interest:, cash_balance:, cash_receipts:, long_option_market_value:, liquidation_value:,
+        money_market_fund:, available_funds_non_marginable_trade:, bond_value:, buying_power:,
+        cash_available_for_trading:, day_trading_buying_power:, day_trading_buying_power_call:,
+        day_trading_equity_call:, equity:, equity_percentage:, long_margin_value:, long_stock_value:,
+        maintenance_call:, maintenance_requirement:, margin:, margin_equity:, mutual_fund_value:,
+        reg_t_call:, short_margin_value:, short_option_market_value:, short_stock_value:, total_cash:,
+        is_in_call:, pending_deposits:, margin_balance:, short_balance:, account_value:
+      )
+        @accrued_interest = accrued_interest
+        @cash_balance = cash_balance
+        @cash_receipts = cash_receipts
+        @long_option_market_value = long_option_market_value
+        @liquidation_value = liquidation_value
+        @money_market_fund = money_market_fund
+        @available_funds_non_marginable_trade = available_funds_non_marginable_trade
+        @bond_value = bond_value
+        @buying_power = buying_power
+        @cash_available_for_trading = cash_available_for_trading
+        @day_trading_buying_power = day_trading_buying_power
+        @day_trading_buying_power_call = day_trading_buying_power_call
+        @day_trading_equity_call = day_trading_equity_call
+        @equity = equity
+        @equity_percentage = equity_percentage
+        @long_margin_value = long_margin_value
+        @long_stock_value = long_stock_value
+        @maintenance_call = maintenance_call
+        @maintenance_requirement = maintenance_requirement
+        @margin = margin
+        @margin_equity = margin_equity
+        @mutual_fund_value = mutual_fund_value
+        @reg_t_call = reg_t_call
+        @short_margin_value = short_margin_value
+        @short_option_market_value = short_option_market_value
+        @short_stock_value = short_stock_value
+        @total_cash = total_cash
+        @is_in_call = is_in_call
+        @pending_deposits = pending_deposits
+        @margin_balance = margin_balance
+        @short_balance = short_balance
+        @account_value = account_value
+      end
+    end
+
+    class CurrentBalances
+      attr_reader :accrued_interest, :cash_balance, :cash_receipts, :long_option_market_value,
+                  :liquidation_value, :long_market_value, :money_market_fund, :savings,
+                  :short_market_value, :pending_deposits, :mutual_fund_value, :bond_value,
+                  :short_option_market_value, :available_funds, :available_funds_non_marginable_trade,
+                  :buying_power, :buying_power_non_marginable_trade, :day_trading_buying_power,
+                  :equity, :equity_percentage, :long_margin_value, :maintenance_call,
+                  :maintenance_requirement, :margin_balance, :reg_t_call, :short_balance,
+                  :short_margin_value, :sma
+
+      class << self
+        def build(data)
+          new(
+            accrued_interest: data[:accruedInterest],
+            cash_balance: data[:cashBalance],
+            cash_receipts: data[:cashReceipts],
+            long_option_market_value: data[:longOptionMarketValue],
+            liquidation_value: data[:liquidationValue],
+            long_market_value: data[:longMarketValue],
+            money_market_fund: data[:moneyMarketFund],
+            savings: data[:savings],
+            short_market_value: data[:shortMarketValue],
+            pending_deposits: data[:pendingDeposits],
+            mutual_fund_value: data[:mutualFundValue],
+            bond_value: data[:bondValue],
+            short_option_market_value: data[:shortOptionMarketValue],
+            available_funds: data[:availableFunds],
+            available_funds_non_marginable_trade: data[:availableFundsNonMarginableTrade],
+            buying_power: data[:buyingPower],
+            buying_power_non_marginable_trade: data[:buyingPowerNonMarginableTrade],
+            day_trading_buying_power: data[:dayTradingBuyingPower],
+            equity: data[:equity],
+            equity_percentage: data[:equityPercentage],
+            long_margin_value: data[:longMarginValue],
+            maintenance_call: data[:maintenanceCall],
+            maintenance_requirement: data[:maintenanceRequirement],
+            margin_balance: data[:marginBalance],
+            reg_t_call: data[:regTCall],
+            short_balance: data[:shortBalance],
+            short_margin_value: data[:shortMarginValue],
+            sma: data[:sma]
+          )
+        end
+      end
+
+      def initialize(
+        accrued_interest:, cash_balance:, cash_receipts:, long_option_market_value:, liquidation_value:,
+        long_market_value:, money_market_fund:, savings:, short_market_value:, pending_deposits:,
+        mutual_fund_value:, bond_value:, short_option_market_value:, available_funds:,
+        available_funds_non_marginable_trade:, buying_power:, buying_power_non_marginable_trade:,
+        day_trading_buying_power:, equity:, equity_percentage:, long_margin_value:, maintenance_call:,
+        maintenance_requirement:, margin_balance:, reg_t_call:, short_balance:, short_margin_value:,
+        sma:
+      )
+        @accrued_interest = accrued_interest
+        @cash_balance = cash_balance
+        @cash_receipts = cash_receipts
+        @long_option_market_value = long_option_market_value
+        @liquidation_value = liquidation_value
+        @long_market_value = long_market_value
+        @money_market_fund = money_market_fund
+        @savings = savings
+        @short_market_value = short_market_value
+        @pending_deposits = pending_deposits
+        @mutual_fund_value = mutual_fund_value
+        @bond_value = bond_value
+        @short_option_market_value = short_option_market_value
+        @available_funds = available_funds
+        @available_funds_non_marginable_trade = available_funds_non_marginable_trade
+        @buying_power = buying_power
+        @buying_power_non_marginable_trade = buying_power_non_marginable_trade
+        @day_trading_buying_power = day_trading_buying_power
+        @equity = equity
+        @equity_percentage = equity_percentage
+        @long_margin_value = long_margin_value
+        @maintenance_call = maintenance_call
+        @maintenance_requirement = maintenance_requirement
+        @margin_balance = margin_balance
+        @reg_t_call = reg_t_call
+        @short_balance = short_balance
+        @short_margin_value = short_margin_value
+        @sma = sma
+      end
+    end
+
+    class ProjectedBalances
+      attr_reader :available_funds, :available_funds_non_marginable_trade, :buying_power,
+                  :day_trading_buying_power, :day_trading_buying_power_call, :maintenance_call,
+                  :reg_t_call, :is_in_call, :stock_buying_power
+
+      class << self
+        def build(data)
+          new(
+            available_funds: data[:availableFunds],
+            available_funds_non_marginable_trade: data[:availableFundsNonMarginableTrade],
+            buying_power: data[:buyingPower],
+            day_trading_buying_power: data[:dayTradingBuyingPower],
+            day_trading_buying_power_call: data[:dayTradingBuyingPowerCall],
+            maintenance_call: data[:maintenanceCall],
+            reg_t_call: data[:regTCall],
+            is_in_call: data[:isInCall],
+            stock_buying_power: data[:stockBuyingPower]
+          )
+        end
+      end
+
+      def initialize(
+        available_funds:, available_funds_non_marginable_trade:, buying_power:, day_trading_buying_power:,
+        day_trading_buying_power_call:, maintenance_call:, reg_t_call:, is_in_call:, stock_buying_power:
+      )
+        @available_funds = available_funds
+        @available_funds_non_marginable_trade = available_funds_non_marginable_trade
+        @buying_power = buying_power
+        @day_trading_buying_power = day_trading_buying_power
+        @day_trading_buying_power_call = day_trading_buying_power_call
+        @maintenance_call = maintenance_call
+        @reg_t_call = reg_t_call
+        @is_in_call = is_in_call
+        @stock_buying_power = stock_buying_power
+      end
+    end
+
+    class AggregatedBalance
+      class << self
+        def build(data)
+          new(
+            current_liquidation_value: data.fetch(:currentLiquidationValue),
+            liquidation_value: data.fetch(:liquidationValue)
+          )
+        end
+      end
+
+      def initialize(current_liquidation_value:, liquidation_value:)
+        @current_liquidation_value = current_liquidation_value
+        @liquidation_value = liquidation_value
+      end
+
+      attr_reader :current_liquidation_value, :liquidation_value
+    end
+
+    class Account
+      class << self
+        def build(data)
+          data = data[:securitiesAccount] if data.key?(:securitiesAccount)
+          new(
+            type: data.fetch(:type),
+            account_number: data.fetch(:accountNumber),
+            round_trips: data.fetch(:roundTrips),
+            is_day_trader: data.fetch(:isDayTrader),
+            is_closing_only_restricted: data.fetch(:isClosingOnlyRestricted),
+            pfcb_flag: data.fetch(:pfcbFlag),
+            positions: data.fetch(:positions).map { |position| Position.build(position) },
+            initial_balances: InitialBalances.build(data.fetch(:initialBalances)),
+            current_balances: CurrentBalances.build(data.fetch(:currentBalances)),
+            projected_balances: ProjectedBalances.build(data.fetch(:projectedBalances))
+          )
+        end
+      end
+
+      def initialize(type:, account_number:, round_trips:, is_day_trader:, is_closing_only_restricted:,
+                     pfcb_flag:, initial_balances:, current_balances:, projected_balances:, positions: [])
+        @type = type
+        @account_number = account_number
+        @round_trips = round_trips
+        @is_day_trader = is_day_trader
+        @is_closing_only_restricted = is_closing_only_restricted
+        @pfcb_flag = pfcb_flag
+        @positions = positions
+        @initial_balances = initial_balances
+        @current_balances = current_balances
+        @projected_balances = projected_balances
+      end
+
+      attr_reader :type, :account_number, :round_trips, :is_day_trader, :is_closing_only_restricted,
+                  :pfcb_flag, :positions, :initial_balances, :current_balances, :projected_balances
+    end
+  end
+end

data/lib/schwab_rb/data_objects/account_numbers.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module SchwabRb
+  module DataObjects
+    class AccountNumbers
+      attr_reader :accounts
+
+      class << self
+        def build(data)
+          new(data)
+        end
+      end
+
+      def initialize(data)
+        @accounts = data.map { |account_data| AccountNumber.new(account_data) }
+      end
+
+      def to_h
+        @accounts.map(&:to_h)
+      end
+
+      def find_by_account_number(account_number)
+        @accounts.find { |account| account.account_number == account_number }
+      end
+
+      def find_hash_value(account_number)
+        account = find_by_account_number(account_number)
+        account&.hash_value
+      end
+
+      def account_numbers
+        @accounts.map(&:account_number)
+      end
+
+      def hash_values
+        @accounts.map(&:hash_value)
+      end
+
+      def size
+        @accounts.size
+      end
+
+      def empty?
+        @accounts.empty?
+      end
+
+      def each(&block)
+        @accounts.each(&block)
+      end
+
+      class AccountNumber
+        attr_reader :account_number, :hash_value
+
+        def initialize(data)
+          @account_number = data[:accountNumber]
+          @hash_value = data[:hashValue]
+        end
+
+        def to_h
+          {
+            accountNumber: @account_number,
+            hashValue: @hash_value
+          }
+        end
+      end
+    end
+  end
+end

data/lib/schwab_rb/data_objects/instrument.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module SchwabRb
+  module DataObjects
+    class Asset
+      attr_reader :asset_type, :status, :symbol, :instrument_id, :closing_price, :type, :description,
+                  :active_contract, :expiration_date, :last_trading_date, :multiplier, :future_type
+
+      def self.build(data)
+        new(
+          asset_type: data.fetch(:assetType, nil),
+          status: data.fetch(:status, nil),
+          symbol: data.fetch(:symbol, nil),
+          instrument_id: data.fetch(:instrumentId, nil),
+          closing_price: data.fetch(:closingPrice, nil),
+          type: data.fetch(:type, nil),
+          description: data.fetch(:description, nil),
+          active_contract: data.fetch(:activeContract, nil),
+          expiration_date: data.fetch(:expirationDate, nil),
+          last_trading_date: data.fetch(:lastTradingDate, nil),
+          multiplier: data.fetch(:multiplier, nil),
+          future_type: data.fetch(:futureType, nil)
+        )
+      end
+
+      def initialize(
+        asset_type: nil, status: nil, symbol: nil, instrument_id: nil, closing_price: nil, type: nil, description: nil, active_contract: nil, expiration_date: nil, last_trading_date: nil, multiplier: nil, future_type: nil
+      )
+        @asset_type = asset_type
+        @status = status
+        @symbol = symbol
+        @instrument_id = instrument_id
+        @closing_price = closing_price
+        @type = type
+        @description = description
+        @active_contract = active_contract
+        @expiration_date = expiration_date
+        @last_trading_date = last_trading_date
+        @multiplier = multiplier
+        @future_type = future_type
+      end
+
+      def to_h
+        {
+          assetType: @asset_type,
+          status: @status,
+          symbol: @symbol,
+          instrumentId: @instrument_id,
+          closingPrice: @closing_price,
+          type: @type,
+          description: @description,
+          activeContract: @active_contract,
+          expirationDate: @expiration_date,
+          lastTradingDate: @last_trading_date,
+          multiplier: @multiplier,
+          futureType: @future_type
+        }.compact
+      end
+    end
+
+    class OptionDeliverable
+      attr_reader :root_symbol, :symbol, :deliverable_units, :deliverable_number, :strike_percent, :deliverable
+
+      def self.build(data)
+        new(
+          root_symbol: data.fetch(:rootSymbol, nil),
+          symbol: data.fetch(:symbol, nil),
+          strike_percent: data.fetch(:strikePercent, nil),
+          deliverable_number: data.fetch(:deliverableNumber, nil),
+          deliverable_units: data.fetch(:deliverableUnits),
+          deliverable: data.fetch(:deliverable, nil).then { |d| d.nil? ? nil : Instrument.build(d) }
+        )
+      end
+
+      def initialize(root_symbol:, symbol:, deliverable_units:, deliverable_number:, strike_percent:, deliverable:)
+        @root_symbol = root_symbol
+        @symbol = symbol
+        @deliverable_units = deliverable_units
+        @deliverable_number = deliverable_number
+        @strike_percent = strike_percent
+        @deliverable = deliverable
+      end
+
+      def to_h
+        {
+          rootSymbol: @root_symbol,
+          symbol: @symbol,
+          strikePercent: @strike_percent,
+          deliverableNumber: @deliverable_number,
+          deliverableUnits: @deliverable_units,
+          deliverable: @deliverable&.to_h
+        }.compact
+      end
+    end
+
+    class Instrument
+      attr_reader :asset_type, :cusip, :symbol, :description, :net_change, :type, :put_call,
+                  :underlying_symbol, :status, :instrument_id, :closing_price, :option_deliverables
+
+      def self.build(data)
+        new(
+          asset_type: data.fetch(:assetType),
+          symbol: data.fetch(:symbol, nil),
+          description: data.fetch(:description, nil),
+          cusip: data.fetch(:cusip, nil),
+          net_change: data.fetch(:netChange, nil),
+          type: data.fetch(:type, nil),
+          put_call: data.fetch(:putCall, nil),
+          underlying_symbol: data.fetch(:underlyingSymbol, nil),
+          status: data.fetch(:status, nil),
+          instrument_id: data.fetch(:instrumentId, nil),
+          closing_price: data.fetch(:closingPrice, nil),
+          option_deliverables: data.fetch(:optionDeliverables, []).map { |d| OptionDeliverable.build(d) }
+        )
+      end
+
+      def initialize(
+        symbol:, description:, asset_type: nil, cusip: nil, net_change: nil, type: nil, put_call: nil, underlying_symbol: nil, status: nil, instrument_id: nil, closing_price: nil, option_deliverables: []
+      )
+        @asset_type = asset_type
+        @cusip = cusip
+        @symbol = symbol
+        @description = description
+        @net_change = net_change
+        @type = type
+        @put_call = put_call
+        @underlying_symbol = underlying_symbol
+        @status = status
+        @instrument_id = instrument_id
+        @closing_price = closing_price
+        @option_deliverables = option_deliverables
+      end
+
+      def option?
+        asset_type == 'OPTION'
+      end
+
+      def to_h
+        {
+          assetType: @asset_type,
+          symbol: @symbol,
+          description: @description,
+          cusip: @cusip,
+          netChange: @net_change,
+          type: @type,
+          putCall: @put_call,
+          underlyingSymbol: @underlying_symbol,
+          status: @status,
+          instrumentId: @instrument_id,
+          closingPrice: @closing_price,
+          optionDeliverables: @option_deliverables.map(&:to_h)
+        }.compact
+      end
+    end
+  end
+end