def get_id(bot: Bot, update: Update, args: List[str]): user_id = extract_user(update.effective_message, args) chat = update.effective_chat # type: Optional[Chat] if user_id: if update.effective_message.reply_to_message and update.effective_message.reply_to_message.forward_from: user1 = update.effective_message.reply_to_message.from_user user2 = update.effective_message.reply_to_message.forward_from update.effective_message.reply_text(tld( chat.id, "The original sender, {}, has an ID of `{}`.\nThe forwarder, {}, has an ID of `{}`." ).format(escape_markdown(user2.first_name), user2.id, escape_markdown(user1.first_name), user1.id), parse_mode=ParseMode.MARKDOWN) else: user = bot.get_chat(user_id) update.effective_message.reply_text(tld( chat.id, "{}'s id is `{}`.").format(escape_markdown(user.first_name), user.id), parse_mode=ParseMode.MARKDOWN) else: chat = update.effective_chat # type: Optional[Chat] if chat.type == "private": update.effective_message.reply_text(tld( chat.id, "Your id is `{}`.").format(chat.id), parse_mode=ParseMode.MARKDOWN) else: update.effective_message.reply_text(tld( chat.id, "This group's id is `{}`.").format(chat.id), parse_mode=ParseMode.MARKDOWN)
def warns(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) or update.effective_user.id result = sql.get_warns(user_id, chat.id) if result and result[0] != 0: num_warns, reasons = result limit, soft_warn = sql.get_warn_setting(chat.id) if reasons: text = "This person has {}/{} warnings, for the following reasons:".format( num_warns, limit) for reason in reasons: text += "\n - {}".format(reason) msgs = split_message(text) for msg in msgs: update.effective_message.reply_text(msg) else: update.effective_message.reply_text( "Person has {}/{} warnings, but no reasons for any of them.". format(num_warns, limit)) else: update.effective_message.reply_text( "This person hasn't got any warnings!")
def promote(bot: Bot, update: Update, args: List[str]) -> str: message = update.effective_message # type: Optional[Message] user = update.effective_user # type: Optional[User] chat = update.effective_chat # type: Optional[Chat] conn = connected(bot, update, chat, user.id) if not conn == False: chatD = dispatcher.bot.getChat(conn) else: chatD = update.effective_chat if chat.type == "private": exit(1) if not chatD.get_member(bot.id).can_promote_members: update.effective_message.reply_text( "I can't promote/demote people here! " "Make sure I'm admin and can appoint new admins.") exit(1) user_id = extract_user(message, args) if not user_id: message.reply_text( tld(chat.id, "You don't seem to be referring to a user.")) return "" user_member = chatD.get_member(user_id) if user_member.status == 'administrator' or user_member.status == 'creator': message.reply_text( tld(chat.id, "How am I meant to promote someone that's already an admin?")) return "" if user_id == bot.id: message.reply_text( tld(chat.id, "I can't promote myself! Get an admin to do it for me.")) return "" # set same perms as bot - bot can't assign higher perms than itself! bot_member = chatD.get_member(bot.id) bot.promoteChatMember( chatD.id, user_id, can_change_info=bot_member.can_change_info, can_post_messages=bot_member.can_post_messages, can_edit_messages=bot_member.can_edit_messages, can_delete_messages=bot_member.can_delete_messages, #can_invite_users=bot_member.can_invite_users, can_restrict_members=bot_member.can_restrict_members, can_pin_messages=bot_member.can_pin_messages, can_promote_members=bot_member.can_promote_members) message.reply_text(tld(chat.id, f"Successfully promoted in *{chatD.title}*!"), parse_mode=ParseMode.MARKDOWN) return f"<b>{html.escape(chatD.title)}:</b>" \ "\n#PROMOTED" \ f"\n<b>Admin:</b> {mention_html(user.id, user.first_name)}" \ f"\n<b>User:</b> {mention_html(user_member.user.id, user_member.user.first_name)}"
def unmute(update, context): chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] message = update.effective_message # type: Optional[Message] args = context.args if user_can_ban(chat, user, context.bot.id) == False: message.reply_text("You don't have enough rights to unmute people") return "" user_id = extract_user(message, args) if not user_id: message.reply_text( "You'll need to either give me a username to unmute, or reply to someone to be unmuted." ) return "" member = chat.get_member(int(user_id)) if member.status != "kicked" and member.status != "left": if (member.can_send_messages and member.can_send_media_messages and member.can_send_other_messages and member.can_add_web_page_previews): message.reply_text("This user already has the right to speak.") else: context.bot.restrict_chat_member( chat.id, int(user_id), permissions=ChatPermissions( can_send_messages=True, can_invite_users=True, can_pin_messages=True, can_send_polls=True, can_change_info=True, can_send_media_messages=True, can_send_other_messages=True, can_add_web_page_previews=True, ), ) message.reply_text("Yep! this user can start talking again...") return ("<b>{}:</b>" "\n#UNMUTE" "\n<b>Admin:</b> {}" "\n<b>User:</b> {}".format( html.escape(chat.title), mention_html(user.id, user.first_name), mention_html(member.user.id, member.user.first_name), )) else: message.reply_text( "This user isn't even in the chat, unmuting them won't make them talk more than they " "already do!") return ""
def gkick(bot: Bot, update: Update, args: List[str]): message = update.effective_message user_id = extract_user(message, args) try: user_chat = bot.get_chat(user_id) except BadRequest as excp: if excp.message in GKICK_ERRORS: pass else: message.reply_text( "User cannot be Globally kicked because: {}".format( excp.message)) return except TelegramError: pass if not user_id: message.reply_text("You do not seems to be referring to a person") return if int(user_id) in SUDO_USERS or int(user_id) in SUPPORT_USERS: message.reply_text( "OHHH! Someone's trying to gkick a sudo/support user! *Grabs popcorn*" ) return if int(user_id) == OWNER_ID: message.reply_text( "Wow! Some's trying to gkick my owner! *Grabs Potato Chips*") return if user_id == bot.id: message.reply_text("Well, I'm not gonna gkick myself!") return if int(user_id) in SUDO_USERS: message.reply_text("") return chats = get_all_chats() message.reply_text("Globally kicking person @{}".format( user_chat.username)) for chat in chats: try: bot.unban_chat_member(chat.chat_id, user_id) # Unban_member = kick (and not ban) except BadRequest as excp: if excp.message in GKICK_ERRORS: pass else: message.reply_text( "Person cannot be Globally kicked because: {}".format( excp.message)) return except TelegramError: pass
def user_demote_fed(bot: Bot, update: Update, args: List[str]): chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] fed_id = sql.get_fed_id(chat.id) if is_user_fed_owner(fed_id, user.id) == False: update.effective_message.reply_text( tld(chat.id, "Only fed owner can do this!")) return msg = update.effective_message # type: Optional[Message] user_id = extract_user(msg, args) if user_id: user = bot.get_chat(user_id) elif not msg.reply_to_message and not args: user = msg.from_user elif not msg.reply_to_message and ( not args or (len(args) >= 1 and not args[0].startswith("@") and not args[0].isdigit() and not msg.parse_entities([MessageEntity.TEXT_MENTION]))): msg.reply_text(tld(chat.id, "I can't extract a user from this.")) return #else: # return if user_id == bot.id: update.effective_message.reply_text( tld( chat.id, "What are you trying to do? Demoting me from your federation?") ) return if sql.search_user_in_fed(fed_id, user_id) == False: update.effective_message.reply_text( tld( chat.id, "I can't demote user which is not a fed admin! If you wanna bring him to tears, promote him first!" )) return res = sql.user_demote_fed(fed_id, user_id) if res == True: update.effective_message.reply_text(tld(chat.id, "Get out of here!")) else: update.effective_message.reply_text( tld(chat.id, "I can not remove him, I am powerless!"))
def mute(update, context): chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] message = update.effective_message # type: Optional[Message] args = context.args if user_can_ban(chat, user, context.bot.id) == False: message.reply_text( "You don't have enough rights to restrict someone from talking!") return "" user_id = extract_user(message, args) if not user_id: message.reply_text( "You'll need to either give me a username to mute, or reply to someone to be muted." ) return "" if user_id == context.bot.id: message.reply_text("Yeahh... I'm not muting myself!") return "" member = chat.get_member(int(user_id)) if member: if is_user_admin(chat, user_id, member=member): message.reply_text( "Well i'm not gonna stop an admin from talking!") elif member.can_send_messages is None or member.can_send_messages: context.bot.restrict_chat_member( chat.id, user_id, permissions=ChatPermissions(can_send_messages=False), ) message.reply_text("👍🏻 muted! 🤐") return ("<b>{}:</b>" "\n#MUTE" "\n<b>Admin:</b> {}" "\n<b>User:</b> {}".format( html.escape(chat.title), mention_html(user.id, user.first_name), mention_html(member.user.id, member.user.first_name), )) else: message.reply_text("This user is already taped 🤐") else: message.reply_text("This user isn't in the chat!") return ""
def warns(update, context): message = update.effective_message chat = update.effective_chat args = context.args user = update.effective_user user_id = extract_user(message, args) or update.effective_user.id conn = connected(context.bot, update, chat, user.id, need_admin=False) if conn: chat_id = conn chat_name = dispatcher.bot.getChat(conn).title else: if chat.type == "private": return else: chat_id = update.effective_chat.id chat_name = chat.title result = sql.get_warns(user_id, chat_id) num = 1 if result and result[0] != 0: num_warns, reasons = result limit, _ = sql.get_warn_setting(chat_id) if reasons: if conn: text = "This user has {}/{} warnings, in *{}* for the following reasons:".format( num_warns, limit, chat_name) else: text = "This user has {}/{} warnings, for the following reasons:".format( num_warns, limit, ) for reason in reasons: text += "\n {}. {}".format(num, reason) num += 1 msgs = split_message(text) for msg in msgs: update.effective_message.reply_text(msg, parse_mode="markdown") else: update.effective_message.reply_text( "User has {}/{} warnings, but no reasons for any of them.". format(num_warns, limit), parse_mode="markdown", ) else: update.effective_message.reply_text( "This user hasn't got any warnings!")
def slap(bot: Bot, update: Update, args: List[str]): chat = update.effective_chat # type: Optional[Chat] msg = update.effective_message # type: Optional[Message] # reply to correct message reply_text = msg.reply_to_message.reply_text if msg.reply_to_message else msg.reply_text # get user who sent message if msg.from_user.username: curr_user = "******" + escape_markdown(msg.from_user.username) else: curr_user = "******".format(msg.from_user.first_name, msg.from_user.id) user_id = extract_user(update.effective_message, args) if user_id: slapped_user = bot.get_chat(user_id) user1 = curr_user if slapped_user.username: user2 = "@" + escape_markdown(slapped_user.username) else: user2 = "[{}](tg://user?id={})".format(slapped_user.first_name, slapped_user.id) # if no target found, bot targets the sender else: user1 = "[{}](tg://user?id={})".format(bot.first_name, bot.id) user2 = curr_user temp = random.choice(tld(chat.id, "SLAP_TEMPLATES-K")) item = random.choice(tld(chat.id, "ITEMS-K")) hit = random.choice(tld(chat.id, "HIT-K")) throw = random.choice(tld(chat.id, "THROW-K")) itemp = random.choice(tld(chat.id, "ITEMP-K")) itemr = random.choice(tld(chat.id, "ITEMR-K")) repl = temp.format(user1=user1, user2=user2, item=item, hits=hit, throws=throw, itemp=itemp, itemr=itemr) #user1=user1, user2=user2, item=item_ru, hits=hit_ru, throws=throw_ru, itemp=itemp_ru, itemr=itemr_ru reply_text(repl, parse_mode=ParseMode.MARKDOWN)
def slap(update, context): args = context.args msg = update.effective_message # reply to correct message reply_text = (msg.reply_to_message.reply_text if msg.reply_to_message else msg.reply_text) # get user who sent message if msg.from_user.username: curr_user = "******" + escape_markdown(msg.from_user.username) else: curr_user = "******".format(msg.from_user.first_name, msg.from_user.id) user_id = extract_user(update.effective_message, args) if user_id: slapped_user = context.bot.get_chat(user_id) user1 = curr_user if slapped_user.username: user2 = "@" + escape_markdown(slapped_user.username) else: user2 = "[{}](tg://user?id={})".format(slapped_user.first_name, slapped_user.id) # if no target found, bot targets the sender else: user1 = "[{}](tg://user?id={})".format(context.bot.first_name, context.bot.id) user2 = curr_user temp = random.choice(fun.SLAP_TEMPLATES) item = random.choice(fun.ITEMS) hit = random.choice(fun.HIT) throw = random.choice(fun.THROW) repl = temp.format(user1=user1, user2=user2, item=item, hits=hit, throws=throw) reply_text(repl, parse_mode=ParseMode.MARKDOWN)
def reset_warns(bot: Bot, update: Update, args: List[str]) -> str: message = update.effective_message # type: Optional[Message] chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] user_id = extract_user(message, args) if user_id: sql.reset_warns(user_id, chat.id) message.reply_text("Warnings have been reset!") warned = chat.get_member(user_id).user return "<b>{}:</b>" \ "\n#RESETWARNS" \ "\n<b>Admin:</b> {}" \ "\n<b>User:</b> {} (<code>{}</code>)".format(html.escape(chat.title), mention_html(user.id, user.first_name), mention_html(warned.id, warned.first_name), warned.id) else: message.reply_text("No person has been designated!") return ""
def punch(update, context): args = context.args msg = update.effective_message # reply to correct message reply_text = (msg.reply_to_message.reply_text if msg.reply_to_message else msg.reply_text) # get user who sent message if msg.from_user.username: curr_user = "******" + escape_markdown(msg.from_user.username) else: curr_user = "******".format(msg.from_user.first_name, msg.from_user.id) user_id = extract_user(update.effective_message, args) if user_id: punched_user = context.bot.get_chat(user_id) user1 = curr_user if punched_user.username: user2 = "@" + escape_markdown(punched_user.username) else: user2 = "[{}](tg://user?id={})".format(punched_user.first_name, punched_user.id) # if no target found, bot targets the sender else: user1 = "[{}](tg://user?id={})".format(context.bot.first_name, context.bot.id) user2 = curr_user temp = random.choice(fun.PUNCH_TEMPLATES) item = random.choice(fun.ITEMS) punch = random.choice(fun.PUNCH) repl = temp.format(user1=user1, user2=user2, item=item, punches=punch) reply_text(repl, parse_mode=ParseMode.MARKDOWN)
def get_id(update, context): args = context.args user_id = extract_user(update.effective_message, args) if user_id: if (update.effective_message.reply_to_message and update.effective_message.reply_to_message.forward_from): user1 = update.effective_message.reply_to_message.from_user user2 = update.effective_message.reply_to_message.forward_from update.effective_message.reply_text( "The original sender, {}, has an ID of `{}`.\nThe forwarder, {}, has an ID of `{}`." .format( escape_markdown(user2.first_name), user2.id, escape_markdown(user1.first_name), user1.id, ), parse_mode=ParseMode.MARKDOWN, ) else: user = context.bot.get_chat(user_id) update.effective_message.reply_text( "{}'s id is `{}`.".format(escape_markdown(user.first_name), user.id), parse_mode=ParseMode.MARKDOWN, ) else: chat = update.effective_chat # type: Optional[Chat] if chat.type == "private": update.effective_message.reply_text( "Your id is `{}`.".format(chat.id), parse_mode=ParseMode.MARKDOWN, ) else: update.effective_message.reply_text( "This group's id is `{}`.".format(chat.id), parse_mode=ParseMode.MARKDOWN, )
def reset_warns(update, context): message = update.effective_message chat = update.effective_chat user = update.effective_user args = context.args user_id = extract_user(message, args) if user_id: sql.reset_warns(user_id, chat.id) message.reply_text("Warnings have been reset!") warned = chat.get_member(user_id).user return ("<b>{}:</b>" "\n#RESETWARNS" "\n<b>Admin:</b> {}" "\n<b>User:</b> {} (<code>{}</code>)".format( html.escape(chat.title), mention_html(user.id, user.first_name), mention_html(warned.id, warned.first_name), warned.id, )) else: message.reply_text("No user has been designated!") return ""
def about_me(update, context): message = update.effective_message # type: Optional[Message] args = context.args user_id = extract_user(message, args) if user_id: user = context.bot.get_chat(user_id) else: user = message.from_user info = USER_INFO.find_one({'_id': user.id}) if info: update.effective_message.reply_text( "*{}*:\n{}".format(user.first_name, escape_markdown(info["info"])), parse_mode=ParseMode.MARKDOWN, ) elif message.reply_to_message: username = message.reply_to_message.from_user.first_name update.effective_message.reply_text( username + "Information about him is currently unavailable !") else: update.effective_message.reply_text( "You have not added any information about yourself yet !")
def about_bio(update, context): message = update.effective_message # type: Optional[Message] args = context.args user_id = extract_user(message, args) if user_id: user = context.bot.get_chat(user_id) else: user = message.from_user info = USER_BIO.find_one({'_id': user.id}) if info: update.effective_message.reply_text( "*{}*:\n{}".format(user.first_name, escape_markdown(info["bio"])), parse_mode=ParseMode.MARKDOWN, ) elif message.reply_to_message: username = user.first_name update.effective_message.reply_text( "{} No details about him have been saved yet !".format(username)) else: update.effective_message.reply_text( " Your bio about you has been saved !")
def remove_warns(update, context): message = update.effective_message chat = update.effective_chat user = update.effective_user args = context.args user_id = extract_user(message, args) if user_id: sql.remove_warn(user_id, chat.id) message.reply_text("Last warn has been removed!") warned = chat.get_member(user_id).user return ("<b>{}:</b>" "\n#UNWARN" "\n<b>• Admin:</b> {}" "\n<b>• User:</b> {}" "\n<b>• ID:</b> <code>{}</code>".format( html.escape(chat.title), mention_html(user.id, user.first_name), mention_html(warned.id, warned.first_name), warned.id, )) else: message.reply_text("No user has been designated!") return ""
def demote(bot: Bot, update: Update, args: List[str]) -> str: chat = update.effective_chat # type: Optional[Chat] message = update.effective_message # type: Optional[Message] user = update.effective_user # type: Optional[User] conn = connected(bot, update, chat, user.id) if not conn == False: chatD = dispatcher.bot.getChat(conn) else: chatD = update.effective_chat if chat.type == "private": exit(1) if not chatD.get_member(bot.id).can_promote_members: update.effective_message.reply_text( "I can't promote/demote people here! " "Make sure I'm admin and can appoint new admins.") exit(1) user_id = extract_user(message, args) if not user_id: message.reply_text( tld(chat.id, "You don't seem to be referring to a user.")) return "" user_member = chatD.get_member(user_id) if user_member.status == 'creator': message.reply_text( tld(chat.id, "This person CREATED the chat, how would I demote them?")) return "" if not user_member.status == 'administrator': message.reply_text(tld(chat.id, "Can't demote what wasn't promoted!")) return "" if user_id == bot.id: message.reply_text(tld(chat.id, "I can't demote myself!")) return "" try: bot.promoteChatMember(int(chatD.id), int(user_id), can_change_info=False, can_post_messages=False, can_edit_messages=False, can_delete_messages=False, can_invite_users=False, can_restrict_members=False, can_pin_messages=False, can_promote_members=False) message.reply_text(tld(chat.id, f"Successfully demoted in *{chatD.title}*!"), parse_mode=ParseMode.MARKDOWN) return f"<b>{html.escape(chatD.title)}:</b>" \ "\n#DEMOTED" \ f"\n<b>Admin:</b> {mention_html(user.id, user.first_name)}" \ f"\n<b>User:</b> {mention_html(user_member.user.id, user_member.user.first_name)}" except BadRequest: message.reply_text( tld( chat.id, "Could not demote. I might not be admin, or the admin status was appointed by another user, so I can't act upon them!" )) return ""
def user_join_fed(bot: Bot, update: Update, args: List[str]): chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] fed_id = sql.get_fed_id(chat.id) if is_user_fed_owner(fed_id, user.id) == False: update.effective_message.reply_text( tld(chat.id, "Only fed owner can do this!")) return msg = update.effective_message # type: Optional[Message] user_id = extract_user(msg, args) if user_id: user = bot.get_chat(user_id) elif not msg.reply_to_message and not args: user = msg.from_user elif not msg.reply_to_message and ( not args or (len(args) >= 1 and not args[0].startswith("@") and not args[0].isdigit() and not msg.parse_entities([MessageEntity.TEXT_MENTION]))): msg.reply_text(tld(chat.id, "I can't extract a user from this.")) return else: return print(sql.search_user_in_fed(fed_id, user_id)) #if user_id == user_id: # update.effective_message.reply_text(tld(chat.id, "Are you gonna promote yourself?")) # return fed_id = sql.get_fed_id(chat.id) info = sql.get_fed_info(fed_id) OW = bot.get_chat(info.owner_id) HAHA = OW.id if user_id == HAHA: update.effective_message.reply_text( tld(chat.id, "Why are you trying to promote federation owner!?")) return if not sql.search_user_in_fed(fed_id, user_id) == False: update.effective_message.reply_text( tld( chat.id, "I can't promote user which is already a fed admin! But I can demote them." )) return if user_id == bot.id: update.effective_message.reply_text( tld( chat.id, "I am already the federation admin and the one that manage it!" )) return #else: # return res = sql.user_join_fed(fed_id, user_id) if not res: update.effective_message.reply_text( tld( chat.id, "Failed to promoted! It might be because you are admin in another federation! Our code is still buggy, We are sorry for that!" )) return update.effective_message.reply_text(tld(chat.id, "Promoted Successfully!"))
def info(update, context): args = context.args msg = update.effective_message # type: Optional[Message] user_id = extract_user(update.effective_message, args) chat = update.effective_chat if user_id: user = context.bot.get_chat(user_id) elif not msg.reply_to_message and not args: user = msg.from_user elif not msg.reply_to_message and ( not args or (len(args) >= 1 and not args[0].startswith("@") and not args[0].isdigit() and not msg.parse_entities([MessageEntity.TEXT_MENTION]))): msg.reply_text("I can't extract a user from this.") return else: return del_msg = msg.reply_text( "Hold tight while I steal some data from <b>FBI Database</b>...", parse_mode=ParseMode.HTML, ) text = ("<b>USER INFO</b>:" "\n<b>ID:</b> <code>{}</code>" "\n<b>First Name:</b> <code>{}</code>".format( user.id, html.escape(user.first_name))) if user.last_name: text += "\n<b>Last Name:</b> <code>{}</code>".format( html.escape(user.last_name)) if user.username: text += "\n<b>Username:</b> @{}".format(html.escape(user.username)) text += "\n<b>Permanent user link:</b> {}".format( mention_html(user.id, "link")) text += "\n<b>Number of profile pics:</b> <code>{}</code>".format( context.bot.get_user_profile_photos(user.id).total_count) if chat.type != "private": status = context.bot.get_chat_member(chat.id, user.id).status if status: _stext = "\n<b>Status:</b> <code>{}</code>" afk_st = is_afk(user.id) if afk_st: text += _stext.format("Away From Keyboard") else: status = context.bot.get_chat_member(chat.id, user.id).status if status: if status in {"left", "kicked"}: text += _stext.format("Absent") elif status == "member": text += _stext.format("Present") elif status in {"administrator", "creator"}: text += _stext.format("Admin") try: sw = spamwtc.get_ban(int(user.id)) if sw: text += "\n\n<b>This person is banned in Spamwatch!</b>" text += f"\n<b>Reason:</b> <pre>{sw.reason}</pre>" text += "\nAppeal at @SpamWatchSupport" else: pass except BaseException: pass # don't crash if api is down somehow... cas_banned = check_cas(user.id) if cas_banned: text += "\n\n<b>This Person is CAS Banned!</b>" text += f"\n<b>Reason: </b> <a href='{cas_banned}'>CAS Banned</a>" text += "\nAppeal at @cas_discussion" if user.id == OWNER_ID: text += "\n\nAye this guy is my owner.\nI would never do anything against him!" elif user.id in DEV_USERS: text += ("\n\nThis person is one of my dev users! " "\nHe has the most command for me after my owner.") elif user.id in SUDO_USERS: text += ("\n\nThis person is one of my sudo users! " "Nearly as powerful as my owner - so watch it.") elif user.id in SUPPORT_USERS: text += ("\n\nThis person is one of my support users! " "Not quite a sudo user, but can still gban you off the map.") elif user.id in WHITELIST_USERS: text += ("\n\nThis person has been whitelisted! " "That means I'm not allowed to ban/kick them.") elif user.id == int(1087968824): text += "\n\nThis is anonymous admin in this group. " try: memstatus = chat.get_member(user.id).status if memstatus == "administrator" or memstatus == "creator": result = context.bot.get_chat_member(chat.id, user.id) if result.custom_title: text += f"\n\nThis user has custom title <b>{result.custom_title}</b> in this chat." except BadRequest: pass for mod in USER_INFO: try: mod_info = mod.__user_info__(user.id).strip() except TypeError: mod_info = mod.__user_info__(user.id, chat.id).strip() if mod_info: text += "\n\n" + mod_info try: profile = context.bot.get_user_profile_photos(user.id).photos[0][-1] context.bot.sendChatAction(chat.id, "upload_photo") context.bot.send_photo( chat.id, photo=profile, caption=(text), parse_mode=ParseMode.HTML, ) except IndexError: context.bot.sendChatAction(chat.id, "typing") msg.reply_text(text, parse_mode=ParseMode.HTML, disable_web_page_preview=True) finally: del_msg.delete()
def unfban(bot: Bot, update: Update, args: List[str]): chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] message = update.effective_message # type: Optional[Message] fed_id = sql.get_fed_id(chat.id) if not fed_id: update.effective_message.reply_text( tld(chat.id, "This group is not in any federation!")) return info = sql.get_fed_info(fed_id) if is_user_fed_admin(fed_id, user.id) == False: update.effective_message.reply_text( tld(chat.id, "Only fed admins can do this!")) return user_id = extract_user(message, args) if not user_id: message.reply_text( tld(chat.id, "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(tld(chat.id, "That's not a user!")) return if sql.get_fban_user(fed_id, user_id) == False: message.reply_text(tld(chat.id, "This user is not fbanned!")) return banner = update.effective_user # type: Optional[User] message.reply_text( tld(chat.id, "I'll give {} a second chance in this federation.").format( user_chat.first_name)) h = sql.all_fed_chats(fed_id) for O in h: try: member = bot.get_chat_member(O, user_id) if member.status == 'kicked': bot.unban_chat_member(O, user_id) except BadRequest as excp: if excp.message in UNFBAN_ERRORS: pass else: message.reply_text( tld(chat.id, "Could not un-fban due to: {}").format(excp.message)) return except TelegramError: pass try: x = sql.un_fban_user(fed_id, user_id) if not x: message.reply_text( tld(chat.id, "Failed to fban, This user is probably fbanned!")) return except: pass message.reply_text(tld(chat.id, "Person has been un-fbanned.")) OW = bot.get_chat(info.owner_id) HAHA = OW.id FEDADMIN = sql.all_fed_users(fed_id) FEDADMIN.append(int(HAHA)) send_to_list(bot, FEDADMIN, "<b>Un-FedBan</b>" \ "\n<b>Fed:</b> {}" \ "\n<b>FedAdmin:</b> {}" \ "\n<b>User:</b> {}" \ "\n<b>User ID:</b> <code>{}</code>".format(info.fed_name, mention_html(user.id, user.first_name), mention_html(user_chat.id, user_chat.first_name), user_chat.id), html=True)
def media(bot: Bot, update: Update, args: List[str]) -> str: chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] message = update.effective_message # type: Optional[Message] conn = connected(bot, update, chat, user.id) if not conn == False: chatD = dispatcher.bot.getChat(conn) else: if chat.type == "private": exit(1) else: chatD = chat user_id = extract_user(message, args) if not user_id: message.reply_text( tld( chat.id, "You'll need to either give me a username to unrestrict, or reply to someone to be unrestricted." )) return "" member = chatD.get_member(int(user_id)) if member.status != 'kicked' and member.status != 'left': if member.can_send_messages and member.can_send_media_messages \ and member.can_send_other_messages and member.can_add_web_page_previews: message.reply_text( tld( chat.id, "This user already has the rights to send anything in {}." ).format(chatD.title)) else: bot.restrict_chat_member(chatD.id, int(user_id), can_send_messages=True, can_send_media_messages=True, can_send_other_messages=True, can_add_web_page_previews=True) keyboard = [] reply = tld(chat.id, "Yep, {} can send media again in {}!").format( mention_html(member.user.id, member.user.first_name), chatD.title) message.reply_text(reply, reply_markup=keyboard, parse_mode=ParseMode.HTML) return "<b>{}:</b>" \ "\n#UNRESTRICTED" \ "\n<b>• Admin:</b> {}" \ "\n<b>• User:</b> {}" \ "\n<b>• ID:</b> <code>{}</code>".format(html.escape(chatD.title), mention_html(user.id, user.first_name), mention_html(member.user.id, member.user.first_name), user_id) else: message.reply_text( tld( chat.id, "This user isn't even in the chat, unrestricting them won't make them send anything than they " "already do!")) return ""
def nomedia(bot: Bot, update: Update, args: List[str]) -> str: chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] message = update.effective_message # type: Optional[Message] conn = connected(bot, update, chat, user.id) if not conn == False: chatD = dispatcher.bot.getChat(conn) else: if chat.type == "private": exit(1) else: chatD = chat user_id = extract_user(message, args) if not user_id: message.reply_text( tld( chat.id, "You'll need to either give me a username to restrict, or reply to someone to be restricted." )) return "" if user_id == bot.id: message.reply_text(tld(chat.id, "I'm not restricting myself!")) return "" member = chatD.get_member(int(user_id)) if member: if is_user_admin(chatD, user_id, member=member): message.reply_text(tld(chat.id, "Afraid I can't restrict admins!")) elif member.can_send_messages is None or member.can_send_messages: bot.restrict_chat_member(chatD.id, user_id, can_send_messages=True, can_send_media_messages=False, can_send_other_messages=False, can_add_web_page_previews=False) keyboard = [] reply = tld(chat.id, "{} is restricted from sending media in {}!").format( mention_html(member.user.id, member.user.first_name), chatD.title) message.reply_text(reply, reply_markup=keyboard, parse_mode=ParseMode.HTML) return "<b>{}:</b>" \ "\n#RESTRICTED" \ "\n<b>• Admin:</b> {}" \ "\n<b>• User:</b> {}" \ "\n<b>• ID:</b> <code>{}</code>".format(html.escape(chatD.title), mention_html(user.id, user.first_name), mention_html(member.user.id, member.user.first_name), user_id) else: message.reply_text( tld(chat.id, "This user is already restricted in {}!")) else: message.reply_text( tld(chat.id, "This user isn't in the {}!").format(chatD.title)) return ""
def mute(bot: Bot, update: Update, args: List[str]) -> str: chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] message = update.effective_message # type: Optional[Message] conn = connected(bot, update, chat, user.id) if not conn == False: chatD = dispatcher.bot.getChat(conn) else: if chat.type == "private": exit(1) else: chatD = chat user_id = extract_user(message, args) if not user_id: message.reply_text( tld( chat.id, "You'll need to either give me a username to mute, or reply to someone to be muted." )) return "" if user_id == bot.id: message.reply_text(tld(chat.id, "I'm not muting myself!")) return "" member = chatD.get_member(int(user_id)) if member: if user_id in SUDO_USERS: message.reply_text( tld( chat.id, "No! I'm not muting bot sudoers! That would be a pretty dumb idea." )) elif is_user_admin(chatD, user_id, member=member): message.reply_text( tld( chat.id, "No! I'm not muting chat administrator! That would be a pretty dumb idea." )) elif member.can_send_messages is None or member.can_send_messages: bot.restrict_chat_member(chatD.id, user_id, can_send_messages=False) keyboard = [] reply = tld(chat.id, "{} is muted in {}!").format( mention_html(member.user.id, member.user.first_name), chatD.title) message.reply_text(reply, reply_markup=keyboard, parse_mode=ParseMode.HTML) return "<b>{}:</b>" \ "\n#MUTE" \ "\n<b>Admin:</b> {}" \ "\n<b>User:</b> {}".format(html.escape(chatD.title), mention_html(user.id, user.first_name), mention_html(member.user.id, member.user.first_name)) else: message.reply_text( tld(chat.id, "This user is already muted in {}!").format(chatD.title)) else: message.reply_text( tld(chat.id, "This user isn't in the {}!").format(chatD.title)) return ""
def ungban(update, context): message = update.effective_message args = context.args 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 = context.bot.get_chat(user_id) if user_chat.type != "private": message.reply_text("That's not a user!") return if not gban_db.is_user_gbanned(user_id): message.reply_text("This user is not gbanned!") return banner = update.effective_user message.reply_text("I'll give {} a second chance, globally.".format( user_chat.first_name)) context.bot.sendMessage( GBAN_LOGS, "<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, ), parse_mode=ParseMode.HTML, ) chats = get_all_chats() for chat in chats: chat_id = chat["chat_id"] # Check if this group has disabled gbans if not gban_db.does_chat_gban(chat_id): continue try: member = context.bot.get_chat_member(chat_id, user_id) if member.status == "kicked": context.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)) context.bot.send_message( OWNER_ID, "Could not un-gban due to: {}".format(excp.message), ) return except TelegramError: pass gban_db.ungban_user(user_id) message.reply_text("Person has been un-gbanned.")
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 ungmute(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_gmuted(user_id): message.reply_text("This user is not gmuted!") return muter = update.effective_user # type: Optional[User] message.reply_text("I'll let {} speak again, globally.".format( user_chat.first_name)) send_to_list(bot, SUDO_USERS + SUPPORT_USERS, "{} has ungmuted user {}".format( mention_html(muter.id, muter.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 gmutes if not sql.does_chat_gban(chat_id): continue try: member = bot.get_chat_member(chat_id, user_id) if member.status == 'restricted': bot.restrict_chat_member(chat_id, int(user_id), can_send_messages=True, can_send_media_messages=True, can_send_other_messages=True, can_add_web_page_previews=True) except BadRequest as excp: if excp.message == "User is an administrator of the chat": pass elif excp.message == "Chat not found": pass elif excp.message == "Not enough rights to restrict/unrestrict chat member": pass elif excp.message == "User_not_participant": pass elif excp.message == "Method is available for supergroup and channel chats only": pass elif excp.message == "Not in the chat": pass elif excp.message == "Channel_private": pass elif excp.message == "Chat_admin_required": pass else: message.reply_text("Could not un-gmute due to: {}".format( excp.message)) bot.send_message( OWNER_ID, "Could not un-gmute due to: {}".format(excp.message)) return except TelegramError: pass sql.ungmute_user(user_id) send_to_list(bot, SUDO_USERS + SUPPORT_USERS, "un-gmute complete!") message.reply_text("Person has been un-gmuted.")
def info(bot: Bot, update: Update, args: List[str]): msg = update.effective_message # type: Optional[Message] user_id = extract_user(update.effective_message, args) chat = update.effective_chat # type: Optional[Chat] if user_id: user = bot.get_chat(user_id) elif not msg.reply_to_message and not args: user = msg.from_user elif not msg.reply_to_message and ( not args or (len(args) >= 1 and not args[0].startswith("@") and not args[0].isdigit() and not msg.parse_entities([MessageEntity.TEXT_MENTION]))): msg.reply_text(tld(chat.id, "I can't extract a user from this.")) return else: return text = tld(chat.id, "<b>User info</b>:") text += "\nID: <code>{}</code>".format(user.id) text += tld(chat.id, "\nFirst Name: {}").format(html.escape(user.first_name)) if user.last_name: text += tld(chat.id, "\nLast Name: {}").format(html.escape(user.last_name)) if user.username: text += tld(chat.id, "\nUsername: @{}").format(html.escape(user.username)) text += tld(chat.id, "\nUser link: {}\n").format(mention_html(user.id, "link")) if user.id == OWNER_ID: text += tld( chat.id, "\n\nAy, This guy is my owner. I would never do anything against him!" ) else: if user.id in SUDO_USERS: text += tld(chat.id, "\nThis person is one of my sudo users! " \ "Nearly as powerful as my owner - so watch it.") else: if user.id in SUPPORT_USERS: text += tld(chat.id, "\nThis person is one of my support users! " \ "Not quite a sudo user, but can still gban you off the map.") if user.id in WHITELIST_USERS: text += tld(chat.id, "\nThis person has been whitelisted! " \ "That means I'm not allowed to ban/kick them.") for mod in USER_INFO: mod_info = mod.__user_info__(user.id, chat.id).strip() if mod_info: text += "\n\n" + mod_info update.effective_message.reply_text(text, parse_mode=ParseMode.HTML)