def fed_chat(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) user_id = update.effective_message.from_user.id if not is_user_admin(update.effective_chat, user_id): update.effective_message.reply_text( "You must be a chat administrator to run this command :P") return if not fed_id: update.effective_message.reply_text( tld(chat.id, "This group not in any federation!")) return print(fed_id) user = update.effective_user # type: Optional[Chat] chat = update.effective_chat # type: Optional[Chat] info = sql.get_fed_info(fed_id) text = "This chat is part of the following federation:" text += "\n{} (ID: <code>{}</code>)".format(info.fed_name, fed_id) update.effective_message.reply_text(text, parse_mode=ParseMode.HTML)
def button(bot: Bot, update: Update) -> str: query = update.callback_query # type: Optional[CallbackQuery] user = update.effective_user # type: Optional[User] match = re.match(r"rm_warn\((.+?)\)", query.data) if match: user_id = match.group(1) chat = update.effective_chat # type: Optional[Chat] if not is_user_admin(chat, int(user.id)): query.answer( text= "Who the f**k are you? You are not authorized to remove this warn! Only administrators may remove warns.", show_alert=True) return "" res = sql.remove_warn(user_id, chat.id) if res: update.effective_message.edit_text("Warn removed by {}.".format( mention_html(user.id, user.first_name)), parse_mode=ParseMode.HTML) user_member = chat.get_member(user_id) return "<b>{}:</b>" \ "\n#UNWARN" \ "\n<b>Admin:</b> {}" \ "\n<b>User:</b> {} (<code>{}</code>)".format(html.escape(chat.title), mention_html(user.id, user.first_name), mention_html(user_member.user.id, user_member.user.first_name), user_member.user.id) else: update.effective_message.edit_text( "Person already has no warns.".format( mention_html(user.id, user.first_name)), parse_mode=ParseMode.HTML) return ""
def enforce_gmute(bot: Bot, update: Update): # Not using @restrict handler to avoid spamming - just ignore if cant gmute. if sql.does_chat_gban( update.effective_chat.id) and update.effective_chat.get_member( bot.id).can_restrict_members: user = update.effective_user # type: Optional[User] chat = update.effective_chat # type: Optional[Chat] msg = update.effective_message # type: Optional[Message] if user and not is_user_admin(chat, user.id): check_and_mute(bot, update, user.id, should_message=True) if msg.new_chat_members: new_members = update.effective_message.new_chat_members for mem in new_members: check_and_mute(bot, update, mem.id, should_message=True) if msg.reply_to_message: user = msg.reply_to_message.from_user # type: Optional[User] if user and not is_user_admin(chat, user.id): check_and_mute(bot, update, user.id, should_message=True)
def enforce_gban(update, context): # Not using @restrict handler to avoid spamming - just ignore if cant gban. if (sql.does_chat_gban(update.effective_chat.id) and update.effective_chat.get_member( context.bot.id).can_restrict_members): 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) 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 kickme(update, context): user_id = update.effective_message.from_user.id if is_user_admin(update.effective_chat, user_id): update.effective_message.reply_text( "Yeahhh.. not gonna kick an admin.") return res = update.effective_chat.unban_member( user_id) # unban on current user = kick if res: update.effective_message.reply_text("Yeah, you're right Get Out!..") else: update.effective_message.reply_text("Huh? I can't :/")
def unlock(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] if is_user_admin(chat, message.from_user.id): if len(args) >= 1: if args[0] in LOCK_TYPES: sql.update_lock(chat.id, args[0], locked=False) message.reply_text(tld(chat.id, "Unlocked {} for everyone!").format(args[0])) return "<b>{}:</b>" \ "\n#UNLOCK" \ "\n<b>Admin:</b> {}" \ "\nUnlocked <code>{}</code>.".format(html.escape(chat.title), mention_html(user.id, user.first_name), args[0]) elif args[0] in RESTRICTION_TYPES: sql.update_restriction(chat.id, args[0], locked=False) """ members = users_sql.get_chat_members(chat.id) if args[0] == "messages": unrestr_members(bot, chat.id, members, media=False, other=False, previews=False) elif args[0] == "media": unrestr_members(bot, chat.id, members, other=False, previews=False) elif args[0] == "other": unrestr_members(bot, chat.id, members, previews=False) elif args[0] == "previews": unrestr_members(bot, chat.id, members) elif args[0] == "all": unrestr_members(bot, chat.id, members, True, True, True, True) """ message.reply_text(tld(chat.id, "Unlocked {} for everyone!").format(args[0])) return "<b>{}:</b>" \ "\n#UNLOCK" \ "\n<b>Admin:</b> {}" \ "\nUnlocked <code>{}</code>.".format(html.escape(chat.title), mention_html(user.id, user.first_name), args[0]) else: message.reply_text(tld(chat.id, "What are you trying to unlock...? Try /locktypes for the list of lockables")) else: bot.sendMessage(chat.id, tld(chat.id, "What are you trying to unlock...?")) return ""
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 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 kickme(bot: Bot, update: Update): user_id = update.effective_message.from_user.id if user_id == OWNER_ID: update.effective_message.reply_text( "You’re strong. If I try to remove You,I will Never Be Happy In my Life" ) return elif is_user_admin(update.effective_chat, user_id): update.effective_message.reply_text( "Why would I kick an Admin? That sounds like a pretty dumb idea.") return res = update.effective_chat.unban_member( user_id) # unban on current user = kick if res: update.effective_message.reply_text("No problem.") else: update.effective_message.reply_text("Huh? I can't :/")
def check_update(self, update): chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] if super().check_update(update): # Should be safe since check_update passed. command = update.effective_message.text_html.split( None, 1)[0][1:].split('@')[0] # disabled, admincmd, user admin if sql.is_command_disabled(chat.id, command): return command in ADMIN_CMDS and is_user_admin( chat, user.id) # not disabled else: return True return False
def muteme(bot: Bot, update: Update, args: List[str]) -> str: user_id = update.effective_message.from_user.id chat = update.effective_chat user = update.effective_user 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 = bot.restrict_chat_member(chat.id, user_id, can_send_messages=False) if res: update.effective_message.reply_text("No problem, Muted!") log = "<b>{}:</b>" \ "\n#MUTEME" \ "\n<b>User:</b> {}" \ "\n<b>ID:</b> <code>{}</code>".format(html.escape(chat.title), mention_html(user.id, user.first_name), user_id) return log else: update.effective_message.reply_text("Huh? I can't :/")
def start(bot: Bot, update: Update, args: List[str]): LOGGER.info("Start") chat = update.effective_chat # type: Optional[Chat] #query = update.callback_query #Unused variable if update.effective_chat.type == "private": if len(args) >= 1: if args[0].lower() == "help": send_help( update.effective_chat.id, tld(chat.id, "send-help").format( dispatcher.bot.first_name, "" if not ALLOW_EXCL else tld( chat.id, "\nAll commands can either be used with `/` or `!`.\n" ))) 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, update, user=False) else: send_settings(match.group(1), update.effective_user.id, update, user=True) elif args[0][1:].isdigit() and "rules" in IMPORTED: IMPORTED["rules"].send_rules(update, args[0], from_pm=True) elif args[0].lower() == "controlpanel": control_panel(bot, update) else: send_start(bot, update) else: update.effective_message.reply_text("I'm alive")
def get_settings(bot: Bot, update: Update): chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] msg = update.effective_message # type: Optional[Message] args = msg.text.split(None, 1) # 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( bot.username, chat.id)) ]])) else: text = "Click here to check your settings." else: send_settings(chat.id, user.id, True)
def check_update(self, update): if isinstance(update, Update) and update.effective_message: message = update.effective_message if message.text and len(message.text) > 1: fst_word = message.text.split(None, 1)[0] if len(fst_word) > 1 and any( fst_word.startswith(start) for start in CMD_STARTERS): args = message.text.split()[1:] command = fst_word[1:].split("@") command.append(message.bot.username) if not (command[0].lower() in self.command and command[1].lower() == message.bot.username.lower()): return None filter_result = self.filters(update) if filter_result: chat = update.effective_chat user = update.effective_user # disabled, admincmd, user admin if sql.is_command_disabled(chat.id, command[0].lower()): # check if command was disabled is_disabled = command[ 0] in ADMIN_CMDS and is_user_admin( chat, user.id) if not is_disabled: return None else: return args, filter_result return args, filter_result else: return False
def banme(bot: Bot, update: Update): user_id = update.effective_message.from_user.id chat = update.effective_chat user = update.effective_user if user_id == OWNER_ID: update.effective_message.reply_text("Oof, I can't ban my master. 😶") return elif is_user_admin(update.effective_chat, user_id): update.effective_message.reply_text( "Why would I ban an Admin? That sounds like a pretty dumb idea.") return res = update.effective_chat.kick_member(user_id) if res: update.effective_message.reply_text("Kids get lost. 😏") log = "<b>{}:</b>" \ "\n#BANME" \ "\n<b>User:</b> {}" \ "\n<b>ID:</b> <code>{}</code>".format(html.escape(chat.title), mention_html(user.id, user.first_name), user_id) return log else: update.effective_message.reply_text("Huh? I can't :/")
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 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, can't even be warned!") 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: # kick chat.unban_member(user.id) reply = "{} warnings, {} has been kicked!".format( limit, mention_html(user.id, user.first_name)) else: # ban chat.kick_member(user.id) reply = "{} warnings, {} has been banned!".format( limit, mention_html(user.id, user.first_name)) for warn_reason in reasons: reply += "\n - {}".format(html.escape(warn_reason)) message.bot.send_sticker(chat.id, BAN_STICKER) # banhammer marie sticker keyboard = [] log_reason = "<b>{}:</b>" \ "\n#WARN_BAN" \ "\n<b>Admin:</b> {}" \ "\n<b>User:</b> {} (<code>{}</code>)" \ "\n<b>Reason:</b> {}"\ "\n<b>Counts:</b> <code>{}/{}</code>".format(html.escape(chat.title), warner_tag, mention_html(user.id, user.first_name), user.id, reason, num_warns, limit) else: keyboard = InlineKeyboardMarkup([[ InlineKeyboardButton("Remove warn (Admin Only)", callback_data="rm_warn({})".format(user.id)) ]]) reply = "{} has {}/{} warnings... watch out!".format( mention_html(user.id, user.first_name), num_warns, limit) if reason: reply += "\nReason for last warn:\n{}".format(html.escape(reason)) log_reason = "<b>{}:</b>" \ "\n#WARN" \ "\n<b>Admin:</b> {}" \ "\n<b>User:</b> {} (<code>{}</code>)" \ "\n<b>Reason:</b> {}"\ "\n<b>Counts:</b> <code>{}/{}</code>".format(html.escape(chat.title), warner_tag, mention_html(user.id, user.first_name), user.id, reason, num_warns, limit) 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 temp_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, reason = extract_user_and_text(message, args) if not user_id: message.reply_text( tld(chat.id, "You don't seem to be referring to a user.")) return "" try: member = chat.get_member(user_id) except BadRequest as excp: if excp.message == "User not found": message.reply_text(tld(chat.id, "I can't seem to find this user")) return "" else: raise if is_user_admin(chat, user_id, member): message.reply_text( tld(chat.id, "I really wish I could restrict admins...")) return "" if user_id == bot.id: message.reply_text( tld(chat.id, "I'm not gonna RESTRICT myself, are you crazy?")) return "" if not reason: message.reply_text( tld(chat.id, "You haven't specified a time to restrict this user for!")) return "" split_reason = reason.split(None, 1) time_val = split_reason[0].lower() if len(split_reason) > 1: reason = split_reason[1] else: reason = "" mutetime = extract_time(message, time_val) if not mutetime: return "" log = "<b>{}:</b>" \ "\n#TEMP RESTRICTED" \ "\n<b>• Admin:</b> {}" \ "\n<b>• User:</b> {}" \ "\n<b>• ID:</b> <code>{}</code>" \ "\n<b>• Time:</b> {}".format(html.escape(chat.title), mention_html(user.id, user.first_name), mention_html(member.user.id, member.user.first_name), user_id, time_val) if reason: log += "\n<b>• Reason:</b> {}".format(reason) try: if member.can_send_messages is None or member.can_send_messages: bot.restrict_chat_member(chat.id, user_id, until_date=mutetime, can_send_messages=True, can_send_media_messages=False, can_send_other_messages=False, can_add_web_page_previews=False) message.reply_text( tld(chat.id, "Restricted from sending media for {} in {}!").format( time_val, chatD.title)) return log else: message.reply_text( tld(chat.id, "This user is already restricted in {}.").format( chatD.title)) except BadRequest as excp: if excp.message == "Reply message not found": # Do not reply message.reply_text(tld(chat.id, "Restricted for {} in {}!").format( time_val, chatD.title), quote=False) return log else: LOGGER.warning(update) LOGGER.exception("ERROR muting user %s in chat %s (%s) due to %s", user_id, chat.title, chat.id, excp.message) message.reply_text( tld(chat.id, "Well damn, I can't restrict that user.")) return ""
def temp_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 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 "" try: member = chat.get_member(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: raise if is_user_admin(chat, user_id, member): message.reply_text("I really wish I could mute admins...") return "" if user_id == context.bot.id: message.reply_text("I'm not gonna MUTE myself, are you crazy?") return "" if not reason: message.reply_text( "You haven't specified a time to mute this user for!") return "" split_reason = reason.split(None, 1) time_val = split_reason[0].lower() if len(split_reason) > 1: reason = split_reason[1] else: reason = "" mutetime = extract_time(message, time_val) if not mutetime: return "" log = ("<b>{}:</b>" "\n#TEMP MUTED" "\n<b>Admin:</b> {}" "\n<b>User:</b> {}" "\n<b>Time:</b> {}".format( html.escape(chat.title), mention_html(user.id, user.first_name), mention_html(member.user.id, member.user.first_name), time_val, )) if reason: log += "\n<b>Reason:</b> {}".format(reason) try: if member.can_send_messages is None or member.can_send_messages: context.bot.restrict_chat_member( chat.id, user_id, until_date=mutetime, permissions=ChatPermissions(can_send_messages=False), ) message.reply_text("shut up! 🤐 Taped for {}!".format(time_val)) return log else: message.reply_text("This user is already muted.") except BadRequest as excp: if excp.message == "Reply message not found": # Do not reply message.reply_text("shut up! 🤐 Taped for {}!".format(time_val), quote=False) return log else: LOGGER.warning(update) LOGGER.exception( "ERROR muting user %s in chat %s (%s) due to %s", user_id, chat.title, chat.id, excp.message, ) message.reply_text("Well damn, I can't mute that user.") 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 check_update(self, update): return super().check_update(update) and not ( sql.is_restr_locked(update.effective_chat.id, 'messages') and not is_user_admin(update.effective_chat, update.effective_user.id))