ib-api 10.33.1

data/models/ib/order_state.rb

@@ -0,0 +1,155 @@
+module IB
+
+  # OrderState represents dynamic (changeable) info about a single Order,
+  # isolating these changes and making Order essentially immutable
+  class OrderState < IB::Base
+    include BaseProperties
+
+    #p column_names
+    belongs_to :order
+
+    # Properties arriving via OpenOrder message
+    prop :init_margin_after,   # Float: The impact the order would have on your initial margin.
+      :maint_margin_after,     # Float: The impact the order would have on your maintenance margin.
+      :equity_with_loan_after, # Float: The impact the order would have on your equity
+      :init_margin_before, :maint_margin_before, :equity_with_loan_before,
+      :init_margin_change, :maint_margin_change, :equity_with_loan_change,
+      :commission, # double: Shows the commission amount on the order.
+      :min_commission, # The possible min range of the actual order commission.
+      :max_commission, # The possible max range of the actual order commission.
+
+      :commission_currency, # String: Shows the currency of the commission.
+      :warning_text, # String: Displays a warning message if warranted.
+
+      :market_cap_price  # messages#incomming#orderstae#vers. 11
+
+      # Properties arriving via OrderStatus message:
+      prop :filled, #    int
+      :remaining, # int
+      [:price, :last_fill_price,], #    double
+      [:average_price, :average_fill_price], # double
+      :why_held # String: comma-separated list of reasons for order to be held.
+
+      # Properties arriving in both messages:
+      prop :local_id, #  int: Order id associated with client (volatile).
+      :perm_id, #   int: TWS permanent id, remains the same over TWS sessions.
+      :client_id, # int: The id of the client that placed this order.
+      :parent_id, # int: The order ID of the parent (original) order, used
+      :status => :s # String: one of
+      #   ApiCancelled, PreSubmitted, PendingCancel, Cancelled, Submitted, Filled,
+      #   Inactive, PendingSubmit, Unknown, ApiPending,
+      #
+      #  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.
+      #   
+
+      validates_format_of :status, :without => /\A\z/, :message => 'must not be empty'
+    validates_numericality_of :price, :average_price, :allow_nil => true
+    validates_numericality_of :local_id, :perm_id, :client_id, :parent_id, :filled,
+      :remaining, :only_integer => true, :allow_nil => true
+
+    def self.valid_status? the_message
+      valid_stati =  %w( ApiCancelled PreSubmitted PendingCancel Cancelled Submitted Filled
+       Inactive PendingSubmit Unknown ApiPending)
+     valid_stati.include?( the_message )
+    end
+  
+    ## Testing Order state:
+
+    def new?
+      status.empty? || status == 'New'
+    end
+
+    # Order is in a valid, working state on TWS side
+    def submitted?
+      status =~ /Submit/
+    end
+
+    # Order is in a valid, working state on TWS side
+    def pending?
+      submitted? || status =~ /Pending/
+    end
+
+    # Order is in invalid state
+    def inactive?
+      new? || pending? || status =~ /Cancel/
+    end
+
+    def active?
+      !inactive? # status == 'Inactive'
+    end
+
+    def complete_fill?
+      status == 'Filled' && remaining == 0 # filled >= total_quantity # Manually corrected
+    end
+
+    # Comparison
+    def == other
+
+      super(other) ||
+        other.is_a?(self.class) &&
+        status == other.status &&
+        local_id == other.local_id &&
+        perm_id == other.perm_id &&
+        client_id == other.client_id &&
+        filled == other.filled &&
+        remaining == other.remaining &&
+        last_fill_price == other.last_fill_price &&
+        init_margin_after == other.init_margin_after &&
+        maint_margin_after == other.maint_margin_after &&
+        equity_with_loan_after == other.equity_with_loan_after &&
+        why_held == other.why_held &&
+        warning_text == other.warning_text &&
+        commission == other.commission
+    end
+
+    def to_human
+      "<OrderState: #{status} ##{local_id}/#{perm_id} from #{client_id}" +
+        (filled ? " filled #{filled}/#{remaining}" : '') +
+        (last_fill_price ? " at #{last_fill_price}/#{average_fill_price}" : '') +
+        (init_margin_after ? " margin #{init_margin_after}/#{maint_margin_after}" : '') +
+        (equity_with_loan_after ? " equity #{equity_with_loan_after}" : '') +
+        (commission && commission > 0 ? " fee #{commission}" : "") +
+        (why_held ? " why_held #{why_held}" : '') +
+        ((warning_text && warning_text != '') ? " warning #{warning_text}" : '') + ">"
+    end
+
+    alias to_s to_human
+=begin
+If an Order is submitted with the :what_if-Flag set, commission and margin are returned
+via the order_state-Object.
+=end
+    def forcast
+      { :init_margin => init_margin_after,
+        :maint_margin => maint_margin_after,
+        :equity_with_loan => equity_with_loan_after ,
+        :commission => commission,
+        :commission_currency=> commission_currency,
+        :warning => warning_text }
+    end
+  end # class Order
+end # module IB

