goncalossilva_kaltura-ruby 0.4.8

data/lib/kaltura/service/base_service.rb

@@ -0,0 +1,42 @@
+module Kaltura
+  module Service
+    ##
+    # Base Service is a method extraction refactoring performed on the Service module for the Velir 
+    # branch of the kaltura-ruby library.  Previously perform_request existed in each method of each
+    # service.
+    #
+    # @author Patrick Robertson
+    ##
+    class BaseService
+    	attr_accessor :client
+
+    	def initialize(client)
+    		@client = client
+    	end
+      
+      ##
+      # Enqueues the service class, action, and paramters onto the client object and then
+      # informs the client object to perform pop an action off the queue.
+      #
+      # @param [String] service_class The particular class within the Service module.  
+      #   This translates to a paramter of service=service_class on the http request.
+      # @param [String] service_action The action method performed by the service_class.
+      #   This translates to a parameter of action=service_action on the http request.
+      # @param [Boolean] allow_multirequest I've never seen this implemented.  It's around
+      #   just in case though.
+      # 
+      # @return [Object] Returns the result of the request.
+      #
+      # @raise [Kaltura::APIError] Raises the Kaltura error of the request.
+      ## 
+    	def perform_request(service_class,service_action,paramters,allow_multirequest=true)
+        if allow_multirequest == false && client.is_multirequest
+          return nil
+        else
+          client.queue_service_action_call(service_class,service_action,paramters)
+          return client.do_queue
+        end
+      end
+    end #class BaseService
+  end
+end

data/lib/kaltura/service/bulk_upload_service.rb

@@ -0,0 +1,75 @@
+module Kaltura
+  module Service
+    ##
+    # The Bulk upload service is used to upload and manage bulk uploads using CSV files.
+    # This service is available through the KMC and typically would be a one-off, 
+    # though you could choose to use it with a web application.
+    #
+    # @example Create a new bulk upload job:
+    #   csv_file = File.open('/path/to/csv_file/')
+    #   client.bulk_upload_service.add('12141313',csv_file)
+    #
+    # @example Retrieve a bulk upload status:
+    #   status = client.bulk_upload_service.get('124').status
+    #
+    # @example List all bulk upload jobs:
+    #   pager = Kaltura::FilterPager.new
+    #   pager.page_size = 100000000
+    #   client.bulk_upload_service.list(pager)
+    ##
+    class BulkUploadService < BaseService
+      
+      ##
+      # Adds a new bulk upload batch job.
+      # The conversion profile ID can be either specified in the API or in the CSV file itself.
+      # The attribute in the CSV overrides the API ID.  The partner's default conversion profile 
+      # will be used if no ID is provided.
+      #
+      # @param [Integer] conversion_profile_id This is the conversion profile to create flavors for each entry from.
+      #   If there is a conversion profile defined in the file, this paramter will be overriden.
+      # @param [File] csv_file_data The CSV file used to batch upload.
+      #
+      # @return [Kaltura::BulkUpload] A Bulk upload object contains useful information regarding the batch upload status.
+      #   It would be advised you store the ID of this object somewhere for later retrieval.
+      #
+      # @raise [Kaltura::APIError] Raises default Kaltura errors.
+      ##
+  		def add(conversion_profile_id, csv_file_data)
+  			kparams = {}
+  			client.add_param(kparams, 'conversionProfileId', conversion_profile_id)
+  			client.add_param(kparams, 'csvFileData', csv_file_data)
+  			perform_request('bulkUpload','add',kparams,false)
+  		end
+
+      ##
+      # Retrieves a BulkUpload object.
+      #
+      # @param [Integer] id The ID of the BulkUpload object.
+      #
+      # @return [Kaltura::BulkUpload] The BulkUpload object requested.
+      #
+      # @raise [Kaltura::APIError] Raises default Kaltura errors.
+      ##
+  		def get(id)
+  			kparams = {}
+  			client.add_param(kparams, 'id', id)
+  			perform_request('bulkUpload','get',kparams,false)
+  		end
+
+      ##
+      # Lists bulk upload batch jobs given a pager index and size.
+      #
+      # @param [Kaltura::FilterPager] pager Default Kaltura pager object.
+      #
+      # @return [Kaltura::Response::BulkUploadListResponse] Wrapper for BaseResponse.
+      # 
+      # @return [Kaltura::APIError] Raises default Kaltura errors.
+      ## 
+  		def list(pager=nil)
+  			kparams = {}
+  			client.add_param(kparams, 'pager', pager)
+  			perform_request('bulkUpload','list',kparams,false)
+  		end
+  	end #class BulkUploadService
+	end
+end

