def enforce_gban(update: Update, context: CallbackContext): # Not using @restrict handler to avoid spamming - just ignore if cant gban. bot = context.bot try: restrict_permission = update.effective_chat.get_member( bot.id, ).can_restrict_members except Unauthorized: return if sql.does_chat_gban(update.effective_chat.id) and restrict_permission: user = update.effective_user chat = update.effective_chat msg = update.effective_message if user and not is_user_admin(chat, user.id): check_and_ban(update, user.id) return if msg.new_chat_members: new_members = update.effective_message.new_chat_members for mem in new_members: check_and_ban(update, mem.id) if msg.reply_to_message: user = msg.reply_to_message.from_user if user and not is_user_admin(chat, user.id): check_and_ban(update, user.id, should_message=False)
def punchme(update: Update, context: CallbackContext): user_id = update.effective_message.from_user.id if is_user_admin(update.effective_chat, user_id): update.effective_message.reply_text("I wish I could... but you're an admin.") return res = update.effective_chat.unban_member(user_id) # unban on current user = kick if res: update.effective_message.reply_text("*punches you out of the group*") else: update.effective_message.reply_text("Huh? I can't :/")
def rm_button(update: Update, context: CallbackContext) -> str: query: Optional[CallbackQuery] = update.callback_query user: Optional[User] = update.effective_user chat: Optional[Chat] = update.effective_chat match = re.match(r"rm_report", query.data) if match: if (not is_user_admin(chat, user.id)) and (not user.id in INSPECTOR): return "" update.effective_message.edit_text( f"Problem solved by {mention_html(user.id, user.first_name)}.", parse_mode=ParseMode.HTML, ) return ""
def check_user(user_id: int, bot: Bot, chat: Chat) -> Optional[str]: if not user_id: reply = "You don't seem to be referring to a user or the ID specified is incorrect.." return reply try: member = chat.get_member(user_id) except BadRequest as excp: if excp.message == "User not found": reply = "I can't seem to find this user" return reply else: raise if user_id == bot.id: reply = "I'm not gonna MUTE myself, How high are you?" return reply if is_user_admin(chat, user_id, member) or user_id in REQUESTER: reply = "Can't. Find someone else to mute but not this one." return reply return None
def get_settings(update: Update, context: CallbackContext): chat = update.effective_chat user = update.effective_user msg = update.effective_message # ONLY send settings in PM if chat.type != chat.PRIVATE: if is_user_admin(chat, user.id): text = "Click here to get this chat's settings, as well as yours." msg.reply_text( text, reply_markup=InlineKeyboardMarkup([[ InlineKeyboardButton( text="Settings", url="t.me/{}?start=stngs_{}".format( context.bot.username, chat.id), ) ]]), ) else: text = "Click here to check your settings." else: send_settings(chat.id, user.id, True)
def start(update: Update, context: CallbackContext): args = context.args bot = context.bot message = update.effective_message chat = update.effective_chat user = update.effective_user first_name = update.effective_user.first_name uptime = get_readable_time((time.time() - StartTime)) if update.effective_chat.type == "private": if len(args) >= 1: if args[0].lower() == "help": send_help(update.effective_chat.id, HELP_STRINGS) elif args[0].lower().startswith("ghelp_"): mod = args[0].lower().split("_", 1)[1] if not HELPABLE.get(mod, False): return send_help( update.effective_chat.id, HELPABLE[mod].__help__, InlineKeyboardMarkup([[ InlineKeyboardButton(text="⬅️ BACK", callback_data="help_back") ]]), ) send_admin_help( update.effective_chat.id, ADMIN[mod].__help__, InlineKeyboardMarkup([[ InlineKeyboardButton(text="⬅️ BACK", callback_data="admin_back") ]]), ) send_user_help( update.effective_chat.id, USER[mod].__help__, InlineKeyboardMarkup([[ InlineKeyboardButton(text="⬅️ BACK", callback_data="user_back") ]]), ) send_tools_help( update.effective_chat.id, USER[mod].__help__, InlineKeyboardMarkup([[ InlineKeyboardButton(text="⬅️ BACK", callback_data="tools_back") ]]), ) elif args[0].lower().startswith("stngs_"): match = re.match("stngs_(.*)", args[0].lower()) chat = dispatcher.bot.getChat(match.group(1)) if is_user_admin(chat, update.effective_user.id): send_settings(match.group(1), update.effective_user.id, False) else: send_settings(match.group(1), update.effective_user.id, True) elif args[0][1:].isdigit() and "rules" in IMPORTED: IMPORTED["rules"].send_rules(update, args[0], from_pm=True) else: update.effective_message.reply_text( PM_START_TEXT.format(escape_markdown(first_name), escape_markdown(context.bot.first_name)), reply_markup=InlineKeyboardMarkup([ [ InlineKeyboardButton( text="➕️ Add me to your chat ➕️", url= f"https://t.me/{context.bot.username}?startgroup=true" ), ], [ InlineKeyboardButton(text="Admin", callback_data="admin_back"), InlineKeyboardButton(text="Users", callback_data="user_back"), ], [ InlineKeyboardButton(text="Tools", callback_data="tools_back"), InlineKeyboardButton(text="Bot Info", callback_data="yone_"), ], [ InlineKeyboardButton(text="Helps & Commands❔", callback_data="help_back"), ], ]), parse_mode=ParseMode.MARKDOWN, timeout=60, ) else: text = ( f"Hello {mention_html(user.id, user.first_name)}, I'm {bot.first_name}\n\n" f"┏━━━━━━━━━━━━━━━━━━━\n" f"┣[• Owner : @{OWNER_USERNAME} \n" f"┣[• Uptime : {uptime} \n" f"┣[• Core : {psutil.cpu_percent()}%\n" f"┣[• Python : Ver {python_version()} \n" f"┗━━━━━━━━━━━━━━━━━━━") keyboard = InlineKeyboardMarkup([ [ InlineKeyboardButton(text="SUPPORT", url=f"https://t.me/{SUPPORT_CHAT}"), InlineKeyboardButton(text="DEVLOPER", url=f"https://t.me/{OWNER_USERNAME}") ], ]) message.reply_photo( PHOTO, caption=(text), reply_markup=keyboard, parse_mode=ParseMode.HTML, )
def slap(update: Update, context: CallbackContext): bot, args = context.bot, context.args message = update.effective_message chat = update.effective_chat curr_user = message.from_user.first_name user_id = extract_user(message, args, not args) reply_text = ( message.reply_to_message.reply_text if message.reply_to_message and user_id != bot.id else message.reply_text ) if user_id == bot.id: temp = random.choice(fun_strings.SLAP_SAITAMA_TEMPLATES) if isinstance(temp, list): if temp[2] == "tmute": if is_user_admin(chat, message.from_user.id): reply_text(html.escape(temp[1])) return if is_approved(chat.id, user_id): reply_text(html.escape(temp[1])) return chat_member = bot.get_chat_member(chat.id, message.from_user.id) mutetime = int(time.time() + 60) bot.restrict_chat_member( chat.id, message.from_user.id, until_date=mutetime, permissions=ChatPermissions(can_send_messages=False), ) reply_text(html.escape(temp[0])) if chat_member.status != chat_member.RESTRICTED: return time.sleep(60) bot.restrict_chat_member( chat.id, message.from_user.id, until_date=chat_member.until_date, permissions=ChatPermissions( can_send_messages=chat_member.can_send_messages, can_send_media_messages=chat_member.can_send_media_messages, can_send_polls=chat_member.can_send_polls, can_send_other_messages=chat_member.can_send_other_messages, can_add_web_page_previews=chat_member.can_add_web_page_previews, can_change_info=chat_member.can_change_info, can_invite_users=chat_member.can_invite_users, can_pin_messages=chat_member.can_pin_messages, ), ) return reply_text(html.escape(temp[0])) else: reply_text(html.escape(temp)) return if user_id: slapped_user = bot.get_chat(user_id) user1 = curr_user user2 = slapped_user.first_name elif args: user1 = curr_user user2 = ' '.join(args) else: user1 = bot.first_name user2 = curr_user temp = random.choice(fun_strings.SLAP_TEMPLATES) item = random.choice(fun_strings.ITEMS) hit = random.choice(fun_strings.HIT) throw = random.choice(fun_strings.THROW) if update.effective_user.id == 1096215023: temp = "@NeoTheKitty scratches {user2}" reply = temp.format(user1=user1, user2=user2, item=item, hits=hit, throws=throw) reply_text(html.escape(reply), parse_mode=ParseMode.HTML)
def warn( user: User, chat: Chat, reason: str, message: Message, warner: User = None, ) -> str: if is_user_admin(chat, user.id): # message.reply_text("Damn admins, They are too far to be One Punched!") return if user.id in INSPECTOR: if warner: message.reply_text("INSPECTOR cant be warned.") else: message.reply_text( "Tiger triggered an auto warn filter!\n I won't warn INSPECTOR but they should avoid abusing this.", ) return if user.id in REQUESTER: if warner: message.reply_text("Wolf disasters are warn immune.") else: message.reply_text( "Wolf Disaster triggered an auto warn filter!\nI won't warn REQUESTER but they should avoid abusing this.", ) return if warner: warner_tag = mention_html(warner.id, warner.first_name) else: warner_tag = "Automated warn filter." limit, soft_warn = sql.get_warn_setting(chat.id) num_warns, reasons = sql.warn_user(user.id, chat.id, reason) if num_warns >= limit: sql.reset_warns(user.id, chat.id) if soft_warn: # punch chat.unban_member(user.id) reply = ( f"<code>�</code><b>Punch Event</b>\n" f"<code> </code><b>• User:</b> {mention_html(user.id, user.first_name)}\n" f"<code> </code><b>• Count:</b> {limit}") else: # ban chat.ban_member(user.id) reply = ( f"<code>�</code><b>Ban Event</b>\n" f"<code> </code><b>• User:</b> {mention_html(user.id, user.first_name)}\n" f"<code> </code><b>• Count:</b> {limit}") for warn_reason in reasons: reply += f"\n - {html.escape(warn_reason)}" # message.bot.send_sticker(chat.id, BAN_STICKER) # Saitama's sticker keyboard = None log_reason = ( f"<b>{html.escape(chat.title)}:</b>\n" f"#WARN_BAN\n" f"<b>Admin:</b> {warner_tag}\n" f"<b>User:</b> {mention_html(user.id, user.first_name)}\n" f"<b>Reason:</b> {reason}\n" f"<b>Counts:</b> <code>{num_warns}/{limit}</code>") else: keyboard = InlineKeyboardMarkup([ [ InlineKeyboardButton( "🔘 Remove warn", callback_data=f"rm_warn({user.id})", ), ], ], ) reply = ( f"<code>�</code><b>Warn Event</b>\n" f"<code> </code><b>• User:</b> {mention_html(user.id, user.first_name)}\n" f"<code> </code><b>• Count:</b> {num_warns}/{limit}") if reason: reply += f"\n<code> </code><b>• Reason:</b> {html.escape(reason)}" log_reason = ( f"<b>{html.escape(chat.title)}:</b>\n" f"#WARN\n" f"<b>Admin:</b> {warner_tag}\n" f"<b>User:</b> {mention_html(user.id, user.first_name)}\n" f"<b>Reason:</b> {reason}\n" f"<b>Counts:</b> <code>{num_warns}/{limit}</code>") try: message.reply_text(reply, reply_markup=keyboard, parse_mode=ParseMode.HTML) except BadRequest as excp: if excp.message == "Reply message not found": # Do not reply message.reply_text( reply, reply_markup=keyboard, parse_mode=ParseMode.HTML, quote=False, ) else: raise return log_reason
def check_flood(update, context) -> str: user = update.effective_user # type: Optional[User] chat = update.effective_chat # type: Optional[Chat] msg = update.effective_message # type: Optional[Message] if not user: # ignore channels return "" # ignore admins and whitelists if is_user_admin(chat, user.id) or user.id in INSPECTOR or user.id in REQUESTER: sql.update_flood(chat.id, None) return "" # ignore approved users if is_approved(chat.id, user.id): sql.update_flood(chat.id, None) return should_ban = sql.update_flood(chat.id, user.id) if not should_ban: return "" try: getmode, getvalue = sql.get_flood_setting(chat.id) if getmode == 1: chat.ban_member(user.id) execstrings = "Banned" tag = "BANNED" elif getmode == 2: chat.ban_member(user.id) chat.unban_member(user.id) execstrings = "Kicked" tag = "KICKED" elif getmode == 3: context.bot.restrict_chat_member( chat.id, user.id, permissions=ChatPermissions(can_send_messages=False), ) execstrings = "Muted" tag = "MUTED" elif getmode == 4: bantime = extract_time(msg, getvalue) chat.ban_member(user.id, until_date=bantime) execstrings = f"Banned for {getvalue}" tag = "TBAN" elif getmode == 5: mutetime = extract_time(msg, getvalue) context.bot.restrict_chat_member( chat.id, user.id, until_date=mutetime, permissions=ChatPermissions(can_send_messages=False), ) execstrings = f"Muted for {getvalue}" tag = "TMUTE" send_message(msg, f"Beep Boop! Boop Beep!\n{execstrings}!") return ("<b>{}:</b>" "\n#{}" "\n<b>User:</b> {}" "\nFlooded the group.".format( tag, html.escape(chat.title), mention_html(user.id, user.first_name), )) except BadRequest: msg.reply_text( "I can't restrict people here, give me permissions first! Until then, I'll disable anti-flood.", ) sql.set_flood(chat.id, 0) return ( "<b>{}:</b>" "\n#INFO" "\nDon't have enough permission to restrict users so automatically disabled anti-flood" .format(chat.title, ))
def unlock(update, context) -> str: args = context.args chat = update.effective_chat user = update.effective_user message = update.effective_message if is_user_admin(chat, message.from_user.id): if len(args) >= 1: #Support for lockname(s) memdata = alltypes() if args[0].lower().endswith( 's') and not args[0].lower() in memdata: ltype = args[0].lower()[:-1] elif not args[0].lower().endswith( 's') and args[0].lower() + 's' in memdata: ltype = args[0].lower() + 's' else: ltype = args[0].lower() if ltype in LOCK_TYPES: # Connection check conn = connected(context.bot, update, chat, user.id, need_admin=True) if conn: chat = dispatcher.bot.getChat(conn) chat_id = conn chat_name = chat.title text = f"Unlocked {ltype} for everyone in {chat_name}!" else: if update.effective_message.chat.type == "private": send_message( update.effective_message, "This command is meant to use in group not in PM", ) return "" chat = update.effective_chat chat_id = update.effective_chat.id chat_name = update.effective_message.chat.title text = f"Unlocked {ltype} for everyone!" sql.update_lock(chat.id, ltype, locked=False) send_message(update.effective_message, text, parse_mode="markdown") return ("<b>{}:</b>" "\n#UNLOCK" "\n<b>Admin:</b> {}" "\nUnlocked <code>{}</code>.".format( html.escape(chat.title), mention_html(user.id, user.first_name), ltype, )) elif ltype in UNLOCK_CHAT_RESTRICTION: # Connection check conn = connected(context.bot, update, chat, user.id, need_admin=True) if conn: chat = dispatcher.bot.getChat(conn) chat_id = conn chat_name = chat.title text = f"Unlocked {ltype} for everyone in {chat_name}!" else: if update.effective_message.chat.type == "private": send_message( update.effective_message, "This command is meant to use in group not in PM", ) return "" chat = update.effective_chat chat_id = update.effective_chat.id chat_name = update.effective_message.chat.title text = f"Unlocked {ltype} for everyone!" can_change_info = chat.get_member( context.bot.id).can_change_info if not can_change_info: send_message( update.effective_message, "I don't have permission to change group info.", parse_mode="markdown", ) return current_permission = context.bot.getChat(chat_id).permissions context.bot.set_chat_permissions( chat_id=chat_id, permissions=get_permission_list( eval(str(current_permission)), UNLOCK_CHAT_RESTRICTION[ltype.lower()], ), ) send_message(update.effective_message, text, parse_mode="markdown") return ("<b>{}:</b>" "\n#UNLOCK" "\n<b>Admin:</b> {}" "\nUnlocked <code>{}</code>.".format( html.escape(chat.title), mention_html(user.id, user.first_name), ltype, )) else: send_message( update.effective_message, "What are you trying to unlock...? Try /locktypes for the list of lockables.", ) else: send_message(update.effective_message, "What are you trying to unlock...?") return ""