kaltura_box 0.0.1

data/lib/kaltura_box/configuration.rb

@@ -0,0 +1,22 @@
+require 'singleton'
+
+module KalturaBox
+  class Config
+    include Singleton
+
+    ATTRIBUTES = [ :login_email, :login_password, :partner_id, :subpartner_id,
+      :administrator_secret, :user_secret, :thumb_width, :thumb_height,
+      :player_conf_id, :service_url, :logger ]
+
+    attr_accessor *ATTRIBUTES
+  end
+
+  def self.config
+    if block_given?
+      yield Config.instance
+    else
+      Config.instance
+    end
+  end
+
+end

data/lib/kaltura_box/entry.rb

@@ -0,0 +1,36 @@
+require 'kaltura_box/entry/class_methods'
+require 'kaltura_box/entry/instance_methods'
+require 'kaltura_box/entry/metadata'
+
+module KalturaBox
+  module Entry
+
+    #
+    # Entry object should have the following attributes:
+    #
+    # entry_id
+    # title
+    # description
+    # title
+    # description
+    # thumbnail_url
+    # data_url
+    # download_url
+    # ms_duration
+    # tags
+    # plays
+    # views
+    #
+
+    def self.included(base)
+      base.extend ClassMethods
+      base.class_eval do
+        include InstanceMethods
+        include ClassMethods
+        include Metadata
+      end
+      super
+    end
+
+  end
+end

data/lib/kaltura_box/entry/class_methods.rb

@@ -0,0 +1,51 @@
+require 'kaltura'
+require 'kaltura_box/client'
+require 'active_record'
+
+module KalturaBox
+  module Entry
+    module ClassMethods
+
+      def upload(upload_object, options={})
+        client = KalturaBox::Client.update_session
+        media_entry = Kaltura::KalturaMediaEntry.new
+
+        options.each do |key, value|
+          media_entry.send("#{key}=", value) if valid_entry_attribute?(key)
+        end
+
+        media_entry.media_type = Kaltura::KalturaMediaType::VIDEO unless options[:media_type]
+
+        if options[:source] == :file
+          upload_token = client.media_service.upload(upload_object)
+          client.media_service.add_from_uploaded_file(media_entry,upload_token).id
+        end
+      end
+
+      def video_list
+        client = KalturaBox::Client.update_session
+        media = Kaltura::KalturaMediaService.new(client)
+        media_list = media.list
+        media_list.objects.reject { |v| v.media_type != 1  }
+      end
+
+      def update_all_videos!
+        video_list.each do |v|
+          self.create(
+            entry_id: v.id,
+            title: v.name,
+            description: v.description,
+            thumbnail_url: v.thumbnail_url,
+            data_url: v.data_url,
+            download_url: v.download_url,
+            ms_duration: v.ms_duration,
+            tags: v.tags,
+            plays: v.plays,
+            views: v.views
+          )
+        end
+      end
+
+    end
+  end
+end

data/lib/kaltura_box/entry/instance_methods.rb

@@ -0,0 +1,13 @@
+module KalturaBox
+  module Entry
+    module InstanceMethods
+
+      def get
+        client = KalturaBox::Client.update_session
+        media = Kaltura::KalturaMediaService.new(client)
+        media.get(self.entry_id)
+      end
+
+    end
+  end
+end

data/lib/kaltura_box/entry/metadata.rb

