def blacklist_user(user_id, reason=None): with BLACKLIST_LOCK: user = SESSION.query(BlacklistUsers).get(str(user_id)) if not user: user = BlacklistUsers(str(user_id), reason) else: user.reason = reason SESSION.add(user) SESSION.commit() __load_blacklist_userid_list()
def add_to_stickers(chat_id, trigger): with STICKERS_FILTER_INSERTION_LOCK: stickers_filt = StickersFilters(str(chat_id), trigger) SESSION.merge(stickers_filt) # merge to avoid duplicate key issues SESSION.commit() global CHAT_STICKERS if CHAT_STICKERS.get(str(chat_id), set()) == set(): CHAT_STICKERS[str(chat_id)] = {trigger} else: CHAT_STICKERS.get(str(chat_id), set()).add(trigger)
def set_feds_setting(user_id: int, setting: bool): with FEDS_SETTINGS_LOCK: global FEDERATION_NOTIFICATION user_setting = SESSION.query(FedsUserSettings).get(user_id) if not user_setting: user_setting = FedsUserSettings(user_id) user_setting.should_report = setting FEDERATION_NOTIFICATION[str(user_id)] = setting SESSION.add(user_setting) SESSION.commit()
def set_sudo(user_id, fname): with INSERTION_LOCK: curr = SESSION.query(SUDO).get(user_id) if not curr: curr = SUDO(user_id, fname, True) else: curr.is_sudo = True curr.fname = fname SUDO_USERS[user_id] = fname SUDO_USERSS[user_id] = fname SESSION.add(curr) SESSION.commit()
def update_gban_reason(user_id, name, reason=None): with GBANNED_USERS_LOCK: user = SESSION.query(GloballyBannedUsers).get(user_id) if not user: return None old_reason = user.reason user.name = name user.reason = reason SESSION.merge(user) SESSION.commit() return old_reason
def gban_user(user_id, name, reason=None): with GBANNED_USERS_LOCK: user = SESSION.query(GloballyBannedUsers).get(user_id) if not user: user = GloballyBannedUsers(user_id, name, reason) else: user.name = name user.reason = reason SESSION.merge(user) SESSION.commit() __load_gbanned_userid_list()
def add_warn_filter(chat_id, keyword, reply): with WARN_FILTER_INSERTION_LOCK: warn_filt = WarnFilters(str(chat_id), keyword, reply) if keyword not in WARN_FILTERS.get(str(chat_id), []): WARN_FILTERS[str(chat_id)] = sorted( WARN_FILTERS.get(str(chat_id), []) + [keyword], key=lambda x: (-len(x), x), ) SESSION.merge(warn_filt) # merge to avoid duplicate key issues SESSION.commit()
def add_sub(my_fed, fed_id): mime = FedSubs(my_fed, fed_id) SESSION.merge(mime) # merge to avoid duplicate key issues SESSION.commit() global MYFEDS_SUBSCRIBER if MYFEDS_SUBSCRIBER.get(my_fed, set()) == set(): MYFEDS_SUBSCRIBER[my_fed] = {fed_id} else: MYFEDS_SUBSCRIBER.get(my_fed, set()).add(fed_id) return True
def migrate_chat(old_chat_id, new_chat_id): with PERM_LOCK: perms = SESSION.query(Permissions).get(str(old_chat_id)) if perms: perms.chat_id = str(new_chat_id) SESSION.commit() with RESTR_LOCK: rest = SESSION.query(Restrictions).get(str(old_chat_id)) if rest: rest.chat_id = str(new_chat_id) SESSION.commit()
def migrate_chat(old_chat_id, new_chat_id): with INSERTION_LOCK: chat = SESSION.query(Chats).get(str(old_chat_id)) if chat: chat.chat_id = str(new_chat_id) SESSION.commit() chat_members = (SESSION.query(ChatMembers).filter( ChatMembers.chat == str(old_chat_id)).all()) for member in chat_members: member.chat = str(new_chat_id) SESSION.commit()
def set_afk(user_id, reason=""): with INSERTION_LOCK: curr = SESSION.query(AFK).get(user_id) if not curr: curr = AFK(user_id, reason, True) else: curr.is_afk = True AFK_USERS[user_id] = reason SESSION.add(curr) SESSION.commit()
def del_user(user_id): with INSERTION_LOCK: curr = SESSION.query(Users).get(user_id) if curr: SESSION.delete(curr) SESSION.commit() return True ChatMembers.query.filter(ChatMembers.user == user_id).delete() SESSION.commit() SESSION.close() return False
def remove_warn_filter(chat_id, keyword): with WARN_FILTER_INSERTION_LOCK: warn_filt = SESSION.query(WarnFilters).get((str(chat_id), keyword)) if warn_filt: if keyword in WARN_FILTERS.get(str(chat_id), []): # sanity check WARN_FILTERS.get(str(chat_id), []).remove(keyword) SESSION.delete(warn_filt) SESSION.commit() return True SESSION.close() return False
def migrate_chat(old_chat_id, new_chat_id): with DISABLE_INSERTION_LOCK: chats = SESSION.query(Disable).filter( Disable.chat_id == str(old_chat_id)).all() for chat in chats: chat.chat_id = str(new_chat_id) SESSION.add(chat) if str(old_chat_id) in DISABLED: DISABLED[str(new_chat_id)] = DISABLED.get(str(old_chat_id), set()) SESSION.commit()
def add_filter( chat_id, keyword, reply, is_sticker=False, is_document=False, is_image=False, is_audio=False, is_voice=False, is_video=False, buttons=None, ): global CHAT_FILTERS if buttons is None: buttons = [] with CUST_FILT_LOCK: prev = SESSION.query(CustomFilters).get((str(chat_id), keyword)) if prev: with BUTTON_LOCK: prev_buttons = (SESSION.query(Buttons).filter( Buttons.chat_id == str(chat_id), Buttons.keyword == keyword).all()) for btn in prev_buttons: SESSION.delete(btn) SESSION.delete(prev) filt = CustomFilters( str(chat_id), keyword, reply, is_sticker, is_document, is_image, is_audio, is_voice, is_video, bool(buttons), ) if keyword not in CHAT_FILTERS.get(str(chat_id), []): CHAT_FILTERS[str(chat_id)] = sorted( CHAT_FILTERS.get(str(chat_id), []) + [keyword], key=lambda x: (-len(x), x), ) SESSION.add(filt) SESSION.commit() for b_name, url, same_line in buttons: add_note_button_to_db(chat_id, keyword, b_name, url, same_line)
def set_human_checks(user_id, chat_id): with INSERTION_LOCK: human_check = SESSION.query(WelcomeMuteUsers).get((user_id, str(chat_id))) if not human_check: human_check = WelcomeMuteUsers(user_id, str(chat_id), True) else: human_check.human_check = True SESSION.add(human_check) SESSION.commit() return human_check
def rm_afk(user_id): with INSERTION_LOCK: curr = SESSION.query(AFK).get(user_id) if curr: if user_id in AFK_USERS: # sanity check del AFK_USERS[user_id] SESSION.delete(curr) SESSION.commit() return True SESSION.close() return False
def rem_sub(my_fed, fed_id): sox = SESSION.query(FedSubs).get((my_fed, fed_id)) if sox: if fed_id in MYFEDS_SUBSCRIBER.get(my_fed, set()): # sanity check MYFEDS_SUBSCRIBER.get(my_fed, set()).remove(fed_id) SESSION.delete(sox) SESSION.commit() return True SESSION.close() return False
def rm_sudo(user_id): with INSERTION_LOCK: curr = SESSION.query(SUDO).get(user_id) if curr: if user_id in SUDO_USERS: # sanity check del SUDO_USERS[user_id] del SUDO_USERSS[user_id] SESSION.delete(curr) SESSION.commit() return True SESSION.close() return False
def set_flood(chat_id, amount): with INSERTION_FLOOD_LOCK: flood = SESSION.query(FloodControl).get(str(chat_id)) if not flood: flood = FloodControl(str(chat_id)) flood.user_id = None flood.limit = amount CHAT_FLOOD[str(chat_id)] = (None, DEF_COUNT, amount) SESSION.add(flood) SESSION.commit()
def unsubs_fed(fed_id, my_fed): with FEDS_SUBSCRIBER_LOCK: getsubs = SESSION.query(FedSubs).get((fed_id, my_fed)) if getsubs: if my_fed in FEDS_SUBSCRIBER.get(fed_id, set()): # sanity check FEDS_SUBSCRIBER.get(fed_id, set()).remove(my_fed) SESSION.delete(getsubs) SESSION.commit() return True SESSION.close() return False
def multi_fban_user( multi_fed_id, multi_user_id, multi_first_name, multi_last_name, multi_user_name, multi_reason, ): if True: # with FEDS_LOCK: counter = 0 time = 0 for x in range(len(multi_fed_id)): fed_id = multi_fed_id[x] user_id = multi_user_id[x] first_name = multi_first_name[x] last_name = multi_last_name[x] user_name = multi_user_name[x] reason = multi_reason[x] r = SESSION.query(BansF).all() for I in r: if I.fed_id == fed_id: if int(I.user_id) == int(user_id): SESSION.delete(I) r = BansF( str(fed_id), str(user_id), first_name, last_name, user_name, reason, time, ) SESSION.add(r) counter += 1 if str(str(counter)[-2:]) == "00": print(user_id) print(first_name) print(reason) print(counter) try: SESSION.commit() except: SESSION.rollback() return False finally: SESSION.commit() __load_all_feds_banned() print("Done") return counter
def disable_command(chat_id, disable): with DISABLE_INSERTION_LOCK: disabled = SESSION.query(Disable).get((str(chat_id), disable)) if not disabled: DISABLED.setdefault(str(chat_id), set()).add(disable) disabled = Disable(str(chat_id), disable) SESSION.add(disabled) SESSION.commit() return True SESSION.close() return False
def remove_warn(user_id, chat_id): with WARN_INSERTION_LOCK: removed = False warned_user = SESSION.query(Warns).get((user_id, str(chat_id))) if warned_user and warned_user.num_warns > 0: warned_user.num_warns -= 1 warned_user.reasons = warned_user.reasons[:-1] SESSION.add(warned_user) SESSION.commit() removed = True SESSION.close() return removed
def migrate_chat(old_chat_id, new_chat_id): with NOTES_INSERTION_LOCK: chat_notes = (SESSION.query(Notes).filter( Notes.chat_id == str(old_chat_id)).all()) for note in chat_notes: note.chat_id = str(new_chat_id) with BUTTONS_INSERTION_LOCK: chat_buttons = (SESSION.query(Buttons).filter( Buttons.chat_id == str(old_chat_id)).all()) for btn in chat_buttons: btn.chat_id = str(new_chat_id) SESSION.commit()
def enable_command(chat_id, enable): with DISABLE_INSERTION_LOCK: disabled = SESSION.query(Disable).get((str(chat_id), enable)) if disabled: if enable in DISABLED.get(str(chat_id)): # sanity check DISABLED.setdefault(str(chat_id), set()).remove(enable) SESSION.delete(disabled) SESSION.commit() return True SESSION.close() return False
def subs_fed(fed_id, my_fed): check = get_spec_subs(fed_id, my_fed) if check: return False with FEDS_SUBSCRIBER_LOCK: subsfed = FedSubs(fed_id, my_fed) SESSION.merge(subsfed) # merge to avoid duplicate key issues SESSION.commit() global FEDS_SUBSCRIBER if FEDS_SUBSCRIBER.get(fed_id, set()) == set(): FEDS_SUBSCRIBER[fed_id] = {my_fed} else: FEDS_SUBSCRIBER.get(fed_id, set()).add(my_fed) return True
def chat_join_fed(fed_id, chat_name, chat_id): with FEDS_LOCK: global FEDERATION_CHATS, FEDERATION_CHATS_BYID r = ChatF(chat_id, chat_name, fed_id) SESSION.add(r) FEDERATION_CHATS[str(chat_id)] = { "chat_name": chat_name, "fid": fed_id } checkid = FEDERATION_CHATS_BYID.get(fed_id) if checkid is None: FEDERATION_CHATS_BYID[fed_id] = [] FEDERATION_CHATS_BYID[fed_id].append(str(chat_id)) SESSION.commit() return r
def global_unignore_command(command): command = command.lower() with CLEANER_GLOBAL_LOCK: unignored = SESSION.query(CleanerBlueTextGlobal).get(str(command)) if unignored: if command in GLOBAL_IGNORE_COMMANDS: GLOBAL_IGNORE_COMMANDS.remove(command) SESSION.delete(command) SESSION.commit() return True SESSION.close() return False
def global_ignore_command(command): command = command.lower() with CLEANER_GLOBAL_LOCK: ignored = SESSION.query(CleanerBlueTextGlobal).get(str(command)) if not ignored: GLOBAL_IGNORE_COMMANDS.add(command) ignored = CleanerBlueTextGlobal(str(command)) SESSION.add(ignored) SESSION.commit() return True SESSION.close() return False