ib-extensions 1.0 → 1.1

data/lib/ib/gateway/account-infos.rb

@@ -30,7 +30,6 @@ raises an IB::Error if less then 100 items are recieved-
 =end
 	def get_account_data  *accounts,  watchlists: []
 
-		logger.progname = 'Gateway#get_account_data'
 
 		@account_data_subscription ||=   subscribe_account_updates
 
@@ -106,7 +105,7 @@ raises an IB::Error if less then 100 items are recieved-
 #								.portfolio_values
 #								.update_or_create( msg.portfolio_value ) { :account } 
 						logger.debug { "#{ account.account } :: #{ msg.contract.to_human }" }
-					end # case
+        end # case
 			end # account_data 
 		end # subscribe
 	end  # def 

data/lib/ib/gateway/order-handling.rb

@@ -4,109 +4,105 @@ module OrderHandling
 UpdateOrderDependingObject
 
 Generic method which enables operations on the order-Object,
-which is associated to OrderState-, Execution-, CommissionReport- 
+which is associated to OrderState-, Execution-, CommissionReport-
 events fired by the tws.
 The order is identified by local_id and perm_id
 
 Everything is carried out in a mutex-synchonized environment
 =end
-	def update_order_dependent_object order_dependent_object  # :nodoc:
-		  account_data  do  | a | 
-			order = if order_dependent_object.local_id.present?
-								a.locate_order( :local_id => order_dependent_object.local_id)
-							else
-								a.locate_order( :perm_id => order_dependent_object.perm_id)
-							end
-			yield order if order.present?
-		end 
-	end
-	def initialize_order_handling
-		tws.subscribe( :CommissionReport, :ExecutionData, :OrderStatus, :OpenOrder, :OpenOrderEnd, :NextValidId ) do |msg| 
-			logger.progname = 'Gateway#order_handling'
-			case msg
-
-			when IB::Messages::Incoming::CommissionReport
-				# Commission-Reports are not assigned to a order -  
-				logger.info "CommissionReport -------#{msg.exec_id} :...:C: #{msg.commission} :...:P/L: #{msg.realized_pnl}-"
-			when IB::Messages::Incoming::OrderStatus
-
-				# The order-state only links via local_id and perm_id to orders.
-				# There is no reference to a contract or an account
-
-				success= update_order_dependent_object( msg.order_state) do |o|
-					o.order_states.update_or_create msg.order_state, :status 
-				end
-
-				logger.info {  "Order State not assigned-- #{msg.order_state.to_human} ----------" } if success.nil?
-
-			when IB::Messages::Incoming::OpenOrder
-				## todo --> handling of bags --> no con_id
-				account_data(msg.order.account) do | this_account |
-					# first update the contracts
-					# make open order equal to IB::Spreads (include negativ con_id)
-					msg.contract[:con_id] = -msg.contract.combo_legs.map{|y| y.con_id}.sum  if msg.contract.is_a? IB::Bag
-					msg.contract.orders.update_or_create msg.order, :local_id
-					this_account.contracts.first_or_create msg.contract, :con_id
-					# now save the order-record
-					msg.order.contract = msg.contract
-					this_account.orders.update_or_create msg.order, :local_id
-				end
-
-				#     update_ib_order msg  ## aus support 
-			when  IB::Messages::Incoming::OpenOrderEnd
-				#             exitcondition=true
-				logger.debug { "OpenOrderEnd" }
-
-			when IB::Messages::Incoming::ExecutionData
-				# Excution-Data are fired independly from order-states.
-				# The Objects are stored at the associated order
-				success= update_order_dependent_object( msg.execution) do |o|
-					logger.progname = 'Gateway#order_handling::ExecutionData '
-					o.executions << msg.execution 
-					if  msg.execution.cumulative_quantity.to_i == o.total_quantity.abs
-						logger.info{ "#{o.account} --> #{o.contract.symbol}: Execution completed" }
-						o.order_states.first_or_create(  IB::OrderState.new( perm_id: o.perm_id, local_id: o.local_id,
-
-																																status: 'Filled' ),  :status )
-						# update portfoliovalue
-						a = @accounts.detect{|x| x.account == o.account } #  we are in a mutex controlled environment
-						pv =  a.portfolio_values.detect{|y| y.contract.con_id == o.contract.con_id}
-						change =  o.action == :sell ? -o.total_quantity : o.total_quantity
-						if pv.present?
-							pv.update_attribute :position,  pv.position + change
-						else
-							a.portfolio_values << IB::PortfolioValue.new( position: change, contract: o.contract)
-						end
-					else
-						logger.debug{ "#{o.account} --> #{o.contract.symbol}: Execution not completed (#{msg.execution.cumulative_quantity.to_i}/#{o.total_quantity.abs})" }
-					end  # branch
-				end # block
-
-				logger.error {  "Execution-Record not assigned-- #{msg.execution.to_human} ----------" } if success.nil?
-
-			end  # case msg.code
-		end # do
-	end # def subscribe
-
-# Resets the order-array for each account first.
-# Requests all open (eg. pending)  orders from the tws 
-#
-# Waits until the OpenOrderEnd-Message is recieved
-
-
-	def request_open_orders
-
-		exit_condition = false
-		subscription = tws.subscribe(  :OpenOrderEnd ){ exit_condition = true }
-		account_data{| account | account.orders=[] }
-		send_message :RequestAllOpenOrders
-		Timeout::timeout(1, IB::TransmissionError,"OpenOrders not received" ) do
-			loop{  sleep 0.1; break if exit_condition  }
-		end
-		tws.unsubscribe subscription
-	end
-
-	alias update_orders request_open_orders 
+  def update_order_dependent_object order_dependent_object  # :nodoc:
+    account_data  do  | a | 
+      order = if order_dependent_object.local_id.present?
+                a.locate_order( :local_id => order_dependent_object.local_id)
+              else
+                a.locate_order( :perm_id => order_dependent_object.perm_id)
+              end
+      yield order if order.present?
+    end
+  end
+  def initialize_order_handling
+    tws.subscribe( :CommissionReport, :ExecutionData, :OrderStatus, :OpenOrder, :OpenOrderEnd, :NextValidId ) do |msg| 
+      case msg
+
+      when IB::Messages::Incoming::CommissionReport
+        # Commission-Reports are not assigned to a order -
+        logger.info "CommissionReport -------#{msg.exec_id} :...:C: #{msg.commission} :...:P/L: #{msg.realized_pnl}-"
+      when IB::Messages::Incoming::OrderStatus
+
+        # The order-state only links via local_id and perm_id to orders.
+        # There is no reference to a contract or an account
+
+        success = update_order_dependent_object( msg.order_state) do |o|
+          o.order_states.update_or_create msg.order_state, :status
+        end
+
+        logger.info {  "Order State not assigned-- #{msg.order_state.to_human} ----------" } if success.nil?
+
+      when IB::Messages::Incoming::OpenOrder
+        ## todo --> handling of bags --> no con_id
+        account_data(msg.order.account) do | this_account |
+          # first update the contracts
+          # make open order equal to IB::Spreads (include negativ con_id)
+          msg.contract[:con_id] = -msg.contract.combo_legs.map{|y| y.con_id}.sum  if msg.contract.is_a? IB::Bag
+          msg.contract.orders.update_or_create msg.order, :local_id
+          this_account.contracts.first_or_create msg.contract, :con_id
+          # now save the order-record
+          msg.order.contract = msg.contract
+          this_account.orders.update_or_create msg.order, :local_id
+        end
+
+        #     update_ib_order msg  ## aus support
+      when IB::Messages::Incoming::OpenOrderEnd
+        #             exitcondition=true
+        logger.debug { "OpenOrderEnd" }
+
+      when IB::Messages::Incoming::ExecutionData
+        # Excution-Data are fired independly from order-states.
+        # The Objects are stored at the associated order
+        success = update_order_dependent_object( msg.execution) do |o|
+          o.executions << msg.execution
+          if msg.execution.cumulative_quantity.to_i == o.total_quantity.abs
+            logger.info{ "#{o.account} --> #{o.contract.symbol}: Execution completed" }
+            o.order_states.first_or_create( IB::OrderState.new( perm_id: o.perm_id, local_id: o.local_id,
+
+                                                                status: 'Filled' ), :status )
+            # update portfoliovalue
+            a = @accounts.detect{ | x | x.account == o.account } #  we are in a mutex controlled environment
+            pv = a.portfolio_values.detect{ | y | y.contract.con_id == o.contract.con_id}
+            change = o.action == :sell ? -o.total_quantity : o.total_quantity
+            if pv.present?
+              pv.update_attribute :position, pv.position + change
+            else
+              a.portfolio_values << IB::PortfolioValue.new( position: change, contract: o.contract )
+            end
+          else
+            logger.debug{ "#{o.account} --> #{o.contract.symbol}: Execution not completed (#{msg.execution.cumulative_quantity.to_i}/#{o.total_quantity.abs})" }
+          end  # branch
+        end # block
+
+        logger.error { "Execution-Record not assigned-- #{msg.execution.to_human} ----------" } if success.nil?
+
+      end  # case msg.code
+    end # do
+  end # def subscribe
+
+  # Resets the order-array for each account first.
+  # Requests all open (eg. pending)  orders from the tws
+  #
+  # Waits until the OpenOrderEnd-Message is recieved
+
+
+  def request_open_orders
+
+    exit_condition = false
+    subscription = tws.subscribe( :OpenOrderEnd ) { exit_condition = true }
+    account_data{| account | account.orders = [] }
+    send_message :RequestAllOpenOrders
+    i=0; loop{ i+=1; sleep 0.01;  break if i > 1000 || exit_condition }
+    tws.unsubscribe subscription
+  end
+
+  alias update_orders request_open_orders 
 
 
 