data/lib/kaltura/service/category_service.rb

@@ -0,0 +1,112 @@
+module Kaltura
+  module Service
+    ##
+    # CategoryService is responsible for adding and managing Categories.  Categories are the main 
+    # means to filter entries within the KMC.
+    #
+    # @example Add a new category to the KMC filter list.
+    #   new_category = Kaltura::Category.new
+    #   new_category.name = "waffles"
+    #   client.category_service.add(new_category)
+    #
+    # @example Get an existing category by ID.
+    #   client.category_service.get(214)
+    #
+    # @example Update an existing category.
+    #   category_update = Kaltura::Category.new
+    #   category_update.description = "waffles are pretty freaking good."
+    #   client.category_service.update(214,category_update)
+    #
+    # @example Delete an existing category.
+    #   client.category_service.delete(214)
+    #
+    # @example List all categories with a parent_id of 2
+    #   category_filter = Kaltura::Filter::CategoryFilter.new
+    #   category_filter.parent_id_equal = 2
+    #   client.category_service.list(category_filter)
+    ##
+    class CategoryService < BaseService
+      
+      ##
+      # Adds a new Category.
+      #
+      # @param [Kaltura::Category] category The category that will be created.  The crucial field to fill out is name.
+      # 
+      # @return [Kaltura::Category] Returns the category as it now appears on the server.  It would be beneficial to 
+      #   save the ID of the category for later reference.
+      #
+      # @raise [Kaltura::APIError] Raises default Kaltura errors.
+      ##
+  		def add(category)
+  			kparams = {}
+  			client.add_param(kparams, 'category', category)
+  			perform_request('category','add',kparams,false)
+  		end
+
+      ##
+      # Retrieves a category by it's ID.
+      #
+      # @param [Integer] id The Kaltura::Category object's id.
+      #
+      # @return [Kaltura::Category] The requested category.
+      #
+      # @raise [Kaltura::APIError] Raises default Kaltura errors.
+      ##
+  		def get(id)
+  			kparams = {}
+  			client.add_param(kparams, 'id', id)
+  			perform_request('category','get',kparams,false)
+  		end
+
+      ##
+      # Updates a category.
+      # The best practice as with all updates would be to insantiate a new Kaltura::Category and update specific fields.
+      #
+      # @param [Integer] id The Kaltura::Category id of the category to be updated.
+      # @param [Kaltura::Category] A newly insantiated Category object with the fields updated that you'd like to update.
+      # 
+      # @return [Kaltura::Category] The new and improved Category object.
+      # 
+      # @raise [Kaltura::APIError] Raises default Kaltura errors.
+      ##
+  		def update(id, category)
+  			kparams = {}
+  			client.add_param(kparams, 'id', id)
+  			client.add_param(kparams, 'category', category)
+  			perform_request('category','update',kparams,false)
+  		end
+
+      ##
+      # Deletes the requested Category.
+      # I am fairly confident that this will not actually clear the category from each entry, but it is no longer
+      # a filter on the KMC.
+      #
+      # @param [Integer] id The category ID to remove.
+      #
+      # @return [nil] Returns nothing.
+      #
+      # @raise [Kaltura::APIError] Raises default Kaltura errors.
+      ##
+  		def delete(id)
+  			kparams = {}
+  			client.add_param(kparams, 'id', id)
+  			perform_request('category','delete',kparams,false)
+  		end
+
+      ##
+      # Lists all Categories given the specified filter.
+      #
+      # @param [Kaltura::Filter::CategoryFilter] filter The filter to apply.
+      #
+      # @return [Kaltura::Response::CategoryListResponse] Wrapper for Kaltura::Response::BaseResponse.
+      #
+      # @raise [Kaltura::APIError] Raises default Kaltura errors.      
+      ##
+  		def list(filter=nil)
+  			kparams = {}
+  			client.add_param(kparams, 'filter', filter)
+  			perform_request('category','list',kparams,false)
+  		end
+  	end #class CategoryService
+	end
+end

data/lib/kaltura/service/conversion_profile_service.rb

