ib-api 972.0

data/lib/ib/messages/incoming/abstract_message.rb

@@ -0,0 +1,116 @@
+require 'ib/messages/abstract_message'
+require 'ib/support'
+require 'ox'
+module IB
+	module Messages
+		module Incoming
+			using IBSupport # refine Array-method for decoding of IB-Messages
+
+
+			# Container for specific message classes, keyed by their message_ids
+			Classes = {}
+
+			class AbstractMessage < IB::Messages::AbstractMessage
+
+				attr_accessor :buffer # is an array
+
+				def version # Per message, received messages may have the different versions
+					@data[:version]
+				end
+
+				def check_version actual, expected
+					unless actual == expected || expected.is_a?(Array) && expected.include?(actual)
+						puts self.class.name
+						error "Unsupported version #{actual} received, expected #{expected}"
+					end
+				end
+
+				# Create incoming message from a given source (IB Socket or data Hash)
+				def initialize source
+					@created_at = Time.now
+					if source.is_a?(Hash)  # Source is a @data Hash
+						@data = source
+						@buffer =[] # initialize empty buffer, indicates a successfull initializing
+					else
+						@buffer = source
+			### DEBUG  DEBUG  DEBUG  RAW STREAM                            ###############
+			#  if uncommented, the raw-input from the tws is included in the logging
+		  #		  puts "BUFFER :> #{buffer.inspect} "
+			### DEBUG  DEBUG  DEBUG  RAW STREAM                            ###############
+						@data = Hash.new
+						self.load
+					end
+				end
+
+				def valid?
+					@buffer.empty? 
+				end
+
+				## more recent messages omit the transmission of a version
+				## thus just load the parameter-map 
+				def simple_load
+					load_map *self.class.data_map
+				rescue IB::Error  => e
+					error "Reading #{self.class}: #{e.class}: #{e.message}", :load, e.backtrace
+				end
+				# Every message loads received message version first
+				# Override the load method in your subclass to do actual reading into @data.
+				def load
+					unless self.class.version.zero?
+						@data[:version] = buffer.read_int
+						check_version @data[:version], self.class.version
+					end
+					simple_load
+				end
+
+				# Load @data from the buffer according to the given data map.
+				#
+				# map is a series of Arrays in the format of
+				#   [ :name, :type ], [  :group, :name, :type]
+				# type identifiers must have a corresponding read_type method on the buffer-class (read_int, etc.).
+				# group is used to lump together aggregates, such as Contract or Order fields
+				def load_map(*map)
+					map.each do |instruction|
+						# We determine the function of the first element
+						head = instruction.first
+						case head
+						when Integer # >= Version condition: [ min_version, [map]]
+							load_map *instruction.drop(1) if version >= head
+
+						when Proc # Callable condition: [ condition, [map]]
+							load_map *instruction.drop(1) if head.call
+
+						when true # Pre-condition already succeeded!
+							load_map *instruction.drop(1)
+
+						when nil, false # Pre-condition already failed! Do nothing...
+
+						when Symbol # Normal map
+							group, name, type, block =
+								if  instruction[2].nil? || instruction[2].is_a?(Proc)  # lambda's are Proc's 
+									[nil] + instruction # No group, [ :name, :type, (:block) ]
+								else
+									instruction # [ :group, :name, :type, (:block)]
+								end
+							begin
+								data = @buffer.__send__("read_#{type}", &block)
+							rescue IB::LoadError, NoMethodError => e
+								error "Reading #{self.class}: #{e.class}: #{e.message}  --> Instruction: #{name}" , :reader, false 
+							end
+							# debug	      puts data.inspect
+							if group
+								@data[group] ||= {}
+								@data[group][name] = data
+							else
+								@data[name] = data    
+							end
+						else
+							error "Unrecognized instruction #{instruction}"
+						end
+					end
+				end
+
+			end # class AbstractMessage
+		end # module Incoming
+	end # module Messages
+end # module IB

data/lib/ib/messages/incoming/account_value.rb

