acts_as_kaltura 1.0.0

data/README.md

@@ -0,0 +1 @@
+Coming up :)

data/lib/acts_as_kaltura/annotation.rb

@@ -0,0 +1,61 @@
+require 'active_support/concern'
+
+module ActsAsKaltura
+  module Annotation
+    extend ActiveSupport::Concern
+
+    class KalturaAnnotationAddFailure < ::StandardError; end
+    class KalturaAnnotationUpdateFailure < ::StandardError; end
+
+    module ClassMethods
+      def acts_as_kaltura_annotation options = { }
+        before_create :create_kaltura_annotation
+        after_update :update_kaltura_annotation
+        after_destroy :delete_kaltura_annotation
+      end
+    end
+
+    module InstanceMethods
+
+      def create_kaltura_annotation
+        if self.cuepoint_key.nil?
+          @kaltura_annotation = self.class.kaltura_client.cuepoint_service.
+              add( self.as_annotation_cuepoint )
+          raise KalturaAnnotationAddFailure if @kaltura_annotation.nil?
+
+          self.cuepoint_key = @kaltura_annotation.id.to_s
+        end
+      end
+
+      def update_kaltura_annotation
+        if self.cuepoint_key.present?
+          @kaltura_annotation = self.class.kaltura_client.cuepoint_service.
+              update(self.cuepoint_key, self.as_annotation_cuepoint )
+          raise KalturaAnnotationUpdateFailure if @kaltura_annotation.nil?
+        end
+      end
+
+      def delete_kaltura_annotation
+        if self.cuepoint_key.present?
+          self.class.kaltura_client.cuepoint_service.delete(self.cuepoint_key)
+          @kaltura_annotation = nil
+        end
+      end
+
+      def kaltura_annotation
+        @kaltura_annotation ||= find_kaltura_annotation
+      end
+
+      def kaltura_annotation=(annotation)
+        @kaltura_annotation = annotation
+      end
+
+      private
+        def find_kaltura_annotation
+          if self.cuepoint_key.present?
+            self.class.kaltura_client.cuepoint_service.get(self.cuepoint_key)
+          end
+        end
+    end
+  end
+end

data/lib/acts_as_kaltura/callbacks.rb

@@ -0,0 +1,24 @@
+require 'active_support/concern'
+
+module ActsAsKaltura
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :_kaltura_after_save_callbacks
+      @@_kaltura_after_save_callbacks = []
+    end
+
+    module ClassMethods
+      def set_kaltura_after_save_callback(callback_method)
+        _kaltura_after_save_callbacks << callback_method
+      end
+
+      def run_kaltura_after_save_callbacks(instance)
+        if _kaltura_after_save_callbacks.present?
+          _kaltura_after_save_callbacks.each { |m| instance.send m }
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_kaltura/config.rb

@@ -0,0 +1,73 @@
+require 'yaml'
+require 'active_support/concern'
+
+module ActsAsKaltura
+  module Config
+    extend ActiveSupport::Concern
+
+    class Logger
+      def log(*args)
+        puts args
+      end
+    end
+
+    included do
+      cattr_accessor :_kaltura_config_file
+      @@_kaltura_config_file = Rails.root.join('config', 'kaltura.yml').to_s
+
+      cattr_accessor :_kaltura_client
+    end
+
+    module ClassMethods
+      def kaltura_configs(env = Rails.env.to_s)
+        if !defined?(@@_kaltura_configs)
+          @@_kaltura_configs = YAML.load(File.read(_kaltura_config_file)).with_indifferent_access
+        end
+
+        @@_kaltura_configs[env]
+      end
+
+      def kaltura_client(env = Rails.env.to_s)
+        if _kaltura_client.nil?
+          configs = kaltura_configs(env)
+          config  = Kaltura::Configuration.new(configs[:partner_id])
+
+          # Set timeout if mentioned in configuration
+          if configs[:timeout].present?
+            config.timeout = configs[:timeout]
+          end
+
+          # Set debug logger if mentioned in configuration
+          if configs[:debug]
+            config.logger = ActsAsKaltura::Config::Logger.new
+            _debug_response
+          end
+
+          client          = Kaltura::Client.new(config)
+          session         = client.session_service.start(
+              configs[:admin_secret], '', Kaltura::Constants::SessionType::ADMIN)
+          client.ks       = session
+          _kaltura_client = client
+        end
+
+        _kaltura_client
+      end
+
+      def reload_kaltura_client(env = Rails.env.to_s)
+        _kaltura_client = nil
+        kaltura_client
+      end
+
+      def _debug_response
+        if ['test', 'development'].include?(Rails.env)
+          Kaltura::ClientBase.class_eval do
+            def parse_to_objects(data)
+              puts data
+              parse_xml_to_objects(data)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_kaltura/delegator.rb

