def gmute(bot: Bot, update: Update, args: List[str]):
message = update.effective_message # type: Optional[Message]
user_id, reason = extract_user_and_text(message, args)
if not user_id:
message.reply_text(
"നിങ്ങൾ ഒരു യൂസേറിനെ റെഫർ ചെയ്യുന്നതായി തോന്നുന്നില്ല.")
return
if int(user_id) in SUDO_USERS:
message.reply_text(
"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:
message.reply_text(
"OOOH someone's trying to gmute a support user! *grabs popcorn*")
return
if user_id == bot.id:
message.reply_text(
"-_- ആഹ് നല്ല കോമഡി😂 നിനക്കു ഞാൻ മിണ്ടുന്നത് കൊണ്ടെന്താ കൊഴപ്പം?.")
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("അതൊരു യൂസർ അല്ല !")
return
if sql.is_user_gmuted(user_id):
if not reason:
message.reply_text(
"ഈ യൂസേറിനെ മുന്നേ തന്നെ gmute ചെയ്തതാണ്; ഞാൻ വേണേൽ gmute ചെയ്യാനുള്ള കാരണം മാറ്റാം, പക്ഷേ നിങ്ങൾ ഒരു കാരണവും തന്നിട്ടില്ലല്ലോ..."
)
return
success = sql.update_gmute_reason(
user_id, user_chat.username or user_chat.first_name, reason)
if success:
message.reply_text(
"This user is already gmuted; I've gone and updated the gmute reason though!"
)
else:
message.reply_text(
"Do you mind trying again? I thought this person was gmuted, but then they weren't? "
"Am very confused")
return
message.reply_text("*Gets duct tape ready* 😉")
muter = update.effective_user # type: Optional[User]
send_to_list(bot,
SUDO_USERS + SUPPORT_USERS,
"{} is gmuting user {} "
"because:\n{}".format(
mention_html(muter.id, muter.first_name),
mention_html(user_chat.id, user_chat.first_name), reason
or "No reason given"),
html=True)
sql.gmute_user(user_id, user_chat.username or user_chat.first_name, reason)
chats = get_all_chats()
for chat in chats:
chat_id = chat.chat_id
# Check if this group has disabled gmutes
if not sql.does_chat_gmute(chat_id):
continue
try:
bot.restrict_chat_member(chat_id, user_id, can_send_messages=False)
except BadRequest as excp:
if excp.message == "User is an administrator of the chat":
pass
elif excp.message == "Chat not found":
pass
elif excp.message == "Not enough rights to restrict/unrestrict chat member":
pass
elif excp.message == "User_not_participant":
pass
elif excp.message == "Peer_id_invalid": # Suspect this happens when a group is suspended by telegram.
pass
elif excp.message == "Group chat was deactivated":
pass
elif excp.message == "Need to be inviter of a user to kick it from a basic group":
pass
elif excp.message == "Chat_admin_required":
pass
elif excp.message == "Only the creator of a basic group can kick group administrators":
pass
elif excp.message == "Method is available only for supergroups":
pass
elif excp.message == "Can't demote chat creator":
pass
else:
message.reply_text("Could not gmute due to: {}".format(
excp.message))
send_to_list(bot, SUDO_USERS + SUPPORT_USERS,
"Could not gmute due to: {}".format(excp.message))
sql.ungmute_user(user_id)
return
except TelegramError:
pass
send_to_list(bot, SUDO_USERS + SUPPORT_USERS, "gmute complete!")
message.reply_text("Person has been gmuted.")
def temp_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("You don't seem to be referring to a user.")
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 ""
if not reason:
message.reply_text("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#TEMP BANNED" \
"\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:
chat.kick_member(user_id, until_date=bantime)
bot.send_sticker(chat.id, BAN_STICKER) # banhammer marie sticker
message.reply_text("Banned! User will be banned for {}.".format(time_val))
return log
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
message.reply_text("Banned! User will be banned for {}.".format(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 ""
def gmute(bot: Bot, update: Update, args: List[str]):
message = update.effective_message # type: Optional[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.")
return
if int(user_id) in SUDO_USERS:
message.reply_text("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:
message.reply_text("OOOH someone's trying to gmute a support user! *grabs popcorn*")
return
if user_id == bot.id:
message.reply_text("-_- So funny, lets gmute myself why don't I? Nice try.")
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 sql.is_user_gmuted(user_id):
if not reason:
message.reply_text("This user is already gmuted; I'd change the reason, but you haven't given me one...")
return
success = sql.update_gmute_reason(user_id, user_chat.username or user_chat.first_name, reason)
if success:
message.reply_text("This user is already gmuted; I've gone and updated the gmute reason though!")
else:
message.reply_text("Do you mind trying again? I thought this person was gmuted, but then they weren't? "
"Am very confused")
return
message.reply_text("*Gets duct tape ready* 😉")
muter = update.effective_user # type: Optional[User]
send_to_list(bot, SUDO_USERS + SUPPORT_USERS,
"{} is gmuting user {} "
"because:\n{}".format(mention_html(muter.id, muter.first_name),
mention_html(user_chat.id, user_chat.first_name), reason or "No reason given"),
html=True)
sql.gmute_user(user_id, user_chat.username or user_chat.first_name, reason)
chats = get_all_chats()
for chat in chats:
chat_id = chat.chat_id
# Check if this group has disabled gmutes
if not sql.does_chat_gmute(chat_id):
continue
try:
bot.restrict_chat_member(chat_id, user_id, can_send_messages=False)
except BadRequest as excp:
if excp.message == "User is an administrator of the chat":
pass
elif excp.message == "Chat not found":
pass
elif excp.message == "Not enough rights to restrict/unrestrict chat member":
pass
elif excp.message == "User_not_participant":
pass
elif excp.message == "Peer_id_invalid": # Suspect this happens when a group is suspended by telegram.
pass
elif excp.message == "Group chat was deactivated":
pass
elif excp.message == "Need to be inviter of a user to kick it from a basic group":
pass
elif excp.message == "Chat_admin_required":
pass
elif excp.message == "Only the creator of a basic group can kick group administrators":
pass
elif excp.message == "Method is available only for supergroups":
pass
elif excp.message != "Can't demote chat creator":
message.reply_text("Could not gmute due to: {}".format(excp.message))
send_to_list(bot, SUDO_USERS + SUPPORT_USERS, "Could not gmute due to: {}".format(excp.message))
sql.ungmute_user(user_id)
return
except TelegramError:
pass
send_to_list(bot, SUDO_USERS + SUPPORT_USERS, "gmute complete!")
message.reply_text("Person has been gmuted.")
def fed_ban(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[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 # type: Optional[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("Nice try!")
return
if is_user_fed_owner(fed_id, user_id) == True:
message.reply_text("You can't ban the federation owner!")
return
if is_user_fed_admin(fed_id, user_id) == True:
message.reply_text("Why are you trying to ban a federation admin?")
return
if user_id == OWNER_ID:
message.reply_text("I'm not gonna ban my owner!")
return
if int(user_id) in SUDO_USERS:
message.reply_text("This person is sudo so I won't ban them!")
return
if int(user_id) in WHITELIST_USERS:
message.reply_text("This person is whitelisted so I can't ban them!")
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 = "Starting FedBan for {} in the Federation <b>{}</b>is for\n".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 fban reason!")
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! If this problem persists, reach out to us @CtrlSupport.")
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("I've updated the FedBan reason!")
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! If this problem persists, reach out to us @PhoenixSupport.")
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 left fed {} because bot has been kicked.".format(chat, info['fname']))
continue
else:
LOGGER.warning("Cannot fban in {} 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("{} has been fbanned.".format(mention_html(user_chat.id, user_chat.first_name)),
parse_mode=ParseMode.HTML)
def gban(bot: Bot, update: Update, args: List[str]):
message = update.effective_message # type: Optional[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.")
return
if int(user_id) in SUDO_USERS:
message.reply_text("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:
message.reply_text("OOOH someone's trying to gban a support user! *grabs popcorn*")
return
if user_id == bot.id:
message.reply_text("-_- So funny, lets gban myself why don't I? Nice try.")
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 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("⚡️ *Snaps the Banhammer* ⚡️")
banner = update.effective_user # type: Optional[User]
send_to_list(bot, SUDO_USERS + SUPPORT_USERS,
"<b>Global Ban</b>" \
"\n#GBAN" \
"\n<b>Status:</b> <code>Enforcing</code>" \
"\n<b>Sudo Admin:</b> {}" \
"\n<b>User:</b> {}" \
"\n<b>ID:</b> <code>{}</code>" \
"\n<b>Reason:</b> {}".format(mention_html(banner.id, banner.first_name),
mention_html(user_chat.id, user_chat.first_name),
user_chat.id, reason or "No reason given"),
html=True)
sql.gban_user(user_id, user_chat.username or user_chat.first_name, 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:
bot.kick_chat_member(chat_id, user_id)
except BadRequest as excp:
if excp.message in GBAN_ERRORS:
pass
else:
message.reply_text("Could not gban due to: {}".format(excp.message))
send_to_list(bot, SUDO_USERS + SUPPORT_USERS, "Could not gban due to: {}".format(excp.message))
sql.ungban_user(user_id)
return
except TelegramError:
pass
send_to_list(bot, SUDO_USERS + SUPPORT_USERS,
"{} has been successfully gbanned!".format(mention_html(user_chat.id, user_chat.first_name)),
html=True)
message.reply_text("Person has been gbanned.")
def gmute(bot: Bot, update: Update, args: List[str]):
message = update.effective_message # type: Optional[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.")
return
if int(user_id) in SUDO_USERS:
message.reply_text(
"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:
message.reply_text(
"OOOH someone's trying to gmute a support user! *grabs popcorn*")
return
if user_id == bot.id:
message.reply_text(
"-_- So funny, lets gmute myself why don't I? Nice try.")
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 sql.is_user_gmuted(user_id):
if not reason:
message.reply_text(
"This user is already gmuted; I'd change the reason, but you haven't given me one..."
)
return
old_reason = sql.update_gmute_reason(
user_id, user_chat.username or user_chat.first_name, reason)
user_id, new_reason = extract_user_and_text(message, args)
if old_reason:
muter = update.effective_user # type: Optional[User]
send_to_list(bot, SUDO_USERS + SUPPORT_USERS,
"<b>Emendation of Global Mute</b>" \
"\n#GMUTE" \
"\n<b>Status:</b> <code>Amended</code>" \
"\n<b>Sudo Admin:</b> {}" \
"\n<b>User:</b> {}" \
"\n<b>ID:</b> <code>{}</code>" \
"\n<b>Previous Reason:</b> {}" \
"\n<b>Amended Reason:</b> {}".format(mention_html(muter.id, muter.first_name),
mention_html(user_chat.id, user_chat.first_name or "Deleted Account"),
user_chat.id, old_reason, new_reason),
html=True)
message.reply_text(
"This user is already gmuted, 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:
muter = update.effective_user # type: Optional[User]
send_to_list(bot, SUDO_USERS + SUPPORT_USERS,
"<b>Emendation of Global Mute</b>" \
"\n#GMUTE" \
"\n<b>Status:</b> <code>New reason</code>" \
"\n<b>Sudo Admin:</b> {}" \
"\n<b>User:</b> {}" \
"\n<b>ID:</b> <code>{}</code>" \
"\n<b>New Reason:</b> {}".format(mention_html(muter.id, muter.first_name),
mention_html(user_chat.id, user_chat.first_name or "Deleted Account"),
user_chat.id, new_reason),
html=True)
message.reply_text(
"This user is already gmuted, but had no reason set; I've gone and updated it!"
)
return
starting = "Initiating global mute for {}...".format(
mention_html(user_chat.id, user_chat.first_name or "Deleted Account"))
keyboard = []
message.reply_text(starting,
reply_markup=keyboard,
parse_mode=ParseMode.HTML)
muter = update.effective_user # type: Optional[User]
send_to_list(bot, SUDO_USERS + SUPPORT_USERS,
"<b>Global Mute</b>" \
"\n#GMUTE" \
"\n<b>Status:</b> <code>Enforcing</code>" \
"\n<b>Sudo Admin:</b> {}" \
"\n<b>User:</b> {}" \
"\n<b>ID:</b> <code>{}</code>" \
"\n<b>Reason:</b> {}".format(mention_html(muter.id, muter.first_name),
mention_html(user_chat.id, user_chat.first_name or "Deleted Account"),
user_chat.id, reason or "No reason given"),
html=True)
sql.gmute_user(user_id, user_chat.username or user_chat.first_name, reason)
chats = get_all_chats()
for chat in chats:
chat_id = chat.chat_id
# Check if this group has disabled gmutes
if not sql.does_chat_gmute(chat_id):
continue
try:
bot.restrict_chat_member(chat_id, user_id, can_send_messages=False)
except BadRequest as excp:
if excp.message == "User is an administrator of the chat":
pass
elif excp.message == "Chat not found":
pass
elif excp.message == "Not enough rights to restrict/unrestrict chat member":
pass
elif excp.message == "User_not_participant":
pass
elif excp.message == "Peer_id_invalid": # Suspect this happens when a group is suspended by telegram.
pass
elif excp.message == "Group chat was deactivated":
pass
elif excp.message == "Need to be inviter of a user to kick it from a basic group":
pass
elif excp.message == "Chat_admin_required":
pass
elif excp.message == "Only the creator of a basic group can kick group administrators":
pass
elif excp.message == "Method is available only for supergroups":
pass
elif excp.message == "Can't demote chat creator":
pass
else:
message.reply_text("Could not gmute due to: {}".format(
excp.message))
send_to_list(bot, SUDO_USERS + SUPPORT_USERS,
"Could not gmute due to: {}".format(excp.message))
sql.ungmute_user(user_id)
return
except TelegramError:
pass
send_to_list(bot,
SUDO_USERS + SUPPORT_USERS,
"{} has been successfully gmuted!".format(
mention_html(user_chat.id, user_chat.first_name
or "Deleted Account")),
html=True)
message.reply_text("Person has been gmuted.")
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.")
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!")
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 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("You don't seem to be referring to a user.")
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 ""
log = "<b>{}:</b>" \
"\n#BANNED" \
"\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))
if reason:
log += "\n<b>Reason:</b> {}".format(reason)
try:
chat.kick_member(user_id)
banned_message = message.reply_text("Banned")
bot.delete_message(banned_message.chat_id, banned_message.message_id)
bot.delete_message(update.message.chat_id, update.message.message_id)
try:
bot.delete_message(update.message.reply_to_message.chat_id, update.message.reply_to_message.message_id)
except:
pass
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("Well damn, I can't ban that user.")
return ""
def gban(bot: Bot, update: Update, args: List[str]):
message = update.effective_message # type: Optional[Message]
user = update.effective_user # type: Optional[User]
user_id, reason = extract_user_and_text(message, args)
if not user_id or int(user_id)==777000:
message.reply_text("You don't seem to be referring to a user.")
return
if int(user_id) in SUDO_USERS:
message.reply_text("Now kiss each other!")
return
if int(user_id) in SUPPORT_USERS:
message.reply_text("OOOH someone's trying to gban a support user! *grabs popcorn*")
return
if user_id == bot.id:
message.reply_text("Lets gban myself why don't I? Good one.")
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 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)
user_id, new_reason = extract_user_and_text(message, args)
if old_reason:
banner = update.effective_user # type: Optional[User]
send_to_list(bot, SUDO_USERS + SUPPORT_USERS,
"<b>Emendation of Global Ban</b>" \
"\n#GBAN" \
"\n<b>Status:</b> <code>Amended</code>" \
"\n<b>Sudo Admin:</b> {}" \
"\n<b>User:</b> {}" \
"\n<b>ID:</b> <code>{}</code>" \
"\n<b>Previous Reason:</b> {}" \
"\n<b>Amended Reason:</b> {}".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, new_reason),
html=True)
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:
banner = update.effective_user # type: Optional[User]
send_to_list(bot, SUDO_USERS + SUPPORT_USERS,
"<b>Emendation of Global Ban</b>" \
"\n#GBAN" \
"\n<b>Status:</b> <code>New reason</code>" \
"\n<b>Sudo Admin:</b> {}" \
"\n<b>User:</b> {}" \
"\n<b>ID:</b> <code>{}</code>" \
"\n<b>New Reason:</b> {}".format(mention_html(banner.id, banner.first_name),
mention_html(user_chat.id, user_chat.first_name or "Deleted Account"),
user_chat.id, new_reason),
html=True)
message.reply_text("This user is already gbanned, but had no reason set; I've gone and updated it!")
return
starting = "Initiating global ban for {}...".format(mention_html(user_chat.id, user_chat.first_name or "Deleted Account"))
keyboard = []
# message.reply_text(starting, reply_markup=keyboard, parse_mode=ParseMode.HTML)
banner = update.effective_user # type: Optional[User]
send_to_list(bot, SUDO_USERS + SUPPORT_USERS,
"<b>Global Ban</b>" \
"\n#GBAN" \
"\n<b>Status:</b> <code>Enforcing</code>" \
"\n<b>Sudo Admin:</b> {}" \
"\n<b>User:</b> {}" \
"\n<b>ID:</b> <code>{}</code>" \
"\n<b>Reason:</b> {}".format(mention_html(banner.id, banner.first_name),
mention_html(user_chat.id, user_chat.first_name or "Deleted Account"),
user_chat.id, reason or "No reason given"),
html=True)
sql.gban_user(user_id, user_chat.username or user_chat.first_name, 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:
bot.kick_chat_member(chat_id, user_id)
except BadRequest as excp:
if excp.message in GBAN_ERRORS:
pass
else:
message.reply_text("Could not gban due to: {}".format(excp.message))
send_to_list(bot, SUDO_USERS + SUPPORT_USERS, "Could not gban due to: {}".format(excp.message))
sql.ungban_user(user_id)
return
except TelegramError:
pass
send_to_list(bot, SUDO_USERS + SUPPORT_USERS,
"{} has been successfully gbanned!".format(mention_html(user_chat.id, user_chat.first_name or "Deleted Account")),
html=True)
message.reply_text("Person has been gbanned.")
def rkick(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(
"ഇങ്ങള് ആരേലും റെഫർ ചെയ്താൽ അല്ലെ എനിക്ക് എന്തേലും ചെയ്യാൻ പറ്റു.")
return
elif not chat_id:
message.reply_text(
"ഇങ്ങള് ഏതേലും ചാറ്റ് റെഫർ ചെയ്താൽ അല്ലെ എനിക്ക് എന്തേലും ചെയ്യാൻ പറ്റു."
)
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("അതൊരു പ്രൈവറ്റ് ചാറ്റ് ആണ് ഭായ്😔!")
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 kick 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("എനിക്കും അഡ്മിൻസിനെ പുറത്താക്കണം എന്നുണ്ട്😞..")
return
if user_id == bot.id:
message.reply_text(
"ഞാൻ എന്ത് തെറ്റു ചെയ്തിട്ട എന്നെ പുറത്താക്കുന്നേ😒?")
return
try:
chat.unban_member(user_id)
message.reply_text("Kicked from chat!")
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
message.reply_text('Kicked!', quote=False)
elif excp.message in RKICK_ERRORS:
message.reply_text(excp.message)
else:
LOGGER.warning(update)
LOGGER.exception("ERROR kicking 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 kick that user.")
def rmute(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.")
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("അതൊരു പ്രൈവറ്റ് ചാറ്റ് ആണ് ഭായ്😔!")
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 mute 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("എനിക്ക് അഡ്മിൻസിന്റെ വായ അടപ്പിക്കാൻ പറ്റൂല😔...")
return
if user_id == bot.id:
message.reply_text("ഞാൻ എന്റെ തന്നെ വായ അടപ്പിക്കാനാ😂?")
return
try:
bot.restrict_chat_member(chat.id, user_id, can_send_messages=False)
message.reply_text("Muted from the chat!")
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
message.reply_text('Muted!', quote=False)
elif excp.message in RMUTE_ERRORS:
message.reply_text(excp.message)
else:
LOGGER.warning(update)
LOGGER.exception("ERROR mute 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.")
def runban(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.")
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("അതൊരു പ്രൈവറ്റ് ചാറ്റ് ആണ് ഭായ്😔!")
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):
message.reply_text(
"Why are you trying to remotely unban someone that's already in that chat?"
)
return
if user_id == bot.id:
message.reply_text("I'm not gonna UNBAN myself, I'm an admin there!")
return
try:
chat.unban_member(user_id)
message.reply_text("ആഹ് ഇനി ഈ ചെങ്ങായിക്കു ഇവിടെ കയറാം!")
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
message.reply_text('Unbanned!', quote=False)
elif excp.message in RUNBAN_ERRORS:
message.reply_text(excp.message)
else:
LOGGER.warning(update)
LOGGER.exception(
"ERROR unbanning user %s in chat %s (%s) due to %s", user_id,
chat.title, chat.id, excp.message)
message.reply_text(
"കൊള്ളാം പൊളി സാനം... പക്ഷെ ഇക്ക് ഓനെ unban ചെയ്യാൻ പറ്റൂല.")
def temp_mute(update: Update, context: CallbackContext) -> str:
bot, args = context.bot, context.args
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:
chat_permissions = ChatPermissions(can_send_messages=False)
bot.restrict_chat_member(chat.id,
user_id,
chat_permissions,
until_date=mutetime)
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:
log.warning(update)
log.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 # type: Optional[Message]
banner = update.effective_user
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.")
return
if int(user_id) == OWNER_ID:
message.reply_text(
"Well, RiP yourself. He's my owner, and I am never ever gonna stab him, you idiot!!"
)
return
if int(user_id) in SUDO_USERS and banner.id == OWNER_ID:
message.reply_text(
"Hey master, I can't gban a sudo user! Please remove him from sudo user list, and try again!"
)
return
if int(user_id) in SUDO_USERS and banner.id != OWNER_ID:
message.reply_text("F**k off! He is one of my sudo users.")
return
if int(user_id) in SUPPORT_USERS:
message.reply_text(
"OOOH someone's trying to gban a support user! *grabs popcorn*")
return
if user_id == bot.id:
message.reply_text(" -_-So funny! I won't be globally banning myself")
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 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("*Blows dust off of banhammer* 😉")
send_to_list(bot,
SUDO_USERS + SUPPORT_USERS,
"{} is gbanning user {} "
"because:\n{}".format(
mention_html(banner.id, banner.first_name),
mention_html(user_chat.id, user_chat.first_name), reason
or "No reason given"),
html=True)
sql.gban_user(user_id, user_chat.username or user_chat.first_name, reason)
ban_in_all_group(bot, user_id)
send_to_list(bot, SUDO_USERS + SUPPORT_USERS, "gban complete!")
message.reply_text("Person has been Globally banned.")
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("You don't seem to be referring to a user.")
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 user_id == OWNER_ID:
message.reply_text("Stop trying to ban my Lord Drona, you retard")
return ""
if is_user_ban_protected(chat, user_id, member):
message.reply_text("Sed, I really wish I could ban admins...")
return ""
if user_id == bot.id:
message.reply_text("I'm not gonna BAN myself, Go F yourself")
return ""
log = "<b>{}:</b>" \
"\n#BANNED" \
"\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))
reply = "User {} was 🔨banned by {} in {}.".format(mention_html(member.user.id, member.user.first_name), mention_html(user.id, user.first_name), chat.title)
if reason:
log += "\n<b>Reason:</b> {}".format(reason)
reply += "\n<b>Reason:</b> {}".format(reason)
try:
chat.kick_member(user_id)
keyboard = []
bot.send_sticker(chat.id, BAN_STICKER)
message.reply_text(reply, reply_markup=keyboard, parse_mode=ParseMode.HTML)
return log
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
message.reply_text('Banned that retard!', 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 ""
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 = "<b>{}:</b>" \
"\n#TEMP MUTED" \
"\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:
bot.restrict_chat_member(chat.id,
user_id,
until_date=mutetime,
can_send_messages=False)
bot.sendMessage(chat.id,
"Muted <b>{}</b> for {}!".format(
html.escape(member.user.first_name), 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("Muted for {}!".format(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 # type: Optional[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.")
return
if int(user_id) in SUDO_USERS:
message.reply_text("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:
message.reply_text("OOOH someone's trying to gban a support user! *grabs popcorn*")
return
if user_id == bot.id:
message.reply_text("Nice try but I ain't gonna gban myself!")
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 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:
if old_reason == reason:
message.reply_text("This user is already gbanned for the exact same reason!")
else:
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("Starting a global ban for {}".format(mention_html(user_chat.id, user_chat.first_name)),
parse_mode=ParseMode.HTML)
banner = update.effective_user # type: Optional[User]
send_to_list(bot, SUDO_USERS,
"{} is gbanning user {} "
"because:\n{}".format(mention_html(banner.id, banner.first_name),
mention_html(user_chat.id, user_chat.first_name), reason or "No reason given"),
html=True)
sql.gban_user(user_id, user_chat.username or user_chat.first_name, 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:
bot.kick_chat_member(chat_id, user_id)
except BadRequest as excp:
if excp.message in GBAN_ERRORS:
pass
else:
message.reply_text("Could not gban due to: {}".format(excp.message))
send_to_list(bot, SUDO_USERS, "Could not gban due to: {}".format(excp.message))
sql.ungban_user(user_id)
return
except TelegramError:
pass
send_to_list(bot, SUDO_USERS, "Gban complete!")
message.reply_text("Done! {} has been globally banned.".format(mention_html(user_chat.id, user_chat.first_name)),
parse_mode=ParseMode.HTML)
try:
bot.send_message(user_id, "You've been globally banned from all groups where I am admin. If this is a mistake, you can appeal your ban @GraveyardDwellers or PM @TheRealPhoenix",parse_mode=ParseMode.HTML)
except:
pass #Bot either blocked or never started by 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.")
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.")
return
if int(user_id) in DEV_USERS:
message.reply_text("That user is part of the Union\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 Nation! 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 Sakura Nation! *grabs popcorn*")
return
if int(user_id) in SARDEGNA_USERS:
message.reply_text("That's a Sardegna! They cannot be banned!")
return
if int(user_id) in WHITELIST_USERS:
message.reply_text("That's a Neptunia! 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 = "%H:%M - %d-%m-%Y"
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> {chat_origin}\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> {user_chat.id}\n"
f"<b>Event Stamp:</b> {current_time}")
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> {reason}"
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> {gbanned_chats}", parse_mode=ParseMode.HTML)
else:
send_to_list(bot, SUDO_USERS + SUPPORT_USERS, f"Gban complete! (User banned in {gbanned_chats} chats)")
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 {gbanned_chats} chats, Took {gban_time} min")
else:
message.reply_text(f"Done! This gban affected {gbanned_chats} chats, Took {gban_time} sec")
try:
bot.send_message(user_id,
"You have been globally banned from all groups where I have administrative permissions."
"If you think that this was a mistake, you may appeal your ban here: @Aman_Ahmed",
parse_mode=ParseMode.HTML)
except:
pass # bot probably blocked by user
def temp_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("You don't seem to be referring to a user.")
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("അഡ്മിൻ ആണ്... ബാൻ ചെയ്യാൻ പറ്റില്ല!")
return ""
if user_id == bot.id:
message.reply_text("ഞാൻ എന്നെത്തന്നെ ബാൻ ചെയ്യണം എന്നാണോ പറയുന്നത്?")
return ""
if not reason:
message.reply_text("ഇയാളെ എത്ര സമയം ബാൻ ചെയ്യണം എന്നു പറഞ്ഞില്ലല്ലോ?")
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#TEMP BANNED" \
"\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:
chat.kick_member(user_id, until_date=bantime)
bot.send_sticker(chat.id, BAN_STICKER) # banhammer marie sticker
message.reply_text(
"ബണ്ണ് കൊടുത്തുവിട്ടു! User will be BANNED for {}.".format(
time_val))
return log
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
message.reply_text(
"ബണ്ണ് കൊടുത്തുവിട്ടു! User will be BANNED for {}.".format(
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 ""
def gban(update: Update, context: CallbackContext):
bot, args = context.bot, context.args
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 Union\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 nation! 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 Sakura Nation! *grabs popcorn*")
return
if int(user_id) in SARDEGNA_USERS:
message.reply_text("That's a Sardegna! They cannot be banned!")
return
if int(user_id) in WHITELIST_USERS:
message.reply_text("That's a Neptunia! They cannot be banned!")
return
if int(user_id) in (777000, 1087968824):
message.reply_text("Huh, why would I gban Telegram bots?")
return
if user_id == bot.id:
message.reply_text("You uhh...want me to kill 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="https://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_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 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)",
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,
"#GBAN"
"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> @YorkTownEagleUnion",
parse_mode=ParseMode.HTML,
)
except:
pass # bot probably blocked by user
def fed_ban(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
fed_id = sql.get_fed_id(chat.id)
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
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, "You don't seem to be referring to a user."))
return
if user_id == bot.id:
message.reply_text(
tld(
chat.id,
"You can't fban me, better hit your head against the wall, it's more fun."
))
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(tld(chat.id, "That's not a user!"))
return
message.reply_text(tld(chat.id, "Starting federation ban!"))
if reason == "":
reason = "no reason"
sql.fban_user(fed_id, user_id, reason)
h = sql.all_fed_chats(fed_id)
for O in h:
try:
bot.kick_chat_member(O, user_id)
#text = tld(chat.id, "I should gban {}, but it's only test fban, right? So i let him live.").format(O)
text = "Fbanning {}".format(user_id)
#message.reply_text(text)
except BadRequest as excp:
if excp.message in FBAN_ERRORS:
pass
else:
message.reply_text(
tld(chat.id,
"Could not fban due to: {}").format(excp.message))
return
except TelegramError:
pass
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_nomedia(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]
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 = chat
user_id, reason = extract_user_and_text(message, args)
if not user_id:
message.reply_text(
tld(chat.id, "You don't seem to be referring to a 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, "I can't seem to find this user"))
return ""
else:
raise
if is_user_admin(chat, user_id, member):
message.reply_text(
tld(chat.id, "I really wish I could restrict admins..."))
return ""
if user_id == bot.id:
message.reply_text(
tld(chat.id, "I'm not gonna RESTRICT myself, are you crazy?"))
return ""
if not reason:
message.reply_text(
tld(chat.id,
"You haven't specified a time to restrict 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#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 += "\n<b>• Reason:</b> {}".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,
"Restricted from sending media for {} in {}!").format(
time_val, chatD.title))
return log
else:
message.reply_text(
tld(chat.id, "This user is already restricted in {}.").format(
chatD.title))
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
message.reply_text(tld(chat.id, "Restricted for {} in {}!").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, "Well damn, I can't restrict that user."))
return ""
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, group_id = extract_user_and_text(message, args)
if not user_id:
message.reply_text("You don't seem to be referring to a user.")
return
elif not group_id:
message.reply_text("You don't seem to be referring to a chat.")
return
try:
chat = bot.get_chat(group_id)
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) and 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!")
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
message.reply_text('Banned!', quote=False)
elif excp.message == "User_not_participant":
message.reply_text("This user is not a participant of the chat!")
elif excp.message == "Group chat was deactivated":
message.reply_text("This group chat was deactivated!")
elif excp.message == "Need to be inviter of a user to kick it from a basic group":
message.reply_text(excp.message)
elif excp.message == "Only the creator of a basic group can kick group administrators":
message.reply_text(excp.message)
elif excp.message == "Peer_id_invalid":
message.reply_text("Could not ban user. Perhaps the group has been suspended by Telegram.")
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 temp_mute(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("You don't seem to be referring to a user.")
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_admin(chat, user_id, member):
message.reply_text("I really wish I could mute admins...")
return ""
if user_id == bot.id:
message.reply_text("I'm not gonna MUTE myself, are you crazy?")
return ""
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 = "<b>{}:</b>" \
"\n#TEMP MUTED" \
"\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:
bot.restrict_chat_member(chat.id,
user_id,
until_date=mutetime,
can_send_messages=False)
message.reply_text("Muted for {}!".format(time_val))
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("Muted for {}!".format(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 temp_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("നിങ്ങൾ ഒരു വ്യക്തിയെ സൂചിപ്പിക്കുന്നതായി തോന്നുന്നില്ല!.")
return ""
try:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "User not found":
message.reply_text("എനിക്ക് ഈ യൂസേറിനെ കണ്ടെത്താൻ കഴിയുന്നില്ല")
return ""
else:
raise
if is_user_ban_protected(chat, user_id, member):
message.reply_text("എനിക്ക് ആഗ്രഹം ഒക്കെ ഉണ്ട് but നടക്കൂലല്ലോ😛...")
return ""
if user_id == bot.id:
message.reply_text("എന്നെ ബാൻ ചെയ്യാനോ..😢? ഞാൻ...എന്നെ ബാൻ ചെയ്യൂല എനിക്ക് ബണ്ണ് വേണ്ടാ..😔")
return ""
if not reason:
message.reply_text("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> {}" \
"\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 += "\n<b>• Reason:</b> {}".format(reason)
try:
chat.kick_member(user_id, until_date=bantime)
keyboard = []
bot.send_sticker(update.effective_chat.id, BAN_STICKER) # banhammer marie sticker
reply = "{} has been temporarily banned for {}!".format(mention_html(member.user.id, member.user.first_name),time_val)
message.reply_text(reply, reply_markup=keyboard, parse_mode=ParseMode.HTML)
return log
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
message.reply_text("Banned! User will be banned for {}.".format(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 ""
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(
"നിങ്ങൾ ഒരുഭോക്താവിനെ സൂചിപ്പിക്കുന്നതായി തോന്നുന്നില്ല...")
return ""
try:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "User not found":
message.reply_text(
"ഇങ്ങനെ ഒരാളെ എനിക്ക് കണ്ടെത്താൻ സാധിച്ചില്ല...")
return ""
else:
raise
if is_user_ban_protected(chat, user_id, member):
message.reply_text(
"എനിക്ക് Adminsനെ ബാൻ ചെയ്യാൻ സാധിക്കില്ല സുഹൃത്തേ...")
return ""
if user_id == bot.id:
message.reply_text(
"ഞാൻ എന്നെത്തന്നെ ബാൻ ചെയ്യാനോ നടക്കുന്ന കാര്യം വല്ലതും പറ... ")
return ""
log = "<b>{}:</b>" \
"\n#BANNED" \
"\n<b>• Admin:</b> {}" \
"\n<b>• User:</b> {}" \
"\n<b>• ID:</b> <code>{}</code>".format(html.escape(chat.title), mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name), user_id)
reply = "{} നെ ബാൻ ചെയ്തിട്ടുണ്ട്..".format(
mention_html(member.user.id, member.user.first_name))
if reason:
log += "\n<b>• Reason:</b> {}".format(reason)
reply += "\n<b>Reason:</b> <i>{}</i>".format(reason)
try:
chat.kick_member(user_id)
keyboard = []
bot.send_sticker(update.effective_chat.id,
BAN_STICKER) # banhammer marie sticker
message.reply_text(reply,
reply_markup=keyboard,
parse_mode=ParseMode.HTML)
return log
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
message.reply_text('ബാൻ ചെയ്തിട്ടുണ്ട്...!', 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("എനിക്കയാളെ ബാൻ ചെയ്യാൻ സാധിക്കില്ല..")
return ""
def runban(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):
message.reply_text(
"Why are you trying to remotely unban someone that's already in that chat?"
)
return
if user_id == bot.id:
message.reply_text("I'm not gonna UNBAN myself, I'm an admin there!")
return
try:
chat.unban_member(user_id)
message.reply_text("Yep, this user can join that chat!")
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
message.reply_text('Unbanned!', quote=False)
elif excp.message in RUNBAN_ERRORS:
message.reply_text(excp.message)
else:
LOGGER.warning(update)
LOGGER.exception(
"ERROR unbanning 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 unban that user.")
def ban(update: Update, context: CallbackContext):
if not check_perms(update, 1):
return
bot, args = context.bot, context.args
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
message = update.effective_message # type: Optional[Message]
banType = 0
userIds = extract_multiple_users(message, args)
allTrue = True
for id in userIds:
if id is None or not isinstance(id, int) or id == "":
allTrue = False
if len(userIds) > 1 and allTrue:
banType = 1
if banType == 1:
if len(userIds) == 0:
message.reply_text("There was a problem parsing the user IDs")
return ""
log = "#BAN MUL\n Admin: " + user.first_name + "\n"
for id in userIds:
try:
integerID = int(id)
member = chat.get_member(integerID)
if integerID == bot.id:
message.reply_text("I wont ban myself... " +
str(integerID) + " is my ID.")
continue
if integerID in (777000, 1087968824):
message.reply_text(
str(integerID) +
" is an account reserved for telegram, I cannot ban it"
)
continue
if is_user_ban_protected(chat, integerID, member):
message.reply_text("Can't ban " + str(integerID) +
", user is ban protected.")
continue
try:
chat.ban_member(integerID)
# bot.send_sticker(update.effective_chat.id, BAN_STICKER) # ban sticker
reply = "{} has been banned!".format(
mention_html(member.user.id, member.user.first_name))
message.reply_text(reply, parse_mode=ParseMode.HTML)
log += "ID: " + str(member.user.id) + "\n"
except BadRequest as excp:
LOGGER.warning(update)
LOGGER.exception(
"ERROR banning user %s in chat %s (%s) due to %s",
integerID,
chat.title,
chat.id,
excp.message,
)
message.reply_text("Well damn, I can't ban " +
str(integerID))
except ValueError:
message.reply_text("Error parsing the ID: " + id +
" is not a valid user ID")
except BadRequest as excp:
if excp.message == "User not found":
message.reply_text("User " + str(integerID) +
"has not been found")
continue
raise
return log
user_id, reason = extract_user_and_text(message, args)
if not user_id or int(user_id) == 777000 or int(user_id) == 1087968824:
message.reply_text("You don't seem to be referring to a user.")
return ""
try:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "User not found":
message.reply_text("404 - user not found")
return ""
raise
if user_id == bot.id:
message.reply_text("hahahahahahaha nice try.. nope")
return ""
if is_user_ban_protected(chat, user_id, member):
message.reply_text("Can't do that, user is admin..")
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:
chat.ban_member(user_id)
bot.send_sticker(update.effective_chat.id, BAN_STICKER) # ban sticker
reply = "{} has been banned!".format(
mention_html(member.user.id, member.user.first_name))
reply += "\nReason: <code>{}</code>".format(reason) if reason else ""
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("Banned!", quote=False)
return log
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 ""