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 del_lockables(bot: Bot, update: Update):
chat = update.effective_chat
message = update.effective_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, "locks_lock_bots_no_admin"))
return
chat.kick_member(new_mem.id)
message.reply_text(tld(chat.id,
"locks_lock_bots_kick"))
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 antiarabic(bot: Bot, update: Update):
chat = update.effective_chat
msg = update.effective_message
to_match = extract_text(msg)
user = update.effective_user
has_arabic = False
if not sql.chat_antiarabic(chat.id):
return ""
if not user: # ignore channels
return ""
if user.id == 777000: # ignore telegram
return ""
if not to_match:
return
if chat.type != chat.PRIVATE:
for c in to_match:
if ('\u0600' <= c <= '\u06FF' or '\u0750' <= c <= '\u077F'
or '\u08A0' <= c <= '\u08FF' or '\uFB50' <= c <= '\uFDFF'
or '\uFE70' <= c <= '\uFEFF'
or '\U00010E60' <= c <= '\U00010E7F'
or '\U0001EE00' <= c <= '\U0001EEFF'):
if can_delete(chat, bot.id):
update.effective_message.delete()
return ""
def rest_handler(bot: Bot, update: Update):
msg = update.effective_message
chat = update.effective_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":
LOGGER.exception("ERROR in restrictions")
break
def del_message(bot: Bot, update: Update) -> str:
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("Whadya want to delete?")
return ""
def purge(bot: Bot, update: Update, args: List[str]) -> str:
msg = update.effective_message # type: Optional[Message]
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
if args and args[0].isdigit():
if int(args[0]) < int(1):
return
delete_to = message_id + int(args[0])
else:
delete_to = msg.message_id - 1
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":
bot.send_message(chat.id, "Cannot delete all messages. The messages may be too old, I might "
"not have delete rights, or this might not be a supergroup.")
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":
bot.send_message(chat.id, "Cannot delete all messages. The messages may be too old, I might "
"not have delete rights, or this might not be a supergroup.")
elif err.message != "Message to delete not found":
LOGGER.exception("Error while purging chat messages.")
bot.send_message(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("Reply to a message to select where to start purging from.")
return ""
def lock(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]
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 lock(bot: Bot, update: Update, args: List[str]) -> str:
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
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,
"locks_lock_success").format(args[0]),
parse_mode=ParseMode.MARKDOWN)
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)
message.reply_text(tld(chat.id,
"locks_lock_success").format(args[0]),
parse_mode=ParseMode.MARKDOWN)
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, "locks_type_invalid"))
else:
message.reply_text(tld(chat.id, "locks_lock_no_type"))
else:
message.reply_text(tld(chat.id, "locks_bot_not_admin"))
return ""
def del_lockables(update, context):
chat = update.effective_chat # type: Optional[Chat]
message = update.effective_message # type: Optional[Message]
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":
pass
else:
LOGGER.exception("ERROR in lockables")
getconf = sql.get_lockconf(chat.id)
if getconf:
warn(
update.effective_user,
chat,
tl(
update.effective_message,
"Mengirim 'Teks RTL' yang sedang di kunci saat ini"
),
message,
update.effective_user,
conn=False)
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":
pass
else:
LOGGER.exception("ERROR in lockables")
getconf = sql.get_lockconf(chat.id)
if getconf:
warn(
update.effective_user,
chat,
tl(
update.effective_message,
"Mengirim 'Teks RTL' yang sedang di kunci saat ini"
),
message,
update.effective_user,
conn=False)
break
continue
if lockable == "button":
if sql.is_locked(chat.id, lockable) and can_delete(
chat, context.bot.id):
if message.reply_markup and message.reply_markup.inline_keyboard:
try:
message.delete()
except BadRequest as excp:
if excp.message == "Message to delete not found":
pass
else:
LOGGER.exception("ERROR in lockables")
getconf = sql.get_lockconf(chat.id)
if getconf:
warn(
update.effective_user,
chat,
tl(
update.effective_message,
"Mengirim 'Pesan Tombol' yang sedang di kunci saat ini"
),
message,
update.effective_user,
conn=False)
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,
tl(
update.effective_message,
"Saya melihat bot, dan saya diberitahu untuk menghentikan mereka bergabung... "
"tapi saya bukan admin!"))
return
chat.kick_member(new_mem.id)
send_message(
update.effective_message,
tl(
update.effective_message,
"Hanya admin yang diizinkan menambahkan bot ke obrolan ini! Keluar dari sini!"
))
getconf = sql.get_lockconf(chat.id)
if getconf:
warn(
update.effective_user,
chat,
tl(
update.effective_message,
"Memasukan 'Bot' yang sedang di kunci saat ini"
),
message,
update.effective_user,
conn=False)
break
else:
try:
message.delete()
except BadRequest as excp:
if excp.message == "Message to delete not found":
pass
else:
LOGGER.exception("ERROR in lockables")
getconf = sql.get_lockconf(chat.id)
if getconf:
warn(update.effective_user,
chat,
tl(update.effective_message,
"Mengirim '{}' yang sedang di kunci saat ini").
format(lockable),
message,
update.effective_user,
conn=False)
break
def lock(update, context) -> str:
args = context.args
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
if can_delete(
chat,
context.bot.id) or update.effective_message.chat.type == "private":
if len(args) >= 1:
ltype = args[0].lower()
if ltype in LOCK_TYPES:
# Connection check
conn = connected(context.bot,
update,
chat,
user.id,
need_admin=True)
if conn:
chat = dispatcher.bot.getChat(conn)
chat_id = conn
chat_name = chat.title
text = tl(
update.effective_message,
"Terkunci pesan *{}* untuk semua non-admin pada *{}*!"
).format(ltype, chat_name)
else:
if update.effective_message.chat.type == "private":
send_message(
update.effective_message,
tl(
update.effective_message,
"Anda bisa lakukan command ini pada grup, bukan pada PM"
))
return ""
chat = update.effective_chat
chat_id = update.effective_chat.id
chat_name = update.effective_message.chat.title
text = tl(
update.effective_message,
"Terkunci pesan *{}* untuk semua non-admin!").format(
ltype)
sql.update_lock(chat.id, ltype, locked=True)
send_message(update.effective_message,
text,
parse_mode="markdown")
return "<b>{}:</b>" \
"\n#LOCK" \
"\n<b>Admin:</b> {}" \
"\nLocked <code>{}</code>.".format(html.escape(chat.title),
mention_html(user.id, user.first_name), ltype)
elif ltype in LOCK_CHAT_RESTRICTION:
# Connection check
conn = connected(context.bot,
update,
chat,
user.id,
need_admin=True)
if conn:
chat = dispatcher.bot.getChat(conn)
chat_id = conn
chat_name = chat.title
text = tl(
update.effective_message,
"Izin terkunci pesan *{}* untuk semua non-admin pada *{}*!"
).format(ltype, chat_name)
else:
if update.effective_message.chat.type == "private":
send_message(
update.effective_message,
tl(
update.effective_message,
"Anda bisa lakukan command ini pada grup, bukan pada PM"
))
return ""
chat = update.effective_chat
chat_id = update.effective_chat.id
chat_name = update.effective_message.chat.title
text = tl(
update.effective_message,
"Izin terkunci pesan *{}* untuk semua non-admin!"
).format(ltype)
current_permission = context.bot.getChat(chat_id).permissions
context.bot.set_chat_permissions(
chat_id=chat_id,
permissions=get_permission_list(
eval(str(current_permission)),
LOCK_CHAT_RESTRICTION[ltype.lower()]))
send_message(update.effective_message,
text,
parse_mode="markdown")
return "<b>{}:</b>" \
"\n#Permission_LOCK" \
"\n<b>Admin:</b> {}" \
"\nLocked <code>{}</code>.".format(html.escape(chat.title),
mention_html(user.id, user.first_name), ltype)
else:
send_message(
update.effective_message,
tl(
update.effective_message,
"Apa yang Anda coba untuk kunci...? Coba /locktypes untuk daftar kunci yang dapat dikunci"
))
else:
send_message(
update.effective_message,
tl(update.effective_message, "Apa yang Anda ingin kunci...?"))
else:
send_message(
update.effective_message,
tl(update.effective_message,
"Saya bukan admin, atau tidak punya hak menghapus."))
return ""
