orientdb-time-graph 0.7

data/config/config.yml

@@ -0,0 +1,8 @@
+---
+:active_orient:
+## Namespace: Prefix of Model-Objects. :self -> ActiveOrient::Model::{name}
+##				       :object => No Prefix
+##				       :active_orient => ActiveOrient::{name}
+ :namespace: :object
+ :model_dir: 'model'
+

data/config/connect.yml

@@ -0,0 +1,21 @@
+---
+:orientdb:
+  :production:
+   :server: 172.28.50.25  # localhost
+   :user:  hctw
+   :password: a***k 
+   :database: o
+  :test:
+   :server: 10.222.148.109
+   :user: hctw
+   :password: s*p**
+   :database: test
+  :development:
+   :server: 10.222.148.109
+   :user: hctw
+   :password: s*p**
+   :database: demo
+:port: 2480
+:logger: stdout           # 'file' or 'stdout'
+
+# hfx: 101

data/lib/init_db.rb

@@ -0,0 +1,60 @@
+module TG 
+  module Setup
+		def self.init_database database_instance= V.db
+			stored_namespace =  ActiveOrient::Model.namespace
+			ActiveOrient::Init.define_namespace { TG }
+			(logger= ActiveOrient::OrientDB.logger).progname= 'TG::Setup#InitDatabase'
+			# because edges are not resolved because of the namingconvention
+			tg_edges =  [  :time_of, :day_of, :month_of, :grid_of ]	
+			time_base_vertices =  [  :stunde, :tag, :monat, :jahr  ]
+			edges = V.db.class_hierarchy( base_class: 'E') & tg_edges.map( &:to_s )
+			vertices =  V.db.class_hierarchy( base_class: 'tg_time_base' ) & time_base_vertices.map( &:to_s )
+			logger.info{ "affected-database-classes: \n #{ (vertices + edges).join(', ')}"  }
+
+			delete_class = -> (c,d) do 
+				the_class = ActiveOrient::Model.orientdb_class( name: c, superclass: d)
+				logger.info{  "The Class: "+the_class.to_s+ " removed from Database" }
+				the_class.delete_class
+			end
+			if defined?(TimeBase)
+				vertices.each{|v| delete_class[ v, :tg_time_base ] }
+				delete_class[ :tg_time_base, :V ] 
+			end
+
+      logger.progname= 'TG::Setup#InitDatabase'
+      cleared_database = V.db.database_classes 
+      logger.info{ "  Creating Classes " }
+      V.create_class :time_base		      # --> TimeBase
+      # hour, day: month cannot be alloacated, because Day is a class of DateTime and thus is reserved
+      time_base_classes = TimeBase.create_class *time_base_vertices  # --> Hour, Day, Month
+      TimeBase.create_property :value, type:  :integer 						
+      #
+      ## this puts an  index on child-classes
+      time_base_classes.each{|c| c.create_index c.ref_name+'_value_idx' , type: :notunique, on: :value }
+      
+      # modified naming-convention in  model/e.rb
+      edges = E.create_class  *tg_edges   # --> TIME_OF, :DAY_OF
+      edges.each &:uniq_index
+
+      # restore namespace
+      ActiveOrient::Init.define_namespace { stored_namespace }
+
+      V.db.database_classes - cleared_database  # return_value
+    end
+  end
+end
+# to_do:  define validations
+#  hour_class   = r.create_vertex_class "Hour", properties: {value_string: {type: :string}, value: {type: :integer}}
+#  hour_class.alter_property property: "value", attribute: "MIN", alteration: 0
+#  hour_class.alter_property property: "value", attribute: "MAX", alteration: 23
+#
+#  day_class    = r.create_vertex_class "Day", properties: {value_string: {type: :string}, value: {type: :integer}}
+#  day_class.alter_property property: "value", attribute: "MIN", alteration: 1
+#  day_class.alter_property property: "value", attribute: "MAX", alteration: 31
+#
+#  month_class  = r.create_vertex_class "Month", properties: {value_string: {type: :string}, value: {type: :integer}}
+#  month_class.alter_property property: "value", attribute: "MIN", alteration: 1
+#  month_class.alter_property property: "value", attribute: "MAX", alteration: 12
+#
+
+#  timeof_class = r.create_edge_class "TIMEOF"

data/lib/orientdb_time_graph.rb