data/models/ib/portfolio_value.rb

@@ -0,0 +1,86 @@
+module IB
+class PortfolioValue < IB::Base
+    include BaseProperties
+# belongs_to :currency
+  belongs_to :account
+  belongs_to :contract
+
+# scope :single, ->(key) { where :schluessel => key } rescue nil
+
+    prop :position, 
+  :market_price, 
+  :market_value, 
+  :average_cost, 
+  :unrealized_pnl, 
+  :realized_pnl
+
+
+    # Order comparison
+    def == other
+      super(other) ||
+        other.is_a?(self.class) &&
+        market_price == other.market_price &&
+        average_cost == other.average_cost &&
+        position == other.position &&
+  unrealized_pnl == other.unrealized_pnl  &&
+  realized_pnl == other.realized_pnl &&
+        contract == other.contract
+    end
+    def to_human
+      the_account = if account.present? 
+                      if account.is_a?(String)
+                        account + " "
+                      else
+                        account.account+" "
+                      end
+                    else 
+                      ""
+                    end
+
+      "<PortfolioValue: "+
+      the_account  +
+      "Pos=#{ position.to_i } @ #{market_price.to_f.round(3)};" +
+      "Value=#{market_value.to_f.round(2)};PNL=" + 
+      ( unrealized_pnl.to_i.zero? ? "": "#{unrealized_pnl} unrealized;") +
+      ( realized_pnl.to_i.zero? ? "" : "#{realized_pnl} realized;>" ) + 
+      contract.to_human
+    end
+    alias to_s to_human
+
+    def table_header
+      if block_given?
+      [ '' ,   yield , 'pos',  'entry', 'market', 'value', 'unrealized', 'realized'  ]
+      else
+      [ '' ,   '', 'pos',  'entry', 'market', 'value', 'unrealized', 'realized'  ]
+      end
+    end
+
+    def table_row
+      outprice= ->( item ) { { value: item.nil? ? "--" :  item , alignment: :right } } 
+
+      the_account = if account.present? 
+                      if account.is_a?(String)
+                        account + " "
+                      else
+                        account.account+" "
+                      end
+                    else 
+                      ""
+                    end
+      
+      entry = average_cost.to_f / (contract.multiplier.to_i.zero? ?  1 : contract.multiplier.to_i)
+
+      [ the_account,
+        contract.to_human[1..-2],
+       outprice[position.to_i],
+       outprice[entry.to_f.round(3)],
+       outprice[market_price.to_f.round(3)],
+       outprice[market_value.to_f.round(2)],
+       unrealized_pnl.to_i.zero? ? "": outprice[unrealized_pnl], 
+       realized_pnl.to_i.zero? ? "" : outprice[realized_pnl] 
+      ]
+    end
+
+
+end # class
+end # module

data/models/ib/spread.rb

