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 buildTagRulesFromScratch(utag_threshold=5,
freq_threshold=3,
rule_threshold=0.8):
with MongoTransaction(client) as s:
_clearOrCreateCollections(s())
ret = db.db.items.aggregate([{
'$unwind': {
'path': '$item.utags'
}
}, {
'$group': {
'_id': '$item.utags',
'count': {
'$sum': 1
}
}
}],
session=s())
for r in ret:
db.db.utag_freq.insert_one(r, session=s())
s.mark_succeed()
with MongoTransaction(client) as s:
in_mem_utag_freq = dict([
(it['_id'], it['count'])
for it in db.db.utag_freq.find({}, session=s())
])
in_mem_tag_utag_freq = defaultdict(int)
for video_item in db.db.items.find({}, session=s()):
cur_tags = video_item['tags']
cur_utags = video_item['item']['utags'] if 'utags' in video_item[
'item'] else []
for (tag, utag) in itertools.product(cur_tags, cur_utags):
in_mem_tag_utag_freq[(tag, utag)] += 1
db.db.utag_tag_freq.insert_many([{
'tag': tag,
'utag': utag,
'freq': freq
} for ((tag, utag), freq) in in_mem_tag_utag_freq.items()],
session=s())
for ((tag, utag), freq) in in_mem_tag_utag_freq.items():
if freq < freq_threshold:
continue
if in_mem_utag_freq[utag] < utag_threshold:
continue
prob = float(freq) / float(in_mem_utag_freq[utag])
if prob > rule_threshold:
db.db.utag_rules.insert_one({
'utag': utag,
'tag': tag
},
session=s())
tag_obj = db.db.tags.find_one({'id': tag}, session=s())
print('Adding rule {%s} => {%s} with prob = %.2f%%' %
(utag, translateTagToPreferredLanguage(
tag_obj, 'CHS'), prob * 100))
s.mark_succeed()
def markAllRead(user, note_type: str = 'all') :
with MongoTransaction(client) as s :
if note_type == 'all ':
db.notes.update_many({'to': user['_id']}, {'$set': {'read': True}}, session = s())
else :
db.notes.update_many({'to': user['_id'], 'type': note_type}, {'$set': {'read': True}}, session = s())
s.mark_succeed()
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 addToVideo(user, vid: ObjectId, text: str, use_bleach=True):
filterOperation('postComment', user)
video_obj = db.videos.find_one({'_id': vid})
if video_obj is None:
raise UserError('VIDEO_NOT_EXIST')
with redis_lock.Lock(rdb, "videoEdit:" + video_obj["item"]["unique_id"]):
if 'comment_thread' in video_obj:
cid = addComment(user,
video_obj['comment_thread'],
text,
use_bleach=use_bleach)
return video_obj['comment_thread'], cid
else:
with MongoTransaction(client) as s:
tid = createThread('video',
video_obj['_id'],
video_obj['meta']['created_by'],
session=s())
db.videos.update_one({'_id': vid},
{'$set': {
'comment_thread': tid
}},
session=s())
s.mark_succeed()
cid = addComment(user, tid, text)
return tid, cid
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 queryAndProcessQueuingRequests(user, max_videos: int, worker_id: str):
filterOperation('subtitleocr_queryAndProcessQueuingRequests', user)
# step 1: max_videos > 0 and max_videos <= 100
if max_videos <= 0 or max_videos > Subtitles.MAX_WORKER_JOBS:
raise UserError('TOO_MANY_JOBS')
with redis_lock.Lock(rdb,
"mmdocr_global_lock"), MongoTransaction(client) as s:
# step 2: get top k oldest requests
ret = list(
db.subtitle_ocr.find({
"status": "Queuing"
}, session=s()).sort([("meta.modified_at", 1)
]).limit(max_videos)) # FIFO
ret_vids = [i['vid'] for i in ret]
ret_ids = [i['_id'] for i in ret]
# step 3: retrive video URLs
video_items = tagdb.retrive_items({"_id": {
"$in": ret_vids
}},
session=s())
video_urls = [{
"url": i["item"]["url"],
"unique_id": i["item"]["unique_id"]
} for i in video_items]
# step 4: mark reserved
db.subtitle_ocr.update_many({"_id": {
"$in": ret_ids
}}, {"$set": {
"status": "Reserved",
"worker_id": worker_id
}},
session=s())
s.mark_succeed()
# step 5: return
return video_urls
def addToPlaylist(user, pid: ObjectId, text: str, use_bleach=True):
filterOperation('postComment', user)
playlist_obj = playlist_db.retrive_item(pid)
if playlist_obj is None:
raise UserError('PLAYLIST_NOT_EXIST')
with redis_lock.Lock(rdb, "playlistEdit:" + str(pid)):
if 'comment_thread' in playlist_obj:
cid = addComment(user,
playlist_obj['comment_thread'],
text,
use_bleach=use_bleach)
return playlist_obj['comment_thread'], cid
else:
with MongoTransaction(client) as s:
tid = createThread('playlist',
playlist_obj['_id'],
playlist_obj['meta']['created_by'],
session=s())
playlist_db.update_item_query(
playlist_obj, {'$set': {
'comment_thread': tid
}},
session=s())
s.mark_succeed()
cid = addComment(user, tid, text)
return tid, cid
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 editComment(user, text: str, comment_id: ObjectId, use_bleach=True):
comm_obj = db.comment_items.find_one({'_id': comment_id})
if comm_obj is None:
raise UserError('COMMENT_NOT_EXIST')
if use_bleach:
text = bleach.clean(text, tags=[], attributes=[], styles=[])
l = len(text)
if l > Comments.MAX_COMMENT_LENGTH_LONG:
raise UserError('COMMENT_TOO_LONG')
elif l > Comments.MAX_COMMENT_LENGTH_REGULAR and not filterOperation(
'postLongComment', user, raise_exception=False):
raise UserError('COMMENT_TOO_LONG')
filterOperation('commentAdmin', user, comm_obj)
with MongoTransaction(client) as s:
db.comment_items.update_one(
{'_id': comment_id}, {'$set': {
'content': text,
'edited': True
}},
session=s())
db.comment_items.update_one({'_id': comment_id}, {
'$set': {
'meta.modified_at': datetime.now(),
'meta.modified_by': user['_id']
}
},
session=s())
s.mark_succeed()
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 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 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 _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 update_popularity_and_move_to_next_bin(self):
next_bin_idx = (self.idx + 1) % (self.num_bins + 2)
to_subtract_bin_idx = (self.idx + 2) % (self.num_bins + 2)
all_hitmap = Counter(self.hitmap)
current_bin = self.bins[self.idx] or {}
#print('current')
#print(current_bin)
current_bin_tags = list(current_bin.keys())
current_bin = {tag: current_bin[tag] for tag in current_bin_tags}
current_hitmap = Counter(current_bin)
all_hitmap = all_hitmap + current_hitmap
if self.bins[to_subtract_bin_idx] is not None:
#print('subtracting')
#print(self.bins[to_subtract_bin_idx])
to_subtract_hitmap = Counter(self.bins[to_subtract_bin_idx])
all_hitmap = all_hitmap - to_subtract_hitmap
self.bins[to_subtract_bin_idx] = {}
#print('all_hitmap')
#print(all_hitmap)
self.hitmap = all_hitmap
self.idx = next_bin_idx
self._sort()
with MongoTransaction(dbclient) as s:
self._try_save(s())
s.mark_succeed()
return self.hitmap_sorted
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 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 markAllRead(user):
with MongoTransaction(client) as s:
db.notes.update_many({'to': user['_id']}, {'$set': {
'read': True
}},
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 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 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 createPlaylistFromCopies(pid, site, user):
if site not in ["youtube", "bilibili", "nicovideo", "twitter", "acfun"]:
raise UserError("UNSUPPORTED_SITE")
videos, _, playlist_obj = listAllPlaylistVideosOrdered(pid, user)
new_pid = createPlaylist('english',
playlist_obj['title']['english'] + ' - %s' % site,
playlist_obj['desc']['english'],
playlist_obj['cover'], user,
playlist_obj['private'])
with redis_lock.Lock(rdb, 'editLink'), redis_lock.Lock(
rdb,
"playlistEdit:" + str(new_pid)), MongoTransaction(client) as s:
rank = 0
for video in videos:
copies = video['item']['item']['copies']
for cp in copies:
item = tagdb.retrive_item(cp, session=s())
if item['_id'] != video['vid'] and item['item']['site'] == site:
addVideoToPlaylistLockFree(new_pid,
item['_id'],
user,
rank,
session=s())
rank += 1
break
s.mark_succeed()
return new_pid
def rateVideo(user, vid: ObjectId, stars: int):
stars = max(min(int(stars), 10), 1)
video_obj = db.videos.find_one({'_id': vid})
if video_obj is None:
raise UserError('VIDEO_NOT_EXIST')
with redis_lock.Lock(
rdb, "videoEdit:" +
video_obj["item"]["unique_id"]), MongoTransaction(client) as s:
rating_obj = db.video_ratings.find_one(
{
'vid': vid,
'uid': ObjectId(user['_id'])
}, session=s())
user_rated = 0
if rating_obj:
user_rated = 1
db.video_ratings.update_one(
{
'vid': vid,
'uid': ObjectId(user['_id'])
}, {'$set': {
'v': int(stars)
}},
session=s())
else:
user_rated = 0
db.video_ratings.insert_one(
{
'vid': vid,
'uid': ObjectId(user['_id']),
'v': int(stars)
},
session=s())
if 'total_rating' in video_obj:
if rating_obj:
db.videos.update_one({'_id': vid}, {
'$inc': {
'total_rating': int(stars - rating_obj['v']),
'total_rating_user': int(1 - user_rated)
}
},
session=s())
else:
db.videos.update_one({'_id': vid}, {
'$inc': {
'total_rating': int(stars),
'total_rating_user': int(1 - user_rated)
}
},
session=s())
else:
db.videos.update_one({'_id': vid}, {
'$set': {
'total_rating': int(stars),
'total_rating_user': int(1)
}
},
session=s())
s.mark_succeed()
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 setVideoClearence(vid, clearence, user) :
if clearence >= 0 and clearence <= 3 :
filterOperation('setVideoClearence', user, vid)
with MongoTransaction(client) as s :
tagdb.set_item_clearence(vid, clearence, user, session = s())
s.mark_succeed()
else :
raise UserError('INCORRECT_CLEARENCE')
def ratePlaylist(user, pid: ObjectId, stars: int):
stars = max(min(int(stars), 10), 1)
playlist_obj = playlist_db.retrive_item(pid)
if playlist_obj is None:
raise UserError('PLAYLIST_NOT_EXIST')
with redis_lock.Lock(rdb, "playlistEdit:" +
str(pid)), MongoTransaction(client) as s:
rating_obj = db.playlist_ratings.find_one(
{
'pid': pid,
'uid': ObjectId(user['_id'])
}, session=s())
user_rated = 0
if rating_obj:
user_rated = 1
db.playlist_ratings.update_one(
{
'pid': pid,
'uid': ObjectId(user['_id'])
}, {'$set': {
'v': int(stars)
}},
session=s())
else:
user_rated = 0
db.playlist_ratings.insert_one(
{
'pid': pid,
'uid': ObjectId(user['_id']),
'v': int(stars)
},
session=s())
if 'total_rating' in playlist_obj:
if rating_obj:
playlist_db.update_item_query(playlist_obj, {
'$inc': {
'total_rating': int(stars - rating_obj['v']),
'total_rating_user': int(1 - user_rated)
}
},
session=s())
else:
playlist_db.update_item_query(playlist_obj, {
'$inc': {
'total_rating': int(stars),
'total_rating_user': int(1 - user_rated)
}
},
session=s())
else:
playlist_db.update_item_query(playlist_obj, {
'$set': {
'total_rating': int(stars),
'total_rating_user': int(1)
}
},
session=s())
s.mark_succeed()
def markRead(user, note_ids) :
if isinstance(note_ids, str) :
note_ids = [note_ids]
assert isinstance(note_ids, list)
note_ids = [ObjectId(i) for i in note_ids]
with MongoTransaction(client) as s :
# TODO: one can mark other's notifications as read here, add filtering later
db.notes.update_many({'_id': {'$in': note_ids}, 'to': user['_id']}, {'$set': {'read': True}}, session = s())
s.mark_succeed()
def broadcastNotificationWithContent(content: str) :
"""
similar to createNotification but does so for everyone!
"""
if len(content) > 65536 :
raise UserError('CONTENT_TOO_LONG')
with MongoTransaction(client) as s :
for u in db.users.find({}) :
createNotification('system_message', ObjectId(u['_id']), session = s(), other = {'content': content})
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()