@@ -0,0 +1,50 @@
+require 'active_support/concern'
+
+module ActsAsKaltura
+  module Delegator
+    extend ActiveSupport::Concern
+
+    included do
+      self.set_kaltura_after_save_callback :reset_kaltura_delegated_attributes
+    end
+
+    module ClassMethods
+      def delegates_kaltura_attributes(attrs)
+        attrs.each do |attr|
+          # def thumbnail_url
+          #   _lookup_local_attribute(:"thumbnail_url") || _lookup_kaltura_attribute(:"thumbnail_url")
+          # end
+          class_eval <<-RUBY
+            def #{attr}
+              self._lookup_local_attribute(:'#{attr.to_s}') ||
+               self._lookup_kaltura_attribute(:'#{attr.to_s}')
+            end
+          RUBY
+        end
+      end
+    end
+
+    module InstanceMethods
+      protected
+        def reset_kaltura_delegated_attributes
+          if self.class._kaltura_options.present?
+            self.class._kaltura_options[:delegate].each do |attr|
+              self.send(:"#{attr}=", nil)
+            end
+          end
+        end
+
+        def _lookup_local_attribute(attr)
+          self.read_attribute attr
+        end
+
+        def _lookup_kaltura_attribute(attr)
+          if entry = self.kaltura_entry
+            value = entry.send(attr)
+            self.update_column(attr, value) if value
+            value
+          end
+        end
+    end
+  end
+end

data/lib/acts_as_kaltura/extension/entry.rb

@@ -0,0 +1,25 @@
+module ActsAsKaltura
+  module Extension
+    class KalturaCuepoint < Kaltura::BaseEntry
+      TYPE_AD         = 'adCuePoint.Ad'
+      TYPE_ANNOTATION = 'annotation.Annotation'
+      TYPE_CODE       = 'codeCuePoint.Code'
+
+      STATUS_DELETED = 2
+      STATUS_READY   = 1
+
+      dual_attr_accessor :createdAt, :cuePointType, :entryId, :forceStop, :id,
+                         :partnerData, :partnerId, :partnerSortValue,
+                         :startTime, :status, :systemName, :tags, :thumbOffset,
+                         :updatedAt, :userId
+    end
+
+    class KalturaAnnotation < KalturaCuepoint
+      dual_attr_accessor :duration, :endTime, :parentId, :text, :cuepointId
+    end
+  end
+end
+
+module Kaltura
+  class Annotation < ActsAsKaltura::Extension::KalturaAnnotation; end
+end

data/lib/acts_as_kaltura/extension/filter.rb