@@ -0,0 +1,176 @@
+module IB
+  class Spread  < Bag
+    has_many :legs
+
+    using IB::Support
+
+=begin
+Parameters:   front: YYYMM(DD)
+              back: {n}w, {n}d or YYYYMM(DD)
+
+Adds (or substracts) relative (back) measures to the front month, just passes absolute YYYYMM(DD) value
+
+  front: 201809   back:  2m (-1m) --> 201811 (201808)
+  front: 20180908 back:  1w (-1w) --> 20180918 (20180902)
+=end
+
+    def self.transform_distance front, back
+      # Check Format of back: 201809 --> > 200.000
+      #                       20180989 ---> 20.000.000
+      start_date = front.to_i < 20000000 ?  Date.strptime(front.to_s,"%Y%m") :  Date.strptime(front.to_s,"%Y%m%d")
+      nb = if back.to_i > 200000
+             back.to_i
+           elsif back[-1] == "w" && front.to_i > 20000000
+             start_date + (back.to_i * 7) + 1   # +1 to compensate for friday's bank-holiday, target has to be verified through next_expiry
+           elsif back[-1] == "m" && front.to_i > 200000
+             start_date >> back.to_i
+           else
+             error "Wrong date #{back} required format YYYMM, YYYYMMDD ord {n}w or {n}m"
+           end
+      if nb.is_a?(Date) 
+        if back[-1]=='w'
+          nb.strftime("%Y%m%d")
+        else
+          nb.strftime("%Y%m")
+        end
+      else
+        nb
+      end
+    end # def
+
+    def to_human
+      self.description
+    end
+
+    def calculate_spread_value( array_of_portfolio_values )
+      array_of_portfolio_values.map{|x| x.send yield }.sum if block_given?
+    end
+
+    def fake_portfolio_position(  array_of_portfolio_values )
+        calculate_spread_value= ->( a_o_p_v, attribute ) do
+              a_o_p_v.map{|x| x.send attribute }.sum
+        end
+        ar=array_of_portfolio_values
+        IB::PortfolioValue.new  contract: self,
+          average_cost: calculate_spread_value[ar, :average_cost],
+          market_price: calculate_spread_value[ar, :market_price],
+          market_value: calculate_spread_value[ar, :market_value],
+          unrealized_pnl: calculate_spread_value[ar, :unrealized_pnl],
+          realized_pnl: calculate_spread_value[ar, :realized_pnl],
+          position: 0
+
+    end
+
+
+    # adds a leg to any spread
+    #
+    # Parameter:
+    #   contract:  Will be verified. Contract.essential is added to legs-array
+    #   action: :buy or :sell
+    #   weight:
+    #   ratio:
+    #
+    # Default:  action: :buy, weight: 1
+
+    def add_leg contract,  **leg_params
+      error "need a IB::Contract as first argument" unless contract.is_a? IB::Contract
+      self.legs <<  contract
+      error "cannot add leg if no con_id is provided" if contract.con_id.blank?
+      #     weigth = 1 --> sets Combo.side to buy and overwrites the action statement
+#     leg_params[:weight] = 1 unless leg_params.key?(:weight) || leg_params.key?(:ratio)
+      leg_description = leg_params.extract!( :description )
+      leg_description = "#{leg_params[:action] || 'buy'} #{leg_params[:weight] || "1"} #{contract.to_human}" if leg_description.empty?
+      self.combo_legs <<  ComboLeg.new( contract.attributes.slice( :con_id, :exchange ).merge( leg_params ))
+      self.description = "#{description.nil? ? "": description + " / "} #{leg_description}" rescue "Spread: #{contract.to_human}"
+
+      self  # return object to enable chaining
+
+
+    end
+
+    # removes the contract from the spread definition
+    #
+    def remove_leg contract_or_position = nil
+      contract = if contract_or_position.is_a? (IB::Contract)
+                   contract_or_position
+                 elsif contract_or_position.is_a? Numeric
+                   legs.at contract_or_position
+                 else
+                   error "Specify a contract to be removed or the position in the legs-array as parameter to remove a leg"
+      end
+      the_con_id = contract.verify.first &.con_id
+      error "Invalid Contract specified" unless the_con_id.is_a? Numeric
+      legs.delete_if { |x| x.con_id == the_con_id }
+      combo_legs.delete_if { |x| x.con_id == the_con_id }
+      self.description = description + " removed #{contract.to_human}"
+      self   # make method chainable
+    end
+
+# essentail
+# effectivley clones the object
+#
+    def essential
+      the_es = self.class.new invariant_attributes
+      the_es.legs = legs.map{|y| IB::Contract.build y.invariant_attributes}
+      the_es.combo_legs = combo_legs.map{|y| IB::ComboLeg.new y.invariant_attributes }
+      the_es.description = description
+      the_es  # return
+    end
+
+    def  multiplier
+      (legs.map(&:multiplier).sum/legs.size).to_i
+    end
+
+    # provide a negative con_id
+    def con_id
+      if attributes[:con_id].present? && attributes[] < 0
+        attributes[:con_id]
+      else
+        -legs.map{ |x| x.is_a?(String) ? x.expand.con_id : x.con_id}.sum
+      end
+    end
+
+
+#    def non_guaranteed= x
+#      super.merge   combo_params: [ ['NonGuaranteed', x] ]
+#    end
+#
+#
+#    def non_guaranteed
+#      combo_params['NonGuaranteed']
+#    end
+#  optional: specify default order prarmeters for all spreads
+#   def order_requirements
+#    super.merge    symbol: symbol
+#   end
+
+
+    def as_table
+      t=  Terminal::Table.new title:  description[1..-2] ,
+                          headings: table_header,
+
+                          style: { border: :unicode }
+
+      t.add_row table_row
+      legs.each{ |y| t.add_row y.table_row }
+      t.render
+
+    end
+
+    def self.build_from_json container
+      read_leg = ->(a) do
+          IB::ComboLeg.new :con_id => a.read_int,
+                           :ratio => a.read_int,
+                           :action => a.read_string,
+                           :exchange => a.read_string
+
+      end
+      object= self.new  container['Spread'].clone.read_contract
+      object.legs = container['legs'].map{|x| IB::Contract.build x.clone.read_contract}
+      object.combo_legs = container['combo_legs'].map{ |x| read_leg[ x.clone ] }
+      object.description = container['misc'].clone.read_string
+      object
+
+    end
+  end
+end

