class Kaltura::KalturaMediaService

Media service lets you upload and manage media files (images / videos & audio)

Public Class Methods

new(client) click to toggle source
Calls superclass method
# File lib/kaltura_client.rb, line 2820
def initialize(client)
        super(client)
end

Public Instance Methods

add(entry) click to toggle source

Add entry @return [KalturaMediaEntry]

# File lib/kaltura_client.rb, line 2826
def add(entry)
        kparams = {}
        client.add_param(kparams, 'entry', entry)
        client.queue_service_action_call('media', 'add', 'KalturaMediaEntry', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
add_content(entry_id, resource=KalturaNotImplemented) click to toggle source

Add content to media entry which is not yet associated with content (therefore is in status NO_CONTENT).

If the requirement is to replace the entry's associated content, use action updateContent.

@return [KalturaMediaEntry]

# File lib/kaltura_client.rb, line 2839
def add_content(entry_id, resource=KalturaNotImplemented)
        kparams = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.add_param(kparams, 'resource', resource)
        client.queue_service_action_call('media', 'addContent', 'KalturaMediaEntry', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
add_from_bulk(media_entry, url, bulk_upload_id) click to toggle source

Adds new media entry by importing an HTTP or FTP URL.

The entry will be queued for import and then for conversion.
This action should be exposed only to the batches

@return [KalturaMediaEntry]

# File lib/kaltura_client.rb, line 2854
def add_from_bulk(media_entry, url, bulk_upload_id)
        kparams = {}
        client.add_param(kparams, 'mediaEntry', media_entry)
        client.add_param(kparams, 'url', url)
        client.add_param(kparams, 'bulkUploadId', bulk_upload_id)
        client.queue_service_action_call('media', 'addFromBulk', 'KalturaMediaEntry', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
add_from_entry(source_entry_id, media_entry=KalturaNotImplemented, source_flavor_params_id=KalturaNotImplemented) click to toggle source

Copy entry into new entry @return [KalturaMediaEntry]

# File lib/kaltura_client.rb, line 2868
def add_from_entry(source_entry_id, media_entry=KalturaNotImplemented, source_flavor_params_id=KalturaNotImplemented)
        kparams = {}
        client.add_param(kparams, 'sourceEntryId', source_entry_id)
        client.add_param(kparams, 'mediaEntry', media_entry)
        client.add_param(kparams, 'sourceFlavorParamsId', source_flavor_params_id)
        client.queue_service_action_call('media', 'addFromEntry', 'KalturaMediaEntry', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
add_from_flavor_asset(source_flavor_asset_id, media_entry=KalturaNotImplemented) click to toggle source

Copy flavor asset into new entry @return [KalturaMediaEntry]

# File lib/kaltura_client.rb, line 2882
def add_from_flavor_asset(source_flavor_asset_id, media_entry=KalturaNotImplemented)
        kparams = {}
        client.add_param(kparams, 'sourceFlavorAssetId', source_flavor_asset_id)
        client.add_param(kparams, 'mediaEntry', media_entry)
        client.queue_service_action_call('media', 'addFromFlavorAsset', 'KalturaMediaEntry', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
add_from_recorded_webcam(media_entry, webcam_token_id) click to toggle source

Add new entry after the file was recorded on the server and the token id exists @return [KalturaMediaEntry]

# File lib/kaltura_client.rb, line 2895
def add_from_recorded_webcam(media_entry, webcam_token_id)
        kparams = {}
        client.add_param(kparams, 'mediaEntry', media_entry)
        client.add_param(kparams, 'webcamTokenId', webcam_token_id)
        client.queue_service_action_call('media', 'addFromRecordedWebcam', 'KalturaMediaEntry', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
add_from_search_result(media_entry=KalturaNotImplemented, search_result=KalturaNotImplemented) click to toggle source

Adds new media entry by importing the media file from a search provider.

This action should be used with the search service result.

@return [KalturaMediaEntry]

# File lib/kaltura_client.rb, line 2909
def add_from_search_result(media_entry=KalturaNotImplemented, search_result=KalturaNotImplemented)
        kparams = {}
        client.add_param(kparams, 'mediaEntry', media_entry)
        client.add_param(kparams, 'searchResult', search_result)
        client.queue_service_action_call('media', 'addFromSearchResult', 'KalturaMediaEntry', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
add_from_uploaded_file(media_entry, upload_token_id) click to toggle source

Add new entry after the specific media file was uploaded and the upload token id exists @return [KalturaMediaEntry]

# File lib/kaltura_client.rb, line 2922
def add_from_uploaded_file(media_entry, upload_token_id)
        kparams = {}
        client.add_param(kparams, 'mediaEntry', media_entry)
        client.add_param(kparams, 'uploadTokenId', upload_token_id)
        client.queue_service_action_call('media', 'addFromUploadedFile', 'KalturaMediaEntry', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
add_from_url(media_entry, url) click to toggle source

Adds new media entry by importing an HTTP or FTP URL.

The entry will be queued for import and then for conversion.

@return [KalturaMediaEntry]

# File lib/kaltura_client.rb, line 2936
def add_from_url(media_entry, url)
        kparams = {}
        client.add_param(kparams, 'mediaEntry', media_entry)
        client.add_param(kparams, 'url', url)
        client.queue_service_action_call('media', 'addFromUrl', 'KalturaMediaEntry', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
anonymous_rank(entry_id, rank) click to toggle source

Anonymously rank a media entry, no validation is done on duplicate rankings @return []

# File lib/kaltura_client.rb, line 2949
def anonymous_rank(entry_id, rank)
        kparams = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.add_param(kparams, 'rank', rank)
        client.queue_service_action_call('media', 'anonymousRank', '', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
approve(entry_id) click to toggle source

Approve the media entry and mark the pending flags (if any) as moderated (this will make the entry playable) @return []

# File lib/kaltura_client.rb, line 2962
def approve(entry_id)
        kparams = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.queue_service_action_call('media', 'approve', '', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
approve_replace(entry_id) click to toggle source

Approves media replacement @return [KalturaMediaEntry]

# File lib/kaltura_client.rb, line 2974
def approve_replace(entry_id)
        kparams = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.queue_service_action_call('media', 'approveReplace', 'KalturaMediaEntry', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
bulk_upload_add(file_data, bulk_upload_data=KalturaNotImplemented, bulk_upload_entry_data=KalturaNotImplemented) click to toggle source

Add new bulk upload batch job

Conversion profile id can be specified in the API or in the CSV file, the one in the CSV file will be stronger.
If no conversion profile was specified, partner's default will be used

@return [KalturaBulkUpload]

# File lib/kaltura_client.rb, line 2988
def bulk_upload_add(file_data, bulk_upload_data=KalturaNotImplemented, bulk_upload_entry_data=KalturaNotImplemented)
        kparams = {}
        kfiles = {}
        client.add_param(kfiles, 'fileData', file_data)
        client.add_param(kparams, 'bulkUploadData', bulk_upload_data)
        client.add_param(kparams, 'bulkUploadEntryData', bulk_upload_entry_data)
        client.queue_service_action_call('media', 'bulkUploadAdd', 'KalturaBulkUpload', kparams, kfiles)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
cancel_replace(entry_id) click to toggle source

Cancels media replacement @return [KalturaMediaEntry]

# File lib/kaltura_client.rb, line 3003
def cancel_replace(entry_id)
        kparams = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.queue_service_action_call('media', 'cancelReplace', 'KalturaMediaEntry', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
convert(entry_id, conversion_profile_id=KalturaNotImplemented, dynamic_conversion_attributes=KalturaNotImplemented) click to toggle source

Convert entry @return [bigint]

# File lib/kaltura_client.rb, line 3015
def convert(entry_id, conversion_profile_id=KalturaNotImplemented, dynamic_conversion_attributes=KalturaNotImplemented)
        kparams = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.add_param(kparams, 'conversionProfileId', conversion_profile_id)
        client.add_param(kparams, 'dynamicConversionAttributes', dynamic_conversion_attributes)
        client.queue_service_action_call('media', 'convert', 'bigint', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
count(filter=KalturaNotImplemented) click to toggle source

Count media entries by filter. @return [int]

# File lib/kaltura_client.rb, line 3029
def count(filter=KalturaNotImplemented)
        kparams = {}
        client.add_param(kparams, 'filter', filter)
        client.queue_service_action_call('media', 'count', 'int', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
delete(entry_id) click to toggle source

Delete a media entry. @return []

# File lib/kaltura_client.rb, line 3041
def delete(entry_id)
        kparams = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.queue_service_action_call('media', 'delete', '', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
export_to_csv(data) click to toggle source

Creates a batch job that sends an email with a link to download a CSV containing a list of entries @return [string]

# File lib/kaltura_client.rb, line 3053
def export_to_csv(data)
        kparams = {}
        client.add_param(kparams, 'data', data)
        client.queue_service_action_call('media', 'exportToCsv', 'string', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
flag(moderation_flag) click to toggle source

Flag inappropriate media entry for moderation @return []

# File lib/kaltura_client.rb, line 3065
def flag(moderation_flag)
        kparams = {}
        client.add_param(kparams, 'moderationFlag', moderation_flag)
        client.queue_service_action_call('media', 'flag', '', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
get(entry_id, version=-1) click to toggle source

Get media entry by ID. @return [KalturaMediaEntry]

# File lib/kaltura_client.rb, line 3077
def get(entry_id, version=-1)
        kparams = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.add_param(kparams, 'version', version)
        client.queue_service_action_call('media', 'get', 'KalturaMediaEntry', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
get_mrss(entry_id, extending_items_array=KalturaNotImplemented, features=KalturaNotImplemented) click to toggle source

Get MRSS by entry id

XML will return as an escaped string

@return [string]

# File lib/kaltura_client.rb, line 3091
def get_mrss(entry_id, extending_items_array=KalturaNotImplemented, features=KalturaNotImplemented)
        kparams = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.add_param(kparams, 'extendingItemsArray', extending_items_array)
        client.add_param(kparams, 'features', features)
        client.queue_service_action_call('media', 'getMrss', 'string', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
get_volume_map(entry_id) click to toggle source

Get volume map by entry id @return [file]

# File lib/kaltura_client.rb, line 3105
def get_volume_map(entry_id)
        kparams = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.queue_service_action_call('media', 'getVolumeMap', 'file', kparams)
        return client.get_serve_url()
end
list(filter=KalturaNotImplemented, pager=KalturaNotImplemented) click to toggle source

List media entries by filter with paging support. @return [KalturaMediaListResponse]

# File lib/kaltura_client.rb, line 3114
def list(filter=KalturaNotImplemented, pager=KalturaNotImplemented)
        kparams = {}
        client.add_param(kparams, 'filter', filter)
        client.add_param(kparams, 'pager', pager)
        client.queue_service_action_call('media', 'list', 'KalturaMediaListResponse', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
list_flags(entry_id, pager=KalturaNotImplemented) click to toggle source

List all pending flags for the media entry @return [KalturaModerationFlagListResponse]

# File lib/kaltura_client.rb, line 3127
def list_flags(entry_id, pager=KalturaNotImplemented)
        kparams = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.add_param(kparams, 'pager', pager)
        client.queue_service_action_call('media', 'listFlags', 'KalturaModerationFlagListResponse', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
reject(entry_id) click to toggle source

Reject the media entry and mark the pending flags (if any) as moderated (this will make the entry non playable) @return []

# File lib/kaltura_client.rb, line 3140
def reject(entry_id)
        kparams = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.queue_service_action_call('media', 'reject', '', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
request_conversion(entry_id, file_format) click to toggle source

Request a new conversion job, this can be used to convert the media entry to a different format @return [int]

# File lib/kaltura_client.rb, line 3152
def request_conversion(entry_id, file_format)
        kparams = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.add_param(kparams, 'fileFormat', file_format)
        client.queue_service_action_call('media', 'requestConversion', 'int', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
update(entry_id, media_entry) click to toggle source

Update media entry. Only the properties that were set will be updated. @return [KalturaMediaEntry]

# File lib/kaltura_client.rb, line 3165
def update(entry_id, media_entry)
        kparams = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.add_param(kparams, 'mediaEntry', media_entry)
        client.queue_service_action_call('media', 'update', 'KalturaMediaEntry', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
update_content(entry_id, resource, conversion_profile_id=KalturaNotImplemented, advanced_options=KalturaNotImplemented) click to toggle source

Replace content associated with the media entry. @return [KalturaMediaEntry]

# File lib/kaltura_client.rb, line 3178
def update_content(entry_id, resource, conversion_profile_id=KalturaNotImplemented, advanced_options=KalturaNotImplemented)
        kparams = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.add_param(kparams, 'resource', resource)
        client.add_param(kparams, 'conversionProfileId', conversion_profile_id)
        client.add_param(kparams, 'advancedOptions', advanced_options)
        client.queue_service_action_call('media', 'updateContent', 'KalturaMediaEntry', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
update_thumbnail(entry_id, time_offset, flavor_params_id=KalturaNotImplemented) click to toggle source

Update media entry thumbnail by a specified time offset (In seconds)

If flavor params id not specified, source flavor will be used by default

@return [KalturaMediaEntry]

# File lib/kaltura_client.rb, line 3194
def update_thumbnail(entry_id, time_offset, flavor_params_id=KalturaNotImplemented)
        kparams = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.add_param(kparams, 'timeOffset', time_offset)
        client.add_param(kparams, 'flavorParamsId', flavor_params_id)
        client.queue_service_action_call('media', 'updateThumbnail', 'KalturaMediaEntry', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
update_thumbnail_from_source_entry(entry_id, source_entry_id, time_offset, flavor_params_id=KalturaNotImplemented) click to toggle source

Update media entry thumbnail from a different entry by a specified time offset (In seconds)

If flavor params id not specified, source flavor will be used by default

@return [KalturaMediaEntry]

# File lib/kaltura_client.rb, line 3209
def update_thumbnail_from_source_entry(entry_id, source_entry_id, time_offset, flavor_params_id=KalturaNotImplemented)
        kparams = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.add_param(kparams, 'sourceEntryId', source_entry_id)
        client.add_param(kparams, 'timeOffset', time_offset)
        client.add_param(kparams, 'flavorParamsId', flavor_params_id)
        client.queue_service_action_call('media', 'updateThumbnailFromSourceEntry', 'KalturaMediaEntry', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
update_thumbnail_from_url(entry_id, url) click to toggle source

Update entry thumbnail using URL @return [KalturaBaseEntry]

# File lib/kaltura_client.rb, line 3224
def update_thumbnail_from_url(entry_id, url)
        kparams = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.add_param(kparams, 'url', url)
        client.queue_service_action_call('media', 'updateThumbnailFromUrl', 'KalturaBaseEntry', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
update_thumbnail_jpeg(entry_id, file_data) click to toggle source

Update media entry thumbnail using a raw jpeg file @return [KalturaMediaEntry]

# File lib/kaltura_client.rb, line 3237
def update_thumbnail_jpeg(entry_id, file_data)
        kparams = {}
        kfiles = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.add_param(kfiles, 'fileData', file_data)
        client.queue_service_action_call('media', 'updateThumbnailJpeg', 'KalturaMediaEntry', kparams, kfiles)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
upload(file_data) click to toggle source

Upload a media file to Kaltura, then the file can be used to create a media entry. @return [string]

# File lib/kaltura_client.rb, line 3251
def upload(file_data)
        kparams = {}
        kfiles = {}
        client.add_param(kfiles, 'fileData', file_data)
        client.queue_service_action_call('media', 'upload', 'string', kparams, kfiles)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end