@@ -119,32 +115,31 @@ end # module
 
 module IB
 
-	class Order
-		def auto_adjust
-			# lambda to perform the calculation
-		adjust_price = ->(a,b) do
-			a=BigDecimal(a,5) 
-			b=BigDecimal(b,5) 
-			_,o =a.divmod(b)
-			a-o 
-		end
-		# adjust_price[2.6896, 0.1].to_f     => 2.6 
-		# adjust_price[2.0896, 0.05].to_f    => 2.05 
-		# adjust_price[2.0896, 0.002].to_f   => 2.088 
-
-
-		error "No Contract provided to Auto adjust " unless contract.is_a? IB::Contract
-		unless contract.is_a? IB::Bag
-			# ensure that contract_details are present
-			
-			contract.verify do |the_contract | 
-				the_details =  the_contract.contract_detail.presence || the_contract.verify.first.contract_detail
-				# there are two attributes to consider: limit_price and aux_price
-				# limit_price +  aux_price may be nil or an empty string. Then ".to_f.zero?" becomes true 
-				self.limit_price= adjust_price.call(limit_price.to_f, the_details.min_tick) unless limit_price.to_f.zero?
-				self.aux_price= adjust_price.call(aux_price.to_f, the_details.min_tick) unless aux_price.to_f.zero?
-			end
-		end
-	end
-end  # class Order
+  class Order
+    def auto_adjust
+      # lambda to perform the calculation
+      adjust_price = ->(a,b) do
+        a = BigDecimal( a, 5 ) 
+        b = BigDecimal( b, 5 ) 
+        _,o = a.divmod(b)
+        a - o
+      end
+      # adjust_price[2.6896, 0.1].to_f     => 2.6
+      # adjust_price[2.0896, 0.05].to_f    => 2.05
+      # adjust_price[2.0896, 0.002].to_f   => 2.088
+
+
+      error "No Contract provided to Auto adjust" unless contract.is_a? IB::Contract
+
+      unless contract.is_a? IB::Bag
+        # ensure that contract_details are present
+
+        the_details = contract.contract_detail.present? ? contract.contract_detail : contract.verify.first.contract_detail
+          # there are two attributes to consider: limit_price and aux_price
+          # limit_price +  aux_price may be nil or an empty string. Then ".to_f.zero?" becomes true 
+          self.limit_price= adjust_price.call(limit_price.to_f, the_details.min_tick) unless limit_price.to_f.zero?
+          self.aux_price= adjust_price.call(aux_price.to_f, the_details.min_tick) unless aux_price.to_f.zero?
+      end
+    end
+  end  # class Order
 end  # module

