def connected(bot, update, chat, user_id, need_admin=True):
user = update.effective_user
if chat.type == chat.PRIVATE and sql.get_connected_chat(user_id):
conn_id = sql.get_connected_chat(user_id).chat_id
getstatusadmin = bot.get_chat_member(
conn_id, update.effective_message.from_user.id)
isadmin = getstatusadmin.status in ('administrator', 'creator')
ismember = getstatusadmin.status in ('member')
isallow = sql.allow_connect_to_chat(conn_id)
if (isadmin) or (isallow and ismember) or (user.id in SUDO_USERS) or (
user.id in DEV_USERS):
if need_admin == True:
if getstatusadmin.status in (
'administrator', 'creator'
) or user_id in SUDO_USERS or user.id in DEV_USERS:
return conn_id
else:
send_message(
update.effective_message,
"You must be an admin in the connected group!")
else:
return conn_id
else:
send_message(
update.effective_message,
"The group changed the connection rights or you are no longer an admin.\nI've disconnected you."
)
disconnect_chat(update, bot)
else:
return False
def connection_chat(bot: Bot, update: Update):
chat = update.effective_chat
user = update.effective_user
spam = spamfilters(update.effective_message.text,
update.effective_message.from_user.id,
update.effective_chat.id)
if spam == True:
return
conn = connected(bot, update, chat, user.id, need_admin=True)
if conn:
chat = dispatcher.bot.getChat(conn)
chat_name = dispatcher.bot.getChat(conn).title
else:
if update.effective_message.chat.type != "private":
return
chat = update.effective_chat
chat_name = update.effective_message.chat.title
if conn:
message = "You are currently connected with {}.\n".format(chat_name)
else:
message = "You are currently not connected in any group.\n"
send_message(update.effective_message, message, parse_mode="markdown")
def help_connect_chat(update, context):
args = context.args
if update.effective_message.chat.type != "private":
send_message(update.effective_message,
"PM me with that command to get help.")
return
else:
send_message(update.effective_message,
CONN_HELP,
parse_mode="markdown")
def disconnect_chat(update, context):
if update.effective_chat.type == 'private':
disconnection_status = sql.disconnect(
update.effective_message.from_user.id)
if disconnection_status:
sql.disconnected_chat = send_message(update.effective_message,
"Disconnected from chat!")
else:
send_message(update.effective_message, "You're not connected!")
else:
send_message(update.effective_message,
"This command is only available in PM.")
def help_connect_chat(bot: Bot, update: Update):
spam = spamfilters(update.effective_message.text,
update.effective_message.from_user.id,
update.effective_chat.id)
if spam == True:
return
if update.effective_message.chat.type != "private":
send_message(update.effective_message,
"PM me with that command to get help.")
return
else:
send_message(update.effective_message,
"All commands",
parse_mode="markdown")
def disconnect_chat(bot: Bot, update: Update):
spam = spamfilters(update.effective_message.text,
update.effective_message.from_user.id,
update.effective_chat.id)
if spam == True:
return
if update.effective_chat.type == 'private':
disconnection_status = sql.disconnect(
update.effective_message.from_user.id)
if disconnection_status:
sql.disconnected_chat = send_message(update.effective_message,
"Disconnected from chat!")
else:
send_message(update.effective_message, "You're not connected!")
else:
send_message(update.effective_message,
"This command is only available in PM.")
def commands(update, context):
chat = update.effective_chat
user = update.effective_user
conn = connected(context.bot, update, chat, user.id, need_admin=True)
if conn:
chat = dispatcher.bot.getChat(conn)
chat_id = conn
else:
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
text = build_curr_disabled(chat.id)
send_message(update.effective_message,
text,
parse_mode=ParseMode.MARKDOWN)
def connection_chat(update, context):
chat = update.effective_chat
user = update.effective_user
conn = connected(context.bot, update, chat, user.id, need_admin=True)
if conn:
chat = dispatcher.bot.getChat(conn)
chat_name = dispatcher.bot.getChat(conn).title
else:
if update.effective_message.chat.type != "private":
return
chat = update.effective_chat
chat_name = update.effective_message.chat.title
if conn:
message = "You are currently connected to {}.\n".format(chat_name)
else:
message = "You are currently not connected in any group.\n"
send_message(update.effective_message, message, parse_mode="markdown")
def list_locks(update, context):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user
# Connection check
conn = connected(context.bot, update, chat, user.id, need_admin=True)
if conn:
chat = dispatcher.bot.getChat(conn)
chat_name = chat.title
else:
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_name = update.effective_message.chat.title
res = build_lock_message(chat.id)
if conn:
res = res.replace('Locks in', '*{}*'.format(chat_name))
send_message(update.effective_message, res, parse_mode=ParseMode.MARKDOWN)
def flood(update, context):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
msg = update.effective_message
conn = connected(context.bot, update, chat, user.id, need_admin=False)
if conn:
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
else:
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:
if conn:
text = msg.reply_text(
"I'm not enforcing any flood control in {}!".format(chat_name))
else:
text = msg.reply_text("I'm not enforcing any flood control here!")
send_message(update.effective_message, text, parse_mode="markdown")
else:
if conn:
text = msg.reply_text(
"I'm currently restricting members after {} consecutive messages in {}."
.format(limit, chat_name))
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 blacklist(update, context):
chat = update.effective_chat
user = update.effective_user
args = context.args
conn = connected(context.bot, update, chat, user.id, need_admin=False)
if conn:
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
else:
if chat.type == "private":
return
else:
chat_id = update.effective_chat.id
chat_name = chat.title
filter_list = "Current blacklisted words in <b>{}</b>:\n".format(chat_name)
all_blacklisted = sql.get_chat_blacklist(chat_id)
if len(args) > 0 and args[0].lower() == 'copy':
for trigger in all_blacklisted:
filter_list += "<code>{}</code>\n".format(html.escape(trigger))
else:
for trigger in all_blacklisted:
filter_list += " - <code>{}</code>\n".format(html.escape(trigger))
# for trigger in all_blacklisted:
# filter_list += " - <code>{}</code>\n".format(html.escape(trigger))
split_text = split_message(filter_list)
for text in split_text:
if filter_list == "Current blacklisted words in <b>{}</b>:\n".format(
chat_name):
send_message(
update.effective_message,
"No blacklisted words in <b>{}</b>!".format(chat_name),
parse_mode=ParseMode.HTML)
return
send_message(update.effective_message, text, parse_mode=ParseMode.HTML)
def blackliststicker(bot: Bot, update: Update, args: List[str]):
msg = update.effective_message # type: Optional[Message]
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
conn = connected(bot, update, chat, user.id, need_admin=False)
if conn:
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
else:
if chat.type == "private":
return
else:
chat_id = update.effective_chat.id
chat_name = chat.title
sticker_list = "<b>List black stickers currently in {}:</b>\n".format(
chat_name)
all_stickerlist = sql.get_chat_stickers(chat_id)
if len(args) > 0 and args[0].lower() == 'copy':
for trigger in all_stickerlist:
sticker_list += "<code>{}</code>\n".format(html.escape(trigger))
elif len(args) == 0:
for trigger in all_stickerlist:
sticker_list += " - <code>{}</code>\n".format(html.escape(trigger))
split_text = split_message(sticker_list)
for text in split_text:
if sticker_list == "<b>List black stickers currently in {}:</b>\n".format(
chat_name).format(chat_name):
send_message(update.effective_message,
"There is no blacklist sticker in <b>{}</b>!".format(
chat_name),
parse_mode=ParseMode.HTML)
return
send_message(update.effective_message, text, parse_mode=ParseMode.HTML)
def reply_afk(update, context):
message = update.effective_message # type: Optional[Message]
entities = message.parse_entities(
[MessageEntity.TEXT_MENTION, MessageEntity.MENTION])
if message.entities and entities:
for ent in entities:
if ent.type == MessageEntity.TEXT_MENTION:
user_id = ent.user.id
fst_name = ent.user.first_name
elif ent.type == MessageEntity.MENTION:
user_id = get_user_id(message.text[ent.offset:ent.offset +
ent.length])
if not user_id:
# Should never happen, since for a user to become AFK they must have spoken. Maybe changed username?
return
try:
chat = context.bot.get_chat(user_id)
except BadRequest:
print("Error in afk can't get user id {}".format(user_id))
return
fst_name = chat.first_name
else:
return
if sql.is_afk(user_id):
valid, reason = sql.check_afk_status(user_id)
if valid:
if not reason:
rplafkstr = random.choice(fun.AFKRPL)
res = rplafkstr.format(fst_name)
else:
res = f"<b>{fst_name}</b> is away from keyboard! says it's because of \n{reason}"
send_message(update.effective_message,
res,
parse_mode=ParseMode.HTML)
def enable(update, context):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user
args = context.args
conn = connected(context.bot, update, chat, user.id, need_admin=True)
if conn:
chat = dispatcher.bot.getChat(conn)
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
else:
if update.effective_message.chat.type == "private":
send_message(
update.effective_message,
"This command is meant to be used in group not in PM")
return ""
chat = update.effective_chat
chat_id = update.effective_chat.id
chat_name = update.effective_message.chat.title
if len(args) >= 1:
enable_cmd = args[0]
if enable_cmd.startswith(CMD_STARTERS):
enable_cmd = enable_cmd[1:]
if sql.enable_command(chat.id, enable_cmd):
if conn:
text = "Enabled the use of `{}` command in *{}*!".format(
enable_cmd, chat_name)
else:
text = "Enabled the use of `{}` command!".format(
enable_cmd)
send_message(update.effective_message,
text,
parse_mode=ParseMode.MARKDOWN)
else:
send_message(update.effective_message,
"Is that even disabled?")
else:
send_message(update.effective_message, "What should I enable?")
def disable(update, context):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user
args = context.args
conn = connected(context.bot, update, chat, user.id, need_admin=True)
if conn:
chat = dispatcher.bot.getChat(conn)
chat_name = dispatcher.bot.getChat(conn).title
else:
if update.effective_message.chat.type == "private":
send_message(
update.effective_message,
"This command meant to be used in group not in PM")
return ""
chat = update.effective_chat
chat_name = update.effective_message.chat.title
if len(args) >= 1:
disable_cmd = args[0]
if disable_cmd.startswith(CMD_STARTERS):
disable_cmd = disable_cmd[1:]
if disable_cmd in set(DISABLE_CMDS + DISABLE_OTHER):
sql.disable_command(chat.id, disable_cmd)
if conn:
text = "Disabled the use of `{}` command in *{}*!".format(
disable_cmd, chat_name)
else:
text = "Disabled the use of `{}` command!".format(
disable_cmd)
send_message(update.effective_message,
text,
parse_mode=ParseMode.MARKDOWN)
else:
send_message(update.effective_message,
"This command can't be disabled")
else:
send_message(update.effective_message, "What should I disable?")
def add_blacklist(update, context):
msg = update.effective_message
chat = update.effective_chat
user = update.effective_user
words = msg.text.split(None, 1)
conn = connected(context.bot, update, chat, user.id)
if conn:
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
else:
chat_id = update.effective_chat.id
if chat.type == "private":
return
else:
chat_name = chat.title
if len(words) > 1:
text = words[1]
to_blacklist = list(
set(trigger.strip() for trigger in text.split("\n")
if trigger.strip()))
for trigger in to_blacklist:
sql.add_to_blacklist(chat_id, trigger.lower())
if len(to_blacklist) == 1:
send_message(
update.effective_message,
"Added blacklist <code>{}</code> in chat: <b>{}</b>!".format(
html.escape(to_blacklist[0]), chat_name),
parse_mode=ParseMode.HTML)
else:
send_message(
update.effective_message,
"Added blacklist trigger: <code>{}</code> in <b>{}</b>!".
format(len(to_blacklist), chat_name),
parse_mode=ParseMode.HTML)
else:
send_message(
update.effective_message,
"Tell me which words you would like to add in blacklist.")
def blacklist_mode(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
msg = update.effective_message # type: Optional[Message]
conn = connected(bot, update, chat, user.id, need_admin=True)
if conn:
chat = dispatcher.bot.getChat(conn)
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
else:
if update.effective_message.chat.type == "private":
send_message(update.effective_message,
"You can do this command in groups, not 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() == 'off' or args[0].lower(
) == 'nothing' or args[0].lower() == 'no':
settypeblacklist = 'turn off'
sql.set_blacklist_strength(chat_id, 0, "0")
elif args[0].lower() == 'del' or args[0].lower() == 'delete':
settypeblacklist = 'left, the message will be deleted'
sql.set_blacklist_strength(chat_id, 1, "0")
elif args[0].lower() == 'warn':
settypeblacklist = 'warned'
sql.set_blacklist_strength(chat_id, 2, "0")
elif args[0].lower() == 'mute':
settypeblacklist = 'muted'
sql.set_blacklist_strength(chat_id, 3, "0")
elif args[0].lower() == 'kick':
settypeblacklist = 'kicked'
sql.set_blacklist_strength(chat_id, 4, "0")
elif args[0].lower() == 'ban':
settypeblacklist = 'banned'
sql.set_blacklist_strength(chat_id, 5, "0")
elif args[0].lower() == 'tban':
if len(args) == 1:
teks = """It looks like you are trying to set a temporary value to blacklist, but has not determined the time; use `/blstickermode tban <timevalue>`.
Examples of time values: 4m = 4 minute, 3h = 3 hours, 6d = 6 days, 5w = 5 weeks."""
send_message(update.effective_message,
teks,
parse_mode="markdown")
return
settypeblacklist = 'temporary banned for {}'.format(args[1])
sql.set_blacklist_strength(chat_id, 6, str(args[1]))
elif args[0].lower() == 'tmute':
if len(args) == 1:
teks = """It looks like you are trying to set a temporary value to blacklist, but has not determined the time; use `/blstickermode tmute <timevalue>`.
Examples of time values: 4m = 4 minute, 3h = 3 hours, 6d = 6 days, 5w = 5 weeks."""
send_message(update.effective_message,
teks,
parse_mode="markdown")
return
settypeblacklist = tl(update.effective_message,
'temporary muted for {}').format(args[1])
sql.set_blacklist_strength(chat_id, 7, str(args[1]))
else:
send_message(
update.effective_message,
"I only understand off/del/warn/ban/kick/mute/tban/tmute!")
return
if conn:
text = "Blacklist sticker mode changed, will `{}` at *{}*!".format(
settypeblacklist, chat_name)
else:
text = "Blacklist sticker mode changed, will `{}`!".format(
settypeblacklist)
send_message(update.effective_message, text, parse_mode="markdown")
return "<b>{}:</b>\n" \
"<b>Admin:</b> {}\n" \
"Changed sticker blacklist mode. Will {}.".format(html.escape(chat.title),
mention_html(user.id, user.first_name), settypeblacklist)
else:
getmode, getvalue = sql.get_blacklist_setting(chat.id)
if getmode == 0:
settypeblacklist = "not active"
elif getmode == 1:
settypeblacklist = "hapus"
elif getmode == 2:
settypeblacklist = "warn"
elif getmode == 3:
settypeblacklist = "mute"
elif getmode == 4:
settypeblacklist = "kick"
elif getmode == 5:
settypeblacklist = "ban"
elif getmode == 6:
settypeblacklist = "temporarily banned for {}".format(getvalue)
elif getmode == 7:
settypeblacklist = "temporarily muted for {}".format(getvalue)
if conn:
text = "Blacklist sticker mode is currently set to *{}* in *{}*.".format(
settypeblacklist, chat_name)
else:
text = "Blacklist sticker mode is currently set to *{}*.".format(
settypeblacklist)
send_message(update.effective_message,
text,
parse_mode=ParseMode.MARKDOWN)
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")
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")
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")
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.")
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 allow_connections(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat
if chat.type != chat.PRIVATE:
if len(args) >= 1:
var = args[0]
if var == "no":
sql.set_allow_connect_to_chat(chat.id, False)
send_message(update.effective_message,
"Connection has been disabled for this chat")
elif var == "yes":
sql.set_allow_connect_to_chat(chat.id, True)
send_message(update.effective_message,
"Connection has been enabled for this chat")
else:
send_message(update.effective_message,
"Please enter `yes` or `no`!",
parse_mode=ParseMode.MARKDOWN)
else:
get_settings = sql.allow_connect_to_chat(chat.id)
if get_settings:
send_message(
update.effective_message,
"Connections to this group are *Allowed* for members!",
parse_mode=ParseMode.MARKDOWN)
else:
send_message(
update.effective_message,
"Connection to this group are *Not Allowed* for members!",
parse_mode=ParseMode.MARKDOWN)
else:
send_message(update.effective_message,
"This command is for group only. Not in PM!")
def private_note(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
conn = connected(bot, update, chat, user.id)
if conn:
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
else:
chat_id = update.effective_chat.id
if chat.type == "private":
chat_name = chat.title
else:
chat_name = chat.title
if len(args) >= 1:
if args[0] in ("yes", "on"):
if len(args) >= 2:
if args[1] == "del":
sql.private_note(str(chat_id), True, True)
send_message(
update.effective_message,
"Private Note was *enabled*, when users get notes, the message will be sent to the PM and the hashtag message will be deleted.",
parse_mode="markdown")
else:
sql.private_note(str(chat_id), True, False)
send_message(
update.effective_message,
"Private Note was *enabled*, when users get notes, the message will be sent to the PM.",
parse_mode="markdown")
else:
sql.private_note(str(chat_id), True, False)
send_message(
update.effective_message,
"Private Note was *enabled*, when users get notes, the message will be sent to the PM.",
parse_mode="markdown")
elif args[0] in ("no", "off"):
sql.private_note(str(chat_id), False, False)
send_message(
update.effective_message,
"Private Note was *disabled*, notes will be sent to group.",
parse_mode="markdown")
else:
send_message(update.effective_message,
"Unknown argument - please use 'yes', or 'no'.")
else:
is_private, is_delete = sql.get_private_note(chat_id)
print(is_private, is_delete)
send_message(update.effective_message,
"Current Private Note settings at {}: *{}*{}".format(
chat_name, "Enabled" if is_private else "Disabled",
" - *Hash will be deleted*" if is_delete else ""),
parse_mode="markdown")
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
conn = connected(context.bot, update, chat, user.id, need_admin=True)
if conn:
chat = dispatcher.bot.getChat(conn)
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
else:
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
if conn:
text = msg.reply_text(
"Exceeding consecutive flood limit will result in {} in {}!".
format(settypeflood, chat_name))
else:
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))
else:
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))
if conn:
text = msg.reply_text(
"Sending more messages than flood limit will result in {} in {}."
.format(settypeflood, chat_name))
else:
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 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)
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
conn = connected(context.bot, update, chat, user.id, need_admin=True)
if conn:
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
else:
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)
if conn:
text = message.reply_text(
"Antiflood has been disabled in {}.".format(chat_name))
else:
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)
if conn:
text = message.reply_text(
"Antiflood has been disabled in {}.".format(chat_name))
else:
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))
elif amount < 3:
send_message(
update.effective_message,
"Antiflood must be either 0 (disabled) or number greater than 3!"
)
return ""
else:
sql.set_flood(chat_id, amount)
if conn:
text = message.reply_text(
"Anti-flood has been set to {} in chat: {}".format(
amount, chat_name))
else:
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 unblacklist(update, context):
msg = update.effective_message
chat = update.effective_chat
user = update.effective_user
words = msg.text.split(None, 1)
conn = connected(context.bot, update, chat, user.id)
if conn:
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
else:
chat_id = update.effective_chat.id
if chat.type == "private":
return
else:
chat_name = chat.title
if len(words) > 1:
text = words[1]
to_unblacklist = list(
set(trigger.strip() for trigger in text.split("\n")
if trigger.strip()))
successful = 0
for trigger in to_unblacklist:
success = sql.rm_from_blacklist(chat_id, trigger.lower())
if success:
successful += 1
if len(to_unblacklist) == 1:
if successful:
send_message(
update.effective_message,
"Removed <code>{}</code> from blacklist in <b>{}</b>!".
format(html.escape(to_unblacklist[0]), chat_name),
parse_mode=ParseMode.HTML)
else:
send_message(update.effective_message,
"This is not a blacklist trigger!")
elif successful == len(to_unblacklist):
send_message(
update.effective_message,
"Removed <code>{}</code> from blacklist in <b>{}</b>!".format(
successful, chat_name),
parse_mode=ParseMode.HTML)
elif not successful:
send_message(
update.effective_message,
"None of these triggers exist so it can't be removed.".format(
successful,
len(to_unblacklist) - successful),
parse_mode=ParseMode.HTML)
else:
send_message(
update.effective_message,
"Removed <code>{}</code> from blacklist. {} did not exist, "
"so were not removed.".format(successful,
len(to_unblacklist) -
successful),
parse_mode=ParseMode.HTML)
else:
send_message(
update.effective_message,
"Tell me which words you would like to remove from blacklist!")
def add_blackliststicker(bot: Bot, update: Update):
msg = update.effective_message # type: Optional[Message]
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
words = msg.text.split(None, 1)
conn = connected(bot, update, chat, user.id)
if conn:
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
else:
chat_id = update.effective_chat.id
if chat.type == "private":
return
else:
chat_name = chat.title
if len(words) > 1:
text = words[1].replace('https://t.me/addstickers/', '')
to_blacklist = list(
set(trigger.strip() for trigger in text.split("\n")
if trigger.strip()))
added = 0
for trigger in to_blacklist:
try:
get = bot.getStickerSet(trigger)
sql.add_to_stickers(chat_id, trigger.lower())
added += 1
except BadRequest:
send_message(update.effective_message,
"Sticker `{}` can not be found!".format(trigger),
parse_mode="markdown")
if added == 0:
return
if len(to_blacklist) == 1:
send_message(
update.effective_message,
"Sticker <code>{}</code> added to blacklist stickers in <b>{}</b>!"
.format(html.escape(to_blacklist[0]), chat_name),
parse_mode=ParseMode.HTML)
else:
send_message(
update.effective_message,
"<code>{}</code> stickers added to blacklist sticker in <b>{}</b>!"
.format(added, chat_name),
parse_mode=ParseMode.HTML)
elif msg.reply_to_message:
added = 0
trigger = msg.reply_to_message.sticker.set_name
if trigger == None:
send_message(update.effective_message, "Sticker is invalid!")
return
try:
get = bot.getStickerSet(trigger)
sql.add_to_stickers(chat_id, trigger.lower())
added += 1
except BadRequest:
send_message(update.effective_message,
"Sticker `{}` can not be found!".format(trigger),
parse_mode="markdown")
if added == 0:
return
send_message(
update.effective_message,
"Sticker <code>{}</code> added to blacklist stickers in <b>{}</b>!"
.format(trigger, chat_name),
parse_mode=ParseMode.HTML)
else:
send_message(
update.effective_message,
"Tell me what stickers you want to add to the blacklist stickers.")
def unlock(update, context) -> str:
args = context.args
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
if is_user_admin(chat, message.from_user.id):
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 = ("Unlocked {} messages for everyone in {}!".format(ltype, chat_name))
else:
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
text = ("Unlocked {} messages for everyone!".format(ltype))
sql.update_lock(chat.id, ltype, locked=False)
send_message(update.effective_message, text, parse_mode="markdown")
return "<b>{}:</b>" \
"\n#UNLOCK" \
"\n<b>Admin:</b> {}" \
"\nUnlocked <code>{}</code>.".format(html.escape(chat.title),
mention_html(user.id, user.first_name), ltype)
elif ltype in UNLOCK_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 = ("Unlocked {} for everyone in {}!".format(ltype, chat_name))
else:
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
text = ("Unlocked {} for everyone!".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)), UNLOCK_CHAT_RESTRICTION[ltype.lower()]))
send_message(update.effective_message, text, parse_mode="markdown")
return "<b>{}:</b>" \
"\n#UNLOCK" \
"\n<b>Admin:</b> {}" \
"\nUnlocked <code>{}</code>.".format(html.escape(chat.title),
mention_html(user.id, user.first_name), ltype)
else:
send_message(update.effective_message, "What are you trying to unlock...? Try /locktypes for the list of lockables.")
else:
send_message(update.effective_message, "What are you trying to unlock...?")
return ""
def blacklist_mode(update, context):
chat = update.effective_chat
user = update.effective_user
msg = update.effective_message
args = context.args
conn = connected(context.bot, update, chat, user.id, need_admin=True)
if conn:
chat = dispatcher.bot.getChat(conn)
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
else:
if update.effective_message.chat.type == "private":
send_message(update.effective_message,
"This command can be only used 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() == 'off' or args[0].lower(
) == 'nothing' or args[0].lower() == 'no':
settypeblacklist = ('do nothing')
sql.set_blacklist_strength(chat_id, 0, "0")
elif args[0].lower() == 'del' or args[0].lower() == 'delete':
settypeblacklist = ('will delete blacklisted message')
sql.set_blacklist_strength(chat_id, 1, "0")
elif args[0].lower() == 'warn':
settypeblacklist = ('warn the sender')
sql.set_blacklist_strength(chat_id, 2, "0")
elif args[0].lower() == 'mute':
settypeblacklist = ('mute the sender')
sql.set_blacklist_strength(chat_id, 3, "0")
elif args[0].lower() == 'kick':
settypeblacklist = ('kick the sender')
sql.set_blacklist_strength(chat_id, 4, "0")
elif args[0].lower() == 'ban':
settypeblacklist = ('ban the sender')
sql.set_blacklist_strength(chat_id, 5, "0")
elif args[0].lower() == 'tban':
if len(args) == 1:
teks = """It looks like you tried to set time value for blacklist but you didn't specified time; Try, `/blacklistmode 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 ""
restime = extract_time(msg, args[1])
if not restime:
teks = """Invalid time value!
Example 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 ""
settypeblacklist = ('temporarily ban for {}'.format(args[1]))
sql.set_blacklist_strength(chat_id, 6, str(args[1]))
elif args[0].lower() == 'tmute':
if len(args) == 1:
teks = """It looks like you tried to set time value for blacklist but you didn't specified time; try, `/blacklistmode 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 ""
restime = extract_time(msg, args[1])
if not restime:
teks = """Invalid time value!
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 ""
settypeblacklist = ('temporarily mute for {}'.format(args[1]))
sql.set_blacklist_strength(chat_id, 7, str(args[1]))
else:
send_message(
update.effective_message,
"I only understand: off/del/warn/ban/kick/mute/tban/tmute!")
return ""
if conn:
text = "Changed blacklist mode: `{}` in *{}*!".format(
settypeblacklist, chat_name)
else:
text = "Changed blacklist mode: `{}`!".format(settypeblacklist)
send_message(update.effective_message, text, parse_mode="markdown")
return "<b>{}:</b>\n" \
"<b>Admin:</b> {}\n" \
"Changed the blacklist mode. will {}.".format(html.escape(chat.title),
mention_html(user.id, user.first_name), settypeblacklist)
else:
getmode, getvalue = sql.get_blacklist_setting(chat.id)
if getmode == 0:
settypeblacklist = ("do nothing")
elif getmode == 1:
settypeblacklist = ("delete")
elif getmode == 2:
settypeblacklist = ("warn")
elif getmode == 3:
settypeblacklist = ("mute")
elif getmode == 4:
settypeblacklist = ("kick")
elif getmode == 5:
settypeblacklist = ("ban")
elif getmode == 6:
settypeblacklist = ("temporarily ban for {}".format(getvalue))
elif getmode == 7:
settypeblacklist = ("temporarily mute for {}".format(getvalue))
if conn:
text = ("Current blacklistmode: *{}* in *{}*.".format(
settypeblacklist, chat_name))
else:
text = ("Current blacklistmode: *{}*.".format(settypeblacklist))
send_message(update.effective_message,
text,
parse_mode=ParseMode.MARKDOWN)
return ""
def unblackliststicker(bot: Bot, update: Update):
msg = update.effective_message # type: Optional[Message]
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
words = msg.text.split(None, 1)
conn = connected(bot, update, chat, user.id)
if conn:
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
else:
chat_id = update.effective_chat.id
if chat.type == "private":
return
else:
chat_name = chat.title
if len(words) > 1:
text = words[1].replace('https://t.me/addstickers/', '')
to_unblacklist = list(
set(trigger.strip() for trigger in text.split("\n")
if trigger.strip()))
successful = 0
for trigger in to_unblacklist:
success = sql.rm_from_stickers(chat_id, trigger.lower())
if success:
successful += 1
if len(to_unblacklist) == 1:
if successful:
send_message(
update.effective_message,
"Sticker <code>{}</code> deleted from blacklist in <b>{}</b>!"
.format(html.escape(to_unblacklist[0]), chat_name),
parse_mode=ParseMode.HTML)
else:
send_message(update.effective_message,
"This is not on the blacklist stickers...!")
elif successful == len(to_unblacklist):
send_message(
update.effective_message,
"Sticker <code>{}</code> deleted from blacklist in <b>{}</b>!".
format(successful, chat_name),
parse_mode=ParseMode.HTML)
elif not successful:
send_message(
update.effective_message,
"None of these stickers exist, so they cannot be removed.".
format(successful,
len(to_unblacklist) - successful),
parse_mode=ParseMode.HTML)
else:
send_message(
update.effective_message,
"Sticker <code>{}</code> deleted from blacklist. {} did not exist, so it's not deleted."
.format(successful,
len(to_unblacklist) - successful),
parse_mode=ParseMode.HTML)
elif msg.reply_to_message:
trigger = msg.reply_to_message.sticker.set_name
if trigger == None:
send_message(update.effective_message, "Sticker is invalid!")
return
success = sql.rm_from_stickers(chat_id, trigger.lower())
if success:
send_message(
update.effective_message,
"Sticker <code>{}</code> deleted from blacklist in <b>{}</b>!".
format(trigger, chat_name),
parse_mode=ParseMode.HTML)
else:
send_message(
update.effective_message,
"{} not found on blacklisted stickers...!".format(trigger))
else:
send_message(
update.effective_message,
"Tell me what stickers you want to add to the blacklist stickers.")
def connect_chat(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat
user = update.effective_user
spam = spamfilters(update.effective_message.text,
update.effective_message.from_user.id,
update.effective_chat.id)
if spam == True:
return
if update.effective_chat.type == 'private':
if len(args) >= 1:
try:
connect_chat = int(args[0])
getstatusadmin = bot.get_chat_member(
connect_chat, update.effective_message.from_user.id)
except ValueError:
try:
connect_chat = str(args[0])
get_chat = bot.getChat(connect_chat)
connect_chat = get_chat.id
getstatusadmin = bot.get_chat_member(
connect_chat, update.effective_message.from_user.id)
except BadRequest:
send_message(update.effective_message, "Invalid Chat ID!")
return
except BadRequest:
send_message(update.effective_message, "Invalid Chat ID!")
return
isadmin = getstatusadmin.status in ('administrator', 'creator')
ismember = getstatusadmin.status in ('member')
isallow = sql.allow_connect_to_chat(connect_chat)
if (isadmin) or (isallow and ismember) or (
user.id in SUDO_USERS) or (user.id in DEV_USERS):
connection_status = sql.connect(
update.effective_message.from_user.id, connect_chat)
if connection_status:
conn_chat = dispatcher.bot.getChat(
connected(bot, update, chat, user.id,
need_admin=False))
chat_name = conn_chat.title
send_message(
update.effective_message,
"Successfully connected to *{}*. Use /connection for see current available commands."
.format(chat_name),
parse_mode=ParseMode.MARKDOWN)
sql.add_history_conn(user.id, str(conn_chat.id), chat_name)
else:
send_message(update.effective_message,
"Connection failed!")
else:
send_message(update.effective_message,
"Connection to this chat is not allowed!")
else:
gethistory = sql.get_history_conn(user.id)
if gethistory:
buttons = [
InlineKeyboardButton(text="❎ Close button",
callback_data="connect_close"),
InlineKeyboardButton(text="🧹 Clear history",
callback_data="connect_clear")
]
else:
buttons = []
conn = connected(bot, update, chat, user.id, need_admin=False)
if conn:
connectedchat = dispatcher.bot.getChat(conn)
text = "You are connected to *{}* (`{}`)".format(
connectedchat.title, conn)
buttons.append(
InlineKeyboardButton(text="🔌 Disconnect",
callback_data="connect_disconnect"))
else:
text = "Write the chat ID or tag to connect!"
if gethistory:
text += "\n\n*Connection history:*\n"
text += "╒═══「 *Info* 」\n"
text += "│ Sorted: `Newest`\n"
text += "│\n"
buttons = [buttons]
for x in sorted(gethistory.keys(), reverse=True):
htime = time.strftime("%d/%m/%Y", time.localtime(x))
text += "╞═「 *{}* 」\n│ `{}`\n│ `{}`\n".format(
gethistory[x]['chat_name'], gethistory[x]['chat_id'],
htime)
text += "│\n"
buttons.append([
InlineKeyboardButton(
text=gethistory[x]['chat_name'],
callback_data="connect({})".format(
gethistory[x]['chat_id']))
])
text += "╘══「 Total {} Chats 」".format(
str(len(gethistory)) +
" (max)" if len(gethistory) == 5 else str(len(gethistory)))
conn_hist = InlineKeyboardMarkup(buttons)
elif buttons:
conn_hist = InlineKeyboardMarkup([buttons])
else:
conn_hist = None
send_message(update.effective_message,
text,
parse_mode="markdown",
reply_markup=conn_hist)
else:
getstatusadmin = bot.get_chat_member(
chat.id, update.effective_message.from_user.id)
isadmin = getstatusadmin.status in ('administrator', 'creator')
ismember = getstatusadmin.status in ('member')
isallow = sql.allow_connect_to_chat(chat.id)
if (isadmin) or (isallow and ismember) or (user.id in SUDO_USERS) or (
user.id in DEV_USERS):
connection_status = sql.connect(
update.effective_message.from_user.id, chat.id)
if connection_status:
chat_name = dispatcher.bot.getChat(chat.id).title
send_message(
update.effective_message,
"Successfully connected to *{}*.".format(chat_name),
parse_mode=ParseMode.MARKDOWN)
try:
sql.add_history_conn(user.id, str(chat.id), chat_name)
bot.send_message(
update.effective_message.from_user.id,
"You have connected with *{}*. Use /connection for see current available commands."
.format(chat_name),
parse_mode="markdown")
except BadRequest:
pass
except Unauthorized:
pass
else:
send_message(update.effective_message, "Connection failed!")
else:
send_message(update.effective_message,
"Connection to this chat is not allowed!")
def lock(update, context) -> str:
args = context.args
chat = update.effective_chat
user = update.effective_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 = ("Locked all {} messages for non-admins in {}!".format(ltype, chat_name))
else:
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
text = ("Locked all {} messages for non-admins!".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 = ("Locked {} for all non-admins in {}!".format(ltype, chat_name))
else:
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
text = ("Locked {} for all non-admins!".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, "What are you trying to lock...? Try /locktypes for the list of lockables")
else:
send_message(update.effective_message, "What are you trying to lock...?")
else:
send_message(update.effective_message, "I am not administrator or haven't got enough rights.")
return ""
