ib-orientdb 1.0

data/lib/ib/setup-orientdb.rb

@@ -0,0 +1,112 @@
+module HC; end
+
+module IB
+module Setup
+	# connects to a running interactive brokers TWS or Gateway
+	# and to an active OrientDB-Server.
+	#
+	#
+	# Parameter tws:   host: (default 'localhost') 
+	#                  port: (default 4002 , specify 4001/4002 (Gateway) or 7496/7497 ())
+	# Parameter orientdb: server: ( default: 'localhost' )
+	#                     user: 
+	#                     password:
+	#                     database: ( default: 'temp' )
+	#
+	# The parameter are transmitted to IB::Connection and OrientDB without further checking
+	#
+	# It returns the active Connection 
+	#
+	# The optional block is evaluated in the context of the initialized, but not connected IB::Connection.
+	#
+	#
+	#
+	def self.connect tws:, orientdb:, kind: :connection
+		project_root = File.expand_path('../..', __FILE__)
+		ActiveOrient::Init.connect **orientdb
+		ActiveOrient::Model.keep_models_without_file = false
+		#IB::Model = V   --> Dynamic Assignment Error, this does the same:
+		IB.const_set( :Model, V )
+
+  	TG.connect { project_root + '/models'}
+
+		## There are two locations of modelfiles
+		## 1. ib-api-model files
+		## 2. ib.orientdb-model files
+		model_dir =[ (Pathname.new( `gem which ib-api`.to_s[0..-2]).dirname + "models/").to_s ,
+																	 project_root + '/models']
+		ActiveOrient::Init.define_namespace { IB  }
+		ActiveOrient::OrientDB.new model_dir: model_dir
+
+		init_database 
+		require 'ib/messages'
+
+		target = (kind == :connection) ? IB::Connection : IB::OrientGateway
+		if block_given? 
+			target.new( **tws )  { |c| yield c  }
+		else
+			target.new **tws 
+		end
+
+		require 'ib/extensions'
+
+	end
+
+	def self.init_database db= V.db
+			vertices= db.class_hierarchy( base_class: 'V' ).flatten
+			return if vertices.include? "ib_contract"
+      init_timegraph
+     	ActiveOrient::Init.define_namespace { IB }
+
+			### Vertices
+		  V.create_class            :contract	, :account  
+			IB::Account.create_class  :advisor, :user
+			IB::Advisor.create_class  :demo_advisor
+			IB::User.create_class     :demo_user
+			V.create_class            :portfolio_value, :account_value,  :underlying, :contract_detail, :bar
+			IB::Contract.create_class :option, :future, :stock, :forex, :index, :bag
+			IB::Bag.create_class      :spread
+						
+		  IB::Contract.create_property :con_id, type: :integer, index: :unique
+		  IB::Contract.create_property :bars, type: :link_list,  index: :notunique, 
+																										 linked_class: IB::Bar
+		  IB::Contract.create_property :contract_detail, type: :link,  index: :notunique, 
+																										 linked_class: IB::ContractDetail
+
+			IB::Account.create_property  :account, type: :string, index: :unique
+			IB::Account.create_property  :last_access, type: :date
+			IB::User.create_property     :watchlist, type: :map
+			IB::PortfolioValue.create_property  :position, type: :decimal
+			IB::PortfolioValue.create_property  :market_price, type: :decimal
+			IB::PortfolioValue.create_property  :market_value, type: :decimal
+			IB::PortfolioValue.create_property  :average_cost, type: :decimal
+			IB::PortfolioValue.create_property  :realized_pnl, type: :decimal
+			IB::PortfolioValue.create_property  :unrealized_pnl, type: :decimal
+		  IB::PortfolioValue.create_property  :contract, type: :link, index: :notunique, linked_class: IB::Contract
+
+     	ActiveOrient::Init.define_namespace { HC }
+			V.create_class :portfolio 
+			HC::Portfolio.create_property :account, type: :link,  index: :notunique, linked_class: IB::Account
+			HC::Portfolio.create_property :positions, type: :link_list, linked_class: IB::PortfolioValue
+			HC::Portfolio.create_property :values, type:  :map 
+			#
+			## Edges   (Namespace HC)
+			E.create_class :has_portfolio, :has_position,  :grid, :has_account, :has_strategy
+			E.create_class  :d2F, :p2U, :my_user
+			HC::GRID.uniq_index
+	end
+
+	def self.init_timegraph
+			## Initialize TimeGraph
+			TG::Setup.init_database 
+			TG::TimeGraph.populate 1980..2030
+			TG.info
+	end
+
+	def self.clear_database 
+		IB::Account.delete  all: true
+    IB::Contract.delete all: true
+	end
+
+end
+end

