kaltura-ruby 0.1.0

data/lib/kaltura_client_base.rb

@@ -0,0 +1,282 @@
+require 'rubygems'
+require 'json'
+require 'net/http'
+require 'digest/md5'
+require 'rexml/document'
+
+module Kaltura
+	class KalturaClientBase
+		attr_accessor 	:config
+		attr_accessor 	:ks
+		attr_reader 	:is_multirequest
+	
+		def initialize(config)
+			@should_log = false
+			@config = config
+			@calls_queue = []
+	
+			if @config.logger != nil
+				@should_log = true
+			end
+		end
+		
+		def queue_service_action_call(service, action, params = {})
+			# in start session partner id is optional (default -1). if partner id was not set, use the one in the config
+			if (!params.key?('partnerId') || params['partnerId'] == -1)
+				params['partnerId'] = config.partner_id;
+			end	
+			
+			add_param(params, 'ks', @ks);
+			
+			call = KalturaServiceActionCall.new(service, action, params);
+			@calls_queue.push(call);
+		end
+	
+		def do_queue()
+			start_time = Time.now
+			
+			if @calls_queue.length == 0
+				@is_multirequest = false
+				return nil
+			end
+					
+			log('service url: [' + @config.service_url + ']')
+			
+			# append the basic params
+			params = {}
+			add_param(params, "format", @config.format)
+			add_param(params, "clientTag", @config.client_tag)
+			
+			url = @config.service_url+"/api_v3/index.php?service="
+			if (@is_multirequest)
+				url += "multirequest"
+				i = 1
+				@calls_queue.each_value do |call|
+					call_params = call.get_params_for_multirequest(i.next)
+					params.merge!(call_params)
+				end
+			else
+				call = @calls_queue[0]
+				url += call.service + "&action=" + call.action
+				params.merge!(call.params)
+			end
+			
+			# reset
+			@calls_queue = []
+			@is_multirequest = false
+			
+			signature = signature(params)
+			add_param(params, "kalsig", signature)
+			
+			log("url: " + url)
+			log("params: " + params.to_yaml)
+			
+			result = do_http_request(url, params)
+			
+			result_object = parse_to_objects(result.body)
+
+			log("result (object yaml dump): " + result_object.to_yaml)
+			
+			end_time = Time.now
+			log("execution time for [#{url}]: [#{end_time - start_time}]")
+			
+			return result_object			
+		end
+		
+		def do_http_request(url, params)
+			url = URI.parse(url)
+			req = Net::HTTP::Post.new(url.path + '?' + url.query)
+			req.set_form_data(params)
+			res = Net::HTTP.new(url.host, url.port).start { |http| http.request(req) }
+			return res
+		end
+		
+		def parse_to_objects(data)
+			parse_xml_to_objects(data)
+		end
+		
+		def parse_xml_to_objects(xml)
+			doc = REXML::Document.new(xml)
+			doc.elements.each('xml/result') do | element |
+				return KalturaClassFactory.object_from_xml(element)
+			end
+		end
+		
+		def parse_element_to_object(xml_element)
+		end
+		
+		def parse_elements_to_array(xml_elements)
+			xml_elements.each('item') do | element |
+			end
+		end
+		
+		def start_multirequest()
+			@is_multirequest = true
+		end
+	
+		def do_multirequest()
+			return do_queue()
+		end
+
+		def signature(params)
+			str = params.keys.map {|key| key.to_s }.sort.map {|key|
+				"#{escape(key)}#{escape(params[key])}"
+			}.join("")
+			
+			Digest::MD5.hexdigest(str)
+		end
+		
+		def add_param(params, name, value)
+			if value == nil
+				return
+			elsif value.is_a? Hash
+				value.each do |sub_name, sub_value|
+					add_param(params, "#{name}:#{sub_name}", sub_value);
+				end
+			elsif value.is_a? KalturaObjectBase
+				add_param(params, name, value.to_params)
+			else
+				params[name] = value
+			end
+		end
+	
+		# Escapes a query parameter. Stolen from RFuzz
+		def escape(s)
+			s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
+				'%' + $1.unpack('H2'*$1.size).join('%').upcase
+			}.tr(' ', '+')
+		end
+		
+		def log(msg)
+			if @should_log
+				config.logger.log(msg)
+			end
+		end
+	end
+	
+	class KalturaServiceActionCall
+		attr_accessor :service
+		attr_accessor :action
+		attr_accessor :params
+	
+		def initialize(service, action, params = array())
+			@service = service
+			@action = action
+			@params = parse_params(params)
+		end
+	
+		def parse_params(params)
+			new_params = {}
+			params.each do |key, val| 
+				if val.kind_of? Hash
+					new_params[key] = parse_params(val)
+				else
+					new_params[key] = val
+				end
+			end
+			return new_params
+		end
+	
+		def get_params_for_multirequest(multirequest_index)
+			multirequest_params = {}
+			multirequest_params[multirequest_index+":service"] = @service
+			multirequest_params[multirequest_index+":action"] = @action
+			@params.each do |key|
+				multirequest_params[multirequest_index+":"+key] = @params[key]
+			end
+			return multirequest_params
+		end
+	end
+
+	class KalturaObjectBase
+		attr_accessor :object_type
+		
+		def to_params
+			params = {};
+			params["objectType"] = self.class.name.split('::').last 
+			instance_variables.each do |var|
+				value = instance_variable_get(var)
+				var = var.sub('@', '')
+				kvar = camelcase(var)
+				if (value != nil)
+					if (value.is_a? KalturaObjectBase)
+						params[kvar] = value.to_params;
+					else
+						params[kvar] = value;
+					end
+				end
+			end
+			return params;
+		end
+		
+		def to_b(val)
+			return [true, 'true', 1, '1'].include?(val.is_a?(String) ? val.downcase : val)
+		end
+		
+		def camelcase(val)
+			val = val.split('_').map { |e| e.capitalize }.join()
+			val[0,1].downcase + val[1,val.length]
+		end
+	end
+	
+	class KalturaServiceBase
+		attr_accessor :client
+		
+		def initialize(client)
+			@client = client
+		end
+	end
+
+	class KalturaConfiguration
+		attr_accessor :logger
+		attr_accessor :service_url
+		attr_accessor :format
+		attr_accessor :client_tag
+		attr_accessor :timeout
+		attr_accessor :partner_id
+	
+		def initialize(partner_id = -1)
+			@service_url 	= "http://www.kaltura.com"
+			@format 		= 2 # xml
+			@client_tag 	= "ruby"
+			@timeout 		= 10
+			@partner_id 	= partner_id
+		end
+		
+		def service_url=(url)
+			@service_url = url.chomp('/')
+		end
+	end
+	
+	class KalturaClassFactory
+		def self.object_from_xml(xml_element)
+			instance = nil
+	        if xml_element.elements.size > 0
+				if xml_element.elements[1].name == 'item' # array	
+					instance = []
+					xml_element.elements.each('item') do | element |
+						instance.push(KalturaClassFactory.object_from_xml(element))
+					end
+				else # object
+					object_type_element = xml_element.get_text('objectType')
+					if (object_type_element != nil)
+						object_class = xml_element.get_text('objectType').value
+						instance = Object.const_get(object_class).new
+						xml_element.elements.each do | element |
+							value = KalturaClassFactory.object_from_xml(element)
+							instance.send(self.underscore(element.name) + "=", value);
+						end
+					end
+				end
+			else # simple type
+	        	return xml_element.text
+	       	end
+	
+	       	return instance;
+		end
+		
+		def self.underscore(val)
+			val.gsub(/(.)([A-Z])/,'\1_\2').downcase
+		end
+	end
+end

