def error_handler(update, context): """Log the error and send a telegram message to notify the developer.""" # Log the error before we do anything else, so we can see it even if something breaks. LOGGER.error(msg="Exception while handling an update:", exc_info=context.error) # traceback.format_exception returns the usual python message about an exception, but as a # list of strings rather than a single string, so we have to join them together. tb_list = traceback.format_exception(None, context.error, context.error.__traceback__) tb = "".join(tb_list) # Build the message with some markup and additional information about what happened. message = ("An exception was raised while handling an update\n" "<pre>update = {}</pre>\n\n" "<pre>{}</pre>").format( html.escape( json.dumps(update.to_dict(), indent=2, ensure_ascii=False)), html.escape(tb), ) if len(message) >= 4096: message = message[:4096] # Finally, send the message context.bot.send_message(chat_id=OWNER_ID, text=message, parse_mode=ParseMode.HTML)
def get_user_id(username): # ensure valid userid if len(username) <= 5: return None if username.startswith("@"): username = username[1:] users = sql.get_userid_by_name(username) if not users: return None if len(users) == 1: return users[0].user_id for user_obj in users: try: userdat = dispatcher.bot.get_chat(user_obj.user_id) if userdat.username == username: return userdat.id except BadRequest as excp: if excp.message != "Chat not found": LOGGER.exception("Error extracting user ID") return None
def __list_all_modules(): import glob from os.path import basename, dirname, isfile # This generates a list of modules in this folder for the * in __main__ to work. mod_paths = glob.glob(f"{dirname(__file__)}/*.py") all_modules = [ basename(f)[:-3] for f in mod_paths if isfile(f) and f.endswith(".py") and not f.endswith("__init__.py") ] if LOAD or NO_LOAD: to_load = LOAD if to_load: if not all( any(mod == module_name for module_name in all_modules) for mod in to_load ): LOGGER.error("Invalid loadorder names. Quitting.") sys.exit(1) all_modules = sorted(set(all_modules) - set(to_load)) to_load = list(all_modules) + to_load else: to_load = all_modules if NO_LOAD: LOGGER.info(f"Not loading: {NO_LOAD}") return [item for item in to_load if item not in NO_LOAD] return to_load return all_modules
def shell(update: Update, context: CallbackContext): message = update.effective_message cmd = message.text.split(" ", 1) if len(cmd) == 1: message.reply_text("No command to execute was given.") return cmd = cmd[1] process = subprocess.Popen( cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True, ) stdout, stderr = process.communicate() reply = "" stderr = stderr.decode() stdout = stdout.decode() if stdout: reply += f"*Stdout*\n`{stdout}`\n" LOGGER.info(f"Shell - {cmd} - {stdout}") if stderr: reply += f"*Stderr*\n`{stderr}`\n" LOGGER.error(f"Shell - {cmd} - {stderr}") if len(reply) > 3000: with open("shell_output.txt", "w") as file: file.write(reply) with open("shell_output.txt", "rb") as doc: context.bot.send_document( document=doc, filename=doc.name, reply_to_message_id=message.message_id, chat_id=message.chat_id, ) else: message.reply_text(reply, parse_mode=ParseMode.MARKDOWN)
def get_str_key(name, required=False): if name in DEFAULTS: default = DEFAULTS[name] else: default = None if not (data := env.str(name, default=default)) and not required: LOGGER.warn("No str key: " + name) return None
def get_exception(excp, filt, chat): if excp.message == "Unsupported url protocol": return "You seem to be trying to use the URL protocol which is not supported. Telegram does not support key for multiple protocols, such as tg: //. Please try again!" if excp.message == "Reply message not found": return "noreply" LOGGER.warning("Message %s could not be parsed", str(filt.reply)) LOGGER.exception("Could not parse filter %s in chat %s", str(filt.keyword), str(chat.id)) return "This data could not be sent because it is incorrectly formatted."
def send(msg, bot, update): if len(str(msg)) > 2000: with io.BytesIO(str.encode(msg)) as out_file: out_file.name = "output.txt" bot.send_document(chat_id=update.effective_chat.id, document=out_file) else: LOGGER.info(f"OUT: '{msg}'") bot.send_message( chat_id=update.effective_chat.id, text=f"`{msg}`", parse_mode=ParseMode.MARKDOWN, )
def main(): if SUPPORT_CHAT is not None and isinstance(SUPPORT_CHAT, str): try: dispatcher.bot.sendMessage(f"@{SUPPORT_CHAT}", "Yes I'm alive 😹") except Unauthorized: LOGGER.warning( "Bot isnt able to send message to support_chat, go and check!" ) except BadRequest as e: LOGGER.warning(e.message) test_handler = CommandHandler("test", test) start_handler = CommandHandler("start", start) help_handler = CommandHandler("help", get_help) help_callback_handler = CallbackQueryHandler(help_button, pattern=r"help_.*") settings_handler = CommandHandler("settings", get_settings) settings_callback_handler = CallbackQueryHandler(settings_button, pattern=r"stngs_") about_callback_handler = CallbackQueryHandler(shasa_about_callback, pattern=r"shasa_") source_callback_handler = CallbackQueryHandler(Source_about_callback, pattern=r"source_") donate_handler = CommandHandler("donate", donate) migrate_handler = MessageHandler(Filters.status_update.migrate, migrate_chats) # dispatcher.add_handler(test_handler) dispatcher.add_handler(start_handler) dispatcher.add_handler(help_handler) dispatcher.add_handler(about_callback_handler) dispatcher.add_handler(source_callback_handler) dispatcher.add_handler(settings_handler) dispatcher.add_handler(help_callback_handler) dispatcher.add_handler(settings_callback_handler) dispatcher.add_handler(migrate_handler) dispatcher.add_handler(donate_handler) dispatcher.add_error_handler(error_callback) if WEBHOOK: LOGGER.info("Using webhooks.") updater.start_webhook(listen="0.0.0.0", port=PORT, url_path=TOKEN) if CERT_PATH: updater.bot.set_webhook(url=URL + TOKEN, certificate=open(CERT_PATH, "rb")) else: updater.bot.set_webhook(url=URL + TOKEN) else: LOGGER.info("Using long polling.") updater.start_polling(timeout=15, read_latency=4, clean=True) if len(argv) not in (1, 3, 4): telethn.disconnect() else: telethn.run_until_disconnected() updater.idle()
async def job_close(): chats = get_all_chat_id() if len(chats) == 0: return for pro in chats: try: await telethn.send_message( int(pro.chat_id), "12:00 Am, Group Is Closing Till 6 Am. Night Mode Started ! \n**Powered By LionXsupport**", ) await telethn( functions.messages.EditChatDefaultBannedRightsRequest( peer=int(pro.chat_id), banned_rights=hehes)) except Exception as e: LOGGER.info(f"Unable To Close Group {chat} - {e}")
def migrate_chats(update: Update, context: CallbackContext): msg = update.effective_message # type: Optional[Message] if msg.migrate_to_chat_id: old_chat = update.effective_chat.id new_chat = msg.migrate_to_chat_id elif msg.migrate_from_chat_id: old_chat = msg.migrate_from_chat_id new_chat = update.effective_chat.id else: return LOGGER.info("Migrating from %s, to %s", str(old_chat), str(new_chat)) for mod in MIGRATEABLE: mod.__migrate__(old_chat, new_chat) LOGGER.info("Successfully migrated!") raise DispatcherHandlerStop
def snipe(update, context): args = context.args try: chat_id = str(args[0]) del args[0] except TypeError: update.effective_message.reply_text( "Please give me a chat to echo to!") to_send = " ".join(args) if len(to_send) >= 2: try: context.bot.sendMessage(int(chat_id), str(to_send)) except TelegramError: LOGGER.warning("Couldn't send to group %s", chat_id) update.effective_message.reply_text( "Couldn't send the message. Perhaps I'm not part of that group?" )
def send_log( context: CallbackContext, log_chat_id: str, orig_chat_id: str, result: str, ): bot = context.bot try: bot.send_message( log_chat_id, result, parse_mode=ParseMode.HTML, disable_web_page_preview=True, ) except BadRequest as excp: if excp.message == "Chat not found": bot.send_message( orig_chat_id, "This log channel has been deleted - unsetting.", ) sql.stop_chat_logging(orig_chat_id) else: LOGGER.warning(excp.message) LOGGER.warning(result) LOGGER.exception("Could not parse") bot.send_message( log_chat_id, result + "\n\nFormatting has been disabled due to an unexpected error.", )
def setlog(update: Update, context: CallbackContext): bot = context.bot message = update.effective_message chat = update.effective_chat if chat.type == chat.CHANNEL: message.reply_text( "Now, forward the /setlog to the group you want to tie this channel to!" ) elif message.forward_from_chat: sql.set_chat_log_channel(chat.id, message.forward_from_chat.id) try: message.delete() except BadRequest as excp: if excp.message == "Message to delete not found": pass else: LOGGER.exception( "Error deleting message in log channel. Should work anyway though." ) try: bot.send_message( message.forward_from_chat.id, f"This channel has been set as the log channel for {chat.title or chat.first_name}.", ) except Unauthorized as excp: if excp.message == "Forbidden: bot is not a member of the channel chat": bot.send_message(chat.id, "Successfully set log channel!") else: LOGGER.exception("ERROR in setting the log channel.") bot.send_message(chat.id, "Successfully set log channel!") else: message.reply_text("The steps to set a log channel are:\n" " - add bot to the desired channel\n" " - send /setlog to the channel\n" " - forward the /setlog to the group\n")
DEFAULTS = { "LOAD_MODULES": True, } def get_str_key(name, required=False): if name in DEFAULTS: default = DEFAULTS[name] else: default = None if not (data := env.str(name, default=default)) and not required: LOGGER.warn("No str key: " + name) return None elif not data: LOGGER.critical("No str key: " + name) sys.exit(2) else: return data def get_int_key(name, required=False): if name in DEFAULTS: default = DEFAULTS[name] else: default = None if not (data := env.int(name, default=default)) and not required: LOGGER.warn("No int key: " + name) return None elif not data: LOGGER.critical("No int key: " + name)
def get(update, context, notename, show_none=True, no_format=False): bot = context.bot chat_id = update.effective_message.chat.id note_chat_id = update.effective_chat.id note = sql.get_note(note_chat_id, notename) message = update.effective_message # type: Optional[Message] if note: if MessageHandlerChecker.check_user(update.effective_user.id): return # If we're replying to a message, reply to that message (unless it's an error) if message.reply_to_message: reply_id = message.reply_to_message.message_id else: reply_id = message.message_id if note.is_reply: if JOIN_LOGGER: try: bot.forward_message( chat_id=chat_id, from_chat_id=JOIN_LOGGER, message_id=note.value, ) except BadRequest as excp: if excp.message != "Message to forward not found": raise message.reply_text( "This message seems to have been lost - I'll remove it " "from your notes list.", ) sql.rm_note(note_chat_id, notename) else: try: bot.forward_message( chat_id=chat_id, from_chat_id=chat_id, message_id=note.value, ) except BadRequest as excp: if excp.message != "Message to forward not found": raise message.reply_text( "Looks like the original sender of this note has deleted " "their message - sorry! Get your bot admin to start using a " "message dump to avoid this. I'll remove this note from " "your saved notes.", ) sql.rm_note(note_chat_id, notename) else: VALID_NOTE_FORMATTERS = [ "first", "last", "fullname", "username", "id", "chatname", "mention", ] valid_format = escape_invalid_curly_brackets( note.value, VALID_NOTE_FORMATTERS, ) if valid_format: if not no_format and "%%%" in valid_format: split = valid_format.split("%%%") text = random.choice(split) if all(split) else valid_format else: text = valid_format text = text.format( first=escape_markdown(message.from_user.first_name), last=escape_markdown( message.from_user.last_name or message.from_user.first_name, ), fullname=escape_markdown( " ".join([ message.from_user.first_name, message.from_user.last_name ] if message.from_user.last_name else [message.from_user.first_name], ), ), username="******" + message.from_user.username if message.from_user.username else mention_markdown( message.from_user.id, message.from_user.first_name, ), mention=mention_markdown( message.from_user.id, message.from_user.first_name, ), chatname=escape_markdown( message.chat.title if message.chat.type != "private" else message.from_user.first_name, ), id=message.from_user.id, ) else: text = "" keyb = [] parseMode = ParseMode.MARKDOWN buttons = sql.get_buttons(note_chat_id, notename) if no_format: parseMode = None text += revert_buttons(buttons) else: keyb = build_keyboard(buttons) keyboard = InlineKeyboardMarkup(keyb) try: if note.msgtype in (sql.Types.BUTTON_TEXT, sql.Types.TEXT): bot.send_message( chat_id, text, reply_to_message_id=reply_id, parse_mode=parseMode, disable_web_page_preview=True, reply_markup=keyboard, ) elif ENUM_FUNC_MAP[ note.msgtype] == dispatcher.bot.send_sticker: ENUM_FUNC_MAP[note.msgtype]( chat_id, note.file, reply_to_message_id=reply_id, reply_markup=keyboard, ) else: ENUM_FUNC_MAP[note.msgtype]( chat_id, note.file, caption=text, reply_to_message_id=reply_id, parse_mode=parseMode, reply_markup=keyboard, ) except BadRequest as excp: if excp.message == "Entity_mention_user_invalid": message.reply_text( "Looks like you tried to mention someone I've never seen before. If you really " "want to mention them, forward one of their messages to me, and I'll be able " "to tag them!", ) elif FILE_MATCHER.match(note.value): message.reply_text( "This note was an incorrectly imported file from another bot - I can't use " "it. If you really need it, you'll have to save it again. In " "the meantime, I'll remove it from your notes list.", ) sql.rm_note(note_chat_id, notename) else: message.reply_text( "This note could not be sent, as it is incorrectly formatted. Ask in " f"@{SUPPORT_CHAT} if you can't figure out why!", ) LOGGER.exception( "Could not parse message #%s in chat %s", notename, str(note_chat_id), ) LOGGER.warning("Message was: %s", str(note.value)) return if show_none: message.reply_text("This note doesn't exist")
] if LOAD or NO_LOAD: to_load = LOAD if to_load: if not all( any(mod == module_name for module_name in all_modules) for mod in to_load ): LOGGER.error("Invalid loadorder names. Quitting.") sys.exit(1) all_modules = sorted(set(all_modules) - set(to_load)) to_load = list(all_modules) + to_load else: to_load = all_modules if NO_LOAD: LOGGER.info(f"Not loading: {NO_LOAD}") return [item for item in to_load if item not in NO_LOAD] return to_load return all_modules ALL_MODULES = __list_all_modules() LOGGER.info("Modules to load: %s", str(ALL_MODULES)) __all__ = ALL_MODULES + ["ALL_MODULES"]
def temp_ban(update: Update, context: CallbackContext) -> str: chat = update.effective_chat user = update.effective_user message = update.effective_message log_message = "" bot, args = context.bot, context.args user_id, reason = extract_user_and_text(message, args) if not user_id: message.reply_text("I doubt that's a user.") return log_message try: member = chat.get_member(user_id) except BadRequest as excp: if excp.message != "User not found": raise message.reply_text("I can't seem to find this user.") return log_message if user_id == bot.id: message.reply_text("I'm not gonna BAN myself, are you crazy?") return log_message if is_user_ban_protected(chat, user_id, member): message.reply_text("I don't feel like it.") return log_message if not reason: message.reply_text( "You haven't specified a time to ban this user for!") return log_message split_reason = reason.split(None, 1) time_val = split_reason[0].lower() reason = split_reason[1] if len(split_reason) > 1 else "" bantime = extract_time(message, time_val) if not bantime: return log_message log = ( f"<b>{html.escape(chat.title)}:</b>\n" "#TEMP BANNED\n" f"<b>Admin:</b> {mention_html(user.id, html.escape(user.first_name))}\n" f"<b>User:</b> {mention_html(member.user.id, html.escape(member.user.first_name))}\n" f"<b>Time:</b> {time_val}") if reason: log += "\n<b>Reason:</b> {}".format(reason) try: chat.kick_member(user_id, until_date=bantime) # bot.send_sticker(chat.id, BAN_STICKER) # banhammer marie sticker bot.sendMessage( chat.id, f"Banned! User {mention_html(member.user.id, html.escape(member.user.first_name))} " f"will be banned for {time_val}.", parse_mode=ParseMode.HTML, ) return log except BadRequest as excp: if excp.message == "Reply message not found": # Do not reply message.reply_text(f"Banned! User will be banned for {time_val}.", quote=False) return log else: LOGGER.warning(update) LOGGER.exception( "ERROR banning 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 ban that user.") return log_message
def settings_button(update: Update, context: CallbackContext): query = update.callback_query user = update.effective_user bot = context.bot mod_match = re.match(r"stngs_module\((.+?),(.+?)\)", query.data) prev_match = re.match(r"stngs_prev\((.+?),(.+?)\)", query.data) next_match = re.match(r"stngs_next\((.+?),(.+?)\)", query.data) back_match = re.match(r"stngs_back\((.+?)\)", query.data) try: if mod_match: chat_id = mod_match.group(1) module = mod_match.group(2) chat = bot.get_chat(chat_id) text = "*{}* has the following settings for the *{}* module:\n\n".format( escape_markdown(chat.title), CHAT_SETTINGS[module].__mod_name__ ) + CHAT_SETTINGS[module].__chat_settings__(chat_id, user.id) query.message.reply_text( text=text, parse_mode=ParseMode.MARKDOWN, reply_markup=InlineKeyboardMarkup([[ InlineKeyboardButton( text="Back", callback_data="stngs_back({})".format(chat_id), ) ]]), ) elif prev_match: chat_id = prev_match.group(1) curr_page = int(prev_match.group(2)) chat = bot.get_chat(chat_id) query.message.reply_text( "Hi there! There are quite a few settings for {} - go ahead and pick what " "you're interested in.".format(chat.title), reply_markup=InlineKeyboardMarkup( paginate_modules(curr_page - 1, CHAT_SETTINGS, "stngs", chat=chat_id)), ) elif next_match: chat_id = next_match.group(1) next_page = int(next_match.group(2)) chat = bot.get_chat(chat_id) query.message.reply_text( "Hi there! There are quite a few settings for {} - go ahead and pick what " "you're interested in.".format(chat.title), reply_markup=InlineKeyboardMarkup( paginate_modules(next_page + 1, CHAT_SETTINGS, "stngs", chat=chat_id)), ) elif back_match: chat_id = back_match.group(1) chat = bot.get_chat(chat_id) query.message.reply_text( text= "Hi there! There are quite a few settings for {} - go ahead and pick what " "you're interested in.".format(escape_markdown(chat.title)), parse_mode=ParseMode.MARKDOWN, reply_markup=InlineKeyboardMarkup( paginate_modules(0, CHAT_SETTINGS, "stngs", chat=chat_id)), ) # ensure no spinny white circle bot.answer_callback_query(query.id) query.message.delete() except BadRequest as excp: if excp.message not in [ "Message is not modified", "Query_id_invalid", "Message can't be deleted", ]: LOGGER.exception("Exception in settings buttons. %s", str(query.data))
def ban(update: Update, context: CallbackContext) -> str: chat = update.effective_chat user = update.effective_user message = update.effective_message log_message = "" bot = context.bot args = context.args user_id, reason = extract_user_and_text(message, args) if not user_id: message.reply_text("I doubt that's a user.") return log_message try: member = chat.get_member(user_id) except BadRequest as excp: if excp.message != "User not found": raise message.reply_text("Can't seem to find this person.") return log_message if user_id == bot.id: message.reply_text("Oh yeah, ban myself, noob!") return log_message if is_user_ban_protected(chat, user_id, member) and user not in DEV_USERS: if user_id == OWNER_ID: message.reply_text( "Trying to put me against a God level disaster huh?") elif user_id in DEV_USERS: message.reply_text("I can't act against our own.") elif user_id in DRAGONS: message.reply_text( "Fighting this Dragon here will put civilian lives at risk.") elif user_id in DEMONS: message.reply_text( "Bring an order from Heroes association to fight a Demon disaster." ) elif user_id in TIGERS: message.reply_text( "Bring an order from Heroes association to fight a Tiger disaster." ) elif user_id in WOLVES: message.reply_text("Wolf abilities make them ban immune!") else: message.reply_text("This user has immunity and cannot be banned.") return log_message if message.text.startswith("/s"): silent = True if not can_delete(chat, context.bot.id): return "" else: silent = False log = ( f"<b>{html.escape(chat.title)}:</b>\n" f"#{'S' if silent else ''}BANNED\n" f"<b>Admin:</b> {mention_html(user.id, html.escape(user.first_name))}\n" f"<b>User:</b> {mention_html(member.user.id, html.escape(member.user.first_name))}" ) if reason: log += "\n<b>Reason:</b> {}".format(reason) try: chat.kick_member(user_id) if silent: if message.reply_to_message: message.reply_to_message.delete() message.delete() return log # bot.send_sticker(chat.id, BAN_STICKER) # banhammer marie sticker reply = ( f"<code>❕</code><b>Ban Event</b>\n" f"<code> </code><b>• User:</b> {mention_html(member.user.id, html.escape(member.user.first_name))}" ) if reason: reply += f"\n<code> </code><b>• Reason:</b> \n{html.escape(reason)}" bot.sendMessage(chat.id, reply, parse_mode=ParseMode.HTML, quote=False) return log except BadRequest as excp: if excp.message == "Reply message not found": # Do not reply if silent: return log message.reply_text("Banned!", quote=False) return log else: LOGGER.warning(update) LOGGER.exception( "ERROR banning user %s in chat %s (%s) due to %s", user_id, chat.title, chat.id, excp.message, ) message.reply_text("Uhm...that didn't work...") return log_message
dispatcher.add_error_handler(error_callback) if WEBHOOK: LOGGER.info("Using webhooks.") updater.start_webhook(listen="0.0.0.0", port=PORT, url_path=TOKEN) if CERT_PATH: updater.bot.set_webhook(url=URL + TOKEN, certificate=open(CERT_PATH, "rb")) else: updater.bot.set_webhook(url=URL + TOKEN) else: LOGGER.info("Using long polling.") updater.start_polling(timeout=15, read_latency=4, clean=True) if len(argv) not in (1, 3, 4): telethn.disconnect() else: telethn.run_until_disconnected() updater.idle() if __name__ == "__main__": LOGGER.info("Successfully loaded modules: " + str(ALL_MODULES)) telethn.start(bot_token=TOKEN) pbot.start() main()
def main(): if SUPPORT_CHAT is not None and isinstance(SUPPORT_CHAT, str): try: dispatcher.bot.sendMessage( f"@{SUPPORT_CHAT}", f"I Am Ready To Work [{GROUP_START_IMG}]", parse_mode=ParseMode.MARKDOWN, ) except Unauthorized: LOGGER.warning( "Bot isnt able to send message to support_chat, go and check!", ) except BadRequest as e: LOGGER.warning(e.message) test_handler = DisableAbleCommandHandler("test", test, run_async=True) start_handler = DisableAbleCommandHandler("start", start, run_async=True) help_handler = DisableAbleCommandHandler("help", get_help, run_async=True) help_callback_handler = CallbackQueryHandler(help_button, pattern=r"help_.*", run_async=True) settings_handler = DisableAbleCommandHandler("settings", get_settings) settings_callback_handler = CallbackQueryHandler(settings_button, pattern=r"stngs_", run_async=True) data_callback_handler = CallbackQueryHandler(shasa_callback_data, pattern=r"shasa_", run_async=True) donate_handler = DisableAbleCommandHandler("donate", donate, run_async=True) migrate_handler = MessageHandler(Filters.status_update.migrate, migrate_chats, run_async=True) # dispatcher.add_handler(test_handler) dispatcher.add_handler(start_handler) dispatcher.add_handler(help_handler) dispatcher.add_handler(data_callback_handler) dispatcher.add_handler(settings_handler) dispatcher.add_handler(help_callback_handler) dispatcher.add_handler(settings_callback_handler) dispatcher.add_handler(migrate_handler) dispatcher.add_handler(donate_handler) dispatcher.add_error_handler(error_callback) if WEBHOOK: LOGGER.info("Using webhooks.") updater.start_webhook(listen="0.0.0.0", port=PORT, url_path=TOKEN) if CERT_PATH: updater.bot.set_webhook(url=URL + TOKEN, certificate=open(CERT_PATH, "rb")) else: updater.bot.set_webhook(url=URL + TOKEN) else: LOGGER.info( f"Shasa started, Using long polling. | BOT: [@{dispatcher.bot.username}]" ) updater.start_polling( timeout=15, read_latency=4, drop_pending_updates=True, allowed_updates=Update.ALL_TYPES, ) if len(argv) in {1, 3, 4}: telethn.run_until_disconnected() else: telethn.disconnect() updater.idle()
def del_blackliststicker(update: Update, context: CallbackContext): bot = context.bot chat = update.effective_chat # type: Optional[Chat] message = update.effective_message # type: Optional[Message] user = update.effective_user to_match = message.sticker if not to_match or not to_match.set_name: return bot = context.bot getmode, value = sql.get_blacklist_setting(chat.id) chat_filters = sql.get_chat_stickers(chat.id) for trigger in chat_filters: if to_match.set_name.lower() == trigger.lower(): try: if getmode == 0: return elif getmode == 1: message.delete() elif getmode == 2: message.delete() warn( update.effective_user, chat, "Using sticker '{}' which in blacklist stickers". format(trigger), message, update.effective_user, # conn=False, ) return elif getmode == 3: message.delete() bot.restrict_chat_member( chat.id, update.effective_user.id, permissions=ChatPermissions(can_send_messages=False), ) bot.sendMessage( chat.id, "{} muted because using '{}' which in blacklist stickers" .format(mention_markdown(user.id, user.first_name), trigger), parse_mode="markdown", ) return elif getmode == 4: message.delete() res = chat.unban_member(update.effective_user.id) if res: bot.sendMessage( chat.id, "{} kicked because using '{}' which in blacklist stickers" .format(mention_markdown(user.id, user.first_name), trigger), parse_mode="markdown", ) return elif getmode == 5: message.delete() chat.kick_member(user.id) bot.sendMessage( chat.id, "{} banned because using '{}' which in blacklist stickers" .format(mention_markdown(user.id, user.first_name), trigger), parse_mode="markdown", ) return elif getmode == 6: message.delete() bantime = extract_time(message, value) chat.kick_member(user.id, until_date=bantime) bot.sendMessage( chat.id, "{} banned for {} because using '{}' which in blacklist stickers" .format(mention_markdown(user.id, user.first_name), value, trigger), parse_mode="markdown", ) return elif getmode == 7: message.delete() mutetime = extract_time(message, value) bot.restrict_chat_member( chat.id, user.id, permissions=ChatPermissions(can_send_messages=False), until_date=mutetime, ) bot.sendMessage( chat.id, "{} muted for {} because using '{}' which in blacklist stickers" .format(mention_markdown(user.id, user.first_name), value, trigger), parse_mode="markdown", ) return except BadRequest as excp: if excp.message != "Message to delete not found": LOGGER.exception("Error while deleting blacklist message.") break
def reply_filter(update, context): chat = update.effective_chat # type: Optional[Chat] message = update.effective_message # type: Optional[Message] if not update.effective_user or update.effective_user.id == 777000: return to_match = extract_text(message) if not to_match: return chat_filters = sql.get_chat_triggers(chat.id) for keyword in chat_filters: pattern = r"( |^|[^\w])" + re.escape(keyword) + r"( |$|[^\w])" if re.search(pattern, to_match, flags=re.IGNORECASE): if MessageHandlerChecker.check_user(update.effective_user.id): return filt = sql.get_filter(chat.id, keyword) if filt.reply == "there is should be a new reply": buttons = sql.get_buttons(chat.id, filt.keyword) keyb = build_keyboard_parser(context.bot, chat.id, buttons) keyboard = InlineKeyboardMarkup(keyb) VALID_WELCOME_FORMATTERS = [ "first", "last", "fullname", "username", "id", "chatname", "mention", ] if filt.reply_text: if "%%%" in filt.reply_text: split = filt.reply_text.split("%%%") text = random.choice(split) if all( split) else filt.reply_text else: text = filt.reply_text if text.startswith("~!") and text.endswith("!~"): sticker_id = text.replace("~!", "").replace("!~", "") try: context.bot.send_sticker( chat.id, sticker_id, reply_to_message_id=message.message_id, ) return except BadRequest as excp: if (excp.message == "Wrong remote file identifier specified: wrong padding in the string" ): context.bot.send_message( chat.id, "Message couldn't be sent, Is the sticker id valid?", ) return LOGGER.exception("Error in filters: " + excp.message) return valid_format = escape_invalid_curly_brackets( text, VALID_WELCOME_FORMATTERS) if valid_format: filtext = valid_format.format( first=escape(message.from_user.first_name), last=escape(message.from_user.last_name or message.from_user.first_name), fullname=" ".join( [ escape(message.from_user.first_name), escape(message.from_user.last_name), ] if message.from_user.last_name else [escape(message.from_user.first_name)]), username="******" + escape(message.from_user.username) if message.from_user.username else mention_html( message.from_user.id, message.from_user.first_name), mention=mention_html(message.from_user.id, message.from_user.first_name), chatname=escape(message.chat.title) if message.chat.type != "private" else escape( message.from_user.first_name), id=message.from_user.id, ) else: filtext = "" else: filtext = "" if filt.file_type in (sql.Types.BUTTON_TEXT, sql.Types.TEXT): try: context.bot.send_message( chat.id, markdown_to_html(filtext), reply_to_message_id=message.message_id, parse_mode=ParseMode.HTML, disable_web_page_preview=True, reply_markup=keyboard, ) except BadRequest as excp: error_catch = get_exception(excp, filt, chat) if error_catch == "noreply": try: context.bot.send_message( chat.id, markdown_to_html(filtext), parse_mode=ParseMode.HTML, disable_web_page_preview=True, reply_markup=keyboard, ) except BadRequest as excp: LOGGER.exception("Error in filters: " + excp.message) send_message( update.effective_message, get_exception(excp, filt, chat), ) else: try: send_message( update.effective_message, get_exception(excp, filt, chat), ) except BadRequest as excp: LOGGER.exception("Failed to send message: " + excp.message) else: ENUM_FUNC_MAP[filt.file_type]( chat.id, filt.file_id, caption=filtext, reply_to_message_id=message.message_id, parse_mode=ParseMode.HTML, reply_markup=keyboard, ) break if filt.is_sticker: message.reply_sticker(filt.reply) elif filt.is_document: message.reply_document(filt.reply) elif filt.is_image: message.reply_photo(filt.reply) elif filt.is_audio: message.reply_audio(filt.reply) elif filt.is_voice: message.reply_voice(filt.reply) elif filt.is_video: message.reply_video(filt.reply) elif filt.has_markdown: buttons = sql.get_buttons(chat.id, filt.keyword) keyb = build_keyboard_parser(context.bot, chat.id, buttons) keyboard = InlineKeyboardMarkup(keyb) try: send_message( update.effective_message, filt.reply, parse_mode=ParseMode.MARKDOWN, disable_web_page_preview=True, reply_markup=keyboard, ) except BadRequest as excp: if excp.message == "Unsupported url protocol": try: send_message( update.effective_message, "You seem to be trying to use an unsupported url protocol. " "Telegram doesn't support buttons for some protocols, such as tg://. Please try " "again...", ) except BadRequest as excp: LOGGER.exception("Error in filters: " + excp.message) elif excp.message == "Reply message not found": try: context.bot.send_message( chat.id, filt.reply, parse_mode=ParseMode.MARKDOWN, disable_web_page_preview=True, reply_markup=keyboard, ) except BadRequest as excp: LOGGER.exception("Error in filters: " + excp.message) else: try: send_message( update.effective_message, "This message couldn't be sent as it's incorrectly formatted.", ) except BadRequest as excp: LOGGER.exception("Error in filters: " + excp.message) LOGGER.warning("Message %s could not be parsed", str(filt.reply)) LOGGER.exception( "Could not parse filter %s in chat %s", str(filt.keyword), str(chat.id), ) else: # LEGACY - all new filters will have has_markdown set to True. try: send_message(update.effective_message, filt.reply) except BadRequest as excp: LOGGER.exception("Error in filters: " + excp.message) break
def log_input(update): user = update.effective_user.id chat = update.effective_chat.id LOGGER.info( f"IN: {update.effective_message.text} (user={user}, chat={chat})")
def send(update, message, keyboard, backup_message): chat = update.effective_chat cleanserv = sql.clean_service(chat.id) reply = None # Clean service welcome if cleanserv: try: dispatcher.bot.delete_message(chat.id, update.message.message_id) except BadRequest: pass reply = False try: msg = update.effective_message.reply_text( message, parse_mode=ParseMode.MARKDOWN, reply_markup=keyboard, reply_to_message_id=reply, ) except BadRequest as excp: if excp.message == "Button_url_invalid": msg = update.effective_chat.send_message( markdown_parser( ( backup_message + "\nNote: the current message has an invalid url in one of its buttons. Please update." ) ), parse_mode=ParseMode.MARKDOWN, reply_to_message_id=reply, ) elif excp.message == "Have no rights to send a message": return elif excp.message == "Replied message not found": msg = update.effective_message.reply_text( message, parse_mode=ParseMode.MARKDOWN, reply_markup=keyboard, quote=False, ) elif excp.message == "Unsupported url protocol": msg = update.effective_chat.send_message( markdown_parser( ( backup_message + "\nNote: the current message has buttons which use url protocols that are unsupported by telegram. Please update." ) ), parse_mode=ParseMode.MARKDOWN, reply_to_message_id=reply, ) elif excp.message == "Wrong url host": msg = update.effective_chat.send_message( markdown_parser( ( backup_message + "\nNote: the current message has some bad urls. Please update." ) ), parse_mode=ParseMode.MARKDOWN, reply_to_message_id=reply, ) LOGGER.warning(message) LOGGER.warning(keyboard) LOGGER.exception("Could not parse! got invalid url host errors") else: msg = update.effective_chat.send_message( markdown_parser( ( backup_message + "\nNote: An error occured when sending the custom message. Please update." ) ), parse_mode=ParseMode.MARKDOWN, reply_to_message_id=reply, ) LOGGER.exception() return msg
def temp_mute(update: Update, context: CallbackContext) -> str: bot, args = context.bot, context.args chat = update.effective_chat user = update.effective_user message = update.effective_message user_id, reason = extract_user_and_text(message, args) reply = check_user(user_id, bot, chat) if reply: message.reply_text(reply) return "" member = chat.get_member(user_id) 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 = ( f"<b>{html.escape(chat.title)}:</b>\n" f"#TEMP MUTED\n" f"<b>Admin:</b> {mention_html(user.id, user.first_name)}\n" f"<b>User:</b> {mention_html(member.user.id, member.user.first_name)}\n" f"<b>Time:</b> {time_val}") if reason: log += f"\n<b>Reason:</b> {reason}" try: if member.can_send_messages is None or member.can_send_messages: chat_permissions = ChatPermissions(can_send_messages=False) bot.restrict_chat_member(chat.id, user_id, chat_permissions, until_date=mutetime) bot.sendMessage( chat.id, f"Muted <b>{html.escape(member.user.first_name)}</b> for {time_val}!", parse_mode=ParseMode.HTML, ) 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(f"Muted for {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 extract_unt_fedban(message: Message, args: List[str]) -> (Optional[int], Optional[str]): prev_message = message.reply_to_message split_text = message.text.split(None, 1) if len(split_text) < 2: return id_from_reply(message) # only option possible text_to_parse = split_text[1] text = "" entities = list(message.parse_entities([MessageEntity.TEXT_MENTION])) ent = entities[0] if entities else None # if entity offset matches (command end/text start) then all good if entities and ent and ent.offset == len( message.text) - len(text_to_parse): ent = entities[0] user_id = ent.user.id text = message.text[ent.offset + ent.length:] elif len(args) >= 1 and args[0][0] == "@": user = args[0] user_id = get_user_id(user) if not user_id and not isinstance(user_id, int): message.reply_text( "I don't have that user in my db. " "You'll be able to interact with them if you reply to that person's message instead, or forward one of that user's messages." ) return None, None else: user_id = user_id res = message.text.split(None, 2) if len(res) >= 3: text = res[2] elif len(args) >= 1 and args[0].isdigit(): user_id = int(args[0]) res = message.text.split(None, 2) if len(res) >= 3: text = res[2] elif prev_message: user_id, text = id_from_reply(message) else: return None, None try: message.bot.get_chat(user_id) except BadRequest as excp: if excp.message in ("User_id_invalid", "Chat not found") and not isinstance(user_id, int): message.reply_text( "I don't seem to have interacted with this user before " "please forward a message from them to give me control! " "(like a voodoo doll, I need a piece of them to be able to execute certain commands...)" ) return None, None elif excp.message != "Chat not found": LOGGER.exception("Exception %s on user %s", excp.message, user_id) return None, None elif not isinstance(user_id, int): return None, None return user_id, text
def del_lockables(update, context): chat = update.effective_chat # type: Optional[Chat] user = update.effective_user message = update.effective_message # type: Optional[Message] chat_id = str(chat.id)[1:] approve_list = list(REDIS.sunion(f"approve_list_{chat_id}")) is_user_approved = mention_html(user.id, user.first_name) if is_user_approved in approve_list: return 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(f"{message.caption}") if "ARABIC" in check: try: message.delete() except BadRequest as excp: if excp.message != "Message to delete not found": LOGGER.exception("ERROR in lockables") break if message.text: check = ad.detect_alphabet(f"{message.text}") if "ARABIC" in check: try: message.delete() except BadRequest as excp: if excp.message != "Message to delete not found": LOGGER.exception("ERROR in lockables") break continue if lockable == "button": if (sql.is_locked(chat.id, lockable) and can_delete(chat, context.bot.id) and message.reply_markup and message.reply_markup.inline_keyboard): try: message.delete() except BadRequest as excp: if excp.message != "Message to delete not found": LOGGER.exception("ERROR in lockables") break continue if lockable == "inline": if (sql.is_locked(chat.id, lockable) and can_delete(chat, context.bot.id) and message and message.via_bot): try: message.delete() except BadRequest as excp: if excp.message != "Message to delete not found": LOGGER.exception("ERROR in lockables") break 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.ban_member(new_mem.id) send_message( update.effective_message, "Only admins are allowed to add bots in this chat! Get outta here.", ) break else: try: message.delete() except BadRequest as excp: if excp.message != "Message to delete not found": LOGGER.exception("ERROR in lockables") break
def sed(update: Update, context: CallbackContext): sed_result = separate_sed(update.effective_message.text) if sed_result and update.effective_message.reply_to_message: if update.effective_message.reply_to_message.text: to_fix = update.effective_message.reply_to_message.text elif update.effective_message.reply_to_message.caption: to_fix = update.effective_message.reply_to_message.caption else: return repl, repl_with, flags = sed_result if not repl: update.effective_message.reply_to_message.reply_text( "You're trying to replace... " "nothing with something?" ) return try: try: check = regex.match(repl, to_fix, flags=regex.IGNORECASE, timeout=5) except TimeoutError: return if check and check.group(0).lower() == to_fix.lower(): update.effective_message.reply_to_message.reply_text( "Hey everyone, {} is trying to make " "me say stuff I don't wanna " "say!".format(update.effective_user.first_name) ) return if infinite_loop_check(repl): update.effective_message.reply_text( "I'm afraid I can't run that regex." ) return if "i" in flags and "g" in flags: text = regex.sub( repl, repl_with, to_fix, flags=regex.I, timeout=3 ).strip() elif "i" in flags: text = regex.sub( repl, repl_with, to_fix, count=1, flags=regex.I, timeout=3 ).strip() elif "g" in flags: text = regex.sub(repl, repl_with, to_fix, timeout=3).strip() else: text = regex.sub(repl, repl_with, to_fix, count=1, timeout=3).strip() except TimeoutError: update.effective_message.reply_text("Timeout") return except sre_constants.error: LOGGER.warning(update.effective_message.text) LOGGER.exception("SRE constant error") update.effective_message.reply_text("Do you even sed? Apparently not.") return # empty string errors -_- if len(text) >= telegram.MAX_MESSAGE_LENGTH: update.effective_message.reply_text( "The result of the sed command was too long for \ telegram!" ) elif text: update.effective_message.reply_to_message.reply_text(text)
LOGGER.info( f"Shasa started, Using long polling. | BOT: [@{dispatcher.bot.username}]" ) updater.start_polling( timeout=15, read_latency=4, drop_pending_updates=True, allowed_updates=Update.ALL_TYPES, ) if len(argv) in {1, 3, 4}: telethn.run_until_disconnected() else: telethn.disconnect() updater.idle() try: ubot.start() except BaseException: print("Userbot Error! Have you added a STRING_SESSION in deploying??") sys.exit(1) if __name__ == "__main__": LOGGER.info(f"Successfully loaded modules: {str(ALL_MODULES)}") telethn.start(bot_token=TOKEN) pbot.start() main() idle()