ib-api 972.0

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

@@ -0,0 +1,44 @@
+module IB
+  module Messages
+    module Incoming
+
+      MarketDepth =
+          def_message 12, [:request_id, :int],
+                      [:position, :int], # The row Id of this market depth entry.
+                      [:operation, :int], # How it should be applied to the market depth:
+                      #   0 = insert this new order into the row identified by :position
+                      #   1 = update the existing order in the row identified by :position
+                      #   2 = delete the existing order at the row identified by :position
+                      [:side, :int], # side of the book: 0 = ask, 1 = bid
+                      [:price, :decimal],
+                      [:size, :int]
+
+      class MarketDepth
+        def side
+          @data[:side] == 0 ? :ask : :bid
+        end
+
+        def operation
+          @data[:operation] == 0 ? :insert : @data[:operation] == 1 ? :update : :delete
+        end
+
+        def to_human
+          "<#{self.message_type}: #{operation} #{side} @ "+
+              "#{position} = #{price} x #{size}>"
+        end
+      end
+
+      MarketDepthL2 =
+          def_message 13, MarketDepth, # Fields descriptions - see above
+                      [:request_id, :int],
+                      [:position, :int],
+                      [:market_maker, :string], # The exchange hosting this order.
+                      [:operation, :int],
+                      [:side, :int],
+                      [:price, :decimal],
+                      [:size, :int]
+
+
+    end # module Incoming
+  end # module Messages
+end # module IB

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

@@ -0,0 +1,18 @@
+module IB
+  module Messages
+    module Incoming
+
+      # This message is always sent by TWS automatically at connect.
+      # The IB::Connection class subscribes to it automatically and stores
+      # the order id in its @next_local_id attribute.
+      NextValidID = NextValidId = def_message(9, [:local_id, :int])
+
+      class NextValidId
+
+        # Legacy accessor
+        alias order_id local_id
+
+      end # class NextValidId
+    end # module Incoming
+  end # module Messages
+end # module IB

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

