ig_markets 0.1

data/lib/ig_markets/client_sentiment.rb

@@ -0,0 +1,16 @@
+module IGMarkets
+  # Contains details on client sentiment for a single market. Returned by {DealingPlatform::ClientSentimentMethods#[]}
+  # and {#related_sentiments}.
+  class ClientSentiment < Model
+    attribute :long_position_percentage, Float
+    attribute :market_id
+    attribute :short_position_percentage, Float
+
+    # Returns client sentiments for markets that are related to this one.
+    #
+    # @return [Array<ClientSentiment>]
+    def related_sentiments
+      @dealing_platform.gather "clientsentiment/related/#{market_id}", :client_sentiments, ClientSentiment
+    end
+  end
+end

data/lib/ig_markets/deal_confirmation.rb

@@ -0,0 +1,41 @@
+module IGMarkets
+  # Contains details on a single dealing event. Returned by {DealingPlatform#deal_confirmation}.
+  class DealConfirmation < Model
+    # Contains details on a specific deal that was affected by a dealing event. Returned by {#affected_deals}.
+    class AffectedDeal < Model
+      attribute :deal_id
+      attribute :status, Symbol, allowed_values: [:amended, :deleted, :fully_closed, :opened, :partially_closed]
+    end
+
+    attribute :affected_deals, AffectedDeal
+    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 :expiry, DateTime, nil_if: '-', format: '%d-%b-%y'
+    attribute :guaranteed_stop, Boolean
+    attribute :level, Float
+    attribute :limit_distance, Float
+    attribute :limit_level, Float
+    attribute :reason, Symbol, allowed_values: [
+      :account_not_enabled_to_trading, :attached_order_level_error, :attached_order_trailing_stop_error,
+      :cannot_change_stop_type, :cannot_remove_stop, :closing_only_trades_accepted_on_this_market, :conflicting_order,
+      :cr_spacing, :duplicate_order_error, :exchange_manual_override, :finance_repeat_dealing,
+      :force_open_on_same_market_different_currency, :general_error, :good_till_date_in_the_past, :instrument_not_found,
+      :insufficient_funds, :level_tolerance_error, :manual_order_timeout, :market_closed, :market_closed_with_edits,
+      :market_closing, :market_not_borrowable, :market_offline, :market_phone_only, :market_rolled,
+      :market_unavailable_to_client, :max_auto_size_exceeded, :minimum_order_size_error, :move_away_only_limit,
+      :move_away_only_stop, :move_away_only_trigger_level, :opposing_direction_orders_not_allowed,
+      :opposing_positions_not_allowed, :order_locked, :order_not_found, :over_normal_market_size,
+      :partially_closed_position_not_deleted, :position_not_available_to_close, :position_not_found,
+      :reject_spreadbet_order_on_cfd_account, :size_increment, :sprint_market_expiry_after_market_close,
+      :stop_or_limit_not_allowed, :stop_required_error, :strike_level_tolerance, :success, :trailing_stop_not_allowed,
+      :unknown, :wrong_side_of_market]
+    attribute :size, Fixnum
+    attribute :status, Symbol, allowed_values: [:amended, :closed, :deleted, :open, :partially_closed]
+    attribute :stop_distance, Float
+    attribute :stop_level, Float
+    attribute :trailing_stop, Boolean
+  end
+end

data/lib/ig_markets/dealing_platform.rb

