knjrbfw 0.0.3

data/lib/knj/objects.rb

@@ -0,0 +1,731 @@
+class Knj::Objects
+	attr_reader :args, :events
+	
+	def initialize(args)
+		@callbacks = {}
+		@args = Knj::ArrayExt.hash_sym(args)
+		@args[:col_id] = :id if !@args[:col_id]
+		@args[:class_pre] = "class_" if !@args[:class_pre]
+		@args[:module] = Kernel if !@args[:module]
+		@objects = {}
+		@objects_mutex = Mutex.new
+		
+		@events = Knj::Event_handler.new
+		@events.add_event(
+      :name => :no_html,
+      :connections_max => 1
+		)
+		
+		raise "No DB given." if !@args[:db]
+		raise "No class path given." if !@args[:class_path] and (@args[:require] or !@args.has_key?(:require))
+	end
+	
+	#Returns a cloned version of the @objects variable. Cloned because iteration on it may crash some of the other methods in Ruby 1.9+
+	def objects
+		objs_cloned = {}
+		
+		@objects_mutex.synchronize do
+			@objects.each do |classn, newhash|
+				objs_cloned[classn] = newhash.clone
+			end
+		end
+		
+		return objs_cloned
+	end
+	
+	def db
+		return @args[:db]
+	end
+	
+	def count_objects
+		count = 0
+		@objects_mutex.synchronize do
+			@objects.each do |key, value|
+				value.each do |id, object|
+					count += 1
+				end
+			end
+		end
+		
+		return count
+	end
+	
+	def connect(args, &block)
+		raise "No object given." if !args["object"]
+		raise "No signals given." if !args.has_key?("signal") and !args.has_key?("signals")
+		args["block"] = block if block_given?
+		@callbacks[args["object"]] = {} if !@callbacks[args["object"]]
+		conn_id = @callbacks[args["object"]].length.to_s
+		@callbacks[args["object"]][conn_id] = args
+	end
+	
+	def call(args, &block)
+		classstr = args["object"].class.to_s
+		
+		if @callbacks[classstr]
+			@callbacks[classstr].clone.each do |callback_key, callback|
+				docall = false
+				
+				if callback.has_key?("signal") and args.has_key?("signal") and callback["signal"] == args["signal"]
+					docall = true
+				elsif callback["signals"] and args["signal"] and callback["signals"].index(args["signal"]) != nil
+					docall = true
+				end
+				
+				next if !docall
+				
+				if callback["block"]
+					callargs = []
+					arity = callback["block"].arity
+					if arity <= 0
+						#do nothing
+					elsif arity == 1
+						callargs << args["object"]
+					else
+						raise "Unknown number of arguments: #{arity}"
+					end
+					
+					callback["block"].call(*callargs)
+				elsif callback["callback"]
+					Knj::Php.call_user_func(callback["callback"], args)
+				else
+					raise "No valid callback given."
+				end
+			end
+		end
+	end
+	
+	def requireclass(classname)
+		return nil if !@args[:require] and @args.has_key?(:require)
+		classname = classname.to_s
+		
+		if !Knj::Php.class_exists(classname)
+			filename = @args[:class_path] + "/#{@args[:class_pre]}#{classname.downcase}.rb"
+			filename_req = @args[:class_path] + "/#{@args[:class_pre]}#{classname.downcase}"
+			raise "Class file could not be found: #{filename}." if !File.exists?(filename)
+			require filename_req
+		end
+	end
+	
+	def get(classname, data)
+		classname = classname.to_sym
+		
+		if data.is_a?(Hash) and data[@args[:col_id].to_sym]
+			id = data[@args[:col_id].to_sym].to_i
+		elsif data.is_a?(Hash) and data[@args[:col_id].to_s]
+			id = data[@args[:col_id].to_s].to_i
+		elsif data.is_a?(Integer) or data.is_a?(String) or data.is_a?(Fixnum)
+			id = data.to_i
+		elsif
+			raise Knj::Errors::InvalidData, "Unknown data: '#{data.class.to_s}'."
+		end
+		
+		return @objects[classname][id] if @objects.has_key?(classname) and @objects[classname].has_key?(id)
+		
+		retobj = nil
+		@objects_mutex.synchronize do
+			if !@objects.has_key?(classname)
+				self.requireclass(classname)
+				@objects[classname] = {}
+			end
+			
+			if @args[:datarow]
+				@objects[classname][id] = @args[:module].const_get(classname).new(Knj::Hash_methods.new(
+					:ob => self,
+					:data => data
+				))
+			else
+				args = [data]
+				args = args | @args[:extra_args] if @args[:extra_args]
+				@objects[classname][id] = @args[:module].const_get(classname).new(*args)
+			end
+			
+			return @objects[classname][id]
+		end
+		
+		raise "Something went wrong."
+	end
+	
+	def get_by(classname, args = {})
+		classname = classname.to_sym
+		self.requireclass(classname)
+		classob = @args[:module].const_get(classname)
+		
+		raise "list-function has not been implemented for #{classname}" if !classob.respond_to?("list")
+		
+		args[:limit_from] = 0
+		args[:limit_to] = 1
+		
+		self.list(classname, args) do |obj|
+			return obj
+		end
+		
+		return false
+	end
+	
+	def get_try(obj, col_name, obj_name = nil)
+		if !obj_name
+			if match = col_name.to_s.match(/^(.+)_id$/)
+				obj_name = Knj::Php.ucwords(match[1]).to_sym
+			else
+				raise "Could not figure out objectname for: #{col_name}."
+			end
+		end
+		
+		id_data = obj[col_name].to_i
+		return false if !id_data
+		
+		begin
+			return self.get(obj_name, id_data)
+		rescue Knj::Errors::NotFound
+			return false
+		end
+	end
+	
+	def list(classname, args = {}, &block)
+		classname = classname.to_sym
+		self.requireclass(classname)
+		classob = @args[:module].const_get(classname)
+		
+		raise "list-function has not been implemented for #{classname}" if !classob.respond_to?("list")
+		
+		if @args[:datarow]
+			ret = classob.list(Knj::Hash_methods.new(:args => args, :ob => self, :db => @args[:db]))
+		else
+			realargs = [args]
+			realargs = realargs | @args[:extra_args] if @args[:extra_args]
+			ret = classob.list(*realargs)
+		end
+		
+		if block_given?
+			ret.each do |obj|
+				yield(obj)
+			end
+		else
+			return ret
+		end
+	end
+	
+	def list_opts(classname, args = {})
+		Knj::ArrayExt.hash_sym(args)
+		classname = classname.to_sym
+		
+		if args[:list_args]
+			obs = self.list(classname, args[:list_args])
+		else
+			obs = self.list(classname)
+		end
+		
+		html = ""
+		
+		if args[:addnew] or args[:add]
+			html += "<option"
+			html += " selected=\"selected\"" if !args[:selected]
+			html += " value=\"\">#{_("Add new")}</option>"
+		end
+		
+		obs.each do |object|
+			html += "<option value=\"#{object.id.html}\""
+			
+			selected = false
+			if args[:selected].is_a?(Array) and args[:selected].index(object) != nil
+				selected = true
+			elsif args[:selected] and args[:selected].respond_to?("is_knj?") and args[:selected].id.to_s == object.id.to_s
+				selected = true
+			end
+			
+			html += " selected=\"selected\"" if selected
+			
+			obj_methods = object.class.instance_methods(false)
+			
+			begin
+				if obj_methods.index("name") != nil or obj_methods.index(:name) != nil
+					objhtml = object.name.html
+				elsif obj_methods.index("title") != nil or obj_methods.index(:title) != nil
+					objhtml = object.title.html
+				elsif object.respond_to?(:data)
+					obj_data = object.data
+					
+					if obj_data.has_key?(:name)
+						objhtml = obj_data[:name]
+					elsif obj_data.has_key?(:title)
+						objhtml = obj_data[:title]
+					end
+				else
+          objhtml = ""
+        end
+				
+				raise "Could not figure out which name-method to call?" if !objhtml
+				html += ">#{objhtml}</option>"
+			rescue Exception => e
+				html += ">[#{object.class.name}: #{e.message}]</option>"
+			end
+		end
+		
+		return html
+	end
+	
+	def list_optshash(classname, args = {})
+		Knj::ArrayExt.hash_sym(args)
+		classname = classname.to_sym
+		
+		if args[:list_args]
+			obs = self.list(classname, args[:list_args])
+		else
+			obs = self.list(classname)
+		end
+		
+		if Knj::Php.class_exists("Dictionary")
+			list = Dictionary.new
+		else
+			list = Hash.new
+		end
+		
+		if args[:addnew] or args[:add]
+			list["0"] = _("Add new")
+		elsif args[:choose]
+			list["0"] = _("Choose") + ":"
+		elsif args[:all]
+			list["0"] = _("All")
+		elsif args[:none]
+			list["0"] = _("None")
+		end
+		
+		obs.each do |object|
+			list[object.id] = object.title
+		end
+		
+		return list
+	end
+	
+	# Returns a list of a specific object by running specific SQL against the database.
+	def list_bysql(classname, sql)
+		classname = classname.to_sym
+		
+		ret = [] if !block_given?
+		@args[:db].q(sql) do |d_obs|
+			if block_given?
+				yield(self.get(classname, d_obs))
+			else
+				ret << self.get(classname, d_obs)
+			end
+		end
+		
+		return ret if !block_given?
+	end
+	
+	# Add a new object to the database and to the cache.
+	def add(classname, data = {})
+		classname = classname.to_sym
+		self.requireclass(classname)
+		
+		args = [data]
+		args = args | @args[:extra_args] if @args[:extra_args]
+		
+		if @args[:datarow]
+      classobj = @args[:module].const_get(classname)
+			if classobj.respond_to?(:add)
+				classobj.add(Knj::Hash_methods.new(
+					:ob => self,
+					:db => self.db,
+					:data => data
+				))
+			end
+			
+			required_data = classobj.required_data
+			required_data.each do |req_data|
+        if !data.has_key?(req_data[:col])
+          raise "No '#{req_data[:class]}' given by the data '#{req_data[:col]}'."
+        end
+        
+        begin
+          obj = self.get(req_data[:class], data[req_data[:col]])
+        rescue Knj::Errors::NotFound
+          raise "The '#{req_data[:class]}' by ID '#{data[req_data[:col]]}' could not be found with the data '#{req_data[:col]}'."
+        end
+			end
+			
+			ins_id = @args[:db].insert(classname, data, {:return_id => true})
+			retob = self.get(classname, ins_id)
+		else
+			retob = @args[:module].const_get(classname).add(*args)
+		end
+		
+		self.call("object" => retob, "signal" => "add")
+		if retob.respond_to?(:add_after)
+			retob.send(:add_after, {})
+		end
+		
+		return retob
+	end
+	
+	def adds(classname, datas)
+		if !@args[:datarow]
+			datas.each do |data|
+				@args[:module].const_get(classname).add(*args)
+				self.call("object" => retob, "signal" => "add")
+			end
+		else
+			if @args[:module].const_get(classname).respond_to?(:add)
+				datas.each do |data|
+					@args[:module].const_get(classname).add(Knj::Hash_methods.new(
+						:ob => self,
+						:db => self.db,
+						:data => data
+					))
+				end
+			end
+			
+			db.insert_multi(classname, datas)
+		end
+	end
+	
+	def static(class_name, method_name, *args)
+		raise "Only available with datarow enabled." if !@args[:datarow]
+		class_name = class_name.to_sym
+		method_name = method_name.to_sym
+		
+		self.requireclass(class_name)
+		class_obj = @args[:module].const_get(class_name)
+		raise "The class '#{class_obj.name}' has no such method: '#{method_name}'." if !class_obj.respond_to?(method_name)
+		method_obj = class_obj.method(method_name)
+		
+		pass_args = []
+		pass_args << Knj::Hash_methods.new(
+			:ob => self,
+			:db => self.db
+		)
+		
+		args.each do |arg|
+			pass_args << arg
+		end
+		
+		method_obj.call(*pass_args)
+	end
+	
+	# Unset object. Do this if you are sure, that there are no more references left. This will be done automatically when deleting it.
+	def unset(object)
+		if object.is_a?(Array)
+			object.each do |obj|
+				unset(obj)
+			end
+			return nil
+		end
+		
+		classname = object.class.name
+		
+		if @args[:module]
+			classname = classname.gsub(@args[:module].name + "::", "")
+		end
+		
+		classname = classname.to_sym
+		
+		#if !@objects.has_key?(classname)
+			#raise "Could not find object class in cache: #{classname}."
+		#elsif !@objects[classname].has_key?(object.id.to_i)
+			#errstr = ""
+			#errstr += "Could not unset object from cache.\n"
+			#errstr += "Class: #{object.class.name}.\n"
+			#errstr += "ID: #{object.id}.\n"
+			#errstr += "Could not find object ID in cache."
+			#raise errstr
+		#else
+			@objects_mutex.synchronize do
+				@objects[classname].delete(object.id.to_i)
+			end
+		#end
+	end
+	
+	def unset_class(classname)
+		if classname.is_a?(Array)
+			classname.each do |classn|
+				self.unset_class(classn)
+			end
+			
+			return false
+		end
+		
+		classname = classname.to_sym
+		
+		return false if !@objects.has_key?(classname)
+		@objects_mutex.synchronize do
+			@objects[classname] = {}
+		end
+	end
+	
+	# Delete an object. Both from the database and from the cache.
+	def delete(object)
+		self.call("object" => object, "signal" => "delete_before")
+		self.unset(object)
+		obj_id = object.id
+		object.delete if object.respond_to?(:delete)
+		
+		if @args[:datarow]
+      object.class.depending_data.each do |dep_data|
+        objs = self.list(dep_data[:classname], {dep_data[:colname].to_s => object.id, "limit" => 1})
+        if !objs.empty?
+          raise "Cannot delete <#{object.class.name}:#{object.id}> because <#{objs[0].class.name}:#{objs[0].id}> depends on it."
+        end
+      end
+      
+			@args[:db].delete(object.table, {:id => obj_id})
+		end
+		
+		self.call("object" => object, "signal" => "delete")
+		object.destroy
+	end
+	
+	def deletes(objs)
+		if !@args[:datarow]
+			objs.each do |obj|
+				self.delete(obj)
+			end
+		else
+			arr_ids = []
+			ids = []
+			objs.each do |obj|
+				ids << obj.id
+				if ids.length >= 1000
+					arr_ids << ids
+					ids = []
+				end
+				
+				obj.delete if obj.respond_to?(:delete)
+			end
+			
+			arr_ids << ids if ids.length > 0
+			arr_ids.each do |ids|
+				@args[:db].delete(objs[0].table, {:id => ids})
+			end
+		end
+	end
+	
+	# Try to clean up objects by unsetting everything, start the garbagecollector, get all the remaining objects via ObjectSpace and set them again. Some (if not all) should be cleaned up and our cache should still be safe... dirty but works.
+	def clean(classn)
+		if classn.is_a?(Array)
+			classn.each do |realclassn|
+				self.clean(realclassn)
+			end
+		else
+			return false if !@objects.has_key?(classn)
+			@objects_mutex.synchronize do
+				@objects[classn] = {}
+				GC.start
+			end
+		end
+	end
+	
+	def clean_all
+		classnames = []
+		@objects_mutex.synchronize do
+			@objects.each do |classn, hash_list|
+				classnames << classn
+			end
+			
+			classnames.each do |classn|
+				@objects[classn] = {}
+			end
+		end
+		
+		GC.start
+	end
+	
+	def clean_recover
+		@objects_mutex.synchronize do
+			@objects.each do |classn, hash_list|
+				classobj = Kernel.const_get(classn)
+				ObjectSpace.each_object(classobj) do |obj|
+					@objects[classn][obj.id] = obj
+				end
+			end
+		end
+	end
+	
+	def sqlhelper(list_args, args)
+		if args[:db]
+			db = args[:db]
+		else
+			db = @args[:db]
+		end
+		
+		if args[:table]
+			table = "`#{db.esc_table(args[:table])}`."
+		else
+			table = ""
+		end
+		
+		sql_where = ""
+		sql_order = ""
+		sql_limit = ""
+		
+		limit_from = nil
+		limit_to = nil
+		
+		cols_str_has = args.has_key?(:cols_str)
+		cols_num_has = args.has_key?(:cols_num)
+		cols_date_has = args.has_key?(:cols_date)
+		cols_dbrows_has = args.has_key?(:cols_dbrows)
+		cols_bools_has = args.has_key?(:cols_bools)
+		
+		if list_args.has_key?("orderby")
+			orders = []
+			orderstr = list_args["orderby"]
+			
+			if list_args["orderby"].is_a?(String)
+				found = false
+				found = true if !found and cols_str_has and args[:cols_str].index(orderstr) != nil
+				found = true if !found and cols_date_has and args[:cols_date].index(orderstr) != nil
+				found = true if !found and cols_num_has and args[:cols_num].index(orderstr) != nil
+				
+				if found
+					sql_order += " ORDER BY "
+					ordermode = " ASC"
+					if list_args.has_key?("ordermode")
+						if list_args["ordermode"] == "desc"
+							ordermode = " DESC"
+						elsif list_args["ordermode"] == "asc"
+							ordermode = " ASC"
+							raise "Unknown ordermode: #{list_args["ordermode"]}"
+						end
+						
+						list_args.delete("ordermode")
+					end
+					
+					sql_order += "#{table}`#{db.esc_col(list_args["orderby"])}`#{ordermode}"
+					list_args.delete("orderby")
+				end
+			elsif list_args["orderby"].is_a?(Array)
+				sql_order += " ORDER BY "
+				
+				list_args["orderby"].each do |val|
+					if val.is_a?(Array)
+						orderstr = val[0]
+						
+						if val[1] == "asc"
+							ordermode = " ASC"
+						elsif val[1] == "desc"
+							ordermode = "DESC"
+						end
+					elsif val.is_a?(String)
+						orderstr = val
+						ordermode = " ASC"
+					else
+						raise "Unknown object: #{val.class.name}"
+					end
+					
+					found = false
+					found = true if !found and cols_str_has and args[:cols_str].index(orderstr) != nil
+					found = true if !found and cols_date_has and args[:cols_date].index(orderstr) != nil
+					found = true if !found and cols_num_has and args[:cols_num].index(orderstr) != nil
+					found = true if !found and cols_bools_has and args[:cols_bools].index(orderstr) != nil
+					
+					raise "Column not found for ordering: #{orderstr}." if !found
+					orders << "#{table}`#{db.esc_col(orderstr)}`#{ordermode}"
+				end
+				
+				sql_order += orders.join(", ")
+				list_args.delete("orderby")
+			else
+				raise "Unknown orderby object: #{list_args["orderby"].class.name}."
+			end
+		end
+		
+		list_args.each do |key, val|
+			found = false
+			
+			if (cols_str_has and args[:cols_str].index(key) != nil) or (cols_num_has and args[:cols_num].index(key) != nil) or (cols_dbrows_has and args[:cols_dbrows].index(key) != nil)
+        if val.is_a?(Array)
+          escape_sql = Knj::ArrayExt.join(
+            :arr => val,
+            :callback => proc{|value|
+              db.escape(value)
+            },
+            :sep => ",",
+            :surr => "'")
+          sql_where += " AND #{table}`#{db.esc_col(key)}` IN (#{escape_sql})"
+        else
+          sql_where += " AND #{table}`#{db.esc_col(key)}` = '#{db.esc(val)}'"
+        end
+        
+				found = true
+			elsif cols_bools_has and args[:cols_bools].index(key) != nil
+				if val.is_a?(TrueClass) or (val.is_a?(Integer) and val.to_i == 1) or (val.is_a?(String) and (val == "true" or val == "1"))
+					realval = "1"
+				elsif val.is_a?(FalseClass) or (val.is_a?(Integer) and val.to_i == 0) or (val.is_a?(String) and (val == "false" or val == "0"))
+					realval = "0"
+				else
+					raise "Could not make real value out of class: #{val.class.name} => #{val}."
+				end
+				
+				sql_where += " AND #{table}`#{db.esc_col(key)}` = '#{db.esc(realval)}'"
+				found = true
+			elsif key.to_s == "limit_from"
+				limit_from = val.to_i
+				found = true
+			elsif key.to_s == "limit_to"
+				limit_to = val.to_i
+				found = true
+			elsif key.to_s == "limit"
+				limit_from = 0
+				limit_to = val.to_i
+				found = true
+			elsif cols_dbrows_has and args[:cols_dbrows].index(key.to_s + "_id") != nil
+				sql_where += " AND #{table}`#{db.esc_col(key.to_s + "_id")}` = '#{db.esc(val.id)}'"
+				found = true
+			elsif cols_str_has and match = key.match(/^([A-z_\d]+)_(search|has)$/) and args[:cols_str].index(match[1]) != nil
+				if match[2] == "search"
+					Knj::Strings.searchstring(val).each do |str|
+						sql_where += " AND #{table}`#{db.esc_col(match[1])}` LIKE '%#{db.esc(str)}%'"
+					end
+				elsif match[2] == "has"
+					if val
+						sql_where += " AND #{table}`#{db.esc_col(match[1])}` != ''"
+					else
+						sql_where += " AND #{table}`#{db.esc_col(match[1])}` = ''"
+					end
+				end
+				
+				found = true
+			elsif match = key.match(/^([A-z_\d]+)_not$/) and ((cols_str_has and args[:cols_str].index(match[1]) != nil) or (cols_num_has and args[:cols_num].index(match[1]) != nil))
+				sql_where += " AND #{table}`#{db.esc_col(match[1])}` != '#{db.esc(val)}'"
+				found = true
+			elsif cols_date_has and match = key.match(/^(.+)_(day|month|from|to)$/) and args[:cols_date].index(match[1]) != nil
+				if match[2] == "day"
+					sql_where += " AND DATE_FORMAT(#{table}`#{db.esc_col(match[1])}`, '%d %m %Y') = DATE_FORMAT('#{db.esc(val.dbstr)}', '%d %m %Y')"
+				elsif match[2] == "month"
+					sql_where += " AND DATE_FORMAT(#{table}`#{db.esc_col(match[1])}`, '%m %Y') = DATE_FORMAT('#{db.esc(val.dbstr)}', '%m %Y')"
+				elsif match[2] == "from"
+					sql_where += " AND #{table}`#{db.esc_col(match[1])}` >= '#{db.esc(val.dbstr)}'"
+				elsif match[2] == "to"
+					sql_where += " AND #{table}`#{db.esc_col(match[1])}` <= '#{db.esc(val.dbstr)}'"
+				else
+					raise "Unknown date-key: #{match[2]}."
+				end
+				
+				found = true
+			elsif cols_num_has and match = key.match(/^(.+)_(from|to)$/) and args[:cols_num].index(match[1]) != nil
+				if match[2] == "from"
+					sql_where += " AND #{table}`#{db.esc_col(match[1])}` <= '#{db.esc(val)}'"
+				elsif match[2] == "to"
+					sql_where += " AND #{table}`#{db.esc_col(match[1])}` >= '#{db.esc(val)}'"
+				else
+					raise "Unknown method of treating cols-num-argument: #{match[2]}."
+				end
+				
+				found = true
+			end
+			
+			list_args.delete(key) if found
+		end
+		
+		if limit_from and limit_to
+			sql_limit = " LIMIT #{limit_from}, #{limit_to}"
+		end
+		
+		return {
+			:sql_where => sql_where,
+			:sql_limit => sql_limit,
+			:sql_order => sql_order
+		}
+	end
+end