data/lib/ib/market-price.rb

@@ -65,7 +65,7 @@ module IB
 				#and cancel subscriptions to the message handler
 				# method returns the (running) thread
 				th = Thread.new do
-					finalize, raise_delay_alert = false, false
+ 					finalize, raise_delay_alert = false, false
 					s_id = tws.subscribe(:TickSnapshotEnd){|x| finalize = true if x.ticker_id == the_id }
 
 				e_id = tws.subscribe(:Alert){|x| raise_delay_alert = true if x.code == 354 && x.error_id == the_id } 
@@ -77,7 +77,7 @@ module IB
 						[last,close,bid,ask].each do |x| 
 							tickdata[x] = msg.the_data[:price] if x.include?( IB::TICK_TYPES[ msg.the_data[:tick_type]]) 
 							#  fast exit condition
-							finalize = true if tickdata.size ==4  || ( tickdata[bid].present? && tickdata[ask].present? )  
+							finalize = true if tickdata.size >= 4  || ( tickdata[bid].present? && tickdata[ask].present? )  
 						end if  msg.ticker_id == the_id 
 					end
 					# initialize »the_id« that is used to identify the received tick messages

data/lib/ib/models/account.rb

@@ -1,11 +1,11 @@
 module IB
 
-	class Account 
+	class Account
 
 
 		def account_data_scan search_key, search_currency=nil
 			if account_values.is_a? Array
