• `/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.
*Admins only:*
• `/reports <on/off>`*:* change report setting, or view current status.
• If done in pm, toggles your status.
• If in group, toggles that groups's status.
"""
SETTING_HANDLER = CommandHandler("reports", report_setting, run_async=True)
REPORT_HANDLER = CommandHandler("report",
report,
filters=Filters.chat_type.groups,
run_async=True)
ADMIN_REPORT_HANDLER = MessageHandler(Filters.regex(r"(?i)@admin(s)?"), report)
REPORT_BUTTON_USER_HANDLER = CallbackQueryHandler(buttons, pattern=r"report_")
dispatcher.add_handler(REPORT_BUTTON_USER_HANDLER)
dispatcher.add_handler(SETTING_HANDLER)
dispatcher.add_handler(REPORT_HANDLER, REPORT_GROUP)
dispatcher.add_handler(ADMIN_REPORT_HANDLER, REPORT_GROUP)
__mod_name__ = "Reporting"
__handlers__ = [
(REPORT_HANDLER, REPORT_GROUP),
(ADMIN_REPORT_HANDLER, REPORT_GROUP),
(SETTING_HANDLER),
]
def done(bot, update, args):
if Helper.not_a_group(update) or Helper.not_authorised(update):
return
for arg in args:
try:
OrderHandler.update_done_order(bot, update.message.chat.id, int(arg))
except Exception as error:
logging.warning('Unable to mark item "%s" as done, error: "%s"' % (arg, error))
# Read config file to get telegram bot token later
with open('config.json') as data_file:
config_data = json.load(data_file)
updater = Updater(token=config_data['bot_token'])
updater.dispatcher.add_handler(CommandHandler('start', start))
updater.dispatcher.add_handler(CallbackQueryHandler(button))
updater.dispatcher.add_handler(CommandHandler('sub', sub))
updater.dispatcher.add_handler(CommandHandler('unsub', unsub))
updater.dispatcher.add_handler(CommandHandler('help', help))
updater.dispatcher.add_handler(CommandHandler('done', done, pass_args=True))
updater.dispatcher.add_error_handler(error)
updater.start_polling()
updater.idle()
reset_welcome,
filters=Filters.group)
RESET_GOODBYE = CommandHandler("resetgoodbye",
reset_goodbye,
filters=Filters.group)
WELCOMEMUTE_HANDLER = CommandHandler("welcomemute",
welcomemute,
pass_args=True,
filters=Filters.group)
CLEAN_WELCOME = CommandHandler("cleanwelcome",
clean_welcome,
pass_args=True,
filters=Filters.group)
WELCOME_HELP = CommandHandler("welcomehelp", welcome_help)
WELCOME_MUTE_HELP = CommandHandler("welcomemutehelp", welcome_mute_help)
BUTTON_VERIFY_HANDLER = CallbackQueryHandler(user_button,
pattern=r"user_join_")
dispatcher.add_handler(NEW_MEM_HANDLER)
dispatcher.add_handler(LEFT_MEM_HANDLER)
dispatcher.add_handler(WELC_PREF_HANDLER)
dispatcher.add_handler(GOODBYE_PREF_HANDLER)
dispatcher.add_handler(SET_WELCOME)
dispatcher.add_handler(SET_GOODBYE)
dispatcher.add_handler(RESET_WELCOME)
dispatcher.add_handler(RESET_GOODBYE)
dispatcher.add_handler(CLEAN_WELCOME)
dispatcher.add_handler(WELCOME_HELP)
dispatcher.add_handler(WELCOMEMUTE_HANDLER)
dispatcher.add_handler(BUTTON_VERIFY_HANDLER)
dispatcher.add_handler(WELCOME_MUTE_HELP)
if query_type == "db_leave_chat":
if query.from_user.id in admin_list:
bot.editMessageText("Leaving chats ...", chat_id,
message.message_id)
chat_count = get_muted_chats(update, context, True)
bot.sendMessage(chat_id, f"Left {chat_count} chats.")
else:
query.answer("You are not allowed to use this.")
elif query_type == "db_cleanup":
if query.from_user.id in admin_list:
bot.editMessageText("Cleaning up DB ...", chat_id,
message.message_id)
invalid_chat_count = get_invalid_chats(update, context, True)
invalid_gban_count = get_invalid_gban(update, context, True)
reply = "Cleaned up {} chats and {} gbanned users from db.".format(
invalid_chat_count, invalid_gban_count)
bot.sendMessage(chat_id, reply)
else:
query.answer("You are not allowed to use this.")
DB_CLEANUP_HANDLER = CommandHandler("dbcleanup", dbcleanup)
BUTTON_HANDLER = CallbackQueryHandler(callback_button, pattern="db_.*")
dispatcher.add_handler(DB_CLEANUP_HANDLER)
dispatcher.add_handler(BUTTON_HANDLER)
__mod_name__ = "DB Cleanup"
__handlers__ = [DB_CLEANUP_HANDLER, BUTTON_HANDLER]
def startup():
print('main called')
msg_queue = mq.MessageQueue(all_burst_limit=28, all_time_limit_ms=1050)
request = Request(con_pool_size=8)
TOKEN = open('campobot/token/token_test.txt', 'r').read().strip()
campo_bot = MQBot(TOKEN, request=request, mqueue=msg_queue)
updater = Updater(bot=campo_bot)
dispatcher = updater.dispatcher
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO)
jobs = updater.job_queue
jobs.run_daily(callback=report_notification_job,
time=datetime.time(hour=12, minute=30))
# Help Handler
dispatcher.add_handler(
CallbackQueryHandler(callback=help_callback,
pattern=CALLBACK_HELP_INTRO))
dispatcher.add_handler(
CallbackQueryHandler(callback=help_callback,
pattern=CALLBACK_HELP_HOURS))
dispatcher.add_handler(
CallbackQueryHandler(callback=help_callback,
pattern=CALLBACK_HELP_CRON))
dispatcher.add_handler(
CallbackQueryHandler(callback=help_callback,
pattern=CALLBACK_HELP_PUBS))
dispatcher.add_handler(
CallbackQueryHandler(callback=help_callback,
pattern=CALLBACK_HELP_VIDEOS))
dispatcher.add_handler(
CallbackQueryHandler(callback=help_callback,
pattern=CALLBACK_HELP_RETURNS))
dispatcher.add_handler(
CallbackQueryHandler(callback=help_callback,
pattern=CALLBACK_HELP_STUDIES))
dispatcher.add_handler(
CallbackQueryHandler(callback=help_callback,
pattern=CALLBACK_HELP_REPORT))
dispatcher.add_handler(
CallbackQueryHandler(callback=help_callback,
pattern=CALLBACK_HELP_HOURS_DEMO))
dispatcher.add_handler(
CallbackQueryHandler(callback=help_callback,
pattern=CALLBACK_HELP_CRON_DEMO))
dispatcher.add_handler(
CallbackQueryHandler(callback=help_callback,
pattern=CALLBACK_HELP_VIDEOS_DEMO))
dispatcher.add_handler(
CallbackQueryHandler(callback=help_callback,
pattern=CALLBACK_HELP_PUBS_DEMO))
dispatcher.add_handler(
CallbackQueryHandler(callback=help_callback,
pattern=CALLBACK_HELP_RETURNS_DEMO))
dispatcher.add_handler(
CallbackQueryHandler(callback=help_callback,
pattern=CALLBACK_HELP_STUDIES_DEMO))
dispatcher.add_handler(
CallbackQueryHandler(callback=help_callback,
pattern=CALLBACK_HELP_REPORT_DEMO))
dispatcher.add_handler(
RegexHandler(callback=help_inline,
pattern=str(Regex.START_WITH_EMOJI_SLASH +
Regex.HELP_COMMAND)))
# Cron Handler
dispatcher.add_handler(
CallbackQueryHandler(callback=cron_callback,
pattern=CALLBACK_CRON_START,
pass_user_data=True))
dispatcher.add_handler(
CallbackQueryHandler(callback=cron_callback,
pattern=CALLBACK_CRON_UPDATE,
pass_user_data=True))
dispatcher.add_handler(
CallbackQueryHandler(callback=cron_callback,
pattern=CALLBACK_CRON_STOP,
pass_user_data=True))
dispatcher.add_handler(
CallbackQueryHandler(callback=cron_callback,
pattern=CALLBACK_CRON_SAVE,
pass_user_data=True))
dispatcher.add_handler(
CallbackQueryHandler(callback=cron_callback,
pattern=CALLBACK_CRON_DISCARD,
pass_user_data=True))
dispatcher.add_handler(
RegexHandler(callback=cron_inline,
pattern=str(Regex.START_WITH_EMOJI_SLASH +
Regex.CRON_COMMAND),
pass_user_data=True))
# Videos Handler
dispatcher.add_handler(
CallbackQueryHandler(callback=video_callback,
pattern=CALLBACK_VIDEO_ADD_ONE))
dispatcher.add_handler(
CallbackQueryHandler(callback=video_callback,
pattern=CALLBACK_VIDEO_ADD_THREE))
dispatcher.add_handler(
CallbackQueryHandler(callback=video_callback,
pattern=CALLBACK_VIDEO_REMOVE_ONE))
dispatcher.add_handler(
RegexHandler(callback=video_offline_add_callback,
pattern=Regex.VIDEO_OFFLINE_ADD))
dispatcher.add_handler(
RegexHandler(callback=video_offline_remove_callback,
pattern=Regex.VIDEO_OFFLINE_REMOVE))
dispatcher.add_handler(
RegexHandler(callback=video_inline,
pattern=str(Regex.START_WITH_EMOJI_SLASH +
Regex.VIDEO_COMMAND)))
# Report Handler
dispatcher.add_handler(
CallbackQueryHandler(callback=reports_callback,
pattern=CALLBACK_REPORT_LAST_MONTH))
dispatcher.add_handler(
CallbackQueryHandler(callback=reports_callback,
pattern=CALLBACK_REPORT_CURRENT_MONTH))
dispatcher.add_handler(
RegexHandler(callback=reports_inline,
pattern=str(Regex.START_WITH_EMOJI_SLASH +
Regex.REPORT_COMMAND)))
# Studies Handler
dispatcher.add_handler(
CallbackQueryHandler(callback=studies_callback,
pattern=CALLBACK_STUDIES_ADD_ONE))
dispatcher.add_handler(
CallbackQueryHandler(callback=studies_callback,
pattern=CALLBACK_STUDIES_ADD_THREE))
dispatcher.add_handler(
CallbackQueryHandler(callback=studies_callback,
pattern=CALLBACK_STUDIES_REMOVE_ONE))
dispatcher.add_handler(
RegexHandler(callback=studies_offline_add_callback,
pattern=Regex.STUDIES_OFFLINE_ADD))
dispatcher.add_handler(
RegexHandler(callback=studies_offline_remove_callback,
pattern=Regex.STUDIES_OFFLINE_REMOVE))
dispatcher.add_handler(
RegexHandler(callback=studies_inline,
pattern=str(Regex.START_WITH_EMOJI_SLASH +
Regex.STUDIES_COMMAND)))
# Pubs Handler
dispatcher.add_handler(
CallbackQueryHandler(callback=pubs_callback,
pattern=CALLBACK_PUBS_ADD_ONE))
dispatcher.add_handler(
CallbackQueryHandler(callback=pubs_callback,
pattern=CALLBACK_PUBS_ADD_THREE))
dispatcher.add_handler(
CallbackQueryHandler(callback=pubs_callback,
pattern=CALLBACK_PUBS_REMOVE_ONE))
dispatcher.add_handler(
RegexHandler(callback=pubs_offline_add_callback,
pattern=Regex.PUBS_OFFLINE_ADD))
dispatcher.add_handler(
RegexHandler(callback=pubs_offline_remove_callback,
pattern=Regex.PUBS_OFFLINE_REMOVE))
dispatcher.add_handler(
RegexHandler(callback=pubs_inline,
pattern=str(Regex.START_WITH_EMOJI_SLASH +
Regex.PUBS_COMMAND)))
# Hours Handler
dispatcher.add_handler(
CallbackQueryHandler(callback=hours_callback,
pattern=CALLBACK_HOURS_ADD,
pass_user_data=True))
dispatcher.add_handler(
CallbackQueryHandler(callback=hours_callback,
pattern=CALLBACK_HOURS_MINUTES_ADD,
pass_user_data=True))
dispatcher.add_handler(
CallbackQueryHandler(callback=hours_callback,
pattern=CALLBACK_HOURS_ADD_ONE_HOUR,
pass_user_data=True))
dispatcher.add_handler(
CallbackQueryHandler(callback=hours_callback,
pattern=CALLBACK_HOURS_ADD_TWO_HOURS,
pass_user_data=True))
dispatcher.add_handler(
CallbackQueryHandler(callback=hours_callback,
pattern=CALLBACK_HOURS_REMOVE_ONE_HOUR,
pass_user_data=True))
dispatcher.add_handler(
CallbackQueryHandler(callback=hours_callback,
pattern=CALLBACK_HOURS_REMOVE_TWO_HOURS,
pass_user_data=True))
dispatcher.add_handler(
CallbackQueryHandler(callback=hours_callback,
pattern=CALLBACK_HOURS_ADD_THIRTY_MINUTES))
dispatcher.add_handler(
CallbackQueryHandler(callback=hours_callback,
pattern=CALLBACK_HOURS_ADD_TEN_MINUTES))
dispatcher.add_handler(
CallbackQueryHandler(callback=hours_callback,
pattern=CALLBACK_HOURS_ADD_FIVE_MINUTES))
dispatcher.add_handler(
CallbackQueryHandler(callback=hours_callback,
pattern=CALLBACK_HOURS_REMOVE_THIRTY_MINUTES))
dispatcher.add_handler(
CallbackQueryHandler(callback=hours_callback,
pattern=CALLBACK_HOURS_REMOVE_TEN_MINUTES))
dispatcher.add_handler(
CallbackQueryHandler(callback=hours_callback,
pattern=CALLBACK_HOURS_REMOVE_FIVE_MINUTES))
dispatcher.add_handler(
RegexHandler(callback=callback_offline_add_hours,
pattern=Regex.HOURS_OFFLINE_ADD))
dispatcher.add_handler(
RegexHandler(callback=callback_offline_remove_hours,
pattern=Regex.HOURS_OFFLINE_REMOVE))
dispatcher.add_handler(
RegexHandler(callback=callback_offline_add_minutes,
pattern=Regex.HOURS_OFFLINE_ADD_MINUTES))
dispatcher.add_handler(
RegexHandler(callback=callback_offline_remove_minutes,
pattern=Regex.HOURS_OFFLINE_REMOVE_MINUTES))
dispatcher.add_handler(
RegexHandler(callback=hours_inline,
pattern=str(Regex.START_WITH_EMOJI_SLASH +
Regex.HOURS_COMMAND)))
# Returns Handler
dispatcher.add_handler(
CallbackQueryHandler(callback=returns_callback,
pattern=CALLBACK_RETURNS_ADD_ONE))
dispatcher.add_handler(
CallbackQueryHandler(callback=returns_callback,
pattern=CALLBACK_RETURNS_ADD_THREE))
dispatcher.add_handler(
CallbackQueryHandler(callback=returns_callback,
pattern=CALLBACK_RETURNS_REMOVE_ONE))
dispatcher.add_handler(
CallbackQueryHandler(callback=returns_callback,
pattern=CALLBACK_RETURNS_LIST))
dispatcher.add_handler(
CallbackQueryHandler(callback=returns_callback,
pattern=CALLBACK_RETURNS_INSTERESTED))
dispatcher.add_handler(
RegexHandler(callback=returns_offline_add_callback,
pattern=Regex.RETURNS_OFFLINE_ADD))
dispatcher.add_handler(
RegexHandler(callback=returns_offline_remove_callback,
pattern=Regex.RETURNS_OFFLINE_REMOVE))
dispatcher.add_handler(
RegexHandler(callback=returns_inline,
pattern=str(Regex.START_WITH_EMOJI_SLASH +
Regex.RETURNS_COMMAND)))
dispatcher.add_handler(
RegexHandler(callback=returns_people_callback,
pattern=Regex.RETURNS_PEOPLE))
dispatcher.add_handler(
RegexHandler(callback=returns_people_remove_callback,
pattern=Regex.RETURNS_PEOPLE_REMOVE))
# Commands Handler
dispatcher.add_handler(CommandHandler('start', start, pass_user_data=True))
dispatcher.add_handler(
RegexHandler(callback=callback_404,
pattern=Regex.NOT_FOUND_404)) # Must be last one
dispatcher.add_error_handler(error)
# Start MongoDB and Bot
startup_mongodb()
updater.start_polling()
def main():
updater = Updater(token=TOKEN, use_context=True)
dispatcher = updater.dispatcher
conv_handler = ConversationHandler(
entry_points=[CommandHandler('start', init_Proposal)],
states={
SELECT_ACTION: [
CallbackQueryHandler(init_add_docx, pattern=ADD_DOCX),
CallbackQueryHandler(init_content_dict,
pattern=ADD_CONTENT_DICT),
CallbackQueryHandler(init_add_info, pattern=ADD_INFO),
CallbackQueryHandler(show_buttons, pattern=SHOW_BUTTONS),
CallbackQueryHandler(start, pattern=START),
CallbackQueryHandler(settings, pattern=SETTINGS),
CallbackQueryHandler(how_to_use, pattern=HOW_TO_USE),
CallbackQueryHandler(change_mode, pattern=CHANGE_MODE),
# CallbackQueryHandler(engineers_settings,
# pattern=ENGINEERS_SETTINGS),
CallbackQueryHandler(choose_engineers,
pattern=CHOOSE_ENGINEER),
CallbackQueryHandler(init_add_new_engineer,
pattern=ADD_NEW_ENGINEER),
CallbackQueryHandler(add_engineer_to_proposal,
pattern=f'.+{ADD_ENGINEER_TO_PROPOSAL}$'),
CallbackQueryHandler(init_add_engineers_rate,
pattern=ADD_ENGINEERS_RATE),
CallbackQueryHandler(edit_title, pattern=f'.+{EDIT_TITLE}$'),
CallbackQueryHandler(choose_title_to_edit,
pattern=CHOOSE_TITLE_TO_EDIT),
CallbackQueryHandler(get_test_pdf_dict, pattern=TEST),
CallbackQueryHandler(generate_html, pattern=CREATE_PDF),
CommandHandler('stop', end)
],
STORE_DATA: [MessageHandler(Filters.text, store_data)],
STORE_ENGINEER_TO_DB:
[MessageHandler(Filters.photo, store_engineer_to_db)],
STORE_DOCX: [MessageHandler(Filters.document.docx, store_docx)],
},
fallbacks=[CallbackQueryHandler(end, pattern=END)],
allow_reentry=True,
per_message=False)
dispatcher.add_handler(conv_handler)
updater.start_polling()
updater.idle()
• `/addwarn <keyword> <reply message>`*:* set a warning filter on a certain keyword. If you want your keyword to \
be a sentence, encompass it with quotes, as such: `/addwarn "very angry" This is an angry user`.
• `/nowarn <keyword>`*:* stop a warning filter
• `/warnlimit <num>`*:* set the warning limit
• `/strongwarn <on/yes/off/no>`*:* If set to on, exceeding the warn limit will result in a ban. Else, will just punch.
"""
__mod_name__ = "Warnings"
WARN_HANDLER = CommandHandler(["warn", "dwarn"],
warn_user,
filters=Filters.group)
RESET_WARN_HANDLER = CommandHandler(["resetwarn", "resetwarns"],
reset_warns,
filters=Filters.group)
CALLBACK_QUERY_HANDLER = CallbackQueryHandler(button, pattern=r"rm_warn")
MYWARNS_HANDLER = DisableAbleCommandHandler("warns",
warns,
filters=Filters.group)
ADD_WARN_HANDLER = CommandHandler("addwarn",
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)
def main():
# Create the Updater and pass it your bot's token.
# Make sure to set use_context=True to use the new context based callbacks
# Post version 12 this will no longer be necessary
updater = Updater("1125616254:AAF-MKSNL0AjbPZ3ZlGMBHYZ8mCoTOP7GsA",
use_context=True)
# Get the dispatcher to register handlers
dp = updater.dispatcher
# Set up third level ConversationHandler (collecting features)
description_conv = ConversationHandler(
entry_points=[
CallbackQueryHandler(select_feature,
pattern='^' + str(MALE) + '$|^' +
str(FEMALE) + '$')
],
states={
SELECTING_FEATURE: [
CallbackQueryHandler(ask_for_input,
pattern='^(?!' + str(END) + ').*$')
],
TYPING: [MessageHandler(Filters.text, save_input)],
},
fallbacks=[
CallbackQueryHandler(end_describing, pattern='^' + str(END) + '$'),
CommandHandler('stop', stop_nested)
],
map_to_parent={
# Return to second level menu
END: SELECTING_LEVEL,
# End conversation alltogether
STOPPING: STOPPING,
})
# Set up second level ConversationHandler (adding a person)
add_member_conv = ConversationHandler(
entry_points=[
CallbackQueryHandler(select_level,
pattern='^' + str(ADDING_MEMBER) + '$')
],
states={
SELECTING_LEVEL: [
CallbackQueryHandler(select_gender,
pattern='^{0}$|^{1}$'.format(
str(PARENTS), str(CHILDREN)))
],
SELECTING_GENDER: [description_conv]
},
fallbacks=[
CallbackQueryHandler(show_data, pattern='^' + str(SHOWING) + '$'),
CallbackQueryHandler(end_second_level,
pattern='^' + str(END) + '$'),
CommandHandler('stop', stop_nested)
],
map_to_parent={
# After showing data return to top level menu
SHOWING: SHOWING,
# Return to top level menu
END: SELECTING_ACTION,
# End conversation alltogether
STOPPING: END,
})
# Set up top level ConversationHandler (selecting action)
conv_handler = ConversationHandler(
entry_points=[CommandHandler('start', start)],
states={
SHOWING:
[CallbackQueryHandler(start, pattern='^' + str(END) + '$')],
SELECTING_ACTION: [
add_member_conv,
CallbackQueryHandler(show_data,
pattern='^' + str(SHOWING) + '$'),
CallbackQueryHandler(adding_self,
pattern='^' + str(ADDING_SELF) + '$'),
CallbackQueryHandler(end, pattern='^' + str(END) + '$'),
],
DESCRIBING_SELF: [description_conv],
},
fallbacks=[CommandHandler('stop', stop)],
)
# Because the states of the third level conversation map to the ones of the
# second level conversation, we need to be a bit hacky about that:
conv_handler.states[SELECTING_LEVEL] = conv_handler.states[
SELECTING_ACTION]
conv_handler.states[STOPPING] = conv_handler.entry_points
dp.add_handler(conv_handler)
# log all errors
dp.add_error_handler(error)
# Start the Bot
updater.start_polling()
# Run the bot until you press Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT. This should be used most of the time, since
# start_polling() is non-blocking and will stop the bot gracefully.
updater.idle()
except:
pass
def watch(update, context):
_watch(context.bot, update)
def watchZip(update, context):
_watch(context.bot, update, True)
def leechWatch(update, context):
_watch(context.bot, update, isLeech=True)
def leechWatchZip(update, context):
_watch(context.bot, update, True, True)
watch_handler = CommandHandler(BotCommands.WatchCommand, watch,
filters=CustomFilters.authorized_chat | CustomFilters.authorized_user, run_async=True)
zip_watch_handler = CommandHandler(BotCommands.ZipWatchCommand, watchZip,
filters=CustomFilters.authorized_chat | CustomFilters.authorized_user, run_async=True)
leech_watch_handler = CommandHandler(BotCommands.LeechWatchCommand, leechWatch,
filters=CustomFilters.authorized_chat | CustomFilters.authorized_user, run_async=True)
leech_zip_watch_handler = CommandHandler(BotCommands.LeechZipWatchCommand, leechWatchZip,
filters=CustomFilters.authorized_chat | CustomFilters.authorized_user, run_async=True)
quality_handler = CallbackQueryHandler(select_format, pattern="qu", run_async=True)
dispatcher.add_handler(watch_handler)
dispatcher.add_handler(zip_watch_handler)
dispatcher.add_handler(leech_watch_handler)
dispatcher.add_handler(leech_zip_watch_handler)
dispatcher.add_handler(quality_handler)
language_settings_choice),
MessageHandler(Filters.regex('^Изменить язык$'),
language_settings_choice),
MessageHandler(Filters.regex('^⬅️ Orqaga$'), main_choice),
MessageHandler(Filters.regex('^⬅️ Назад$'), main_choice),
MessageHandler(Filters.all, do_nothing)
],
SAVING_PHONE_SETTINGS: [
MessageHandler(Filters.regex('^⬅️ Orqaga$'), settings_choice),
MessageHandler(Filters.regex('^⬅️ Назад$'), settings_choice),
MessageHandler(Filters.contact, set_user_phone),
MessageHandler(Filters.all, do_nothing)
],
SAVING_LANGUAGE_SETTINGS: [
MessageHandler(Filters.regex('^🇺🇿 O\'zbekcha$'), set_user_uzbek),
MessageHandler(Filters.regex('^🇷🇺 Русский'), set_user_russian),
MessageHandler(Filters.all, do_nothing)
]
},
fallbacks=[MessageHandler(Filters.regex('^Done$'), cancel)],
allow_reentry=True)
dp.add_handler(MessageHandler(Filters.location, location))
dp.add_handler(conv_handler)
dp.add_handler(CallbackQueryHandler(manage))
dp.add_handler(MessageHandler(Filters.all, echo))
dp.add_error_handler(error)
#dp.add_handler(MessageHandler(Filters.text, verify))
updater.start_polling()
updater.idle()
"""Fetch URL of the latest comic from its individual page"""
response = requests.get(comic_url_homepage)
soup = BeautifulSoup(response.content, 'html.parser')
latest_comic = soup.find('figure')
# Grab the link for the individual page of the comic as we can start crawling from that
comic_uri_part = latest_comic.find('meta',
{'itemprop': 'contentUrl'})['content']
comic_url = f"{URL_BASE}{comic_uri_part}"
return comic_url
handler_conversation = ConversationHandler(
entry_points=[CommandHandler('comics', _start)],
states={
State.MENU: [
CallbackQueryHandler(_random_menu,
pattern=f"^{Command.RANDOM_MENU}$"),
CallbackQueryHandler(_schedule_menu,
pattern=f"^{Command.SCHEDULE_MENU}$"),
CallbackQueryHandler(helper.cancel, pattern=f"^{Command.CANCEL}$"),
],
State.SCHEDULE: [
CallbackQueryHandler(helper.cancel, pattern=f"^{Command.CANCEL}$"),
CallbackQueryHandler(_schedule_post),
],
State.RANDOM: [
CallbackQueryHandler(helper.cancel, pattern=f"^{Command.CANCEL}$"),
CallbackQueryHandler(_random_post),
]
},
fallbacks=[MessageHandler(Filters.all, helper.confused)])
__mod_name__ = "Anti-Flood"
FLOOD_BAN_HANDLER = MessageHandler(Filters.all & ~Filters.status_update
& Filters.chat_type.groups,
check_flood,
run_async=True)
SET_FLOOD_HANDLER = CommandHandler("setflood",
set_flood,
filters=Filters.chat_type.groups,
run_async=True)
SET_FLOOD_MODE_HANDLER = CommandHandler(
"setfloodmode", set_flood_mode,
run_async=True) # , filters=Filters.chat_type.groups)
FLOOD_QUERY_HANDLER = CallbackQueryHandler(flood_button,
pattern=r"unmute_flooder",
run_async=True)
FLOOD_HANDLER = CommandHandler("flood",
flood,
filters=Filters.chat_type.groups,
run_async=True)
dispatcher.add_handler(FLOOD_BAN_HANDLER, FLOOD_GROUP)
dispatcher.add_handler(FLOOD_QUERY_HANDLER)
dispatcher.add_handler(SET_FLOOD_HANDLER)
dispatcher.add_handler(SET_FLOOD_MODE_HANDLER)
dispatcher.add_handler(FLOOD_HANDLER)
__handlers__ = [
(FLOOD_BAN_HANDLER, FLOOD_GROUP),
SET_FLOOD_HANDLER,
*Admin only:*
- /warn <userhandle>: warn a user. After 3 warns, the user will be banned from the group. Can also be used as a reply.
- /resetwarn <userhandle>: reset the warnings for a user. Can also be used as a reply.
- /addwarn <keyword> <reply message>: set a warning filter on a certain keyword. If you want your keyword to \
be a sentence, encompass it with quotes, as such: `/addwarn "very angry" This is an angry user`.
- /nowarn <keyword>: stop a warning filter
- /warnlimit <num>: set the warning limit
- /strongwarn <on/yes/off/no>: If set to on, exceeding the warn limit will result in a ban. Else, will just kick.
"""
__mod_name__ = "Warnings"
WARN_HANDLER = CommandHandler("warn", warn_user, pass_args=True, filters=Filters.group)
RESET_WARN_HANDLER = CommandHandler(["resetwarn", "resetwarns"], reset_warns, pass_args=True, filters=Filters.group)
RMWARN_QUERY_HANDLER = CallbackQueryHandler(rmwarn_handler, pattern=r"rm_warn")
SENDRULES_QUERY_HANDLER = CallbackQueryHandler(sendrules_handler, pattern=r"send_rules")
MYWARNS_HANDLER = DisableAbleCommandHandler("warns", warns, pass_args=True, filters=Filters.group)
ADD_WARN_HANDLER = CommandHandler("addwarn", 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(RMWARN_QUERY_HANDLER)
dispatcher.add_handler(SENDRULES_QUERY_HANDLER)
dispatcher.add_handler(RESET_WARN_HANDLER)
dispatcher.add_handler(MYWARNS_HANDLER)
dispatcher.add_handler(ADD_WARN_HANDLER)
updater.dispatcher.add_handler(CommandHandler('ping', ping))
updater.dispatcher.add_handler(CommandHandler('newgame', newgame))
updater.dispatcher.add_handler(CommandHandler('join', join))
updater.dispatcher.add_handler(CommandHandler('debugjoin', debugjoin))
updater.dispatcher.add_handler(CommandHandler('endjoin', endjoin))
updater.dispatcher.add_handler(CommandHandler('endday', endday))
updater.dispatcher.add_handler(CommandHandler('power', power))
updater.dispatcher.add_handler(CommandHandler('status', status))
updater.dispatcher.add_handler(CommandHandler('role', role))
updater.dispatcher.add_handler(CommandHandler('debug', debug))
updater.dispatcher.add_handler(CommandHandler('debuggameslist',
debuggameslist))
updater.dispatcher.add_handler(CommandHandler('kill', kill))
updater.dispatcher.add_handler(CommandHandler('save', save))
updater.dispatcher.add_handler(CommandHandler('load', load))
updater.dispatcher.add_handler(CommandHandler('delete', delete))
updater.dispatcher.add_handler(
CommandHandler('debugchangerole', debugchangerole))
updater.dispatcher.add_handler(CallbackQueryHandler(inlinekeyboard))
updater.dispatcher.add_error_handler(breakpoint_here)
if __name__ == "__main__":
updater.start_polling()
while True:
try:
updater.idle()
except TimedOut:
time.sleep(10)
caption=tl(
update.effective_message,
"*Berhasil!*\n\nKerja bagus manusia, kini Anda dapat chatting di: *{}*"
).format(chat_name),
parse_mode="markdown"))
query.answer(text=tl(
update.effective_message,
"Berhasil! Anda dapat chatting di {} sekarang").format(chat_name),
show_alert=True)
else:
context.bot.edit_message_media(
chat.id,
message_id=query.message.message_id,
media=InputMediaPhoto(
media="https://telegra.ph/file/d81cdcbafb240071add84.jpg",
caption=tl(
update.effective_message,
"Maaf robot, kamu telah salah klik tombol verifikasi.\n\nCoba lagi dengan klik tombol verifikasi pada pesan selamat datang."
),
parse_mode="markdown"))
query.answer(text=tl(
update.effective_message,
"Gagal! Kamu telah salah mengklik tombol verifikasi"),
show_alert=True)
verify_callback_handler = CallbackQueryHandler(verify_button_pressed,
pattern=r"verify_me")
dispatcher.add_handler(verify_callback_handler)
'user'].get('name'),
date=now_date,
question=question_text)
support_keyboard = keyboards.get_support_keyboard(link=(Config.APP_URL + '/users/' + str(user_id) + '/edit'))
context.bot.send_message(chat_id=Config.TELEGRAM_SUPPORT_GROUP, text=support_message, parse_mode=ParseMode.HTML,
reply_markup=support_keyboard)
message = context.user_data['support_message']
context.bot.delete_message(chat_id=message.chat_id, message_id=message.message_id)
success_message = strings.get_string('support.success', language)
update.message.reply_text(text=success_message)
Navigation.to_account(update, context, new_message=True)
del context.user_data['has_action']
return ConversationHandler.END
else:
return SUPPORT
support_conversation = ConversationHandler(
entry_points=[CallbackQueryHandler(start, pattern='account:support')],
states={
SUPPORT: [MessageHandler(TelegramFilters.text, support)]
},
fallbacks=[
account.account_handler,
referral.referral_handler,
faq.faq_handler,
about.about_handler,
news.news_handler
]
)
def main(poll=True):
telegram_token = os.environ['TELEGRAM_TOKEN']
updater = Updater(telegram_token)
disp = updater.dispatcher
disp.add_error_handler(error)
conv_handler = ConversationHandler(
entry_points=[CommandHandler('start', start, pass_user_data=True), ],
states={
CHOICE: [CallbackQueryHandler(start_button, pass_user_data=True)],
LOCATION: [MessageHandler(Filters.location, got_location, pass_user_data=True)],
GET_DATA: [CallbackQueryHandler(data_from_db, pass_user_data=True)],
FILTERS: [CallbackQueryHandler(filters, pass_user_data=True)],
SELECT_STATION: [CallbackQueryHandler(select_station, pass_user_data=True)],
PHOTO: [(MessageHandler(Filters.document, send_file_dbx, pass_user_data=True)),
MessageHandler(Filters.photo, send_file_dbx, pass_user_data=True)],
PAGINATION: [CallbackQueryHandler(pagin_handler, pass_user_data=True)],
STEPCHANGE: [CallbackQueryHandler(step_set, pass_user_data=True),
RegexHandler(r'\d{1,3}', step_set, pass_user_data=True)],
FILTERS_CHANGE: [CallbackQueryHandler(filters_change, pass_user_data=True)],
DATE_CHOICE: [CallbackQueryHandler(date_choice, pass_user_data=True)],
DATE_OR_RANGE: [CallbackQueryHandler(date_range_or_spec, pass_user_data=True)],
DATE_RANGE_CHOICE: [CallbackQueryHandler(date_range_choice, pass_user_data=True)],
FILTER_SELECTION: [CallbackQueryHandler(filter_selection,
pass_user_data=True)],
STAT_FUNCTION: [CallbackQueryHandler(stat_function, pass_user_data=True)]
},
fallbacks=[CommandHandler('cancel', cancel, pass_user_data=True)]
)
disp.add_handler(conv_handler)
disp.add_handler(CommandHandler("help", helpme))
disp.add_handler(CommandHandler("start", start, pass_user_data=True))
disp.add_error_handler(error)
if poll:
updater.start_polling()
updater.idle()
else:
updater.start_webhook(listen="0.0.0.0",
port=int(os.environ['PORT']),
url_path=telegram_token)
updater.bot.setWebhook(f'{os.environ["URL_PATH"]}/{telegram_token}')
updater.idle()
def main():
updater = Updater("1549956005:AAGbQQsAjmO6ZWHxY4hdpIKCITrZglKQRC0", use_context=True)
dp = updater.dispatcher
dp.add_handler(CommandHandler("start", start))
dp.add_handler(CommandHandler("help", help))
dp.add_handler(CallbackQueryHandler( kafedra_KMAD , pattern = 'kafedra_KMAD'))
dp.add_handler(CallbackQueryHandler( umovy_vstupu , pattern = 'umovy_vstupu'))
dp.add_handler(CallbackQueryHandler(moglyv_stud, pattern = 'moglyv_stud'))
#kafedra_kmad
dp.add_handler(CallbackQueryHandler(vykladach,
pattern ='vykladach'))
dp.add_handler(CallbackQueryHandler(vidmin_kaf,
pattern ='vidmin_kaf'))
dp.add_handler(CallbackQueryHandler(hist_kaf,
pattern ='hist_kaf'))
dp.add_handler(CallbackQueryHandler(aud_kaf,
pattern ='aud_kaf'))
dp.add_handler(CallbackQueryHandler(n_vypuskniki,
pattern ='n_vypuskniki'))
dp.add_handler(CallbackQueryHandler(proekt_nav, pattern = 'proekt_nav'))
dp.add_handler(CallbackQueryHandler(du_osvita, pattern = 'du_osvita'))
dp.add_handler(CallbackQueryHandler(pracevl, pattern = 'pracevl'))
dp.add_handler(CallbackQueryHandler(prakt, pattern = 'prakt'))
#umovy_vstupu
dp.add_handler(CallbackQueryHandler(konk_pred_ZNO,
pattern ='konk_pred_ZNO'))
dp.add_handler(CallbackQueryHandler(pozp_konk_bal,
pattern ='pozp_konk_bal'))
dp.add_handler(CallbackQueryHandler(etap_vstup_komp,
pattern ='etap_vstup_komp'))
dp.add_handler(CallbackQueryHandler(kor_pos,
pattern ='kor_pos'))
dp.add_handler(CallbackQueryHandler(mt_budj_kont_mt_vstup,
pattern ='mt_budj_kont_mt_vstup'))
'''
dp.add_handler(CallbackQueryHandler(about_of_CMAD_department,
pattern = 'about_of_CMAD_department'))
dp.add_handler(CallbackQueryHandler(opportunties_for_the_student,
pattern = 'opportunties_for_the_student'))
dp.add_handler(CallbackQueryHandler(conditions_of_entry,
pattern = 'conditions_of_entry'))
'''
#dfdua
#djfdsfusdu
dp.add_handler(MessageHandler(Filters.text, echo))
dp.add_error_handler(error)
updater.start_polling()
updater.idle()
dp.add_handler(CallbackQueryHandler(vykladach,
pattern ='Викладачі'))
dp.add_handler(CallbackQueryHandler(vidmin_kaf,
pattern ='Відомості о Кафедрі'))
dp.add_handler(CallbackQueryHandler(hist_kaf,
pattern ='Історична Кафедра'))
dp.add_handler(CallbackQueryHandler(aud_kaf,
pattern ='Аудеторія Кафедри'))
dp.add_handler(CallbackQueryHandler(n_vypuskniki,
pattern ='Наші Випусники'))
"Removing of all approved users has been cancelled.")
return ""
if member.status == "administrator":
query.answer("Only owner of the chat can do this.")
if member.status == "member":
query.answer("You need to be admin to do this.")
from tg_bot.modules.language import gs
def get_help(chat):
return gs(chat, "approve_help")
APPROVE = DisableAbleCommandHandler("approve", approve, run_async=True, filters=Filters.chat_type.groups)
DISAPPROVE = DisableAbleCommandHandler("unapprove", disapprove, run_async=True, filters=Filters.chat_type.groups)
APPROVED = DisableAbleCommandHandler("approved", approved, run_async=True, filters=Filters.chat_type.groups)
APPROVAL = DisableAbleCommandHandler("approval", approval, run_async=True, filters=Filters.chat_type.groups)
UNAPPROVEALL = DisableAbleCommandHandler("unapproveall", unapproveall, run_async=True, filters=Filters.chat_type.groups)
UNAPPROVEALL_BTN = CallbackQueryHandler(
unapproveall_btn, pattern=r"unapproveall_.*")
dispatcher.add_handler(APPROVE)
dispatcher.add_handler(DISAPPROVE)
dispatcher.add_handler(APPROVED)
dispatcher.add_handler(APPROVAL)
dispatcher.add_handler(UNAPPROVEALL)
dispatcher.add_handler(UNAPPROVEALL_BTN)
__mod_name__ = "Approvals"
__command_list__ = ["approve", "unapprove", "approved", "approval"]
__handlers__ = [APPROVE, DISAPPROVE, APPROVED, APPROVAL]
def callback_handler(handler_func):
"""Create a callback handler."""
return CallbackQueryHandler(handler_func, pass_user_data=True)
def main():
updater = Updater(KEY)
dispatcher = updater.dispatcher
# group filters
dispatcher.add_handler(
MessageHandler(Filters.status_update.new_chat_members, greeting))
dispatcher.add_handler(
MessageHandler((Filters.command & Filters.group), del_command))
dispatcher.add_handler(
MessageHandler((Filters.group & block_filter), del_msg))
dispatcher.add_handler(
MessageHandler((Filters.text & Filters.group), group_chat_logging))
dispatcher.add_handler(CommandHandler("start", start_command))
dispatcher.add_handler(CommandHandler("help", help_command))
dispatcher.add_handler(CommandHandler("about", about_command))
dispatcher.add_handler(MessageHandler(filt_integers, apartment_save))
dispatcher.add_handler(MessageHandler(filt_call_err, talkative))
dispatcher.add_handler(MessageHandler(Filters.text, msg_handler))
dispatcher.add_handler(
CallbackQueryHandler(callback=start_command, pattern='^_menu$'))
dispatcher.add_handler(
CallbackQueryHandler(callback=building, pattern='^building$'))
dispatcher.add_handler(
CallbackQueryHandler(callback=statistics, pattern='^statistics$'))
dispatcher.add_handler(
CallbackQueryHandler(callback=charts, pattern='^charts$'))
dispatcher.add_handler(
CallbackQueryHandler(callback=notifications_kbd,
pattern='^notifications$'))
dispatcher.add_handler(
CallbackQueryHandler(
callback=notifications_save,
pattern='^_notify_section$|^_notify_house$|^_notify_OFF$'))
dispatcher.add_handler(
CallbackQueryHandler(callback=houses_kbd, pattern='^show$'))
dispatcher.add_handler(
CallbackQueryHandler(callback=show_house, pattern='^show_this_house$'))
dispatcher.add_handler(
CallbackQueryHandler(callback=section_kbd, pattern='^p_h'))
dispatcher.add_handler(
CallbackQueryHandler(callback=save_params, pattern='^p_s'))
dispatcher.add_handler(
CallbackQueryHandler(
callback=check_owns,
pattern='^edit$|^house_neighbors$|section_neighbors'))
dispatcher.add_handler(
CallbackQueryHandler(callback=owns_selected, pattern='^set_owns'))
dispatcher.add_handler(
CallbackQueryHandler(callback=set_section_kbd, pattern='^_h'))
dispatcher.add_handler(
CallbackQueryHandler(
callback=save_user_data,
pattern='^_apart_reject$|^_floor_reject$|^_section_reject$'))
dispatcher.add_handler(
CallbackQueryHandler(callback=set_floor_kbd, pattern='^_s'))
dispatcher.add_handler(
CallbackQueryHandler(callback=set_apartment_kbd, pattern='^_f'))
dispatcher.add_error_handler(catch_err)
updater.start_polling()
updater.idle()
def callcommand_handler(command_message, handler_func):
"""Create a callback handler that only handles specific commands."""
return CallbackQueryHandler(handler_func,
pattern=command_message + "$",
pass_user_data=True)
def start(self):
self.updater.dispatcher.add_handler(
CommandHandler('start', self.do_start))
self.updater.dispatcher.add_handler(
CommandHandler('help', self.do_help))
self.updater.dispatcher.add_handler(
MessageHandler(Filters.regex(r'^\d+$'), self.do_digit_command))
self.updater.dispatcher.add_handler(
MessageHandler(Filters.regex(r'\w+'), self.do_text_command))
self.updater.dispatcher.add_handler(
CallbackQueryHandler(main_menu, pattern='main'))
#find gas station
self.updater.dispatcher.add_handler(
MessageHandler(Filters.location, filtered_gas_stations))
self.updater.dispatcher.add_handler(
CallbackQueryHandler(submit_target_gas_station,
pattern=r'targetgasstation_\d+'))
#choose active filter
self.updater.dispatcher.add_handler(
CallbackQueryHandler(choose_active_filter,
pattern='choose_active_filter'))
self.updater.dispatcher.add_handler(
CallbackQueryHandler(submit_active_filter,
pattern=r'activefilter_\d+'))
#edit filter
self.updater.dispatcher.add_handler(
CallbackQueryHandler(add_filter_menu, pattern='m1_add_filter'))
self.updater.dispatcher.add_handler(
CallbackQueryHandler(tune_filters_menu, pattern='tune_filters'))
self.updater.dispatcher.add_handler(
CallbackQueryHandler(choose_filter, pattern=r'editfilter_\d+'))
self.updater.dispatcher.add_handler(
CallbackQueryHandler(change_filter_name,
pattern='change_filter_name'))
self.updater.dispatcher.add_handler(
CallbackQueryHandler(change_filter_radius,
pattern='change_filter_radius'))
self.updater.dispatcher.add_handler(
CallbackQueryHandler(change_target_fuel,
pattern='change_target_fuel'))
self.updater.dispatcher.add_handler(
CallbackQueryHandler(submit_fuel_type, pattern=r'fueltype_\w+'))
for property in GasStationProperties._meta.get_fields():
self.updater.dispatcher.add_handler(
CallbackQueryHandler(select_filter_property,
pattern=property.name))
#price statistic
self.updater.dispatcher.add_handler(
CallbackQueryHandler(price_statistic, pattern='price_statistic'))
self.updater.dispatcher.add_handler(
CallbackQueryHandler(submit_price_statistic,
pattern=r'pricestatistic_\w+'))
self.updater.start_polling()
self.updater.idle()
chat_id=update.effective_message.chat_id,
text='Сообщение было успешно разослано!',
reply_markup=get_base_reply_keyboard(context.user_data['Role'])
)
return ConversationHandler.END
else:
update.message.reply_text(
'Отправка материала была отменена',
reply_markup=get_base_reply_keyboard(member_role=context.user_data['Role'])
)
return ConversationHandler.END
send_newsletter_handler = ConversationHandler(
entry_points=[
CallbackQueryHandler(callback=send_newsletter_start, pattern='For *')
],
states={
NEWSLETTER_TEXT: [
MessageHandler(Filters.all, send_newsletter)
]
},
fallbacks=[]
)
@debug_requests
def setup_new_member_start(update: Update, context: CallbackContext):
context.user_data['Name'], context.user_data['Role'], context.user_data['Chat_ID'] = get_user_info(
user_id=update.effective_user.id)
context.bot.send_message(
Reply 3`
• `/stop <filter keyword>`*:* Stop that filter.
*Chat creator only:*
• `/removeallfilters`*:* Remove all chat filters at once.
*Note*: Filters also support markdown formatters like: {first}, {last} etc.. and buttons.
Check `/markdownhelp` to know more!
"""
__mod_name__ = "Filters"
FILTER_HANDLER = CommandHandler("filter", filters)
STOP_HANDLER = CommandHandler("stop", stop_filter)
RMALLFILTER_HANDLER = CommandHandler("removeallfilters",
rmall_filters,
filters=Filters.group)
RMALLFILTER_CALLBACK = CallbackQueryHandler(rmall_callback,
pattern=r"filters_.*")
LIST_HANDLER = DisableAbleCommandHandler("filters",
list_handlers,
admin_ok=True)
CUST_FILTER_HANDLER = MessageHandler(
CustomFilters.has_text & ~Filters.update.edited_message, 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)
dispatcher.add_handler(RMALLFILTER_HANDLER)
dispatcher.add_handler(RMALLFILTER_CALLBACK)
__handlers__ = [
FILTER_HANDLER, STOP_HANDLER, LIST_HANDLER,
__mod_name__ = "Connection"
__help__ = """
Sometimes, you just want to add some notes and filters to a group chat, but you don't want everyone to see; This is where connections come in...
This allows you to connect to a chat's database, and add things to it without the commands appearing in chat! For obvious reasons, you need to be an admin to add things; but any member in the group can view your data.
• /connect: Connects to chat (Can be done in a group by /connect or /connect <chat id> in PM)
• /connection: List connected chats
• /disconnect: Disconnect from a chat
• /helpconnect: List available commands that can be used remotely
*Admin only:*
• /allowconnect <yes/no>: allow a user to connect to a chat
"""
CONNECT_CHAT_HANDLER = CommandHandler("connect", connect_chat, pass_args=True)
CONNECTION_CHAT_HANDLER = CommandHandler("connection", connection_chat)
DISCONNECT_CHAT_HANDLER = CommandHandler("disconnect", disconnect_chat)
ALLOW_CONNECTIONS_HANDLER = CommandHandler(
"allowconnect", allow_connections, pass_args=True)
HELP_CONNECT_CHAT_HANDLER = CommandHandler("helpconnect", help_connect_chat)
CONNECT_BTN_HANDLER = CallbackQueryHandler(connect_button, pattern=r"connect")
dispatcher.add_handler(CONNECT_CHAT_HANDLER)
dispatcher.add_handler(CONNECTION_CHAT_HANDLER)
dispatcher.add_handler(DISCONNECT_CHAT_HANDLER)
dispatcher.add_handler(ALLOW_CONNECTIONS_HANDLER)
dispatcher.add_handler(HELP_CONNECT_CHAT_HANDLER)
dispatcher.add_handler(CONNECT_BTN_HANDLER)
pass_args=True,
filters=Filters.group)
SECURITY_MUTE_HANDLER = CommandHandler("welcomemutetime",
security_mute,
pass_args=True,
filters=Filters.group)
SECURITY_HANDLER = CommandHandler("welcomesecurity",
security,
pass_args=True,
filters=Filters.group)
CLEAN_SERVICE_HANDLER = CommandHandler("cleanservice",
cleanservice,
pass_args=True,
filters=Filters.group)
help_callback_handler = CallbackQueryHandler(check_bot_button,
pattern=r"check_bot_")
dispatcher.add_handler(NEW_MEM_HANDLER)
dispatcher.add_handler(LEFT_MEM_HANDLER)
dispatcher.add_handler(WELC_PREF_HANDLER)
dispatcher.add_handler(GOODBYE_PREF_HANDLER)
dispatcher.add_handler(SET_WELCOME)
dispatcher.add_handler(SET_GOODBYE)
dispatcher.add_handler(RESET_WELCOME)
dispatcher.add_handler(RESET_GOODBYE)
dispatcher.add_handler(CLEAN_WELCOME)
dispatcher.add_handler(SECURITY_HANDLER)
dispatcher.add_handler(SECURITY_MUTE_HANDLER)
dispatcher.add_handler(CLEAN_SERVICE_HANDLER)
dispatcher.add_handler(help_callback_handler)
Reply 3`
❍ /clear <notename>*:* clear note with this name
❍ /removeallnotes*:* removes all notes from the group
*Note:* Note names are case-insensitive, and they are automatically converted to lowercase before getting saved.
"""
__mod_name__ = "Notes"
GET_HANDLER = CommandHandler("get", cmd_get)
HASH_GET_HANDLER = MessageHandler(Filters.regex(r"^#[^\s]+"), hash_get)
SLASH_GET_HANDLER = MessageHandler(Filters.regex(r"^/\d+$"), slash_get)
SAVE_HANDLER = CommandHandler("save", save)
DELETE_HANDLER = CommandHandler("clear", clear)
LIST_HANDLER = DisableAbleCommandHandler(["notes", "saved"],
list_notes,
admin_ok=True)
CLEARALL = DisableAbleCommandHandler("removeallnotes", clearall)
CLEARALL_BTN = CallbackQueryHandler(clearall_btn, pattern=r"notes_.*")
dispatcher.add_handler(GET_HANDLER)
dispatcher.add_handler(SAVE_HANDLER)
dispatcher.add_handler(LIST_HANDLER)
dispatcher.add_handler(DELETE_HANDLER)
dispatcher.add_handler(HASH_GET_HANDLER)
dispatcher.add_handler(SLASH_GET_HANDLER)
dispatcher.add_handler(CLEARALL)
dispatcher.add_handler(CLEARALL_BTN)
• `/imdb` <anime/movie name> *:* get IMDb details of the anime or movie
➩ *Anime Fun:*
• `/aq` *:* get random anime quotes
"""
ANIME_HANDLER = DisableAbleCommandHandler("anime", anime)
AIRING_HANDLER = DisableAbleCommandHandler("airing", airing)
CHARACTER_HANDLER = DisableAbleCommandHandler("character", character)
MANGA_HANDLER = DisableAbleCommandHandler("manga", manga)
USER_HANDLER = DisableAbleCommandHandler("user", user)
UPCOMING_HANDLER = DisableAbleCommandHandler("upcoming", upcoming)
KAIZOKU_SEARCH_HANDLER = DisableAbleCommandHandler("kaizoku", kaizoku)
KAYO_SEARCH_HANDLER = DisableAbleCommandHandler("kayo", kayo)
BUTTON_HANDLER = CallbackQueryHandler(button, pattern='anime_.*')
dispatcher.add_handler(BUTTON_HANDLER)
dispatcher.add_handler(ANIME_HANDLER)
dispatcher.add_handler(CHARACTER_HANDLER)
dispatcher.add_handler(MANGA_HANDLER)
dispatcher.add_handler(AIRING_HANDLER)
dispatcher.add_handler(USER_HANDLER)
dispatcher.add_handler(KAIZOKU_SEARCH_HANDLER)
dispatcher.add_handler(KAYO_SEARCH_HANDLER)
dispatcher.add_handler(UPCOMING_HANDLER)
__mod_name__ = "Anime"
__command_list__ = [
"anime", "manga", "character", "user", "upcoming", "kaizoku", "airing",
"kayo"
if query_type == "db_leave_chat":
if query.from_user.id in admin_list:
bot.editMessageText("Dejando chats...", chat_id, message.message_id)
chat_count = get_muted_chats(update, context, True)
bot.sendMessage(chat_id, f"Chats abandonados: {chat_count}.")
else:
query.answer("No tienes permitido usar esto.")
elif query_type == "db_cleanup":
if query.from_user.id in admin_list:
bot.editMessageText("Limpiando BD...", chat_id, message.message_id)
invalid_chat_count = get_invalid_chats(update, context, True)
invalid_gban_count = get_invalid_gban(update, context, True)
reply = "Se limpiaron {} chats y {} usuarios bloqueados globalmente de la BD.".format(
invalid_chat_count, invalid_gban_count
)
bot.sendMessage(chat_id, reply)
else:
query.answer("No tienes permitido usar esto.")
DB_CLEANUP_HANDLER = CommandHandler("dbcleanup", dbcleanup, run_async=True)
BUTTON_HANDLER = CallbackQueryHandler(callback_button, pattern="db_.*", run_async=True)
dispatcher.add_handler(DB_CLEANUP_HANDLER)
dispatcher.add_handler(BUTTON_HANDLER)
__mod_name__ = "DB Cleanup"
__handlers__ = [DB_CLEANUP_HANDLER, BUTTON_HANDLER]
__command_list__ = ["dbcleanup"]
