def list_app_tokens(args):
""" list appTokens """
client = kaltura_session()
if args.apptoken:
filter = KalturaAppTokenFilter()
if args.created_at:
createdAtFilter = datetime(
args.created_at[0], args.created_at[1], args.created_at[2], 0, 0
).timestamp()
filter.createdAtGreaterThanOrEqual = createdAtFilter
result = client.appToken.list(filter)
count = result.totalCount
print("totalcount returned: " + str(count) + "\n")
nid = 0
while nid < count:
for i in result.objects:
print("id: " + i.id)
print("token: " + i.token)
print(i.description)
print(
"created at: "
+ datetime.fromtimestamp(i.createdAt).strftime("%c")
+ "\n"
)
nid = nid + 1
elif args.kmcroles:
filter = KalturaUserRoleFilter()
pager = KalturaFilterPager()
pager.pageIndex = 1
pager.pageSize = 500
listroles = client.userRole.list(filter, pager)
for i in listroles.objects:
print(i.name + " " + str(i.id))
def export_users(client, total_count):
"""
export users and returns python dictionary
kmc users are stored as a dictionary in kmc key
kms users are stored as a dictionary in kms key
"""
filter = KalturaUserFilter()
pager = KalturaFilterPager()
pager.pageSize = 300
page_count = 1
user_return_dict = {"kmc": {}, "kms": {}}
domain_list = []
user_type_count_kms = 0
user_type_count_kmc = 0
print_overview(total_count)
# Iterate on KalturaUserListResponse objects
while page_count <= ceil(total_count / 300):
pager.pageIndex = page_count
result = client.user.list(filter, pager)
for user_entry in track(result.objects,
description="Exporting page " +
str(page_count)):
domain = user_entry.id
domain = domain.split("@", 1)
if len(domain) < 2:
# We disregard KalturaUser objects without domain in userId
continue
domain_list.append(domain[1])
if user_entry.isAdmin is True:
user_type = "kmc"
user_type_count_kmc += 1
else:
user_type = "kms"
user_type_count_kms += 1
user_return_dict[user_type][user_entry.id] = [user_entry.email]
# output summary to console
domain_list_tmp = Counter(domain_list)
console = Console()
table = Table(show_header=True, header_style="bold magenta")
table.add_column("Domain", style="dim", width=12)
table.add_column("count")
for domain, count in domain_list_tmp.items():
table.add_row(domain, str(count))
console.print(table)
console = Console()
table = Table(show_header=True, header_style="bold magenta")
table.add_column("Users", style="dim", width=12)
table.add_column("Count")
table.add_row("Total", str(user_type_count_kms + user_type_count_kmc))
table.add_row("KMS", str(user_type_count_kms))
table.add_row("KMC", str(user_type_count_kmc))
console.print(table)
page_count += 1
return user_return_dict
def export_media(client, total_count):
"""
export and returns python dictionary
key = media owners
value = list of entryId
"""
filter = KalturaMediaEntryFilter()
pager = KalturaFilterPager()
pager.pageSize = 300
page_count = 1
media_return_dict = {}
domain_list = []
print_overview(total_count)
# Iterate on KalturaMediaListResponse objects
while page_count <= ceil(total_count / 300):
pager.pageIndex = page_count
result = client.media.list(filter, pager)
for media_entry in track(result.objects,
description="Exporting page " +
str(page_count)):
domain = media_entry.userId
domain = domain.split("@", 1)
if len(domain) < 2:
# We disregard KalturaMediaEntry objects owned by userId without domain
continue
domain_list.append(domain[1])
if media_entry.userId not in media_return_dict:
media_return_dict[media_entry.userId] = [media_entry.id]
else:
media_return_dict[media_entry.userId].append(media_entry.id)
# Look for Kaltura Capture entryId if mediaType = VIDEO
media_type_check = media_entry.mediaType
if media_type_check.value not in [2, 5, 201, 202, 203, 204]:
logging.debug(media_entry.id +
": mediaType is VIDEO. Check if multi_video")
multi_video_filter = KalturaMediaEntryFilter()
multi_video_filter.parentEntryIdEqual = media_entry.id
multi_video_pager = KalturaFilterPager()
multi_video_search = client.media.list(multi_video_filter,
multi_video_pager)
if len(multi_video_search.objects) > 0:
for multi_video_entry in multi_video_search.objects:
media_return_dict[media_entry.userId].append(
multi_video_entry.id)
else:
logging.debug(
media_entry.id +
": mediaType is not VIDEO. Don't check if multi_video")
# Output summary to console
domain_list_tmp = Counter(domain_list)
console = Console()
table = Table(show_header=True, header_style="bold magenta")
table.add_column("Domain", style="dim", width=12)
table.add_column("count")
for domain, count in domain_list_tmp.items():
table.add_row(domain, str(count))
console.print(table)
page_count += 1
return media_return_dict
def mediaCreation(self) -> DataSourceStatus:
"""
Update data with Kaltura media metadata from Kaltura API.
:return: DataSourceStatus
"""
self._kalturaInit()
KALTURA_MAX_MATCHES_ERROR: str = 'QUERY_EXCEEDED_MAX_MATCHES_ALLOWED'
tableName: str = 'mivideo_media_created'
logger.info('Starting procedure...')
kClient: KalturaRequestConfiguration = KalturaClient(KalturaConfiguration())
kClient.setKs( # pylint: disable=no-member
KalturaSessionService(kClient).start(
self.kUserSecret, type=KalturaSessionType.ADMIN, partnerId=self.kPartnerId))
kMedia = KalturaMediaService(kClient)
lastTime: datetime = self._readTableLastTime(
tableName, 'created_at', self.defaultLastTimestamp)
createdAtTimestamp: float = lastTime.timestamp()
kFilter = KalturaMediaEntryFilter()
kFilter.createdAtGreaterThanOrEqual = createdAtTimestamp
kFilter.categoriesFullNameIn = self.categoriesFullNameIn
kFilter.orderBy = KalturaMediaEntryOrderBy.CREATED_AT_ASC
kPager = KalturaFilterPager()
kPager.pageSize = 500 # 500 is maximum
kPager.pageIndex = 1
results: Sequence[KalturaMediaEntry] = None
lastCreatedAtTimestamp: Union[float, int] = createdAtTimestamp
lastId: Union[str, None] = None
numberResults: int = 0
queryPageNumber: int = kPager.pageIndex # for logging purposes
totalNumberResults: int = numberResults # for logging purposes
endOfResults = False
while not endOfResults:
try:
results = kMedia.list(kFilter, kPager).objects
except KalturaException as kException:
if (KALTURA_MAX_MATCHES_ERROR in kException.args):
# set new filter timestamp, reset pager to page 1, then continue
kFilter.createdAtGreaterThanOrEqual = lastCreatedAtTimestamp
logger.debug(
f'New filter timestamp: ({kFilter.createdAtGreaterThanOrEqual})')
# to avoid dupes, also filter out the last ID returned by previous query
# because Kaltura compares createdAt greater than *or equal* to timestamp
kFilter.idNotIn = lastId
kPager.pageIndex = 1
continue
logger.info(f'Other Kaltura API error: "{kException}"')
break
numberResults = len(results)
logger.debug(
f'Query page ({queryPageNumber}); number of results: ({numberResults})')
if (numberResults > 0):
resultDictionaries: Sequence[Dict] = tuple(r.__dict__ for r in results)
creationData: pd.DataFrame = self._makeCreationData(resultDictionaries)
creationData.to_sql(
tableName, self.appDb.engine, if_exists='append', index=False)
courseData: pd.DataFrame = self._makeCourseData(resultDictionaries)
courseData.to_sql('mivideo_media_courses', self.appDb.engine, if_exists='append',
index=False, method=self._queryRunner)
lastCreatedAtTimestamp = results[-1].createdAt
lastId = results[-1].id
totalNumberResults += numberResults
endOfResults = (numberResults < kPager.pageSize)
kPager.pageIndex += 1
queryPageNumber += 1
logger.info(f'Total number of results: ({totalNumberResults})')
logger.info('Procedure complete.')
return DataSourceStatus(ValidDataSourceName.KALTURA_API)