data/lib/logging.rb

@@ -0,0 +1,34 @@
+module Support
+	module Logging
+		def self.included(base)
+			base.extend ClassMethods
+			base.send :define_method, :logger do
+				base.logger
+			end
+		end
+
+		module ClassMethods
+			def logger
+				@logger
+			end
+
+			def logger=(logger)
+				@logger = logger
+			end
+
+			def configure_logger(log=nil)
+				if log
+					@logger = log
+				else
+					@logger = Logger.new(STDOUT)
+					@logger.level = Logger::INFO
+					@logger.formatter = proc do |severity, datetime, progname, msg|
+					#	"#{datetime.strftime("%d.%m.(%X)")}#{"%5s" % severity}->#{msg}\n"
+						"#{"%5s" % severity}->#{msg}\n"
+					end
+				end # branch
+			end # def
+		end # module ClassMethods
+	end # module Logging
+end # module Support
+

data/lib/models/hc/portfolio.rb

@@ -0,0 +1,161 @@
+module HC
+	class Portfolio 
+		# describes the snapshot of positions and account-values
+		# is stored on a daily base
+		#
+		#
+		# bake generates portfolio-entries for each detected IB::Account,
+		#  stores converted account-values in the portfolio-record,
+		#  assigns Portfolio-positions to the time-grid and
+		#  connects the record to the referenced IB::Account.
+		#
+		# returns an array with rid's of successfully allocated portfolio-datasets 
+		#
+    def self.bake  
+
+			gateway= IB::OrientGateway.current
+      gateway.get_account_data
+			gateway.clients.map do | the_client |
+
+				p = self.new
+				p.import_account_data from: the_client						 # implies update of p, assigns a rid
+				p.import_positions    from: the_client             # assigns portfolio-values to the grid
+				HC::MY_USER.create    from: p, to: the_client      # bidirectional link to account
+				Date.today.to_tg.assign vertex: p, via: HC::D2F    # bidirectional link to the time-grid
+				p.rid                                              # return_value
+			end
+		end
+
+		# returns  the projection for usage in OrientQuery
+		# It filters specific account-values
+		#
+		# To execute a query, inject the from-parameter via a block
+		#
+		def account_data_scan_projection search_key
+			# values.keys.match(/Ac/).compact.string => ["AccruedCash", "AccruedDividend"]
+			fields = values.keys.match(search_key).compact.string 
+      p = fields.map{|y| "values[\"#{y}\"] as #{y} "}.join(", ")
+      if block_given?
+				 q =  OrientSupport::OrientQuery  
+				 o.from( yield )
+				  .projection( p )
+					.execute     # return result
+         else
+					 p  #  return projection string
+			end
+
+
+		end
+
+# pp Date.today.to_tg.environment(3,0) &.out_hc_d2F.compact.in.values.orient_flatten.map{|y| y[:SMA] }
+#[{:ALL=>{:EUR=>-4701.63}, :S=>{:EUR=>-4701.63}},
+# {:ALL=>{:EUR=>-4702.72}, :S=>{:EUR=>-4702.72}},
+# {:ALL=>{:EUR=>-4658.85}, :S=>{:EUR=>-4658.85}},
+# {:ALL=>{:EUR=>-4658.85}, :S=>{:EUR=>-4658.85}},
+# {:ALL=>{:EUR=>-4658.85}, :S=>{:EUR=>-4658.85}},
+# {:ALL=>{:EUR=>-5840.75}, :S=>{:EUR=>-5840.75}},
+# {:ALL=>{:EUR=>-9033.37}, :S=>{:EUR=>-9033.37}}]
+# 
+
+
+		def account_data_scan search_key, search_currency=nil
+			return if values.nil? or values.empty?
+		   values.keys.match(/Ac/).compact.string
+			if account_values.is_a? Array
+				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
+		end
+
+		# Utility function to transform IB:AccountValues into a hash 
+		#
+		# which is stored in the property »value«
+		#
+		# from is either a IB::Account or an array of IB::AccountValues
+		def import_account_data  from:
+			from = from.account_values if from.is_a? IB::Account
+			account_values =  Hash.new
+			currencies = from.find_all{|x| x.key == :Currency }.map &:value  # => ["BASE", "EUR", "SEK", "USD"]
+			from.map{|y| y.key.to_s.split('-').first.to_sym}.uniq.each{|x| account_values[ x ] = {} }
+			subaccounts = [:C, :F, :S]
+			
+			from.each do |a|
+				next if a.currency.empty? || a.value.to_i.zero? || a.value == "1.7976931348623157E308"
+				id, subaccount =  a.key.to_s.split('-')
+#				a.value =  a.value[-3] =='.' ?  a.value.to_f : a.value.to_i  if a.value.is_a?(String)
+				a.value =  a.value.to_f
+				subaccount = 'ALL' if subaccount.nil? 
+				if account_values[id.to_sym][subaccount.to_sym].present? 
+					account_values[id.to_sym][subaccount.to_sym].merge!  a.currency => a.value  
+				else
+					account_values[id.to_sym][subaccount.to_sym] = { a.currency => a.value } 
+				end
+			end
+			account_values.delete_if{|_,l| l.empty?}  # return only elements with valid data, ie.non empty values
+
+			update  values: account_values
+		end
+		
+	
+		# Utility function to add IB::PortfolioValues to the TimeGrid
+		#
+		# from is either a IB::Account or an array of IB::PortfolioValues
+		#
+		def import_positions from: 
+			from = from.portfolio_values if from.is_a? IB::Account
+
+			# delete possibly previous entries
+			out_hc_has_position &.in &.map &:delete
+#			out_hc_has_position &.map &:delete			#  edge is automatically removed by delete(vertex)
+
+			from.each do | portfolio_position |
+
+				portfolio_position.save
+				# build link to portfolio-position
+				assign via: HC::HAS_POSITION, vertex: portfolio_position
+				# connect with previous entry
+				previous = prev_portfolio_position(portfolio_position.contract)
+#				puts "previous: #{previous}"
+				previous &.assign via: HC::GRID, vertex: pp
+			end
+		end
+
+	# go back one step in history, traverse to the portfolio_position where the contract matches
+		def prev_portfolio_position(contract)
+				prev &.position( contract )
+		end
+
+		# shortcut for the portfolio-positions-array
+		def positions
+			out( HC::HAS_POSITION ).in  #  ruby solution, without inheritance
+		end
+			 #################
+##			 nodes :out, via: HC::HAS_POSITION   # database-query solution with inheritance
+			 #################
+
+		def self.positions
+				query.nodes :out, via: HC::HAS_POSITION, expand: false  # returns a query-object
+		end
+
+		# get selected portfolio-value positions
+		def position *contract 
+      
+			# generated query: INFO->select  outE('hc_has_position').in[ contract=208:0 ]  from #249:0 
+		  nodes :out, via: HC::HAS_POSITION , where: { contract: contract }  # database-query solution
+			#positions &.detect{|x| x.contract == contract }   # ruby solution
+		end
+	
+		def account
+			out( /user/ ).in.first
+		end
+
+
+		def to_human
+					"<#{self.class.to_s.split(':').last}[#{rid}]: account:#{account.to_human}, #{values.size} AccountValues; #{out_hc_has_position.size} Positions >"
+		end
+
+	end # class
+end   # module