@@ -0,0 +1,152 @@
+require 'active_support'
+require 'kaltura_box/entry/metadata/class_methods'
+require 'kaltura_box/entry/metadata/class_and_instance_methods'
+
+module KalturaBox
+  module Entry
+
+    ##
+    # The Metadata module provides methods that get/set and add metadata to the
+    # Kaltura installation.
+    #
+    # @author Patrick Robertson
+    ##
+    module Metadata
+
+      ##
+      # @private
+      ##
+      def self.included(base)
+        base.extend ClassAndInstanceMethods
+        base.extend ClassMethods
+        base.class_eval do
+          include ClassAndInstanceMethods
+        end
+        super
+      end
+
+      ##
+      # @private
+      ##
+      def method_missing(name, *args)
+        method_name = name.to_s
+        unless self.class.generated_methods?
+          self.class.define_attribute_methods
+          if self.class.generated_methods.include?(method_name)
+            return self.send(name,*args)
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+
+      ##
+      # @private
+      ##
+      def respond_to?(method)
+        case method.to_s
+        when /^(get|set)_(.*)/
+          valid_entry_attribute?($2.to_sym) || super
+        when /^(add)_(.*)/
+          (valid_entry_attribute?($2.pluralize.to_sym) && valid_add_attribute?($2) ) || super
+        else
+          super
+        end
+      end
+
+      ##
+      # Gets a Kaltura::MediaEntry given a Kaltura entry.
+      #
+      # @param [String] video_id Kaltura entry_id of the video.
+      #
+      # @return [Kaltura::MediaEntry] The MediaEntry object for the Kaltura entry.
+      # @raose [Kaltura::APIError] Raises a kaltura error if it can't find the entry.
+      ##
+      def get_entry(entry_id)
+        client = KalturaBox::Client.update_session
+        client.media_service.get(entry_id)
+      end
+
+      ##
+      # Sets a specific Kaltura::MediaEntry attribute given a Kaltura entry.
+      # This method is called by method_missing, allowing this module set attributes based
+      # off of the current API wrapper, rather than having to update along side the API wrapper.
+      #
+      # @param [String] attr_name The attribute to set.
+      # @param [String] entry_id The Kaltura entry ID.
+      # @param [String] value The value you wish to set the attribute to.
+      #
+      # @return [String] Returns the value as stored in the Kaltura database.  Tag strings come back
+      #   slightly funny.
+      #
+      # @raise [Kaltura::APIError] Passes Kaltura API errors directly through.
+      ##
+      def set_attribute(attr_name,entry_id,value)
+        client = KalturaBox::Client.update_session
+        media_entry = Kaltura::KalturaMediaEntry.new
+        media_entry.send("#{attr_name}=",value)
+        client.media_service.update(entry_id,media_entry).send(attr_name.to_sym)
+
+      end
+
+      ##
+      # Sets multiple Kaltura::MediaEntry attributes in one convienant method.
+      #
+      # @param [String] entry_id The Kaltura entry ID.
+      # @param [Hash] attributes
+      # @option attributes [String] :attribute A Kaltura::MediaEntry attribute to set
+      ##
+      def set(entry_id, attributes={})
+        KalturaBox::Client.update_session
+
+        attributes.each do |key,value|
+          attribute = key.to_s
+          set_attribute(attribute,entry_id,value) if valid_entry_attribute?(key)
+        end
+      end
+
+      ##
+      # @private
+      ##
+      def category_exists?(category_name)
+        client = KalturaBox::Client.update_session
+
+        category_filter = Kaltura::KalturaCategoryFilter.new
+        category_filter.full_name_equal = category_name
+        category_check = client.category_service.list(category_filter).objects
+        if category_check.nil?
+          false
+        else
+          category_check
+        end
+      end
+
+
+      ##
+      # Appends a specific Kaltura::MediaEntry attribute to the end of the original attribute given a Kaltura entry.
+      # This method is called by method_missing, allowing this module add attributes based
+      # off of the current API wrapper, rather than having to update along side the API wrapper.
+      #
+      # @param [String] attr_name The attribute to set.
+      # @param [String] entry_id The Kaltura entry ID.
+      # @param [String] value The value you wish to append the attribute with.
+      #
+      # @return [String] Returns the value as stored in the Kaltura database.  Tag strings come back
+      #   slightly funny.
+      #
+      # @raise [Kaltura::APIError] Passes Kaltura API errors directly through.
+      ##
+      def add_attribute(attr_name,entry_id,value)
+        client = KalturaBox::Client.update_session
+
+        old_attributes = client.media_service.get(entry_id).send(attr_name.to_sym)
+        media_entry = Kaltura::KalturaMediaEntry.new
+        media_entry.send("#{attr_name}=","#{old_attributes},#{value}")
+        client.media_service.update(entry_id,media_entry).send(attr_name.to_sym)
+      end
+
+    end
+  end
+end

data/lib/kaltura_box/entry/metadata/class_and_instance_methods.rb

@@ -0,0 +1,54 @@
+module KalturaBox
+  module Entry
+    module Metadata
+
+      ##
+      # It is necessary to have the check for valid Kaltura MediaEntry methods available at both
+      # the class and instance level, so they are thrown into this module.
+      ##
+      module ClassAndInstanceMethods
+
+        ##
+        # Checks if a requested attribute is in fact a valid MediaEntry atrribute.
+        ##
+        def valid_entry_attribute?(request_attribute)
+          object_methods, media_entry_methods = Object.instance_methods , Kaltura::KalturaMediaEntry.instance_methods
+
+          #clean out all the setter methods from the media entry methods
+          valid_media_entry_methods = media_entry_methods.map{|m| m unless m =~/^(.*)=/}.compact!
+
+          valid_media_entry_methods -= object_methods
+          valid_entry_attributes.include?(request_attribute.to_sym)
+        end
+
+        ##
+        # @private
+        ##
+        def valid_entry_attributes
+          object_methods, media_entry_methods = Object.instance_methods , Kaltura::KalturaMediaEntry.instance_methods
+
+          #clean out all the setter methods from the media entry methods
+          valid_media_entry_methods = media_entry_methods.map{|m| m.to_sym unless m =~/^(.*)=/}.compact!
+
+          valid_media_entry_methods -= object_methods
+        end
+        ##
+        # Determines if an attribute is valid in the sense of the add method making sense.  Only
+        # categories and tags are currently considered valid.
+        ##
+        def valid_add_attribute?(request_attribute)
+          case request_attribute.to_s
+            when /^(.*)_(categories|tags)/
+              return true
+            when /^(categories|tags)/
+              return true
+          else
+            return false
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/kaltura_box/entry/metadata/class_methods.rb

