def get_filter(chat_id, keyword): try: return SESSION.query(Filters).get((str(chat_id), keyword)) except BaseException: return None finally: SESSION.close()
def get_notes(chat_id, keyword): try: return SESSION.query(NOTES).get((str(chat_id), keyword)) except BaseException: return None finally: SESSION.close()
def add_to_blacklist(chat_id, trigger): with BLACKLIST_FILTER_INSERTION_LOCK: blacklist_filt = BlackListFilters(str(chat_id), trigger) SESSION.merge(blacklist_filt) # merge to avoid duplicate key issues SESSION.commit() CHAT_BLACKLISTS.setdefault(str(chat_id), set()).add(trigger)
def is_nightmode_indb(chat_id: str): try: s__ = SESSION.query(Nightmode).get(str(chat_id)) if s__: return str(s__.chat_id) finally: SESSION.close()
def get_all_notes(chat_id): try: return SESSION.query(NOTES).filter(NOTES.chat_id == str(chat_id)).all() except BaseException: return None finally: SESSION.close()
def blacklist_url(chat_id, domain): with URL_BLACKLIST_FILTER_INSERTION_LOCK: domain_filt = URLBlackListFilters(str(chat_id), domain) SESSION.merge(domain_filt) SESSION.commit() CHAT_URL_BLACKLISTS.setdefault(str(chat_id), set()).add(domain)
def add_filter( chat_id, keyword, reply, snip_type, media_id, media_access_hash, media_file_reference, ): adder = SESSION.query(Filters).get((str(chat_id), keyword)) if adder: adder.reply = reply adder.snip_type = snip_type adder.media_id = media_id adder.media_access_hash = media_access_hash adder.media_file_reference = media_file_reference else: adder = Filters( chat_id, keyword, reply, snip_type, media_id, media_access_hash, media_file_reference, ) SESSION.add(adder) SESSION.commit()
def get_all_filters(chat_id): try: return SESSION.query(Filters).filter( Filters.chat_id == str(chat_id)).all() except BaseException: return None finally: SESSION.close()
def get_rules(chat_id): rules = SESSION.query(Rules).get(str(chat_id)) ret = "" if rules: ret = rules.rules SESSION.close() return ret
def already_added(chat_id): try: return SESSION.query(Moidata).filter( Moidata.chat_id == str(chat_id)).one() except: return None finally: SESSION.close()
def get_current_goodbye_settings(chat_id): try: return SESSION.query(Goodbye).filter( Goodbye.chat_id == str(chat_id)).one() except: return None finally: SESSION.close()
def __load_all_feds_settings(): global FEDERATION_NOTIFICATION try: getuser = SESSION.query(FedsUserSettings).all() for x in getuser: FEDERATION_NOTIFICATION[str(x.user_id)] = x.should_report finally: SESSION.close()
def get_current_welcome_settings(chat_id): try: return SESSION.query(Welcome).filter( Welcome.chat_id == str(chat_id)).one() except: return None finally: SESSION.close()
def get_warn_strength(chat_id): try: setting = SESSION.query(WarnSettings).get(str(chat_id)) if setting: return setting.soft_warn return "ban" finally: SESSION.close()
def get_all_chats(): try: return SESSION.query(ChatbotChats.chat_id).all() finally: SESSION.close()
def __load_afk_users(): global AFK_USERS global AFK_USERSS try: all_afk = SESSION.query(AFK).all() AFK_USERS = {user.user_id: user.reason for user in all_afk if user.is_afk} AFK_USERSS = {user.user_id: user.start_time for user in all_afk if user.is_afk} finally: SESSION.close()
def get_warn_setting(chat_id): try: setting = SESSION.query(WarnSettings).get(str(chat_id)) if setting: return setting.warn_limit, setting.soft_warn return 3, "ban" finally: SESSION.close()
def set_rules(chat_id, rules_text): with INSERTION_LOCK: rules = SESSION.query(Rules).get(str(chat_id)) if not rules: rules = Rules(str(chat_id)) rules.rules = rules_text SESSION.add(rules) SESSION.commit()
def set_warn_strength(chat_id, soft_warn): with WARN_SETTINGS_LOCK: curr_setting = SESSION.query(WarnSettings).get(str(chat_id)) if not curr_setting: curr_setting = WarnSettings(chat_id, soft_warn=soft_warn) curr_setting.soft_warn = soft_warn SESSION.add(curr_setting) SESSION.commit()
def set_warn_limit(chat_id, warn_limit): with WARN_SETTINGS_LOCK: curr_setting = SESSION.query(WarnSettings).get(str(chat_id)) if not curr_setting: curr_setting = WarnSettings(chat_id, warn_limit=warn_limit) curr_setting.warn_limit = warn_limit SESSION.add(curr_setting) SESSION.commit()
def get_warns(user_id, chat_id): try: user = SESSION.query(Warns).get((user_id, str(chat_id))) if not user: return None reasons = user.reasons num = user.num_warns return num, reasons finally: SESSION.close()
def __load_cleaner_list(): global GLOBAL_IGNORE_COMMANDS global CLEANER_CHATS try: GLOBAL_IGNORE_COMMANDS = { int(x.command) for x in SESSION.query(CleanerBlueTextGlobal).all() } finally: SESSION.close() try: for x in SESSION.query(CleanerBlueTextChatSettings).all(): CLEANER_CHATS.setdefault(x.chat_id, { "setting": False, "commands": set() }) CLEANER_CHATS[x.chat_id]["setting"] = x.is_enable finally: SESSION.close() try: for x in SESSION.query(CleanerBlueTextChat).all(): CLEANER_CHATS.setdefault(x.chat_id, { "setting": False, "commands": set() }) CLEANER_CHATS[x.chat_id]["commands"].add(x.command) finally: SESSION.close()
def __load_feds_subscriber(): global FEDS_SUBSCRIBER global MYFEDS_SUBSCRIBER try: feds = SESSION.query(FedSubs.fed_id).distinct().all() for (fed_id, ) in feds: # remove tuple by ( ,) FEDS_SUBSCRIBER[fed_id] = [] MYFEDS_SUBSCRIBER[fed_id] = [] all_fedsubs = SESSION.query(FedSubs).all() for x in all_fedsubs: FEDS_SUBSCRIBER[x.fed_id] += [x.fed_subs] try: MYFEDS_SUBSCRIBER[x.fed_subs] += [x.fed_id] except KeyError: getsubs = SESSION.query(FedSubs).get((x.fed_id, x.fed_subs)) if getsubs: SESSION.delete(getsubs) SESSION.commit() FEDS_SUBSCRIBER = {x: set(y) for x, y in FEDS_SUBSCRIBER.items()} MYFEDS_SUBSCRIBER = {x: set(y) for x, y in MYFEDS_SUBSCRIBER.items()} finally: SESSION.close()
def rem_chat(chat_id): with INSERTION_LOCK: autochat = SESSION.query(ChatbotChats).get(str(chat_id)) if autochat: SESSION.delete(autochat) SESSION.commit()
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_bio(user_id, fname): with INSERTION_LOCK: curr = SESSION.query(BIO).get(user_id) if not curr: curr = BIO(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 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 set_afk(user_id, reason, start_time=""): with INSERTION_LOCK: curr = SESSION.query(AFK).get(user_id) if not curr: curr = AFK(user_id, reason, True, start_time) else: curr.is_afk = True curr.reason = reason curr.start_time = start_time AFK_USERS[user_id] = reason AFK_USERSS[user_id] = start_time SESSION.add(curr) SESSION.commit()
def add_note(chat_id, keyword, reply): adder = SESSION.query(NOTES).get((str(chat_id), keyword)) if adder: adder.reply = reply else: adder = NOTES(chat_id, keyword, reply) adder = NOTES( chat_id, keyword, reply, ) SESSION.add(adder) SESSION.commit()
def __load_sudo_users(): global SUDO_USERS global SUDO_USERSS try: all_bio = SESSION.query(BIO).all() SUDO_USERS = { user.user_id: user.fname for user in all_bio if user.is_sudo } SUDO_USERSS = { user.user_id: user.fname for user in all_bio if user.is_sudo } finally: SESSION.close()