def reply_filter(update: Update, context: CallbackContext) -> str:
chat: Optional[Chat] = update.effective_chat
message: Optional[Message] = update.effective_message
user: Optional[User] = update.effective_user
if not user: # Ignore channel
return
if user.id == 777000:
return
if is_approved(chat.id, user.id):
return
chat_warn_filters = sql.get_chat_warn_triggers(chat.id)
to_match = extract_text(message)
if not to_match:
return ""
for keyword in chat_warn_filters:
pattern = r"( |^|[^\w])" + re.escape(keyword) + r"( |$|[^\w])"
if re.search(pattern, to_match, flags=re.IGNORECASE):
user: Optional[User] = update.effective_user
warn_filter = sql.get_warn_filter(chat.id, keyword)
return warn(user, chat, warn_filter.reply, message)
return ""
def disapprove(update, context):
message = update.effective_message
chat_title = message.chat.title
chat = update.effective_chat
args = context.args
user = update.effective_user
user_id = extract_user(message, args)
if not user_id:
message.reply_text(
"I don't know who you're talking about, you're going to need to specify a user!"
)
return ""
try:
member = chat.get_member(user_id)
except BadRequest:
return ""
if member.status in ("administrator", "creator"):
message.reply_text("This user is an admin, they can't be unapproved.")
return ""
if not redis.is_approved(message.chat_id, user_id):
message.reply_text(f"{member.user['first_name']} isn't approved yet!")
return ""
redis.disapprove(message.chat_id, user_id)
message.reply_text(
f"{member.user['first_name']} is no longer approved in {chat_title}.")
log_message = (
f"<b>{html.escape(chat.title)}:</b>\n"
f"#UNAPPROVED\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)}")
return log_message
def check_user(user_id: int, bot: Bot, chat: Chat) -> Optional[str]:
if not user_id:
reply = "You don't seem to be referring to a user or the ID specified is incorrect.."
return reply
if is_approved(chat.id, user_id):
reply = (
"This is user is approved in this chat and approved users can't be muted!"
)
return reply
try:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "User not found":
reply = "I can't seem to find this user"
return reply
raise
if user_id == bot.id:
reply = "I'm not gonna MUTE myself, How high are you?"
return reply
if is_user_admin(chat, user_id, member) or user_id in FAFNIRS:
reply = "Can't. Find someone else to mute but not this one."
return reply
return None
def approval(update, context):
message = update.effective_message
chat = update.effective_chat
args = context.args
user_id = extract_user(message, args)
member = chat.get_member(int(user_id))
if not user_id:
message.reply_text(
"I don't know who you're talking about, you're going to need to specify a user!"
)
return ""
if redis.is_approved(message.chat_id, user_id):
message.reply_text(
f"{member.user['first_name']} is an approved user. Locks, antiflood, warns, bans, mutes, kicks and blacklists won't apply to them."
)
else:
message.reply_text(
f"{member.user['first_name']} is not an approved user. They are affected by normal commands."
)
def approve(update, context):
message = update.effective_message
chat_title = message.chat.title
chat = update.effective_chat
args = context.args
user = update.effective_user
user_id = extract_user(message, args)
if not user_id:
message.reply_text(
"I don't know who you're talking about, you're going to need to specify a user!"
)
return ""
try:
member = chat.get_member(user_id)
except BadRequest:
return ""
if member.status in ("administrator", "creator"):
message.reply_text("No need to approve an Admin!")
return ""
if redis.is_approved(message.chat_id, user_id):
message.reply_text(
f"[{member.user['first_name']}](tg://user?id={member.user['id']}) is already approved in {chat_title}",
parse_mode=ParseMode.MARKDOWN,
)
return ""
redis.approve(message.chat_id, user_id)
message.reply_text(
f"[{member.user['first_name']}](tg://user?id={member.user['id']}) has been approved in {chat_title}! They will now be ignored by admin actions like locks, blacklists, warns, bans, mutes, kicks and antiflood",
parse_mode=ParseMode.MARKDOWN,
)
log_message = (
f"<b>{html.escape(chat.title)}:</b>\n"
f"#APPROVED\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)}")
return log_message
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 is_approved(chat.id, user.id):
sql.update_flood(chat.id, None)
return
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.ban_member(user.id)
execstrings = "Banned"
tag = "BANNED"
elif getmode == 2:
chat.ban_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.ban_member(user.id, until_date=bantime)
execstrings = f"Banned for {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 = f"Muted for {getvalue}"
tag = "TMUTE"
send_message(
update.effective_message,
"Wanna Spam?! Sorry it's not your house Man!\n{}!".format(
execstrings),
)
return ("<b>{}:</b>"
"\n#{}"
"\n<b>User:</b> {}"
"\nFlooded the group.".format(
html.escape(chat.title), tag,
mention_html(user.id, user.first_name)))
except BadRequest:
msg.reply_text(
"I can't restrict people here, give me permissions first! Until then, I'll disable anti-flood."
)
sql.set_flood(chat.id, 0)
return (
"<b>{}:</b>"
"\n#INFO"
"\nDon't have enough permission to restrict users so automatically disabled anti-flood"
.format(chat.title))
def warn(user: User,
chat: Chat,
reason: str,
message: Message,
warner: User = None) -> str:
if is_user_admin(chat, user.id):
# message.reply_text("Damn admins, They are too far to be One Punched!")
return
if is_approved(chat.id, user.id):
if warner:
message.reply_text(
"This user is approved in this chat and Approved users can't be warned!"
)
else:
message.reply_text(
"Approved user triggered an auto filter! But they can't be warned."
)
return
if user.id in FAFNIRS:
if warner:
message.reply_text("Scouts cant be warned.")
else:
message.reply_text(
"Scout triggered an auto warn filter!\n I can't warn scouts but they should avoid abusing this."
)
return
if user.id in LUINORS:
if warner:
message.reply_text("Garrisons are warn immune.")
else:
message.reply_text(
"Garrison triggered an auto warn filter!\nI can't warn garrisons but they should avoid abusing this."
)
return
if warner:
warner_tag = mention_html(warner.id, warner.first_name)
else:
warner_tag = "Automated warn filter."
limit, soft_warn = sql.get_warn_setting(chat.id)
num_warns, reasons = sql.warn_user(user.id, chat.id, reason)
if num_warns >= limit:
sql.reset_warns(user.id, chat.id)
if soft_warn: # punch
chat.unban_member(user.id)
reply = (
f"<code>�</code><b>kick Event</b>\n"
f"<code> </code><b>• User:</b> {mention_html(user.id, user.first_name)}\n"
f"<code> </code><b>• Count:</b> {limit}")
else: # ban
chat.ban_member(user.id)
reply = (
f"<code>�</code><b>Ban Event</b>\n"
f"<code> </code><b>• User:</b> {mention_html(user.id, user.first_name)}\n"
f"<code> </code><b>• Count:</b> {limit}")
for warn_reason in reasons:
reply += f"\n - {html.escape(warn_reason)}"
# message.bot.send_sticker(chat.id, BAN_STICKER) # Saitama's sticker
keyboard = None
log_reason = (
f"<b>{html.escape(chat.title)}:</b>\n"
f"#WARN_BAN\n"
f"<b>Admin:</b> {warner_tag}\n"
f"<b>User:</b> {mention_html(user.id, user.first_name)}\n"
f"<b>Reason:</b> {reason}\n"
f"<b>Counts:</b> <code>{num_warns}/{limit}</code>")
else:
keyboard = InlineKeyboardMarkup([[
InlineKeyboardButton("🔘 Remove warn",
callback_data="rm_warn({})".format(user.id))
]])
reply = (
f"<code>�</code><b>Warn Event</b>\n"
f"<code> </code><b>• User:</b> {mention_html(user.id, user.first_name)}\n"
f"<code> </code><b>• Count:</b> {num_warns}/{limit}")
if reason:
reply += f"\n<code> </code><b>• Reason:</b> {html.escape(reason)}"
log_reason = (
f"<b>{html.escape(chat.title)}:</b>\n"
f"#WARN\n"
f"<b>Admin:</b> {warner_tag}\n"
f"<b>User:</b> {mention_html(user.id, user.first_name)}\n"
f"<b>Reason:</b> {reason}\n"
f"<b>Counts:</b> <code>{num_warns}/{limit}</code>")
try:
message.reply_text(reply,
reply_markup=keyboard,
parse_mode=ParseMode.HTML)
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
message.reply_text(reply,
reply_markup=keyboard,
parse_mode=ParseMode.HTML,
quote=False)
else:
raise
return log_reason
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
if is_approved(chat.id, user.id): # ignore approved users
return
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
if getmode == 1:
message.delete()
elif getmode == 2:
message.delete()
warn(
update.effective_user,
chat,
f"Using sticker '{trigger}' which in blacklist stickers",
message,
update.effective_user,
)
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,
f"{mention_markdown(user.id, user.first_name)} muted because using '{trigger}' which in blacklist stickers",
parse_mode="markdown",
)
return
elif getmode == 4:
message.delete()
res = chat.unban_member(update.effective_user.id)
if res:
bot.sendMessage(
chat.id,
f"{mention_markdown(user.id, user.first_name)} kicked because using '{trigger}' which in blacklist stickers",
parse_mode="markdown",
)
return
elif getmode == 5:
message.delete()
chat.ban_member(user.id)
bot.sendMessage(
chat.id,
f"{mention_markdown(user.id, user.first_name)} banned because using '{trigger}' which in blacklist stickers",
parse_mode="markdown",
)
return
elif getmode == 6:
message.delete()
bantime = extract_time(message, value)
chat.ban_member(user.id, until_date=bantime)
bot.sendMessage(
chat.id,
f"{mention_markdown(user.id, user.first_name)} banned for {value} because using '{trigger}' which in blacklist stickers",
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,
f"{mention_markdown(user.id, user.first_name)} muted for {value} because using '{trigger}' which in blacklist stickers",
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 del_blacklist(update, context):
chat = update.effective_chat
message = update.effective_message
user = update.effective_user
bot = context.bot
to_match = extract_text(message)
if not to_match:
return
if is_approved(chat.id, user.id):
return
getmode, value = sql.get_blacklist_setting(chat.id)
chat_filters = sql.get_chat_blacklist(chat.id)
for trigger in chat_filters:
pattern = f"( |^|[^\\w]){re.escape(trigger)}( |$|[^\\w])"
if re.search(pattern, to_match, flags=re.IGNORECASE):
try:
if getmode == 0:
return
if getmode == 1:
message.delete()
elif getmode == 2:
message.delete()
warn(
update.effective_user,
chat,
f"Using blacklisted trigger: {trigger}",
message,
update.effective_user,
)
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,
f"Muted {user.first_name} for using Blacklisted word: {trigger}!",
)
return
elif getmode == 4:
message.delete()
res = chat.unban_member(update.effective_user.id)
if res:
bot.sendMessage(
chat.id,
f"Kicked {user.first_name} for using Blacklisted word: {trigger}!",
)
return
elif getmode == 5:
message.delete()
chat.ban_member(user.id)
bot.sendMessage(
chat.id,
f"Banned {user.first_name} for using Blacklisted word: {trigger}",
)
return
elif getmode == 6:
message.delete()
bantime = extract_time(message, value)
chat.ban_member(user.id, until_date=bantime)
bot.sendMessage(
chat.id,
f"Banned {user.first_name} until '{value}' for using Blacklisted word: {trigger}!",
)
return
elif getmode == 7:
message.delete()
mutetime = extract_time(message, value)
bot.restrict_chat_member(
chat.id,
user.id,
until_date=mutetime,
permissions=ChatPermissions(can_send_messages=False),
)
bot.sendMessage(
chat.id,
f"Muted {user.first_name} until '{value}' for using Blacklisted word: {trigger}!",
)
return
except BadRequest as excp:
if excp.message != "Message to delete not found":
LOGGER.exception("Error while deleting blacklist message.")
break
