ib-api 10.33.1

data/plugins/ib/advanced-account.rb

@@ -0,0 +1,442 @@
+module IB
+=begin
+
+Plugin that provides helper methods for orders
+
+
+Public API
+==========
+
+Extends IB::Account
+
+=end
+
+  module Advanced
+
+
+    def account_data_scan search_key, search_currency=nil
+        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 ) }
+        end
+    end
+
+
+
+=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)
+the last associated Order-record is returned.
+
+Thus if several Orders are placed with the same order_ref, the active one is returned
+
+(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/, 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  # select all orders of the current account
+            else
+              key,value = search_option
+              orders.find_all{|x| x[key].to_i == value.to_i }
+            end
+
+      if contract.present?
+        if contract.con_id.zero?  && !contract.is_a?( IB::Bag )
+          contract =  contract.verify.first
+        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
+        matched_items.detect{|x| x.order_state.status =~ status }
+      else
+        matched_items.last  # return the last item
+      end
+    end
+
+
+=begin rdoc
+requires an IB::Order as parameter.
+
+If attached, the associated IB::Contract is used to specify the tws-command
+
+The associated Contract overtakes  the specified (as parameter)
+
+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!
+
+It can further used to modify and eventually cancel
+
+
+Example
+
+   j36 =  IB::Stock.new symbol: 'J36', exchange: 'SGX'
+   order =  IB::Limit.order size: 100, price: 65.5
+   g =  IB::Connection.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",
+          :warning=>""
+
+   g.place order: order
+      => 67           # returns local_id
+   order.contract     # updated (and verifired) contract-record
+      => #<IB::Contract:0x00000000013c94b0 @attributes={:con_id=>9534669,
+                                                        :exchange=>"SGX",
+                                                        :right=>"",
+                                                        :include_expired=>false}>
+
+   order.limit_price = 65   # set new price
+   g.modify order: order    # and transmit
+     => 67 # returns local_id
+
+   g.locate_order( local_id: {a number} )
+     => returns the assigned order-record for inspection
+
+   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: true
+    result = ->(l){ orders.detect{|x| x.local_id == l  && x.submitted? } }
+    qualified_contract = ->(c) do
+       c.is_a?(IB::Contract) &&
+    #·IB::Symbols are always qualified. They carry a description-field
+         ( c.description.present? || !c.con_id.to_i.zero? ||
+          (c.con_id.to_i <0  && c.sec_type == :bag ) )   # bags that carry a negative con_id are qualified
+    end
+
+    # assign qualificated contract to the order object if not present
+    order.contract ||= if qualified_contract[ contract ]
+                         contract
+                       else
+                         contract.verify.first
+                       end
+    # disable auto-adjust if min_tick is not available
+    auto_adjust =  false if order.contract.contract_detail.nil?
+
+    error "No valid contract given" unless order.contract.is_a?(IB::Contract)
+
+    ## 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] or contract.nil?
+
+    # declare some variables
+    ib = IB::Connection.current
+    wrong_order = nil
+    the_local_id =  nil
+    q =  Queue.new
+
+    ### Handle Error messages
+    ### Default action:  log message and raise IB::TransmissionError
+    sa = ib.subscribe( :Alert ) do | msg |
+      if msg.error_id == the_local_id
+        wrong_order =  msg.message
+        if msg.code == 110 #  The price does not confirm to the minimum price variation for this contract
+          if auto_adjust
+            wrong_order = nil
+            the_local_id =  -1
+            ib.logger.info "adjusting order-price"
+          else
+            ib.logger.error "The price #{order.limit_price}/ #{order.aux_price} not confirm to the minimum price variation for #{order.contract.to_human}"
+          end
+        elsif [ 201, # Order rejected, No Trading permissions
+            203, # Security is not allowed for trading
+            325, # Discretionary Orders are not supported for this combination of order-type and exchange
+            355, # Order size does not conform to market rule
+            361, 362, 363, 364, # invalid trigger or stop-price
+            388,  # Order size x is smaller than the minimum required size of yy.
+        ].include? msg.code
+          ib.logger.error msg.message
+        end
+          q.close   # closing the queue indicates that no order was transmitted
+      end
+    end
+    # transfer the received openOrder to the queue
+    sb = ib.subscribe( :OpenOrder ){|m| q << m.order if m.order.local_id.to_i == the_local_id.to_i }
+    #  modify order (parameter)
+    order.account =  account  # assign the account_id to the account-field of IB::Order
+    self.orders.save_insert order, :order_ref
+    order.auto_adjust  if ib.plugins.include?( "auto-adjust" ) && auto_adjust
+    if convert_size
+      order.action = order.total_quantity.to_d < 0 ? :sell : :buy unless order.action == :sell
+      logger.info{ "Converted ordersize to #{order.total_quantity} and triggered a #{order.action}  order"} if  order.total_quantity.to_d < 0
+      order.total_quantity  = order.total_quantity.to_d.abs
+    end
+    #  con_id and exchange fully qualify a contract, no need to transmit other data
+    #  if no contract is passed to order.place, order.contract is used for placement
+    #   ... delegated to order#modify...
+#    the_contract = order.contract.con_id.to_i > 0 ? Contract.new( con_id: order.contract.con_id, exchange: order.contract.exchange) : nil
+    contract = order.contract
+    order =  order.then{|x| x.contract = nil; x }
+    loop do
+      the_local_id = ib.place_order order, contract  # return the local_id
+      # if transmit is false, just include the local_id in the order-record
+      Thread.new{  if order.transmit  || order.what_if  then sleep 1 else sleep 0.001 end ;  q.close }
+      tws_answer = q.pop
+
+      adjust_price = ->(p) do
+        if order.action == :sell
+          p + contract.contract_detail.min_tick
+        else
+          p - contract.contract_detail.min_tick
+        end
+      end
+
+      if q.closed?
+        if wrong_order.present?
+          raise IB::SymbolError,  wrong_order
+        elsif the_local_id.present?
+          if the_local_id < 0  # auto-adjust condition
+            order.local_id = nil # reset order record
+            order.aux_price = adjust_price.call( order.aux_price ) unless order.aux_price.to_i.zero?
+            order.limit_price = adjust_price.call( order.limit_price ) unless order.limit_price.to_i.zero?
+          else
+            order.local_id = the_local_id
+          end
+        else
+          error " #{order.to_human} is not transmitted properly", :symbol
+        end
+      else
+        order=tws_answer #  return order-record received from tws
+      end
+      break unless order.local_id.nil?
+      q = Queue.new   # reset queue
+    end
+    order.contract = contract
+    ib.unsubscribe sa
+    ib.unsubscribe sb
+    order  # return the order-record
+  end # place
+
+
+  # shortcut to enable
+  #  account.place order: {} , contract: {}
+  #  account.preview order: {} , contract: {}
+  #  account.modify order: {}
+  alias place place_order
+
+=begin #rdoc
+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 modifyable.
+  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
+without further checking. The block is now optional.
+  Important: The OrderRecord must provide a valid Contract.
+
+The simple version does not adjust the given prices to tick-limits.
+This has to be done manually in the provided block
+=end
+
+
+    def modify_order  local_id: nil, order_ref: nil, order:nil, contract: nil
+
+      result = ->(l){ orders.detect{|x| x.local_id == l  && x.submitted? } }
+      order ||= locate_order( local_id: local_id,
+                             status: /ubmitted/ ,
+                             order_ref: order_ref )
+      if order.is_a? IB::Order
+        order.modify
+      else
+        error "No suitable IB::Order provided/detected. Instead: #{order.inspect}"
+      end
+    end
+
+    alias modify modify_order
+
+# Preview
+    #
+    # Submits a "WhatIf" Order
+    #
+    # Returns the presubmitted order record, where the local_id is erased and the what_if-flag is false
+    #
+    #
+    # output of the results:
+    #   u =  Connection.current.clients.last
+    #   o =  Limit.order ...
+    #   c =  Contract.new ...
+    #   preview =  u.preview contract: c, order: o
+    #   puts preview.order_state.forcast
+    #
+    # The returned order can be used as argument for a subsequent order-placement
+    # i.e
+    #   fits_margin_minium = ->(x) do
+    #                       buffer = x[equity_with_loan] - x[:init_margin]
+    #                       net_liquidation =  account_data_scan( /NetLiq/ ).first.value.to_i
+    #                       buffer > net_liquidation * 0.1  #  90 Percent margin usage is aceptable
+    #                              end
+    #   u.preview( contract: c, order: o )
+    #    .check_margin(u){|y| fits_margin_minumum[ y.order_state.forcast ] } &.place
+    #
+    #
+    # The order received from the TWS is also kept in account.orders
+    #
+    # Raises IB::SymbolError if the Order could not be placed properly
+    #
+  def preview order:, contract: nil, **args_which_are_ignored
+    # to_do:  use a copy of order instead of temporary setting order.what_if
+    q =  Queue.new
+    ib =  IB::Connection.current
+    contract = order.contract if contract.nil?
+    order =  order.then{|x| x.contract =  nil; x }
+    the_local_id = nil
+    # put the order into the queue (and exit) if the event is fired
+    req =  ib.subscribe( :OpenOrder ) do |m|
+      q << m.order if m.order.local_id.to_i == the_local_id.to_i && !m.order.order_state.init_margin_after.nil?
+    end
+
+    order.what_if = true
+    order.account = account
+    the_local_id = ib.place_order order, contract
+    Thread.new{  sleep 2  ;  q.close }   #  wait max 2 sec.
+    returned_order = q.pop
+    ib.unsubscribe req
+#   order.what_if = false # reset what_if flag
+#   order.local_id = nil  # reset local_id to enable re-using the order-object for placing
+    raise IB::SymbolError,"(Preview-) #{order.to_human} is not transmitted properly" if q.closed?
+    #order.order_state.forcast  #  return_value
+    returned_order.local_id =  nil
+    returned_order.what_if = false
+    returned_order.contract = contract
+    returned_order
+  end
+
+
+# closes the contract by submitting an appropriate order
+  # the action- and total_amount attributes of the assigned order are overwritten.
+  #
+  # if a ratio-value (0 ..1) is specified in _order.total_quantity_ only a fraction of the position is closed.
+  # Other values are silently ignored
+  #
+  # if _reverse_ is specified, the opposite position is established.
+  # Any value in total_quantity is overwritten
+  #
+  # returns the order transmitted
+  #v  # raises an IB::Error if no PortfolioValues have been loaded to the IB::Account
+  def close order:, contract: nil, reverse: false,  **args_which_are_ignored
+    error "must only be called after initializing portfolio_values "  if portfolio_values.blank?
+    contract_size = ->(c) do      # note: portfolio_value.position is either positiv or negativ
+      if c.con_id <0 # Spread
+        p = portfolio_values.detect{|p| p.contract.con_id ==c.legs.first.con_id} &.position.to_i
+        p/ c.combo_legs.first.weight  unless p.to_i.zero?
+      else
+        portfolio_values.detect{|x| x.contract.con_id == c.con_id} &.position.to_i   # nil.to_i -->0
+      end
+    end
+
+    order.contract =  contract.verify.first unless contract.nil? || contract.con_id.to_i <=0
+    error "Cannot transmit the order – No Contract given " unless order.contract.is_a?( IB::Contract )
+
+    the_quantity = if reverse
+             -contract_size[order.contract] * 2
+           elsif order.total_quantity.abs < 1 && !order.total_quantity.zero?
+            -contract_size[order.contract] *  order.total_quantity.abs
+           else
+            -contract_size[order.contract]
+           end
+    if the_quantity.zero?
+      logger.info{ "Cannot close #{order.contract.to_human} - no position detected"}
+    else
+      order.total_quantity = the_quantity
+      order.action =  nil
+      order.local_id =  nil  # in any case, close is a new order
+      logger.info { "Order modified to close, reduce or revese position: #{order.to_human}" }
+      place order: order, convert_size: true
+    end
+  end
+
+# just a wrapper to the Gateway-cancel-order method
+  def cancel order:
+    Connection.current.cancel_order order.local_id
+  end
+
+  ## ToDo ... needs adaption !
+  #returns an hash where portfolio_positions are grouped into Watchlists.
+  #
+  # Watchlist => [  contract => [ portfoliopositon] , ... ] ]
+  #
+  def organize_portfolio_positions   the_watchlistsi #= IB::Gateway.current.active_watchlists
+      the_watchlists = [ the_watchlists ] unless the_watchlists.is_a?(Array)
+      self.focuses = portfolio_values.map do | pw |             # iterate over pw
+                     ref_con_id = pw.contract.con_id
+                              z = the_watchlists.map do | w |           # iterate over w and assign to z
+                                  watchlist_contract = w.find do |c|      # iterate over c
+                                                        if c.is_a? IB::Bag
+                                                           c.combo_legs.map( &:con_id ).include?( ref_con_id )
+                                                        else
+                                                           c.con_id == ref_con_id
+                                                         end
+                                                       end rescue nil
+                                  watchlist_contract.present? ? [w,watchlist_contract] : nil
+                               end.compact
+
+                    z.empty? ? [ IB::Symbols::Unspecified, pw.contract, pw ] : z.first + pw
+      end.group_by{|a,_,_| a }.map{|x,y|[x, y.map{|_,d,e|[d,e]}.group_by{|e,_| e}.map{|f,z| [f, z.map(&:last)]} ] }.to_h
+      # group:by --> [a,b,c] .group_by {|_g,_| g} --->{ a => [a,b,c] }
+      # group_by+map --> removes "a" from the resulting array
+    end
+
+
+    def locate_contract con_id
+      contracts.detect{|x| x.con_id.to_i == con_id.to_i }
+    end
+
+    ## returns the contract definition of an complex portfolio-position detected in the account
+    def complex_position con_id
+      con_id = con_id.con_id  if con_id.is_a?(IB::Contract)
+      focuses.map{|x,y| y.detect{|x,y| x.con_id.to_i==  con_id.to_i} }.compact.flatten.first
+    end
+  end # module  Advanced
+    ##
+    # in the console   (call gateway with watchlist: [:Spreads, :BuyAndHold])
+#head :001 > .clients.first.focuses.to_a.to_human
+#Unspecified
+#<Stock: BLUE EUR SBF>
+#<PortfolioValue: DU167348 Pos=720 @ 15.88;Value=11433.24;PNL=-4870.05 unrealized;<Stock: BLUE EUR SBF>
+#<Stock: CSCO USD NASDAQ>
+#<PortfolioValue: DU167348 Pos=44 @ 44.4;Value=1953.6;PNL=1009.8 unrealized;<Stock: CSCO USD NASDAQ>
+#<Stock: DBB USD ARCA>
+#<PortfolioValue: DU167348 Pos=-1 @ 16.575;Value=-16.58;PNL=1.05 unrealized;<Stock: DBB USD ARCA>
+#<Stock: NEU USD NYSE>
+#<PortfolioValue: DU167348 Pos=1 @ 375.617;Value=375.62;PNL=98.63 unrealized;<Stock: NEU USD NYSE>
+#<Stock: WFC USD NYSE>
+#<PortfolioValue: DU167348 Pos=100 @ 51.25;Value=5125.0;PNL=-171.0 unrealized;<Stock: WFC USD NYSE>
+#BuyAndHold
+#<Stock: CIEN USD NYSE>
+#<PortfolioValue: DU167348 Pos=812 @ 29.637;Value=24065.57;PNL=4841.47 unrealized;<Stock: CIEN USD NYSE>
+#<Stock: J36 USD SGX>
+#<PortfolioValue: DU167348 Pos=100 @ 56.245;Value=5624.5;PNL=-830.66 unrealized;<Stock: J36 USD SGX>
+#Spreads
+#<Strangle Estx50(3200.0,3000.0)[Dec 2018]>
+#<PortfolioValue: DU167348 Pos=-3 @ 168.933;Value=-5067.99;PNL=603.51 unrealized;<Option: ESTX50 20181221 call 3000.0  EUR>
+#<PortfolioValue: DU167348 Pos=-3 @ 142.574;Value=-4277.22;PNL=-867.72 unrealized;<Option: ESTX50 20181221 put 3200.0  EUR>
+# => nil
+#
+  #
+  # load  managed-accounts first and switch to gateway-mode
+Connection.current.activate_plugin 'managed-accounts'
+Connection.current.activate_plugin 'order-flow'
+class Account 
+   include Advanced
+end
+end ## module IB