data/lib/test.rb

@@ -0,0 +1,26 @@
+require "ruby_client.rb"
+
+include Kaltura
+
+config = KalturaConfiguration.new(450)
+#config.logger = MyLog.new
+#config.service_url = 'http://www.kaltura.com/'
+client = KalturaClient.new(config)
+secret = ''
+ks = client.session_service.start(secret, '', KalturaSessionType::ADMIN)
+puts ks
+client.ks = ks
+filter = KalturaFilter.new
+pager = KalturaFilterPager.new
+pager.page_size = 1
+pager.page_index = 2
+#result = client.mixing_service.list(filter, pager);
+media_entry = KalturaMediaEntry.new
+media_entry.name = "Testing Ruby Client"
+media_entry.media_type = KalturaMediaType::VIDEO
+url = 'http://kaldev.kaltura.com/content/zbale/roman/kaltura_logo_animated_black_1.flv';
+media_entry = client.media_service.add_from_url(media_entry, url);
+puts media_entry.to_yaml
+
+#puts result.to_yaml
+#puts result.objects[0].has_real_thumbnail

data/test/kaltura-ruby_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class KalturaRubyTest < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

data/test/test.rb

@@ -0,0 +1,23 @@
+require "kaltura_client.rb"
+
+include Kaltura
+conf = KalturaConfiguration.new(250, 25000)
+user = KalturaSessionUser.new(2)
+cl = KalturaClient.new(conf)
+secert = 'dae1be648b8a86d25adafdac2d32e8c3'
+cl.start(user, secert)
+
+kshow = KalturaKShow.new()
+kshow.name = "test ruby"
+kshow.description = "desc ruby"
+
+result = cl.addKShow(user, kshow, 1)
+
+print (result['result']['kshow']['name'])
+
+print("\n")
+print("\n")
+
+result = cl.search(user, KalturaEntryMediaType::VIDEO, KalturaEntryMediaSource::MYSPACE, "funny");
+
+print (result['result'])

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'kaltura-ruby'
+
+class Test::Unit::TestCase
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification 
+name: kaltura-ruby
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- papyromancer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-16 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activeresource
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+description: 
+email: papyromancer@papyromancer.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- VERSION.yml
+- kaltura-ruby.gemspec
+- lib/kaltura-ruby.rb
+- lib/kaltura_client.rb
+- lib/kaltura_client_base.rb
+- lib/test.rb
+- test/kaltura-ruby_test.rb
+- test/test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/papyromancer/kaltura-ruby
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby gem for accessing the Kaltura API
+test_files: 
+- test/kaltura-ruby_test.rb
+- test/test.rb
+- test/test_helper.rb