@@ -0,0 +1,277 @@
+module IB
+  module Messages
+    module Incoming
+      using IBSupport
+      # OpenOrder is the longest message with complex processing logics
+      OpenOrder =
+          def_message [5, 34],		# updated to v. 34 according to python (decoder.py processOpenOrder)
+                      [:order, :local_id, :int],
+
+                      [:contract, :contract], # read standard-contract 
+											# [ con_id, symbol,. sec_type, expiry, strike, right, multiplier,
+											# 	exchange, currency, local_symbol, trading_class ] 
+
+                      [:order, :action, :string],
+                      [:order, :total_quantity, :decimal],
+                      [:order, :order_type, :string],
+                      [:order, :limit_price, :decimal],
+                      [:order, :aux_price, :decimal],
+                      [:order, :tif, :string],
+                      [:order, :oca_group, :string],
+                      [:order, :account, :string],
+                      [:order, :open_close, :string],
+                      [:order, :origin, :int],
+                      [:order, :order_ref, :string],
+                      [:order, :client_id, :int],
+                      [:order, :perm_id, :int],
+                      [:order, :outside_rth, :boolean], # (@socket.read_int == 1)
+                      [:order, :hidden, :boolean], # (@socket.read_int == 1)
+                      [:order, :discretionary_amount, :decimal],
+                      [:order, :good_after_time, :string],
+                      [:shares_allocation, :string], # deprecated! field
+
+                      [:order, :fa_group, :string],
+                      [:order, :fa_method, :string],
+                      [:order, :fa_percentage, :string],
+                      [:order, :fa_profile, :string],
+                      [:order, :model_code, :string],
+                      [:order, :good_till_date, :string],
+                      [:order, :rule_80a, :string],
+                      [:order, :percent_offset, :decimal],
+                      [:order, :settling_firm, :string],
+                      [:order, :short_sale_slot, :int],
+                      [:order, :designated_location, :string],
+                      [:order, :exempt_code, :int],
+                      [:order, :auction_strategy, :int],
+                      [:order, :starting_price, :decimal],
+                      [:order, :stock_ref_price, :decimal],
+                      [:order, :delta, :decimal],
+                      [:order, :stock_range_lower, :decimal],
+                      [:order, :stock_range_upper, :decimal],
+                      [:order, :display_size, :int],
+                      #@order.rth_only = @socket.read_boolean
+                      [:order, :block_order, :boolean],
+                      [:order, :sweep_to_fill, :boolean],
+                      [:order, :all_or_none, :boolean],
+                      [:order, :min_quantity, :int],
+                      [:order, :oca_type, :int],
+                      [:order, :etrade_only, :boolean],
+                      [:order, :firm_quote_only, :boolean],
+                      [:order, :nbbo_price_cap, :decimal],
+                      [:order, :parent_id, :int],
+                      [:order, :trigger_method, :int],
+                      [:order, :volatility, :decimal],
+                      [:order, :volatility_type, :int],
+                      [:order, :delta_neutral_order_type, :string],
+                      [:order, :delta_neutral_aux_price, :decimal]
+
+      class OpenOrder
+
+        # Accessors to make OpenOrder API-compatible with OrderStatus message
+
+        def client_id
+          order.client_id
+        end
+
+        def parent_id
+          order.parent_id
+        end
+
+        def perm_id
+          order.perm_id
+        end
+
+         def local_id
+          order.local_id
+        end
+
+        alias order_id local_id
+
+        def status
+          order.status
+        end
+
+				def conditions
+					order.conditions
+				end
+
+        # Object accessors
+
+        def order
+          @order ||= IB::Order.new @data[:order].merge(:order_state => order_state)
+        end
+
+        def order_state
+          @order_state ||= IB::OrderState.new(
+              @data[:order_state].merge(
+                  :local_id => @data[:order][:local_id],
+                  :perm_id => @data[:order][:perm_id],
+                  :parent_id => @data[:order][:parent_id],
+                  :client_id => @data[:order][:client_id]))
+        end
+
+        def contract
+          @contract ||= IB::Contract.build(
+              @data[:contract].merge(:underlying => underlying)
+          )
+        end
+
+        def underlying
+          @underlying = @data[:underlying_present] ? IB::Underlying.new(@data[:underlying]) : nil
+        end
+
+        alias under_comp underlying
+
+        def load
+          super
+
+#          load_map [proc { | | (@data[:order][:delta_neutral_order_type] != 'None') },
+          load_map [proc { | | filled?(@data[:order][:delta_neutral_order_type]) }, # todo Testcase!
+                      # As of client v.52, we may receive delta... params in openOrder
+                     [:order, :delta_neutral_con_id, :int],
+                     [:order, :delta_neutral_settling_firm, :string],
+                     [:order, :delta_neutral_clearing_account, :string],
+                     [:order, :delta_neutral_clearing_intent, :string],
+                     [:order, :delta_neutral_open_close, :string],
+                     [:order, :delta_neutral_short_sale, :bool],
+		     [:order, :delta_neutral_short_sale_slot, :int],
+		     [:order, :delta_neutral_designated_location, :string] ],  # end proc
+		   [:order, :continuous_update, :int],
+                   [:order, :reference_price_type, :int],
+                   [:order, :trail_stop_price, :decimal],   # not trail-orders. see below
+                   [:order, :trailing_percent, :decimal],
+                   [:order, :basis_points, :decimal],
+                   [:order, :basis_points_type, :int],
+
+                   [:contract, :legs_description, :string],
+
+                   # As of client v.55, we receive in OpenOrder for Combos:
+                   #    Contract.orderComboLegs Array
+                   #    Order.leg_prices Array
+                   [:contract, :combo_legs, :array, proc do |_|
+                     IB::ComboLeg.new :con_id => @buffer.read_int,
+                                      :ratio => @buffer.read_int,
+                                      :action => @buffer.read_string,
+                                      :exchange => @buffer.read_string,
+                                      :open_close => @buffer.read_int,
+                                      :short_sale_slot => @buffer.read_int,
+                                      :designated_location => @buffer.read_string,
+                                      :exempt_code => @buffer.read_int
+                   end],
+                   [:order, :leg_prices, :array, proc { |_| buffer.read_decimal }],   #  needs testing
+                   [:order, :combo_params, :hash ],
+		   #, proc do |_|
+		#		      { tag: buffer.read_string, value: buffer.read_string }  # needs testing
+		 #  end],
+
+                   [:order, :scale_init_level_size, :int],
+                   [:order, :scale_subs_level_size, :int],
+
+                   [:order, :scale_price_increment, :decimal],
+                   [proc { | | filled?(@data[:order][:scale_price_increment]) },
+                     # As of client v.54, we may receive scale order fields
+                     [:order, :scale_price_adjust_value, :decimal],
+                     [:order, :scale_price_adjust_interval, :int],
+                     [:order, :scale_profit_offset, :decimal],
+                     [:order, :scale_auto_reset, :boolean],
+                     [:order, :scale_init_position, :int],
+                     [:order, :scale_init_fill_qty, :decimal],
+                     [:order, :scale_random_percent, :boolean]
+                   ],
+
+                   [:order, :hedge_type, :string],
+                   [proc { | | filled?(@data[:order][:hedge_type]) },
+                     # As of client v.49/50, we can receive hedgeType, hedgeParam
+                     [:order, :hedge_param, :string]
+                  ],
+
+                   [:order, :opt_out_smart_routing, :boolean],
+                   [:order, :clearing_account, :string],
+                   [:order, :clearing_intent, :string],
+                   [:order, :not_held, :boolean],
+
+                   [:underlying_present, :boolean],
+                   [proc { | | filled?(@data[:underlying_present]) },
+                    [:underlying, :con_id, :int],
+                    [:underlying, :delta, :decimal],
+                    [:underlying, :price, :decimal]
+                   ],
+
+                   # TODO: Test Order with algo_params, scale and legs!
+                   [:order, :algo_strategy, :string],
+                   [proc { | | filled?(@data[:order][:algo_strategy]) },
+                    [:order, :algo_params, :hash]  
+                   ],
+                   [:order, :solicided, :boolean],
+                   [:order, :what_if, :boolean],
+		   [:order_state, :status, :string],
+                   # IB uses weird String with Java Double.MAX_VALUE to indicate no value here
+                   [:order_state, :init_margin, :decimal], # :string],
+                   [:order_state, :maint_margin, :decimal], # :string],
+                   [:order_state, :equity_with_loan, :decimal], # :string],
+                   [:order_state, :commission, :decimal], # May be nil!
+                   [:order_state, :min_commission, :decimal], # May be nil!
+                   [:order_state, :max_commission, :decimal], # May be nil!
+                   [:order_state, :commission_currency, :string],
+                   [:order_state, :warning_text, :string],
+
+
+                   [:order, :random_size, :boolean],
+                   [:order, :random_price, :boolean],
+
+		   ## todo: ordertype = PEG BENCH  --  -> test!
+		   [proc{ @data[:order][:order_type] == 'PEG BENCH' },
+		      [:order, :reference_contract_id, :int ],
+		      [:order, :is_pegged_change_amount_decrease, :bool ],
+		      [:order, :pegged_change_amount, :decimal ],
+		      [:order, :reference_change_amount, :decimal ],
+		      [:order, :reference_exchange_id, :string ]
+		   ],
+		    [:order , :conditions, :array, proc {  IB::OrderCondition.make_from( @buffer ) } ],
+				[proc { !@data[:order][:conditions].blank?  },
+						[:order, :conditions_ignore_rth, :bool],
+						[:order, :conditions_cancel_order,:bool]
+					], 
+		    [:order, :adjusted_order_type, :string],
+		    [:order, :trigger_price,  :decimal],
+		    [:order, :trail_stop_price,  :decimal],	    # cpp -source: Traillimit orders 
+		    [:order, :adjusted_stop_limit_price,  :decimal],
+		    [:order, :adjusted_trailing_amount,  :decimal],
+		    [:order, :adjustable_trailing_unit,  :int],
+
+		    [:order, :soft_dollar_tier_name,  :string_not_null],
+		    [:order, :soft_dollar_tier_value, :string_not_null],
+		    [:order, :soft_dollar_tier_display_name,  :string_not_null],
+		    [:order, :cash_qty,  :decimal],
+				[:order, :mifid_2_decision_maker, :string_not_null ],   ## correct appearance of fields below
+				[:order, :mifid_2_decision_algo, :string_not_null ],		##  is not tested yet
+				[:order, :mifid_2_execution_maker, :string ],
+				[:order, :mifid_2_execution_algo, :string_not_null ],
+				[:order, :dont_use_auto_price_for_hedge, :string ],
+				[:order, :is_O_ms_container, :bool ],
+				[ :order, :discretionary_up_to_limit_price, :decimal ]
+
+    
+        end
+
+        # Check if given value was set by TWS to something vaguely "positive"
+        def filled? value
+#	  puts "filled: #{value.class} --> #{value.to_s}"
+          case value
+            when String
+              (!value.empty?)# && (value != :none) && (value !='None')  
+            when Float, Integer, BigDecimal
+              value > 0
+            else
+              !!value # to_bool
+          end
+        end
+
+        def to_human
+          "<OpenOrder: #{contract.to_human} #{order.to_human}>"
+        end
+
+      end # class OpenOrder
+    end # module Incoming
+  end # module Messages
+end # module IB

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