data/models/ib/stock.rb

@@ -0,0 +1,25 @@
+module IB
+  class Stock < IB::Contract
+    validates_format_of :sec_type, :with => /\Astock\z/,
+      :message => "should be a Stock"
+    validates_format_of :symbol, with: /\A.*\z/,
+      message: 'should not be blank'
+    def default_attributes
+      super.merge :sec_type => :stock, currency:'USD', exchange:'SMART'
+    end
+
+    def merge **new_attributes
+      super( **{ trading_class: '', primary_exchange: '' }.merge(new_attributes) )
+    end
+
+    def to_human
+      att =  [ symbol,
+              currency, ( exchange == 'SMART' ? nil: exchange ),
+              (primary_exchange.present? && !primary_exchange.empty? ? primary_exchange : nil),
+              @description.present? ? " (#{@description}) " : nil,
+             ].compact
+            "<Stock: " + att.join(" ") + ">"
+    end
+
+  end
+end

data/models/ib/underlying.rb

@@ -0,0 +1,32 @@
+module IB
+  # Calculated characteristics of underlying Contract (volatile)
+  class Underlying < IB::Base
+    include BaseProperties
+
+    has_one :contract
+
+    prop :con_id, # Id of the Underlying Contract
+      :delta, # double: The underlying stock or future delta.
+      :price #  double: The price of the underlying.
+
+      validates_numericality_of :con_id, :delta, :price #, :allow_nil => true
+
+    def default_attributes
+      super.merge :con_id => 0
+    end
+
+    # Serialize under_comp parameters
+    def serialize
+      [con_id, delta, price]
+    end
+
+    # Comparison
+    def == other
+      super(other) ||
+        other.is_a?(self.class) &&
+        con_id == other.con_id && delta == other.delta && price == other.price
+    end
+
+  end # class Underlying
+  UnderComp = Underlying
+end