def __user_info__(user_id, chat_id): is_gbanned = sql.is_user_gbanned(user_id) is_gmuted = sql.is_user_gmuted(user_id) if not user_id in SUDO_USERS or not user_id in WHITELIST_USERS: text = tld(chat_id, "antispam_userinfo_gbanned") if is_gbanned: text = text.format(tld(chat_id, "common_yes")) text += tld(chat_id, "anitspam_appeal") user = sql.get_gbanned_user(user_id) if user.reason: text += tld(chat_id, "antispam_userinfo_gban_reason").format( html.escape(user.reason)) else: text = text.format(tld(chat_id, "common_no")) text += tld(chat_id, "antispam_userinfo_gmute") if is_gmuted: text = text.format(tld(chat_id, "common_yes")) text += tld(chat_id, "anitspam_appeal") user = sql.get_gmuted_user(user_id) if user.reason: text += tld(chat_id, "antispam_userinfo_gmute_reason").format(html.escape(user.reason)) else: text = text.format(tld(chat_id, "common_no")) return text else: return ""
def check_and_ban(update, user_id, should_message=True): chat = update.effective_chat message = update.effective_message try: if sw != None: sw_ban = sw.get_ban(user_id) if sw_ban: spamwatch_reason = sw_ban.reason chat.kick_member(user_id) if should_message: message.reply_text(tld( chat.id, "antispam_spamwatch_banned").format(spamwatch_reason), parse_mode=ParseMode.HTML) return else: return except Exception: pass if sql.is_user_gbanned(user_id): chat.kick_member(user_id) if should_message: userr = sql.get_gbanned_user(user_id) usrreason = userr.reason if not usrreason: usrreason = tld(chat.id, "antispam_no_reason") message.reply_text(tld( chat.id, "antispam_checkban_user_removed").format(usrreason), parse_mode=ParseMode.MARKDOWN) return
def __user_info__(user_id, chat_id): is_gbanned = sql.is_user_gbanned(user_id) is_gmuted = sql.is_user_gmuted(user_id) if not user_id in SUDO_USERS: text = tld(chat_id, "Globally banned: <b>{}</b>") if is_gbanned: text = text.format(tld(chat_id, "Yes")) user = sql.get_gbanned_user(user_id) if user.reason: text += tld(chat_id, "\nReason: {}").format(html.escape(user.reason)) else: text = text.format(tld(chat_id, "No")) text += tld(chat_id, "\nGlobally muted: <b>{}</b>") if is_gmuted: text = text.format(tld(chat_id, "Yes")) user = sql.get_gmuted_user(user_id) if user.reason: text += tld(chat_id, "\nReason: {}").format(html.escape(user.reason)) else: text = text.format(tld(chat_id, "No")) return text else: return ""
def check_and_ban(update, user_id, should_message=True): if sql.is_user_gbanned(user_id): update.effective_chat.kick_member(user_id) if should_message: update.effective_message.reply_text( "This is a bad person, they shouldn't be here that's why I'm gonna remove him!" )
def check_update(self, update): if (isinstance(update, Update) and (update.message or update.edited_message and self.allow_edited)): message = update.message or update.edited_message if sql.is_user_gbanned(update.effective_user.id): return False if message.text and message.text.startswith('/') and len( message.text) > 1: first_word = message.text_html.split(None, 1)[0] if len(first_word) > 1 and first_word.startswith('/'): command = first_word[1:].split('@') command.append( message.bot.username ) # in case the command was sent without a username if not (command[0].lower() in self.command and command[1].lower() == message.bot.username.lower()): return False if self.filters is None: res = True elif isinstance(self.filters, list): res = any(func(message) for func in self.filters) else: res = self.filters(message) return res return False
def ungban(bot: Bot, update: Update, args: List[str]): message = update.effective_message # type: Optional[Message] user_id = extract_user(message, args) if not user_id: message.reply_text("You don't seem to be referring to a user.") return user_chat = bot.get_chat(user_id) if user_chat.type != 'private': message.reply_text("That's not a user!") return if not sql.is_user_gbanned(user_id): message.reply_text("This user is not gbanned!") return banner = update.effective_user # type: Optional[User] message.reply_text("I'll give {} a second chance, globally.".format( user_chat.first_name)) send_to_list(bot, SUDO_USERS + SUPPORT_USERS, "{} has ungbanned user {}".format( mention_html(banner.id, banner.first_name), mention_html(user_chat.id, user_chat.first_name)), html=True) chats = get_all_chats() for chat in chats: chat_id = chat.chat_id # Check if this group has disabled gbans if not sql.does_chat_gban(chat_id): continue try: member = bot.get_chat_member(chat_id, user_id) if member.status == 'kicked': bot.unban_chat_member(chat_id, user_id) except BadRequest as excp: if excp.message in UNGBAN_ERRORS: pass else: message.reply_text("Could not un-gban due to: {}".format( excp.message)) bot.send_message( OWNER_ID, "Could not un-gban due to: {}".format(excp.message)) return except TelegramError: pass sql.ungban_user(user_id) send_to_list(bot, SUDO_USERS + SUPPORT_USERS, "un-gban complete!") message.reply_text("Person has been un-gbanned.")
def check_and_ban(update, user_id, should_message=True): if sql.is_user_gbanned(user_id): update.effective_chat.kick_member(user_id) if should_message: update.effective_message.reply_text( "Again, insects, you ask what am I? What I am is angry. What I am is insane with rage!" )
def __user_info__(user_id, chat_id): is_gbanned = sql.is_user_gbanned(user_id) is_gmuted = sql.is_user_gmuted(user_id) if not user_id in SUDO_USERS: text = tld(chat_id,"antispam_gban") if is_gbanned: text = text.format(tld(chat_id, "antispam_yes")) user = sql.get_gbanned_user(user_id) if user.reason: text += tld(chat_id, "antispam_reason").format(html.escape(user.reason)) else: text = text.format(tld(chat_id, "antispam_no")) text += tld(chat_id,"antispam_gmuted") if is_gmuted: text = text.format(tld(chat_id, "antispam_yes")) user = sql.get_gmuted_user(user_id) if user.reason: text += tld(chat_id, "antispam_reason").format(html.escape(user.reason)) else: text = text.format(tld(chat_id, "antispam_no")) return text else: return ""
def check_and_ban(update, user_id, should_message=True): if sql.is_user_gbanned(user_id): update.effective_chat.kick_member(user_id) if should_message: update.effective_message.reply_text( "Again, what the f**k? You stupid, you shouldn't be here. You're an evil soul!" )
def check_and_ban(update, user_id, should_message=True): if sql.is_user_gbanned(user_id): update.effective_chat.kick_member(user_id) if should_message: userr = sql.get_gbanned_user(user_id) usrreason = userr.reason if not usrreason: usrreason = "No reason given" update.effective_message.reply_text(f"*This user is gbanned and have been removed.*\nReason: `{usrreason}`", parse_mode=ParseMode.MARKDOWN)
def __user_info__(user_id): is_gbanned = sql.is_user_gbanned(user_id) text = "Globally banned: <b>{}</b>" if is_gbanned: text = text.format("Yes") user = sql.get_gbanned_user(user_id) if user.reason: text += "\n<b>Reason:</b> {}".format(html.escape(user.reason)) text += "\n<b>Appeal Chat:</b> @OnePunchSupport" else: text = text.format("No") return text
def check_and_ban(update, user_id, should_message=True): chat = update.effective_chat # type: Optional[Chat] #sw_ban = sw.get_ban(int(user_id)) #if sw_ban: # update.effective_chat.kick_member(user_id) # if should_message: # update.effective_message.reply_markdown("**This user is detected as spam bot by SpamWatch and have been removed!**\n\nPlease visit @SpamWatchSupport to appeal!") # return # else: # return if sql.is_user_gbanned(user_id): update.effective_chat.kick_member(user_id) if should_message: userr = sql.get_gbanned_user(user_id) usrreason = userr.reason if not usrreason: usrreason = tld(chat.id, "antispam_no_reason") update.effective_message.reply_text(tld( chat.id, "antispam_checkban_user_removed").format(usrreason), parse_mode=ParseMode.MARKDOWN) return
def gban(bot: Bot, update: Update, args: List[str]): message = update.effective_message # type: Optional[Message] chat = update.effective_chat # type: Optional[Chat] banner = update.effective_user # type: Optional[User] user_id, reason = extract_user_and_text(message, args) if not user_id: message.reply_text(tld(chat.id, "common_err_no_user")) return if int(user_id) in SUDO_USERS: message.reply_text(tld(chat.id, "antispam_err_usr_sudo")) return if int(user_id) in SUPPORT_USERS: message.reply_text(tld(chat.id, "antispam_err_usr_support")) return if user_id == bot.id: message.reply_text(tld(chat.id, "antispam_err_usr_bot")) return try: user_chat = bot.get_chat(user_id) except BadRequest as excp: message.reply_text(excp.message) return if user_chat.type != 'private': message.reply_text(tld(chat.id, "antispam_err_not_usr")) return if user_chat.first_name == '': message.reply_text(tld(chat.id, "antispam_err_usr_deleted")) return full_reason = f"{reason} // GBanned by {banner.first_name} id {banner.id}" if sql.is_user_gbanned(user_id): if not reason: message.reply_text(tld(chat.id, "antispam_err_no_new_reason")) return old_reason = sql.update_gban_reason( user_id, user_chat.username or user_chat.first_name, full_reason) or "None" if int(banner.id) in [172811422, 214416808]: return try: bot.send_message( MESSAGE_DUMP, tld(chat.id, "antispam_logger_update_gban").format( mention_html(banner.id, banner.first_name), mention_html(user_chat.id, user_chat.first_name or "Deleted Account"), user_chat.id, old_reason, full_reason), parse_mode=ParseMode.HTML) except: pass message.reply_text(tld(chat.id, "antispam_reason_updated").format( html.escape(old_reason), html.escape(full_reason)), parse_mode=ParseMode.HTML) return starting = tld(chat.id, "antispam_new_gban").format( mention_html(user_chat.id, user_chat.first_name or "Deleted Account"), user_chat.id) message.reply_text(starting, parse_mode=ParseMode.HTML) try: bot.send_message(MESSAGE_DUMP, tld(chat.id, "antispam_logger_new_gban").format( mention_html(banner.id, banner.first_name), mention_html(user_chat.id, user_chat.first_name), user_chat.id, full_reason or tld(chat.id, "antispam_no_reason")), parse_mode=ParseMode.HTML) except: print("nut") sql.gban_user(user_id, user_chat.username or user_chat.first_name, full_reason) try: if int(banner.id) in [172811422, 214416808]: return chat.kick_member(user_chat.id) except: print("Meh")
def left_member(bot: Bot, update: Update): chat = update.effective_chat # type: Optional[Chat] should_goodbye, cust_goodbye, cust_content, goodbye_type = sql.get_gdbye_pref( chat.id) cust_goodbye = markdown_to_html(cust_goodbye) if should_goodbye: left_mem = update.effective_message.left_chat_member if left_mem: if is_user_gbanned(left_mem.id): return # Ignore bot being kicked if left_mem.id == bot.id: return # Give the owner a special goodbye if left_mem.id == OWNER_ID: update.effective_message.reply_text("Bye owner") return # if media goodbye, use appropriate function for it if goodbye_type != sql.Types.TEXT and goodbye_type != sql.Types.BUTTON_TEXT: reply = update.message.message_id cleanserv = sql.clean_service(chat.id) # Clean service welcome if cleanserv: try: dispatcher.bot.delete_message( chat.id, update.message.message_id) except BadRequest: pass reply = False # Formatting text first_name = left_mem.first_name or "PersonWithNoName" # edge case of empty name - occurs for some bugs. if left_mem.last_name: fullname = "{} {}".format(first_name, left_mem.last_name) else: fullname = first_name count = chat.get_members_count() mention = mention_html(left_mem.id, first_name) if left_mem.username: username = "******" + escape(left_mem.username) else: username = mention formatted_text = cust_goodbye.format( first=escape(first_name), last=escape(left_mem.last_name or first_name), fullname=escape(fullname), username=username, mention=mention, count=count, chatname=escape(chat.title), id=left_mem.id) # Build keyboard buttons = sql.get_gdbye_buttons(chat.id) keyb = build_keyboard(buttons) keyboard = InlineKeyboardMarkup(keyb) # Send message ENUM_FUNC_MAP[goodbye_type](chat.id, cust_content, caption=cust_goodbye, reply_markup=keyboard, parse_mode="markdown", reply_to_message_id=reply) return first_name = left_mem.first_name or "PersonWithNoName" # edge case of empty name - occurs for some bugs. if cust_goodbye: if left_mem.last_name: fullname = "{} {}".format(first_name, left_mem.last_name) else: fullname = first_name count = chat.get_members_count() mention = mention_html(left_mem.id, first_name) if left_mem.username: username = "******" + escape(left_mem.username) else: username = mention valid_format = escape_invalid_curly_brackets( cust_goodbye, VALID_WELCOME_FORMATTERS) res = valid_format.format(first=escape(first_name), last=escape(left_mem.last_name or first_name), fullname=escape(fullname), username=username, mention=mention, count=count, chatname=escape(chat.title), id=left_mem.id) buttons = sql.get_gdbye_buttons(chat.id) keyb = build_keyboard(buttons) else: res = sql.DEFAULT_GOODBYE keyb = [] keyboard = InlineKeyboardMarkup(keyb) send(update, res, keyboard, sql.DEFAULT_GOODBYE)
def ungban(bot: Bot, update: Update, args: List[str]): message = update.effective_message # type: Optional[Message] chat = update.effective_chat # type: Optional[Chat] user_id = extract_user(message, args) if not user_id: message.reply_text(tld(chat.id, "common_err_no_user")) return user_chat = bot.get_chat(user_id) if user_chat.type != 'private': message.reply_text(tld(chat.id, "antispam_err_not_usr")) return if not sql.is_user_gbanned(user_id): message.reply_text(tld(chat.id, "antispam_user_not_gbanned")) return banner = update.effective_user # type: Optional[User] message.reply_text("I'll give {} a second chance, globally.".format( user_chat.first_name)) try: bot.send_message(MESSAGE_DUMP, tld(chat.id, "antispam_logger_ungban").format( mention_html(banner.id, banner.first_name), mention_html(user_chat.id, user_chat.first_name)), parse_mode=ParseMode.HTML) except: pass chats = get_all_chats() for chat in chats: chat_id = chat.chat_id # Check if this group has disabled gbans if not sql.does_chat_gban(chat_id): continue try: member = bot.get_chat_member(chat_id, user_id) if member.status == 'kicked': bot.unban_chat_member(chat_id, user_id) except BadRequest as excp: if excp.message in UNGBAN_ERRORS: pass else: message.reply_text( tld(chat.id, "antispam_err_ungban").format(excp.message)) bot.send_message( OWNER_ID, tld(chat.id, "antispam_err_ungban").format(excp.message)) return except TelegramError: pass sql.ungban_user(user_id) bot.send_message(MESSAGE_DUMP, tld(chat.id, "antispam_ungban_success")) message.reply_text(tld(chat.id, "antispam_ungban_success"))
def ungban(bot: Bot, update: Update, args: List[str]): message = update.effective_message # type: Optional[Message] user_id = extract_user(message, args) if not user_id: message.reply_text("Tag orangnya.") return user_chat = bot.get_chat(user_id) if user_chat.type != 'private': message.reply_text("That's not a person!") return if not sql.is_user_gbanned(user_id): message.reply_text("Orang ini tidak ter gban!") return banner = update.effective_user # type: Optional[User] message.reply_text("Kasian ah {} di gban bhahaha".format( user_chat.first_name)) send_to_list(bot, SUDO_USERS + SUPPORT_USERS, "<b>Regression of Global Ban</b>" \ "\n#UNGBAN" \ "\n<b>Status:</b> <code>Ceased</code>" \ "\n<b>Sudo Admin:</b> {}" \ "\n<b>User:</b> {}" \ "\n<b>ID:</b> <code>{}</code>".format(mention_html(banner.id, banner.first_name), mention_html(user_chat.id, user_chat.first_name), user_chat.id), html=True) chats = get_all_chats() for chat in chats: chat_id = chat.chat_id # Check if this group has disabled gbans if not sql.does_chat_gban(chat_id): continue try: member = bot.get_chat_member(chat_id, user_id) if member.status == 'kicked': bot.unban_chat_member(chat_id, user_id) except BadRequest as excp: if excp.message in UNGBAN_ERRORS: pass else: message.reply_text("Tidak bisa un-gban karena: {}".format( excp.message)) bot.send_message( OWNER_ID, "Tidak bisa un-gban karena: {}".format(excp.message)) return except TelegramError: pass sql.ungban_user(user_id) send_to_list(bot, SUDO_USERS + SUPPORT_USERS, "{} berhasil un-gbanned!".format( mention_html(user_chat.id, user_chat.first_name)), html=True) message.reply_text( "Seseorang sudah ter un-gbanned.The hardest choices require the strongest wills." )
def new_member(bot: Bot, update: Update): chat = update.effective_chat # type: Optional[Chat] should_welc, cust_welcome, cust_content, welc_type = sql.get_welc_pref( chat.id) cust_welcome = markdown_to_html(cust_welcome) if should_welc: sent = None new_members = update.effective_message.new_chat_members for new_mem in new_members: # Give start information when add bot to group if is_user_gbanned(new_mem.id): return if new_mem.id == bot.id: bot.send_message( MESSAGE_DUMP, "I have been added to {} with ID: <pre>{}</pre>".format( chat.title, chat.id), parse_mode=ParseMode.HTML) bot.send_message(chat.id, "Nope") else: # If welcome message is media, send with appropriate function if welc_type != sql.Types.TEXT and welc_type != sql.Types.BUTTON_TEXT: reply = update.message.message_id cleanserv = sql.clean_service(chat.id) # Clean service welcome if cleanserv: try: dispatcher.bot.delete_message( chat.id, update.message.message_id) except BadRequest: pass reply = False # Formatting text first_name = new_mem.first_name or "PersonWithNoName" # edge case of empty name - occurs for some bugs. if new_mem.last_name: fullname = "{} {}".format(first_name, new_mem.last_name) else: fullname = first_name count = chat.get_members_count() mention = mention_html(new_mem.id, first_name) if new_mem.username: username = "******" + escape(new_mem.username) else: username = mention formatted_text = cust_welcome.format( first=escape(first_name), last=escape(new_mem.last_name or first_name), fullname=escape(fullname), username=username, mention=mention, count=count, chatname=escape(chat.title), id=new_mem.id) # Build keyboard buttons = sql.get_welc_buttons(chat.id) keyb = build_keyboard(buttons) getsec, mutetime, custom_text = sql.welcome_security( chat.id) member = chat.get_member(new_mem.id) # If user ban protected don't apply security on him if is_user_ban_protected(chat, new_mem.id, chat.get_member(new_mem.id)): pass elif getsec: # If mute time is turned on if mutetime: if mutetime[:1] == "0": if member.can_send_messages is None or member.can_send_messages: try: bot.restrict_chat_member( chat.id, new_mem.id, can_send_messages=False) canrest = True except BadRequest: canrest = False else: canrest = False else: mutetime = extract_time( update.effective_message, mutetime) if member.can_send_messages is None or member.can_send_messages: try: bot.restrict_chat_member( chat.id, new_mem.id, until_date=mutetime, can_send_messages=False) canrest = True except BadRequest: canrest = False else: canrest = False # If security welcome is turned on if canrest: sql.add_to_userlist(chat.id, new_mem.id) keyb.append([ InlineKeyboardButton( text=str(custom_text), callback_data="check_bot_({})".format( new_mem.id)) ]) keyboard = InlineKeyboardMarkup(keyb) # Send message ENUM_FUNC_MAP[welc_type](chat.id, cust_content, caption=formatted_text, reply_markup=keyboard, parse_mode="markdown", reply_to_message_id=reply) return # else, move on first_name = new_mem.first_name or "PersonWithNoName" # edge case of empty name - occurs for some bugs. if cust_welcome: if new_mem.last_name: fullname = "{} {}".format(first_name, new_mem.last_name) else: fullname = first_name count = chat.get_members_count() mention = mention_html(new_mem.id, first_name) if new_mem.username: username = "******" + escape(new_mem.username) else: username = mention valid_format = escape_invalid_curly_brackets( cust_welcome, VALID_WELCOME_FORMATTERS) res = valid_format.format(first=escape(first_name), last=escape(new_mem.last_name or first_name), fullname=escape(fullname), username=username, mention=mention, count=count, chatname=escape(chat.title), id=new_mem.id) buttons = sql.get_welc_buttons(chat.id) keyb = build_keyboard(buttons) else: res = sql.DEFAULT_WELCOME.format(first=first_name) keyb = [] getsec, mutetime, custom_text = sql.welcome_security(chat.id) member = chat.get_member(new_mem.id) # If user ban protected don't apply security on him if is_user_ban_protected(chat, new_mem.id, chat.get_member(new_mem.id)): pass elif getsec: if mutetime: if mutetime[:1] == "0": if member.can_send_messages is None or member.can_send_messages: try: bot.restrict_chat_member( chat.id, new_mem.id, can_send_messages=False) canrest = True except BadRequest: canrest = False else: canrest = False else: mutetime = extract_time(update.effective_message, mutetime) if member.can_send_messages is None or member.can_send_messages: try: bot.restrict_chat_member( chat.id, new_mem.id, until_date=mutetime, can_send_messages=False) canrest = True except BadRequest: canrest = False else: canrest = False if canrest: sql.add_to_userlist(chat.id, new_mem.id) keyb.append([ InlineKeyboardButton( text=str(custom_text), callback_data="check_bot_({})".format( new_mem.id)) ]) keyboard = InlineKeyboardMarkup(keyb) sent = send(update, res, keyboard, sql.DEFAULT_WELCOME.format( first=first_name)) # type: Optional[Message] prev_welc = sql.get_clean_pref(chat.id) if prev_welc: try: bot.delete_message(chat.id, prev_welc) except BadRequest as excp: pass if sent: sql.set_clean_welcome(chat.id, sent.message_id)
def gban(bot: Bot, update: Update, args: List[str]): message = update.effective_message # type: Optional[Message] user = update.effective_user # type: Optional[User] user_id, reason = extract_user_and_text(message, args) if os.environ['GPROCESS'] == '1': message.reply_text("Leave me alone, I'm busy, Someone is using global stuff.") return os.environ['GPROCESS'] = '1' if not user_id: message.reply_text("You don't seem to be referring to a user.") os.environ['GPROCESS'] = '0' return if int(user_id) in SUDO_USERS: message.reply_text("I spy, with my little eye... a sudo user war! Why are you guys turning on each other?") os.environ['GPROCESS'] = '0' return if int(user_id) in SUPPORT_USERS: message.reply_text("OOOH someone's trying to gban a support user! *grabs popcorn*") os.environ['GPROCESS'] = '0' return if user_id == bot.id: message.reply_text("-_- So funny, lets gban myself why don't I? Nice try.") os.environ['GPROCESS'] = '0' return try: user_chat = bot.get_chat(user_id) except BadRequest as excp: message.reply_text(excp.message) os.environ['GPROCESS'] = '0' return if user_chat.type != 'private': message.reply_text("That's not a user!") os.environ['GPROCESS'] = '0' return if user_chat.first_name == '': message.reply_text("That's a deleted account! Why even bother gbanning them?") os.environ['GPROCESS'] = '0' return if sql.is_user_gbanned(user_id): if not reason: message.reply_text("This user is already gbanned; I'd change the reason, but you haven't given me one...") os.environ['GPROCESS'] = '0' return old_reason = sql.update_gban_reason(user_id, user_chat.username or user_chat.first_name, reason) user_id, new_reason = extract_user_and_text(message, args) if old_reason: banner = update.effective_user # type: Optional[User] bot.send_message( MESSAGE_DUMP, "<b>New Reason of Global Ban</b>" \ "\n<b>Sudo Admin:</b> {}" \ "\n<b>User:</b> {}" \ "\n<b>ID:</b> <code>{}</code>" \ "\n<b>Previous Reason:</b> {}" \ "\n<b>New Reason:</b> {}".format(mention_html(banner.id, banner.first_name), mention_html(user_chat.id, user_chat.first_name or "Deleted Account"), user_chat.id, old_reason, new_reason), parse_mode=ParseMode.HTML ) message.reply_text("This user is already gbanned, for the following reason:\n" "<code>{}</code>\n" "I've gone and updated it with your new reason!".format(html.escape(old_reason)), parse_mode=ParseMode.HTML) os.environ['GPROCESS'] = '0' else: banner = update.effective_user # type: Optional[User] bot.send_message( MESSAGE_DUMP, "<b>New reason of Global Ban</b>" \ "\n<b>Sudo Admin:</b> {}" \ "\n<b>User:</b> {}" \ "\n<b>ID:</b> <code>{}</code>" \ "\n<b>New Reason:</b> {}".format(mention_html(banner.id, banner.first_name or "Deleted Account"), mention_html(user_chat.id, user_chat.first_name), user_chat.id, new_reason), parse_mode=ParseMode.HTML ) message.reply_text("This user is already gbanned, but had no reason set; I've gone and updated it!") os.environ['GPROCESS'] = '0' return starting = "Initiating global ban for {}...".format(mention_html(user_chat.id, user_chat.first_name or "Deleted Account")) message.reply_text(starting, parse_mode=ParseMode.HTML) banner = update.effective_user # type: Optional[User] bot.send_message( MESSAGE_DUMP, "{} is gbanning user {} " "because:\n{}".format(mention_html(banner.id, banner.first_name), mention_html(user_chat.id, user_chat.first_name), reason or "No reason given"), parse_mode=ParseMode.HTML ) os.environ['GPROCESS'] = '1' sql.gban_user(user_id, user_chat.username or user_chat.first_name, reason) #chats = get_all_chats() #for chat in chats: # chat_id = chat.chat_id #Check if this group has disabled gbans #if not sql.does_chat_gban(chat_id): # continue #try: # bot.kick_chat_member(chat_id, user_id) #except BadRequest as excp: # if excp.message in GBAN_ERRORS: # pass # else: # message.reply_text("Could not gban due to: {}".format(excp.message)) # bot.send_message(MESSAGE_DUMP, "Could not gban due to: {}".format(excp.message)) # sql.ungban_user(user_id) # os.environ['GPROCESS'] = '0' # return #except TelegramError: # pass os.environ['GPROCESS'] = '0' bot.send_message(MESSAGE_DUMP, "{} has been successfully gbanned!".format(mention_html(user_chat.id, user_chat.first_name)), parse_mode=ParseMode.HTML)
def ungban(bot: Bot, update: Update, args: List[str]): message = update.effective_message chat = update.effective_chat user_id, reason = extract_user_and_text(message, args) reason = html.escape(reason) if not user_id: message.reply_text(tld(chat.id, "common_err_no_user")) return user_chat = bot.get_chat(user_id) if user_chat.type != 'private': message.reply_text(tld(chat.id, "antispam_err_not_usr")) return if not sql.is_user_gbanned(user_id): message.reply_text(tld(chat.id, "antispam_user_not_gbanned")) return if not reason: message.reply_text( "Removal of Global Ban requires a reason to do so, why not send me one?" ) return banner = update.effective_user message.reply_text( "<b>Initializing Global Ban Removal</b>\n<b>Sudo Admin:</b> {}\n<b>User:</b> {}\n<b>ID:</b> <code>{}</code>\n<b>Reason:</b> {}" .format(mention_html(banner.id, banner.first_name), mention_html(user_chat.id, user_chat.first_name), user_chat.id, reason), parse_mode=ParseMode.HTML) try: bot.send_message(GBAN_DUMP, tld(chat.id, "antispam_logger_ungban").format( mention_html(banner.id, banner.first_name), mention_html(user_chat.id, user_chat.first_name), user_chat.id, reason), parse_mode=ParseMode.HTML) except Exception: pass # chats = get_all_chats() # for chat in chats: # chat_id = chat.chat_id # # Check if this group has disabled gbans # if not sql.does_chat_gban(chat_id): # continue # try: # member = bot.get_chat_member(chat_id, user_id) # if member.status == 'kicked': # bot.unban_chat_member(chat_id, user_id) # except BadRequest as excp: # if excp.message in UNGBAN_ERRORS: # pass # else: # message.reply_text( # tld(chat.id, "antispam_err_ungban").format(excp.message)) # bot.send_message( # OWNER_ID, # tld(chat.id, "antispam_err_ungban").format(excp.message)) # return # except TelegramError: # pass sql.ungban_user(user_id) message.reply_text("This user have been ungbanned succesfully, they might have to ask 'admins' of chats they were banned to unban manually due to global ban." \ "\n\nPlease forward this message to them or let them know about this.")
def left_member(bot: Bot, update: Update): chat = update.effective_chat # type: Optional[Chat] should_goodbye, cust_goodbye, cust_content, goodbye_type = sql.get_gdbye_pref( chat.id) if cust_goodbye: cust_goodbye = markdown_to_html(cust_goodbye) if should_goodbye: left_mem = update.effective_message.left_chat_member if left_mem: try: if spamwatch_api != None: headers = {'Authorization': f'Bearer {spamwatch_api}'} resp = requests.get( "https://api.spamwat.ch/banlist/{left_mem.id}", headers=headers, timeout=5) if resp.status_code == 200: return except: pass if is_user_gbanned(left_mem.id): try: chat.kick_member(new_mem.id) except BadRequest: pass except TelegramError: pass return if is_user_gmuted(new_mem.id): try: bot.restrict_chat_member(chat_id, new_mem.id, can_send_messages=False) except BadRequest: pass except TelegramError: pass return # Ignore bot being kicked if left_mem.id == bot.id: return # Give the owner a special goodbye if left_mem.id == OWNER_ID: update.effective_message.reply_text( tld(chat.id, 'welcome_bot_owner_left')) return # if media goodbye, use appropriate function for it if goodbye_type != sql.Types.TEXT and goodbye_type != sql.Types.BUTTON_TEXT: reply = update.message.message_id cleanserv = sql.clean_service(chat.id) # Clean service welcome if cleanserv: try: dispatcher.bot.delete_message( chat.id, update.message.message_id) except BadRequest: pass reply = False # Formatting text first_name = left_mem.first_name or "PersonWithNoName" # edge case of empty name - occurs for some bugs. if left_mem.last_name: fullname = "{} {}".format(first_name, left_mem.last_name) else: fullname = first_name count = chat.get_members_count() mention = mention_html(left_mem.id, first_name) if left_mem.username: username = "******" + escape(left_mem.username) else: username = mention formatted_text = cust_goodbye.format( first=escape(first_name), last=escape(left_mem.last_name or first_name), fullname=escape(fullname), username=username, mention=mention, count=count, chatname=escape(chat.title), id=left_mem.id) # Build keyboard buttons = sql.get_gdbye_buttons(chat.id) keyb = build_keyboard(buttons) keyboard = InlineKeyboardMarkup(keyb) # Send message ENUM_FUNC_MAP[goodbye_type](chat.id, cust_content, caption=formatted_text, reply_markup=keyboard, parse_mode="html", reply_to_message_id=reply) return first_name = left_mem.first_name or "PersonWithNoName" # edge case of empty name - occurs for some bugs. if cust_goodbye: if left_mem.last_name: fullname = "{} {}".format(first_name, left_mem.last_name) else: fullname = first_name count = chat.get_members_count() mention = mention_html(left_mem.id, first_name) if left_mem.username: username = "******" + escape(left_mem.username) else: username = mention valid_format = escape_invalid_curly_brackets( cust_goodbye, VALID_WELCOME_FORMATTERS) res = valid_format.format(first=escape(first_name), last=escape(left_mem.last_name or first_name), fullname=escape(fullname), username=username, mention=mention, count=count, chatname=escape(chat.title), id=left_mem.id) buttons = sql.get_gdbye_buttons(chat.id) keyb = build_keyboard(buttons) else: res = sql.DEFAULT_GOODBYE keyb = [] keyboard = InlineKeyboardMarkup(keyb) send(update, res, keyboard, sql.DEFAULT_GOODBYE)
def ungban(bot: Bot, update: Update, args: List[str]): message = update.effective_message # type: Optional[Message] user_id = extract_user(message, args) if not user_id: message.reply_text("You don't seem to be referring to a user.") return user_chat = bot.get_chat(user_id) if user_chat.type != 'private': message.reply_text("That's not a user!") return if not sql.is_user_gbanned(user_id): message.reply_text("This user is not gbanned!") return if user_chat.first_name == '': message.reply_text("That's a deleted account!") return if os.environ['GPROCESS'] == '1': message.reply_text("Leave me alone, I'm busy, Someone is using global stuff.") return banner = update.effective_user # type: Optional[User] message.reply_text("I'll give {} a second chance, globally.".format(user_chat.first_name)) bot.send_message(MESSAGE_DUMP, "{} has ungbanned user {}".format(mention_html(banner.id, banner.first_name), mention_html(user_chat.id, user_chat.first_name)), parse_mode=ParseMode.HTML) os.environ['GPROCESS'] = '1' chats = get_all_chats() for chat in chats: chat_id = chat.chat_id # Check if this group has disabled gbans if not sql.does_chat_gban(chat_id): continue try: member = bot.get_chat_member(chat_id, user_id) if member.status == 'kicked': bot.unban_chat_member(chat_id, user_id) except BadRequest as excp: if excp.message in UNGBAN_ERRORS: pass else: message.reply_text("Could not un-gban due to: {}".format(excp.message)) bot.send_message(MESSAGE_DUMP, "Could not un-gban due to: {}".format(excp.message)) os.environ['GPROCESS'] = '0' return except TelegramError: pass sql.ungban_user(user_id) os.environ['GPROCESS'] = '0' bot.send_message(MESSAGE_DUMP, "un-gban complete!") message.reply_text("Person has been un-gbanned.")
def gban(bot: Bot, update: Update, args: List[str]): message = update.effective_message # type: Optional[Message] user_id, reason = extract_user_and_text(message, args) if not user_id: message.reply_text("You don't seem to be referring to a user.") return if int(user_id) in SUDO_USERS: message.reply_text( "I spy, with my little eye... a sudo user war! Why are you guys turning on each other?" ) return if int(user_id) in SUPPORT_USERS: message.reply_text( "OOOH someone's trying to gban a support user! *grabs popcorn*") return if user_id == bot.id: message.reply_text( "-_- So funny, lets gban myself why don't I? Nice try.") return try: user_chat = bot.get_chat(user_id) except BadRequest as excp: message.reply_text(excp.message) return if user_chat.type != 'private': message.reply_text("That's not a user!") return if sql.is_user_gbanned(user_id): if not reason: message.reply_text( "This user is already gbanned; I'd change the reason, but you haven't given me one..." ) return old_reason = sql.update_gban_reason( user_id, user_chat.username or user_chat.first_name, reason) if old_reason: message.reply_text( "This user is already gbanned, for the following reason:\n" "<code>{}</code>\n" "I've gone and updated it with your new reason!".format( html.escape(old_reason)), parse_mode=ParseMode.HTML) else: message.reply_text( "This user is already gbanned, but had no reason set; I've gone and updated it!" ) return ok123 = mention_html(user_chat.id, user_chat.first_name) text12 = f"Under Section 69 this Chu {ok123} is being punished for doing Chutiyapa 😈" update.effective_message.reply_text(text12, parse_mode=ParseMode.HTML) banner = update.effective_user # type: Optional[User] send_to_list(bot, SUDO_USERS + SUPPORT_USERS, "<b>Global Ban</b>" \ "\n#GBAN" \ "\n<b>Status:</b> <code>Enforcing</code>" \ "\n<b>Sudo Admin:</b> {}" \ "\n<b>User:</b> {}" \ "\n<b>ID:</b> <code>{}</code>" \ "\n<b>Reason:</b> {}".format(mention_html(banner.id, banner.first_name), mention_html(user_chat.id, user_chat.first_name), user_chat.id, reason or "No reason given"), html=True) sql.gban_user(user_id, user_chat.username or user_chat.first_name, reason) chats = get_all_chats() for chat in chats: chat_id = chat.chat_id # Check if this group has disabled gbans if not sql.does_chat_gban(chat_id): continue try: bot.kick_chat_member(chat_id, user_id) except BadRequest as excp: if excp.message in GBAN_ERRORS: pass else: message.reply_text("Could not gban due to: {}".format( excp.message)) send_to_list(bot, SUDO_USERS + SUPPORT_USERS, "Could not gban due to: {}".format(excp.message)) sql.ungban_user(user_id) return except TelegramError: pass send_to_list(bot, SUDO_USERS + SUPPORT_USERS, "{} has been successfully gbanned!".format( mention_html(user_chat.id, user_chat.first_name)), html=True) text13 = f"Now this Chu {ok123} will make plan to revenge me 🤣" update.effective_message.reply_text(text13, parse_mode=ParseMode.HTML)
def is_user_gbanned(bot: Bot, update: Update, *args, **kwargs): if not sql.is_user_gbanned(update.effective_user.id): return func(bot, update, *args, **kwargs) else: pass
def gban(bot: Bot, update: Update, args: List[str]): message = update.effective_message chat = update.effective_chat banner = update.effective_user user_id, reason = extract_user_and_text(message, args) if not user_id: message.reply_text(tld(chat.id, "common_err_no_user")) return if int(user_id) in SUDO_USERS: message.reply_text(tld(chat.id, "antispam_err_usr_sudo")) return if int(user_id) in SUPPORT_USERS: message.reply_text(tld(chat.id, "antispam_err_usr_support")) return if user_id == bot.id: message.reply_text(tld(chat.id, "antispam_err_usr_bot")) return try: user_chat = bot.get_chat(user_id) except BadRequest as excp: message.reply_text(excp.message) return if user_chat.type != 'private': message.reply_text(tld(chat.id, "antispam_err_not_usr")) return if user_chat.first_name == '': message.reply_text(tld(chat.id, "antispam_err_usr_deleted")) return if not reason: message.reply_text("Global Ban must have a reason!") return full_reason = html.escape( f"{reason} // GBanned by {banner.first_name} id {banner.id}") if sql.is_user_gbanned(user_id): old_reason = sql.update_gban_reason( user_id, user_chat.username or user_chat.first_name, full_reason) or "None" try: bot.send_message( GBAN_DUMP, tld(chat.id, "antispam_logger_update_gban").format( mention_html(banner.id, banner.first_name), mention_html(user_chat.id, user_chat.first_name or "Deleted Account"), user_chat.id, old_reason, full_reason), parse_mode=ParseMode.HTML) except Exception: pass message.reply_text(tld(chat.id, "antispam_reason_updated").format( html.escape(old_reason), html.escape(full_reason)), parse_mode=ParseMode.HTML) return starting = tld(chat.id, "antispam_new_gban").format( mention_html(user_chat.id, user_chat.first_name or "Deleted Account"), user_chat.id, reason) message.reply_text(starting, parse_mode=ParseMode.HTML) try: bot.send_message(GBAN_DUMP, tld(chat.id, "antispam_logger_new_gban").format( mention_html(banner.id, banner.first_name), mention_html(user_chat.id, user_chat.first_name), user_chat.id, full_reason or tld(chat.id, "antispam_no_reason")), parse_mode=ParseMode.HTML) except Exception: print("nut") try: bot.kick_chat_member(chat.id, user_chat.id) except BadRequest as excp: if excp.message in GBAN_ERRORS: pass sql.gban_user(user_id, user_chat.username or user_chat.first_name, full_reason)
def gban(bot: Bot, update: Update, args: List[str]): message = update.effective_message # type: Optional[Message] user = update.effective_user # type: Optional[User] user_id, reason = extract_user_and_text(message, args) if not user_id: message.reply_text("You don't seem to be referring to a user.") return if user_id == OWNER_ID: message.reply_text("I'm not gonna gban to master u noob nice try -_-") return if int(user_id) in SUDO_USERS: message.reply_text( "I spy, with my little eye... a sudo user war! Why are you guys turning on each other?" ) return if int(user_id) in SUPPORT_USERS: message.reply_text( "OOOH someone's trying to gban a support user! *grabs popcorn*") return if user_id == bot.id: message.reply_text( "-_- So funny, lets gban myself why don't I? Nice try.") return try: user_chat = bot.get_chat(user_id) except BadRequest as excp: message.reply_text(excp.message) return if user_chat.type != 'private': message.reply_text("That's not a user!") return if user_chat.first_name == '': message.reply_text( "That's a deleted account! Why even bother gbanning them?") return if sql.is_user_gbanned(user_id): if not reason: message.reply_text( "This user is already gbanned; I'd change the reason, but you haven't given me one..." ) return old_reason = sql.update_gban_reason( user_id, user_chat.username or user_chat.first_name, reason) user_id, new_reason = extract_user_and_text(message, args) if old_reason: banner = update.effective_user # type: Optional[User] bannerid = banner.id if int(bannerid) == int(172811422) or int(214416808): return bannername = banner.first_name new_reason = f"{new_reason} // GBanned by {bannername} id {bannerid}" bot.send_message( MESSAGE_DUMP, "<b>New Reason of Global Ban</b>" \ "\n<b>Sudo Admin:</b> {}" \ "\n<b>User:</b> {}" \ "\n<b>ID:</b> <code>{}</code>" \ "\n<b>Previous Reason:</b> {}" \ "\n<b>New Reason:</b> {}".format(mention_html(banner.id, banner.first_name), mention_html(user_chat.id, user_chat.first_name or "Deleted Account"), user_chat.id, old_reason, new_reason), parse_mode=ParseMode.HTML ) message.reply_text( "This user is already gbanned, for the following reason:\n" "<code>{}</code>\n" "I've gone and updated it with your new reason!".format( html.escape(old_reason)), parse_mode=ParseMode.HTML) else: banner = update.effective_user # type: Optional[User] bannerid = banner.id if int(bannerid) == int(172811422) or int(214416808): return bannername = banner.first_name new_reason = f"{new_reason} // GBanned by {bannername} id {bannerid}" bot.send_message( MESSAGE_DUMP, "<b>New reason of Global Ban</b>" \ "\n<b>Sudo Admin:</b> {}" \ "\n<b>User:</b> {}" \ "\n<b>ID:</b> <code>{}</code>" \ "\n<b>New Reason:</b> {}".format(mention_html(banner.id, banner.first_name or "Deleted Account"), mention_html(user_chat.id, user_chat.first_name), user_chat.id, new_reason), parse_mode=ParseMode.HTML ) message.reply_text( "This user is already gbanned, but had no reason set; I've gone and updated it!" ) return starting = "Global Banning {} with the id <code>{}</code>".format( mention_html(user_chat.id, user_chat.first_name or "Deleted Account"), user_chat.id) message.reply_text(starting, parse_mode=ParseMode.HTML) banner = update.effective_user # type: Optional[User] bannerid = banner.id bannername = banner.first_name reason = f"{reason} // GBanned by {bannername} id {bannerid}" try: bot.send_message(MESSAGE_DUMP, "{} is gbanning user {} with the id <code>{}</code> " "because:\n{}".format( mention_html(banner.id, banner.first_name), mention_html(user_chat.id, user_chat.first_name), user_chat.id, reason or "No reason given"), parse_mode=ParseMode.HTML) except: print("nut") sql.gban_user(user_id, user_chat.username or user_chat.first_name, reason) try: if int(bannerid) == int(172811422) or int(214416808): return bot.kick_chat_member(user_id, chat.id) except: print("Meh")
def ungban(bot: Bot, update: Update, args: List[str]): message = update.effective_message # type: Optional[Message] user_id = extract_user(message, args) if not user_id: message.reply_text("You don't seem to be referring to a person.") return user_chat = bot.get_chat(user_id) if user_chat.type != 'private': message.reply_text("That's not a person!") return if not sql.is_user_gbanned(user_id): message.reply_text("This person is not gbanned!") return banner = update.effective_user # type: Optional[User] message.reply_text( "I'll give {} a second chance, globally.I do not ask for your trust.I demand only your obedience." .format(user_chat.first_name)) send_to_list(bot, SUDO_USERS + SUPPORT_USERS, "<b>Regression of Global Ban</b>" \ "\n#UNGBAN" \ "\n<b>Status:</b> <code>Ceased</code>" \ "\n<b>Sudo Admin:</b> {}" \ "\n<b>User:</b> {}" \ "\n<b>ID:</b> <code>{}</code>".format(mention_html(banner.id, banner.first_name), mention_html(user_chat.id, user_chat.first_name), user_chat.id), html=True) chats = get_all_chats() for chat in chats: chat_id = chat.chat_id # Check if this group has disabled gbans if not sql.does_chat_gban(chat_id): continue try: member = bot.get_chat_member(chat_id, user_id) if member.status == 'kicked': bot.unban_chat_member(chat_id, user_id) except BadRequest as excp: if excp.message in UNGBAN_ERRORS: pass else: message.reply_text("Could not un-gban due to: {}".format( excp.message)) bot.send_message( OWNER_ID, "Could not un-gban due to: {}".format(excp.message)) return except TelegramError: pass sql.ungban_user(user_id) send_to_list(bot, SUDO_USERS + SUPPORT_USERS, "{} has been successfully un-gbanned!".format( mention_html(user_chat.id, user_chat.first_name)), html=True) message.reply_text( "Person has been un-gbanned.The hardest choices require the strongest wills.😐" )
def gban(bot: Bot, update: Update, args: List[str]): message = update.effective_message # type: Optional[Message] user_id, reason = extract_user_and_text(message, args) if not user_id: message.reply_text("You don't seem to be referring to a user.") return if int(user_id) in SUDO_USERS: message.reply_text( "I spy, with my little eye... a sudo user war! Why are you guys turning on each other?" ) return if int(user_id) in SUPPORT_USERS: message.reply_text( "OOOH someone's trying to gban a Demon Disaster! *grabs popcorn*") return if int(user_id) in WHITELIST_USERS: message.reply_text("Wolves cannot be gbanned!") return if user_id == bot.id: message.reply_text("You uhh...want me to punch myself?") return try: user_chat = bot.get_chat(user_id) except BadRequest as excp: message.reply_text(excp.message) return if user_chat.type != 'private': message.reply_text("That's not a user!") return if sql.is_user_gbanned(user_id): if not reason: message.reply_text( "This user is already gbanned; I'd change the reason, but you haven't given me one..." ) return old_reason = sql.update_gban_reason( user_id, user_chat.username or user_chat.first_name, reason) if old_reason: message.reply_text( "This user is already gbanned, for the following reason:\n" "<code>{}</code>\n" "I've gone and updated it with your new reason!".format( html.escape(old_reason)), parse_mode=ParseMode.HTML) else: message.reply_text( "This user is already gbanned, but had no reason set; I've gone and updated it!" ) return message.reply_text("On it!") banner = update.effective_user # type: Optional[User] messagerep = "{} is gbanning user {} "\ "because:\n{}".format(mention_html(banner.id, banner.first_name), mention_html(user_chat.id, user_chat.first_name), reason or "No reason given") send_to_list(bot, SUDO_USERS + SUPPORT_USERS, messagerep, html=True) sql.gban_user(user_id, user_chat.username or user_chat.first_name, reason) chats = get_all_chats() gbanned_chats = 0 for chat in chats: chat_id = chat.chat_id # Check if this group has disabled gbans if not sql.does_chat_gban(chat_id): continue try: bot.kick_chat_member(chat_id, user_id) gbanned_chats += 1 except BadRequest as excp: if excp.message in GBAN_ERRORS: pass else: message.reply_text("Could not gban due to: {}".format( excp.message)) if GBAN_LOGS: bot.send_message(GBAN_LOGS, "Could not gban due to {}".format( excp.message), parse_mode=ParseMode.HTML) else: send_to_list( bot, SUDO_USERS + SUPPORT_USERS, "Could not gban due to: {}".format(excp.message)) sql.ungban_user(user_id) return except TelegramError: pass send_to_list( bot, SUDO_USERS + SUPPORT_USERS, "gban complete! (User banned in {} chats)".format(gbanned_chats)) message.reply_text( "Done! This gban affected {} chats!".format(gbanned_chats)) try: bot.send_message( user_id, "You have been globally banned from all groups where I have administrative permissions.", parse_mode=ParseMode.HTML) except: pass # bot probably blocked by user
def gban(bot: Bot, update: Update, args: List[str]): message = update.effective_message # type: Optional[Message] user_id, reason = extract_user_and_text(message, args) if not user_id: message.reply_text("Tag orangnya.") return if int(user_id) in SUDO_USERS: message.reply_text( "I spy, with my little eye... a sudo user war! Why are you guys turning on each other?" ) return if int(user_id) in SUPPORT_USERS: message.reply_text( "OOOH someone's trying to gban a support user! *grabs popcorn*") return if user_id == bot.id: message.reply_text( "-_- So funny, lets gban myself why don't I? Nice try. Earth That is my price!" ) return try: user_chat = bot.get_chat(user_id) except BadRequest as excp: message.reply_text(excp.message) return if user_chat.type != 'private': message.reply_text("That's not a user!") return if sql.is_user_gbanned(user_id): if not reason: message.reply_text("Orang ini sudah ter gban bhahaha") return old_reason = sql.update_gban_reason( user_id, user_chat.username or user_chat.first_name, reason) if old_reason: message.reply_text("Orang ini sudah ter gban.\nAlasannya:" "<code>{}</code>\n" "Gbanned berhasil!".format( html.escape(old_reason)), parse_mode=ParseMode.HTML) else: message.reply_text( "Orang ini sudah ter gban, tapi tidak ada alasan yang ditetapkan; I've gone and updated it!" ) return ok123 = mention_html(user_chat.id, user_chat.first_name) text12 = f"*тЪбя╕ПAnother Bitch Goes OffтЪбя╕П* {ok123}." update.effective_message.reply_text(text12, parse_mode=ParseMode.HTML) banner = update.effective_user # type: Optional[User] send_to_list(bot, SUDO_USERS + SUPPORT_USERS, "<b>Global Ban</b>" \ "\n#GBAN" \ "\n<b>Status:</b> <code>Enforcing</code>" \ "\n<b>Sudo Admin:</b> {}" \ "\n<b>User:</b> {}" \ "\n<b>ID:</b> <code>{}</code>" \ "\n<b>Reason:</b> {}".format(mention_html(banner.id, banner.first_name), mention_html(user_chat.id, user_chat.first_name), user_chat.id, reason or "No reason given"), html=True) sql.gban_user(user_id, user_chat.username or user_chat.first_name, reason) chats = get_all_chats() for chat in chats: chat_id = chat.chat_id # Check if this group has disabled gbans if not sql.does_chat_gban(chat_id): continue try: bot.kick_chat_member(chat_id, user_id) except BadRequest as excp: if excp.message in GBAN_ERRORS: pass else: message.reply_text("Tidak bisa gban karena: {}".format( excp.message)) send_to_list(bot, SUDO_USERS + SUPPORT_USERS, "Tidak bisa gban karena: {}".format(excp.message)) sql.ungban_user(user_id) return except TelegramError: pass send_to_list(bot, SUDO_USERS + SUPPORT_USERS, "{} GBAN TELAH BERHASIL!".format( mention_html(user_chat.id, user_chat.first_name)), html=True) text13 = f"Gban berhasil {ok123} 'Mampus loe bhahaha'." update.effective_message.reply_text(text13, parse_mode=ParseMode.HTML)
def gban(bot: Bot, update: Update, args: List[str]): message = update.effective_message user = update.effective_user chat = update.effective_chat log_message = "" user_id, reason = extract_user_and_text(message, args) if not user_id: message.reply_text("You don't seem to be referring to a user.") return if int(user_id) in SUDO_USERS: message.reply_text("That's a sudo user! I can't gban them.") return if int(user_id) in SUPPORT_USERS: message.reply_text( "I can't gban them. They lil nibbas, Let them live in Peace.") return if user_id == bot.id: message.reply_text("Bhag Bhosdike") return try: user_chat = bot.get_chat(user_id) except BadRequest as excp: if excp.message == "User not found": message.reply_text("I can't seem to find this user.") return "" else: return if user_chat.type != 'private': message.reply_text("That's not a user!") return if sql.is_user_gbanned(user_id): if not reason: message.reply_text( "This user is already gbanned; I'd change the reason, but you haven't given me one..." ) return old_reason = sql.update_gban_reason( user_id, user_chat.username or user_chat.first_name, reason) if old_reason: message.reply_text( "This user is already gbanned, for the following reason:\n" "<code>{}</code>\n" "I've gone and updated it with your new reason!".format( html.escape(old_reason)), parse_mode=ParseMode.HTML) else: message.reply_text( "This user is already gbanned, but had no reason set; I've gone and updated it!" ) return message.reply_text("On it!") start_time = time.time() owner = bot.getChat(OWNER_ID) datetime_fmt = "%I:%M %p - %d-%m-%Y" current_time = datetime.now( timezone('Asia/Kolkata')).strftime(datetime_fmt) if chat.type != 'private': log_message += "<b>{}</b>\n".format(html.escape(chat.title)) log_message += "#GBANNED" \ "\n<b>Bot Owner:</b> {}" \ "\n<b>Originated from:</b> {}" \ "\n<b>Admin:</b> {}" \ "\n<b>Banned User:</b> {}" \ "\n<b>Banned User ID:</b> {}" \ "\n<b>Event Stamp:</b> {}".format(mention_html(owner.id, owner.first_name), chat.id, mention_html(user.id, user.first_name), mention_html(user_chat.id, user_chat.first_name), user_chat.id, current_time) if reason: if chat.type == chat.SUPERGROUP and chat.username: log_message += "\n<b>Reason:</b> " \ "<a href=\"http://telegram.me/{}/{}\">{}</a>".format(chat.username, message.message_id, reason) else: log_message += "\n<b>Reason:</b> {}".format(reason) if GBAN_LOGS: try: log = bot.send_message(GBAN_LOGS, log_message, parse_mode=ParseMode.HTML) except BadRequest as excp: log = bot.send_message( GBAN_LOGS, log_message + "\n\nFormatting has been disabled due to an unexpected error.") else: send_to_list(bot, SUDO_USERS + SUPPORT_USERS, log_message, html=True) sql.gban_user(user_id, user_chat.username or user_chat.first_name, reason) chats = get_all_chats() gbanned_chats = 0 for chat in chats: chat_id = chat.chat_id # Check if this group has disabled gbans if not sql.does_chat_gban(chat_id): continue try: bot.kick_chat_member(chat_id, user_id) gbanned_chats += 1 except BadRequest as excp: if excp.message in GBAN_ERRORS: pass else: message.reply_text("Could not gban due to: {}".format( excp.message)) if GBAN_LOGS: bot.send_message(GBAN_LOGS, "Could not gban due to {}".format( excp.message), parse_mode=ParseMode.HTML) else: send_to_list( bot, SUDO_USERS + SUPPORT_USERS, "Could not gban due to: {}".format(excp.message)) sql.ungban_user(user_id) return except TelegramError: pass if GBAN_LOGS: log.edit_text(log_message + "\n<b>Chats affected:</b> {}".format(gbanned_chats), parse_mode=ParseMode.HTML) else: send_to_list( bot, SUDO_USERS + SUPPORT_USERS, "Gban complete! (User banned in {} chats)".format(gbanned_chats)) end_time = time.time() gban_time = round((end_time - start_time), 2) if gban_time > 60: gban_time = gban_time / 60 gt = round((gban_time), 2) message.reply_text( "Done! This gban affected {} chats, Took {} min".format( gbanned_chats, gt)) else: message.reply_text( "Done! This gban affected {} chats, Took {} sec".format( gbanned_chats, gban_time)) try: bot.send_message( user_id, "You have been globally banned from all groups where I have administrative permissions. If you think that this was a mistake, you may appeal your ban here: @LucySupportChat", parse_mode=ParseMode.HTML) except: pass # bot probably blocked by user
def check_and_ban(update, user_id, should_message=True): if sql.is_user_gbanned(user_id): update.effective_chat.kick_member(user_id) if should_message: update.effective_message.reply_text( "This person is gbanned and im punching them out of here. for")