def del_lockables(bot: Bot, update: Update):
chat = update.effective_chat # type: Optional[Chat]
message = update.effective_message # type: Optional[Message]
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(
tld(
chat.id,
"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(
tld(
chat.id,
"Only admins are allowed to add bots to this chat! Get outta here."
))
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 kick(bot: Bot, update: Update, args: List[str]) -> str:
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
message = update.effective_message # type: Optional[Message]
user_id, reason = extract_user_and_text(message, args)
time.sleep(2)
message.delete()
if can_delete(chat, bot.id):
try:
update.effective_message.reply_to_message.delete()
except AttributeError:
pass
if not user_id:
return ""
try:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "User not found":
message.reply_text("I can't seem to find this user")
return ""
else:
raise
if user_id == bot.id:
message.reply_text("I'm not kicking myself!")
return ""
if is_user_ban_protected(chat, user_id):
message.reply_text(
"Why would I kick an admin? That sounds like a pretty dumb idea.")
return ""
res = chat.unban_member(user_id) # unban on current user = kick
if res:
reply = "{} Kicked!".format(
mention_html(member.user.id, member.user.first_name))
bot.sendMessage(chat.id, reply, parse_mode=ParseMode.HTML)
log = "<b>{}:</b>" \
"\n#KICKED" \
"\n<b>Admin:</b> {}" \
"\n<b>User:</b> {} (<code>{}</code>)".format(html.escape(chat.title),
mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name),
member.user.id)
if reason:
log += "\n<b>Reason:</b> {}".format(reason)
return log
else:
message.reply_text("Kicked!")
return ""
def sban(update, context) -> str:
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
message = update.effective_message # type: Optional[Message]
bot = context.bot
args = context.args
update.effective_message.delete()
user_id, reason = extract_user_and_text(message, args)
time.sleep(2)
message.delete()
if can_delete(chat, bot.id):
try:
update.effective_message.reply_to_message.delete()
except AttributeError:
pass
if not user_id:
return ""
try:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "User not found":
return ""
else:
raise
if is_user_ban_protected(chat, user_id, member):
return ""
if user_id == bot.id:
return ""
log = "<b>{}:</b>" \
"\n# SILENTBAN" \
"\n<b>• Admin:</b> {}" \
"\n<b>• User:</b> {}" \
"\n<b>• ID:</b> <code>{}</code>".format(html.escape(chat.title), mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name), user_id)
if reason:
log += "\n<b>• Reason:</b> {}".format(reason)
try:
chat.kick_member(user_id)
return log
except BadRequest as excp:
if excp.message == "Reply message not found":
return log
else:
LOGGER.warning(update)
LOGGER.exception("ERROR banning user %s in chat %s (%s) due to %s",
user_id, chat.title, chat.id, excp.message)
return ""
def lock(update, context) -> str:
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
message = update.effective_message # type: Optional[Message]
bot = context.bot
args = context.args
if can_delete(chat, bot.id):
if len(args) >= 1:
if args[0] in LOCK_TYPES:
sql.update_lock(chat.id, args[0], locked=True)
message.reply_text(
tld(chat.id,
"Locked {} messages for all non-admins!").format(
args[0]))
return "<b>{}:</b>" \
"\n#LOCK" \
"\n<b>Admin:</b> {}" \
"\nLocked <code>{}</code>.".format(html.escape(chat.title),
mention_html(user.id, user.first_name), args[0])
elif args[0] in RESTRICTION_TYPES:
sql.update_restriction(chat.id, args[0], locked=True)
if args[0] == "previews":
members = users_sql.get_chat_members(str(chat.id))
restr_members(bot,
chat.id,
members,
messages=True,
media=True,
other=True)
message.reply_text(
tld(chat.id,
"Locked {} for all non-admins!").format(args[0]))
return "<b>{}:</b>" \
"\n#LOCK" \
"\n<b>Admin:</b> {}" \
"\nLocked <code>{}</code>.".format(html.escape(chat.title),
mention_html(user.id, user.first_name), args[0])
else:
message.reply_text(
tld(
chat.id,
"What are you trying to lock...? Try /locktypes for the list of lockables"
))
else:
message.reply_text(
tld(
chat.id,
"Make sure I'm a group administrator and have permission to delete messages, then try again."
))
return ""
def purge(update, context) -> str:
msg = update.effective_message # type: Optional[Message]
chat = update.effective_chat # type: Optional[Chat]
bot = context.bot
args = context.args
if msg.reply_to_message:
user = update.effective_user # type: Optional[User]
chat = update.effective_chat # type: Optional[Chat]
if can_delete(chat, bot.id):
message_id = msg.reply_to_message.message_id
delete_to = msg.message_id - 1
if args and args[0].isdigit():
new_del = message_id + int(args[0])
# No point deleting messages which haven't been written yet.
if new_del < delete_to:
delete_to = new_del
for m_id in range(delete_to, message_id - 1,
-1): # Reverse iteration over message ids
try:
bot.deleteMessage(chat.id, m_id)
except BadRequest as err:
if err.message == "Message can't be deleted":
LOGGER.exception("Error while purging chat messages.")
elif err.message != "Message to delete not found":
LOGGER.exception("Error while purging chat messages.")
try:
msg.delete()
except BadRequest as err:
if err.message == "Message can't be deleted":
LOGGER.exception("Error while purging chat messages.")
elif err.message != "Message to delete not found":
LOGGER.exception("Error while purging chat messages.")
bot.send_message(chat.id, tld(chat.id, "Purge complete."))
return "<b>{}:</b>" \
"\n#PURGE" \
"\n<b>Admin:</b> {}" \
"\nPurged <code>{}</code> messages.".format(html.escape(chat.title),
mention_html(user.id, user.first_name),
delete_to - message_id)
else:
msg.reply_text(
tld(chat.id,
"Reply to a message to select where to start purging from."))
return ""
def rest_handler(bot: Bot, update: Update):
msg = update.effective_message # type: Optional[Message]
chat = update.effective_chat # type: Optional[Chat]
for restriction, filter in RESTRICTION_TYPES.items():
if filter(msg) and sql.is_restr_locked(
chat.id, restriction) and can_delete(chat, bot.id):
try:
msg.delete()
except BadRequest as excp:
if excp.message == "Message to delete not found":
pass
else:
LOGGER.exception("ERROR in restrictions")
break
def del_message(update, context) -> str:
chat = update.effective_chat # type: Optional[Chat]
if update.effective_message.reply_to_message:
user = update.effective_user # type: Optional[User]
chat = update.effective_chat # type: Optional[Chat]
if can_delete(chat, bot.id):
update.effective_message.reply_to_message.delete()
update.effective_message.delete()
return "<b>{}:</b>" \
"\n#DEL" \
"\n<b>Admin:</b> {}" \
"\nMessage deleted.".format(html.escape(chat.title),
mention_html(user.id, user.first_name))
else:
update.effective_message.reply_text(
tld(chat.id, "Whadya want to delete?"))
return ""
def ban(bot: Bot, update: Update, args: List[str]) -> str:
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
message = update.effective_message # type: Optional[Message]
user_id, reason = extract_user_and_text(message, args)
time.sleep(2)
message.delete()
if can_delete(chat, bot.id):
try:
update.effective_message.reply_to_message.delete()
except AttributeError:
pass
if not user_id:
message.reply_text(
tld(chat.id, "You don't seem to be referring to a user."))
return ""
try:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "User not found":
message.reply_text(tld(chat.id, "I can't seem to find this user"))
return ""
else:
raise
if user_id == bot.id:
message.reply_text(
tld(chat.id, "I'm not gonna BAN myself, are you crazy?"))
return ""
if user_id == 631847622:
message.reply_text(
tld(
chat.id,
"Someone trying to ban my master and act like pro #LMAO i got a noob and its you"
))
return ""
if is_user_ban_protected(chat, user_id, member):
message.reply_text(
tld(
chat.id,
"Why would I ban an admin? That sounds like a pretty dumb idea."
))
return ""
log = "<b>{}:</b>" \
"\n#BANNED" \
"\n<b>Admin:</b> {}" \
"\n<b>User:</b> {} (<code>{}</code>)".format(html.escape(chat.title),
mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name),
member.user.id)
if reason:
log += "\n<b>Reason:</b> {}".format(reason)
try:
chat.kick_member(user_id)
bot.send_sticker(chat.id, BAN_STICKER) # banhammer marie sticker
reply = "Admin {} Banned User {} in {}!".format(
mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name), chat.title)
bot.sendMessage(chat.id, reply, parse_mode=ParseMode.HTML)
return log
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
message.reply_text(tld(chat.id, "Banned!"), quote=False)
return log
else:
LOGGER.warning(update)
LOGGER.exception("ERROR banning user %s in chat %s (%s) due to %s",
user_id, chat.title, chat.id, excp.message)
message.reply_text(tld(chat.id, "Banned!"))
return ""
def temp_ban(bot: Bot, update: Update, args: List[str]) -> str:
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
message = update.effective_message # type: Optional[Message]
user_id, reason = extract_user_and_text(message, args)
time.sleep(2)
message.delete()
if can_delete(chat, bot.id):
try:
update.effective_message.reply_to_message.delete()
except AttributeError:
pass
if not user_id:
message.reply_text(
tld(chat.id, "You don't seem to be referring to a user."))
return ""
try:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "User not found":
message.reply_text(tld(chat.id, "I can't seem to find this user"))
return ""
else:
raise
if is_user_ban_protected(chat, user_id, member):
message.reply_text(
tld(
chat.id,
"This user is ban protected, meaning that you cannot ban this user!"
))
return ""
if user_id == bot.id:
message.reply_text(
tld(chat.id, "I'm not gonna BAN myself, are you crazy?"))
return ""
if not reason:
message.reply_text(
tld(chat.id, "You haven't specified a time to ban this user for!"))
return ""
split_reason = reason.split(None, 1)
time_val = split_reason[0].lower()
if len(split_reason) > 1:
reason = split_reason[1]
else:
reason = ""
bantime = extract_time(message, time_val)
if not bantime:
return ""
log = "<b>{}:</b>" \
"\n#TEMP BANNED" \
"\n<b>Admin:</b> {}" \
"\n<b>User:</b> {} (<code>{}</code>)" \
"\n<b>Time:</b> {}".format(html.escape(chat.title),
mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name),
member.user.id,
time_val)
if reason:
log += "\n<b>Reason:</b> {}".format(reason)
try:
chat.kick_member(user_id, until_date=bantime)
bot.send_sticker(update.effective_chat.id, BAN_STICKER)
reply = "{} has been temporarily banned for {}!".format(
mention_html(member.user.id, member.user.first_name), time_val)
bot.sendMessage(chat.id, reply, parse_mode=ParseMode.HTML)
return log
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
bot.send_sticker(chat.id, BAN_STICKER) # banhammer marie sticker
message.reply_text(
tld(chat.id,
"Banned! User will be banned for {}.").format(time_val),
quote=False)
return log
else:
LOGGER.warning(update)
LOGGER.exception("ERROR banning user %s in chat %s (%s) due to %s",
user_id, chat.title, chat.id, excp.message)
message.reply_text(tld(chat.id, "Banned!"))
return ""