data/lib/models/ib/account.rb

@@ -0,0 +1,5 @@
+module IB
+	class Account < IB::Model
+
+	end
+end

data/lib/models/ib/account_value.rb

@@ -0,0 +1,29 @@
+module IB
+	class AccountValue 
+		
+		# Assigns an AccountValue to the TimeGrid and inserts a link to the account to the  AccountValueRecord
+		def bake account:, date:  Date.today, via: IB::HAS_ACCOUNT
+			self.attributes[:account]= account.rid
+			date.to_tg.assign vertex = self, via: via
+		end
+
+
+
+		def self.bake from:, with:
+
+		user = HC::Users.where( account_id: with.is_a?(String) ? with : with.account ) &.first
+
+		raise ArgumentError "No HC::Users record available" unless user.is_a? HC::Users
+		
+		time_graph_index =  Date.today.to_tg
+#		from.each do | account_value |
+			new_ds = create values: {},  account: user, date: Date.today
+			new_ds.values << from
+			HC::AV.create from: time_graph_index, to: new_ds
+			HC::MY_USER.create from:  user, to: new_ds
+
+
+		end
+
+	end
+end

data/lib/models/ib/contract.rb

@@ -0,0 +1,15 @@
+module IB
+	class Contract  < IB::Model
+
+		# if con_id is not set, the contract cannot be saved
+		#
+		# if con_id or rid is present, the contract is updated
+		def save
+			return false if con_id.blank? || con_id.zero?
+			super
+		end
+	end
+
+end
+
+