data/plugins/ib/alerts/base-alert.rb

@@ -0,0 +1,125 @@
+module IB
+  class Alert
+=begin
+The Singleton IB::Alert handles any response to IB:Messages::Incomming:Alert
+
+Individual methods can be defined as well as methods responding to a group of error-codes.
+The default-behavior is defined in the method_missing-method. This just logs the object at the debug level.
+
+Default-wrappers to completely ignore the error-message (ignore_alert)
+and to log the object in a different log-level (log_alert_in [warn,info,error] ) are defined in base_alert.
+
+Just add
+```
+  module IB
+    class Alert
+      log_alert_in_warn {list of codennumbers}
+    end
+  end
+```
+to your code
+
+
+IB::Gateway calls the methods in response of subscribing to the :Alert signal by calling
+   IB::Alert.send("alert_#{msg.code}", msg )
+
+To define a response to the code 134 ( Modify order failed)  a method like
+    module IB
+      class Alert
+        def self.alert_134 msg
+          (your code)
+        end
+      end
+    end
+has to be written.
+
+Important: The class is accessed asynchronically. Be careful while raising interrupts.
+
+=end
+
+    # acts as prototype for any generated method
+    #require 'active_support'
+
+
+    def self.method_missing( method_id, msg , *args, &block )
+      if msg.is_a?  IB::Messages::Incoming::Alert
+#       IB::Connection.logger.debug { msg.to_human }
+      else
+        IB::Connection.logger.error { "Argument to IB::Alert is not a IB::Messages::Incoming::Alert" }
+        IB::Connection.logger.error { "The object: #{msg.inspect} " }
+      end
+    rescue NoMethodError
+      unless IB::Connection.logger.nil?
+        IB::Connection.logger.error { "The Argument is not a valid  IB::Messages:Incoming::Alert object"}
+        IB::Connection.logger.error { "The object: #{msg.inspect} " }
+      else
+        puts "No Logging-Device specified"
+        puts "The object: #{msg.inspect} "
+      end
+    end
+
+
+
+    class << self
+
+      def ignore_alert  *codes
+        codes.each do |n|
+          class_eval <<-EOD
+        def self.alert_#{n} msg
+          # even the log_debug entry is suppressed 
+        end              
+          EOD
+        end
+      end
+      def log_alert_in_info  *codes
+        codes.each do |n|
+          class_eval <<-EOD
+        def self.alert_#{n} msg
+          #       IB::Connection.logger.info { msg.to_human }
+        end              
+          EOD
+        end
+      end
+      def log_alert_in_warn  *codes
+        codes.each do |n|
+          class_eval <<-EOD
+        def self.alert_#{n} msg
+          #       IB::Connection.logger.warn { msg.to_human }
+        end              
+          EOD
+        end
+      end
+
+      def log_alert_in_error  *codes
+        codes.each do |n|
+          class_eval <<-EOD
+        def self.alert_#{n} msg
+          if msg.error_id.present? && msg.error_id > 0
+          #     IB::Connection.logger.error {  msg.message + ' id: ' + msg.error_id.to_s }
+          else
+          #     IB::Connection.logger.error {  msg.message   }
+          end
+        end              
+            EOD
+        end
+      end
+    end
+
+      ignore_alert 200 , # is handled by IB::Contract.update_contract
+        2100, # API client has been unsubscribed from account data
+        2105,
+        399 # your order will not be placed at the exchange until
+
+      log_alert_in_info    1102 #Connectivity between IB and Trader Workstation has been restored
+
+
+      log_alert_in_error 320, 321, 323, 324, #ServerError
+        ##        110, # The price does not conform to the minimum price variation
+        #       103, #duplicate order  ## order-alerts
+        #       201, #deleted objecta  ## order-alerts
+        326 #Unable connect as the client id is already in use
+
+      log_alert_in_warn  354 #Requested market data is not subscribed
+
+    end
+  end