@@ -0,0 +1,105 @@
+module IGMarkets
+  # This is the primary class for interacting with the IG Markets API. After signing in using {#sign_in} most
+  # functionality is accessed via the following top-level methods:
+  #
+  # - {#account}
+  # - {#client_sentiment}
+  # - {#markets}
+  # - {#positions}
+  # - {#sprint_market_positions}
+  # - {#watchlists}
+  # - {#working_orders}
+  #
+  # See `README.md` for examples.
+  #
+  # If any errors occur while executing requests to the IG Markets API then {RequestFailedError} will be raised.
+  class DealingPlatform
+    # @return [Session] The session used by this dealing platform.
+    attr_reader :session
+
+    # @return [AccountMethods] Methods for working with the logged in account.
+    attr_reader :account
+
+    # @return [ClientSentimentMethods] Methods for working with client sentiment.
+    attr_reader :client_sentiment
+
+    # @return [MarketMethods] Methods for working with markets.
+    attr_reader :markets
+
+    # @return [PositionMethods] Methods for working with positions.
+    attr_reader :positions
+
+    # @return [SprintMarketPositionMethods] Methods for working with sprint market positions.
+    attr_reader :sprint_market_positions
+
+    # @return [WatchlistMethods] Methods for working with watchlists.
+    attr_reader :watchlists
+
+    # @return [WorkingOrderMethods] Methods for working with working orders.
+    attr_reader :working_orders
+
+    def initialize
+      @session = Session.new
+
+      @account = AccountMethods.new self
+      @client_sentiment = ClientSentimentMethods.new self
+      @markets = MarketMethods.new self
+      @positions = PositionMethods.new self
+      @sprint_market_positions = SprintMarketPositionMethods.new self
+      @watchlists = WatchlistMethods.new self
+      @working_orders = WorkingOrderMethods.new self
+    end
+
+    # Signs in to the IG Markets Dealing Platform, either the production platform or the demo platform.
+    #
+    # @param [String] username The account username.
+    # @param [String] password The account password.
+    # @param [String] api_key The account API key.
+    # @param [:production, :demo] platform The platform to use.
+    def sign_in(username, password, api_key, platform)
+      session.username = username
+      session.password = password
+      session.api_key = api_key
+      session.platform = platform
+
+      session.sign_in
+    end
+
+    # Signs out of the IG Markets Dealing Platform, ending any current session.
+    def sign_out
+      session.sign_out
+    end
+
+    # Returns a full deal confirmation for the specified deal reference.
+    #
+    # @return [DealConfirmation]
+    def deal_confirmation(deal_reference)
+      DealConfirmation.from session.get "confirms/#{deal_reference}", API_V1
+    end
+
+    # Returns details on the IG Markets applications for the accounts associated with this login.
+    #
+    # @return [Array<Application>]
+    def applications
+      Application.from session.get 'operations/application', API_V1
+    end
+
+    # Sends a GET request to a URL then takes a single key from the returned hash and converts its contents to an array
+    # of type `klass`.
+    #
+    # @param [String] url The URL to send a GET request to.
+    # @param [Symbol] collection The name of the top level symbol that contains the array of data to return.
+    # @param [Class] klass The type to return.
+    # @param [API_V1, API_V2, API_V3] api_version The API version to target for the request.
+    #
+    # @return [Array]
+    def gather(url, collection, klass, api_version = API_V1)
+      klass.from(session.get(url, api_version).fetch(collection)).tap do |result|
+        # Set @dealing_platform on all the results
+        result.each do |item|
+          item.instance_variable_set :@dealing_platform, self
+        end
+      end
+    end
+  end
+end

data/lib/ig_markets/dealing_platform/account_methods.rb