@@ -0,0 +1,68 @@
+require 'active-orient'
+require_relative 'time_graph.rb'
+require_relative 'support.rb'
+
+require_relative 'init_db'
+
+
+
+module TG
+
+	# completes the parameter for calling ActiveOrient::Init.connect
+	# 
+	# Is called from connect only if ActiveOrient.default_server is not set previously
+	# 
+	# otherwise the credentials from the main-activeorient-instance are used.
+  def self.set_defaults  **login
+    c = { :server =>  'localhost',
+	  :port   => 2480,
+	  :protocol => 'http',
+	  :user    => 'root',
+	  :password => 'root',
+	  :database => 'temp'
+    }.merge login
+
+    ActiveOrient.default_server= { user: c[:user], password: c[:password] ,
+				   server: c[:server], port: c[:port]  }
+    ActiveOrient.database = c[:database]
+  end
+
+  def self.connect **login
+    project_root = File.expand_path('../..', __FILE__)
+    set_defaults( **login) unless ActiveOrient.default_server.is_a?(Hash) && ActiveOrient.default_server[:user].present?
+    ActiveOrient::Init.define_namespace { TG } 
+		# a provided block is used to introduce additional locations of model-files
+		the_model_dirs = block_given? ? [ "#{project_root}/model", yield].flatten :  [ "#{project_root}/model" ]
+		ActiveOrient::OrientDB.new  preallocate: true, model_dir: the_model_dirs
+		@time_graph = TG.const_defined?(:TIME_OF) ? TG::TIME_OF.count > 0 : nil
+  end
+
+	def self.time_graph?
+		@time_graph
+	end
+  def self.check_and_initialize database_instance
+    if database_instance.get_classes( "name").values.flatten.include? 'time_base'
+      return true
+    else
+      TG::Setup.init_database database_instance
+      puts "Database-Structure allocated"
+      puts "Exiting now, please restart and call »TG::TimeGraph.populate«"
+      Kernel.exit
+    end
+	end
+
+  def self.info 
+    puts "-------------- TIME GRAPH ------------------"
+    puts "Allocated Years : "
+    puts TG::Jahr.all.map(&:value).sort.join('; ')
+    puts ""
+    puts "Type: #{TG::Stunde.all.empty? ? "Date-Graph" : "DateTime-Graph"}"
+    puts ""
+
+  end
+end
+
+
+
+
+

data/lib/setup.rb

@@ -0,0 +1,40 @@
+#require 'bunny'
+require 'active_support'
+require 'active-orient'
+require 'yaml'
+require_relative 'orientdb_time_graph'
+#require 'dry/core/class_attributes'
+#require_relative "logging"
+require_relative "init_db"
+	
+
+module TG 
+
+	## Standalone setup 
+	##  
+	## initializes ActiveOrient and adds time-graph database-classes
+	## through namespace 
+	# 
+	# valid environments:  :test, :development, :production
+	def self.setup environment = :test
+
+		read_yml = -> (key) do
+			YAML::load_file( File.expand_path('../../config/connect.yml',__FILE__))[key]
+		end
+
+
+	 logon =  read_yml[:orientdb][environment]
+
+	 ActiveOrient::Init.connect  **logon
+	 TG.connect **logon
+	 # we have to initialise the timegraph at this point, otherwise any
+	 # manual requirement fails.
+	 unless ActiveOrient::Model.namespace.send :const_defined?, 'Tag' 
+		 Setup.init_database V.orientdb
+	 end
+
+	end
+
+
+
+end

data/lib/support.rb

@@ -0,0 +1,38 @@
+## We are defining to_tg methods for Strings, Date and DateTiem objects.
+## Strings are converted to the time format.
+#
+class Date
+  def to_tg
+# old method performed queries
+# Date.today.to_tg
+# INFO->select from tg_jahr where value = 2019
+# INFO->select  expand (out_tg_month_of.in[value = 4]) from #117:0  
+# INFO->select  expand (out_tg_day_of.in[value = 2]) from #108:6  
+# 
+# the alternative:
+#    TG::Jahr[year].monat(month).tag(day).orient_flatten
+# which can be combined through
+#		query "select  expand (out_tg_day_of.in[value = #{day}]) from (select  expand (out_tg_month_of.in[value = #{month}]) from (select from tg_jahr where value = #{year} ) ) "
+#
+# this is realized in fetch
+		TG::Tag.fetch self
+  end
+end
+
+class DateTime
+  def to_tg
+    if TG.time_graph? 
+      TG::Monat[month].tag(day).stunde(hour).pop.pop
+    else
+		TG::Tag.fetch self
+    end
+  end
+end
+
+class String
+  def to_tg
+    date =  DateTime.parse(self)
+    date.to_tg
+  end
+end
+

data/lib/time_graph.rb