@@ -0,0 +1,85 @@
+module IB
+  module Messages
+    module Incoming
+
+      # :status - Displays the order status. Possible values include:
+      # - PendingSubmit - indicates that you have transmitted the order, but
+      #   have not yet received confirmation that it has been accepted by the
+      #   order destination. NOTE: This order status is NOT sent back by TWS
+      #   and should be explicitly set by YOU when an order is submitted.
+      # - PendingCancel - indicates that you have sent a request to cancel
+      #   the order but have not yet received cancel confirmation from the
+      #   order destination. At this point, your order cancel is not confirmed.
+      #   You may still receive an execution while your cancellation request
+      #   is pending. NOTE: This order status is not sent back by TWS and
+      #   should be explicitly set by YOU when an order is canceled.
+      # - PreSubmitted - indicates that a simulated order type has been
+      #   accepted by the IB system and that this order has yet to be elected.
+      #   The order is held in the IB system until the election criteria are
+      #   met. At that time the order is transmitted to the order destination
+      #   as specified.
+      # - Submitted - indicates that your order has been accepted at the order
+      #   destination and is working.
+      # - Cancelled - indicates that the balance of your order has been
+      #   confirmed canceled by the IB system. This could occur unexpectedly
+      #   when IB or the destination has rejected your order.
+      # - ApiCancelled - canceled via API
+      # - Filled - indicates that the order has been completely filled.
+      # - Inactive - indicates that the order has been accepted by the system
+      #   (simulated orders) or an exchange (native orders) but that currently
+      #   the order is inactive due to system, exchange or other issues.
+      # :why_held - This property contains the comma-separated list of reasons for
+      #      order to be held. For example, when TWS is trying to locate shares for
+      #      a short sell, the value used to indicate this is 'locate'.
+      #      As  of Api 9.72, no version is given anymore
+      #
+      OrderStatus = def_message [3, 0],
+                                [:order_state, :local_id, :int],
+                                [:order_state, :status, :string],
+                                [:order_state, :filled, :decimal],
+                                [:order_state, :remaining, :decimal],
+                                [:order_state, :average_fill_price, :decimal],
+                                [:order_state, :perm_id, :int],
+                                [:order_state, :parent_id, :int],
+                                [:order_state, :last_fill_price, :decimal],
+                                [:order_state, :client_id, :int],
+                                [:order_state, :why_held, :string],
+				[:order_state, :market_cap_price, :decimal] 
+      class OrderStatus
+
+
+        def order_state
+          @order_state ||= IB::OrderState.new @data[:order_state]
+        end
+
+        # Accessors to make OpenOrder and OrderStatus messages API-compatible
+        def client_id
+          order_state.client_id
+        end
+
+        def parent_id
+          order_state.parent_id
+        end
+
+        def perm_id
+          order_state.perm_id
+        end
+
+        def local_id
+          order_state.local_id
+        end
+
+        alias order_id local_id
+
+        def status
+          order_state.status
+        end
+
+        def to_human
+          order_state.to_human
+        end
+
+      end # class OrderStatus
+    end # module Incoming
+  end # module Messages
+end # module IB

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