@@ -0,0 +1,69 @@
+module KalturaBox
+  module Entry
+    module Metadata
+      module ClassMethods
+
+        # Contains the names of the generated attribute methods.
+        def generated_methods #:nodoc:
+          @generated_methods ||= Set.new
+        end
+
+        def generated_methods?
+          !generated_methods.empty?
+        end
+
+        ##
+        # This method is called from with method_missing.  It generates
+        # actual methods for all the valid Kaltura::Media Entry methods
+        # the first time a dynamic getter/setter/adder is called.
+        ##
+        def define_attribute_methods
+          return if generated_methods?
+          valid_entry_attributes.each do |name|
+            define_set_method(name)
+            define_get_method(name)
+            define_add_method(name) if valid_add_attribute?(name)
+          end
+        end
+
+        ##
+        # Defines the set method for a specific Media Entry attribute
+        ##
+        def define_set_method(attr_name)
+          evaluate_attribute_method( attr_name,
+            "def set_#{attr_name}(new_value);set_attribute('#{attr_name}',self.entry_id,new_value);end",
+            "set_#{attr_name}"
+          )
+        end
+
+        ##
+        # defines a get methods
+        ##
+        def define_get_method(attr_name)
+          evaluate_attribute_method( attr_name,
+            "def get_#{attr_name};get_entry(self.entry_id).send('#{attr_name}');end",
+            "get_#{attr_name}"
+          )
+        end
+
+        def define_add_method(attr_name)
+          evaluate_attribute_method( attr_name,
+            "def add_#{attr_name}(new_value);add_attribute('#{attr_name}',self.entry_id,new_value);end",
+            "add_#{attr_name}"
+          )
+        end
+
+        def evaluate_attribute_method(attr_name, method_definition, method_name=attr_name)
+          generated_methods << method_name
+
+          begin
+            class_eval(method_definition, __FILE__, __LINE__)
+          rescue SyntaxError => err
+            generated_methods.delete(attr_name)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/kaltura_box/version.rb

@@ -0,0 +1,3 @@
+module KalturaBox
+  VERSION = "0.0.1"
+end

data/spec/api_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe "KalturaBox::APIWrapper" do
+  let(:api) { KalturaBox::APIWrapper.new }
+
+  before(:all) { KalturaBoxTest.setup! }
+
+  describe "config values" do
+    it { expect( api.client.config.login_email ).to eq(KalturaBox.config.login_email) }
+    it { expect( api.client.config.login_password ).to eq(KalturaBox.config.login_password) }
+    it { expect( api.client.config.partner_id ).to eq(KalturaBox.config.partner_id) }
+    it { expect( api.client.config.subpartner_id ).to eq(KalturaBox.config.subpartner_id) }
+    it { expect( api.client.config.administrator_secret ).to eq(KalturaBox.config.administrator_secret) }
+    it { expect( api.client.config.user_secret ).to eq(KalturaBox.config.user_secret) }
+    it { expect( api.client.config.thumb_width ).to eq(KalturaBox.config.thumb_width) }
+    it { expect( api.client.config.thumb_height ).to eq(KalturaBox.config.thumb_height) }
+    it { expect( api.client.config.player_conf_id ).to eq(KalturaBox.config.player_conf_id) }
+    it { expect( api.client.config.service_url ).to eq(KalturaBox.config.service_url) }
+    it { expect( api.client.config.logger ).to eq(KalturaBox.config.logger) }
+  end
+
+end

data/spec/category_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'active_record'
+
+class Category < ActiveRecord::Base
+  include KalturaBox::Category
+end
+
+describe "KalturaBox::Category" do
+
+  before(:all) { KalturaBoxTest.setup! }
+
+  describe "class methods" do
+
+    let(:categories) { Category.list }
+
+    before { KalturaBoxTest.setup_db! }
+
+    context "list" do
+      it { expect(categories.class).to eq Array }
+    end
+
+    context "update all categories" do
+      it { expect{Category.update_all_categories!}.to change{Category.count}.from(0).to(categories.count) }
+    end
+
+    context "add" do
+      it { expect{Category.add("new_cat", "New Category", true)}.to change{Category.count}.by(1) }
+    end
+
+  end
+
+  describe "instance methods" do
+
+    before { KalturaBoxTest.setup_db! }
+
+    let!(:category) { Category.add("new_cat2", "New Category 2") }
+
+    context "update" do
+      xit "Looking for a way to remove the updated category on Kaltura" do
+        expect{category.edit(name: "new_cat3", description: "New Category 3")}.to change{category.name}.from("new_cat2").to("new_cat3")
+      end
+    end
+
+    context "remove" do
+      let!(:category) { Category.add("new_cat4", "New Category 4") }
+      it { expect{category.remove}.to change{Category.count}.by(-1) }
+    end
+
+  end
+
+end