-				if search_currency.present? 
+				if search_currency.present?
 					account_values.find_all{|x| x.key.match( search_key )  && x.currency == search_currency.upcase }
 				else
 					account_values.find_all{|x| x.key.match( search_key ) }
@@ -24,8 +24,8 @@ module IB
 
 =begin rdoc
 given any key of local_id, perm_id or order_ref
-and an optional status, which can be a string or a 
-regexp ( status: /mitted/ matches Submitted and Presubmitted) 
+and an optional status, which can be a string or a
+regexp ( status: /mitted/ matches Submitted and Presubmitted)
 the last associated Orderrecord is returned.
 
 Thus if several Orders are placed with the same order_ref, the active one is returned
@@ -33,16 +33,23 @@ Thus if several Orders are placed with the same order_ref, the active one is ret
 (If multible keys are specified, local_id preceeds perm_id)
 
 =end
-		def locate_order local_id: nil, perm_id: nil, order_ref: nil, status: /ubmitted/, con_id: nil
+		def locate_order local_id: nil, perm_id: nil, order_ref: nil, status: /ubmitted/, contract: nil, con_id: nil
 			search_option= [ local_id.present? ? [:local_id , local_id] : nil ,
 										perm_id.present? ? [:perm_id, perm_id] : nil,
 										order_ref.present? ? [:order_ref , order_ref ] : nil ].compact.first
-			matched_items = if search_option.nil? 
-												orders 
-											else 
+			matched_items = if search_option.nil?
+												orders
+											else
 												orders.find_all{|x| x[search_option.first].to_i == search_option.last.to_i }
 											end
-			matched_items = matched_items.find_all{|x| x.contract.con_id == con_id } if con_id.present?
+      if contract.present?
+        if contract.con_id.nil? || contract.con_id =="" || contract.con_id.zero? 
+          contract =  contract.verify.first unless contract.is_a? IB::Bag
+        end
+        matched_items = matched_items.find_all{|o| o.contract.essential == contract.essential } 
+      elsif con_id.present?
+        matched_items = matched_items.find_all{|o| o.contract.con_id == con_id } 
+      end
 
 			if status.present?
 				status = Regexp.new(status) unless status.is_a? Regexp
@@ -53,8 +60,8 @@ Thus if several Orders are placed with the same order_ref, the active one is ret
 		end
 
 
-=begin rdoc 
-requires an IB::Order as parameter. 
+=begin rdoc
+requires an IB::Order as parameter.
 
 If attached, the associated IB::Contract is used to specify the tws-command
 
