def insertIntoPlaylistLockFree(pid, vid, rank, user, session) :
log(obj = {'pid': pid, 'vid': vid, 'rank': rank})
if tagdb.retrive_item({'_id': ObjectId(vid)}, session = session) is None :
#raise UserError('VIDEO_NOT_EXIST')
return False
conflicting_item = db.playlist_items.find_one({'pid': ObjectId(pid), 'vid': ObjectId(vid)}, session = session)
if conflicting_item is not None :
editPlaylist_MoveLockFree(pid, conflicting_item, rank, session = session)
db.playlists.update_one({'_id': ObjectId(pid)}, {'$set': {
'meta.modified_by': makeUserMeta(user),
'meta.modified_at': datetime.now()}}, session = session)
if conflicting_item['rank'] >= rank :
return True
else :
return False
playlists = tagdb.retrive_item({'_id': ObjectId(vid)}, session = session)['item']['series']
playlists.append(ObjectId(pid))
playlists = list(set(playlists))
tagdb.update_item_query(ObjectId(vid), {'$set': {'item.series': playlists}}, makeUserMeta(user), session = session)
db.playlists.update_one({"_id": ObjectId(pid)}, {"$inc": {"videos": int(1)}}, session = session)
db.playlist_items.update_many({'pid': ObjectId(pid), 'rank': {'$gte': rank}}, {'$inc': {'rank': int(1)}}, session = session)
db.playlist_items.insert_one({"pid": ObjectId(pid), "vid": ObjectId(vid), "rank": int(rank), "meta": makeUserMeta(user)}, session = session)
db.playlists.update_one({'_id': ObjectId(pid)}, {'$set': {
'meta.modified_by': makeUserMeta(user),
'meta.modified_at': datetime.now()}}, session = session)
return True
def updateCommonTags(pid, tags, user):
log(obj={'pid': pid, 'tags': tags})
with MongoTransaction(client) as s:
playlist_obj = db.playlists.find_one({'_id': ObjectId(pid)})
if playlist_obj is None:
raise UserError('PLAYLIST_NOT_EXIST')
filterOperation('editPlaylist', user, playlist_obj)
# user is editing video tags, not the playlist itself, no need to lock playlist
tags = tagdb.filter_and_translate_tags(tags, session=s())
old_tags = listCommonTagIDs(pid, user)
log(obj={'old_tags': old_tags})
old_tags_set = set(old_tags)
new_tags_set = set(tags)
tags_added = list((old_tags_set ^ new_tags_set) - old_tags_set)
tags_to_remove = list((old_tags_set ^ new_tags_set) - new_tags_set)
if len(tags_added) - len(
tags_to_remove) > PlaylistConfig.MAX_COMMON_TAGS:
raise UserError('TOO_MANY_TAGS')
all_video_ids, _ = listAllPlaylistVideosUnordered(pid)
if tags_to_remove:
tagdb.update_many_items_tags_pull(all_video_ids,
tags_to_remove,
makeUserMeta(user),
session=s())
if tags_added:
tagdb.update_many_items_tags_merge(all_video_ids,
tags_added,
makeUserMeta(user),
session=s())
s.mark_succeed()
def renameFolder(user, path, new_name) :
_verifyPath(path)
_verifyFolderName(new_name)
if path == "/" :
raise UserError('INVALID_PATH')
with redis_lock.Lock(rdb, f"folderEdit:{str(makeUserMeta(user))}:{path}"), MongoTransaction(client) as s :
folder_obj = _findFolder(user, path)
filterOperation('renameFolder', user, folder_obj)
parent_path, cur_folder = _parentPath(path)
if '\\' in cur_folder :
raise UserError('INVALID_PATH')
if db.playlist_folders.find_one({'user': makeUserMeta(user), 'path': parent_path + new_name + '/'}) :
raise UserError('FOLDER_ALREADY_EXIST')
parent_path_escaped = re.escape(parent_path)
cur_folder_esacped = re.escape(cur_folder)
query_regex = f'^{parent_path_escaped}{cur_folder_esacped}\\/.*'
replace_regex = re.compile(f'^({parent_path_escaped})({cur_folder_esacped})(\\/.*)')
paths = db.playlist_folders.find({'user': makeUserMeta(user), 'path': {'$regex': query_regex}}, session = s())
db.playlist_folders.update_one({'user': makeUserMeta(user), 'path': {'$regex': f'^{parent_path_escaped}{cur_folder_esacped}\\/$'}}, {'$set': {'name': new_name}}, session = s())
new_name_escaped = re.escape(new_name)
for p in paths :
new_path = replace_regex.sub(rf'\g<1>{new_name}\g<3>', p['path'])
db.playlist_folders.update_one({'_id': p['_id']}, {'$set': {'path': new_path}}, session = s())
db.playlist_folders.update_one({'user': makeUserMeta(user), 'path': {'$regex': query_regex}}, {'$set': {
'meta.modified_by': makeUserMeta(user),
'meta.modified_at': datetime.now()
}}, session = s())
s.mark_succeed()
return parent_path + new_name + '/'
def removePlaylistsFromFolder(user, path, playlists):
_verifyPath(path)
with redis_lock.Lock(
rdb,
f"folderEdit:{str(makeUserMeta(user))}:{path}"), MongoTransaction(
client) as s:
folder_obj = _findFolder(user, path)
filterOperation('addPlaylistsToFolder', user, folder_obj)
for pid in playlists:
fullpath = path + "\\" + pid + "\\/"
path_escaped = re.escape(fullpath)
query_regex = f'^{path_escaped}.*'
db.playlist_folders.delete_one(
{
'user': makeUserMeta(user),
'path': {
'$regex': query_regex
}
},
session=s())
db.playlist_folders.update_one({'_id': folder_obj['_id']}, {
'$set': {
'meta.modified_by': makeUserMeta(user),
'meta.modified_at': datetime.now()
}
},
session=s())
s.mark_succeed()
def changeFolderAccess(user, path, privateView, privateEdit, recursive = True) :
_verifyPath(path)
with redis_lock.Lock(rdb, f"folderEdit:{str(makeUserMeta(user))}:{path}"), MongoTransaction(client) as s :
folder_obj = _findFolder(user, path)
filterOperation('changeFolderAccess', user, folder_obj)
path_escaped = re.escape(path)
if recursive :
query_regex = f'^{path_escaped}.*'
else :
query_regex = f'^{path_escaped}$'
db.playlist_folders.update_many(
{
'user': makeUserMeta(user),
'path': {'$regex': query_regex}
},
{
'$set': {
'privateView': privateView,
'privateEdit': privateEdit
}
}, session = s())
db.playlist_folders.update_one({'_id': folder_obj['_id']}, {'$set': {
'meta.modified_by': makeUserMeta(user),
'meta.modified_at': datetime.now()
}}, session = s())
s.mark_succeed()
def addPlaylistsToFolder(user, path, playlists) :
_verifyPath(path)
with redis_lock.Lock(rdb, f"folderEdit:{str(makeUserMeta(user))}:{path}"), MongoTransaction(client) as s :
folder_obj = _findFolder(user, path)
filterOperation('addPlaylistsToFolder', user, folder_obj)
for pid in playlists :
playlist = playlist_db.retrive_item(pid, session = s())
if playlist is None :
continue # skip non-exist playlist
if playlist['item']['private'] and not filterOperation('viewPrivatePlaylist', user, playlist, raise_exception = False) :
continue # skip other's private playlist
playlist_path = path + "\\" + str(playlist['_id']) + "\\/"
if _findFolder(user, playlist_path, raise_exception = False) :
continue # skip duplicated playlist
playlist_obj = {
'user': makeUserMeta(user),
'leaf': True,
'playlist': playlist['_id'],
'name': None,
'path': playlist_path,
'privateView': folder_obj['privateView'],
'privateEdit': folder_obj['privateEdit'],
'meta': makeUserMetaObject(user)
}
db.playlist_folders.insert_one(playlist_obj, session = s())
db.playlist_folders.update_one({'_id': folder_obj['_id']}, {'$set': {
'meta.modified_by': makeUserMeta(user),
'meta.modified_at': datetime.now()
}}, session = s())
s.mark_succeed()
def insertIntoPlaylist(pid, vid, rank, user) :
log(obj = {'pid': pid, 'vid': vid, 'rank': rank})
with redis_lock.Lock(rdb, "playlistEdit:" + str(pid)), MongoTransaction(client) as s :
playlist = db.playlists.find_one({'_id': ObjectId(pid)}, session = s())
if playlist is None :
raise UserError('PLAYLIST_NOT_EXIST')
filterOperation('editPlaylist', user, playlist)
if tagdb.retrive_item({'_id': ObjectId(vid)}, session = s()) is None :
raise UserError('VIDEO_NOT_EXIST')
if playlist["videos"] > PlaylistConfig.MAX_VIDEO_PER_PLAYLIST :
raise UserError('VIDEO_LIMIT_EXCEEDED')
conflicting_item = db.playlist_items.find_one({'pid': ObjectId(pid), 'vid': ObjectId(vid)}, session = s())
if conflicting_item is not None :
editPlaylist_MoveLockFree(pid, conflicting_item, rank, session = s())
db.playlists.update_one({'_id': ObjectId(pid)}, {'$set': {
'meta.modified_by': makeUserMeta(user),
'meta.modified_at': datetime.now()}}, session = s())
s.mark_succeed()
return
if rank < 0 :
raise UserError('OUT_OF_RANGE')
if rank > playlist['videos'] :
rank = int(playlist['videos'])
playlists = tagdb.retrive_item({'_id': ObjectId(vid)}, session = s())['item']['series']
playlists.append(ObjectId(pid))
playlists = list(set(playlists))
tagdb.update_item_query(ObjectId(vid), {'$set': {'item.series': playlists}}, makeUserMeta(user), session = s())
db.playlists.update_one({"_id": ObjectId(pid)}, {"$inc": {"videos": int(1)}}, session = s())
db.playlist_items.update_many({'pid': ObjectId(pid), 'rank': {'$gte': rank}}, {'$inc': {'rank': int(1)}}, session = s())
db.playlist_items.insert_one({"pid": ObjectId(pid), "vid": ObjectId(vid), "rank": int(rank), "meta": makeUserMeta(user)}, session = s())
db.playlists.update_one({'_id': ObjectId(pid)}, {'$set': {
'meta.modified_by': makeUserMeta(user),
'meta.modified_at': datetime.now()}}, session = s())
s.mark_succeed()
def editVideoTagsQuery(query, query_type, tags_to_add, tags_to_remove, user):
if query_type not in ['tag', 'text']:
raise UserError('INCORRECT_QUERY_TYPE')
filterOperation('batchVideoTagEdit', user)
query_obj, _ = tagdb.compile_query(query)
log(obj={'query': dumps(query_obj)})
tagids_to_add = tagdb.filter_and_translate_tags(tags_to_add)
tagids_to_remove = tagdb.filter_and_translate_tags(tags_to_remove)
try:
count = 0
with MongoTransaction(client) as s_read, MongoTransaction(
client) as s_write:
result_cursor = tagdb.retrive_items(query_obj, session=s_read())
batch = _batchedRead(result_cursor)
while batch:
item_ids = [item['_id'] for item in batch]
tagdb.update_many_items_tags_pull(item_ids,
tagids_to_remove,
makeUserMeta(user),
session=s_write())
tagdb.update_many_items_tags_merge(item_ids,
tagids_to_add,
makeUserMeta(user),
session=s_write())
count += len(batch)
batch = _batchedRead(result_cursor)
s_write.mark_succeed()
return count
except pymongo.errors.OperationFailure as ex:
if '$not' in str(ex):
raise UserError('FAILED_NOT_OP')
else:
log(level='ERR', obj={'ex': str(ex)})
raise UserError('FAILED_UNKNOWN')
def addVideoToPlaylist(pid, vid, user):
log(obj={'pid': pid, 'vid': vid})
with redis_lock.Lock(rdb, "playlistEdit:" +
str(pid)), MongoTransaction(client) as s:
playlist = playlist_db.retrive_item(pid)
if playlist is None:
raise UserError('PLAYLIST_NOT_EXIST')
filterOperation('editPlaylist', user, playlist)
if tagdb.retrive_item({'_id': ObjectId(vid)}, session=s()) is None:
raise UserError('VIDEO_NOT_EXIST')
if playlist['item']["videos"] > PlaylistConfig.MAX_VIDEO_PER_PLAYLIST:
raise UserError('VIDEO_LIMIT_EXCEEDED')
conflicting_item = db.playlist_items.find_one(
{
'pid': ObjectId(pid),
'vid': ObjectId(vid)
}, session=s())
if conflicting_item is not None:
editPlaylist_MoveLockFree(pid,
conflicting_item,
int(playlist['item']["videos"]),
session=s())
playlist_db.update_item_query(playlist, {},
user=makeUserMeta(user),
session=s())
s.mark_succeed()
return
playlists = tagdb.retrive_item({'_id': ObjectId(vid)},
session=s())['item']['series']
playlists.append(ObjectId(pid))
playlists = list(set(playlists))
tagdb.update_item_query(ObjectId(vid),
{'$set': {
'item.series': playlists
}},
user=makeUserMeta(user),
session=s())
db.playlist_items.insert_one(
{
"pid": ObjectId(pid),
"vid": ObjectId(vid),
"rank": int(playlist['item']["videos"]),
"meta": makeUserMeta(user)
},
session=s())
playlist_db.update_item_query(playlist,
{"$inc": {
"item.videos": int(1)
}},
user=makeUserMeta(user),
session=s())
s.mark_succeed()
def updatePlaylistInfo(pid,
title,
desc,
cover,
user,
private=False,
privateEdit=True):
log(
obj={
'title': title,
'desc': desc,
'cover': cover,
'private': private,
'privateEdit': privateEdit
})
if len(title) > PlaylistConfig.MAX_TITLE_LENGTH:
raise UserError('TITLE_TOO_LONG')
if len(desc) > PlaylistConfig.MAX_DESC_LENGTH:
raise UserError('DESC_TOO_LONG')
if cover and len(cover) > PlaylistConfig.MAX_COVER_URL_LENGTH:
raise UserError('URL_TOO_LONG')
if not title:
raise UserError('EMPTY_TITLE')
if not desc:
raise UserError('EMPTY_DESC')
with redis_lock.Lock(rdb, "playlistEdit:" +
str(pid)), MongoTransaction(client) as s:
list_obj = playlist_db.retrive_item(pid)
log(obj={'playlist': list_obj})
if list_obj is None:
raise UserError('PLAYLIST_NOT_EXIST')
filterOperation('editPlaylist', user, list_obj)
if cover:
playlist_db.update_item_query(list_obj,
{'$set': {
"item.cover": cover
}},
user=makeUserMeta(user),
session=s())
playlist_db.update_item_query(
list_obj, {
'$set': {
"item.title": title,
"item.desc": desc,
"item.private": private,
"item.privateEdit": privateEdit
}
},
fields_to_index=['item.title', 'item.desc'],
user=makeUserMeta(user),
session=s())
s.mark_succeed()
def breakLink(vid, user):
filterOperation('breakLink', user, vid)
with redis_lock.Lock(rdb, 'editLink'), MongoTransaction(client) as s:
nodes = _getAllCopies(vid)
log(obj={'old_clique': nodes, 'node_remove': vid})
if nodes:
for node in nodes:
_removeThisCopy(node, vid, makeUserMeta(user), session=s())
tagdb.update_item_query(ObjectId(vid),
{"$set": {
"item.copies": []
}},
makeUserMeta(user),
session=s())
s.mark_succeed()
def editPlaylist_MoveUp(pid, vid, page, page_size, user) :
log(obj = {'pid': pid, 'vid': vid})
with redis_lock.Lock(rdb, "playlistEdit:" + str(pid)), MongoTransaction(client) as s :
playlist = db.playlists.find_one({'_id': ObjectId(pid)}, session = s())
if playlist is None :
raise UserError('PLAYLIST_NOT_EXIST')
filterOperation('editPlaylist', user, playlist)
if playlist["videos"] > 0 :
entry = db.playlist_items.find_one({"pid": ObjectId(pid), "vid": ObjectId(vid)}, session = s())
if entry is None :
s.mark_failover()
raise UserError('VIDEO_NOT_EXIST_OR_NOT_IN_PLAYLIST')
if entry['rank'] <= 0 :
return None
exchange_entry = db.playlist_items.find_one({"pid": ObjectId(pid), "rank": int(entry['rank'] - 1)}, session = s())
db.playlist_items.update_one({'_id': entry['_id']}, {'$set': {'rank': int(entry['rank'] - 1)}}, session = s())
db.playlist_items.update_one({'_id': exchange_entry['_id']}, {'$set': {'rank': int(entry['rank'])}}, session = s())
db.playlists.update_one({'_id': ObjectId(pid)}, {'$set': {
'meta.modified_by': makeUserMeta(user),
'meta.modified_at': datetime.now()}}, session = s())
#video_page, video_count = listPlaylistVideos(pid, page - 1, page_size, user)
s.mark_succeed()
#return {'videos': video_page, 'video_count': video_count, 'page': page}
else :
raise UserError('EMPTY_PLAYLIST')
def removeVideoFromPlaylist(pid, vid, page, page_size, user) :
log(obj = {'pid': pid, 'vid': vid})
with redis_lock.Lock(rdb, "playlistEdit:" + str(pid)), MongoTransaction(client) as s :
playlist = db.playlists.find_one({'_id': ObjectId(pid)}, session = s())
if playlist is None :
raise UserError('PLAYLIST_NOT_EXIST')
filterOperation('editPlaylist', user, playlist)
if playlist["videos"] > 0 :
entry = db.playlist_items.find_one({"pid": ObjectId(pid), "vid": ObjectId(vid)}, session = s())
if entry is None :
raise UserError('VIDEO_NOT_EXIST_OR_NOT_IN_PLAYLIST')
db.playlist_items.update_many({'pid': ObjectId(pid), 'rank': {'$gt': entry['rank']}}, {'$inc': {'rank': int(-1)}}, session = s())
db.playlist_items.delete_one({'_id': entry['_id']}, session = s())
db.playlists.update_one({"_id": ObjectId(pid)}, {"$inc": {"videos": int(-1)}}, session = s())
db.playlists.update_one({'_id': ObjectId(pid)}, {'$set': {
'meta.modified_by': makeUserMeta(user),
'meta.modified_at': datetime.now()}}, session = s())
else :
raise UserError('EMPTY_PLAYLIST')
"""
video_page, video_count = listPlaylistVideos(pid, page - 1, page_size, user)
if len(video_page) == 0 and page > 1 and video_count > 0 :
# in case deleting video results in current page becomes empty, show the previous page
video_page, video_count = listPlaylistVideos(pid, page - 2, page_size, user)
s.mark_succeed()
return {'videos': video_page, 'video_count': video_count, 'page': page - 1}
"""
s.mark_succeed()
def updatePlaylistInfo(pid, language, title, desc, cover, user, private = False) :
log(obj = {'title': title, 'desc': desc, 'cover': cover, 'private': private})
if len(title) > PlaylistConfig.MAX_TITLE_LENGTH :
raise UserError('TITLE_TOO_LONG')
if len(desc) > PlaylistConfig.MAX_DESC_LENGTH :
raise UserError('DESC_TOO_LONG')
if cover and len(cover) > PlaylistConfig.MAX_COVER_URL_LENGTH :
raise UserError('URL_TOO_LONG')
if not title :
raise UserError('EMPTY_TITLE')
if not desc :
raise UserError('EMPTY_DESC')
with redis_lock.Lock(rdb, "playlistEdit:" + str(pid)), MongoTransaction(client) as s :
list_obj = db.playlists.find_one({'_id': ObjectId(pid)})
log(obj = {'playlist': list_obj})
if list_obj is None :
raise UserError('PLAYLIST_NOT_EXIST')
filterOperation('editPlaylist', user, list_obj)
if cover :
db.playlists.update_one({'_id': ObjectId(pid)}, {'$set': {"cover": cover}}, session = s())
db.playlists.update_one({'_id': ObjectId(pid)}, {'$set': {
"title.%s" % language: title,
"desc.%s" % language: desc,
"private": private,
'meta.modified_by': makeUserMeta(user),
'meta.modified_at': datetime.now()}}, session = s())
s.mark_succeed()
def createFolder(user, root, name, privateView=False, privateEdit=True):
filterOperation('createFolder', user, root)
_verifyPath(root)
_verifyFolderName(name)
with redis_lock.Lock(rdb, f"folderEdit:{str(makeUserMeta(user))}:{root}"):
_findFolder(user, root)
fullpath = root + name + "/"
with redis_lock.Lock(
rdb, f"folderEdit:{str(makeUserMeta(user))}:{fullpath}"
), MongoTransaction(client) as s:
obj = _findFolder(user, fullpath, raise_exception=False)
if obj:
raise UserError('FOLDER_ALREADY_EXIST')
folder_obj = {
'user': makeUserMeta(user),
'leaf': False,
'playlist': None,
'name': name,
'path': fullpath,
'privateView': privateView,
'privateEdit': privateEdit,
'meta': makeUserMetaObject(user)
}
db.playlist_folders.insert_one(folder_obj, session=s())
s.mark_succeed()
def updatePlaylistCoverFromFile(pid, user, file_key):
log(obj={'pid': pid, 'file_key': file_key})
photo_file = None
if file_key.startswith("upload-image-"):
filename = rdb.get(file_key)
if filename:
photo_file = filename.decode('ascii')
if photo_file is None:
raise UserError('NO_COVER')
with redis_lock.Lock(rdb, "playlistEdit:" +
str(pid)), MongoTransaction(client) as s:
list_obj = playlist_db.retrive_item(pid)
log(obj={'playlist': list_obj})
if list_obj is None:
raise UserError('PLAYLIST_NOT_EXIST')
filterOperation('editPlaylist', user, list_obj)
playlist_db.update_item_query(list_obj,
{'$set': {
"item.cover": photo_file
}},
user=makeUserMeta(user),
session=s())
s.mark_succeed()
def _findFolder(user, path, raise_exception = True) :
if isinstance(user, str) :
user_id = ObjectId(user)
elif isinstance(user, dict) :
user_id = makeUserMeta(user)
elif isinstance(user, ObjectId) :
user_id = user
else :
assert False
obj = db.playlist_folders.find_one({'user': user_id, 'path': path})
if obj is None :
if path == '/' :
with MongoTransaction(client) as s :
obj = {
'user': user_id,
'leaf': False,
'playlist': None,
'name': "",
'path': "/",
'privateView': False,
'privateEdit': True,
'meta': {
'created_by': user_id,
'created_at': datetime.utcnow()
}
}
db.playlist_folders.insert_one(obj, session = s())
s.mark_succeed()
return obj
else :
if raise_exception :
raise UserError('FOLDER_NOT_EXIST')
else :
return None
return obj
def createPlaylist(title, desc, cover, user, private=False, privateEdit=True):
log(
obj={
'title': title,
'desc': desc,
'cover': cover,
'private': private,
'privateEdit': privateEdit
})
filterOperation('createPlaylist', user)
if len(title) > PlaylistConfig.MAX_TITLE_LENGTH:
raise UserError('TITLE_TOO_LONG')
if len(desc) > PlaylistConfig.MAX_DESC_LENGTH:
raise UserError('DESC_TOO_LONG')
if len(cover) > PlaylistConfig.MAX_COVER_URL_LENGTH:
raise UserError('URL_TOO_LONG')
if not cover:
cover = 'default-cover.jpg'
if not title:
raise UserError('EMPTY_TITLE')
if not desc:
raise UserError('EMPTY_DESC')
pid = playlist_db.add_item(
[], {
"title": title,
"desc": desc,
"private": private,
"privateEdit": privateEdit,
"views": int(0),
"videos": int(0),
"cover": cover
}, 3, ['title', 'desc'], makeUserMeta(user))
log(obj={'pid': pid})
return pid
def updatePlaylistCoverVID(pid, vid, page, page_size, user):
log(obj={'pid': pid, 'vid': vid})
with redis_lock.Lock(rdb, "playlistEdit:" +
str(pid)), MongoTransaction(client) as s:
list_obj = db.playlists.find_one({'_id': ObjectId(pid)})
log(obj={'playlist': list_obj})
if list_obj is None:
raise UserError('PLAYLIST_NOT_EXIST')
filterOperation('editPlaylist', user, list_obj)
video_obj = filterSingleVideo(vid, user)
if video_obj is None:
raise UserError('VIDEO_NOT_EXIST')
cover = video_obj['item']['cover_image']
db.playlists.update_one({'_id': ObjectId(pid)},
{'$set': {
"cover": cover
}},
session=s())
db.playlists.update_one({'_id': ObjectId(pid)}, {
'$set': {
'meta.modified_by': makeUserMeta(user),
'meta.modified_at': datetime.now()
}
},
session=s())
#video_page, video_count = listPlaylistVideos(pid, page - 1, page_size, user)
s.mark_succeed()
def listSubscriptedItems(user,
page_idx,
page_size,
user_language,
hide_placeholder=True,
order='latest_video'):
subs = list(db.subs.find({'meta.created_by': makeUserMeta(user)}))
q = [tagdb.compile_query(q['qs'], q['qt']) for q in subs]
query_obj = {'$or': []}
for qi, _ in q:
query_obj['$or'].append(qi)
for i in range(len(q)):
subs[i]['obj'] = q[i][0]
subs[i]['obj_tags'] = q[i][1]
default_blacklist_tagids = [
int(i) for i in Config.DEFAULT_BLACKLIST.split(',')
]
if user and 'settings' in user:
if user['settings']['blacklist'] == 'default':
query_obj = {
'$and':
[query_obj, {
'tags': {
'$nin': default_blacklist_tagids
}
}]
}
else:
query_obj = {
'$and':
[query_obj, {
'tags': {
'$nin': user['settings']['blacklist']
}
}]
}
elif user is None:
query_obj = {
'$and': [query_obj, {
'tags': {
'$nin': default_blacklist_tagids
}
}]
}
result = tagdb.retrive_items(query_obj)
if order == 'latest':
result = result.sort([("meta.created_at", -1)])
if order == 'oldest':
result = result.sort([("meta.created_at", 1)])
if order == 'video_latest':
result = result.sort([("item.upload_time", -1)])
if order == 'video_oldest':
result = result.sort([("item.upload_time", 1)])
ret = result.skip(page_idx * page_size).limit(page_size)
count = ret.count()
videos = [item for item in ret]
videos = filterVideoList(videos, user)
if hide_placeholder:
videos = _filterPlaceholder(videos)
return videos, subs, getCommonTags(user_language, videos), count
def listSubscriptionTags(user):
return list(
db.subs.find({
'meta.created_by': makeUserMeta(user),
'tagid': {
'$exists': True
}
}))
def removeAlias(user, alias):
with MongoTransaction(client) as s:
alias_obj = tagdb.db.tag_alias.find_one({'tag': alias}, session=s())
if alias_obj:
log(obj={'alias': alias, 'dst': alias_obj['dst']})
filterOperation('tagAdmin', user, alias_obj)
tagdb.remove_alias(alias, makeUserMeta(user), session=s())
s.mark_succeed()
def removeTag(user, tag):
log(obj={'tag': tag})
with MongoTransaction(client) as s:
tag_obj = tagdb.get_tag_object(tag, session=s())
log(obj={'tag_obj': tag_obj})
if tag_obj:
filterOperation('tagAdmin', user, tag_obj)
tagdb.remove_tag(tag_obj, makeUserMeta(user), session=s())
s.mark_succeed()
def transferCategory(user, tag, new_cat):
log(obj={'tag': tag, 'new_cat': new_cat})
with MongoTransaction(client) as s:
tag_obj = tagdb.get_tag_object(tag, session=s())
if tag_obj:
filterOperation('transferCategory', user, tag_obj)
tagdb.transfer_category(tag_obj,
new_cat,
makeUserMeta(user),
session=s())
s.mark_succeed()
def editTags_impl(item, tags, user, edit_behaviour):
with redis_lock.Lock(
rdb, "videoEdit:" +
item['item']['unique_id']), MongoTransaction(client) as s:
new_tagids = tagdb.update_item_tags(item,
tags,
makeUserMeta(user),
session=s(),
behaviour=edit_behaviour)
s.mark_succeed()
return new_tagids
def deleteFolder(user, path) :
_verifyPath(path)
with redis_lock.Lock(rdb, f"folderEdit:{str(makeUserMeta(user))}:{path}"), MongoTransaction(client) as s :
folder_obj = _findFolder(user, path)
filterOperation('deleteFolder', user, folder_obj)
path_escaped = re.escape(path)
query_regex = f'^{path_escaped}.*'
db.playlist_folders.delete_many({'user': makeUserMeta(user), 'path': {'$regex': query_regex}}, session = s())
s.mark_succeed()
def addVideoToPlaylistLockFree(pid, vid, user, rank, session):
log(obj={'pid': pid, 'vid': vid})
if tagdb.retrive_item({'_id': ObjectId(vid)}, session=session) is None:
#raise UserError('VIDEO_NOT_EXIST')
return False
conflicting_item = db.playlist_items.find_one(
{
'pid': ObjectId(pid),
'vid': ObjectId(vid)
}, session=session)
if conflicting_item is not None:
editPlaylist_MoveLockFree(pid, conflicting_item, rank, session=session)
playlist_db.update_item_query(pid, {},
user=makeUserMeta(user),
session=session)
return False
playlists = tagdb.retrive_item({'_id': ObjectId(vid)},
session=session)['item']['series']
playlists.append(ObjectId(pid))
playlists = list(set(playlists))
tagdb.update_item_query(ObjectId(vid),
{'$set': {
'item.series': playlists
}},
user=makeUserMeta(user),
session=session)
db.playlist_items.insert_one(
{
"pid": ObjectId(pid),
"vid": ObjectId(vid),
"rank": int(rank),
"meta": makeUserMeta(user)
},
session=session)
playlist_db.update_item_query(pid, {"$inc": {
"item.videos": int(1)
}},
user=makeUserMeta(user),
session=session)
return True
def postSubtitle(user, vid: ObjectId, language: str, subformat: str,
content: str):
if language not in VALID_LANGUAGES:
raise UserError('INVALID_LANGUAGE')
subformat = subformat.lower()
if subformat not in VALID_SUBTITLE_FORMAT:
raise UserError('INVALID_SUBTITLE_FORMAT')
video_item = tagdb.retrive_item(vid)
if video_item is None:
raise UserError('VIDEO_NOT_FOUND')
try:
size = len(content.encode('utf-8'))
except:
size = -1
filterOperation('postSubtitle', user)
with redis_lock.Lock(
rdb, "videoEdit:" +
video_item['item']['unique_id']), MongoTransaction(client) as s:
existing_item = db.subtitles.find_one(
{
'vid': vid,
'lang': language,
'format': subformat,
'meta.created_by': makeUserMeta(user)
},
session=s())
if existing_item is None:
subid = db.subtitles.insert_one(
{
'vid': vid,
'lang': language,
'format': subformat,
'content': content,
'size': size,
'deleted': False,
'autogen': False,
'version': 0,
'meta': makeUserMetaObject(user)
},
session=s()).inserted_id
else:
db.subtitles.update_one({'_id': existing_item['_id']}, {
'$set': {
'content': content,
'size': size,
'meta.modified_at': datetime.utcnow()
}
},
session=s())
subid = existing_item['_id']
s.mark_succeed()
return ObjectId(subid)
def updatePlaylistCover(pid, cover, user) :
log(obj = {'pid': pid, 'cover': cover})
with redis_lock.Lock(rdb, "playlistEdit:" + str(pid)), MongoTransaction(client) as s :
list_obj = db.playlists.find_one({'_id': ObjectId(pid)})
log(obj = {'playlist': list_obj})
if list_obj is None :
raise UserError('PLAYLIST_NOT_EXIST')
filterOperation('editPlaylist', user, list_obj)
db.playlists.update_one({'_id': ObjectId(pid)}, {'$set': {"cover": cover}}, session = s())
db.playlists.update_one({'_id': ObjectId(pid)}, {'$set': {
'meta.modified_by': makeUserMeta(user),
'meta.modified_at': datetime.now()}}, session = s())
s.mark_succeed()
def addTag_impl(user, tag, category, language):
ret, sanitized_tag = verifyAndSanitizeTagOrAlias(tag)
log(obj={'tag': sanitized_tag, 'cat': category, 'lang': language})
filterOperation('addTag', user)
if not ret:
raise UserError('INVALID_TAG')
if len(sanitized_tag) > TagsConfig.MAX_TAG_LENGTH:
raise UserError('TAG_TOO_LONG')
with MongoTransaction(client) as s:
tagdb.add_tag(sanitized_tag,
category,
language,
makeUserMeta(user),
session=s())
s.mark_succeed()