@@ -0,0 +1,92 @@
+module IGMarkets
+  class DealingPlatform
+    # Provides methods for working with the logged in account. Returned by {DealingPlatform#account}.
+    class AccountMethods
+      # Initializes this helper class with the specified dealing platform.
+      #
+      # @param [DealingPlatform] dealing_platform The dealing platform.
+      def initialize(dealing_platform)
+        @dealing_platform = dealing_platform
+      end
+
+      # Returns all accounts associated with the current IG Markets login.
+      #
+      # @return [Array<Account>]
+      def all
+        @dealing_platform.gather 'accounts', :accounts, Account
+      end
+
+      # Returns all account activities that occurred in the specified date range.
+      #
+      # @param [Date] from_date The start date of the desired date range.
+      # @param [Date] to_date The end date of the desired date range.
+      #
+      # @return [Array<AccountActivity>]
+      def activities_in_date_range(from_date, to_date)
+        from_date = format_date from_date
+        to_date = format_date to_date
+
+        @dealing_platform.gather "history/activity/#{from_date}/#{to_date}", :activities, AccountActivity
+      end
+
+      # Returns all account activities that occurred in the most recent specified number of seconds.
+      #
+      # @param [Integer, Float] seconds The number of seconds to return recent activities for.
+      #
+      # @return [Array<AccountActivity>]
+      def recent_activities(seconds)
+        @dealing_platform.gather "history/activity/#{(seconds * 1000.0).to_i}", :activities, AccountActivity
+      end
+
+      # Returns all transactions that occurred in the specified date range.
+      #
+      # @param [Date] from_date The start date of the desired date range.
+      # @param [Date] to_date The end date of the desired date range.
+      # @param [:all, :all_deal, :deposit, :withdrawal] transaction_type The type of transactions to return.
+      #
+      # @return [Array<AccountTransaction>]
+      def transactions_in_date_range(from_date, to_date, transaction_type = :all)
+        validate_transaction_type transaction_type
+
+        from_date = format_date from_date
+        to_date = format_date to_date
+
+        url = "history/transactions/#{transaction_type.to_s.upcase}/#{from_date}/#{to_date}"
+
+        @dealing_platform.gather url, :transactions, AccountTransaction
+      end
+
+      # Returns all transactions that occurred in the last specified number of seconds.
+      #
+      # @param [Integer, Float] seconds The number of seconds to return recent transactions for.
+      # @param [:all, :all_deal, :deposit, :withdrawal] transaction_type The type of transactions to return.
+      #
+      # @return [Array<AccountTransaction>]
+      def recent_transactions(seconds, transaction_type = :all)
+        validate_transaction_type transaction_type
+
+        url = "history/transactions/#{transaction_type.to_s.upcase}/#{(seconds * 1000.0).to_i}"
+
+        @dealing_platform.gather url, :transactions, AccountTransaction
+      end
+
+      private
+
+      # Validates whether the passed argument is a valid transaction type.
+      #
+      # @param [Symbol] type The candidate transaction type to validate.
+      def validate_transaction_type(type)
+        raise ArgumentError, 'transaction type is invalid' unless [:all, :all_deal, :deposit, :withdrawal].include? type
+      end
+
+      # Formats the passed `Date` as a string in the manner needed for building IG Markets URLs.
+      #
+      # @param [Date] date The date to format.
+      #
+      # @return [String]
+      def format_date(date)
+        date.strftime '%d-%m-%Y'
+      end
+    end
+  end
+end

data/lib/ig_markets/dealing_platform/client_sentiment_methods.rb

@@ -0,0 +1,26 @@
+module IGMarkets
+  class DealingPlatform
+    # Provides methods for working with client sentiment. Returned by {DealingPlatform#client_sentiment}.
+    class ClientSentimentMethods
+      # Initializes this helper class with the specified dealing platform.
+      #
+      # @param [DealingPlatform] dealing_platform The dealing platform.
+      def initialize(dealing_platform)
+        @dealing_platform = dealing_platform
+      end
+
+      # Returns the client sentiment for a market.
+      #
+      # @param [String] market_id The ID of the market to return client sentiment for.
+      #
+      # @return [ClientSentiment]
+      def [](market_id)
+        result = @dealing_platform.session.get "clientsentiment/#{market_id}", API_V1
+
+        ClientSentiment.from(result).tap do |client_sentiment|
+          client_sentiment.instance_variable_set :@dealing_platform, @dealing_platform
+        end
+      end
+    end
+  end
+end

data/lib/ig_markets/dealing_platform/market_methods.rb

@@ -0,0 +1,59 @@
+module IGMarkets
+  class DealingPlatform
+    # Provides methods for working with markets. Returned by {DealingPlatform#markets}.
+    class MarketMethods
+      # Initializes this helper class with the specified dealing platform.
+      #
+      # @param [DealingPlatform] dealing_platform The dealing platform.
+      def initialize(dealing_platform)
+        @dealing_platform = dealing_platform
+      end
+
+      # Returns details on the market hierarchy directly under the specified node.
+      #
+      # @param [String] node_id The ID of the node to return the market hierarchy for. If `nil` then details on the root
+      #        node of the hierarchy will be returned.
+      #
+      # @return [MarketHierarchyResult]
+      def hierarchy(node_id = nil)
+        url = ['marketnavigation', node_id].compact.join '/'
+
+        MarketHierarchyResult.from @dealing_platform.session.get(url, API_V1)
+      end
+
+      # Returns details for the markets with the passed EPICs.
+      #
+      # @param [Array<String>] epics The EPICs of the markets to return details for.
+      #
+      # @return [Array<Market>]
+      def find(*epics)
+        raise ArgumentError, 'at least one EPIC must be specified' if epics.empty?
+
+        epics.each do |epic|
+          raise ArgumentError, "invalid EPIC: #{epic}" unless epic.to_s =~ Regex::EPIC
+        end
+
+        @dealing_platform.gather "markets?epics=#{epics.join(',')}", :market_details, Market, API_V2
+      end
+
+      # Searches markets using a search term and returns an array of results.
+      #
+      # @param [String] search_term The search term to use.
+      #
+      # @return [Array<MarketOverview>]
+      def search(search_term)
+        @dealing_platform.gather "markets?searchTerm=#{search_term}", :markets, MarketOverview
+      end
+
+      # Returns market details for the market with the specified EPIC, or `nil` if there is no market with that EPIC.
+      # Internally a call to {#find} is made.
+      #
+      # @param [String] epic The EPIC of the market to return details for.
+      #
+      # @return [Market]
+      def [](epic)
+        find(epic)[0]
+      end
+    end
+  end
+end