@@ -65,9 +72,9 @@ auto_adjust: Limit- and Aux-Prices are adjusted to Min-Tick
 convert_size: The action-attribute (:buy  :sell) is associated according the content of :total_quantity.
 
 
-The parameter «order» is modified! 
+The parameter «order» is modified!
 
-It can be used to modify and eventually cancel 
+It can be used to modify and eventually cancel
 
 The method raises an  IB::TransmissionError if the transmitted order ist not acknowledged by the tws after
 one second.
@@ -79,23 +86,23 @@ Example
    g =  IB::Gateway.current.clients.last
 
 	 g.preview contract: j36, order: order
-      => {:init_margin=>0.10864874e6, 
-			    :maint_margin=>0.9704137e5, 
-					:equity_with_loan=>0.97877973e6, 
-					:commission=>0.524e1, 
-					:commission_currency=>"USD", 
+      => {:init_margin=>0.10864874e6,
+			    :maint_margin=>0.9704137e5,
+					:equity_with_loan=>0.97877973e6,
+					:commission=>0.524e1,
+					:commission_currency=>"USD",
 					:warning=>""}
 
    the_local_id = g.place order: order
 		  => 67						# returns local_id
-	 order.contract			# updated contract-record 
-      => #<IB::Contract:0x00000000013c94b0 @attributes={:con_id=>95346693, 
-			                                                   :exchange=>"SGX", 
-																												 :right=>"", 
-																												 :include_expired=>false}> 
+	 order.contract			# updated contract-record
+      => #<IB::Contract:0x00000000013c94b0 @attributes={:con_id=>95346693,
+			                                                   :exchange=>"SGX",
+																												 :right=>"",
+																												 :include_expired=>false}>
 
 		order.limit_price = 65   # set new price
-	  g.modify order: order    # and transmit 
+	  g.modify order: order    # and transmit
 		  => 67 # returns local_id
 
 		g.locate_order( local_id: the_local_id  )
@@ -103,18 +110,24 @@ Example
 
 		g.cancel order: order
 				# logger output: 05:17:11 Cancelling 65 New #250/ from 3000/DU167349>
-	 
 =end
 
-		def place_order  order:, contract: nil, auto_adjust: true, convert_size:  false
+		def place_order  order:, contract: nil, auto_adjust: true, convert_size:  false,  enable_error: false
 			# adjust the orderprice to  min-tick
-			logger.progname =  'Account#PlaceOrder' 
 			result = ->(l){ orders.detect{|x| x.local_id == l  && x.submitted? } }
 			#·IB::Symbols are always qualified. They carry a description-field
-			qualified_contract = ->(c) { c.description.present? || (c.con_id.present?  &&  !c.con_id.to_i.zero?) || 
-																c.con_id <0  && c.sec_type == :bag  }
-			order.contract = contract.verify.first if contract.present? && order.contract.nil? 
-
+      qualified_contract = ->(c) { c.is_a?(IB::Contract) && ( c.description.present? || (c.con_id.present?  &&  !c.con_id.to_i.zero?) || (c.con_id.to_i <0  && c.sec_type == :bag )) }
+
+			order.contract ||=  if qualified_contract[ contract ]
+                        contract
+                         else
+                           contract.verify.first
+                         end
+
+      if order.contract.nil?
+       error "No valid contract given" if enable_error
+       return 0
+      end 
 			## sending of plain vanilla IB::Bags will fail using account.place, unless a (negative) con-id is provided!
 #			error "place order: ContractVerification failed. No con_id assigned"  unless qualified_contract[order.contract]
 			ib = IB::Connection.current
@@ -122,46 +135,41 @@ Example
 			the_local_id =  nil
 
 			### Handle Error messages
-			### Default action:  display error in log and return nil
+			### Default action:  raise IB::Transmission Error
 			sa = ib.subscribe( :Alert ) do | msg |
+  #      puts "local_id: #{the_local_id}"
 				if msg.error_id == the_local_id