@@ -0,0 +1,116 @@
+module Kaltura
+  module Service
+    
+    ##
+    # The Conversion Profile Service is responsible for adding and managing conversion profiles.
+    #
+    # @example Create a new conversion profile:
+    #   conversion_profile = Kaltura::ConversionProfile.new
+    #   conversion_profile.name = "waffles"
+    #   conversion_profile.is_default = "true"
+    #   conversion_profile.clip_duration = 15
+    #   client.conversion_profile_service.add(conversion_profile)
+    #
+    # @example Retrieve a conversion profile:
+    #   client.conversion_profile_service.get(224)
+    #
+    # @example Update a conversion profile:
+    #   update_profile = Kaltura::ConversionProfile.new
+    #   update_profile.description = "why does the documentor love waffles so much?"
+    #   update_profile.clip_start = 3
+    #   client.conversion_profile_service.update(224,update_profile)
+    #
+    # @example Delete a conversion profile:
+    #   client.conversion_profile_service.delete(224)
+    #
+    # @example Retrieve all conversion profiles with an ID of 224
+    #   filter = Kaltura::Filter::ConversionProfileFilter.new
+    #   filter.id_equal = 224
+    #   client.conversion_profile_service.list(filter)
+    ##
+    class ConversionProfileService < BaseService
+
+      ##
+      # Adds a new conversion profile.
+      #
+      # @param [Kaltura::ConversionProfile] conversion_profile The new conversion profile.
+      #
+      # @return [Kaltura::ConversionProfile] The conversion profile as it is stored on the Kaltura server.
+      #   It might be important to store the ID returned.
+      #
+      # @raise [Kaltura::APIError] Raises default Kaltura errors.
+      ##
+  		def add(conversion_profile)
+  			kparams = {}
+  			client.add_param(kparams, 'conversionProfile', conversion_profile)
+  			perform_request('conversionProfile','add',kparams,false)
+  		end
+      
+      ##
+      # Retrieves a conversion profile by ID.
+      #
+      # @param [Integer] id The conversion profile ID.
+      #
+      # @return [Kaltura::ConversionProfile] The requested conversion profile.
+      #
+      # @raise [Kaltura::APIError] Raises default Kaltura errors.
+      ##      
+  		def get(id)
+  			kparams = {}
+  			client.add_param(kparams, 'id', id)
+  			perform_request('conversionProfile','get',kparams,false)
+  		end
+
+      ##
+      # Updates a conversion profile given an ID and a newly instantiated ConversionProfile.
+      # It will update any populated fields on the provided profile.
+      #
+      # @param [Integer] id The conversion profile ID.
+      # @param [Kaltura::ConversionProfile] conversion_profile Newly instantiated conversion profile with 
+      #   the fields to update.
+      # 
+      # @return [Kaltura::ConversionProfile] Returns an updated conversion profile.
+      # 
+      # @raise [Kaltura::APIError] Raises default Kaltura errors.
+      ##
+  		def update(id, conversion_profile)
+  			kparams = {}
+  			client.add_param(kparams, 'id', id)
+  			client.add_param(kparams, 'conversionProfile', conversion_profile)
+  			perform_request('conversionProfile','update',kparams,false)
+  		end
+
+      ##
+      # Deletes a conversion profile by ID.
+      #
+      # @param [Integer] id The conversion profile ID.
+      #
+      # @return [nil] Returns nothing.
+      #
+      # @raise [Kaltura::APIError] Raises default Kaltura errors.
+      ##
+  		def delete(id)
+  			kparams = {}
+  			client.add_param(kparams, 'id', id)
+  			perform_request('conversionProfile','delete',kparams,false)
+  		end
+
+      ##
+      # Lists conversion profiles given a filter with paging support for larger result sets.
+      #
+      # @param [Kaltura::Filter::ConversionProfileFilter] filter The filter to apply to the list.
+      # @param [Kaltura::FilterPager] pager Default Kaltura Pager.
+      #
+      # @return [Kaltura::Response::ConversionProfileListResponse] Wrapper for Kaltura::Response::BaseResponse.
+      #
+      # @raise [Kaltura::APIError] Raises default Kaltura errors.
+      ##
+  		def list(filter=nil, pager=nil)
+  			kparams = {}
+  			client.add_param(kparams, 'filter', filter)
+  			client.add_param(kparams, 'pager', pager)
+  			perform_request('conversionProfile','list',kparams,false)
+  		end 
+  	end #class ConversionProfileService
+	end
+end

data/lib/kaltura/service/data_service.rb