@@ -0,0 +1,34 @@
+module ActsAsKaltura
+  module Extension
+    class KalturaCuepointFilter < Kaltura::Filter::BaseEntryFilter
+      attr_accessor :order_by
+      attr_accessor :advanced_search
+      attr_accessor :id_equal
+      attr_accessor :id_in
+      attr_accessor :cue_point_type_equal
+      attr_accessor :cue_point_type_in
+      attr_accessor :status_equal
+      attr_accessor :status_in
+      attr_accessor :entry_id_equal
+      attr_accessor :entry_id_in
+      attr_accessor :created_at_greater_than_or_equal
+      attr_accessor :created_at_less_than_or_equal
+      attr_accessor :updated_at_greater_than_or_equal
+      attr_accessor :updated_at_less_than_or_equal
+      attr_accessor :tags_like
+      attr_accessor :tags_multi_like_or
+      attr_accessor :tags_multi_like_and
+      attr_accessor :start_time_greater_than_or_equal
+      attr_accessor :start_time_less_than_or_equal
+      attr_accessor :user_id_equal
+      attr_accessor :user_id_in
+      attr_accessor :partner_sort_value_equal
+      attr_accessor :partner_sort_value_in
+      attr_accessor :partner_sort_value_greater_than_or_equal
+      attr_accessor :partner_sort_value_less_than_or_equal
+      attr_accessor :force_stop_equal
+      attr_accessor :system_name_equal
+      attr_accessor :system_name_in
+    end
+  end
+end

data/lib/acts_as_kaltura/extension/response.rb

@@ -0,0 +1,9 @@
+module ActsAsKaltura
+  module Extension
+    class CuePointListResponse < Kaltura::Response::BaseResponse; end
+  end
+end
+
+module Kaltura::Response
+  CuePointListResponse = ActsAsKaltura::Extension::CuePointListResponse
+end

data/lib/acts_as_kaltura/extension/service.rb

@@ -0,0 +1,60 @@
+module ActsAsKaltura
+  module Extension
+    module Service
+
+      class CuePointService < Kaltura::Service::BaseService
+        #
+        # Create new cuepoint
+        def add(cuepoint)
+          kparams = { }
+          client.add_param(kparams, 'cuePoint', cuepoint)
+          perform_request('cuepoint_cuepoint', 'add', kparams, false)
+        end
+
+        #
+        # Retrieve kaltura entry
+        def get(entry_id, version = -1)
+          kparams = { }
+          client.add_param(kparams, 'id', entry_id)
+          client.add_param(kparams, 'version', version)
+          perform_request('cuepoint_cuepoint', 'get', kparams, false)
+        end
+
+        #
+        # Count total available cue points for the specified filtered list
+        def count(filter=nil)
+          kparams = { }
+          client.add_param(kparams, 'filter', filter)
+          perform_request('cuepoint_cuepoint', 'count', kparams, false)
+        end
+
+        #
+        # Update an existing cuepoint object
+        def update(entry_id, cuepoint)
+          kparams = { }
+          client.add_param(kparams, 'id', entry_id)
+          client.add_param(kparams, 'cuePoint', cuepoint)
+          perform_request('cuepoint_cuepoint', 'update', kparams, false)
+        end
+
+        #
+        # Retrieve list of existing videos, you can filter by passing filter
+        # Also paginate through passing paginate object
+        def list(filter = nil, pager = nil)
+          kparams = { }
+          client.add_param(kparams, 'filter', filter)
+          client.add_param(kparams, 'pager', pager)
+          perform_request('cuepoint_cuepoint', 'list', kparams, false)
+        end
+
+        #
+        # Delete the specific cuepoint
+        def delete(entry_id)
+          kparams = { }
+          client.add_param(kparams, 'id', entry_id)
+          perform_request('cuepoint_cuepoint', 'delete', kparams, false)
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_kaltura/extension.rb

@@ -0,0 +1,17 @@
+require 'active_support/concern'
+require 'acts_as_kaltura/extension/entry'
+require 'acts_as_kaltura/extension/response'
+require 'acts_as_kaltura/extension/filter'
+require 'acts_as_kaltura/extension/service'
+
+module ActsAsKaltura
+  module Extension
+    extend ActiveSupport::Concern
+
+    module InstanceMethods
+      def cuepoint_service
+        @cuepoint_service ||= ActsAsKaltura::Extension::Service::CuePointService.new(self)
+      end
+    end
+  end
+end

