def stop_filter(update, context):
chat = update.effective_chat
user = update.effective_user
args = update.effective_message.text.split(None, 1)
chat_id = update.effective_chat.id
if chat.type == "private":
chat_name = "Local filters"
else:
chat_name = chat.title
if len(args) < 2:
send_message(update.effective_message, "What should i stop?")
return
chat_filters = sql.get_chat_triggers(chat_id)
if not chat_filters:
send_message(update.effective_message, "No filters active here!")
return
for keyword in chat_filters:
if keyword == args[1]:
sql.remove_filter(chat_id, args[1])
send_message(
update.effective_message,
"Okay, I'll stop replying to that filter in *{}*.".format(
chat_name),
parse_mode=telegram.ParseMode.MARKDOWN,
)
raise DispatcherHandlerStop
send_message(
update.effective_message,
"That's not a filter - Click: /filters to get currently active filters.",
)
def flood(update, context):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
msg = update.effective_message
if update.effective_message.chat.type == "private":
send_message(
update.effective_message,
"This command is meant to use in group not in PM",
)
return
chat_id = update.effective_chat.id
chat_name = update.effective_message.chat.title
limit = sql.get_flood_limit(chat_id)
if limit == 0:
text = msg.reply_text("I'm not enforcing any flood control here!")
send_message(update.effective_message, text, parse_mode="markdown")
else:
text = msg.reply_text(
"I'm currently restricting members after {} consecutive messages.".
format(limit))
send_message(update.effective_message, text, parse_mode="markdown")
def list_handlers(update, context):
chat = update.effective_chat
user = update.effective_user
chat_id = update.effective_chat.id
if chat.type == "private":
chat_name = "Local filters"
filter_list = "*local filters:*\n"
else:
chat_name = chat.title
filter_list = "*Filters in {}*:\n"
all_handlers = sql.get_chat_triggers(chat_id)
if not all_handlers:
send_message(update.effective_message,
"No filters saved in {}!".format(chat_name))
return
for keyword in all_handlers:
entry = " × `{}`\n".format(escape_markdown(keyword))
if len(entry) + len(filter_list) > telegram.MAX_MESSAGE_LENGTH:
send_message(
update.effective_message,
filter_list.format(chat_name),
parse_mode=telegram.ParseMode.MARKDOWN,
)
filter_list = entry
else:
filter_list += entry
send_message(
update.effective_message,
filter_list.format(chat_name),
parse_mode=telegram.ParseMode.MARKDOWN,
)
def filters(update, context):
chat = update.effective_chat
user = update.effective_user
msg = update.effective_message
args = msg.text.split(
None,
1) # use python's maxsplit to separate Cmd, keyword, and reply_text
chat_id = update.effective_chat.id
if chat.type == "private":
chat_name = "local filters"
else:
chat_name = chat.title
if not msg.reply_to_message and len(args) < 2:
send_message(
update.effective_message,
"Please provide keyboard keyword for this filter to reply with!",
)
return
if msg.reply_to_message:
if len(args) < 2:
send_message(
update.effective_message,
"Please provide keyword for this filter to reply with!",
)
return
keyword = args[1]
else:
extracted = split_quotes(args[1])
if len(extracted) < 1:
return
# set trigger -> lower, so as to avoid adding duplicate filters with
# different cases
keyword = extracted[0].lower()
# Add the filter
# Note: perhaps handlers can be removed somehow using sql.get_chat_filters
for handler in dispatcher.handlers.get(HANDLER_GROUP, []):
if handler.filters == (keyword, chat_id):
dispatcher.remove_handler(handler, HANDLER_GROUP)
text, file_type, file_id = get_filter_type(msg)
if not msg.reply_to_message and len(extracted) >= 2:
offset = len(extracted[1]) - len(
msg.text) # set correct offset relative to command + notename
text, buttons = button_markdown_parser(extracted[1],
entities=msg.parse_entities(),
offset=offset)
text = text.strip()
if not text:
send_message(
update.effective_message,
"There is no note message - You can't JUST have buttons, you need a message to go with it!",
)
return
elif msg.reply_to_message and len(args) >= 2:
if msg.reply_to_message.text:
text_to_parsing = msg.reply_to_message.text
elif msg.reply_to_message.caption:
text_to_parsing = msg.reply_to_message.caption
else:
text_to_parsing = ""
offset = len(text_to_parsing
) # set correct offset relative to command + notename
text, buttons = button_markdown_parser(text_to_parsing,
entities=msg.parse_entities(),
offset=offset)
text = text.strip()
elif not text and not file_type:
send_message(
update.effective_message,
"Please provide keyword for this filter reply with!",
)
return
elif msg.reply_to_message:
if msg.reply_to_message.text:
text_to_parsing = msg.reply_to_message.text
elif msg.reply_to_message.caption:
text_to_parsing = msg.reply_to_message.caption
else:
text_to_parsing = ""
offset = len(text_to_parsing
) # set correct offset relative to command + notename
text, buttons = button_markdown_parser(text_to_parsing,
entities=msg.parse_entities(),
offset=offset)
text = text.strip()
if (msg.reply_to_message.text
or msg.reply_to_message.caption) and not text:
send_message(
update.effective_message,
"There is no note message - You can't JUST have buttons, you need a message to go with it!",
)
return
else:
send_message(update.effective_message, "Invalid filter!")
return
add = addnew_filter(update, chat_id, keyword, text, file_type, file_id,
buttons)
# This is an old method
# sql.add_filter(chat_id, keyword, content, is_sticker, is_document, is_image, is_audio, is_voice, is_video, buttons)
if add is True:
send_message(
update.effective_message,
"Saved filter '{}' in *{}*!".format(keyword, chat_name),
parse_mode=telegram.ParseMode.MARKDOWN,
)
raise DispatcherHandlerStop
def reply_filter(update, context):
chat = update.effective_chat # type: Optional[Chat]
message = update.effective_message # type: Optional[Message]
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):
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:
valid_format = escape_invalid_curly_brackets(
filt.reply_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=markdown_to_html(filtext),
reply_to_message_id=message.message_id,
parse_mode=ParseMode.HTML,
disable_web_page_preview=True,
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 set_flood_mode(update, context):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
msg = update.effective_message # type: Optional[Message]
args = context.args
if update.effective_message.chat.type == "private":
send_message(
update.effective_message,
"This command is meant to use in group not in PM",
)
return ""
chat = update.effective_chat
chat_id = update.effective_chat.id
chat_name = update.effective_message.chat.title
if args:
if args[0].lower() == "ban":
settypeflood = "ban"
sql.set_flood_strength(chat_id, 1, "0")
elif args[0].lower() == "kick":
settypeflood = "kick"
sql.set_flood_strength(chat_id, 2, "0")
elif args[0].lower() == "mute":
settypeflood = "mute"
sql.set_flood_strength(chat_id, 3, "0")
elif args[0].lower() == "tban":
if len(args) == 1:
teks = """It looks like you tried to set time value for antiflood but you didn't specified time; Try, `/setfloodmode tban <timevalue>`.
Examples of time value: 4m = 4 minutes, 3h = 3 hours, 6d = 6 days, 5w = 5 weeks."""
send_message(update.effective_message,
teks,
parse_mode="markdown")
return
settypeflood = "tban for {}".format(args[1])
sql.set_flood_strength(chat_id, 4, str(args[1]))
elif args[0].lower() == "tmute":
if len(args) == 1:
teks = """It looks like you tried to set time value for antiflood but you didn't specified time; Try, `/setfloodmode tmute <timevalue>`.
Examples of time value: 4m = 4 minutes, 3h = 3 hours, 6d = 6 days, 5w = 5 weeks."""
send_message(update.effective_message,
teks,
parse_mode="markdown")
return
settypeflood = "tmute for {}".format(args[1])
sql.set_flood_strength(chat_id, 5, str(args[1]))
else:
send_message(update.effective_message,
"I only understand ban/kick/mute/tban/tmute!")
return
text = msg.reply_text(
"Exceeding consecutive flood limit will result in {}!".format(
settypeflood))
send_message(update.effective_message, text, parse_mode="markdown")
return ("<b>{}:</b>\n"
"<b>Admin:</b> {}\n"
"Has changed antiflood mode. User will {}.".format(
settypeflood,
html.escape(chat.title),
mention_html(user.id, user.first_name),
))
getmode, getvalue = sql.get_flood_setting(chat.id)
if getmode == 1:
settypeflood = "ban"
elif getmode == 2:
settypeflood = "kick"
elif getmode == 3:
settypeflood = "mute"
elif getmode == 4:
settypeflood = "tban for {}".format(getvalue)
elif getmode == 5:
settypeflood = "tmute for {}".format(getvalue)
text = msg.reply_text(
"Sending more message than flood limit will result in {}.".format(
settypeflood))
send_message(update.effective_message, text, parse_mode=ParseMode.MARKDOWN)
return ""
def set_flood(update, context) -> str:
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
message = update.effective_message # type: Optional[Message]
args = context.args
if update.effective_message.chat.type == "private":
send_message(
update.effective_message,
"This command is meant to use in group not in PM",
)
return ""
chat_id = update.effective_chat.id
chat_name = update.effective_message.chat.title
if len(args) >= 1:
val = args[0].lower()
if val == "off" or val == "no" or val == "0":
sql.set_flood(chat_id, 0)
text = message.reply_text("Antiflood has been disabled.")
send_message(update.effective_message, text, parse_mode="markdown")
elif val.isdigit():
amount = int(val)
if amount <= 0:
sql.set_flood(chat_id, 0)
text = message.reply_text("Antiflood has been disabled.")
return ("<b>{}:</b>"
"\n#SETFLOOD"
"\n<b>Admin:</b> {}"
"\nDisable antiflood.".format(
html.escape(chat_name),
mention_html(user.id, user.first_name)))
if amount < 3:
send_message(
update.effective_message,
"Antiflood must be either 0 (disabled) or number greater than 3!",
)
return ""
sql.set_flood(chat_id, amount)
text = message.reply_text(
"Successfully updated anti-flood limit to {}!".format(amount))
send_message(update.effective_message, text, parse_mode="markdown")
return ("<b>{}:</b>"
"\n#SETFLOOD"
"\n<b>Admin:</b> {}"
"\nSet antiflood to <code>{}</code>.".format(
html.escape(chat_name),
mention_html(user.id, user.first_name),
amount,
))
else:
message.reply_text(
"Invalid argument please use a number, 'off' or 'no'")
else:
message.reply_text(
("Use `/setflood number` to enable anti-flood.\nOr use `/setflood off` to disable antiflood!."
),
parse_mode="markdown",
)
return ""
def check_flood(update, context) -> str:
user = update.effective_user # type: Optional[User]
chat = update.effective_chat # type: Optional[Chat]
msg = update.effective_message # type: Optional[Message]
if not user: # ignore channels
return ""
# ignore admins
if is_user_admin(chat, user.id):
sql.update_flood(chat.id, None)
return ""
should_ban = sql.update_flood(chat.id, user.id)
if not should_ban:
return ""
try:
getmode, getvalue = sql.get_flood_setting(chat.id)
if getmode == 1:
chat.kick_member(user.id)
execstrings = "Banned"
tag = "BANNED"
elif getmode == 2:
chat.kick_member(user.id)
chat.unban_member(user.id)
execstrings = "Kicked"
tag = "KICKED"
elif getmode == 3:
context.bot.restrict_chat_member(
chat.id,
user.id,
permissions=ChatPermissions(can_send_messages=False))
execstrings = "Muted"
tag = "MUTED"
elif getmode == 4:
bantime = extract_time(msg, getvalue)
chat.kick_member(user.id, until_date=bantime)
execstrings = "Banned for {}".format(getvalue)
tag = "TBAN"
elif getmode == 5:
mutetime = extract_time(msg, getvalue)
context.bot.restrict_chat_member(
chat.id,
user.id,
until_date=mutetime,
permissions=ChatPermissions(can_send_messages=False),
)
execstrings = "Muted for {}".format(getvalue)
tag = "TMUTE"
send_message(
update.effective_message,
"Great, I like to leave flooding to natural disasters but you, "
"you were just a disappointment. {}!".format(execstrings),
)
return ("<b>{}:</b>"
"\n#{}"
"\n<b>User:</b> {}"
"\nFlooded the group.".format(
tag, html.escape(chat.title),
mention_html(user.id, user.first_name)))
except BadRequest:
msg.reply_text(
"I can't restrict people here, give me permissions first! Until then, I'll disable anti-flood."
)
sql.set_flood(chat.id, 0)
return (
"<b>{}:</b>"
"\n#INFO"
"\nDon't have enough permission to restrict users so automatically disabled anti-flood"
.format(chat.title))