@@ -0,0 +1,78 @@
+module IB
+  module Messages
+    module Incoming
+
+			class ContractMessage < AbstractMessage
+				def contract
+					@contract = IB::Contract.build @data[:contract]
+				end
+			end
+
+			PortfolioValue = def_message [7, 8], ContractMessage,
+						[:contract, :contract], # read standard-contract 
+						[:portfolio_value, :position, :decimal],  
+						[:portfolio_value,:market_price, :decimal],
+						[:portfolio_value,:market_value, :decimal],
+						[:portfolio_value,:average_cost, :decimal],
+						[:portfolio_value,:unrealized_pnl, :decimal], # May be nil!
+						[:portfolio_value,:realized_pnl, :decimal], #   May be nil!
+						[:account, :string] 
+
+
+				class PortfolioValue
+
+
+					def to_human
+				#	"<PortfolioValue: #{contract.to_human} #{portfolio_value}>"
+						portfolio_value.to_human
+					end
+					
+					def portfolio_value
+						unless @portfolio_value.present?
+							@portfolio_value =  IB::PortfolioValue.new   @data[:portfolio_value] 
+							@portfolio_value.contract = contract
+							@portfolio_value.account =  account
+						end
+						@portfolio_value # return_value
+					end
+
+					def account_name
+						@account_name =  @data[:account]
+					end
+
+#					alias :to_human :portfolio_value 
+				end # PortfolioValue
+
+
+
+			PositionData =
+				def_message( [61,3] , ContractMessage,
+					[:account, :string],
+          [:contract, :contract], # read standard-contract 
+#																	 [ con_id, symbol,. sec_type, expiry, strike, right, multiplier,
+																	 # primary_exchange, currency, local_symbol, trading_class ] 
+          [:position, :decimal],   # changed from int after Server Vers. MIN_SERVER_VER_FRACTIONAL_POSITIONS
+					[:price, :decimal]
+									 ) do 
+#        def to_human
+          "<PositionValue: #{account} ->  #{contract.to_human} ( Amount #{position}) : Market-Price #{price} >"
+        end
+
+			PositionDataEnd = def_message( 62 )
+			PositionsMulti =  def_message( 71, ContractMessage,
+																		[ :request_id, :int ], 
+																		[ :account, :string ],
+																		[:contract, :contract], # read standard-contract 
+          [ :position, :decimal],   # changed from int after Server Vers. MIN_SERVER_VER_FRACTIONAL_POSITIONS
+					[ :average_cost, :decimal],
+					[ :model_code, :string ])
+
+			PositionsMultiEnd =  def_message 72
+	
+					
+
+
+
+    end # module Incoming
+  end # module Messages
+end # module IB