@@ -0,0 +1,116 @@
+module Kaltura
+  module Service
+    ##
+    # The Data Service allows you to add and manage texual content.
+    #
+    # @example Creating a new DataEntry:
+    #   new_data_entry = Kaltura::DataEntry.new
+    #   new_data_entry.name = "pancake"
+    #   new_data_entry.data_content = "We all know  that waffles are better.  But the documentation author is tired."
+    #   client.data_entry_service.add(new_data_entry)
+    #
+    # @example Retrieve a DataEntry:
+    #   client.data_entry_service.get('1_ad342xk')
+    # 
+    # @example Update a DataEntry:
+    #   update_entry = Kaltura::DataEntry.new
+    #   update_entry.data_content = 'Ninjas <3 waffles.  Pirates love the pancakes.'
+    #   client.data_entry_service.update('1_ad342xk',update_entry)
+    #
+    # @example Delete a DataEntry:
+    #   client.data_entry_service.delete('1_ad342xk')
+    #
+    # @example Filter DataEntries by group ID 2:
+    #   filter = Kaltura::Filter::DataEntryFilter.new
+    #   filter.group_id_equal = '2'
+    #   client.data_entry_service.list(filter)
+    ##
+    class DataService < BaseService
+
+      ##
+      # Adds a new data entry.
+      #
+      # @param [Kaltura::DataEntry] data_entry This is essentially a BaseEntry except there
+      #   is a field called data_content.  Presumably you shove text into this field.
+      #
+      # @return [Kaltura::DataEntry] Returns the data entry as it is stored in the DB.
+      #
+      # @raise [Kaltura::APIError] Raises the default Kaltura errors.
+      ##
+  		def add(data_entry)
+  			kparams = {}
+  			client.add_param(kparams, 'dataEntry', data_entry)
+  			perform_request('data','add',kparams,false)
+  		end
+
+      ##
+      # Gets a data entry by ID.
+      #
+      # @param [String] entry_id the DataEntry id.
+      # @param [Integer] version Version of the DataEntry.
+      #
+      # @return [Kaltura::DataEntry] Returns the desired DataEntry object.
+      # 
+      # @raise [Kaltura::APIError] Raises the default Kaltura errors in addition to 'ENTRY_ID_NOT_FOUND'.
+      ##
+  		def get(entry_id, version=-1)
+  			kparams = {}
+  			client.add_param(kparams, 'entryId', entry_id)
+  			client.add_param(kparams, 'version', version)
+  			perform_request('data','get',kparams,false)
+  		end
+
+      ##
+      # Updates a data entry.
+      # As with other update actions, the best practice is to instantiate a new Kaltura::DataEntry object
+      # and set the fields of that object that you wish to change.
+      #
+      # @param [String] entry_id The DataEntry you wish to update.
+      # @param [Kaltura::DataEntry] document_entry A newly instantiated DataEntry object with only 
+      #   the fields that you wish to update filled in.
+      #
+      # @return [Kaltura::DataEntry] Returns the updated DataEntry object complete with a version bump.
+      # 
+      # @raise [Kaltura::APIError] Raises the default Kaltura errors in addition to 'ENTRY_ID_NOT_FOUND'.
+      ##
+  		def update(entry_id, document_entry)
+  			kparams = {}
+  			client.add_param(kparams, 'entryId', entry_id)
+  			client.add_param(kparams, 'documentEntry', document_entry)
+  			perform_request('data','update',kparams,false)
+  		end
+
+      ##
+      # Removes a DataEntry object.
+      #
+      # @param [String] entry_id the DataEntry to delete.
+      #
+      # @return [nil] Returns nothing.
+      #
+      # @raise [Kaltura::APIError] Raises the default Kaltura errors in addition to 'ENTRY_ID_NOT_FOUND'.      
+      ##
+  		def delete(entry_id)
+  			kparams = {}
+  			client.add_param(kparams, 'entryId', entry_id)
+  			perform_request('data','delete',kparams,false)
+  		end
+
+      ##
+      # Lists DataEntry objects with the given filter and paging support for larger sets of data.
+      #
+      # @param [Kaltura::Filter::DataEntryFilter] filter The filter to apply to the list.
+      # @param [Kaltura::FilterPager] pager The default Kaltura pager.
+      #
+      # @return [Kaltura::Response::DataListResponse] Wrapper for Kaltura::Response::BaseResponse.
+      #
+      # @raise [Kaltura::APIError] Raises the default Kaltura errrors.
+      ##
+  		def list(filter=nil, pager=nil)
+  			kparams = {}
+  			client.add_param(kparams, 'filter', filter)
+  			client.add_param(kparams, 'pager', pager)
+  			perform_request('data','list',kparams,false)
+  		end
+  	end #class DataService
+	end
+end