-				 if [ 110, #  The price does not conform to the minimum price variation for this contract
+				 if [ 110, #  The price does not confirm to the minimum price variation for this contract
 					   388,  # Order size x is smaller than the minimum required size of yy.
 					  ].include? msg.code
-					 wrong_order =  msg.error_id.to_i  
+           error msg.message if enable_error
+           wrong_order =  msg.error_id.to_i
 					 ib.logger.error msg.message
 				 end
 				end
 			end
 			order.account =  account  # assign the account_id to the account-field of IB::Order
-			if qualified_contract[order.contract]
-				self.orders.update_or_create order, :order_ref
-				order.auto_adjust # if auto_adjust  /defined in lib/order_handling
-			end
-			if convert_size 
-			 	order.action = order.total_quantity.to_i > 0  ? 	:buy : :sell 
+      self.orders.update_or_create order, :order_ref
+      order.auto_adjust # if auto_adjust  /defined in lib/order_handling
+			if convert_size
+				order.action = order.total_quantity.to_i > 0  ?	:buy : :sell
+        logger.info{ "Converted ordesize to #{order.total_quantity} and triggered a #{order.action}  order"} if  order.total_quantity.to_i < 0
 				order.total_quantity  = order.total_quantity.to_i.abs
 			end
 				# apply non_guarenteed and other stuff bound to the contract to order.
 			order.attributes.merge! order.contract.order_requirements unless order.contract.order_requirements.blank?
 				#  con_id and exchange fully qualify a contract, no need to transmit other data
-			the_contract = order.contract.con_id >0 ? Contract.new( con_id: order.contract.con_id, exchange: order.contract.exchange) : nil 
+			the_contract = order.contract.con_id >0 ? Contract.new( con_id: order.contract.con_id, exchange: order.contract.exchange) : nil
 			the_local_id = order.place the_contract # return the local_id
-			Timeout::timeout(1, IB::TransmissionError,"TimeOut ::Transmitted Order was not acknowledged") do 
-				loop{ sleep(0.001); break if locate_order( local_id: the_local_id, status: nil ).present? }
-			end
+      i=0;	loop{i+=1; sleep(0.01); break if locate_order( local_id: the_local_id, status: nil ).present? || i> 1000  }
 
 			ib.unsubscribe sa
-
-			if wrong_order.nil?
-				the_local_id  # return_value
-			else
-				nil
-			end
-		end # place 
+      raise IB::TransmissionError," #{order.to_human} is not transmitted properly" if i >=1000
+      the_local_id  # return_value
+		end # place
 
 		# shortcut to enable
-		#  account.place order: {} , contract: {} 
+		#  account.place order: {} , contract: {}
 		#  account.preview order: {} , contract: {}
 		#  account.modify order: {}
 		alias place place_order
@@ -171,7 +179,7 @@ Account#ModifyOrder operates in two modi:
 
 First: The order is specified  via local_id, perm_id or order_ref.
 	It is checked, whether the order is still modificable.
-	Then the Order ist provided through  the block. Any modification is done there. 
+	Then the Order ist provided through  the block. Any modification is done there.
 	Important: The Block has to return the modified IB::Order
 
 Second: The order can be provided as parameter as well. This will be used
@@ -185,7 +193,6 @@ This has to be done manualy in the provided block
 		def modify_order  local_id: nil, order_ref: nil, order:nil
 
 			result = ->(l){ orders.detect{|x| x.local_id == l  && x.submitted? } }
-			logger.tap{ |l| l.progname = "Account #{account}#modify_order"}
 			order ||= locate_order( local_id: local_id, 
 														 status: /ubmitted/ ,
 														 order_ref: order_ref ) 
@@ -214,9 +221,9 @@ This has to be done manualy in the provided block
 		order.what_if = true
 		the_local_id = place_order order: order, contract: contract
 		i=0; loop{ i= i+1;  break if result[the_local_id] || i > 1000; sleep 0.01 }
-		raise IB::TransmissionError,"(Preview-)Order is not transmitted properly" if i >=1000
+    raise IB::TransmissionError,"(Preview-) #{order.to_human} is not transmitted properly" if i >=1000
 		order.what_if = false # reset what_if flag
-		order.local_id = nil  # reset local_id to enable reusage of the order-object for placing
+		order.local_id = nil  # reset local_id to enable re-using the order-object for placing
 		result[the_local_id].order_state.forcast  #  return_value
 	end