def unban(bot: Bot, update: Update, args: List[str]) -> str:
message = update.effective_message # type: Optional[Message]
user = update.effective_user # type: Optional[User]
chat = update.effective_chat # type: Optional[Chat]
user_id, reason = extract_user_and_text(message, args)
if not user_id:
return ""
try:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "User not found":
message.reply_text(tld(chat.id, "common_err_no_user"))
return ""
else:
raise
if is_user_in_chat(chat, user_id):
message.reply_text(tld(chat.id, "bans_unban_user_in_chat"))
return ""
chat.unban_member(user_id)
message.reply_text(tld(chat.id, "bans_unban_success"))
log = tld(chat.id, "bans_unban_logger").format(
html.escape(chat.title), mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name), member.user.id)
if reason:
log += tld(chat.id, "bans_logger_reason").format(reason)
return log
def warn_user(update, context):
message = update.effective_message # type: Optional[Message]
chat = update.effective_chat # type: Optional[Chat]
warner = update.effective_user # type: Optional[User]
user = update.effective_user
args = context.args
user_id, reason = extract_user_and_text(message, args)
if user_id == "error":
send_message(update.effective_message, reason)
return ""
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,
"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
check = context.bot.getChatMember(chat_id, context.bot.id)
if check.status == 'member' or check['can_restrict_members'] == False:
if conn:
text = "I can't restrect people on {}! Make sure I'm already an admin.".format(
chat_name)
else:
text = "I can't restrect people in here! Make sure I'm already an admin."
send_message(update.effective_message, text, parse_mode=ParseMode.HTML)
return ""
if user_id:
if conn:
warning = warn(chat.get_member(user_id).user,
chat,
reason,
message,
warner,
conn=True)
send_message(update.effective_message,
"That user has been warned in *{}*".format(chat_name),
parse_mode=ParseMode.HTML)
return warning
else:
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:
send_message(update.effective_message, "No user was designated!")
return ""
def ban(bot: Bot, update: Update, args: List[str]) -> str:
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
message = update.effective_message # type: Optional[Message]
user_id, reason = extract_user_and_text(message, args)
if not user_id:
message.reply_text(tld(chat.id, "common_err_no_user"))
return ""
try:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "User not found.":
message.reply_text(tld(chat.id, "bans_err_usr_not_found"))
return ""
else:
raise
if user_id == bot.id:
message.reply_text(tld(chat.id, "bans_err_usr_is_bot"))
return ""
if is_user_ban_protected(chat, user_id, member):
message.reply_text(tld(chat.id, "bans_err_usr_is_admin"))
return ""
log = tld(chat.id, "bans_logger").format(
html.escape(chat.title), mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name), user_id)
reply = tld(chat.id, "bans_banned_success").format(
mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name),
html.escape(chat.title))
if reason:
log += tld(chat.id, "bans_logger_reason").format(reason)
reply += tld(chat.id, "bans_logger_reason").format(reason)
try:
chat.kick_member(user_id)
message.reply_text(reply, parse_mode=ParseMode.HTML)
return log
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
message.reply_text(reply, quote=False, parse_mode=ParseMode.HTML)
return log
else:
LOGGER.warning(update)
LOGGER.exception("ERROR banning user %s in chat %s (%s) due to %s",
user_id, chat.title, chat.id, excp.message)
message.reply_text(
tld(chat.id, "bans_err_unknown").format("banning"))
return ""
def kick(bot: Bot, update: Update, args: List[str]) -> str:
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
message = update.effective_message # type: Optional[Message]
user_id, reason = extract_user_and_text(message, args)
if not user_id:
message.reply_text(tld(chat.id, "common_err_no_user"))
return ""
try:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "User not found.":
message.reply_text(tld(chat.id, "bans_err_usr_not_found"))
return ""
else:
raise
if user_id == bot.id:
message.reply_text(tld(chat.id, "bans_kick_is_bot"))
return ""
if is_user_ban_protected(chat, user_id):
message.reply_text(tld(chat.id, "bans_kick_is_admin"))
return ""
res = chat.unban_member(user_id) # unban on current user = kick
if res:
reply = tld(chat.id, "bans_kick_success").format(
mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name),
html.escape(chat.title))
if reason:
reply += tld(chat.id, "bans_logger_reason").format(reason)
message.reply_text(reply, parse_mode=ParseMode.HTML)
log = tld(chat.id, "bans_kick_logger").format(
html.escape(chat.title), mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name),
member.user.id)
if reason:
log += tld(chat.id, "bans_logger_reason").format(reason)
return log
else:
message.reply_text(tld(chat.id, "bans_err_unknown").format("kicking"))
return ""
def warn_user(bot: Bot, update: Update, args: List[str]) -> str:
message = update.effective_message
chat = update.effective_chat
warner = 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(tld(chat.id, 'common_err_no_user'))
return ""
def sban(bot: Bot, update: Update, args: List[str]) -> str:
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
message = update.effective_message # type: Optional[Message]
update.effective_message.delete()
user_id, reason = extract_user_and_text(message, args)
if not user_id:
return ""
try:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "User not found":
return ""
else:
raise
if is_user_ban_protected(chat, user_id, member):
return ""
if user_id == bot.id:
return ""
log = tld(chat.id, "bans_sban_logger").format(
html.escape(chat.title), mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name), user_id)
if reason:
log += tld(chat.id, "bans_logger_reason").format(reason)
try:
chat.kick_member(user_id)
return log
except BadRequest as excp:
if excp.message == "Reply message not found":
return log
else:
LOGGER.warning(update)
LOGGER.exception("ERROR banning user %s in chat %s (%s) due to %s",
user_id, chat.title, chat.id, excp.message)
return ""
def 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(tld(chat.id, "common_err_no_user"))
return
if user_id == bot.id:
message.reply_text(tld(chat.id, "antispam_err_usr_bot"))
return
if user_id in [777000, 1087968824]:
message.reply_text(tld(chat.id, "antisoam_err_tg_support"))
return
try:
user_chat = bot.get_chat(user_id)
except BadRequest as excp:
if excp.message == "User not found":
message.reply_text(tld(chat.id, "antispam_err_notfound_usr"))
return ""
else:
return
if user_chat.type != "private":
message.reply_text(tld(chat.id, "antispam_err_not_usr"))
return
if sql.is_user_gbanned(user_id):
if not reason:
message.reply_text(tld(chat.id, "antispam_err_no_new_reason"))
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("Banging...")
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="https://telegram.me/{chat.username}/{message.message_id}">{reason}</a>'
else:
log_message += f"\n<b>Reason:</b> <code>{reason}</code>"
if EVENT_LOGS:
try:
log = bot.send_message(EVENT_LOGS, log_message, parse_mode=ParseMode.HTML)
except BadRequest as excp:
log = bot.send_message(
EVENT_LOGS,
log_message
+ "\n\nFormatting has been disabled due to an unexpected error.",
)
else:
send_to_list(bot, log_message, html=True)
sql.gban_user(user_id, user_chat.username or user_chat.first_name, reason)
chats = get_user_com_chats(user_id)
gbanned_chats = 0
for chat in chats:
chat_id = int(chat)
# 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 EVENT_LOGS:
bot.send_message(
EVENT_LOGS,
f"Could not gban due to {excp.message}",
parse_mode=ParseMode.HTML,
)
else:
send_to_list(
bot, f"Could not gban due to: {excp.message}"
)
sql.ungban_user(user_id)
return
except TelegramError:
pass
if EVENT_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,
f"Gban complete! (User banned in <code>{gbanned_chats}</code> chats)",
html=True,
)
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("Done! Gbanned.", parse_mode=ParseMode.HTML)
else:
message.reply_text("Done! Gbanned.", parse_mode=ParseMode.HTML)
try:
bot.send_message(
user_id,
"#EVENT"
"You have been marked as Malicious and as such have been banned from any future groups we manage."
f"\n<b>Reason:</b> <code>{html.escape(user.reason)}</code>"
f"</b>Appeal Chat:</b> @{SUPPORT_CHAT}",
parse_mode=ParseMode.HTML,
)
except:
pass # bot probably blocked by user
def mute(update, context):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
message = update.effective_message # type: Optional[Message]
args = context.args
user_id, reason = extract_user_and_text(message, args)
if not user_id or user_id == "error":
send_message(
update.effective_message,
"You'll need to either give me a username to mute, or reply to someone to be muted."
)
return ""
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
text = "Muted on *{}*!".format(chat_name)
else:
if update.effective_message.chat.type == "private":
update.effective_send_message(
update.effective_message,
"You can do this command in groups, not PM")
return ""
chat = update.effective_chat
member = chat.get_member(int(user_id))
chat_id = update.effective_chat.id
chat_name = update.effective_message.chat.title
text = "Admin {} Muted user {}\n<b>Reason:</b> {}".format(
mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name), reason
or "No reason given")
if user_id == context.bot.id:
send_message(update.effective_message, "I'm not muting myself!")
return ""
check = context.bot.getChatMember(chat.id, user.id)
if check['can_restrict_members'] == False:
send_message(update.effective_message,
"You have no right to restrict someone.")
return ""
if member:
if is_user_admin(chat, user_id, member=member):
send_message(update.effective_message,
"I can't stop an admin from talking!")
elif member.can_send_messages is None or member.can_send_messages:
context.bot.restrict_chat_member(
chat.id,
user_id,
permissions=ChatPermissions(can_send_messages=False))
send_message(update.effective_message,
text,
parse_mode=ParseMode.HTML)
return "<b>{}:</b>" \
"\n#MUTE" \
"\n<b>Admin:</b> {}" \
"\n<b>User:</b> {}".format(html.escape(chat.title),
mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name))
else:
send_message(update.effective_message,
"This user is already muted!")
else:
send_message(update.effective_message, "This user isn't in the chat!")
return ""
def temp_mute(update, context):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
message = update.effective_message # type: Optional[Message]
args = context.args
user_id, reason = extract_user_and_text(message, args)
if user_id == "error":
send_message(update.effective_message, reason)
return ""
if not user_id:
send_message(update.effective_message,
"You don't seem to be referring to a user.")
return ""
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":
update.effective_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
try:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "User not found":
send_message(update.effective_message, "I can't find this user")
return ""
else:
raise
if is_user_admin(chat, user_id, member):
send_message(update.effective_message,
"I really wish I could mute admins...")
return ""
if user_id == context.bot.id:
send_message(update.effective_message,
"I'm not gonna MUTE myself, are you crazy?")
return ""
check = context.bot.getChatMember(chat.id, user.id)
if check['can_restrict_members'] == False:
send_message(update.effective_message,
"You have no right to restrict someone.")
return ""
if not reason:
send_message(update.effective_message,
"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 = "<b>{}:</b>" \
"\n#TMUTE" \
"\n<b>Admin:</b> {}" \
"\n<b>User:</b> {}" \
"\n<b>Time:</b> {}".format(html.escape(chat.title), mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name), time_val)
if reason:
log += "\n<b>Reason:</b> {}".format(reason)
try:
if member.can_send_messages is None or member.can_send_messages:
context.bot.restrict_chat_member(
chat.id,
user_id,
until_date=mutetime,
permissions=ChatPermissions(can_send_messages=False))
if conn:
text = "Muted for *{}* in *{}*!".format(time_val, chat_name)
else:
text = "Admin {} Temporary Muted user {} for {}\n<b>Reason:</b> {}".format(
mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name),
time_val, reason or "No reason given")
send_message(update.effective_message,
text,
parse_mode=ParseMode.HTML)
return log
else:
send_message(update.effective_message,
"This user is already muted.")
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
send_message(
update.effective_message,
"Admin {} Temporary Muted user {} for {}\n<b>Reason:</b> {}".
format(mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name),
time_val, reason or "No reason given"),
parse_mode=ParseMode.HTML)
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)
send_message(update.effective_message,
"Well damn, I can't mute that user.")
return ""
def gban(update, context):
banner = update.effective_user # type: Optional[User]
message = update.effective_message # type: Optional[Message]
chat_name = update.effective_message.chat.title
args = context.args
user_id, reason = extract_user_and_text(message, args)
if user_id == "error":
send_message(update.effective_message, reason)
return ""
if not user_id:
send_message(update.effective_message, "You don't seem to be referring to a user.")
return
if int(user_id) in SUDO_USERS:
send_message(update.effective_message, "I spy, with my little eye... a sudo user war! Why are you guys turning on each other?")
return
if int(user_id) in SUPPORT_USERS:
send_message(update.effective_message, "OOOH someone's trying to gban a support user! *grabs popcorn*")
return
if user_id == context.bot.id:
send_message(update.effective_message, "So funny, lets gban myself why don't I? Nice try.")
return
try:
user_chat = context.bot.get_chat(user_id)
except BadRequest as excp:
send_message(update.effective_message, excp.message)
return
if user_chat.type != 'private':
send_message(update.effective_message, "That's not a user!")
return
if user_chat.first_name == '':
send_message(update.effective_message, "That's a deleted account! Why even bother gbanning them?")
return
full_reason = f"{reason} // GBanned by {banner.first_name}"
if sql.is_user_gbanned(user_id):
if not reason:
send_message(update.effective_message, "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,
full_reason) or "None"
try:
context.bot.send_message(
UPDATE_GBAN.format(
mention_html(banner.id, banner.first_name),
mention_html(user_chat.id, user_chat.first_name
or "Deleted Account"), user_chat.id,
old_reason, full_reason),
parse_mode=ParseMode.HTML)
except Exception:
pass
# send_message(update.effective_message, "This user has already been gbanned. I have updated the reason.\nPrevious reason: <code>{}</code>\nNew reason: <code>{}</code>".format(
# html.escape(old_reason), html.escape(full_reason)),
# parse_mode=ParseMode.HTML)
# return
starting = "Global Banning {} with the id <code>{}</code>...".format(
mention_html(user_chat.id, user_chat.first_name or "Deleted Account"),
user_chat.id)
send_message(update.effective_message, starting, parse_mode=ParseMode.HTML)
try:
context.bot.send_message("{} is gbanning user {} with the following reason: <code>{}</code>.".format(
mention_html(banner.id, banner.first_name),
mention_html(user_chat.id, user_chat.first_name),
full_reason
or "No reason given"),
html=True)
except Exception:
print("nut")
sql.gban_user(user_id, user_chat.username or user_chat.first_name,
full_reason)
chats = get_all_chats()
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:
context.bot.kick_chat_member(chat_id, user_id)
except BadRequest as excp:
if excp.message in GBAN_ERRORS:
pass
else:
send_message(update.effective_message, "Could not gban due to: {}".format(excp.message))
send_to_list(context.bot, SUDO_USERS + SUPPORT_USERS, "Could not un-gban due to: {}".format(excp.message))
sql.ungban_user(user_id)
return
except TelegramError:
pass
log_message = (f"#GBANNED\n"
f"<b>Originated from:</b> {chat_name}\n"
f"<b>Admin:</b> {mention_html(banner.id, banner.first_name)}\n"
f"<b>Banned User:</b> {mention_html(user_chat.id, user_chat.first_name)}\n"
f"<b>Banned User ID:</b> {user_chat.id}\n"
f"<b>Reason:</b> {reason}" or "No reason given")
if GBAN_LOGS:
context.bot.send_message(GBAN_LOGS, log_message, parse_mode=ParseMode.HTML)
send_to_list(context.bot, SUDO_USERS + SUPPORT_USERS, f"Admin {mention_html(banner.id, banner.first_name)} gbanned user {mention_html(user_chat.id, user_chat.first_name)}\nReason: {reason}" , html=True)
send_message(update.effective_message, f"Admin {mention_html(banner.id, banner.first_name)} gbanned user {mention_html(user_chat.id, user_chat.first_name)}\nReason: {reason}" , parse_mode=ParseMode.HTML)
def fed_ban(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat
user = update.effective_user
fed_id = sql.get_fed_id(chat.id)
if not fed_id:
update.effective_message.reply_text(
"This group is not a part of any federation!")
return
info = sql.get_fed_info(fed_id)
OW = bot.get_chat(info['owner'])
HAHA = OW.id
FEDADMIN = sql.all_fed_users(fed_id)
FEDADMIN.append(int(HAHA))
if is_user_fed_admin(fed_id, user.id) == False:
update.effective_message.reply_text(
"Only federation admins can do this!")
return
message = update.effective_message
user_id, reason = extract_user_and_text(message, args)
fban, fbanreason = sql.get_fban_user(fed_id, user_id)
if not user_id:
message.reply_text("You don't seem to be referring to a user")
return
if user_id == bot.id:
message.reply_text(
"What is funnier than fbanning the bot? Self sacrifice.")
return
if is_user_fed_owner(fed_id, user_id) == True:
message.reply_text("Why did you try the federation fban?")
return
if is_user_fed_admin(fed_id, user_id) == True:
message.reply_text("He is a federation admin, I can't fban him.")
return
if user_id == OWNER_ID:
message.reply_text(
"I don't want to fban my master, that's a very stupid idea!")
return
if int(user_id) in SUDO_USERS:
message.reply_text("I will not fban sudos!")
return
if int(user_id) in WHITELIST_USERS:
message.reply_text(
"This person is whitelisted, so they can't be fbanned!")
return
try:
user_chat = bot.get_chat(user_id)
except BadRequest as excp:
message.reply_text(excp.message)
return
if user_chat.type != 'private':
message.reply_text("That's not a user!")
return
if fban:
user_target = mention_html(user_chat.id, user_chat.first_name)
fed_name = info['fname']
starting = "The reason of federation ban has been replaced for {} in the Federation <b>{}</b>.".format(
user_target, fed_name)
update.effective_message.reply_text(starting,
parse_mode=ParseMode.HTML)
if reason == "":
reason = "No reason given."
temp = sql.un_fban_user(fed_id, user_id)
if not temp:
message.reply_text("Failed to update the reason for fban!")
return
x = sql.fban_user(fed_id, user_id, user_chat.first_name,
user_chat.last_name, user_chat.username, reason)
if not x:
message.reply_text("Failed to ban from the federation.")
return
fed_chats = sql.all_fed_chats(fed_id)
for chat in fed_chats:
try:
bot.kick_chat_member(chat, user_id)
except BadRequest as excp:
if excp.message in FBAN_ERRORS:
pass
else:
LOGGER.warning("Could not fban in {} because: {}".format(
chat, excp.message))
except TelegramError:
pass
send_to_list(bot,
FEDADMIN,
"<b>FedBan reason updated</b>"
"\n<b>Federation:</b> {}"
"\n<b>Federation Admin:</b> {}"
"\n<b>User:</b> {}"
"\n<b>User ID:</b> <code>{}</code>"
"\n<b>Reason:</b> {}".format(
fed_name, mention_html(user.id, user.first_name),
mention_html(user_chat.id, user_chat.first_name),
user_chat.id, reason),
html=True)
message.reply_text("FedBan reason has been updated.")
return
user_target = mention_html(user_chat.id, user_chat.first_name)
fed_name = info['fname']
starting = "Starting a federation ban for {} in the Federation <b>{}</b>.".format(
user_target, fed_name)
update.effective_message.reply_text(starting, parse_mode=ParseMode.HTML)
if reason == "":
reason = "No reason given."
x = sql.fban_user(fed_id, user_id, user_chat.first_name,
user_chat.last_name, user_chat.username, reason)
if not x:
message.reply_text("Failed to ban from the federation.")
return
fed_chats = sql.all_fed_chats(fed_id)
for chat in fed_chats:
try:
bot.kick_chat_member(chat, user_id)
except BadRequest as excp:
if excp.message in FBAN_ERRORS:
try:
dispatcher.bot.getChat(chat)
except Unauthorized:
sql.chat_leave_fed(chat)
LOGGER.info(
"Chat {} has leave fed {} because bot is kicked".
format(chat, info['fname']))
continue
else:
LOGGER.warning("Cannot fban on {} because: {}".format(
chat, excp.message))
except TelegramError:
pass
send_to_list(bot,
FEDADMIN,
"<b>New FedBan</b>"
"\n<b>Federation:</b> {}"
"\n<b>Federation Admin:</b> {}"
"\n<b>User:</b> {}"
"\n<b>User ID:</b> <code>{}</code>"
"\n<b>Reason:</b> {}".format(
fed_name, mention_html(user.id, user.first_name),
mention_html(user_chat.id, user_chat.first_name),
user_chat.id, reason),
html=True)
message.reply_text("This person has been fbanned")
def unban(update, context):
message = update.effective_message # type: Optional[Message]
user = update.effective_user # type: Optional[User]
chat = update.effective_chat # type: Optional[Chat]
args = context.args
user_id, reason = extract_user_and_text(message, args)
if user_id == "error":
send_message(update.effective_message, reason)
return ""
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, "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 not user_id:
return ""
check = context.bot.getChatMember(chat_id, context.bot.id)
if check.status == 'member':
if conn:
text = "I can't restrict people in {}! Make sure I'm admin and can appoint new admins.".format(chat_name)
else:
text = "I can't restrict people here! Make sure I'm admin and can appoint new admins."
send_message(update.effective_message, text, parse_mode=ParseMode.HTML)
return ""
else:
if check['can_restrict_members'] == False:
if conn:
text = "I can't restrict people in {}! Make sure I'm admin and can appoint new admins.".format(chat_name)
else:
text = "I can't restrict people here! Make sure I'm admin and can appoint new admins."
send_message(update.effective_message, text, parse_mode=ParseMode.HTML)
return ""
try:
if conn:
member = context.bot.getChatMember(chat_id, user_id)
else:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "User not found":
send_message(update.effective_message, "I can't find this user")
return ""
else:
raise
if user_id == context.bot.id:
send_message(update.effective_message, "How would I unban myself if I wasn't here...?")
return ""
if is_user_in_chat(chat, user_id):
send_message(update.effective_message, "Why are you trying to unban someone that's already in the chat?")
return ""
check = context.bot.getChatMember(chat.id, user.id)
if check['can_restrict_members'] == False:
send_message(update.effective_message, "You have no right to restrict someone.")
return ""
if conn:
context.bot.unbanChatMember(chat_id, user_id)
send_message(update.effective_message, "Yep, {} can join in {}!".format(mention_html(member.user.id, member.user.first_name), chat_name), parse_mode=ParseMode.HTML)
else:
chat.unban_member(user_id)
send_message(update.effective_message, "Yep, {} can join!".format(mention_html(member.user.id, member.user.first_name)), parse_mode=ParseMode.HTML)
log = "<b>{}:</b>" \
"\n#UNBANNED" \
"\n<b>Admin:</b> {}" \
"\n<b>User:</b> {} (<code>{}</code>)".format(html.escape(chat.title),
mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name),
member.user.id)
if reason:
log += "\n<b>Reason:</b> {}".format(reason)
return log
def kick(update, context):
currentchat = update.effective_chat # type: Optional[Chat]
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
message = update.effective_message # type: Optional[Message]
args = context.args
user_id, reason = extract_user_and_text(message, args)
if user_id == "error":
send_message(update.effective_message, reason)
return ""
if not user_id:
send_message(update.effective_message, "You don't seem to be referring to a user.")
return ""
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, "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
check = context.bot.getChatMember(chat_id, context.bot.id)
if check.status == 'member':
if conn:
text = "I can't restrict people in {}! Make sure I'm admin and can appoint new admins.".format(chat_name)
else:
text = "I can't restrict people here! Make sure I'm admin and can appoint new admins."
send_message(update.effective_message, text, parse_mode=ParseMode.HTML)
return ""
else:
if check['can_restrict_members'] == False:
if conn:
text = "I can't restrict people in {}! Make sure I'm admin and can appoint new admins.".format(chat_name)
else:
text = "I can't restrict people here! Make sure I'm admin and can appoint new admins."
send_message(update.effective_message, text, parse_mode=ParseMode.HTML)
return ""
if not user_id:
return ""
try:
if conn:
member = context.bot.getChatMember(chat_id, user_id)
else:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "User not found":
send_message(update.effective_message, "I can't find this user")
return ""
else:
raise
if user_id == context.bot.id:
send_message(update.effective_message, "I'm not gonna kick myself, are you crazy?")
return ""
if is_user_ban_protected(chat, user_id):
send_message(update.effective_message, "I really wish I could kick admins...")
return ""
if user_id == context.bot.id:
send_message(update.effective_message, "Yeahhh I'm not gonna do that")
return ""
check = context.bot.getChatMember(chat.id, user.id)
if check['can_restrict_members'] == False:
send_message(update.effective_message, "You have no right to restrict someone.")
return ""
if conn:
res = context.bot.unbanChatMember(chat_id, user_id) # unban on current user = kick
else:
res = chat.unban_member(user_id) # unban on current user = kick
if res:
if conn:
context.bot.send_sticker(currentchat.id, BAN_STICKER) # banhammer marie sticker
text = "Kicked at *{}*!".format(chat_name)
send_message(update.effective_message, text, parse_mode=ParseMode.HTML)
else:
if message.text.split(None, 1)[0][1:] == "skick":
update.effective_message.delete()
else:
context.bot.send_sticker(chat.id, BAN_STICKER) # banhammer marie sticker
send_message(update.effective_message, "Admin {} Kicked user {}\n<b>Reason:</b> {}".format(mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name),
reason or "No reason given"),
parse_mode=ParseMode.HTML)
log = "<b>{}:</b>" \
"\n#KICKED" \
"\n<b>Admin:</b> {}" \
"\n<b>User:</b> {} (<code>{}</code>)".format(html.escape(chat.title),
mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name),
member.user.id)
log += "\n<b>Reason:</b> {}".format(reason)
return log
else:
send_message(update.effective_message, "Well damn, I can't kick that user")
return ""
def ban(update, context):
currentchat = update.effective_chat # type: Optional[Chat]
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
message = update.effective_message # type: Optional[Message]
args = context.args
user_id, reason = extract_user_and_text(message, args)
if user_id == "error":
send_message(update.effective_message, reason)
return ""
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, "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
check = context.bot.getChatMember(chat_id, context.bot.id)
if check.status == 'member' or check['can_restrict_members'] == False:
if conn:
text = "I can't restrict people in {}! Make sure I'm admin and can appoint new admins.".format(chat_name)
else:
text = "I can't restrict people here! Make sure I'm admin and can appoint new admins."
send_message(update.effective_message, text, parse_mode=ParseMode.HTML)
return ""
if not user_id:
send_message(update.effective_message, "You don't seem to be referring to a user.")
return ""
try:
if conn:
member = context.bot.getChatMember(chat_id, user_id)
else:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "User not found":
if conn:
text = "I can't find this user on *{}*".format(chat_name)
else:
text = "I can't find this user"
send_message(update.effective_message, text, parse_mode=ParseMode.HTML)
return ""
else:
raise
if user_id == context.bot.id:
send_message(update.effective_message, "I'm not gonna BAN myself, are you crazy?")
return ""
if is_user_ban_protected(chat, user_id, member):
send_message(update.effective_message, "I really wish I could ban admins...")
return ""
if member['can_restrict_members'] == False:
if conn:
text = "You have no right to restrict someone in *{}*.".format(chat_name)
else:
text = "You have no right to restrict someone."
send_message(update.effective_message, text, parse_mode=ParseMode.HTML)
return ""
log = "<b>{}:</b>" \
"\n#BANNED" \
"\n<b>Admin:</b> {}" \
"\n<b>User:</b> {} (<code>{}</code>)".format(html.escape(chat.title),
mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name),
member.user.id)
if reason:
log += "\n<b>Reason:</b> {}".format(reason)
try:
if conn:
context.bot.kickChatMember(chat_id, user_id)
context.bot.send_sticker(currentchat.id, BAN_STICKER) # banhammer marie sticker
send_message(update.effective_message, "Banned at *{}*!".format(chat_name), parse_mode=ParseMode.HTML)
else:
chat.kick_member(user_id)
if message.text.split(None, 1)[0][1:] == "sban":
update.effective_message.delete()
else:
context.bot.send_sticker(chat.id, BAN_STICKER) # banhammer marie sticker
send_message(update.effective_message, "Admin {} Banned user {}\n<b>Reason:</b> {}".format(mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name),
reason or "No reason given"),
parse_mode=ParseMode.HTML)
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
send_message(update.effective_message, "Admin {} Banned user {}\n<b>Reason:</b> {}".format(mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name),
reason or "No reason given"),
parse_mode=ParseMode.HTML)
return log
elif excp.message == "Message can't be deleted":
pass
else:
LOGGER.warning(update)
LOGGER.exception("ERROR banned the user %s in the chat %s (%s) caused by %s", user_id, chat.title, chat.id,
excp.message)
send_message(update.effective_message, "Well damn, I can't ban that user ")
return ""
def temp_ban(update, context):
currentchat = update.effective_chat # type: Optional[Chat]
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
message = update.effective_message # type: Optional[Message]
args = context.args
user_id, reason = extract_user_and_text(message, args)
if user_id == "error":
send_message(update.effective_message, reason)
return ""
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, "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
check = context.bot.getChatMember(chat_id, context.bot.id)
if check.status == 'member':
if conn:
text = "I can't restrict people in {}! Make sure I'm admin and can appoint new admins.".format(chat_name)
else:
text = "I can't restrict people here! Make sure I'm admin and can appoint new admins."
send_message(update.effective_message, text, parse_mode=ParseMode.HTML)
return ""
else:
if check['can_restrict_members'] == False:
if conn:
text = "I can't restrict people in {}! Make sure I'm admin and can appoint new admins.".format(chat_name)
else:
text = "I can't restrict people here! Make sure I'm admin and can appoint new admins."
send_message(update.effective_message, text, parse_mode=ParseMode.HTML)
return ""
if not user_id:
send_message(update.effective_message, "You don't seem to be referring to a user.")
return ""
try:
if conn:
member = context.bot.getChatMember(chat_id, user_id)
else:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "User not found":
send_message(update.effective_message, "I can't find this user")
return ""
else:
raise
if user_id == context.bot.id:
send_message(update.effective_message, "I'm not gonna BAN myself, are you crazy?")
return ""
if is_user_ban_protected(chat, user_id, member):
send_message(update.effective_message, "I really wish I could ban admins...")
return ""
if member['can_restrict_members'] == False:
send_message(update.effective_message, "You have no right to restrict someone.")
return ""
if not reason:
send_message(update.effective_message, "You haven't specified a time to ban this user for!")
return ""
split_reason = reason.split(None, 1)
time_val = split_reason[0].lower()
if len(split_reason) > 1:
reason = split_reason[1]
else:
reason = ""
bantime = extract_time(message, time_val)
if not bantime:
return ""
log = "<b>{}:</b>" \
"\n#TEMPBAN" \
"\n<b>Admin:</b> {}" \
"\n<b>User:</b> {} (<code>{}</code>)" \
"\n<b>Time:</b> {}".format(html.escape(chat.title),
mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name),
member.user.id,
time_val)
if reason:
log += "\n<b>Reason:</b> {}".format(reason)
try:
if conn:
context.bot.kickChatMember(chat_id, user_id, until_date=bantime)
context.bot.send_sticker(currentchat.id, BAN_STICKER) # banhammer marie sticker
send_message(update.effective_message, "Admin {} Temporary Banned user {} for {} at {}\n<b>Reason:</b> {}".format(mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name),
time_val, chat_name, reason or "No reason given"),
parse_mode=ParseMode.HTML)
else:
chat.kick_member(user_id, until_date=bantime)
context.bot.send_sticker(chat.id, BAN_STICKER) # banhammer marie sticker
send_message(update.effective_message, "Admin {} Temporary Banned user {} for {}\n<b>Reason:</b> {}".format(mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name),
time_val, reason or "No reason given"),
parse_mode=ParseMode.HTML)
return log
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
send_message(update.effective_message,"Admin {} Temporary Banned user {} for {}\n<b>Reason:</b> {}".format(mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name),
time_val, reason),
parse_mode=ParseMode.HTML)
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)
send_message(update.effective_message, "Well damn, I can't kick that user")
return ""
def temp_nomedia(bot: Bot, update: Update, args: List[str]) -> str:
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
conn = connected(bot, update, chat, user.id)
if conn:
chatD = dispatcher.bot.getChat(conn)
else:
if chat.type == "private":
return
else:
chatD = chat
user_id, reason = extract_user_and_text(message, args)
if not user_id:
message.reply_text(tld(chat.id, "mute_not_refer"))
return ""
try:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "User not found":
message.reply_text(tld(chat.id, "mute_not_existed"))
return ""
else:
raise
if is_user_admin(chat, user_id, member):
message.reply_text(tld(chat.id, "restrict_is_admin"))
return ""
if user_id == bot.id:
message.reply_text(tld(chat.id, "restrict_is_bot"))
return ""
if not reason:
message.reply_text(tld(chat.id, "nomedia_need_time"))
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 = "<b>{}:</b>" \
"\n#TEMP RESTRICTED" \
"\n<b>• Admin:</b> {}" \
"\n<b>• User:</b> {}" \
"\n<b>• ID:</b> <code>{}</code>" \
"\n<b>• Time:</b> {}".format(html.escape(chat.title), mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name), user_id, time_val)
if reason:
log += tld(chat.id, "bans_logger_reason").format(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=True,
can_send_media_messages=False,
can_send_other_messages=False,
can_add_web_page_previews=False)
message.reply_text(
tld(chat.id, "nomedia_success").format(time_val, chatD.title))
return log
else:
message.reply_text(
tld(chat.id,
"restrict_already_restricted").format(chatD.title))
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
message.reply_text(tld(chat.id, "nomedia_success").format(
time_val, chatD.title),
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(tld(chat.id, "restrict_cant_restricted"))
return ""