def get_id(bot: Bot, update: Update, args: List[str]):
user_id = extract_user(update.effective_message, args)
chat = update.effective_chat # type: Optional[Chat]
if user_id:
if update.effective_message.reply_to_message and update.effective_message.reply_to_message.forward_from:
user1 = update.effective_message.reply_to_message.from_user
user2 = update.effective_message.reply_to_message.forward_from
update.effective_message.reply_text(tld(
chat.id,
"The original sender, {}, has an ID of `{}`.\nThe forwarder, {}, has an ID of `{}`."
).format(escape_markdown(user2.first_name), user2.id,
escape_markdown(user1.first_name), user1.id),
parse_mode=ParseMode.MARKDOWN)
else:
user = bot.get_chat(user_id)
update.effective_message.reply_text(tld(
chat.id,
"{}'s id is `{}`.").format(escape_markdown(user.first_name),
user.id),
parse_mode=ParseMode.MARKDOWN)
else:
chat = update.effective_chat # type: Optional[Chat]
if chat.type == "private":
update.effective_message.reply_text(tld(
chat.id, "Your id is `{}`.").format(chat.id),
parse_mode=ParseMode.MARKDOWN)
else:
update.effective_message.reply_text(tld(
chat.id, "This group's id is `{}`.").format(chat.id),
parse_mode=ParseMode.MARKDOWN)
def invite(bot: Bot, update: Update):
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 not conn == False:
chatP = dispatcher.bot.getChat(conn)
else:
chatP = update.effective_chat
if chat.type == "private":
exit(1)
if chatP.username:
update.effective_message.reply_text(chatP.username)
elif chatP.type == chatP.SUPERGROUP or chatP.type == chatP.CHANNEL:
bot_member = chatP.get_member(bot.id)
if bot_member.can_invite_users:
invitelink = chatP.invite_link
#print(invitelink)
if not invitelink:
invitelink = bot.exportChatInviteLink(chatP.id)
update.effective_message.reply_text(invitelink)
else:
update.effective_message.reply_text(tld(chat.id, "I don't have access to the invite link, try changing my permissions!"))
else:
update.effective_message.reply_text(tld(chat.id, "I can only give you invite links for supergroups and channels, sorry!"))
def enable(update, context):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
bot = context.bot
args = context.args
conn = connected(bot, update, chat, user.id)
if not conn == False:
chatD = dispatcher.bot.getChat(conn)
else:
if chat.type == "private":
exit(1)
else:
chatD = update.effective_chat
if len(args) >= 1:
enable_cmd = args[0]
if enable_cmd.startswith(CMD_STARTERS):
enable_cmd = enable_cmd[1:]
if sql.enable_command(chatD.id, enable_cmd):
update.effective_message.reply_text(tld(chat.id, "Enabled the use of `{}` in *{}*").format(enable_cmd, chatD.title),
parse_mode=ParseMode.MARKDOWN)
else:
update.effective_message.reply_text(tld(chat.id, "Is that even disabled?"))
else:
update.effective_message.reply_text(tld(chat.id, "What should I enable?"))
def commands(bot: Bot, update: Update):
chat = update.effective_chat
user = update.effective_user # type: Optional[User]
conn = connected(bot, update, chat, user.id, need_admin=False)
if not conn == False:
chatD = dispatcher.bot.getChat(conn)
else:
if chat.type == "private":
exit(1)
else:
chatD = update.effective_chat
disabled = sql.get_all_disabled(chatD.id)
if not disabled:
update.effective_message.reply_text(
tld(chat.id,
"No commands are disabled! in *{}*!").format(chatD.title))
text = build_curr_disabled(chatD.id, chat.id)
update.effective_message.reply_text(tld(
chat.id,
"The following commands are currently restricted in *{}*:\n{}").
format(chatD.title, text),
parse_mode=ParseMode.MARKDOWN)
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 allow_connections(update, context) -> str:
chat = update.effective_chat # type: Optional[Chat]
bot = context.bot
args = context.args
if chat.type != chat.PRIVATE:
if len(args) >= 1:
var = args[0]
print(var)
if var == "no":
sql.set_allow_connect_to_chat(chat.id, False)
update.effective_message.reply_text(
tld(chat.id,
"Disabled connections to this chat for users"))
elif var == "yes":
sql.set_allow_connect_to_chat(chat.id, True)
update.effective_message.reply_text(
tld(chat.id, "Enabled connections to this chat for users"))
else:
update.effective_message.reply_text(
tld(chat.id, "Please enter on/yes/off/no in group!"))
else:
update.effective_message.reply_text(
tld(chat.id, "Please enter on/yes/off/no in group!"))
else:
update.effective_message.reply_text(
tld(chat.id, "Please enter on/yes/off/no in group!"))
def disable(update, context):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
bot = context.bot
args = context.args
conn = connected(bot, update, chat, user.id)
if not conn == False:
chatD = dispatcher.bot.getChat(conn)
else:
if chat.type == "private":
exit(1)
else:
chatD = update.effective_chat
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(chatD.id, disable_cmd)
update.effective_message.reply_text(tld(chat.id, "Disabled the use of `{}` in *{}*").format(disable_cmd, chatD.title),
parse_mode=ParseMode.MARKDOWN)
else:
update.effective_message.reply_text(tld(chat.id, "That command can't be disabled"))
else:
update.effective_message.reply_text(tld(chat.id, "What should I disable?"))
def set_frules(update, context):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
bot = context.bot
args = context.args
fed_id = sql.get_fed_id(chat.id)
if not fed_id:
update.effective_message.reply_text(tld(chat.id, "This chat is not in any federation!"))
return
if is_user_fed_admin(fed_id, user.id) == False:
update.effective_message.reply_text(tld(chat.id, "Only fed admins can do this!"))
return
if len(args) >= 1:
msg = update.effective_message # type: Optional[Message]
raw_text = msg.text
args = raw_text.split(None, 1) # use python's maxsplit to separate cmd and args
if len(args) == 2:
txt = args[1]
offset = len(txt) - len(raw_text) # set correct offset relative to command
markdown_rules = markdown_parser(txt, entities=msg.parse_entities(), offset=offset)
x = sql.set_frules(fed_id, markdown_rules)
if not x:
update.effective_message.reply_text(tld(chat.id, "Big F! There is an error while setting federation rules! If you wondered why please ask it in support group!"))
return
rules = sql.get_fed_info(fed_id).fed_name
update.effective_message.reply_text(tld(chat.id, f"Rules are set for {rules}!"))
else:
update.effective_message.reply_text(tld(chat.id, "Please write rules to set it up!"))
def new_fed(update, context):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
message = update.effective_message
fednam = message.text[len('/newfed '):]
if not fednam == '':
fed_id = str(uuid.uuid4())
fed_name = fednam
LOGGER.info(fed_id)
#if fednam == 'Name':
# fed_id = "Name"
x = sql.new_fed(user.id, fed_name, fed_id)
if not x:
update.effective_message.reply_text(tld(chat.id, "Big F! There is an error while creating Federations, Kindly get into my support group and ask what is going on!"))
return
update.effective_message.reply_text("*You have successfully created a new federation!*"\
"\nName: `{}`"\
"\nID: `{}`"
"\n\nUse command below to join the federation:"
"\n`/joinfed {}`".format(fed_name, fed_id, fed_id), parse_mode=ParseMode.MARKDOWN)
context.bot.send_message(
MESSAGE_DUMP,
"Federation <b>{}</b> has been created with ID: <pre>{}</pre>".format(fed_name, fed_id),parse_mode=ParseMode.HTML)
else:
update.effective_message.reply_text(tld(chat.id, "Please write federation name!"))
def fed_admin(update, context):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
bot = context.bot
args = context.args
fed_id = sql.get_fed_id(chat.id)
if not fed_id:
update.effective_message.reply_text(tld(chat.id, "This group is not in any federation!"))
return
if is_user_fed_admin(fed_id, user.id) == False:
update.effective_message.reply_text(tld(chat.id, "Only fed admins can do this!"))
return
print(fed_id)
user = update.effective_user # type: Optional[Chat]
chat = update.effective_chat # type: Optional[Chat]
info = sql.get_fed_info(fed_id)
text = "\n\n<b>Federation Admins:</b>"
user = bot.get_chat(info.owner_id)
text += "\n• {} - <code>{}</code> (Creator)".format(mention_html(user.id, user.first_name), user.id)
h = sql.all_fed_users(fed_id)
for O in h:
user = bot.get_chat(O)
text += "\n• {} - <code>{}</code>".format(mention_html(user.id, user.first_name), user.id, O)
update.effective_message.reply_text(text, parse_mode=ParseMode.HTML)
def leave_fed(update, context):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
bot = context.bot
args = context.args
fed_id = sql.get_fed_id(chat.id)
administrators = chat.get_administrators()
if user.id in SUDO_USERS:
pass
else:
for admin in administrators:
status = admin.status
if status == "creator":
print(admin)
if str(admin.user.id) == str(user.id):
pass
else:
update.effective_message.reply_text(tld(chat.id, "Only group creator can do it!"))
return
if sql.chat_leave_fed(chat.id) == True:
update.effective_message.reply_text(tld(chat.id, "Left from fed!"))
else:
update.effective_message.reply_text(tld(chat.id, "Why you are leaving feds when you have not join any!"))
def build_lock_message(chat, chatP, user, chatname):
locks = sql.get_locks(chat.id)
restr = sql.get_restr(chat.id)
if not (locks or restr):
res = tld(chatP.id,
"There are no current locks in *{}*.".format(chatname))
else:
res = tld(chatP.id, "These are the locks in *{}*:".format(chatname))
if locks:
res += "\n - sticker = `{}`" \
"\n - audio = `{}`" \
"\n - voice = `{}`" \
"\n - document = `{}`" \
"\n - video = `{}`" \
"\n - videonote = `{}`" \
"\n - contact = `{}`" \
"\n - photo = `{}`" \
"\n - gif = `{}`" \
"\n - url = `{}`" \
"\n - bots = `{}`" \
"\n - forward = `{}`" \
"\n - game = `{}`" \
"\n - location = `{}`".format(locks.sticker, locks.audio, locks.voice, locks.document,
locks.video, locks.videonote, locks.contact, locks.photo, locks.gif, locks.url,
locks.bots, locks.forward, locks.game, locks.location)
if restr:
res += "\n - messages = `{}`" \
"\n - media = `{}`" \
"\n - other = `{}`" \
"\n - previews = `{}`" \
"\n - all = `{}`".format(restr.messages, restr.media, restr.other, restr.preview,
all([restr.messages, restr.media, restr.other, restr.preview]))
return res
def paginate_modules(chat_id, page_n: int, module_dict: Dict, prefix, chat=None) -> List:
if not chat:
modules = sorted(
[EqInlineKeyboardButton(tld(chat_id, x.__mod_name__),
callback_data="{}_module({})".format(prefix, x.__mod_name__.lower())) for x
in module_dict.values()])
else:
modules = sorted(
[EqInlineKeyboardButton(tld(chat_id, x.__mod_name__),
callback_data="{}_module({},{})".format(prefix, chat, x.__mod_name__.lower())) for x
in module_dict.values()])
pairs = list(zip(modules[::2], modules[1::2]))
if len(modules) % 2 == 1:
pairs.append((modules[-1],))
max_num_pages = ceil(len(pairs) / 7)
modulo_page = page_n % max_num_pages
# can only have a certain amount of buttons side by side
if len(pairs) > 7:
pairs = pairs[modulo_page * 7:7 * (modulo_page + 1)] + [
(EqInlineKeyboardButton("<<", callback_data="{}_prev({})".format(prefix, modulo_page)),
EqInlineKeyboardButton("⬅️ Back", callback_data="bot_start"),
EqInlineKeyboardButton(">>", callback_data="{}_next({})".format(prefix, modulo_page)))]
else:
pairs += [[EqInlineKeyboardButton("⬅️ Back", callback_data="bot_start")]]
return pairs
def antispam(update, context):
chat = update.effective_chat # type: Optional[Chat]
bot = context.bot
args = context.args
if len(args) > 0:
if args[0].lower() in ["on", "yes"]:
sql.enable_antispam(chat.id)
update.effective_message.reply_text(
tld(
chat.id,
"I've enabled antispam security in this group. This will help protect you "
"from spammers, unsavoury characters, and the biggest trolls."
))
elif args[0].lower() in ["off", "no"]:
sql.disable_antispam(chat.id)
update.effective_message.reply_text(
tld(
chat.id,
"I've disabled antispam security in this group. GBans wont affect your users "
"anymore. You'll be less protected from any trolls and spammers "
"though!"))
else:
update.effective_message.reply_text(
tld(
chat.id,
"Give me some arguments to choose a setting! on/off, yes/no!\n\n"
"Your current setting is: {}\n"
"When True, any gbans that happen will also happen in your group. "
"When False, they won't, leaving you at the possible mercy of "
"spammers.").format(sql.does_chat_gban(chat.id)))
def gdpr(bot: Bot, update: Update):
update.effective_message.reply_text(
tld(update.effective_chat.id, "Deleting identifiable data..."))
for mod in GDPR:
mod.__gdpr__(update.effective_user.id)
update.effective_message.reply_text(tld(update.effective_chat.id,
"send_gdpr"),
parse_mode=ParseMode.MARKDOWN)
def unlock(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 is_user_admin(chat, message.from_user.id):
if len(args) >= 1:
if args[0] in LOCK_TYPES:
sql.update_lock(chat.id, args[0], locked=False)
message.reply_text(
tld(chat.id, "Unlocked {} for everyone!").format(args[0]))
return "<b>{}:</b>" \
"\n#UNLOCK" \
"\n<b>Admin:</b> {}" \
"\nUnlocked <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=False)
"""
members = users_sql.get_chat_members(chat.id)
if args[0] == "messages":
unrestr_members(bot, chat.id, members, media=False, other=False, previews=False)
elif args[0] == "media":
unrestr_members(bot, chat.id, members, other=False, previews=False)
elif args[0] == "other":
unrestr_members(bot, chat.id, members, previews=False)
elif args[0] == "previews":
unrestr_members(bot, chat.id, members)
elif args[0] == "all":
unrestr_members(bot, chat.id, members, True, True, True, True)
"""
message.reply_text(
tld(chat.id, "Unlocked {} for everyone!").format(args[0]))
return "<b>{}:</b>" \
"\n#UNLOCK" \
"\n<b>Admin:</b> {}" \
"\nUnlocked <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 unlock...? Try /locktypes for the list of lockables"
))
else:
bot.sendMessage(chat.id,
tld(chat.id, "What are you trying to unlock...?"))
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 __user_info__(user_id, chat_id):
if user_id == dispatcher.bot.id:
return tld(
chat_id,
"I've seen them in... Wow. Are they stalking me? They're in all the same places I am... oh. It's me."
)
num_chats = sql.get_user_num_chats(user_id)
return tld(
chat_id,
"I've seen them in <code>{}</code> chats in total.").format(num_chats)
def list_cmds(update, context):
chat = update.effective_chat # type: Optional[Chat]
bot = context.bot
if DISABLE_CMDS + DISABLE_OTHER:
result = ""
for cmd in set(DISABLE_CMDS + DISABLE_OTHER):
result += " • `{}`\n".format(escape_markdown(cmd))
update.effective_message.reply_text(tld(chat.id, "The following commands are toggleable:\n{}").format(result),
parse_mode=ParseMode.MARKDOWN)
else:
update.effective_message.reply_text(tld(chat.id, "No commands can be disabled."))
def check_afk(bot, update, user_id, fst_name):
chat = update.effective_chat # type: Optional[Chat]
if sql.is_afk(user_id):
user = sql.check_afk_status(user_id)
if not user.reason:
res = tld(chat.id, f"{fst_name} is AFK!")
else:
res = tld(
chat.id,
f"{fst_name} is AFK! says its because of:\n{user.reason}")
update.effective_message.reply_text(res)
def promote(update, context) -> str:
message = update.effective_message # type: Optional[Message]
user = update.effective_user # type: Optional[User]
chat = update.effective_chat # type: Optional[Chat]
bot = context.bot
args = context.args
user_member = chat.get_member(user.id)
conn = connected(bot, update, chat, user.id)
if not conn == False:
chatD = dispatcher.bot.getChat(conn)
else:
chatD = update.effective_chat
if chat.type == "private":
exit(1)
if not chatD.get_member(bot.id).can_promote_members:
update.effective_message.reply_text("I can't promote/demote people here! "
"Make sure I'm admin and can appoint new admins.")
exit(1)
user_id = extract_user(message, args)
if not user_id:
message.reply_text(tld(chat.id, "You don't seem to be referring to a user."))
return ""
user_member = chatD.get_member(user_id)
if user_member.status == 'administrator' or user_member.status == 'creator':
message.reply_text(tld(chat.id, "How am I meant to promote someone that's already an admin?"))
return ""
if user_id == bot.id:
message.reply_text(tld(chat.id, "I can't promote myself! Get an admin to do it for me."))
return ""
# set same perms as bot - bot can't assign higher perms than itself!
bot_member = chatD.get_member(bot.id)
bot.promoteChatMember(chatD.id, user_id,
can_change_info=bot_member.can_change_info,
can_post_messages=bot_member.can_post_messages,
can_edit_messages=bot_member.can_edit_messages,
can_delete_messages=bot_member.can_delete_messages,
#can_invite_users=bot_member.can_invite_users,
can_restrict_members=bot_member.can_restrict_members,
can_pin_messages=bot_member.can_pin_messages,
can_promote_members=bot_member.can_promote_members)
message.reply_text(tld(chat.id, f"Successfully promoted in *{chatD.title}*!"), parse_mode=ParseMode.MARKDOWN)
return f"<b>{html.escape(chatD.title)}:</b>" \
"\n#PROMOTED" \
f"\n<b>Admin:</b> {mention_html(user.id, user.first_name)}" \
f"\n<b>User:</b> {mention_html(user_member.user.id, user_member.user.first_name)}"
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]
bot = context.bot
args = context.args
if len(args) >= 1:
val = args[0].lower()
if val == "off" or val == "no" or val == "0":
sql.set_flood(chat.id, 0)
message.reply_text(tld(chat.id, "Antiflood has been disabled."))
elif val.isdigit():
amount = int(val)
if amount <= 0:
sql.set_flood(chat.id, 0)
message.reply_text(tld(chat.id,
"Antiflood has been disabled."))
return "#SETFLOOD" \
"\n<b>Chat:</b> {}" \
"\n<b>Admin:</b> {}" \
"\nDisabled antiflood.".format(html.escape(chat.title), mention_html(user.id, user.first_name))
elif amount < 3:
message.reply_text(
tld(
chat.id,
"Antiflood has to be either 0 (disabled), or a number bigger than 3 (enabled)!"
))
return ""
else:
sql.set_flood(chat.id, amount)
message.reply_text(
tld(chat.id,
"Antiflood has been updated and set to {}").format(
amount))
return "#SETFLOOD" \
"\n<b>Chat:</b> {}" \
"\n<b>Admin:</b> {}" \
"\nSet antiflood to <code>{}</code>.".format(html.escape(chat.title),
mention_html(user.id, user.first_name), amount)
else:
message.reply_text(
tld(
chat.id,
"Unrecognised argument - please use a number, 'off', or 'no'."
))
return ""
def flood(bot: Bot, update: Update):
chat = update.effective_chat # type: Optional[Chat]
limit = sql.get_flood_limit(chat.id)
if limit == 0:
update.effective_message.reply_text(
tld(chat.id, "I'm not currently enforcing flood control!"))
else:
update.effective_message.reply_text(
tld(
chat.id,
"I'm currently muting users if they send more than {} consecutive messages."
).format(limit))
def markdown_help(bot: Bot, update: Update):
chat = update.effective_chat # type: Optional[Chat]
update.effective_message.reply_text(tld(chat.id, "MARKDOWN_HELP-K"),
parse_mode=ParseMode.HTML)
update.effective_message.reply_text(
tld(chat.id,
"Try forwarding the following message to me, and you'll see!"))
update.effective_message.reply_text(
tld(
chat.id,
"/save test This is a markdown test. _italics_, *bold*, `code`, "
"[URL](example.com) [button](buttonurl:github.com) "
"[button2](buttonurl://google.com:same)"))
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 __user_info__(user_id, chat_id):
is_gbanned = sql.is_user_gbanned(user_id)
is_gmuted = sql.is_user_gmuted(user_id)
if not user_id in SUDO_USERS:
text = tld(chat_id, "Globally banned: <b>{}</b>")
if is_gbanned:
text = text.format(tld(chat_id, "Yes"))
user = sql.get_gbanned_user(user_id)
if user.reason:
text += tld(chat_id,
"\nReason: {}").format(html.escape(user.reason))
else:
text = text.format(tld(chat_id, "No"))
text += tld(chat_id, "\nGlobally muted: <b>{}</b>")
if is_gmuted:
text = text.format(tld(chat_id, "Yes"))
user = sql.get_gmuted_user(user_id)
if user.reason:
text += tld(chat_id,
"\nReason: {}").format(html.escape(user.reason))
else:
text = text.format(tld(chat_id, "No"))
return text
else:
return ""
def unsetlog(bot: Bot, update: Update):
message = update.effective_message # type: Optional[Message]
chat = update.effective_chat # type: Optional[Chat]
log_channel = sql.stop_chat_logging(chat.id)
if log_channel:
bot.send_message(
log_channel,
tld(chat.id,
"Channel has been unlinked from {}").format(chat.title))
message.reply_text(tld(chat.id, "Log channel has been un-set."))
else:
message.reply_text(tld(chat.id,
"No log channel has been set yet!"))
def setlog(update, context):
message = update.effective_message # type: Optional[Message]
chat = update.effective_chat # type: Optional[Chat]
bot = context.bot
if chat.type == chat.CHANNEL:
message.reply_text(
tld(
chat.id,
"Now, forward the /setlog to the group you want to tie this channel to!"
))
elif message.forward_from_chat:
sql.set_chat_log_channel(chat.id, message.forward_from_chat.id)
try:
message.delete()
except BadRequest as excp:
if excp.message == "Message to delete not found":
pass
else:
LOGGER.exception(
"Error deleting message in log channel. Should work anyway though."
)
try:
bot.send_message(
message.forward_from_chat.id,
tld(
chat.id,
"This channel has been set as the log channel for {}."
).format(chat.title or chat.first_name))
except Unauthorized as excp:
if excp.message == "Forbidden: bot is not a member of the channel chat":
bot.send_message(
chat.id, tld(chat.id, "Successfully set log channel!"))
else:
LOGGER.exception("ERROR in setting the log channel.")
bot.send_message(chat.id,
tld(chat.id, "Successfully set log channel!"))
else:
message.reply_text(
tld(
chat.id, "*The steps to set a log channel are:*\n"
" • add bot to the desired channel\n"
" • send /setlog to the channel\n"
" • forward the /setlog to the group\n"),
ParseMode.MARKDOWN)
def locale(bot, update, args):
chat = update.effective_chat
if len(args) > 0:
locale = args[0].lower()
if locale in list_locales:
if locale in ('en', 'ru', 'ua', 'es', 'tr', 'id', 'it'):
switch_to_locale(chat.id, locale)
update.message.reply_text(
tld(chat.id, 'Switched to {} successfully!').format(
list_locales[locale]))
else:
update.message.reply_text("{} is not supported yet!".format(
list_locales[locale]))
else:
update.message.reply_text(
"Is that even a valid language code? Use an internationally accepted ISO code!"
)
else:
LANGUAGE = prev_locale(chat.id)
if LANGUAGE:
locale = LANGUAGE.locale_name
native_lang = list_locales[locale]
update.message.reply_text(
"Current locale for this chat is: *{}*".format(native_lang),
parse_mode=ParseMode.MARKDOWN)
else:
update.message.reply_text(
"Current locale for this chat is: *English*",
parse_mode=ParseMode.MARKDOWN)
def fed_chat(update, context):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
bot = context.bot
args = context.args
fed_id = sql.get_fed_id(chat.id)
user_id = update.effective_message.from_user.id
if not is_user_admin(update.effective_chat, user_id):
update.effective_message.reply_text("You must be a chat administrator to run this command :P")
return
if not fed_id:
update.effective_message.reply_text(tld(chat.id, "This group not in any federation!"))
return
print(fed_id)
user = update.effective_user # type: Optional[Chat]
chat = update.effective_chat # type: Optional[Chat]
info = sql.get_fed_info(fed_id)
text = "This chat is part of the following federation:"
text += "\n{} (ID: <code>{}</code>)".format(info.fed_name, fed_id)
update.effective_message.reply_text(text, parse_mode=ParseMode.HTML)
