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 == "administrator" or member.status == "creator":
message.reply_text("This user is an admin, they can't be unapproved.")
return ""
if not sql.is_approved(message.chat_id, user_id):
message.reply_text(f"{member.user['first_name']} isn't approved yet!")
return ""
sql.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 approve(bot: Bot, update: Update, args: List[str]) -> str:
message = update.effective_message
chat_title = message.chat.title
chat = update.effective_chat
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 ""
member = chat.get_member(int(user_id))
if member.status == "administrator" or member.status == "creator":
message.reply_text(
f"User is already admin - locks, blocklists, and antiflood already don't apply to them."
)
return
if sql.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
sql.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 automated admin actions like locks, blocklists, and antiflood.",
parse_mode=ParseMode.MARKDOWN)
def del_blacklist(bot: Bot, update: Update):
chat = update.effective_chat
message = update.effective_message
to_match = extract_text(message)
if not to_match:
return
user = update.effective_user
if is_approved(chat.id, user.id):
return
chat_filters = sql.get_chat_blacklist(chat.id)
for trigger in chat_filters:
pattern = r"( |^|[^\w])" + re.escape(trigger) + r"( |$|[^\w])"
if re.search(pattern, to_match, flags=re.IGNORECASE):
try:
message.delete()
except BadRequest as excp:
if excp.message == "Message to delete not found":
pass
else:
LOGGER.exception("Error while deleting blacklist message.")
break
def del_lockables(bot: Bot, update: Update):
user = update.effective_user
chat = update.effective_chat
message = update.effective_message
if is_approved(chat.id, user.id):
return
for lockable, filter in LOCK_TYPES.items():
if filter(message) and sql.is_locked(chat.id, lockable) and can_delete(chat, bot.id):
if lockable == "bots":
new_members = update.effective_message.new_chat_members
for new_mem in new_members:
if new_mem.is_bot:
if not is_bot_admin(chat, bot.id):
message.reply_text("I see a bot, and I've been told to stop them joining... "
"but I'm not admin!")
return
chat.kick_member(new_mem.id)
message.reply_text("Only admins are allowed to add bots to this chat!.")
else:
try:
message.delete()
except BadRequest as excp:
if excp.message == "Message to delete not found":
pass
else:
LOGGER.exception("ERROR in lockables")
break
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(context.bot, user, chat, warn_filter.reply, message)
return ""
def check_flood(bot: Bot, update: Update) -> str:
user = update.effective_user
chat = update.effective_chat
msg = update.effective_message
if is_approved(chat.id, user.id):
return
log_message = ""
if not user: # ignore channels
return log_message
# ignore admins and whitelists
if (is_user_admin(chat, user.id) or user.id in WHITELIST_USERS
or user.id in TIGER_USERS):
sql.update_flood(chat.id, None)
return log_message
should_ban = sql.update_flood(chat.id, user.id)
if not should_ban:
return log_message
try:
bot.restrict_chat_member(chat.id, user.id, can_send_messages=False)
msg.reply_text(
f"*mutes {mention_html(user.id, user.first_name)} permanently*\nStop flooding the group!",
parse_mode=ParseMode.HTML)
log_message = (
f"<b>{html.escape(chat.title)}:</b>\n"
f"#MUTED\n"
f"<b>User:</b> {mention_html(user.id, user.first_name)}\n"
f"Flooded the group.\nMuted until an admin unmutes")
return log_message
except BadRequest:
msg.reply_text(
"I can't kick people here, give me permissions first! Until then, I'll disable antiflood."
)
sql.set_flood(chat.id, 0)
log_message = (
"<b>{chat.title}:</b>\n"
"#INFO\n"
"Don't have kick permissions, so automatically disabled antiflood."
)
return log_message
def approval(bot: Bot, update: Update, args: List[str]) -> str:
message = update.effective_message
chat = update.effective_chat
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 sql.is_approved(message.chat_id, user_id):
message.reply_text(
f"{member.user['first_name']} is an approved user. Locks, antiflood, and blocklists 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 disapprove(bot: Bot, update: Update, args: List[str]) -> str:
message = update.effective_message
chat_title = message.chat.title
chat = update.effective_chat
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 ""
member = chat.get_member(int(user_id))
if member.status == "administrator" or member.status == "creator":
message.reply_text("This user is an admin, they can't be unapproved.")
return
if not sql.is_approved(message.chat_id, user_id):
message.reply_text(f"{member.user['first_name']} isn't approved yet!")
return
sql.disapprove(message.chat_id, user_id)
message.reply_text(
f"{member.user['first_name']} is no longer approved in {chat_title}.")
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 == "administrator" or member.status == "creator":
message.reply_text(
"User is already admin - locks, blocklists, and antiflood already don't apply to them."
)
return ""
if sql.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 ""
sql.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 automated admin actions like locks, blocklists, 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 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 = r"( |^|[^\w])" + re.escape(trigger) + r"( |$|[^\w])"
if re.search(pattern, to_match, flags=re.IGNORECASE):
try:
if getmode == 0:
return
elif getmode == 1:
message.delete()
elif getmode == 2:
message.delete()
warn(
update.effective_user,
chat,
("Using blacklisted trigger: {}".format(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.kick_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.kick_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":
pass
else:
log.exception("Error while deleting blacklist message.")
break
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 and whitelists
if (is_user_admin(chat, user.id) or user.id in WHITELIST_USERS
or user.id in TIGER_USERS):
sql.update_flood(chat.id, None)
return ""
# ignore approved users
if is_approved(chat.id, 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,
"Beep Boop! Boop Beep!\n{}!".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))
def del_lockables(update, context):
chat = update.effective_chat # type: Optional[Chat]
message = update.effective_message # type: Optional[Message]
user = update.effective_user
if is_approved(chat.id, user.id):
return
for lockable, filter in LOCK_TYPES.items():
if lockable == "rtl":
if sql.is_locked(chat.id, lockable) and can_delete(chat, context.bot.id):
if message.caption:
check = ad.detect_alphabet(u"{}".format(message.caption))
if "ARABIC" in check:
try:
message.delete()
except BadRequest as excp:
if excp.message != "Message to delete not found":
log.exception("ERROR in lockables")
break
if message.text:
check = ad.detect_alphabet(u"{}".format(message.text))
if "ARABIC" in check:
try:
message.delete()
except BadRequest as excp:
if excp.message != "Message to delete not found":
log.exception("ERROR in lockables")
break
continue
if lockable == "button":
if (
sql.is_locked(chat.id, lockable)
and can_delete(chat, context.bot.id)
and message.reply_markup
and message.reply_markup.inline_keyboard
):
try:
message.delete()
except BadRequest as excp:
if excp.message != "Message to delete not found":
log.exception("ERROR in lockables")
break
continue
if lockable == "inline":
if (
sql.is_locked(chat.id, lockable)
and can_delete(chat, context.bot.id)
and message
and message.via_bot
):
try:
message.delete()
except BadRequest as excp:
if excp.message != "Message to delete not found":
log.exception("ERROR in lockables")
break
continue
if (
filter(update)
and sql.is_locked(chat.id, lockable)
and can_delete(chat, context.bot.id)
):
if lockable == "bots":
new_members = update.effective_message.new_chat_members
for new_mem in new_members:
if new_mem.is_bot:
if not is_bot_admin(chat, context.bot.id):
send_message(
update.effective_message,
"I see a bot and I've been told to stop them from joining..."
"but I'm not admin!",
)
return
chat.kick_member(new_mem.id)
send_message(
update.effective_message,
"Only admins are allowed to add bots in this chat! Get outta here.",
)
break
else:
try:
message.delete()
except BadRequest as excp:
if excp.message != "Message to delete not found":
log.exception("ERROR in lockables")
break
def del_blackliststicker(update: Update, context: CallbackContext):
bot = context.bot
chat = update.effective_chat # type: Optional[Chat]
message = update.effective_message # type: Optional[Message]
user = update.effective_user
to_match = message.sticker
if not to_match or not to_match.set_name:
return
bot = context.bot
if is_approved(chat.id, user.id):
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
elif getmode == 1:
message.delete()
elif getmode == 2:
message.delete()
warn(
update.effective_user,
update,
"Using sticker '{}' which in blacklist stickers".
format(trigger, ),
message,
update.effective_user,
# conn=False,
)
return
elif getmode == 3:
message.delete()
bot.restrict_chat_member(
chat.id,
update.effective_user.id,
permissions=ChatPermissions(can_send_messages=False),
)
bot.sendMessage(
chat.id,
"{} muted because using '{}' which in blacklist stickers"
.format(
mention_markdown(user.id, user.first_name),
trigger,
),
parse_mode="markdown",
)
return
elif getmode == 4:
message.delete()
res = chat.unban_member(update.effective_user.id)
if res:
bot.sendMessage(
chat.id,
"{} kicked because using '{}' which in blacklist stickers"
.format(
mention_markdown(user.id, user.first_name),
trigger,
),
parse_mode="markdown",
)
return
elif getmode == 5:
message.delete()
chat.ban_member(user.id)
bot.sendMessage(
chat.id,
"{} banned because using '{}' which in blacklist stickers"
.format(
mention_markdown(user.id, user.first_name),
trigger,
),
parse_mode="markdown",
)
return
elif getmode == 6:
message.delete()
bantime = extract_time(message, value)
chat.ban_member(user.id, until_date=bantime)
bot.sendMessage(
chat.id,
"{} banned for {} because using '{}' which in blacklist stickers"
.format(
mention_markdown(user.id, user.first_name),
value,
trigger,
),
parse_mode="markdown",
)
return
elif getmode == 7:
message.delete()
mutetime = extract_time(message, value)
bot.restrict_chat_member(
chat.id,
user.id,
permissions=ChatPermissions(can_send_messages=False),
until_date=mutetime,
)
bot.sendMessage(
chat.id,
"{} muted for {} because using '{}' which in blacklist stickers"
.format(
mention_markdown(user.id, user.first_name),
value,
trigger,
),
parse_mode="markdown",
)
return
except BadRequest as excp:
if excp.message != "Message to delete not found":
LOGGER.exception("Error while deleting blacklist message.")
break