data/lib/acts_as_kaltura/two_way_attr_accessor.rb

@@ -0,0 +1,28 @@
+require 'active_support/concern'
+
+module ActsAsKaltura
+  module TwoWayAttrAccessor
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def dual_attr_accessor(*var_names)
+        var_names.each do |m|
+          m           = m.to_s
+          setter_proc = lambda do |value|
+            self.instance_variable_set :"@#{m.underscore}", value
+          end
+          self.send :define_method, :"#{m}=", setter_proc
+          self.send :define_method, :"#{m.underscore}=", setter_proc
+
+          getter_proc = lambda { self.instance_variable_get :"@#{m.underscore}" }
+          self.send :define_method, m.to_sym, getter_proc
+          self.send :define_method, :"#{m.underscore}", getter_proc
+        end
+      end
+    end
+  end
+end
+
+class Object
+  include ActsAsKaltura::TwoWayAttrAccessor
+end

data/lib/acts_as_kaltura/video.rb

@@ -0,0 +1,160 @@
+require 'active_support/concern'
+
+module ActsAsKaltura
+  module Video
+    extend ActiveSupport::Concern
+
+    class NoUploadedFile < ::StandardError; end
+    class NoUploadedTokenFound < ::StandardError; end
+    class KalturaVideoAddFailure < ::StandardError; end
+
+    included do
+      class_attribute :_kaltura_options, :instance_writer => false
+    end
+
+    module ClassMethods
+      def acts_as_kaltura_video(options = {})
+        # Set instance accessors
+        attr_accessor :video_file, :uploaded_video_token
+        self._kaltura_options = options
+
+        # Delegate kaltura attributes if :delegate option provided
+        if options[:delegate].present?
+          delegates_kaltura_attributes options[:delegate]
+        end
+
+        # Set validators
+        validates :video_file, :presence => {:on => :create}
+
+        # Set filters
+        before_save :process_uploaded_video_file
+        before_create :create_kaltura_video_entry
+        before_update :update_kaltura_video_entry
+        after_destroy :destroy_kaltura_video_entry
+      end
+    end
+
+    module InstanceMethods
+
+      #
+      # Push user uploaded video file to kaltura server
+      # If successful set upload token with the object
+      #
+      def process_uploaded_video_file
+        if @video_file.present?
+          video_file_stream =  if @video_file.respond_to?(:path, true)
+            File.open(@video_file.path)
+          else
+            @video_file
+          end
+          @uploaded_video_token = self.class.kaltura_client.
+              media_service.upload( video_file_stream )
+          raise ActsAsKaltura::Video::NoUploadedTokenFound if @uploaded_video_token.nil?
+        end
+      end
+
+      #
+      # Create kaltura video entry based on current video data
+      # if successful set kaltura id
+      #
+      def create_kaltura_video_entry
+        if @video_file.present?
+          # There must have uploaded token otherwise this should be invoked
+          raise NoUploadedTokenFound if @uploaded_video_token.nil?
+
+          # Covert host model as kaltura entry
+          entry = as_kaltura_entry
+
+          # Request kaltura service to store video entry for the
+          # uploaded video file
+          stored_entry = add_kaltuar_video_file(entry)
+
+          # Nil return should throw exception
+          raise KalturaVideoAddFailure  if stored_entry.nil?
+
+          # Set kaltura_key from stored kaltura entry
+          self.kaltura_key = stored_entry.id.to_s
+          self.kaltura_syncd_at = Time.now
+
+          self.class.run_kaltura_after_save_callbacks self
+        end
+      end
+
+      #
+      # Update kaltura existing video entry
+      # If successful update kaltura_syncd_at
+      #
+      def update_kaltura_video_entry
+        if kaltura_key.present?
+          entry = as_kaltura_entry
+          update_kaltura_entry(entry)
+
+          if @video_file.nil?
+            entry.id = kaltura_key
+            add_kaltuar_video_file(entry)
+          end
+
+          self.class.run_kaltura_after_save_callbacks self
+        end
+      end
+
+      def kaltura_entry
+        find_kaltura_entry if @kaltura_entry.nil?
+        @kaltura_entry
+      end
+
+      def kaltura_entry=(entry)
+        @kaltura_entry = entry
+      end
+
+      def destroy_kaltura_video_entry
+        if kaltura_key
+          destroy_kaltura_entry
+        end
+      end
+
+      private
+        def add_kaltuar_video_file(entry)
+          if @video_file && @uploaded_video_token
+            self.class.kaltura_client.media_service.
+                add_from_uploaded_file(entry, @uploaded_video_token)
+          end
+        end
+
+        def update_kaltura_entry(entry)
+          if kaltura_key.present?
+            self.class.kaltura_client.media_service.update(kaltura_key, entry)
+            self.kaltura_syncd_at = Time.now
+          end
+        end
+
+        def find_kaltura_entry
+          if kaltura_key
+            if @kaltura_entry.nil?
+              @kaltura_entry = self.class.kaltura_client.media_service.get(kaltura_key)
+            end
+
+            @kaltura_entry
+          end
+        end
+
+        def destroy_kaltura_entry
+          if kaltura_key
+            self.class.kaltura_client.media_service.delete(kaltura_key)
+            @kaltura_entry = nil
+          end
+        rescue
+
+        end
+
+        def as_kaltura_entry
+          Kaltura::MediaEntry.new.tap do |entry|
+            entry.name = title
+            entry.description = description
+            entry.tags = tags.map &:name
+            entry.media_type = Kaltura::Constants::Media::Type::VIDEO
+          end
+        end
+    end
+  end
+end