@@ -0,0 +1,78 @@
+module IB
+  module Messages
+		module Incoming
+
+      AccountUpdateTime = def_message 8, [:time_stamp, :string]
+
+      ManagedAccounts =
+          def_message 15, [:accounts_list, :string]
+
+			class ManagedAccounts
+				def accounts
+					accounts_list.split(',').map{|a| Account.new account: a}
+				end
+
+				def to_human
+					"< ManagedAccounts: #{accounts.map(&:account).join(" - ")}>"
+				end
+			end
+
+      # Receives previously requested FA configuration information from TWS.
+      ReceiveFA =
+          def_message 16, [:type, :int], # type of Financial Advisor configuration data
+                      #                    being received from TWS. Valid values include:
+                      #                    1 = GROUPS, 2 = PROFILE, 3 = ACCOUNT ALIASES
+                      [:xml, :xml] # XML string with requested FA configuration information.
+
+				class ReceiveFA
+					def accounts
+						xml[:ListOfAccountAliases][:AccountAlias].map{|x| Account.new x }
+					end
+
+					def to_human
+						"<FA: #{accounts.map(&:to_human).join(" - ")}>"
+					end
+				end
+
+
+
+			class AccountMessage < AbstractMessage
+        def account_value
+          @account_value = IB::AccountValue.new @data[:account_value]
+        end
+				def account_name
+					@account_name =  @data[:account]
+				end
+
+				def to_human
+        "<AccountValue: #{account_name}, #{account_value}"  
+				end
+			end
+			AccountSummary = def_message(63, AccountMessage,
+																	 [:request_id, :int],
+																	[ :account, :string ],
+																	[:account_value, :key, :symbol],
+																	[:account_value, :value, :string],
+																	[:account_value, :currency, :string]
+																	)
+			AccountSummaryEnd = def_message(64)
+
+			AccountValue = def_message([6, 2], AccountMessage,
+																 [:account_value, :key, :symbol],
+																 [:account_value, :value, :string],
+																 [:account_value, :currency, :string],
+																 [:account, :string]) 
+
+
+			AccountUpdatesMulti =  def_message( 73,
+																[ :request_id, :int ],
+																[ :account , :string ],
+																[ :model, :string ],
+																[ :key		,  :string ],
+																[ :value ,	 :decimal],
+																[ :currency, :string ])
+
+					AccountUpdatesMultiEnd =  def_message 74
+    end # module Incoming
+  end # module Messages
+end # module IB

data/lib/ib/messages/incoming/alert.rb

@@ -0,0 +1,34 @@
+module IB
+  module Messages
+    module Incoming
+
+      # Called Error in Java code, but in fact this type of messages also
+      # deliver system alerts and additional (non-error) info from TWS.
+      ErrorMessage = Error = Alert = def_message([4, 2],
+                                                 [:error_id, :int],
+                                                 [:code, :int],
+                                                 [:message, :string])
+      class Alert
+        # Is it an Error message?
+        def error?
+          code < 1000
+        end
+
+        # Is it a System message?
+        def system?
+          code > 1000 && code < 2000
+        end
+
+        # Is it a Warning message?
+        def warning?
+          code > 2000
+        end
+
+        def to_human
+          "TWS #{ error? ? 'Error' : system? ? 'System' : 'Warning'} #{code}: #{message}"
+        end
+      end # class Alert
+
+    end # module Incoming
+  end # module Messages
+end # module IB

data/lib/ib/messages/incoming/contract_data.rb