data/lib/ig_markets/dealing_platform/position_methods.rb

@@ -0,0 +1,164 @@
+module IGMarkets
+  class DealingPlatform
+    # Provides methods for working with positions. Returned by {DealingPlatform#positions}.
+    class PositionMethods
+      # Initializes this helper class with the specified dealing platform.
+      #
+      # @param [DealingPlatform] dealing_platform The dealing platform.
+      def initialize(dealing_platform)
+        @dealing_platform = dealing_platform
+      end
+
+      # Returns all positions.
+      #
+      # @return [Array<Position>]
+      def all
+        @dealing_platform.session.get('positions', API_V2).fetch(:positions).map do |attributes|
+          position_from_attributes attributes
+        end
+      end
+
+      # Returns the position with the specified deal ID, or `nil` if there is no position with that ID.
+      #
+      # @param [String] deal_id The deal ID of the working order to return.
+      #
+      # @return [Position]
+      def [](deal_id)
+        attributes = @dealing_platform.session.get "positions/#{deal_id}", API_V2
+
+        position_from_attributes attributes
+      end
+
+      # Creates a new position.
+      #
+      # @param [Hash] attributes The attributes for the new position.
+      # @option attributes [String] :currency_code The 3 character currency code, must be one of the instrument's
+      #                    currencies (see {Instrument#currencies}). Required.
+      # @option attributes [:buy, :sell] :direction The position direction. Required.
+      # @option attributes [String] :epic The EPIC of the instrument to create a position for. Required.
+      # @option attributes [DateTime] :expiry The expiry date of the instrument, if it has one. Optional.
+      # @option attributes [Boolean] :force_open Whether a force open is required. Defaults to `false`.
+      # @option attributes [Boolean] :guaranteed_stop Whether a guaranteed stop is required. Defaults to `false`.
+      # @option attributes [Float] :level Required if and only if `:order_type` is `:limit` or `:quote`.
+      # @option attributes [Fixnum] :limit_distance The distance away in pips to place the limit. If this is set then
+      #                    `:limit_level` must be `nil`. Optional.
+      # @option attributes [Float] :limit_level The limit level. If this is set then `:limit_distance` must be `nil`.
+      #                    Optional.
+      # @option attributes [:limit, :market, :quote] :order_type The order type. `:market` indicates to fill the order
+      #                    at current market level(s). `:limit` indicates to fill at the price specified by `:level`
+      #                    (or a more favorable one). `:quote` is only permitted following agreement with IG Markets.
+      #                    Defaults to `:market`.
+      # @option attributes [String] :quote_id The Lightstreamer quote ID. Required when `:order_type` is `:quote`.
+      # @option attributes [Float] :size The size of the position to create. Required.
+      # @option attributes [Fixnum] :stop_distance The distance away in pips to place the stop. If this is set then
+      #                    `:stop_level` must be `nil`. Optional.
+      # @option attributes [Float] :stop_level The stop level. If this is set then `:stop_distance` must be `nil`.
+      #                    Optional.
+      # @option attributes [:execute_and_eliminate, :fill_or_kill] :time_in_force The order fill strategy.
+      #                    `:execute_and_eliminate` will fill this order as much as possible within the constraints set
+      #                    by `:order_type`, `:level` and `:quote_id`, which may result in only part of the requested
+      #                    order being filled. `:fill_or_kill` will try to fill the whole order within the constraints,
+      #                    however if this is not possible then the order will not be filled at all. If `:order_type` is
+      #                    `:market` (the default) then `:time_in_force` will be automatically set to
+      #                    `:execute_and_eliminate`.
+      # @option attributes [Boolean] :trailing_stop Whether to use a trailing stop. Defaults to false. Optional.
+      # @option attributes [Fixnum] :trailing_stop_increment The increment step in pips for the trailing stop. Required
+      #                    when `:trailing_stop` is `true`.
+      #
+      # @return [String] The resulting deal reference, use {DealingPlatform#deal_confirmation} to check the result of
+      #         the position creation.
+      def create(attributes)
+        attributes[:force_open] = false unless attributes.key? :force_open
+        attributes[:guaranteed_stop] = false unless attributes.key? :guaranteed_stop
+        attributes[:order_type] ||= :market
+        attributes[:time_in_force] = :execute_and_eliminate if attributes[:order_type] == :market
+
+        model = PositionCreateAttributes.new attributes
+        model.validate
+
+        payload = PayloadFormatter.format model
+        payload[:expiry] ||= '-'
+
+        @dealing_platform.session.post('positions/otc', payload, API_V2).fetch(:deal_reference)
+      end
+
+      private
+
+      # Internal model used by {#create}
+      class PositionCreateAttributes < Model
+        attribute :currency_code, String, regex: Regex::CURRENCY
+        attribute :direction, Symbol, allowed_values: [:buy, :sell]
+        attribute :epic, String, regex: Regex::EPIC
+        attribute :expiry, DateTime, format: '%d-%b-%y'
+        attribute :force_open, Boolean
+        attribute :guaranteed_stop, Boolean
+        attribute :level, Float
+        attribute :limit_distance, Fixnum
+        attribute :limit_level, Float
+        attribute :order_type, Symbol, allowed_values: [:limit, :market, :quote]
+        attribute :quote_id
+        attribute :size, Fixnum
+        attribute :stop_distance, Fixnum
+        attribute :stop_level, Float
+        attribute :time_in_force, Symbol, allowed_values: [:execute_and_eliminate, :fill_or_kill]
+        attribute :trailing_stop, Boolean
+        attribute :trailing_stop_increment, Fixnum
+
+        # Runs a series of validations on this model's attributes to check whether it is ready to be sent to the IG
+        # Markets API.
+        def validate
+          validate_required_attributes_present
+          Position.validate_order_type_constraints attributes
+          validate_trailing_stop_constraints
+          validate_stop_and_limit_constraints
+          validate_guaranteed_stop_constraints
+        end
+
+        private
+
+        # Checks that all required attributes for position creation are present.
+        def validate_required_attributes_present
+          required = [:currency_code, :direction, :epic, :force_open, :guaranteed_stop, :order_type, :size,
+                      :time_in_force]
+
+          required.each do |attribute|
+            raise ArgumentError, "#{attribute} attribute must be set" if attributes[attribute].nil?
+          end
+        end
+
+        # Checks that attributes associated with the trailing stops are valid.
+        def validate_trailing_stop_constraints
+          if trailing_stop
+            raise ArgumentError, 'do not set stop_level when trailing_stop is true' if stop_level
+            raise ArgumentError, 'set stop_distance when trailing_stop is true' unless stop_distance
+          end
+
+          if trailing_stop == trailing_stop_increment.nil?
+            raise ArgumentError, 'set trailing_stop_increment if and only if trailing_stop is true'
+          end
+        end
+
+        # Checks that attributes associated with the stop and limit are valid.
+        def validate_stop_and_limit_constraints
+          raise ArgumentError, 'set only one of limit_level and limit_distance' if limit_level && limit_distance
+          raise ArgumentError, 'set only one of stop_level and stop_distance' if stop_level && stop_distance
+        end
+
+        # Checks that attributes associated with the guaranteed stop are valid.
+        def validate_guaranteed_stop_constraints
+          if guaranteed_stop && !(stop_level.nil? ^ stop_distance.nil?)
+            raise ArgumentError, 'set exactly one of stop_level or stop_distance when guaranteed_stop is true'
+          end
+        end
+      end
+
+      def position_from_attributes(attributes)
+        Position.new(attributes.fetch(:position).merge(market: attributes.fetch(:market))).tap do |position|
+          position.instance_variable_set :@dealing_platform, @dealing_platform
+        end
+      end
+
+      private_constant :PositionCreateAttributes
+    end
+  end
+end