@@ -0,0 +1,100 @@
+#require 'time'
+
+module TG
+
+class TimeGraph
+	class << self   # singleton class
+		## we populate the graph with a 1:n-Layer
+		# (year -->) n[month] --> n[day] ( --> n[hour] ])
+		# thus creating edges is providing a static :from-vertex to numerous :to-vertices
+		# the to:vertices are first created and fenced in an array. Then all edges are created at once. 
+		# In Rest-Mode this is much quicker.
+		def populate years = (1900 .. 2050), delete: true
+
+			count_gridspace = -> do
+				[TG::Jahr,TG::Monat,TG::Tag,TG::Stunde].map{|x|  "#{x.ref_name} -> #{x.count}" }
+			end
+
+			if delete
+				puts count_gridspace[].join('; ')
+				puts "deleting content"
+				[TG::Jahr,TG::Monat,TG::Tag,TG::Stunde].each{|x| x.delete all: true}
+				puts "checking .."
+				puts count_gridspace[].join('; ')
+			end
+
+			kind_of_grid = if years.is_a? Range
+											 'daily'
+										 else
+											 years = years.is_a?(Fixnum) ? [years]: years
+											 'hourly'
+										 end
+
+			### switch logger level
+      previous_looger_level = V.db.logger.level
+			V.db.logger.level = 2
+			### NOW WHERE THE DATABASE IS CLEAN, POPULATE IT WITH A DAILY GRID
+			print "Grid: " 
+			year_grid, month_grid, day_grid, hour_grid  =  nil
+			years.each do | the_year |
+				year_vertex = TG::Jahr.create value: the_year
+				#	puts "YEAR_GRID: #{year_grid.inspect}"
+				TG::GRID_OF.create( from: year_grid , to: year_vertex ) if year_grid.present?
+				year_grid =  year_vertex
+				month_vertices = ( 1 .. 12 ).map do | the_month |
+					month_vertex= TG::Monat.create value: the_month
+					TG::GRID_OF.create( from: month_grid , to: month_vertex ) if month_grid.present?
+					month_grid =  month_vertex
+					last_month_day =  (Date.new( the_year, the_month+1, 1)-1).day rescue 31  # rescue covers month > 12
+					day_vertices = ( 1 .. last_month_day ).map do | the_day | 
+						day_vertex = TG::Tag.create value: the_day  
+						TG::GRID_OF.create( from: day_grid , to: day_vertex ) if day_grid.present?
+						day_grid =  day_vertex
+						if kind_of_grid == 'hourly'
+							hour_vertices = (0 .. 23).map do |h| 
+								hour_vertex =  Stunde.create( value: h)
+
+								TG::GRID_OF.create( from: hour_grid , to: hour_vertex ) if hour_grid.present?
+								hour_grid =  hour_vertex
+								hour_vertex # return_value
+							end
+							TG::TIME_OF.create from: day_vertex, to: hour_vertices
+						end 
+						day_vertex # return_value
+					end
+					TG::DAY_OF.create from: month_vertex, to: day_vertices
+					month_vertex # return_value
+				end
+				print "#{the_year} "
+				TG::MONTH_OF.create from: year_vertex, to: month_vertices
+			end
+			print "\n"
+			V.db.logger.level =  previous_looger_level 
+		end
+	end
+end # class
+end # Module
+## here we start if the file is called from the command-lind
+if $0 == __FILE__
+	require './config/boot'
+	#TG::Setup.init_database   # --> config/init_db
+	TG::TimeGraph.populate
+
+
+	print "\n" * 4
+	puts '-' * 40
+	puts "Features of the DateTime Graph"
+	puts '-' * 40
+	puts
+	puts "Allocated Month   => Monat.first.value:\t\t" + Monat.first.value.to_s
+	puts
+	puts "Adressing Days    => Monat.first.tag[2].value:\t" + Monat.first.tag[2].value.to_s
+	puts
+	puts "Display Date      => Monat.first.tag[13].datum:\t"+ Monat.first.tag[13].datum.to_s
+
+	puts "Display next Date => Monat.first.tag[13].next.datum:\t"+ Monat.first.tag[13].next.datum.to_s
+
+
+
+
+end

data/model/e.rb

@@ -0,0 +1,7 @@
+
+ class E #< ActiveOrient::Model
+      def self.naming_convention name=nil
+          name.present? ? name.upcase : ref_name.upcase
+      end
+  end
+

data/model/tg/day_of.rb

@@ -0,0 +1,3 @@
+class  TG::DAY_OF  
+
+end

data/model/tg/grid_of.rb

@@ -0,0 +1,3 @@
+class  TG::GRID_OF  
+
+end