@@ -0,0 +1,102 @@
+module IB
+  module Messages
+    module Incoming
+      module ContractAccessors
+
+      end
+
+      ContractDetails = ContractData =
+        def_message([10, [6, 8]],
+                    [:request_id, :int],                          ## request id 
+                    [:contract, :symbol, :string],								## next the major contract-fields
+                    [:contract, :sec_type, :string],							## are transmitted
+                    [:contract, :last_trading_day, :date],				## difference to the array.get_contract
+                    [:contract, :strike, :decimal],								## method: con_id is transmitted
+                    [:contract, :right, :string],									## AFTER the main fields
+                    [:contract, :exchange, :string],							##
+                    [:contract, :currency, :string],							## thus we have to read the fields separately
+                    [:contract, :local_symbol, :string],
+                    [:contract_detail, :market_name, :string],    ## extended
+										[:contract, :trading_class, :string],         ## new Version 8
+                    [:contract, :con_id, :int],
+                    [:contract_detail, :min_tick, :decimal],
+                    [:contract_detail, :md_size_multiplier, :int],
+                    [:contract, :multiplier, :int],
+                    [:contract_detail, :order_types, :string],
+                    [:contract_detail, :valid_exchanges, :string],
+                    [:contract_detail, :price_magnifier, :int],
+                    [:contract_detail, :under_con_id, :int],
+                    [:contract_detail, :long_name, :string],
+                    [:contract, :primary_exchange, :string],
+                    [:contract_detail, :contract_month, :string],
+                    [:contract_detail, :industry, :string],
+                    [:contract_detail, :category, :string],
+                    [:contract_detail, :subcategory, :string],
+                    [:contract_detail, :time_zone, :string],
+                    [:contract_detail, :trading_hours, :string],
+                    [:contract_detail, :liquid_hours, :string],
+                    [:contract_detail, :ev_rule, :decimal],
+                    [:contract_detail, :ev_multipler, :string],
+										[:contract_detail, :sec_id_list,:hash],
+										[:contract_detail, :agg_group, :int ],
+										[:contract_detail, :under_symbol, :string ],
+										[:contract_detail, :under_sec_type, :string ],
+										[:contract_detail, :market_rule_ids, :string ],
+										[:contract_detail, :real_expiration_date, :date ]
+									 )
+#
+#
+      class ContractData
+				using IBSupport   # defines tws-method for Array  (socket.rb)
+        def contract
+          @contract = IB::Contract.build @data[:contract].merge(:contract_detail => contract_detail)
+        end
+
+        def contract_detail
+          @contract_detail = IB::ContractDetail.new @data[:contract_detail]
+        end
+
+        alias contract_details contract_detail
+
+				def to_human
+					"<Contract #{contract.to_human}   #{contract_detail.to_human}>"
+				end
+
+      end # ContractData
+
+      BondContractData =
+        def_message [18, [4, 6]], ContractData,
+        [:request_id, :int],
+        [:contract, :symbol, :string],
+        [:contract, :sec_type, :string],
+        [:contract_detail, :cusip, :string],
+        [:contract_detail, :coupon, :decimal],
+        [:contract_detail, :maturity, :string],
+        [:contract_detail, :issue_date, :string],
+        [:contract_detail, :ratings, :string],
+        [:contract_detail, :bond_type, :string],
+        [:contract_detail, :coupon_type, :string],
+        [:contract_detail, :convertible, :boolean],
+        [:contract_detail, :callable, :boolean],
+        [:contract_detail, :puttable, :boolean],
+        [:contract_detail, :desc_append, :string],
+        [:contract, :exchange, :string],
+        [:contract, :currency, :string],
+        [:contract_detail, :market_name, :string], # extended
+        [:contract_detail, :trading_class, :string],
+        [:contract, :con_id, :int],
+        [:contract_detail, :min_tick, :decimal],
+        [:contract_detail, :order_types, :string],
+        [:contract_detail, :valid_exchanges, :string],
+        [:contract_detail, :valid_next_option_date, :string],
+        [:contract_detail, :valid_next_option_type, :string],
+        [:contract_detail, :valid_next_option_partial, :string],
+        [:contract_detail, :notes, :string],
+        [:contract_detail, :long_name, :string],
+        [:contract_detail, :ev_rule, :decimal],
+        [:contract_detail, :ev_multipler, :string],
+        [:sec_id_list_count, :int]
+
+    end # module Incoming
+  end # module Messages
+end # module IB

data/lib/ib/messages/incoming/delta_neutral_validation.rb

@@ -0,0 +1,23 @@
+module IB
+  module Messages
+    module Incoming
+
+      # The server sends this message upon accepting a Delta-Neutral DN RFQ
+      # - see API Reference p. 26
+      DeltaNeutralValidation = def_message 56,
+                                           [:request_id, :int],
+                                           [:underlying, :con_id, :int],
+                                           [:underlying, :delta, :decimal],
+                                           [:underlying, :price, :decimal]
+      class DeltaNeutralValidation
+        def underlying
+          @underlying = IB::Underlying.new @data[:underlying]
+        end
+
+        alias under_comp underlying
+
+      end # DeltaNeutralValidation
+
+    end # module Incoming
+  end # module Messages
+end # module IB

data/lib/ib/messages/incoming/execution_data.rb

