class Kaltura::KalturaBaseEntryService

Base Entry Service

Public Class Methods

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

Public Instance Methods

add(entry, type=KalturaNotImplemented) click to toggle source

Generic add entry, should be used when the uploaded entry type is not known. @return [KalturaBaseEntry]

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

Attach content resource to entry in status NO_MEDIA @return [KalturaBaseEntry]

# File lib/kaltura_client.rb, line 362
def add_content(entry_id, resource)
        kparams = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.add_param(kparams, 'resource', resource)
        client.queue_service_action_call('baseentry', 'addContent', 'KalturaBaseEntry', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
add_from_uploaded_file(entry, upload_token_id, type=KalturaNotImplemented) click to toggle source

Generic add entry using an uploaded file, should be used when the uploaded entry type is not known. @return [KalturaBaseEntry]

# File lib/kaltura_client.rb, line 375
def add_from_uploaded_file(entry, upload_token_id, type=KalturaNotImplemented)
        kparams = {}
        client.add_param(kparams, 'entry', entry)
        client.add_param(kparams, 'uploadTokenId', upload_token_id)
        client.add_param(kparams, 'type', type)
        client.queue_service_action_call('baseentry', 'addFromUploadedFile', 'KalturaBaseEntry', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
anonymous_rank(entry_id, rank) click to toggle source

Anonymously rank an entry, no validation is done on duplicate rankings. @return []

# File lib/kaltura_client.rb, line 389
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('baseentry', 'anonymousRank', '', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
approve(entry_id) click to toggle source

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

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

Clone an entry with optional attributes to apply to the clone @return [KalturaBaseEntry]

# File lib/kaltura_client.rb, line 414
def clone(entry_id, clone_options=KalturaNotImplemented)
        kparams = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.add_param(kparams, 'cloneOptions', clone_options)
        client.queue_service_action_call('baseentry', 'clone', 'KalturaBaseEntry', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
count(filter=KalturaNotImplemented) click to toggle source

Count base entries by filter. @return [int]

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

Delete an entry. @return []

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

@return [KalturaBaseEntry]

# File lib/kaltura_client.rb, line 450
def export(entry_id, storage_profile_id)
        kparams = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.add_param(kparams, 'storageProfileId', storage_profile_id)
        client.queue_service_action_call('baseentry', 'export', 'KalturaBaseEntry', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
export_to_csv(filter=KalturaNotImplemented, metadata_profile_id=KalturaNotImplemented, additional_fields=KalturaNotImplemented, mapped_fields=KalturaNotImplemented) click to toggle source

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

# File lib/kaltura_client.rb, line 463
def export_to_csv(filter=KalturaNotImplemented, metadata_profile_id=KalturaNotImplemented, additional_fields=KalturaNotImplemented, mapped_fields=KalturaNotImplemented)
        kparams = {}
        client.add_param(kparams, 'filter', filter)
        client.add_param(kparams, 'metadataProfileId', metadata_profile_id)
        client.add_param(kparams, 'additionalFields', additional_fields)
        client.add_param(kparams, 'mappedFields', mapped_fields)
        client.queue_service_action_call('baseentry', 'exportToCsv', 'string', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
flag(moderation_flag) click to toggle source

Flag inappropriate entry for moderation. @return []

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

Get base entry by ID. @return [KalturaBaseEntry]

# File lib/kaltura_client.rb, line 490
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('baseentry', 'get', 'KalturaBaseEntry', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
get_by_ids(entry_ids) click to toggle source

Get an array of KalturaBaseEntry objects by a comma-separated list of ids. @return [array]

# File lib/kaltura_client.rb, line 503
def get_by_ids(entry_ids)
        kparams = {}
        client.add_param(kparams, 'entryIds', entry_ids)
        client.queue_service_action_call('baseentry', 'getByIds', 'KalturaBaseEntry', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
get_context_data(entry_id, context_data_params) click to toggle source

This action delivers entry-related data, based on the user's context: access control, restriction, playback format and storage information. @return [KalturaEntryContextDataResult]

# File lib/kaltura_client.rb, line 515
def get_context_data(entry_id, context_data_params)
        kparams = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.add_param(kparams, 'contextDataParams', context_data_params)
        client.queue_service_action_call('baseentry', 'getContextData', 'KalturaEntryContextDataResult', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
get_playback_context(entry_id, context_data_params) click to toggle source

This action delivers all data relevant for player @return [KalturaPlaybackContext]

# File lib/kaltura_client.rb, line 528
def get_playback_context(entry_id, context_data_params)
        kparams = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.add_param(kparams, 'contextDataParams', context_data_params)
        client.queue_service_action_call('baseentry', 'getPlaybackContext', 'KalturaPlaybackContext', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
get_remote_paths(entry_id) click to toggle source

Get remote storage existing paths for the asset. @return [KalturaRemotePathListResponse]

# File lib/kaltura_client.rb, line 541
def get_remote_paths(entry_id)
        kparams = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.queue_service_action_call('baseentry', 'getRemotePaths', 'KalturaRemotePathListResponse', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
index(id, should_update=true) click to toggle source

Index an entry by id. @return [int]

# File lib/kaltura_client.rb, line 553
def index(id, should_update=true)
        kparams = {}
        client.add_param(kparams, 'id', id)
        client.add_param(kparams, 'shouldUpdate', should_update)
        client.queue_service_action_call('baseentry', 'index', 'int', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
list(filter=KalturaNotImplemented, pager=KalturaNotImplemented) click to toggle source

List base entries by filter with paging support. @return [KalturaBaseEntryListResponse]

# File lib/kaltura_client.rb, line 566
def list(filter=KalturaNotImplemented, pager=KalturaNotImplemented)
        kparams = {}
        client.add_param(kparams, 'filter', filter)
        client.add_param(kparams, 'pager', pager)
        client.queue_service_action_call('baseentry', 'list', 'KalturaBaseEntryListResponse', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
list_by_reference_id(ref_id, pager=KalturaNotImplemented) click to toggle source

List base entries by filter according to reference id @return [KalturaBaseEntryListResponse]

# File lib/kaltura_client.rb, line 579
def list_by_reference_id(ref_id, pager=KalturaNotImplemented)
        kparams = {}
        client.add_param(kparams, 'refId', ref_id)
        client.add_param(kparams, 'pager', pager)
        client.queue_service_action_call('baseentry', 'listByReferenceId', 'KalturaBaseEntryListResponse', 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 entry. @return [KalturaModerationFlagListResponse]

# File lib/kaltura_client.rb, line 592
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('baseentry', 'listFlags', 'KalturaModerationFlagListResponse', kparams)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
reject(entry_id) click to toggle source

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

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

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

# File lib/kaltura_client.rb, line 617
def update(entry_id, base_entry)
        kparams = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.add_param(kparams, 'baseEntry', base_entry)
        client.queue_service_action_call('baseentry', 'update', 'KalturaBaseEntry', 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

Update the content resource associated with the entry. @return [KalturaBaseEntry]

# File lib/kaltura_client.rb, line 630
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('baseentry', 'updateContent', 'KalturaBaseEntry', 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) click to toggle source

Update entry thumbnail from a different entry by a specified time offset (in seconds). @return [KalturaBaseEntry]

# File lib/kaltura_client.rb, line 645
def update_thumbnail_from_source_entry(entry_id, source_entry_id, time_offset)
        kparams = {}
        client.add_param(kparams, 'entryId', entry_id)
        client.add_param(kparams, 'sourceEntryId', source_entry_id)
        client.add_param(kparams, 'timeOffset', time_offset)
        client.queue_service_action_call('baseentry', 'updateThumbnailFromSourceEntry', 'KalturaBaseEntry', 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 659
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('baseentry', '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 entry thumbnail using a raw jpeg file. @return [KalturaBaseEntry]

# File lib/kaltura_client.rb, line 672
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('baseentry', 'updateThumbnailJpeg', 'KalturaBaseEntry', kparams, kfiles)
        if (client.is_multirequest)
                return nil
        end
        return client.do_queue()
end
upload(file_data) click to toggle source

Upload a file to Kaltura, that can be used to create an entry. @return [string]

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