data/lib/acts_as_kaltura.rb

@@ -0,0 +1,27 @@
+require 'acts_as_kaltura/two_way_attr_accessor'
+require 'acts_as_kaltura/config'
+require 'acts_as_kaltura/callbacks'
+require 'acts_as_kaltura/delegator'
+require 'acts_as_kaltura/extension'
+require 'acts_as_kaltura/video'
+require 'acts_as_kaltura/annotation'
+
+module ActsAsKaltura
+  VERSION = '1.0.0'
+end
+
+module ActiveRecord
+  class Base
+    include ActsAsKaltura::Config
+    include ActsAsKaltura::Callbacks
+    include ActsAsKaltura::Delegator
+    include ActsAsKaltura::Video
+    include ActsAsKaltura::Annotation
+  end
+end
+
+module Kaltura
+  class Client
+    include ActsAsKaltura::Extension
+  end
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification 
+name: acts_as_kaltura
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 1.0.0
+platform: ruby
+authors: 
+- nhm tanveer hossain khan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-02-01 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: velir_kaltura-ruby
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id004
+description: 
+email: hasan@somewherein.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- lib/acts_as_kaltura.rb
+- lib/acts_as_kaltura/annotation.rb
+- lib/acts_as_kaltura/callbacks.rb
+- lib/acts_as_kaltura/config.rb
+- lib/acts_as_kaltura/delegator.rb
+- lib/acts_as_kaltura/extension.rb
+- lib/acts_as_kaltura/extension/entry.rb
+- lib/acts_as_kaltura/extension/filter.rb
+- lib/acts_as_kaltura/extension/response.rb
+- lib/acts_as_kaltura/extension/service.rb
+- lib/acts_as_kaltura/two_way_attr_accessor.rb
+- lib/acts_as_kaltura/video.rb
+- README.md
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: An extension for supporting acts_as_kaltura_video and acts_as_kaltura_annotation (which automatically maintains kaltura video and cuepoint)
+test_files: []
+