ig_markets 0.19 → 0.20

data/lib/ig_markets/cli/curses_window.rb

@@ -0,0 +1,96 @@
+module IGMarkets
+  module CLI
+    # This helper class supports the display of text in a fullscreen curses window.
+    #
+    # @private
+    class CursesWindow
+      # Initializes this fullscreen curses window.
+      def initialize
+        self.class.prepare
+
+        @window = Curses::Window.new 0, 0, 0, 0
+        @position = [0, 0]
+      end
+
+      # Clears the contents of this curses window and resets the cursor to the top left.
+      def clear
+        @window.clear
+        @position = [0, 0]
+      end
+
+      # Refreshes this curses window so its content is updated on the screen.
+      def refresh
+        @window.refresh
+      end
+
+      # Prints the specified lines in this fullscreen curses window.
+      #
+      # @param [Array<String>] lines The lines to print.
+      def print_lines(*lines)
+        change_foreground_color nil
+
+        lines.flatten.each do |line|
+          print_next_line_segment line until line.empty?
+
+          @position[0] += 1
+          @position[1] = 0
+        end
+      end
+
+      private
+
+      class << self
+        # Returns whether curses support is available. On Windows the 'curses' gem is optional and so this class may not
+        # be usable.
+        def available?
+          Kernel.require 'curses'
+          true
+        rescue LoadError
+          false
+        end
+
+        def prepare
+          raise IGMarketsError, 'curses gem is not installed' unless available?
+
+          return if @prepared
+
+          Curses.noecho
+          Curses.nonl
+          Curses.stdscr.nodelay = 1
+          Curses.init_screen
+          Curses.start_color
+
+          8.times { |color| Curses.init_pair (30 + color), color, 0 }
+
+          @prepared = true
+        end
+      end
+
+      COLORIZE_REGEXP = /^\e\[0(?:;(\d+);49)?m/
+
+      def print_next_line_segment(line)
+        match = line.match COLORIZE_REGEXP
+
+        if match
+          change_foreground_color match.captures.first
+          line[/^[^m]+m/] = ''
+        else
+          print_character line[0]
+          line[0] = ''
+        end
+      end
+
+      def change_foreground_color(colorize_number)
+        colorize_number ||= 37
+
+        @window.attron Curses.color_pair(colorize_number.to_i) | Curses::A_NORMAL
+      end
+
+      def print_character(character)
+        @window.setpos @position[0], @position[1]
+        @window << character
+        @position[1] += 1
+      end
+    end
+  end
+end

data/lib/ig_markets/cli/main.rb

@@ -19,6 +19,9 @@ module IGMarkets
       desc 'sprints [SUBCOMAND=list ...]', 'Command for working with sprint market positions'
       subcommand 'sprints', Sprints
 
+      desc 'stream [SUBCOMAND=dashboard ...]', 'Command for working with display of streaming data'
+      subcommand 'stream', Stream
+
       desc 'watchlists [SUBCOMAND=list ...]', 'Command for working with watchlists'
       subcommand 'watchlists', Watchlists
 

data/lib/ig_markets/cli/tables/table.rb

@@ -17,6 +17,13 @@ module IGMarkets
         table.to_s
       end
 
+      # Returns the individual formatted lines that make up this table.
+      #
+      # @return [Array<String>]
+      def lines
+        to_s.split "\n"
+      end
+
       private
 
       def default_title

data/lib/ig_markets/deal_confirmation.rb

@@ -7,13 +7,14 @@ module IGMarkets
       attribute :status, Symbol, allowed_values: [:amended, :deleted, :fully_closed, :opened, :partially_closed]
     end
 
+    attribute :account_id
     attribute :affected_deals, AffectedDeal
     attribute :date, Time, format: '%FT%T.%L'
     attribute :deal_id
     attribute :deal_reference
     attribute :deal_status, Symbol, allowed_values: [:accepted, :fund_account, :rejected]
     attribute :direction, Symbol, allowed_values: [:buy, :sell]
-    attribute :epic
+    attribute :epic, String, regex: Regex::EPIC
     attribute :expiry, Date, nil_if: %w(- DFB), format: ['%d-%b-%y', '%b-%y']
     attribute :guaranteed_stop, Boolean
     attribute :level, Float

data/lib/ig_markets/dealing_platform.rb

@@ -9,6 +9,7 @@ module IGMarkets
   # - {#sprint_market_positions}
   # - {#watchlists}
   # - {#working_orders}
+  # - {#streaming}
   #
   # See `README.md` for examples.
   #
@@ -59,6 +60,11 @@ module IGMarkets
     # @return [WorkingOrderMethods]
     attr_reader :working_orders
 
+    # Methods for working with live streaming of IG Markets data.
+    #
+    # @return [StreamingMethods]
+    attr_reader :streaming
+
     def initialize
       @session = Session.new
 
@@ -69,6 +75,7 @@ module IGMarkets
       @sprint_market_positions = SprintMarketPositionMethods.new self
       @watchlists = WatchlistMethods.new self
       @working_orders = WorkingOrderMethods.new self
+      @streaming = StreamingMethods.new self
     end
 
     # Signs in to the IG Markets Dealing Platform, either the live platform or the demo platform.
@@ -93,6 +100,7 @@ module IGMarkets
 
     # Signs out of the IG Markets Dealing Platform, ending any current session.
     def sign_out
+      streaming.disconnect
       session.sign_out
     end
 
@@ -119,19 +127,6 @@ module IGMarkets
       instantiate_models Application, session.put('operations/application/disable')
     end
 
-    # Creates a new Lightstreamer session instance from this dealing platform's {#session} that is ready to connect
-    # and start streaming account and market data.
-    #
-    # @return [Lightstreamer::Session, nil] The new Lightstreamer session instance, or `nil` if there is no active
-    #         IG Markets session to connect through.
-    def lightstreamer_session
-      return nil unless session.alive?
-
-      Lightstreamer::Session.new server_url: client_account_summary.lightstreamer_endpoint,
-                                 username: client_account_summary.client_id,
-                                 password: "CST-#{session.client_security_token}|XST-#{session.x_security_token}"
-    end
-
     # This method is used to instantiate the various `Model` subclasses from data returned by the IG Markets API. It
     # recurses through arrays and sub-hashes present in `source`, instantiating the required models based on the types
     # of each attribute as defined on the models. All model instances returned by this method will have their
@@ -161,6 +156,18 @@ module IGMarkets
       end
     end
 
+    # This method is the same as {#instantiate_models} but takes an unparsed JSON string as its input.
+    #
+    # @param [Class] model_class The top-level model class to create from `json`.
+    # @param [String] json The JSON string to parse.
+    #
+    # @return [nil, `model_class`] The resulting instantiated model.
+    #
+    # @private
+    def instantiate_models_from_json(model_class, json)
+      instantiate_models model_class, ResponseParser.parse(JSON.parse(json))
+    end
+
     private
 
     # This method is a helper for {#instantiate_models} that prepares a source object for instantiation.

data/lib/ig_markets/dealing_platform/streaming_methods.rb

@@ -0,0 +1,173 @@
+module IGMarkets
+  class DealingPlatform
+    # Provides methods for working with streaming of IG Markets data. Returned by {DealingPlatform#streaming}.
+    class StreamingMethods
+      # Initializes this class with the specified dealing platform.
+      #
+      # @param [DealingPlatform] dealing_platform The dealing platform.
+      def initialize(dealing_platform)
+        @dealing_platform = dealing_platform
+        @queue = Queue.new
+        @on_error_callbacks = []
+      end
+
+      # Connects the streaming session. Raises a `Lightstreamer::LightstreamerError` if an error occurs.
+      def connect
+        @lightstreamer.disconnect if @lightstreamer
+        @queue.clear
+
+        @lightstreamer = Lightstreamer::Session.new username: username, password: password, server_url: server_url
+        @lightstreamer.on_error { |error| @on_error_callbacks.each { |callback| callback.call error } }
+        @lightstreamer.connect
+      end
+
+      # Disconnects the streaming session.
+      def disconnect
+        @lightstreamer.disconnect if @lightstreamer
+        @lightstreamer = nil
+      end
+
+      # Adds the passed block to the list of callbacks that will be run when the streaming session encounters an error.
+      # The block will be called on a worker thread and so the code that is run by the block must be thread-safe.
+      # The argument passed to the block is `|error|`, which will be a `Lightstreamer::LightstreamerError` subclass
+      # detailing the error that occurred.
+      #
+      # @param [Proc] callback The callback that is to be run.
+      def on_error(&callback)
+        @on_error_callbacks << callback
+      end
+
+      # Creates a new subscription for balance updates on the specified account(s). The returned
+      # {Streaming::Subscription} must be passed to {#start_subscriptions} in order to actually start streaming its
+      # data.
+      #
+      # @param [Array<#account_id>, nil] accounts The accounts to create a subscription for. If this is `nil` then the
+      #        new subscription will apply to all the accounts for the active client.
+      #
+      # @return [Streaming::Subscription]
+      def build_accounts_subscription(accounts = nil)
+        accounts ||= @dealing_platform.client_account_summary.accounts
+
+        items = Array(accounts).map { |account| "ACCOUNT:#{account.account_id}" }
+        fields = [:available_cash, :available_to_deal, :deposit, :equity, :equity_used, :funds, :margin, :margin_lr,
+                  :margin_nlr, :pnl, :pnl_lr, :pnl_nlr]
+
+        build_subscription items: items, fields: fields, mode: :merge
+      end
+
+      # Creates a new Lightstreamer subscription for updates to the specified market(s). The returned
+      # {Streaming::Subscription} must be passed to {#start_subscriptions} in order to actually start streaming its
+      # data.
+      #
+      # @param [Array<String>] epics The EPICs of the markets to create a subscription for.
+      #
+      # @return [Streaming::Subscription]
+      def build_markets_subscription(epics)
+        items = Array(epics).map { |epic| "MARKET:#{epic}" }
+        fields = [:bid, :change, :change_pct, :high, :low, :market_delay, :market_state, :mid_open, :odds, :offer,
+                  :strike_price, :update_time]
+
+        build_subscription items: items, fields: fields, mode: :merge
+      end
+
+      # Creates a new Lightstreamer subscription for trade, position and working order updates on the specified
+      # account(s). The returned {Streaming::Subscription} must be passed to {#start_subscriptions} in order to
+      # actually start streaming its data.
+      #
+      # @param [Array<#account_id>, nil] accounts The accounts to create a subscription for. If this is `nil` then the
+      #        new subscription will apply to all the accounts for the active client.
+      #
+      # @return [Streaming::Subscription]
+      def build_trades_subscription(accounts = nil)
+        accounts ||= @dealing_platform.client_account_summary.accounts
+
+        items = Array(accounts).map { |account| "TRADE:#{account.account_id}" }
+        fields = [:confirms, :opu, :wou]
+
+        build_subscription items: items, fields: fields, mode: :distinct
+      end
+
+      # Creates a new Lightstreamer subscription for chart tick data for the specified EPICs. The returned
+      # {Streaming::Subscription} must be passed to {#start_subscriptions} in order to actually start streaming its
+      # data.
+      #
+      # @param [Array<String>] epics The EPICs of the markets to create a chart tick data subscription for.
+      #
+      # @return [Streaming::Subscription]
+      def build_chart_ticks_subscription(epics)
+        items = Array(epics).map { |epic| "CHART:#{epic}:TICK" }
+        fields = [:bid, :day_high, :day_low, :day_net_chg_mid, :day_open_mid, :day_perc_chg_mid, :ltp, :ltv, :ofr, :ttv,
+                  :utm]
+
+        build_subscription items: items, fields: fields, mode: :distinct
+      end
+
+      # Creates a new Lightstreamer subscription for consolidated chart data for the specified EPIC and scale. The
+      # returned {Streaming::Subscription} must be passed to {#start_subscriptions} in order to actually start streaming
+      # its data.
+      #
+      # @param [String] epic The EPIC of the market to create a consolidated chart data subscription for.
+      # @param [:one_second, :one_minute, :five_minutes, :one_hour] scale The scale of the consolidated data.
+      #
+      # @return [Streaming::Subscription]
+      def build_consolidated_chart_data_subscription(epic, scale)
+        scale = { one_second: 'SECOND', one_minute: '1MINUTE', five_minutes: '5MINUTE', one_hour: 'HOUR' }.fetch scale
+        items = ["CHART:#{epic}:#{scale}"]
+
+        fields = [:bid_close, :bid_high, :bid_low, :bid_open, :cons_end, :cons_tick_count, :day_high, :day_low,
+                  :day_net_chg_mid, :day_open_mid, :day_perc_chg_mid, :ltp_close, :ltp_high, :ltp_low, :ltp_open, :ltv,
+                  :ofr_close, :ofr_high, :ofr_low, :ofr_open, :ttv, :utm]
+
+        build_subscription items: items, fields: fields, mode: :merge
+      end
+
+      # Starts streaming data from the passed Lightstreamer subscription(s). The return value indicates the error state,
+      # if any, for each subscription.
+      #
+      # @param [Array<Streaming::Subscription>] subscriptions
+      # @param [Hash] options The options to start the subscriptions with. See the documentation for
+      #        `Lightstreamer::Subscription#start` for details of the accepted options.
+      #
+      # @return [Array<Lightstreamer::LightstreamerError, nil>] An array with one entry per subscription which indicates
+      #         the error state returned for that subscription's start request, or `nil` if no error occurred.
+      def start_subscriptions(subscriptions, options = {})
+        lightstreamer_subscriptions = Array(subscriptions).compact.map(&:lightstreamer_subscription)
+
+        return if lightstreamer_subscriptions.empty?
+
+        @lightstreamer.start_subscriptions lightstreamer_subscriptions, options
+      end
+
+      # Stops streaming data for the specified subscription(s) and removes them from the streaming session.
+      #
+      # @param [Array<Lightstreamer::Subscription>] subscriptions The subscriptions to stop.
+      def remove_subscriptions(subscriptions)
+        lightstreamer_subscriptions = Array(subscriptions).compact.map(&:lightstreamer_subscription)
+
+        return if lightstreamer_subscriptions.empty?
+
+        @lightstreamer.remove_subscriptions lightstreamer_subscriptions
+      end
+
+      private
+
+      def username
+        @dealing_platform.client_account_summary.client_id
+      end
+
+      def password
+        "CST-#{@dealing_platform.session.client_security_token}|XST-#{@dealing_platform.session.x_security_token}"
+      end
+
+      def server_url
+        @dealing_platform.client_account_summary.lightstreamer_endpoint
+      end
+
+      def build_subscription(options)
+        subscription = @lightstreamer.build_subscription options
+
+        Streaming::Subscription.new @dealing_platform, subscription
+      end
+    end
+  end
+end

data/lib/ig_markets/model/typecasters.rb

@@ -20,6 +20,7 @@ module IGMarkets
 
       def typecaster_boolean(value, _options, _name)
         return value if [nil, true, false].include? value
+        return value == '1' if %w(0 1).include? value
 
         raise ArgumentError, "#{self}##{name}: invalid boolean value: #{value}"
       end

data/lib/ig_markets/position.rb

@@ -7,6 +7,7 @@ module IGMarkets
     attribute :created_date_utc, Time, format: '%FT%T'
     attribute :currency, String, regex: Regex::CURRENCY
     attribute :deal_id
+    attribute :deal_reference
     attribute :direction, Symbol, allowed_values: [:buy, :sell]
     attribute :level, Float
     attribute :limit_level, Float

data/lib/ig_markets/streaming/account_state.rb

@@ -0,0 +1,190 @@
+module IGMarkets
+  module Streaming
+    # This class tracks the current state of a dealing platform's accounts, positions and working orders by subscribing
+    # to the relevant streaming data feeds supported by the IG Markets streaming API. This is much more efficient than
+    # making repeated calls to the REST API to get current account, position or working order details, and also avoids
+    # running into API traffic allowance limits.
+    class AccountState
+      # The current state of the accounts. The balances will be updated automatically as new streaming data arrives.
+      #
+      # @return [Array<Account>]
+      attr_accessor :accounts
+
+      # The current positions for this account. This set of positions will be updated automatically as new streaming
+      # data arrives.
+      #
+      # @return [Array<Position>]
+      attr_accessor :positions
+
+      # The current working orders for this account. This set of working orders will be updated automatically as new
+      # streaming data arrives.
+      #
+      # @return [Array<WorkingOrder>]
+      attr_accessor :working_orders
+
+      # Initializes this account state with the specified dealing platform.
+      #
+      # @param [DealingPlatform] dealing_platform The dealing platform.
+      def initialize(dealing_platform)
+        @dealing_platform = dealing_platform
+
+        @data_queue = Queue.new
+
+        @market_subscriptions_manager = MarketSubscriptionManager.new dealing_platform
+        @market_subscriptions_manager.on_data { |_data, merged_data| @data_queue << [:on_market_update, merged_data] }
+      end
+
+      # Starts all the relevant streaming subscriptions that are needed to keep this account state up to date using live
+      # streaming updates. After this account state has been started the {#process_queued_data} method must be called
+      # repeatedly to process the queue of streaming updates and apply them to {#accounts}, {#positions} and
+      # {#working_orders} as appropriate.
+      def start
+        start_accounts_subscription
+        start_trades_subscription
+
+        @accounts = @dealing_platform.account.all
+        @positions = @dealing_platform.positions.all
+        @working_orders = @dealing_platform.working_orders.all
+
+        @trades_subscription.unsilence
+
+        update_market_subscriptions
+      end
+
+      # Returns whether there is any data waiting to be processed by a call to {#process_queued_data}
+      #
+      # @return [Boolean]
+      def data_to_process?
+        !@data_queue.empty?
+      end
+
+      # Processes all queued data and updates {#accounts}, {#positions} and {#working_orders} accordingly. If there are
+      # no queued data updates then this method blocks until at least one data update is available.
+      def process_queued_data
+        loop do
+          send(*@data_queue.pop)
+
+          break if @data_queue.empty?
+        end
+
+        update_market_subscriptions
+      end
+
+      private
+
+      def start_accounts_subscription
+        @accounts_subscription = @dealing_platform.streaming.build_accounts_subscription
+
+        @accounts_subscription.on_data do |_data, merged_data|
+          @data_queue << [:on_account_update, merged_data]
+        end
+
+        @dealing_platform.streaming.start_subscriptions @accounts_subscription, snapshot: true
+      end
+
+      def start_trades_subscription
+        @trades_subscription = @dealing_platform.streaming.build_trades_subscription
+
+        @trades_subscription.on_data do |data|
+          @data_queue << [:on_position_update, data] if data.is_a? PositionUpdate
+          @data_queue << [:on_working_order_update, data] if data.is_a? WorkingOrderUpdate
+        end
+
+        @dealing_platform.streaming.start_subscriptions @trades_subscription, silent: true
+      end
+
+      def market_models
+        @positions + @working_orders
+      end
+
+      def update_market_subscriptions
+        @market_subscriptions_manager.epics = market_models.map { |model| model.market.epic }
+      end
+
+      def on_account_update(account_update)
+        @accounts.each do |account|
+          next unless account.account_id == account_update.account_id
+
+          account.balance.available = account_update.available_to_deal
+          account.balance.balance = account_update.equity
+          account.balance.deposit = account_update.margin
+          account.balance.profit_loss = account_update.pnl
+        end
+      end
+
+      def on_market_update(market_update)
+        market_models.each do |model|
+          next unless model.market.epic == market_update.epic
+
+          attributes_to_copy = { bid: :bid, high: :high, low: :low, net_change: :change, offer: :offer,
+                                 percentage_change: :change_pct }
+
+          attributes_to_copy.each do |target_attribute, update_attribute|
+            model.market.send "#{target_attribute}=", market_update.send(update_attribute)
+          end
+
+          model.market.market_status = convert_market_status market_update.market_state if market_update.market_state
+        end
+      end
+
+      def convert_market_status(status)
+        { auction: :on_auction, auction_no_edit: :on_auction_no_edits, closed: :closed, edit: :edits_only,
+          offline: :offline, suspended: :suspended, tradeable: :tradeable }.fetch status
+      end
+
+      def on_position_update(position_update)
+        send "on_position_#{position_update.status}", position_update
+      end
+
+      def on_position_open(position_update)
+        return if @positions.any? { |position| position.deal_id == position_update.deal_id }
+
+        new_position = @dealing_platform.positions[position_update.deal_id]
+
+        @positions << new_position if new_position
+      end
+
+      def on_position_updated(position_update)
+        @positions.each do |position|
+          next unless position.deal_id == position_update.deal_id
+
+          position.limit_level = position_update.limit_level
+          position.stop_level = position_update.stop_level
+        end
+      end
+
+      def on_position_deleted(position_update)
+        @positions.delete_if do |position|
+          position.deal_id == position_update.deal_id
+        end
+      end
+
+      def on_working_order_update(working_order_update)
+        send "on_working_order_#{working_order_update.status}", working_order_update
+      end
+
+      def on_working_order_open(working_order_update)
+        return if @working_orders.any? { |working_order| working_order.deal_id == working_order_update.deal_id }
+
+        new_working_order = @dealing_platform.working_orders[working_order_update.deal_id]
+
+        @working_orders << new_working_order if new_working_order
+      end
+
+      def on_working_order_updated(working_order_update)
+        @working_orders.each do |working_order|
+          next unless working_order.deal_id == working_order_update.deal_id
+
+          working_order.limit_distance = working_order_update.limit_distance
+          working_order.stop_distance = working_order_update.stop_distance
+        end
+      end
+
+      def on_working_order_deleted(working_order_update)
+        @working_orders.delete_if do |working_order|
+          working_order.deal_id == working_order_update.deal_id
+        end
+      end
+    end
+  end
+end