def connected(bot, update, chat, user_id, need_admin=True): user = update.effective_user if chat.type == chat.PRIVATE and sql.get_connected_chat(user_id): conn_id = sql.get_connected_chat(user_id).chat_id getstatusadmin = bot.get_chat_member( conn_id, update.effective_message.from_user.id) isadmin = getstatusadmin.status in ('administrator', 'creator') ismember = getstatusadmin.status in ('member') isallow = sql.allow_connect_to_chat(conn_id) if (isadmin) or (isallow and ismember) or (user.id in SUDO_USERS) or ( user.id in DEV_USERS): if need_admin == True: if getstatusadmin.status in ( 'administrator', 'creator' ) or user_id in SUDO_USERS or user.id in DEV_USERS: return conn_id else: send_message( update.effective_message, "You must be an admin in the connected group!") else: return conn_id else: send_message( update.effective_message, "The group changed the connection rights or you are no longer an admin.\nI've disconnected you." ) disconnect_chat(update, bot) else: return False
def connection_chat(bot: Bot, update: Update): chat = update.effective_chat user = update.effective_user spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id) if spam == True: return conn = connected(bot, update, chat, user.id, need_admin=True) if conn: chat = dispatcher.bot.getChat(conn) chat_name = dispatcher.bot.getChat(conn).title else: if update.effective_message.chat.type != "private": return chat = update.effective_chat chat_name = update.effective_message.chat.title if conn: message = "You are currently connected with {}.\n".format(chat_name) else: message = "You are currently not connected in any group.\n" send_message(update.effective_message, message, parse_mode="markdown")
def help_connect_chat(update, context): args = context.args if update.effective_message.chat.type != "private": send_message(update.effective_message, "PM me with that command to get help.") return else: send_message(update.effective_message, CONN_HELP, parse_mode="markdown")
def disconnect_chat(update, context): if update.effective_chat.type == 'private': disconnection_status = sql.disconnect( update.effective_message.from_user.id) if disconnection_status: sql.disconnected_chat = send_message(update.effective_message, "Disconnected from chat!") else: send_message(update.effective_message, "You're not connected!") else: send_message(update.effective_message, "This command is only available in PM.")
def help_connect_chat(bot: Bot, update: Update): spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id) if spam == True: return if update.effective_message.chat.type != "private": send_message(update.effective_message, "PM me with that command to get help.") return else: send_message(update.effective_message, "All commands", parse_mode="markdown")
def disconnect_chat(bot: Bot, update: Update): spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id) if spam == True: return if update.effective_chat.type == 'private': disconnection_status = sql.disconnect( update.effective_message.from_user.id) if disconnection_status: sql.disconnected_chat = send_message(update.effective_message, "Disconnected from chat!") else: send_message(update.effective_message, "You're not connected!") else: send_message(update.effective_message, "This command is only available in PM.")
def commands(update, context): chat = update.effective_chat user = update.effective_user conn = connected(context.bot, update, chat, user.id, need_admin=True) if conn: chat = dispatcher.bot.getChat(conn) chat_id = conn 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 text = build_curr_disabled(chat.id) send_message(update.effective_message, text, parse_mode=ParseMode.MARKDOWN)
def connection_chat(update, context): chat = update.effective_chat user = update.effective_user conn = connected(context.bot, update, chat, user.id, need_admin=True) if conn: chat = dispatcher.bot.getChat(conn) chat_name = dispatcher.bot.getChat(conn).title else: if update.effective_message.chat.type != "private": return chat = update.effective_chat chat_name = update.effective_message.chat.title if conn: message = "You are currently connected to {}.\n".format(chat_name) else: message = "You are currently not connected in any group.\n" send_message(update.effective_message, message, parse_mode="markdown")
def list_locks(update, context): chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # Connection check conn = connected(context.bot, update, chat, user.id, need_admin=True) if conn: chat = dispatcher.bot.getChat(conn) chat_name = chat.title 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_name = update.effective_message.chat.title res = build_lock_message(chat.id) if conn: res = res.replace('Locks in', '*{}*'.format(chat_name)) send_message(update.effective_message, res, parse_mode=ParseMode.MARKDOWN)
def flood(update, context): chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] msg = update.effective_message 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 update.effective_message.chat.type == "private": send_message(update.effective_message, "This command is meant to use in group not in PM") return chat_id = update.effective_chat.id chat_name = update.effective_message.chat.title limit = sql.get_flood_limit(chat_id) if limit == 0: if conn: text = msg.reply_text( "I'm not enforcing any flood control in {}!".format(chat_name)) else: text = msg.reply_text("I'm not enforcing any flood control here!") send_message(update.effective_message, text, parse_mode="markdown") else: if conn: text = msg.reply_text( "I'm currently restricting members after {} consecutive messages in {}." .format(limit, chat_name)) else: text = msg.reply_text( "I'm currently restricting members after {} consecutive messages." .format(limit)) send_message(update.effective_message, text, parse_mode="markdown")
def blacklist(update, context): chat = update.effective_chat user = update.effective_user args = context.args 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 filter_list = "Current blacklisted words in <b>{}</b>:\n".format(chat_name) all_blacklisted = sql.get_chat_blacklist(chat_id) if len(args) > 0 and args[0].lower() == 'copy': for trigger in all_blacklisted: filter_list += "<code>{}</code>\n".format(html.escape(trigger)) else: for trigger in all_blacklisted: filter_list += " - <code>{}</code>\n".format(html.escape(trigger)) # for trigger in all_blacklisted: # filter_list += " - <code>{}</code>\n".format(html.escape(trigger)) split_text = split_message(filter_list) for text in split_text: if filter_list == "Current blacklisted words in <b>{}</b>:\n".format( chat_name): send_message( update.effective_message, "No blacklisted words in <b>{}</b>!".format(chat_name), parse_mode=ParseMode.HTML) return send_message(update.effective_message, text, parse_mode=ParseMode.HTML)
def blackliststicker(bot: Bot, update: Update, args: List[str]): msg = update.effective_message # type: Optional[Message] chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] conn = connected(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 sticker_list = "<b>List black stickers currently in {}:</b>\n".format( chat_name) all_stickerlist = sql.get_chat_stickers(chat_id) if len(args) > 0 and args[0].lower() == 'copy': for trigger in all_stickerlist: sticker_list += "<code>{}</code>\n".format(html.escape(trigger)) elif len(args) == 0: for trigger in all_stickerlist: sticker_list += " - <code>{}</code>\n".format(html.escape(trigger)) split_text = split_message(sticker_list) for text in split_text: if sticker_list == "<b>List black stickers currently in {}:</b>\n".format( chat_name).format(chat_name): send_message(update.effective_message, "There is no blacklist sticker in <b>{}</b>!".format( chat_name), parse_mode=ParseMode.HTML) return send_message(update.effective_message, text, parse_mode=ParseMode.HTML)
def reply_afk(update, context): message = update.effective_message # type: Optional[Message] entities = message.parse_entities( [MessageEntity.TEXT_MENTION, MessageEntity.MENTION]) if message.entities and entities: for ent in entities: if ent.type == MessageEntity.TEXT_MENTION: user_id = ent.user.id fst_name = ent.user.first_name elif ent.type == MessageEntity.MENTION: user_id = get_user_id(message.text[ent.offset:ent.offset + ent.length]) if not user_id: # Should never happen, since for a user to become AFK they must have spoken. Maybe changed username? return try: chat = context.bot.get_chat(user_id) except BadRequest: print("Error in afk can't get user id {}".format(user_id)) return fst_name = chat.first_name else: return if sql.is_afk(user_id): valid, reason = sql.check_afk_status(user_id) if valid: if not reason: rplafkstr = random.choice(fun.AFKRPL) res = rplafkstr.format(fst_name) else: res = f"<b>{fst_name}</b> is away from keyboard! says it's because of \n{reason}" send_message(update.effective_message, res, parse_mode=ParseMode.HTML)
def enable(update, context): chat = update.effective_chat # type: Optional[Chat] user = update.effective_user args = context.args conn = connected(context.bot, update, chat, user.id, need_admin=True) if conn: chat = dispatcher.bot.getChat(conn) chat_id = conn chat_name = dispatcher.bot.getChat(conn).title else: if update.effective_message.chat.type == "private": send_message( update.effective_message, "This command is meant to be used in group not in PM") return "" chat = update.effective_chat chat_id = update.effective_chat.id chat_name = update.effective_message.chat.title if len(args) >= 1: enable_cmd = args[0] if enable_cmd.startswith(CMD_STARTERS): enable_cmd = enable_cmd[1:] if sql.enable_command(chat.id, enable_cmd): if conn: text = "Enabled the use of `{}` command in *{}*!".format( enable_cmd, chat_name) else: text = "Enabled the use of `{}` command!".format( enable_cmd) send_message(update.effective_message, text, parse_mode=ParseMode.MARKDOWN) else: send_message(update.effective_message, "Is that even disabled?") else: send_message(update.effective_message, "What should I enable?")
def disable(update, context): chat = update.effective_chat # type: Optional[Chat] user = update.effective_user args = context.args conn = connected(context.bot, update, chat, user.id, need_admin=True) if conn: chat = dispatcher.bot.getChat(conn) chat_name = dispatcher.bot.getChat(conn).title else: if update.effective_message.chat.type == "private": send_message( update.effective_message, "This command meant to be used in group not in PM") return "" chat = update.effective_chat chat_name = update.effective_message.chat.title if len(args) >= 1: disable_cmd = args[0] if disable_cmd.startswith(CMD_STARTERS): disable_cmd = disable_cmd[1:] if disable_cmd in set(DISABLE_CMDS + DISABLE_OTHER): sql.disable_command(chat.id, disable_cmd) if conn: text = "Disabled the use of `{}` command in *{}*!".format( disable_cmd, chat_name) else: text = "Disabled the use of `{}` command!".format( disable_cmd) send_message(update.effective_message, text, parse_mode=ParseMode.MARKDOWN) else: send_message(update.effective_message, "This command can't be disabled") else: send_message(update.effective_message, "What should I disable?")
def add_blacklist(update, context): msg = update.effective_message chat = update.effective_chat user = update.effective_user words = msg.text.split(None, 1) conn = connected(context.bot, update, chat, user.id) if conn: chat_id = conn chat_name = dispatcher.bot.getChat(conn).title else: chat_id = update.effective_chat.id if chat.type == "private": return else: chat_name = chat.title if len(words) > 1: text = words[1] to_blacklist = list( set(trigger.strip() for trigger in text.split("\n") if trigger.strip())) for trigger in to_blacklist: sql.add_to_blacklist(chat_id, trigger.lower()) if len(to_blacklist) == 1: send_message( update.effective_message, "Added blacklist <code>{}</code> in chat: <b>{}</b>!".format( html.escape(to_blacklist[0]), chat_name), parse_mode=ParseMode.HTML) else: send_message( update.effective_message, "Added blacklist trigger: <code>{}</code> in <b>{}</b>!". format(len(to_blacklist), chat_name), parse_mode=ParseMode.HTML) else: send_message( update.effective_message, "Tell me which words you would like to add in blacklist.")
def blacklist_mode(bot: Bot, update: Update, args: List[str]): chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] msg = update.effective_message # type: Optional[Message] conn = connected(bot, update, chat, user.id, need_admin=True) if conn: chat = dispatcher.bot.getChat(conn) chat_id = conn chat_name = dispatcher.bot.getChat(conn).title else: if update.effective_message.chat.type == "private": send_message(update.effective_message, "You can do this command in groups, not PM") return "" chat = update.effective_chat chat_id = update.effective_chat.id chat_name = update.effective_message.chat.title if args: if args[0].lower() == 'off' or args[0].lower( ) == 'nothing' or args[0].lower() == 'no': settypeblacklist = 'turn off' sql.set_blacklist_strength(chat_id, 0, "0") elif args[0].lower() == 'del' or args[0].lower() == 'delete': settypeblacklist = 'left, the message will be deleted' sql.set_blacklist_strength(chat_id, 1, "0") elif args[0].lower() == 'warn': settypeblacklist = 'warned' sql.set_blacklist_strength(chat_id, 2, "0") elif args[0].lower() == 'mute': settypeblacklist = 'muted' sql.set_blacklist_strength(chat_id, 3, "0") elif args[0].lower() == 'kick': settypeblacklist = 'kicked' sql.set_blacklist_strength(chat_id, 4, "0") elif args[0].lower() == 'ban': settypeblacklist = 'banned' sql.set_blacklist_strength(chat_id, 5, "0") elif args[0].lower() == 'tban': if len(args) == 1: teks = """It looks like you are trying to set a temporary value to blacklist, but has not determined the time; use `/blstickermode tban <timevalue>`. Examples of time values: 4m = 4 minute, 3h = 3 hours, 6d = 6 days, 5w = 5 weeks.""" send_message(update.effective_message, teks, parse_mode="markdown") return settypeblacklist = 'temporary banned for {}'.format(args[1]) sql.set_blacklist_strength(chat_id, 6, str(args[1])) elif args[0].lower() == 'tmute': if len(args) == 1: teks = """It looks like you are trying to set a temporary value to blacklist, but has not determined the time; use `/blstickermode tmute <timevalue>`. Examples of time values: 4m = 4 minute, 3h = 3 hours, 6d = 6 days, 5w = 5 weeks.""" send_message(update.effective_message, teks, parse_mode="markdown") return settypeblacklist = tl(update.effective_message, 'temporary muted for {}').format(args[1]) sql.set_blacklist_strength(chat_id, 7, str(args[1])) else: send_message( update.effective_message, "I only understand off/del/warn/ban/kick/mute/tban/tmute!") return if conn: text = "Blacklist sticker mode changed, will `{}` at *{}*!".format( settypeblacklist, chat_name) else: text = "Blacklist sticker mode changed, will `{}`!".format( settypeblacklist) send_message(update.effective_message, text, parse_mode="markdown") return "<b>{}:</b>\n" \ "<b>Admin:</b> {}\n" \ "Changed sticker blacklist mode. Will {}.".format(html.escape(chat.title), mention_html(user.id, user.first_name), settypeblacklist) else: getmode, getvalue = sql.get_blacklist_setting(chat.id) if getmode == 0: settypeblacklist = "not active" elif getmode == 1: settypeblacklist = "hapus" elif getmode == 2: settypeblacklist = "warn" elif getmode == 3: settypeblacklist = "mute" elif getmode == 4: settypeblacklist = "kick" elif getmode == 5: settypeblacklist = "ban" elif getmode == 6: settypeblacklist = "temporarily banned for {}".format(getvalue) elif getmode == 7: settypeblacklist = "temporarily muted for {}".format(getvalue) if conn: text = "Blacklist sticker mode is currently set to *{}* in *{}*.".format( settypeblacklist, chat_name) else: text = "Blacklist sticker mode is currently set to *{}*.".format( settypeblacklist) send_message(update.effective_message, text, parse_mode=ParseMode.MARKDOWN) return ""
def del_lockables(update, context): chat = update.effective_chat # type: Optional[Chat] message = update.effective_message # type: Optional[Message] for lockable, filter in LOCK_TYPES.items(): if lockable == "rtl": if sql.is_locked(chat.id, lockable) and can_delete(chat, context.bot.id): if message.caption: check = ad.detect_alphabet(u'{}'.format(message.caption)) if 'ARABIC' in check: try: message.delete() except BadRequest as excp: if excp.message == "Message to delete not found": pass else: LOGGER.exception("ERROR in lockables") if message.text: check = ad.detect_alphabet(u'{}'.format(message.text)) if 'ARABIC' in check: try: message.delete() except BadRequest as excp: if excp.message == "Message to delete not found": pass else: LOGGER.exception("ERROR in lockables") continue if lockable == "button": if sql.is_locked(chat.id, lockable) and can_delete(chat, context.bot.id): if message.reply_markup and message.reply_markup.inline_keyboard: try: message.delete() except BadRequest as excp: if excp.message == "Message to delete not found": pass else: LOGGER.exception("ERROR in lockables") continue if filter(update) and sql.is_locked(chat.id, lockable) and can_delete(chat, context.bot.id): if lockable == "bots": new_members = update.effective_message.new_chat_members for new_mem in new_members: if new_mem.is_bot: if not is_bot_admin(chat, context.bot.id): send_message(update.effective_message, "I see a bot and I've been told to stop them from joining..." "but I'm not admin!") return chat.kick_member(new_mem.id) send_message(update.effective_message, "Only admins are allowed to add bots in this chat! Get outta here.") else: try: message.delete() except BadRequest as excp: if excp.message == "Message to delete not found": pass else: LOGGER.exception("ERROR in lockables") break
def allow_connections(bot: Bot, update: Update, args: List[str]): chat = update.effective_chat if chat.type != chat.PRIVATE: if len(args) >= 1: var = args[0] if var == "no": sql.set_allow_connect_to_chat(chat.id, False) send_message(update.effective_message, "Connection has been disabled for this chat") elif var == "yes": sql.set_allow_connect_to_chat(chat.id, True) send_message(update.effective_message, "Connection has been enabled for this chat") else: send_message(update.effective_message, "Please enter `yes` or `no`!", parse_mode=ParseMode.MARKDOWN) else: get_settings = sql.allow_connect_to_chat(chat.id) if get_settings: send_message( update.effective_message, "Connections to this group are *Allowed* for members!", parse_mode=ParseMode.MARKDOWN) else: send_message( update.effective_message, "Connection to this group are *Not Allowed* for members!", parse_mode=ParseMode.MARKDOWN) else: send_message(update.effective_message, "This command is for group only. Not in PM!")
def private_note(bot: Bot, update: Update, args: List[str]): chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] conn = connected(bot, update, chat, user.id) if conn: chat_id = conn chat_name = dispatcher.bot.getChat(conn).title else: chat_id = update.effective_chat.id if chat.type == "private": chat_name = chat.title else: chat_name = chat.title if len(args) >= 1: if args[0] in ("yes", "on"): if len(args) >= 2: if args[1] == "del": sql.private_note(str(chat_id), True, True) send_message( update.effective_message, "Private Note was *enabled*, when users get notes, the message will be sent to the PM and the hashtag message will be deleted.", parse_mode="markdown") else: sql.private_note(str(chat_id), True, False) send_message( update.effective_message, "Private Note was *enabled*, when users get notes, the message will be sent to the PM.", parse_mode="markdown") else: sql.private_note(str(chat_id), True, False) send_message( update.effective_message, "Private Note was *enabled*, when users get notes, the message will be sent to the PM.", parse_mode="markdown") elif args[0] in ("no", "off"): sql.private_note(str(chat_id), False, False) send_message( update.effective_message, "Private Note was *disabled*, notes will be sent to group.", parse_mode="markdown") else: send_message(update.effective_message, "Unknown argument - please use 'yes', or 'no'.") else: is_private, is_delete = sql.get_private_note(chat_id) print(is_private, is_delete) send_message(update.effective_message, "Current Private Note settings at {}: *{}*{}".format( chat_name, "Enabled" if is_private else "Disabled", " - *Hash will be deleted*" if is_delete else ""), parse_mode="markdown")
def set_flood_mode(update, context): chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] msg = update.effective_message # type: Optional[Message] args = context.args conn = connected(context.bot, update, chat, user.id, need_admin=True) if conn: chat = dispatcher.bot.getChat(conn) chat_id = conn chat_name = dispatcher.bot.getChat(conn).title 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 if args: if args[0].lower() == 'ban': settypeflood = ('ban') sql.set_flood_strength(chat_id, 1, "0") elif args[0].lower() == 'kick': settypeflood = ('kick') sql.set_flood_strength(chat_id, 2, "0") elif args[0].lower() == 'mute': settypeflood = ('mute') sql.set_flood_strength(chat_id, 3, "0") elif args[0].lower() == 'tban': if len(args) == 1: teks = """It looks like you tried to set time value for antiflood but you didn't specified time; Try, `/setfloodmode tban <timevalue>`. Examples of time value: 4m = 4 minutes, 3h = 3 hours, 6d = 6 days, 5w = 5 weeks.""" send_message(update.effective_message, teks, parse_mode="markdown") return settypeflood = ("tban for {}".format(args[1])) sql.set_flood_strength(chat_id, 4, str(args[1])) elif args[0].lower() == 'tmute': if len(args) == 1: teks = """It looks like you tried to set time value for antiflood but you didn't specified time; Try, `/setfloodmode tmute <timevalue>`. Examples of time value: 4m = 4 minutes, 3h = 3 hours, 6d = 6 days, 5w = 5 weeks.""" send_message(update.effective_message, teks, parse_mode="markdown") return settypeflood = ("tmute for {}".format(args[1])) sql.set_flood_strength(chat_id, 5, str(args[1])) else: send_message(update.effective_message, "I only understand ban/kick/mute/tban/tmute!") return if conn: text = msg.reply_text( "Exceeding consecutive flood limit will result in {} in {}!". format(settypeflood, chat_name)) else: text = msg.reply_text( "Exceeding consecutive flood limit will result in {}!".format( settypeflood)) send_message(update.effective_message, text, parse_mode="markdown") return "<b>{}:</b>\n" \ "<b>Admin:</b> {}\n" \ "Has changed antiflood mode. User will {}.".format(settypeflood, html.escape(chat.title), mention_html(user.id, user.first_name)) else: getmode, getvalue = sql.get_flood_setting(chat.id) if getmode == 1: settypeflood = ('ban') elif getmode == 2: settypeflood = ('kick') elif getmode == 3: settypeflood = ('mute') elif getmode == 4: settypeflood = ('tban for {}'.format(getvalue)) elif getmode == 5: settypeflood = ('tmute for {}'.format(getvalue)) if conn: text = msg.reply_text( "Sending more messages than flood limit will result in {} in {}." .format(settypeflood, chat_name)) else: text = msg.reply_text( "Sending more message than flood limit will result in {}.". format(settypeflood)) send_message(update.effective_message, text, parse_mode=ParseMode.MARKDOWN) return ""
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 if is_user_admin(chat, 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.kick_member(user.id) execstrings = ("Banned") tag = "BANNED" elif getmode == 2: chat.kick_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.kick_member(user.id, until_date=bantime) execstrings = ("Banned for {}".format(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 = ("Muted for {}".format(getvalue)) tag = "TMUTE" send_message( update.effective_message, "Great, I like to leave flooding to natural disasters but you, " "you were just a disappointment. {}!".format(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 set_flood(update, context) -> str: chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] message = update.effective_message # type: Optional[Message] args = context.args conn = connected(context.bot, update, chat, user.id, need_admin=True) if conn: chat_id = conn chat_name = dispatcher.bot.getChat(conn).title 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_id = update.effective_chat.id chat_name = update.effective_message.chat.title if len(args) >= 1: val = args[0].lower() if val == "off" or val == "no" or val == "0": sql.set_flood(chat_id, 0) if conn: text = message.reply_text( "Antiflood has been disabled in {}.".format(chat_name)) else: text = message.reply_text("Antiflood has been disabled.") send_message(update.effective_message, text, parse_mode="markdown") elif val.isdigit(): amount = int(val) if amount <= 0: sql.set_flood(chat_id, 0) if conn: text = message.reply_text( "Antiflood has been disabled in {}.".format(chat_name)) else: text = message.reply_text("Antiflood has been disabled.") return "<b>{}:</b>" \ "\n#SETFLOOD" \ "\n<b>Admin:</b> {}" \ "\nDisable antiflood.".format(html.escape(chat_name), mention_html(user.id, user.first_name)) elif amount < 3: send_message( update.effective_message, "Antiflood must be either 0 (disabled) or number greater than 3!" ) return "" else: sql.set_flood(chat_id, amount) if conn: text = message.reply_text( "Anti-flood has been set to {} in chat: {}".format( amount, chat_name)) else: text = message.reply_text( "Successfully updated anti-flood limit to {}!".format( amount)) send_message(update.effective_message, text, parse_mode="markdown") return "<b>{}:</b>" \ "\n#SETFLOOD" \ "\n<b>Admin:</b> {}" \ "\nSet antiflood to <code>{}</code>.".format(html.escape(chat_name), mention_html(user.id, user.first_name), amount) else: message.reply_text( "Invalid argument please use a number, 'off' or 'no'") else: message.reply_text(( "Use `/setflood number` to enable anti-flood.\nOr use `/setflood off` to disable antiflood!." ), parse_mode="markdown") return ""
def unblacklist(update, context): msg = update.effective_message chat = update.effective_chat user = update.effective_user words = msg.text.split(None, 1) conn = connected(context.bot, update, chat, user.id) if conn: chat_id = conn chat_name = dispatcher.bot.getChat(conn).title else: chat_id = update.effective_chat.id if chat.type == "private": return else: chat_name = chat.title if len(words) > 1: text = words[1] to_unblacklist = list( set(trigger.strip() for trigger in text.split("\n") if trigger.strip())) successful = 0 for trigger in to_unblacklist: success = sql.rm_from_blacklist(chat_id, trigger.lower()) if success: successful += 1 if len(to_unblacklist) == 1: if successful: send_message( update.effective_message, "Removed <code>{}</code> from blacklist in <b>{}</b>!". format(html.escape(to_unblacklist[0]), chat_name), parse_mode=ParseMode.HTML) else: send_message(update.effective_message, "This is not a blacklist trigger!") elif successful == len(to_unblacklist): send_message( update.effective_message, "Removed <code>{}</code> from blacklist in <b>{}</b>!".format( successful, chat_name), parse_mode=ParseMode.HTML) elif not successful: send_message( update.effective_message, "None of these triggers exist so it can't be removed.".format( successful, len(to_unblacklist) - successful), parse_mode=ParseMode.HTML) else: send_message( update.effective_message, "Removed <code>{}</code> from blacklist. {} did not exist, " "so were not removed.".format(successful, len(to_unblacklist) - successful), parse_mode=ParseMode.HTML) else: send_message( update.effective_message, "Tell me which words you would like to remove from blacklist!")
def add_blackliststicker(bot: Bot, update: Update): msg = update.effective_message # type: Optional[Message] chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] words = msg.text.split(None, 1) conn = connected(bot, update, chat, user.id) if conn: chat_id = conn chat_name = dispatcher.bot.getChat(conn).title else: chat_id = update.effective_chat.id if chat.type == "private": return else: chat_name = chat.title if len(words) > 1: text = words[1].replace('https://t.me/addstickers/', '') to_blacklist = list( set(trigger.strip() for trigger in text.split("\n") if trigger.strip())) added = 0 for trigger in to_blacklist: try: get = bot.getStickerSet(trigger) sql.add_to_stickers(chat_id, trigger.lower()) added += 1 except BadRequest: send_message(update.effective_message, "Sticker `{}` can not be found!".format(trigger), parse_mode="markdown") if added == 0: return if len(to_blacklist) == 1: send_message( update.effective_message, "Sticker <code>{}</code> added to blacklist stickers in <b>{}</b>!" .format(html.escape(to_blacklist[0]), chat_name), parse_mode=ParseMode.HTML) else: send_message( update.effective_message, "<code>{}</code> stickers added to blacklist sticker in <b>{}</b>!" .format(added, chat_name), parse_mode=ParseMode.HTML) elif msg.reply_to_message: added = 0 trigger = msg.reply_to_message.sticker.set_name if trigger == None: send_message(update.effective_message, "Sticker is invalid!") return try: get = bot.getStickerSet(trigger) sql.add_to_stickers(chat_id, trigger.lower()) added += 1 except BadRequest: send_message(update.effective_message, "Sticker `{}` can not be found!".format(trigger), parse_mode="markdown") if added == 0: return send_message( update.effective_message, "Sticker <code>{}</code> added to blacklist stickers in <b>{}</b>!" .format(trigger, chat_name), parse_mode=ParseMode.HTML) else: send_message( update.effective_message, "Tell me what stickers you want to add to the blacklist stickers.")
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: 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 = ("Unlocked {} messages for everyone in {}!".format(ltype, 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 = ("Unlocked {} messages for everyone!".format(ltype)) 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 = ("Unlocked {} for everyone in {}!".format(ltype, 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 = ("Unlocked {} for everyone!".format(ltype)) 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 ""
def blacklist_mode(update, context): chat = update.effective_chat user = update.effective_user msg = update.effective_message args = context.args conn = connected(context.bot, update, chat, user.id, need_admin=True) if conn: chat = dispatcher.bot.getChat(conn) chat_id = conn chat_name = dispatcher.bot.getChat(conn).title else: if update.effective_message.chat.type == "private": send_message(update.effective_message, "This command can be only used in group not in PM") return "" chat = update.effective_chat chat_id = update.effective_chat.id chat_name = update.effective_message.chat.title if args: if args[0].lower() == 'off' or args[0].lower( ) == 'nothing' or args[0].lower() == 'no': settypeblacklist = ('do nothing') sql.set_blacklist_strength(chat_id, 0, "0") elif args[0].lower() == 'del' or args[0].lower() == 'delete': settypeblacklist = ('will delete blacklisted message') sql.set_blacklist_strength(chat_id, 1, "0") elif args[0].lower() == 'warn': settypeblacklist = ('warn the sender') sql.set_blacklist_strength(chat_id, 2, "0") elif args[0].lower() == 'mute': settypeblacklist = ('mute the sender') sql.set_blacklist_strength(chat_id, 3, "0") elif args[0].lower() == 'kick': settypeblacklist = ('kick the sender') sql.set_blacklist_strength(chat_id, 4, "0") elif args[0].lower() == 'ban': settypeblacklist = ('ban the sender') sql.set_blacklist_strength(chat_id, 5, "0") elif args[0].lower() == 'tban': if len(args) == 1: teks = """It looks like you tried to set time value for blacklist but you didn't specified time; Try, `/blacklistmode tban <timevalue>`. Examples of time value: 4m = 4 minutes, 3h = 3 hours, 6d = 6 days, 5w = 5 weeks.""" send_message(update.effective_message, teks, parse_mode="markdown") return "" restime = extract_time(msg, args[1]) if not restime: teks = """Invalid time value! Example of time value: 4m = 4 minutes, 3h = 3 hours, 6d = 6 days, 5w = 5 weeks.""" send_message(update.effective_message, teks, parse_mode="markdown") return "" settypeblacklist = ('temporarily ban for {}'.format(args[1])) sql.set_blacklist_strength(chat_id, 6, str(args[1])) elif args[0].lower() == 'tmute': if len(args) == 1: teks = """It looks like you tried to set time value for blacklist but you didn't specified time; try, `/blacklistmode tmute <timevalue>`. Examples of time value: 4m = 4 minutes, 3h = 3 hours, 6d = 6 days, 5w = 5 weeks.""" send_message(update.effective_message, teks, parse_mode="markdown") return "" restime = extract_time(msg, args[1]) if not restime: teks = """Invalid time value! Examples of time value: 4m = 4 minutes, 3h = 3 hours, 6d = 6 days, 5w = 5 weeks.""" send_message(update.effective_message, teks, parse_mode="markdown") return "" settypeblacklist = ('temporarily mute for {}'.format(args[1])) sql.set_blacklist_strength(chat_id, 7, str(args[1])) else: send_message( update.effective_message, "I only understand: off/del/warn/ban/kick/mute/tban/tmute!") return "" if conn: text = "Changed blacklist mode: `{}` in *{}*!".format( settypeblacklist, chat_name) else: text = "Changed blacklist mode: `{}`!".format(settypeblacklist) send_message(update.effective_message, text, parse_mode="markdown") return "<b>{}:</b>\n" \ "<b>Admin:</b> {}\n" \ "Changed the blacklist mode. will {}.".format(html.escape(chat.title), mention_html(user.id, user.first_name), settypeblacklist) else: getmode, getvalue = sql.get_blacklist_setting(chat.id) if getmode == 0: settypeblacklist = ("do nothing") elif getmode == 1: settypeblacklist = ("delete") elif getmode == 2: settypeblacklist = ("warn") elif getmode == 3: settypeblacklist = ("mute") elif getmode == 4: settypeblacklist = ("kick") elif getmode == 5: settypeblacklist = ("ban") elif getmode == 6: settypeblacklist = ("temporarily ban for {}".format(getvalue)) elif getmode == 7: settypeblacklist = ("temporarily mute for {}".format(getvalue)) if conn: text = ("Current blacklistmode: *{}* in *{}*.".format( settypeblacklist, chat_name)) else: text = ("Current blacklistmode: *{}*.".format(settypeblacklist)) send_message(update.effective_message, text, parse_mode=ParseMode.MARKDOWN) return ""
def unblackliststicker(bot: Bot, update: Update): msg = update.effective_message # type: Optional[Message] chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] words = msg.text.split(None, 1) conn = connected(bot, update, chat, user.id) if conn: chat_id = conn chat_name = dispatcher.bot.getChat(conn).title else: chat_id = update.effective_chat.id if chat.type == "private": return else: chat_name = chat.title if len(words) > 1: text = words[1].replace('https://t.me/addstickers/', '') to_unblacklist = list( set(trigger.strip() for trigger in text.split("\n") if trigger.strip())) successful = 0 for trigger in to_unblacklist: success = sql.rm_from_stickers(chat_id, trigger.lower()) if success: successful += 1 if len(to_unblacklist) == 1: if successful: send_message( update.effective_message, "Sticker <code>{}</code> deleted from blacklist in <b>{}</b>!" .format(html.escape(to_unblacklist[0]), chat_name), parse_mode=ParseMode.HTML) else: send_message(update.effective_message, "This is not on the blacklist stickers...!") elif successful == len(to_unblacklist): send_message( update.effective_message, "Sticker <code>{}</code> deleted from blacklist in <b>{}</b>!". format(successful, chat_name), parse_mode=ParseMode.HTML) elif not successful: send_message( update.effective_message, "None of these stickers exist, so they cannot be removed.". format(successful, len(to_unblacklist) - successful), parse_mode=ParseMode.HTML) else: send_message( update.effective_message, "Sticker <code>{}</code> deleted from blacklist. {} did not exist, so it's not deleted." .format(successful, len(to_unblacklist) - successful), parse_mode=ParseMode.HTML) elif msg.reply_to_message: trigger = msg.reply_to_message.sticker.set_name if trigger == None: send_message(update.effective_message, "Sticker is invalid!") return success = sql.rm_from_stickers(chat_id, trigger.lower()) if success: send_message( update.effective_message, "Sticker <code>{}</code> deleted from blacklist in <b>{}</b>!". format(trigger, chat_name), parse_mode=ParseMode.HTML) else: send_message( update.effective_message, "{} not found on blacklisted stickers...!".format(trigger)) else: send_message( update.effective_message, "Tell me what stickers you want to add to the blacklist stickers.")
def connect_chat(bot: Bot, update: Update, args: List[str]): chat = update.effective_chat user = update.effective_user spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id) if spam == True: return if update.effective_chat.type == 'private': if len(args) >= 1: try: connect_chat = int(args[0]) getstatusadmin = bot.get_chat_member( connect_chat, update.effective_message.from_user.id) except ValueError: try: connect_chat = str(args[0]) get_chat = bot.getChat(connect_chat) connect_chat = get_chat.id getstatusadmin = bot.get_chat_member( connect_chat, update.effective_message.from_user.id) except BadRequest: send_message(update.effective_message, "Invalid Chat ID!") return except BadRequest: send_message(update.effective_message, "Invalid Chat ID!") return isadmin = getstatusadmin.status in ('administrator', 'creator') ismember = getstatusadmin.status in ('member') isallow = sql.allow_connect_to_chat(connect_chat) if (isadmin) or (isallow and ismember) or ( user.id in SUDO_USERS) or (user.id in DEV_USERS): connection_status = sql.connect( update.effective_message.from_user.id, connect_chat) if connection_status: conn_chat = dispatcher.bot.getChat( connected(bot, update, chat, user.id, need_admin=False)) chat_name = conn_chat.title send_message( update.effective_message, "Successfully connected to *{}*. Use /connection for see current available commands." .format(chat_name), parse_mode=ParseMode.MARKDOWN) sql.add_history_conn(user.id, str(conn_chat.id), chat_name) else: send_message(update.effective_message, "Connection failed!") else: send_message(update.effective_message, "Connection to this chat is not allowed!") else: gethistory = sql.get_history_conn(user.id) if gethistory: buttons = [ InlineKeyboardButton(text="β Close button", callback_data="connect_close"), InlineKeyboardButton(text="π§Ή Clear history", callback_data="connect_clear") ] else: buttons = [] conn = connected(bot, update, chat, user.id, need_admin=False) if conn: connectedchat = dispatcher.bot.getChat(conn) text = "You are connected to *{}* (`{}`)".format( connectedchat.title, conn) buttons.append( InlineKeyboardButton(text="π Disconnect", callback_data="connect_disconnect")) else: text = "Write the chat ID or tag to connect!" if gethistory: text += "\n\n*Connection history:*\n" text += "ββββγ *Info* γ\n" text += "β Sorted: `Newest`\n" text += "β\n" buttons = [buttons] for x in sorted(gethistory.keys(), reverse=True): htime = time.strftime("%d/%m/%Y", time.localtime(x)) text += "ββγ *{}* γ\nβ `{}`\nβ `{}`\n".format( gethistory[x]['chat_name'], gethistory[x]['chat_id'], htime) text += "β\n" buttons.append([ InlineKeyboardButton( text=gethistory[x]['chat_name'], callback_data="connect({})".format( gethistory[x]['chat_id'])) ]) text += "βββγ Total {} Chats γ".format( str(len(gethistory)) + " (max)" if len(gethistory) == 5 else str(len(gethistory))) conn_hist = InlineKeyboardMarkup(buttons) elif buttons: conn_hist = InlineKeyboardMarkup([buttons]) else: conn_hist = None send_message(update.effective_message, text, parse_mode="markdown", reply_markup=conn_hist) else: getstatusadmin = bot.get_chat_member( chat.id, update.effective_message.from_user.id) isadmin = getstatusadmin.status in ('administrator', 'creator') ismember = getstatusadmin.status in ('member') isallow = sql.allow_connect_to_chat(chat.id) if (isadmin) or (isallow and ismember) or (user.id in SUDO_USERS) or ( user.id in DEV_USERS): connection_status = sql.connect( update.effective_message.from_user.id, chat.id) if connection_status: chat_name = dispatcher.bot.getChat(chat.id).title send_message( update.effective_message, "Successfully connected to *{}*.".format(chat_name), parse_mode=ParseMode.MARKDOWN) try: sql.add_history_conn(user.id, str(chat.id), chat_name) bot.send_message( update.effective_message.from_user.id, "You have connected with *{}*. Use /connection for see current available commands." .format(chat_name), parse_mode="markdown") except BadRequest: pass except Unauthorized: pass else: send_message(update.effective_message, "Connection failed!") else: send_message(update.effective_message, "Connection to this chat is not allowed!")
def lock(update, context) -> str: args = context.args chat = update.effective_chat user = update.effective_user if can_delete(chat, context.bot.id) or update.effective_message.chat.type == "private": if len(args) >= 1: 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 = ("Locked all {} messages for non-admins in {}!".format(ltype, 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 = ("Locked all {} messages for non-admins!".format(ltype)) sql.update_lock(chat.id, ltype, locked=True) send_message(update.effective_message, text, parse_mode="markdown") return "<b>{}:</b>" \ "\n#LOCK" \ "\n<b>Admin:</b> {}" \ "\nLocked <code>{}</code>.".format(html.escape(chat.title), mention_html(user.id, user.first_name), ltype) elif ltype in LOCK_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 = ("Locked {} for all non-admins in {}!".format(ltype, 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 = ("Locked {} for all non-admins!".format(ltype)) 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)), LOCK_CHAT_RESTRICTION[ltype.lower()])) send_message(update.effective_message, text, parse_mode="markdown") return "<b>{}:</b>" \ "\n#Permission_LOCK" \ "\n<b>Admin:</b> {}" \ "\nLocked <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 lock...? Try /locktypes for the list of lockables") else: send_message(update.effective_message, "What are you trying to lock...?") else: send_message(update.effective_message, "I am not administrator or haven't got enough rights.") return ""