data/model/tg/jahr.rb

@@ -0,0 +1,22 @@
+
+class TG::Jahr #< TG::TimeBase
+  def der_monat m
+    m >0 && m<13 ? out_tg_month_of[m].in : nil
+  end
+ 
+  # returns an array of days
+  # thus enables the use as  
+  #   Monat[9].tag[9]
+  def monat  *key
+		if key.blank?
+			out_tg_month_of.in
+		else
+			key=  key.first		if key.is_a?(Array) && key.size == 1 
+			#	out_tg_month_of[key].in
+			nodes( :out, via: /month/ , where: { value: key } )
+		end
+  end
+
+    
+  end
+

data/model/tg/monat.rb

@@ -0,0 +1,57 @@
+class TG::Monat # < TG::TimeBase
+	# starts at a given month-entry
+	#   tg_monat.in tg_month_of out --> tg_jahr
+	def _jahr
+		query.nodes :in, via: TG::MONTH_OF
+	end
+  def der_tag d
+#    d=d-1
+    d >0 && d<31 ? out_tg_day_of[d].in : nil
+  end
+ 
+  # returns an array of days
+  # thus enables the use as  
+  #   Monat[9].tag[9]
+  def tag *key
+    if key.blank? 
+			out_tg_day_of.in
+    else
+#			out_tg_day_of.in
+			key=  key.first		if key.size == 1
+			nodes( :out, via: /day/ , where: { value: key } )
+    end
+  end
+
+  # returns the specified edge 
+  #  i.e.  Monat[9]
+  #
+
+  def jahr
+		_jahr.execute.first
+#    in_tg_month_of.out.first
+  end
+
+	# returns the absolute Month-Value
+  #
+  # enables easy calculations betwwen month-vertices
+	#
+	# i.e.  TG::Jahr[2013].monat(4).abs_value.first - TG::Jahr[2012].monat(9).abs_value.first 
+	#       => 7
+	def abs_value
+		jahr.value * 12 + value
+	end
+
+	def self.fetch datum , &b  # parameter: a date
+#		query_database( "select  expand (out_tg_day_of.in[value = #{datum.day}]) from (select  expand (out_tg_month_of.in[value = #{datum.month}]) from (select from tg_jahr where value = #{datum.year} ) ) ") &.first
+		q = OrientSupport::OrientQuery.new  from: TG::Jahr, where: { value: datum.year }
+		w = OrientSupport::OrientQuery.new  from: q
+		w.nodes :out, via: TG::MONTH_OF, where: { value: datum.month }
+		
+		query_database( w,  &b).first 
+	end
+
+#TG::Monat.fetch Date.new(2000,4,5)
+#21.06.(06:29:11) INFO->select  expand (  outE('tg_month_of').in[ value = 4 ]  ) from  ( select from tg_jahr where value = 2000  )  
+# => #<TG::Monat:0x00000000032fbe28 @metadata={:type=>"d", :class=>"tg_monat", :version=>34, :fieldTypes=>"out_tg_day_of=g,in_tg_month_of=g,in_tg_grid_of=g,out_tg_grid_of=g", :cluster=>132, :record=>225, :edges=>{:in=>["tg_month_of", "tg_grid_of"], :out=>["tg_day_of", "tg_grid_of"]}}, @d=nil, @attributes={:out_tg_day_of=>["#158:6859", "#159:6859", "#160:6859", "#153:6860", "#154:6860", "#155:6860", "#156:6860", "#157:6860", "#158:6860", "#159:6860", "#160:6860", "#153:6861", "#154:6861", "#155:6861", "#156:6861", "#157:6861", "#158:6861", "#159:6861", "#160:6861", "#153:6862", "#154:6862", "#155:6862", "#156:6862", "#157:6862", "#158:6862", "#159:6862", "#160:6862", "#153:6863", "#154:6863", "#155:6863"], :in_tg_month_of=>["#164:225"], :value=>4, :in_tg_grid_of=>["#173:7103"], :out_tg_grid_of=>["#172:7107"]}> 
+
+end

data/model/tg/stunde.rb

@@ -0,0 +1,16 @@
+class TG::Stunde # < TG::TimeBase
+
+  def tag
+    in_tg_time_of.out
+  end
+
+  def datum
+    month = in_tg_time_of.out.in_tg_day_of.out.value
+    day =  in_tg_time_of.out.value
+    "#{day.first}.#{month.flatten.first}.#{Date.today.year} #{value}:00"
+  end
+  def next
+    puts value.inspect
+    in_tg_day_of.out.first.tag( value + 1 )
+  end
+end