def set_custom_gdbye(chat_id, custom_goodbye, goodbye_type, buttons=None): if buttons is None: buttons = [] with INSERTION_LOCK: welcome_settings = SESSION.query(Welcome).get(str(chat_id)) if not welcome_settings: welcome_settings = Welcome(str(chat_id), True) if custom_goodbye: welcome_settings.custom_leave = custom_goodbye welcome_settings.leave_type = goodbye_type.value else: welcome_settings.custom_leave = DEFAULT_GOODBYE welcome_settings.leave_type = Types.TEXT.value SESSION.add(welcome_settings) with LEAVE_BTN_LOCK: prev_buttons = SESSION.query(GoodbyeButtons).filter(GoodbyeButtons.chat_id == str(chat_id)).all() for btn in prev_buttons: SESSION.delete(btn) for b_name, url, same_line in buttons: button = GoodbyeButtons(chat_id, b_name, url, same_line) SESSION.add(button) SESSION.commit()
def update_user(user_id, username, chat_id=None, chat_name=None): with INSERTION_LOCK: user = SESSION.query(Users).get(user_id) if not user: user = Users(user_id, username) SESSION.add(user) SESSION.flush() else: user.username = username if not chat_id or not chat_name: SESSION.commit() return chat = SESSION.query(Chats).get(str(chat_id)) if not chat: chat = Chats(str(chat_id), chat_name) SESSION.add(chat) SESSION.flush() else: chat.chat_name = chat_name member = SESSION.query(ChatMembers).filter( ChatMembers.chat == chat.chat_id, ChatMembers.user == user.user_id).first() if not member: chat_member = ChatMembers(chat.chat_id, user.user_id) SESSION.add(chat_member) SESSION.commit()
def add_note_to_db(chat_id, note_name, note_data, msgtype, buttons=None, file=None): if not buttons: buttons = [] with NOTES_INSERTION_LOCK: prev = SESSION.query(Notes).get((str(chat_id), note_name)) if prev: with BUTTONS_INSERTION_LOCK: prev_buttons = SESSION.query(Buttons).filter( Buttons.chat_id == str(chat_id), Buttons.note_name == note_name).all() for btn in prev_buttons: SESSION.delete(btn) SESSION.delete(prev) note = Notes(str(chat_id), note_name, note_data or "", msgtype=msgtype.value, file=file) SESSION.add(note) SESSION.commit() for b_name, url, same_line in buttons: add_note_button_to_db(chat_id, note_name, b_name, url, same_line)
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 __load_cleaner_list(): global GLOBAL_IGNORE_COMMANDS global CLEANER_CHATS try: GLOBAL_IGNORE_COMMANDS = { 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 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 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 ASPAM_SETTING_LOCK: gban = SESSION.query(AntispamSettings).get(str(old_chat_id)) if gban: gban.chat_id = new_chat_id SESSION.add(gban) gmute = SESSION.query(AntispamSettings).get(str(old_chat_id)) if gmute: gmute.chat_id = new_chat_id SESSION.add(gmute) SESSION.commit()
def migrate_chat(old_chat_id, new_chat_id): with CUST_FILT_LOCK: chat_filters = SESSION.query(CustomFilters).filter(CustomFilters.chat_id == str(old_chat_id)).all() for filt in chat_filters: filt.chat_id = str(new_chat_id) SESSION.commit() CHAT_FILTERS[str(new_chat_id)] = CHAT_FILTERS[str(old_chat_id)] del CHAT_FILTERS[str(old_chat_id)] with BUTTON_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 __load_CHAT_STICKERS(): global CHAT_STICKERS try: chats = SESSION.query(StickersFilters.chat_id).distinct().all() for (chat_id, ) in chats: # remove tuple by ( ,) CHAT_STICKERS[chat_id] = [] all_filters = SESSION.query(StickersFilters).all() for x in all_filters: CHAT_STICKERS[x.chat_id] += [x.trigger] CHAT_STICKERS = {x: set(y) for x, y in CHAT_STICKERS.items()} finally: SESSION.close()
def __load_chat_filters(): global CHAT_FILTERS try: chats = SESSION.query(CustomFilters.chat_id).distinct().all() for (chat_id,) in chats: # remove tuple by ( ,) CHAT_FILTERS[chat_id] = [] all_filters = SESSION.query(CustomFilters).all() for x in all_filters: CHAT_FILTERS[x.chat_id] += [x.keyword] CHAT_FILTERS = {x: sorted(set(y), key=lambda i: (-len(i), i)) for x, y in CHAT_FILTERS.items()} finally: SESSION.close()
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.add(chat) SESSION.flush() 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.add(member) SESSION.commit()
def __load_chat_blacklists(): global CHAT_BLACKLISTS try: chats = SESSION.query(BlackListFilters.chat_id).distinct().all() for (chat_id, ) in chats: # remove tuple by ( ,) CHAT_BLACKLISTS[chat_id] = [] all_filters = SESSION.query(BlackListFilters).all() for x in all_filters: CHAT_BLACKLISTS[x.chat_id] += [x.trigger] CHAT_BLACKLISTS = {x: set(y) for x, y in CHAT_BLACKLISTS.items()} finally: SESSION.close()
def get_buttons(chat_id, note_name): try: return SESSION.query(Buttons).filter( Buttons.chat_id == str(chat_id), Buttons.note_name == note_name).order_by(Buttons.id).all() finally: SESSION.close()
def get_user_com_chats(user_id): try: chat_members = SESSION.query(ChatMembers).filter( ChatMembers.user == int(user_id)).all() return [i.chat for i in chat_members] finally: SESSION.close()
def __load_flood_settings(): global CHAT_FLOOD try: all_chats = SESSION.query(FloodControl).all() CHAT_FLOOD = {chat.chat_id: (None, DEF_COUNT, chat.limit) for chat in all_chats} finally: SESSION.close()
def unblacklistChat(chat_id): with BANCHATLOCK: chat = SESSION.query(BannedChat).get(chat_id) if chat: SESSION.delete(chat) SESSION.commit() __load_blacklisted_chats_list()
def migrate_chat(old_chat_id, new_chat_id): with CHAT_LOCK: chat_notes = SESSION.query(ReportingChatSettings).filter( ReportingChatSettings.chat_id == str(old_chat_id)).all() for note in chat_notes: note.chat_id = str(new_chat_id) SESSION.commit()
def user_demote_fed(fed_id, user_id): with FEDS_LOCK: global FEDERATION_BYOWNER, FEDERATION_BYFEDID, FEDERATION_BYNAME # Variables getfed = FEDERATION_BYFEDID.get(str(fed_id)) owner_id = getfed['owner'] fed_name = getfed['fname'] fed_rules = getfed['frules'] # Temp set try: members = eval(eval(getfed['fusers'])['members']) except ValueError: return False members.remove(user_id) # Set user FEDERATION_BYOWNER[str(owner_id)]['fusers'] = str({'owner': str(owner_id), 'members': str(members)}) FEDERATION_BYFEDID[str(fed_id)]['fusers'] = str({'owner': str(owner_id), 'members': str(members)}) FEDERATION_BYNAME[fed_name]['fusers'] = str({'owner': str(owner_id), 'members': str(members)}) # Set on database fed = Federations(str(owner_id), fed_name, str(fed_id), fed_rules, str({'owner': str(owner_id), 'members': str(members)})) SESSION.merge(fed) SESSION.commit() return True curr = SESSION.query(UserF).all() result = False for r in curr: if int(r.user_id) == int(user_id): if r.fed_id == fed_id: SESSION.delete(r) SESSION.commit() result = True SESSION.close() return result
def migrate_chat(old_chat_id, new_chat_id): with BLACKLIST_FILTER_INSERTION_LOCK: chat_filters = SESSION.query(BlackListFilters).filter( BlackListFilters.chat_id == str(old_chat_id)).all() for filt in chat_filters: filt.chat_id = str(new_chat_id) SESSION.commit()
def __load_log_channels(): global CHANNELS try: all_chats = SESSION.query(GroupLogs).all() CHANNELS = {chat.chat_id: chat.log_channel for chat in all_chats} finally: SESSION.close()
def __migrate_filters(): try: all_filters = SESSION.query(CustomFilters).distinct().all() for x in all_filters: if x.is_document: file_type = Types.DOCUMENT elif x.is_image: file_type = Types.PHOTO elif x.is_video: file_type = Types.VIDEO elif x.is_sticker: file_type = Types.STICKER elif x.is_audio: file_type = Types.AUDIO elif x.is_voice: file_type = Types.VOICE else: file_type = Types.TEXT print(str(x.chat_id), x.keyword, x.reply, file_type.value) if file_type == Types.TEXT: filt = CustomFilters(str(x.chat_id), x.keyword, x.reply, file_type.value, None) else: filt = CustomFilters(str(x.chat_id), x.keyword, None, file_type.value, x.reply) SESSION.add(filt) SESSION.commit() finally: SESSION.close()
def migrate_chat(old_chat_id, new_chat_id): with STICKERS_FILTER_INSERTION_LOCK: chat_filters = SESSION.query(StickersFilters).filter( StickersFilters.chat_id == str(old_chat_id)).all() for filt in chat_filters: filt.chat_id = str(new_chat_id) SESSION.commit()
def is_locked(chat_id, lock_type): curr_perm = SESSION.query(Permissions).get(str(chat_id)) SESSION.close() if not curr_perm: return False elif lock_type == "sticker": return curr_perm.sticker elif lock_type == "photo": return curr_perm.photo elif lock_type == "audio": return curr_perm.audio elif lock_type == "voice": return curr_perm.voice elif lock_type == "contact": return curr_perm.contact elif lock_type == "video": return curr_perm.video elif lock_type == "document": return curr_perm.document elif lock_type == "gif": return curr_perm.gif elif lock_type == "url": return curr_perm.url elif lock_type == "bots": return curr_perm.bots elif lock_type == "forward": return curr_perm.forward elif lock_type == "game": return curr_perm.game elif lock_type == "location": return curr_perm.location
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_blacklist_strength(chat_id, blacklist_type, value): # for blacklist_type # 0 = nothing # 1 = delete # 2 = warn # 3 = mute # 4 = kick # 5 = ban # 6 = tban # 7 = tmute with STICKSET_FILTER_INSERTION_LOCK: global CHAT_BLSTICK_BLACKLISTS curr_setting = SESSION.query(StickerSettings).get(str(chat_id)) if not curr_setting: curr_setting = StickerSettings(chat_id, blacklist_type=int(blacklist_type), value=value) curr_setting.blacklist_type = int(blacklist_type) curr_setting.value = str(value) CHAT_BLSTICK_BLACKLISTS[str(chat_id)] = { 'blacklist_type': int(blacklist_type), 'value': value } SESSION.add(curr_setting) SESSION.commit()
def _load_chat_blacklist(): global CHAT_URL_BLACKLISTS try: chats = SESSION.query(URLBlackListFilters.chat_id).distinct().all() for (chat_id, ) in chats: CHAT_URL_BLACKLISTS[chat_id] = [] all_urls = SESSION.query(URLBlackListFilters).all() for url in all_urls: CHAT_URL_BLACKLISTS[url.chat_id] += [url.domain] CHAT_URL_BLACKLISTS = { k: set(v) for k, v in CHAT_URL_BLACKLISTS.items() } finally: SESSION.close()
def warn_user(user_id, chat_id, reason=None): with WARN_INSERTION_LOCK: warned_user = SESSION.query(Warns).get((user_id, str(chat_id))) if not warned_user: warned_user = Warns(user_id, str(chat_id)) warned_user.num_warns += 1 if reason == "": reason = "No reason given." if reason: if warned_user.reasons is None: warned_user.reasons = [reason] else: warned_user.reasons = warned_user.reasons + [ reason ] # TODO:: double check this Daan: Not really wizardry, it adds a new entry to a list/array which can be done this way, basically append equivalent reasons = warned_user.reasons num = warned_user.num_warns SESSION.add(warned_user) SESSION.commit() return num, reasons
def gkick_reset(user_id): user = SESSION.query(GloballyKickedUsers).get(user_id) if user: user.times = 0 SESSION.delete(user) SESSION.commit() __load_gkick_userid_list()
def update_lock(chat_id, lock_type, locked): with PERM_LOCK: curr_perm = SESSION.query(Permissions).get(str(chat_id)) if not curr_perm: curr_perm = init_permissions(chat_id) if lock_type == "audio": curr_perm.audio = locked elif lock_type == "voice": curr_perm.voice = locked elif lock_type == "contact": curr_perm.contact = locked elif lock_type == "video": curr_perm.video = locked elif lock_type == "document": curr_perm.document = locked elif lock_type == "photo": curr_perm.photo = locked elif lock_type == "sticker": curr_perm.sticker = locked elif lock_type == "gif": curr_perm.gif = locked elif lock_type == 'url': curr_perm.url = locked elif lock_type == 'bots': curr_perm.bots = locked elif lock_type == 'forward': curr_perm.forward = locked elif lock_type == 'game': curr_perm.game = locked elif lock_type == 'location': curr_perm.location = locked SESSION.add(curr_perm) SESSION.commit()