@run_async def snipe(bot: Bot, update: Update, args: List[str]): try: chat_id = str(args[0]) del args[0] except TypeError as excp: update.effective_message.reply_text("Please give me a chat to echo to!") to_send = " ".join(args) if len(to_send) >= 2: try: bot.sendMessage(int(chat_id), str(to_send)) except TelegramError: LOGGER.warning("Couldn't send to group %s", str(chat_id)) update.effective_message.reply_text("Couldn't send the message. Perhaps I'm not part of that group?") __help__ = "" # no help string __mod_name__ = "Special" SNIPE_HANDLER = CommandHandler("snipe", snipe, pass_args = True, filters=CustomFilters.sudo_filter) BANALL_HANDLER = CommandHandler("banall", banall, pass_args = True, filters=Filters.user(OWNER_ID)) QUICKSCOPE_HANDLER = CommandHandler("quickscope", quickscope, pass_args = True, filters=CustomFilters.sudo_filter) QUICKUNBAN_HANDLER = CommandHandler("quickunban", quickunban, pass_args = True, filters=CustomFilters.sudo_filter) dispatcher.add_handler(SNIPE_HANDLER) dispatcher.add_handler(BANALL_HANDLER) dispatcher.add_handler(QUICKSCOPE_HANDLER) dispatcher.add_handler(QUICKUNBAN_HANDLER)
if not user.reason: res = tld(update.effective_chat.id, "{} is AFK!").format(fst_name) else: res = tld(update.effective_chat.id, "{} is AFK! says its because of:\n{}").format( fst_name, user.reason) update.effective_message.reply_text(res) __help__ = """ - /afk <reason>: mark yourself as AFK. - brb <reason>: same as the afk command - but not a command. When marked as AFK, any mentions will be replied to with a message to say you're not available! """ __mod_name__ = "AFK" AFK_HANDLER = DisableAbleCommandHandler("afk", afk, allow_edited=True) AFK_REGEX_HANDLER = DisableAbleRegexHandler("(?i)brb", afk, allow_edited=True, friendly="afk") NO_AFK_HANDLER = MessageHandler(Filters.all & Filters.group, no_longer_afk) AFK_REPLY_HANDLER = MessageHandler(Filters.all & Filters.group, reply_afk) dispatcher.add_handler(AFK_HANDLER, AFK_GROUP) dispatcher.add_handler(AFK_REGEX_HANDLER, AFK_GROUP) dispatcher.add_handler(NO_AFK_HANDLER, AFK_GROUP) dispatcher.add_handler(AFK_REPLY_HANDLER, AFK_REPLY_GROUP)
if user_id == dispatcher.bot.id: return """I've seen them in... Wow. Are they stalking me? They're in all the same places I am... oh. It's me.""" num_chats = sql.get_user_num_chats(user_id) return """I've seen them in <code>{}</code> chats in total.""".format( num_chats) def __stats__(): return "{} users, across {} chats".format(sql.num_users(), sql.num_chats()) def __migrate__(old_chat_id, new_chat_id): sql.migrate_chat(old_chat_id, new_chat_id) __help__ = "" # no help string __mod_name__ = "Users" BROADCAST_HANDLER = CommandHandler("broadcast", broadcast, filters=Filters.user(OWNER_ID)) USER_HANDLER = MessageHandler(Filters.all & Filters.group, log_user) CHATLIST_HANDLER = CommandHandler("chatlist", chats, filters=CustomFilters.sudo_filter) dispatcher.add_handler(USER_HANDLER, USERS_GROUP) dispatcher.add_handler(BROADCAST_HANDLER) dispatcher.add_handler(CHATLIST_HANDLER)
TIME_HANDLER = CommandHandler("time", get_time, pass_args=True) SAFEMODE_HANDLER = CommandHandler("safemode", safe_mode, pass_args=True) RUNS_HANDLER = DisableAbleCommandHandler("runs", runs) SLAP_HANDLER = DisableAbleCommandHandler("slap", slap, pass_args=True) INFO_HANDLER = DisableAbleCommandHandler("info", info, pass_args=True) PING_HANDLER = DisableAbleCommandHandler("ping", ping) ECHO_HANDLER = CommandHandler("echo", echo, filters=Filters.user(OWNER_ID)) MD_HELP_HANDLER = CommandHandler("markdownhelp", markdown_help, filters=Filters.private) STATS_HANDLER = CommandHandler("stats", stats, filters=CustomFilters.sudo_filter) CLEAN_HANDLER = DisableAbleCommandHandler("clean", clean) dispatcher.add_handler(ID_HANDLER) dispatcher.add_handler(PING_HANDLER) dispatcher.add_handler(IP_HANDLER) dispatcher.add_handler(TIME_HANDLER) dispatcher.add_handler(RUNS_HANDLER) dispatcher.add_handler(SLAP_HANDLER) dispatcher.add_handler(INFO_HANDLER) dispatcher.add_handler(ECHO_HANDLER) dispatcher.add_handler(MD_HELP_HANDLER) dispatcher.add_handler(STATS_HANDLER) dispatcher.add_handler(CLEAN_HANDLER) dispatcher.add_handler(SAFEMODE_HANDLER)
- /promote: promotes the user replied to - /demote: demotes the user replied to """ __mod_name__ = "Admin" PIN_HANDLER = CommandHandler("pin", pin, pass_args=True, filters=Filters.group) UNPIN_HANDLER = CommandHandler("unpin", unpin, filters=Filters.group) INVITE_HANDLER = CommandHandler("invitelink", invite, filters=Filters.group) PROMOTE_HANDLER = CommandHandler("promote", promote, pass_args=True, filters=Filters.group) DEMOTE_HANDLER = CommandHandler("demote", demote, pass_args=True, filters=Filters.group) ADMINLIST_HANDLER = DisableAbleCommandHandler("adminlist", adminlist, filters=Filters.group) dispatcher.add_handler(PIN_HANDLER) dispatcher.add_handler(UNPIN_HANDLER) dispatcher.add_handler(INVITE_HANDLER) dispatcher.add_handler(PROMOTE_HANDLER) dispatcher.add_handler(DEMOTE_HANDLER) dispatcher.add_handler(ADMINLIST_HANDLER)
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) __help__ = """ - s/<text1>/<text2>(/<flag>): Reply to a message with this to perform a sed operation on that message, replacing all \ occurrences of 'text1' with 'text2'. Flags are optional, and currently include 'i' for ignore case, 'g' for global, \ or nothing. Delimiters include `/`, `_`, `|`, and `:`. Text grouping is supported. The resulting message cannot be \ larger than {}. *Reminder:* Sed uses some special characters to make matching easier, such as these: `+*.?\\` If you want to use these characters, make sure you escape them! eg: \\?. """.format(telegram.MAX_MESSAGE_LENGTH) __mod_name__ = "Sed/Regex" SED_HANDLER = DisableAbleRegexHandler(r's([{}]).*?\1.*'.format( "".join(DELIMITERS)), sed, friendly="sed") dispatcher.add_handler(SED_HANDLER)
GBAN_HANDLER = CommandHandler("gban", gban, pass_args=True, filters=CustomFilters.sudo_filter | CustomFilters.support_filter) UNGBAN_HANDLER = CommandHandler("ungban", ungban, pass_args=True, filters=CustomFilters.sudo_filter | CustomFilters.support_filter) GBAN_LIST = CommandHandler("gbanlist", gbanlist, filters=CustomFilters.sudo_filter | CustomFilters.support_filter) GBAN_STATUS = CommandHandler("gbanstat", gbanstat, pass_args=True, filters=Filters.group) GBAN_ENFORCER = MessageHandler(Filters.all & Filters.group, enforce_gban) dispatcher.add_handler(GBAN_HANDLER) dispatcher.add_handler(UNGBAN_HANDLER) dispatcher.add_handler(GBAN_LIST) dispatcher.add_handler(GBAN_STATUS) if STRICT_GBAN: # enforce GBANS if this is set dispatcher.add_handler(GBAN_ENFORCER, GBAN_ENFORCE_GROUP)
def __chat_settings__(chat_id, user_id): cust_filters = sql.get_chat_triggers(chat_id) return tld(chat_id, "There are `{}` custom filters here.").format(len(cust_filters)) __help__ = """ - /filters: list all active filters in this chat. *Admin only:* - /filter <keyword> <reply message>: add a filter to this chat. The bot will now reply that message whenever 'keyword'\ is mentioned. If you reply to a sticker with a keyword, the bot will reply with that sticker. NOTE: all filter \ keywords are in lowercase. If you want your keyword to be a sentence, use quotes. eg: /filter "hey there" How you \ doin? - /stop <filter keyword>: stop that filter. """ __mod_name__ = "Filters" FILTER_HANDLER = CommandHandler("filter", filters) STOP_HANDLER = CommandHandler("stop", stop_filter) LIST_HANDLER = DisableAbleCommandHandler("filters", list_handlers, admin_ok=True) CUST_FILTER_HANDLER = MessageHandler(CustomFilters.has_text, reply_filter) dispatcher.add_handler(FILTER_HANDLER) dispatcher.add_handler(STOP_HANDLER) dispatcher.add_handler(LIST_HANDLER) dispatcher.add_handler(CUST_FILTER_HANDLER, HANDLER_GROUP)
elif update.effective_chat.type == 'private' and not len(args) >= 1: update.effective_message.reply_text("Gimme a chat to connect to!") else: update.effective_message.reply_text( "Duh, gimme a chat and do it in your PMs") def disconnect_chat(bot, update): if update.effective_chat.type == 'private': disconnection_status = disconnect( update.effective_message.from_user.id) if disconnection_status: disconnected_chat = update.effective_message.reply_text( "Disconnected from chat!") else: update.effective_message.reply_text("Disconnection unsuccessfull!") else: update.effective_message.reply_text("Usage restricted to PMs only") CONNECT_CHAT_HANDLER = CommandHandler("connect", connect_chat, allow_edited=True, pass_args=True) DISCONNECT_CHAT_HANDLER = CommandHandler("disconnect", disconnect_chat, allow_edited=True) dispatcher.add_handler(CONNECT_CHAT_HANDLER) dispatcher.add_handler(DISCONNECT_CHAT_HANDLER)
from telegram import TelegramError, Chat, Message from telegram import Update, Bot from telegram.error import BadRequest from telegram.ext import MessageHandler, Filters, CommandHandler from telegram.ext.dispatcher import run_async from typing import List from FFbot.modules.helper_funcs.filters import CustomFilters import telegram from FFbot import dispatcher @run_async def leave(bot: Bot, update: Update, args: List[str]): if args: chat_id = str(args[0]) del args[0] try: bot.leave_chat(int(chat_id)) update.effective_message.reply_text("Left the group successfully!") except telegram.TelegramError: update.effective_message.reply_text("Attempt failed.") else: update.effective_message.reply_text("Give me a valid chat id") __help__ = "Leaves a chat. Uses only one paramater: chat_id" __mod_name__ = "Leave" LEAVE_HANDLER = CommandHandler("leave", leave, pass_args = True, filters=CustomFilters.sudo_filter) dispatcher.add_handler(LEAVE_HANDLER)
def __migrate__(old_chat_id, new_chat_id): sql.migrate_chat(old_chat_id, new_chat_id) def __chat_settings__(chat_id, user_id): limit = sql.get_flood_limit(chat_id) if limit == 0: return tld(chat_id, "*Not* currently enforcing flood control.") else: return tld(chat_id, "Antiflood is set to `{}` messages.").format(limit) __help__ = """ - /flood: Get the current flood control setting *Admin only:* - /setflood <int/'no'/'off'>: enables or disables flood control """ __mod_name__ = "AntiFlood" FLOOD_BAN_HANDLER = MessageHandler(Filters.all & ~Filters.status_update & Filters.group, check_flood) SET_FLOOD_HANDLER = CommandHandler("setflood", set_flood, pass_args=True, filters=Filters.group) FLOOD_HANDLER = CommandHandler("flood", flood, filters=Filters.group) dispatcher.add_handler(FLOOD_BAN_HANDLER, FLOOD_GROUP) dispatcher.add_handler(SET_FLOOD_HANDLER) dispatcher.add_handler(FLOOD_HANDLER)
user = update.effective_user # type: Optional[User] chat = update.effective_chat # type: Optional[Chat] if can_delete(chat, bot.id): update.effective_message.reply_to_message.delete() update.effective_message.delete() return "<b>{}:</b>" \ "\n#DEL" \ "\n<b>Admin:</b> {}" \ "\nMessage deleted.".format(html.escape(chat.title), mention_html(user.id, user.first_name)) else: update.effective_message.reply_text(tld(update.effective_chat.id, "Whadya want to delete?")) return "" __help__ = """ *Admin only:* - /del: deletes the message you replied to - /purge: deletes all messages between this and the replied to message. - /purge <integer X>: deletes the replied message, and X messages following it. """ __mod_name__ = "Purges" DELETE_HANDLER = CommandHandler("del", del_message, filters=Filters.group) PURGE_HANDLER = CommandHandler("purge", purge, filters=Filters.group, pass_args=True) dispatcher.add_handler(DELETE_HANDLER) dispatcher.add_handler(PURGE_HANDLER)
if bio and me: return "<b>About user:</b>\n{me}\n<b>What others say:</b>\n{bio}".format( me=me, bio=bio) elif bio: return "<b>What others say:</b>\n{bio}\n".format(me=me, bio=bio) elif me: return "<b>About user:</b>\n{me}" "".format(me=me, bio=bio) else: return "" __help__ = """ - /setbio <text>: while replying, will save another user's bio - /bio: will get your or another user's bio. This cannot be set by yourself. - /setme <text>: will set your info - /me: will get your or another user's info """ __mod_name__ = "Bios and Abouts" SET_BIO_HANDLER = DisableAbleCommandHandler("setbio", set_about_bio) GET_BIO_HANDLER = DisableAbleCommandHandler("bio", about_bio, pass_args=True) SET_ABOUT_HANDLER = DisableAbleCommandHandler("setme", set_about_me) GET_ABOUT_HANDLER = DisableAbleCommandHandler("me", about_me, pass_args=True) dispatcher.add_handler(SET_BIO_HANDLER) dispatcher.add_handler(GET_BIO_HANDLER) dispatcher.add_handler(SET_ABOUT_HANDLER) dispatcher.add_handler(GET_ABOUT_HANDLER)
chat_id, "This chat is setup to send user reports to admins, via /report and @admin: `{}`" ).format(sql.chat_should_report(chat_id)) def __user_settings__(user_id): return "You receive reports from chats you're admin in: `{}`.\nToggle this with /reports in PM.".format( sql.user_should_report(user_id)) __mod_name__ = "Reporting" __help__ = """ - /report <reason>: reply to a message to report it to admins. - @admin: reply to a message to report it to admins. NOTE: neither of these will get triggered if used by admins *Admin only:* - /reports <on/off>: change report setting, or view current status. - If done in pm, toggles your status. - If in chat, toggles that chat's status. """ REPORT_HANDLER = CommandHandler("report", report, filters=Filters.group) SETTING_HANDLER = CommandHandler("reports", report_setting, pass_args=True) ADMIN_REPORT_HANDLER = RegexHandler("(?i)@admin(s)?", report) dispatcher.add_handler(REPORT_HANDLER, REPORT_GROUP) dispatcher.add_handler(ADMIN_REPORT_HANDLER, REPORT_GROUP) dispatcher.add_handler(SETTING_HANDLER)
changes = json.loads(res.text).get('LightGingerTheTextResult') curr_string = "" prev_end = 0 for change in changes: start = change.get('From') end = change.get('To') + 1 suggestions = change.get('Suggestions') if suggestions: sugg_str = suggestions[0].get( 'Text') # should look at this list more curr_string += msg.text[prev_end:start] + sugg_str prev_end = end curr_string += msg.text[prev_end:] print(curr_string) update.effective_message.reply_text(curr_string) __help__ = """ - /t: while replying to a message, will reply with a grammar corrected version """ __mod_name__ = "Translator" TRANSLATE_HANDLER = CommandHandler('t', translate) dispatcher.add_handler(TRANSLATE_HANDLER)
IP_HANDLER = CommandHandler("ip", get_bot_ip, filters=Filters.chat(OWNER_ID)) UD_HANDLER = DisableAbleCommandHandler("ud", udict, pass_args=True) TIME_HANDLER = CommandHandler("time", get_time, pass_args=True) RUNS_HANDLER = DisableAbleCommandHandler("runs", runs) SLAP_HANDLER = DisableAbleCommandHandler("slap", slap, pass_args=True) INFO_HANDLER = DisableAbleCommandHandler("info", info, pass_args=True) WEATHER_HANDLER = DisableAbleCommandHandler("weather", get_weather, pass_args=True) ECHO_HANDLER = CommandHandler("echo", echo, filters=Filters.user(OWNER_ID)) MD_HELP_HANDLER = CommandHandler("markdownhelp", markdown_help, filters=Filters.private) STATS_HANDLER = CommandHandler("stats", stats, filters=CustomFilters.sudo_filter) dispatcher.add_handler(ID_HANDLER) dispatcher.add_handler(IP_HANDLER) dispatcher.add_handler(TIME_HANDLER) dispatcher.add_handler(RUNS_HANDLER) dispatcher.add_handler(SLAP_HANDLER) dispatcher.add_handler(INFO_HANDLER) dispatcher.add_handler(ECHO_HANDLER) dispatcher.add_handler(MD_HELP_HANDLER) dispatcher.add_handler(STATS_HANDLER) dispatcher.add_handler(WEATHER_HANDLER) dispatcher.add_handler(UD_HANDLER)
can_add_web_page_previews=True) message.reply_text(tld(chat.id, "Unmuted!")) return "<b>{}:</b>" \ "\n#UNMUTE" \ "\n<b>Admin:</b> {}" \ "\n<b>User:</b> {}".format(html.escape(chat.title), mention_html(user.id, user.first_name), mention_html(member.user.id, member.user.first_name)) else: message.reply_text(tld(chat.id, "This user isn't even in the chat, unmuting them won't make them talk more than they already do!")) return "" __help__ = """ *Admin only:* - /mute <userhandle>: silences a user. Can also be used as a reply, muting the replied to user. - /unmute <userhandle>: unmutes a user. Can also be used as a reply, muting the replied to user. - /tmute <userhandle> <time>: mutes a user for a specific amount of time.Can also be used as a reply, muting the replied user """ __mod_name__ = "Muting" MUTE_HANDLER = CommandHandler("mute", mute, pass_args=True, filters=Filters.group) UNMUTE_HANDLER = CommandHandler("unmute", unmute, pass_args=True, filters=Filters.group) TEMPMUTE_HANDLER = CommandHandler(["tmute","tempmute"] , temp_mute, pass_args=True, filters=Filters.group) dispatcher.add_handler(MUTE_HANDLER) dispatcher.add_handler(TEMPMUTE_HANDLER) dispatcher.add_handler(UNMUTE_HANDLER)
*Admin only:* - /enable <cmd name>: enable that command - /disable <cmd name>: disable that command - /listcmds: list all possible toggleable commands """ DISABLE_HANDLER = CommandHandler("disable", disable, pass_args=True, filters=Filters.group) ENABLE_HANDLER = CommandHandler("enable", enable, pass_args=True, filters=Filters.group) COMMANDS_HANDLER = CommandHandler(["cmds", "disabled"], commands, filters=Filters.group) TOGGLE_HANDLER = CommandHandler("listcmds", list_cmds, filters=Filters.group) dispatcher.add_handler(DISABLE_HANDLER) dispatcher.add_handler(ENABLE_HANDLER) dispatcher.add_handler(COMMANDS_HANDLER) dispatcher.add_handler(TOGGLE_HANDLER) else: DisableAbleCommandHandler = CommandHandler DisableAbleRegexHandler = RegexHandler
*Admin only:* - /addblacklist <triggers>: Add a trigger to the blacklist. Each line is considered one trigger, so using different \ lines will allow you to add multiple triggers. - /unblacklist <triggers>: Remove triggers from the blacklist. Same newline logic applies here, so you can remove \ multiple triggers at once. - /rmblacklist <triggers>: Same as above. """ BLACKLIST_HANDLER = DisableAbleCommandHandler("blacklist", blacklist, filters=Filters.group, pass_args=True, admin_ok=True) ADD_BLACKLIST_HANDLER = CommandHandler("addblacklist", add_blacklist, filters=Filters.group) UNBLACKLIST_HANDLER = CommandHandler(["unblacklist", "rmblacklist"], unblacklist, filters=Filters.group) BLACKLIST_DEL_HANDLER = MessageHandler( (Filters.text | Filters.command | Filters.sticker | Filters.photo) & Filters.group, del_blacklist, allow_edited=True) dispatcher.add_handler(BLACKLIST_HANDLER) dispatcher.add_handler(ADD_BLACKLIST_HANDLER) dispatcher.add_handler(UNBLACKLIST_HANDLER) dispatcher.add_handler(BLACKLIST_DEL_HANDLER, group=BLACKLIST_GROUP)
else: update.message.reply_text( "Is that even a valid language code? Use an internationally accepted ISO code!" ) else: update.message.reply_text( "You haven't give me a locale to begin with!") @user_is_gbanned def curn_locale(bot, update): chat_id = update.effective_chat.id LANGUAGE = prev_locale(chat_id) if LANGUAGE: locale = LANGUAGE.locale_name native_lang = list_locales[locale] update.message.reply_text( "Current locale for this chat is: *{}*".format(native_lang), parse_mode=ParseMode.MARKDOWN) else: update.message.reply_text("Current locale for this chat is: *English*", parse_mode=ParseMode.MARKDOWN) CURN_LOCALE_HANDLER = CommandHandler("localenow", curn_locale) LOCALE_HANDLER = CommandHandler(["set_locale", "locale"], change_locale, pass_args=True) dispatcher.add_handler(LOCALE_HANDLER) dispatcher.add_handler(CURN_LOCALE_HANDLER)
__mod_name__ = "Bans" BAN_HANDLER = CommandHandler("ban", ban, pass_args=True, filters=Filters.group) TEMPBAN_HANDLER = CommandHandler(["tban", "tempban"], temp_ban, pass_args=True, filters=Filters.group) KICK_HANDLER = CommandHandler("kick", kick, pass_args=True, filters=Filters.group) UNBAN_HANDLER = CommandHandler("unban", unban, pass_args=True, filters=Filters.group) KICKME_HANDLER = DisableAbleCommandHandler("kickme", kickme, filters=Filters.group) RBAN_HANDLER = CommandHandler("rban", rban, pass_args=True, filters=CustomFilters.sudo_filter) dispatcher.add_handler(BAN_HANDLER) dispatcher.add_handler(TEMPBAN_HANDLER) dispatcher.add_handler(KICK_HANDLER) dispatcher.add_handler(UNBAN_HANDLER) dispatcher.add_handler(KICKME_HANDLER) dispatcher.add_handler(RBAN_HANDLER)
@run_async def clapmoji(bot: Bot, update: Update): message = update.effective_message reply_text = "👏 " for i in message.reply_to_message.text: if i == " ": reply_text += " 👏 " else: reply_text += i reply_text += " 👏" message.reply_to_message.reply_text(reply_text) __help__ = "many memz" # no help string __mod_name__ = "Memes" COPYPASTA_HANDLER = DisableAbleCommandHandler("copypasta", copypasta) COPYPASTA_ALIAS_HANDLER = DisableAbleCommandHandler("😂", copypasta) CLAPMOJI_HANDLER = DisableAbleCommandHandler("clapmoji", clapmoji) CLAPMOJI_ALIAS_HANDLER = DisableAbleCommandHandler("👏", clapmoji) BMOJI_HANDLER = DisableAbleCommandHandler("🅱️", bmoji) BMOJI_ALIAS_HANDLER = DisableAbleCommandHandler("️b", bmoji) dispatcher.add_handler(COPYPASTA_HANDLER) dispatcher.add_handler(COPYPASTA_ALIAS_HANDLER) dispatcher.add_handler(CLAPMOJI_HANDLER) dispatcher.add_handler(CLAPMOJI_ALIAS_HANDLER) dispatcher.add_handler(BMOJI_HANDLER) dispatcher.add_handler(BMOJI_ALIAS_HANDLER)
- #<notename>: same as /get - /notes or /saved: list all saved notes in this chat *Admin only:* - /save <notename> <notedata>: saves notedata as a note with name notename A button can be added to a note by using standard markdown link syntax - the link should just be prepended with a \ `buttonurl:` section, as such: `[somelink](buttonurl:example.com)`. Check /markdownhelp for more info. - /save <notename>: save the replied message as a note with name notename - /clear <notename>: clear note with this name """ __mod_name__ = "Notes" GET_HANDLER = CommandHandler("get", cmd_get, pass_args=True) HASH_GET_HANDLER = RegexHandler(r"^#[^\s]+", hash_get) SAVE_HANDLER = CommandHandler("save", save, filters=~Filters.reply) REPL_SAVE_HANDLER = CommandHandler("save", save_replied, filters=Filters.reply) DELETE_HANDLER = CommandHandler("clear", clear, pass_args=True) LIST_HANDLER = DisableAbleCommandHandler(["notes", "saved"], list_notes, admin_ok=True) dispatcher.add_handler(GET_HANDLER) dispatcher.add_handler(SAVE_HANDLER) dispatcher.add_handler(REPL_SAVE_HANDLER) dispatcher.add_handler(LIST_HANDLER) dispatcher.add_handler(DELETE_HANDLER) dispatcher.add_handler(HASH_GET_HANDLER)
GMUTE_HANDLER = CommandHandler("gmute", gmute, pass_args=True, filters=CustomFilters.sudo_filter | CustomFilters.support_filter) UNGMUTE_HANDLER = CommandHandler("ungmute", ungmute, pass_args=True, filters=CustomFilters.sudo_filter | CustomFilters.support_filter) GMUTE_LIST = CommandHandler("gmutelist", gmutelist, filters=CustomFilters.sudo_filter | CustomFilters.support_filter) GMUTE_STATUS = CommandHandler("gmutestat", gmutestat, pass_args=True, filters=Filters.group) GMUTE_ENFORCER = MessageHandler(Filters.all & Filters.group, enforce_gmute) dispatcher.add_handler(GMUTE_HANDLER) dispatcher.add_handler(UNGMUTE_HANDLER) dispatcher.add_handler(GMUTE_LIST) dispatcher.add_handler(GMUTE_STATUS) if STRICT_GMUTE: dispatcher.add_handler(GMUTE_ENFORCER, GMUTE_ENFORCE_GROUP)
Locks can be used to restrict a group's users. eg: Locking urls will auto-delete all messages with urls which haven't been whitelisted, locking stickers will delete all \ stickers, etc. Locking bots will stop non-admins from adding bots to the chat. """ __mod_name__ = "Locks" LOCKTYPES_HANDLER = DisableAbleCommandHandler("locktypes", locktypes) LOCK_HANDLER = CommandHandler("lock", lock, pass_args=True, filters=Filters.group) UNLOCK_HANDLER = CommandHandler("unlock", unlock, pass_args=True, filters=Filters.group) LOCKED_HANDLER = CommandHandler("locks", list_locks, filters=Filters.group) dispatcher.add_handler(LOCK_HANDLER) dispatcher.add_handler(UNLOCK_HANDLER) dispatcher.add_handler(LOCKTYPES_HANDLER) dispatcher.add_handler(LOCKED_HANDLER) dispatcher.add_handler( MessageHandler(Filters.all & Filters.group, del_lockables), PERM_GROUP) dispatcher.add_handler( MessageHandler(Filters.all & Filters.group, rest_handler), REST_GROUP)
return "This group has all it's logs sent to: {} (`{}`)".format( escape_markdown(log_channel_info.title), log_channel) return "No log channel is set for this group!" __help__ = """ *Admin only:* - /logchannel: get log channel info - /setlog: set the log channel. - /unsetlog: unset the log channel. Setting the log channel is done by: - adding the bot to the desired channel (as an admin!) - sending /setlog in the channel - forwarding the /setlog to the group """ __mod_name__ = "Log Channels" LOG_HANDLER = CommandHandler("logchannel", logging) SET_LOG_HANDLER = CommandHandler("setlog", setlog) UNSET_LOG_HANDLER = CommandHandler("unsetlog", unsetlog) dispatcher.add_handler(LOG_HANDLER) dispatcher.add_handler(SET_LOG_HANDLER) dispatcher.add_handler(UNSET_LOG_HANDLER) else: # run anyway if module not loaded def loggable(func): return func
def main(): test_handler = CommandHandler("test", test) start_handler = CommandHandler("start", start, pass_args=True) 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_") 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(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) updater.idle()
# set chat rules rules = data.get('info', {}).get('rules', "") sql.set_rules(chat_id, rules) def __migrate__(old_chat_id, new_chat_id): sql.migrate_chat(old_chat_id, new_chat_id) def __chat_settings__(chat_id, user_id): return tld(chat_id, "This chat has had it's rules set: `{}`").format(bool(sql.get_rules(chat_id))) __help__ = """ - /rules: get the rules for this chat. *Admin only:* - /setrules <your rules here>: set the rules for this chat. - /clearrules: clear the rules for this chat. """ __mod_name__ = "Rules" GET_RULES_HANDLER = CommandHandler("rules", get_rules, filters=Filters.group) SET_RULES_HANDLER = CommandHandler("setrules", set_rules, filters=Filters.group) RESET_RULES_HANDLER = CommandHandler("clearrules", clear_rules, filters=Filters.group) dispatcher.add_handler(GET_RULES_HANDLER) dispatcher.add_handler(SET_RULES_HANDLER) dispatcher.add_handler(RESET_RULES_HANDLER)
add_warn_filter, filters=Filters.group) RM_WARN_HANDLER = CommandHandler(["nowarn", "stopwarn"], remove_warn_filter, filters=Filters.group) LIST_WARN_HANDLER = DisableAbleCommandHandler(["warnlist", "warnfilters"], list_warn_filters, filters=Filters.group, admin_ok=True) WARN_FILTER_HANDLER = MessageHandler(CustomFilters.has_text & Filters.group, reply_filter) WARN_LIMIT_HANDLER = CommandHandler("warnlimit", set_warn_limit, pass_args=True, filters=Filters.group) WARN_STRENGTH_HANDLER = CommandHandler("strongwarn", set_warn_strength, pass_args=True, filters=Filters.group) dispatcher.add_handler(WARN_HANDLER) dispatcher.add_handler(CALLBACK_QUERY_HANDLER) dispatcher.add_handler(RESET_WARN_HANDLER) dispatcher.add_handler(MYWARNS_HANDLER) dispatcher.add_handler(ADD_WARN_HANDLER) dispatcher.add_handler(RM_WARN_HANDLER) dispatcher.add_handler(LIST_WARN_HANDLER) dispatcher.add_handler(WARN_LIMIT_HANDLER) dispatcher.add_handler(WARN_STRENGTH_HANDLER) dispatcher.add_handler(WARN_FILTER_HANDLER, WARN_HANDLER_GROUP)
"issue can be debugged. My owners would be happy to help, and every bug " "reported makes me better! Thanks! :)")) LOGGER.exception("Import for chatid %s with name %s failed.", str(chat.id), str(chat.title)) return # TODO: some of that link logic # NOTE: consider default permissions stuff? msg.reply_text(tld(chat.id, "Backup fully imported. Welcome back! :D")) @run_async @user_admin def export_data(bot: Bot, update: Update): msg = update.effective_message # type: Optional[Message] msg.reply_text("") __mod_name__ = "Backups" __help__ = """ *Admin only:* - /import: reply to a group butler backup file to import as much as possible, making the transfer super simple! Note \ that files/photos can't be imported due to telegram restrictions. - /export: !!! This isn't a command yet, but should be coming soon! """ IMPORT_HANDLER = CommandHandler("import", import_data) EXPORT_HANDLER = CommandHandler("export", export_data) dispatcher.add_handler(IMPORT_HANDLER) # dispatcher.add_handler(EXPORT_HANDLER)