def ban(bot: Bot, update: Update, args: List[str]) -> str:
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
log_message = ""
user_id, reason = extract_user_and_text(message, args)
if not user_id:
message.reply_text("I doubt that's a user.")
return log_message
try:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "User not found":
message.reply_text("Can't seem to find this person.")
return log_message
else:
raise
if user_id == bot.id:
message.reply_text("Oh yeah, ban myself, noob!")
return log_message
# dev users to bypass whitelist protection incase of abuse
if is_user_ban_protected(chat, user_id, member) and user not in DEV_USERS:
message.reply_text("This user has immunity - I can't ban them.")
return log_message
log = (
f"<b>{html.escape(chat.title)}:</b>\n"
f"#BANNED\n"
f"<b>Admin:</b> {mention_html(user.id, user.first_name)}\n"
f"<b>User:</b> {mention_html(member.user.id, member.user.first_name)}")
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
bot.sendMessage(chat.id,
"Banned user {}.".format(
mention_html(member.user.id,
member.user.first_name)),
parse_mode=ParseMode.HTML)
return log
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
message.reply_text('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("Uhm...that didn't work...")
return log_message
def mute(bot: Bot, update: Update, args: List[str]) -> str:
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
user_id, reason = extract_user_and_text(message, args)
reply = check_user(user_id, bot, chat)
if reply:
message.reply_text(reply)
return ""
member = chat.get_member(user_id)
log = (
f"<b>{html.escape(chat.title)}:</b>\n"
f"#MUTE\n"
f"<b>Admin:</b> {mention_html(user.id, user.first_name)}\n"
f"<b>User:</b> {mention_html(member.user.id, member.user.first_name)}")
if reason:
log += f"\n<b>Reason:</b> {reason}"
if member.can_send_messages is None or member.can_send_messages:
bot.restrict_chat_member(chat.id, user_id, can_send_messages=False)
bot.sendMessage(
chat.id,
f"Muted <b>{html.escape(member.user.first_name)}</b> with no expiration date!",
parse_mode=ParseMode.HTML)
return log
else:
message.reply_text("This user is already muted!")
return ""
def punch(bot: Bot, update: Update, args: List[str]) -> str:
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
log_message = ""
user_id, reason = extract_user_and_text(message, args)
if not user_id:
message.reply_text("I doubt that's a user.")
return log_message
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 log_message
else:
raise
if user_id == bot.id:
message.reply_text("Yeahhh I'm not gonna do that.")
return log_message
if is_user_ban_protected(chat, user_id):
message.reply_text("I really wish I could punch this user....")
return log_message
res = chat.unban_member(user_id) # unban on current user = kick
if res:
# bot.send_sticker(chat.id, BAN_STICKER) # banhammer marie sticker
bot.sendMessage(
chat.id,
f"One Punched! {mention_html(member.user.id, member.user.first_name)}.",
parse_mode=ParseMode.HTML)
log = (
f"<b>{html.escape(chat.title)}:</b>\n"
f"#KICKED\n"
f"<b>Admin:</b> {mention_html(user.id, user.first_name)}\n"
f"<b>User:</b> {mention_html(member.user.id, member.user.first_name)}"
)
if reason:
log += f"\n<b>Reason:</b> {reason}"
return log
else:
message.reply_text("Well damn, I can't punch that user.")
return log_message
def set_title(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat
message = update.effective_message
user_id, title = extract_user_and_text(message, args)
try:
user_member = chat.get_member(user_id)
except:
return
if not user_id:
message.reply_text("You don't seem to be referring to a user or the ID specified is incorrect..")
return
if user_member.status == 'creator':
message.reply_text("This person CREATED the chat, how can i set custom title for him?")
return
if not user_member.status == 'administrator':
message.reply_text("Can't set title for non-admins!\nPromote them first to set custom title!")
return
if user_id == bot.id:
message.reply_text("I can't set my own title myself! Get the one who made me admin to do it for me.")
return
if not title:
message.reply_text("Setting blank title doesn't do anything!")
return
if len(title) > 16:
message.reply_text("The title length is longer than 16 characters.\nTruncating it to 16 characters.")
result = requests.post(f"https://api.telegram.org/bot{TOKEN}/setChatAdministratorCustomTitle"
f"?chat_id={chat.id}"
f"&user_id={user_id}"
f"&custom_title={title}")
status = result.json()["ok"]
if status is True:
bot.sendMessage(chat.id, f"Sucessfully set title for <code>{user_member.user.first_name or user_id}</code> "
f"to <code>{title[:16]}</code>!", parse_mode=ParseMode.HTML)
else:
description = result.json()["description"]
if description == "Bad Request: not enough rights to change custom title of the user":
message.reply_text("I can't set custom title for admins that I didn't promote!")
def warn_user(bot: Bot, update: Update, args: List[str]) -> str:
message: Optional[Message] = update.effective_message
chat: Optional[Chat] = update.effective_chat
warner: Optional[User] = update.effective_user
user_id, reason = extract_user_and_text(message, args)
if user_id:
if message.reply_to_message and message.reply_to_message.from_user.id == user_id:
return warn(message.reply_to_message.from_user, chat, reason,
message.reply_to_message, warner)
else:
return warn(
chat.get_member(user_id).user, chat, reason, message, warner)
else:
message.reply_text("That looks like an invalid User ID to me.")
return ""
def unban(bot: Bot, update: Update, args: List[str]) -> str:
message = update.effective_message
user = update.effective_user
chat = update.effective_chat
log_message = ""
user_id, reason = extract_user_and_text(message, args)
if not user_id:
message.reply_text("I doubt that's a user.")
return log_message
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 log_message
else:
raise
if user_id == bot.id:
message.reply_text("How would I unban myself if I wasn't here...?")
return log_message
if is_user_in_chat(chat, user_id):
message.reply_text("Isn't this person already here??")
return log_message
chat.unban_member(user_id)
message.reply_text("Yep, this user can join!")
log = (
f"<b>{html.escape(chat.title)}:</b>\n"
f"#UNBANNED\n"
f"<b>Admin:</b> {mention_html(user.id, user.first_name)}\n"
f"<b>User:</b> {mention_html(member.user.id, member.user.first_name)}")
if reason:
log += f"\n<b>Reason:</b> {reason}"
return log
def bl_user(bot: Bot, update: Update, args: List[str]) -> str:
message = update.effective_message
user = update.effective_user
user_id, reason = extract_user_and_text(message, args)
if not user_id:
message.reply_text("I doubt that's a user.")
return ""
if user_id == bot.id:
message.reply_text(
"How am I supposed to do my work if I am ignoring myself?")
return ""
if user_id in BLACKLISTWHITELIST:
message.reply_text("No!\nNoticing Disasters is my job.")
return ""
try:
target_user = bot.get_chat(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
sql.blacklist_user(user_id, reason)
message.reply_text("I shall ignore the existence of this user!")
log_message = (
f"#BLACKLIST\n"
f"<b>Admin:</b> {mention_html(user.id, user.first_name)}\n"
f"<b>User:</b> {mention_html(target_user.id, target_user.first_name)}")
if reason:
log_message += f"\n<b>Reason:</b> {reason}"
return log_message
def temp_ban(bot: Bot, update: Update, args: List[str]) -> str:
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
log_message = ""
user_id, reason = extract_user_and_text(message, args)
if not user_id:
message.reply_text("I doubt that's a user.")
return log_message
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 log_message
else:
raise
if user_id == bot.id:
message.reply_text("I'm not gonna BAN myself, are you crazy?")
return log_message
if is_user_ban_protected(chat, user_id, member):
message.reply_text("I don't feel like it.")
return log_message
if not reason:
message.reply_text(
"You haven't specified a time to ban this user for!")
return log_message
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_message
log = (
f"<b>{html.escape(chat.title)}:</b>\n"
"#TEMP BANNED\n"
f"<b>Admin:</b> {mention_html(user.id, user.first_name)}\n"
f"<b>User:</b> {mention_html(member.user.id, member.user.first_name)}\n"
f"<b>Time:</b> {time_val}")
if reason:
log += "\n<b>Reason:</b> {}".format(reason)
try:
chat.kick_member(user_id, until_date=bantime)
# bot.send_sticker(chat.id, BAN_STICKER) # banhammer marie sticker
bot.sendMessage(
chat.id,
f"Banned! User {mention_html(member.user.id, member.user.first_name)} "
f"will be banned for {time_val}.",
parse_mode=ParseMode.HTML)
return log
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
message.reply_text(f"Banned! User will be banned for {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("Well damn, I can't ban that user.")
return log_message
def temp_mute(bot: Bot, update: Update, args: List[str]) -> str:
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
user_id, reason = extract_user_and_text(message, args)
reply = check_user(user_id, bot, chat)
if reply:
message.reply_text(reply)
return ""
member = chat.get_member(user_id)
if not reason:
message.reply_text(
"You haven't specified a time to mute 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 = ""
mutetime = extract_time(message, time_val)
if not mutetime:
return ""
log = (
f"<b>{html.escape(chat.title)}:</b>\n"
f"#TEMP MUTED\n"
f"<b>Admin:</b> {mention_html(user.id, user.first_name)}\n"
f"<b>User:</b> {mention_html(member.user.id, member.user.first_name)}\n"
f"<b>Time:</b> {time_val}")
if reason:
log += f"\n<b>Reason:</b> {reason}"
try:
if member.can_send_messages is None or member.can_send_messages:
bot.restrict_chat_member(chat.id,
user_id,
until_date=mutetime,
can_send_messages=False)
bot.sendMessage(
chat.id,
f"Muted <b>{html.escape(member.user.first_name)}</b> for {time_val}!",
parse_mode=ParseMode.HTML)
return log
else:
message.reply_text("This user is already muted.")
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
message.reply_text(f"Muted for {time_val}!", quote=False)
return log
else:
LOGGER.warning(update)
LOGGER.exception("ERROR muting user %s in chat %s (%s) due to %s",
user_id, chat.title, chat.id, excp.message)
message.reply_text("Well damn, I can't mute that user.")
return ""
def gban(bot: Bot, update: Update, args: List[str]):
message = update.effective_message
user = update.effective_user
chat = update.effective_chat
log_message = ""
user_id, reason = extract_user_and_text(message, args)
if not user_id:
message.reply_text(
"You don't seem to be referring to a user or the ID specified is incorrect.."
)
return
if int(user_id) in DEV_USERS:
message.reply_text(
"That user is part of the Association\nI can't act against our own."
)
return
if int(user_id) in SUDO_USERS:
message.reply_text(
"I spy, with my little eye... a disaster! Why are you guys turning on each other?"
)
return
if int(user_id) in SUPPORT_USERS:
message.reply_text(
"OOOH someone's trying to gban a Demon Disaster! *grabs popcorn*")
return
if int(user_id) in TIGER_USERS:
message.reply_text("That's a Tiger! They cannot be banned!")
return
if int(user_id) in WHITELIST_USERS:
message.reply_text("That's a Wolf! They cannot be banned!")
return
if user_id == bot.id:
message.reply_text("You uhh...want me to punch myself?")
return
try:
user_chat = bot.get_chat(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:
return
if user_chat.type != 'private':
message.reply_text("That's not a user!")
return
if sql.is_user_gbanned(user_id):
if not reason:
message.reply_text(
"This user is already gbanned; I'd change the reason, but you haven't given me one..."
)
return
old_reason = sql.update_gban_reason(
user_id, user_chat.username or user_chat.first_name, reason)
if old_reason:
message.reply_text(
"This user is already gbanned, for the following reason:\n"
"<code>{}</code>\n"
"I've gone and updated it with your new reason!".format(
html.escape(old_reason)),
parse_mode=ParseMode.HTML)
else:
message.reply_text(
"This user is already gbanned, but had no reason set; I've gone and updated it!"
)
return
message.reply_text("On it!")
start_time = time.time()
datetime_fmt = "%Y-%m-%dT%H:%M"
current_time = datetime.utcnow().strftime(datetime_fmt)
if chat.type != 'private':
chat_origin = "<b>{} ({})</b>\n".format(html.escape(chat.title),
chat.id)
else:
chat_origin = "<b>{}</b>\n".format(chat.id)
log_message = (
f"#GBANNED\n"
f"<b>Originated from:</b> <code>{chat_origin}</code>\n"
f"<b>Admin:</b> {mention_html(user.id, user.first_name)}\n"
f"<b>Banned User:</b> {mention_html(user_chat.id, user_chat.first_name)}\n"
f"<b>Banned User ID:</b> <code>{user_chat.id}</code>\n"
f"<b>Event Stamp:</b> <code>{current_time}</code>")
if reason:
if chat.type == chat.SUPERGROUP and chat.username:
log_message += f"\n<b>Reason:</b> <a href=\"http://telegram.me/{chat.username}/{message.message_id}\">{reason}</a>"
else:
log_message += f"\n<b>Reason:</b> <code>{reason}</code>"
if GBAN_LOGS:
try:
log = bot.send_message(GBAN_LOGS,
log_message,
parse_mode=ParseMode.HTML)
except BadRequest as excp:
log = bot.send_message(
GBAN_LOGS, log_message +
"\n\nFormatting has been disabled due to an unexpected error.")
else:
send_to_list(bot, SUDO_USERS + SUPPORT_USERS, log_message, html=True)
sql.gban_user(user_id, user_chat.username or user_chat.first_name, reason)
chats = get_all_chats()
gbanned_chats = 0
for chat in chats:
chat_id = chat.chat_id
# Check if this group has disabled gbans
if not sql.does_chat_gban(chat_id):
continue
try:
bot.kick_chat_member(chat_id, user_id)
gbanned_chats += 1
except BadRequest as excp:
if excp.message in GBAN_ERRORS:
pass
else:
message.reply_text(f"Could not gban due to: {excp.message}")
if GBAN_LOGS:
bot.send_message(GBAN_LOGS,
f"Could not gban due to {excp.message}",
parse_mode=ParseMode.HTML)
else:
send_to_list(bot, SUDO_USERS + SUPPORT_USERS,
f"Could not gban due to: {excp.message}")
sql.ungban_user(user_id)
return
except TelegramError:
pass
if GBAN_LOGS:
log.edit_text(log_message +
f"\n<b>Chats affected:</b> <code>{gbanned_chats}</code>",
parse_mode=ParseMode.HTML)
else:
send_to_list(
bot,
SUDO_USERS + SUPPORT_USERS,
f"Gban complete! (User banned in <code>{gbanned_chats}</code> chats)",
parse_mode=ParseMode.HTML)
end_time = time.time()
gban_time = round((end_time - start_time), 2)
if gban_time > 60:
gban_time = round((gban_time / 60), 2)
message.reply_text(
f"Done! This gban affected <code>{gbanned_chats}</code> chats, Took {gban_time} min",
parse_mode=ParseMode.HTML)
else:
message.reply_text(
f"Done! This gban affected <code>{gbanned_chats}</code> chats, Took {gban_time} sec",
parse_mode=ParseMode.HTML)
try:
bot.send_message(
user_id,
"You have been globally banned from all groups where I have administrative permissions."
"To see the reason click on /info"
f"If you think that this was a mistake, you may appeal your ban here: {SUPPORT_CHAT}",
parse_mode=ParseMode.HTML)
except:
pass # bot probably blocked by user
def rban(bot: Bot, update: Update, args: List[str]):
message = update.effective_message
if not args:
message.reply_text("You don't seem to be referring to a chat/user.")
return
user_id, chat_id = extract_user_and_text(message, args)
if not user_id:
message.reply_text("You don't seem to be referring to a user or the ID specified is incorrect..")
return
elif not chat_id:
message.reply_text("You don't seem to be referring to a chat.")
return
try:
chat = bot.get_chat(chat_id.split()[0])
except BadRequest as excp:
if excp.message == "Chat not found":
message.reply_text("Chat not found! Make sure you entered a valid chat ID and I'm part of that chat.")
return
else:
raise
if chat.type == 'private':
message.reply_text("I'm sorry, but that's a private chat!")
return
if not is_bot_admin(chat, bot.id) or not chat.get_member(bot.id).can_restrict_members:
message.reply_text("I can't restrict people there! Make sure I'm admin and can ban users.")
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 is_user_ban_protected(chat, user_id, member):
message.reply_text("I really wish I could ban admins...")
return
if user_id == bot.id:
message.reply_text("I'm not gonna BAN myself, are you crazy?")
return
try:
chat.kick_member(user_id)
message.reply_text("Banned from chat!")
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
message.reply_text('Banned!', quote=False)
elif excp.message in RBAN_ERRORS:
message.reply_text(excp.message)
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("Well damn, I can't ban that user.")
def runmute(bot: Bot, update: Update, args: List[str]):
message = update.effective_message
if not args:
message.reply_text("You don't seem to be referring to a chat/user.")
return
user_id, chat_id = extract_user_and_text(message, args)
if not user_id:
message.reply_text("You don't seem to be referring to a user or the ID specified is incorrect..")
return
elif not chat_id:
message.reply_text("You don't seem to be referring to a chat.")
return
try:
chat = bot.get_chat(chat_id.split()[0])
except BadRequest as excp:
if excp.message == "Chat not found":
message.reply_text("Chat not found! Make sure you entered a valid chat ID and I'm part of that chat.")
return
else:
raise
if chat.type == 'private':
message.reply_text("I'm sorry, but that's a private chat!")
return
if not is_bot_admin(chat, bot.id) or not chat.get_member(bot.id).can_restrict_members:
message.reply_text("I can't unrestrict people there! Make sure I'm admin and can unban users.")
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 there")
return
else:
raise
if is_user_in_chat(chat, user_id):
if member.can_send_messages and member.can_send_media_messages \
and member.can_send_other_messages and member.can_add_web_page_previews:
message.reply_text("This user already has the right to speak in that chat.")
return
if user_id == bot.id:
message.reply_text("I'm not gonna UNMUTE myself, I'm an admin there!")
return
try:
bot.restrict_chat_member(chat.id, int(user_id),
can_send_messages=True,
can_send_media_messages=True,
can_send_other_messages=True,
can_add_web_page_previews=True)
message.reply_text("Yep, this user can talk in that chat!")
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
message.reply_text('Unmuted!', quote=False)
elif excp.message in RUNMUTE_ERRORS:
message.reply_text(excp.message)
else:
LOGGER.warning(update)
LOGGER.exception("ERROR unmnuting user %s in chat %s (%s) due to %s", user_id, chat.title, chat.id,
excp.message)
message.reply_text("Well damn, I can't unmute that user.")