data/lib/models/ib/financials.rb

@@ -0,0 +1,6 @@
+module IB
+  class Financials
+
+
+	end   # class
+	end   # module

data/lib/models/ib/portfolio_value.rb

@@ -0,0 +1,10 @@
+module IB
+	class PortfolioValue
+
+		def save
+			super
+			contract.save unless contract.rid.rid?
+			update contract: contract.rid
+		end
+	end
+end

data/lib/models/tg/tag.rb

@@ -0,0 +1,16 @@
+module TG
+	class Tag
+		def portfolios
+		  iz= out( HC::D2F ).compact.map( &:in ) # eliminates entries if no HC::D2F is detected
+			iz unless iz.empty? # returns nil if no portfolio is detected
+		end
+
+		def self.portfolios
+			query.nodes( :out, via: HC::D2F , expand: false)
+		end
+	end
+end
+
+# current_date.environment2(1).execute.portfolios.positions.contract
+# INFO->select  expand ( $c ) let $a = (select from  ( traverse  inE('tg_grid_of').out  from #45:1869 while $depth <= 1  )  where $depth >=1 ), $b = (select from  ( traverse  outE('tg_grid_of').in  from #45:1869 while $depth <= 1  )  where $depth >=1 ), $c= UNIONALL($a,$b)  
+# => [[["#186:0", "#202:0", "#203:0", "#188:1", "#204:0", "#194:0", "#187:0", "#189:0", "#190:0", "#191:0", "#192:0", "#186:2", "#206:0", "#207:0", "#208:0", "#195:0", "#187:1", "#193:0", "#186:1", "#209:0"]]]

data/lib/support.rb

@@ -0,0 +1,21 @@
+class Array
+  # enables calling members of an array. which are hashes  by it name
+  # i.e
+  #
+  #  2.5.0 :006 > C.received[:OpenOrder].local_id
+  #   => [16, 17, 21, 20, 19, 8, 7] 
+  #   2.5.0 :007 > C.received[:OpenOrder].contract.to_human
+  #    => ["<Bag: IECombo SMART USD legs:  >", "<Stock: GE USD>", "<Stock: GE USD>", "<Stock: GE USD>", "<Stock: GE USD>", "<Stock: WFC USD>", "<Stock: WFC USD>"] 
+  #
+  # its included temporary 
+	#
+	# to_do: substitute with a delegation solution
+
+  def method_missing(method, *key)
+    unless method == :to_hash || method == :to_str #|| method == :to_int
+      return self.compact.map{|x| x.public_send(method, *key)}
+    end
+
+  end
+end # Array
+