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()