data/plugins/ib/alerts/gateway-alerts.rb

@@ -0,0 +1,15 @@
+# These Alerts are always active
+module IB
+  class Alert
+
+    def self.alert_2102 msg
+      # Connectivity between IB and Trader Workstation has been restored - data maintained.
+      sleep 0.1  #  no need to wait too long.
+      if IB::Gateway.current.check_connection
+        IB::Gateway.logger.debug { "Alert 2102: Connection stable" }
+      else
+        IB::Gateway.current.reconnect
+      end
+    end
+    end
+end

data/plugins/ib/alerts/order-alerts.rb

@@ -0,0 +1,73 @@
+module IB
+  class Alert
+
+    def self.alert_388 msg
+             # Order size x is smaller than the minimum required size of yy.
+      IB::Gateway.logger.error  msg.inspect
+  #     error  msg, :order,  nil
+    end
+    def self.alert_202 msg
+      # do anything in a secure mutex-synchronized-environment
+      any_order = IB::Gateway.current.account_data do | account |
+        order= account.locate_order( local_id: msg.error_id )
+        if order.present? && ( order.order_state.status != 'Cancelled' )
+          order.order_states.update_or_create( IB::OrderState.new( status: 'Cancelled', 
+                                                                  perm_id: order.perm_id, 
+                                                                  local_id: order.local_id  ) ,
+                                                                  :status )
+
+        end
+        order # return_value
+      end
+      if any_order.compact.empty? 
+        IB::Gateway.logger.error{"Alert 202: The deleted order was not registered: local_id #{msg.error_id}"}
+      end
+
+    end
+
+
+    class << self
+=begin
+IB::Alert#AddOrderstateAlert
+
+The OrderState-Record is used to record the history of the order.
+If selected Alert-Messages appear, they are  added to the Order.order_state-Array.
+The last Status is available as Order.order_state, all states are accessible by Order.order_states
+
+The TWS-Message-text is stored to the »warning-text«-field.
+The Status is always »rejected«. 
+If the first OrderState-object of a Order is »rejected«, the order is not placed at all.
+Otherwise only the last action is not applied and the order is unchanged.
+
+=end
+      def add_orderstate_alert  *codes
+        codes.each do |n|
+          class_eval <<-EOD
+             def self.alert_#{n} msg
+
+                 if msg.error_id.present?
+                    IB::Gateway.current.account_data do | account |
+                        order= account.locate_order( local_id: msg.error_id )
+                        if order.present? && ( order.order_state.status != 'Rejected' )
+                          order.order_states.update_or_create(  IB::OrderState.new( status: 'Rejected' ,
+                              perm_id: order.perm_id, 
+                              warning_text: '#{n}: '+  msg.message,
+                              local_id: msg.error_id ), :status )   
+
+                          IB::Gateway.logger.error{  msg.to_human  }
+                        end # order present?
+                     end  # mutex-environment
+                  end # branch
+              end # def
+          EOD
+        end # loop
+      end # def
+    end
+    add_orderstate_alert  103,  # duplicate order
+      201,  # deleted object
+      105,  # Order being modified does not match original order
+      462,  # Cannot change to the new Time in Force:GTD
+      329,  # Cannot change to the new order type:STP
+      10147 # OrderId 0 that needs to be cancelled is not found.
+  end  # class Alert
+end #  module IB