@@ -0,0 +1,50 @@
+module IB
+  module Messages
+    module Incoming
+
+      ExecutionData =
+          def_message [11, 0] , # [8, 9]],
+                      # The reqID that was specified previously in the call to reqExecution()
+                      [:request_id, :int],
+                      [:execution, :local_id, :int],
+                      [:contract, :contract],
+                      [:execution, :exec_id, :string], # Weird format
+                      [:execution, :time, :datetime],
+                      [:execution, :account_name, :string],
+                      [:execution, :exchange, :string],
+                      [:execution, :side, :string],
+                      [:execution, :quantity, :decimal],
+                      [:execution, :price, :decimal],
+                      [:execution, :perm_id, :int],
+                      [:execution, :client_id, :int],
+                      [:execution, :liquidation, :int],
+                      [:execution, :cumulative_quantity, :int],
+                      [:execution, :average_price, :decimal],
+                      [:execution, :order_ref, :string],
+                      [:execution, :ev_rule, :string],
+                      [:execution, :ev_multiplier, :decimal],
+                      [:execution, :model_code, :string],
+                      [:execution, :last_liquidity, :int]
+
+      class ExecutionData
+
+	def load
+	  simple_load
+	end
+
+        def contract
+          @contract = IB::Contract.build @data[:contract]
+        end
+
+        def execution
+          @execution = IB::Execution.new @data[:execution]
+        end
+
+        def to_human
+          "<ExecutionData #{request_id}: #{contract.to_human}, #{execution}>"
+        end
+
+      end # ExecutionData
+    end # module Incoming
+  end # module Messages
+end # module IB

data/lib/ib/messages/incoming/historical_data.rb

@@ -0,0 +1,84 @@
+module IB
+  module Messages
+    module Incoming
+
+      # HistoricalData contains following @data:
+			#
+      # _General_:
+			#
+      # - request_id - The ID of the request to which this is responding
+      # - count - Number of Historical data points returned (size of :results).
+      # - results - an Array of Historical Data Bars
+      # - start_date - beginning of returned Historical data period
+      # - end_date   - end of returned Historical data period
+      # 
+			# Each returned Bar in @data[:results] Array contains this data:
+      # - date - The date-time stamp of the start of the bar. The format is set to sec since EPOCHE
+      #                                                       in outgoing/bar_requests  ReqHistoricalData.
+      # - open -  The bar opening price.
+      # - high -  The high price during the time covered by the bar.
+      # - low -   The low price during the time covered by the bar.
+      # - close - The bar closing price.
+      # - volume - The volume during the time covered by the bar.
+      # - trades - When TRADES historical data is returned, represents number of trades
+      #   that occurred during the time period the bar covers
+      # - wap - The weighted average price during the time covered by the bar.
+
+
+      HistoricalData = def_message [17,0],
+                                   [:request_id, :int],
+                                   [:start_date, :datetime],
+                                   [:end_date, :datetime],
+                                   [:count, :int]
+      class HistoricalData
+        attr_accessor :results
+				using IBSupport  # extended Array-Class  from abstract_message
+ 
+        def load
+          super
+
+          @results = Array.new(@data[:count]) do |_|
+            IB::Bar.new :time => buffer.read_int_date, # conversion of epoche-time-integer to Dateime
+																											 # requires format_date in request to be "2"
+																											 # (outgoing/bar_requests # RequestHistoricalData#Encoding)
+                        :open => buffer.read_decimal,
+                        :high => buffer.read_decimal,
+                        :low => buffer.read_decimal,
+                        :close => buffer.read_decimal,
+                        :volume => buffer.read_int,
+                        :wap => buffer.read_decimal,   
+#                        :has_gaps => buffer.read_string,  # only in ServerVersion  < 124
+                        :trades => buffer.read_int  
+          end
+        end
+
+        def to_human
+          "<HistoricalData: #{request_id}, #{count} items, #{start_date} to #{end_date}>"
+        end
+      end # HistoricalData
+
+
+				HistogramData  = def_message( [89,0], 
+																	[:request_id, :int], 
+																	[ :number_of_points , :int ]) do
+																		# to human
+          "<HistogramData: #{request_id}, #{number_of_points} read>"
+																	end
+
+      class HistogramData
+        attr_accessor :results
+				using IBSupport  # extended Array-Class  from abstract_message
+ 
+        def load
+          super
+
+          @results = Array.new(@data[:number_of_points]) do |_|
+						{ price:  buffer.read_decimal, 
+						 count: buffer.read_int }
+					end
+				end
+			end
+
+    end # module Incoming
+  end # module Messages
+end # module IB