def animestuffs(update, context):
query = update.callback_query
user = update.effective_user
splitter = query.data.split('=')
query_match = splitter[0]
callback_anime_data = splitter[1]
if query_match == "xanime_watchlist":
watchlist = list(REDIS.sunion(f'anime_watch_list{user.id}'))
if not callback_anime_data in watchlist:
REDIS.sadd(f'anime_watch_list{user.id}', callback_anime_data)
context.bot.answer_callback_query(
query.id,
text=
f"{callback_anime_data} is successfully added to your watch list.",
show_alert=True)
else:
context.bot.answer_callback_query(
query.id,
text=
f"{callback_anime_data} is already exists in your watch list!",
show_alert=True)
elif query_match == "xanime_fvrtchar":
fvrt_char = list(REDIS.sunion(f'anime_fvrtchar{user.id}'))
if not callback_anime_data in fvrt_char:
REDIS.sadd(f'anime_fvrtchar{user.id}', callback_anime_data)
context.bot.answer_callback_query(
query.id,
text=
f"{callback_anime_data} is successfully added to your favorite character.",
show_alert=True)
else:
context.bot.answer_callback_query(
query.id,
text=
f"{callback_anime_data} is already exists in your favorite characters list!",
show_alert=True)
elif query_match == "xanime_manga":
fvrt_char = list(REDIS.sunion(f'anime_mangaread{user.id}'))
if not callback_anime_data in fvrt_char:
REDIS.sadd(f'anime_mangaread{user.id}', callback_anime_data)
context.bot.answer_callback_query(
query.id,
text=
f"{callback_anime_data} is successfully added to your read list.",
show_alert=True)
else:
context.bot.answer_callback_query(
query.id,
text=
f"{callback_anime_data} is already exists in your read list!",
show_alert=True)
def removetag(update, context):
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
args = context.args
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
raise
if user_id == context.bot.id:
message.reply_text("how I supposed to tag or untag myself")
return
chat_id = str(chat.id)[1:]
tagall_list = list(REDIS.sunion(f'tagall2_{chat_id}'))
match_user = mention_html(member.user.id, member.user.first_name)
if match_user not in tagall_list:
message.reply_text("{} is doesn't exist in {}'s list!".format(
mention_html(member.user.id, member.user.first_name), chat.title),
parse_mode=ParseMode.HTML)
return
member = chat.get_member(int(user_id))
chat_id = str(chat.id)[1:]
REDIS.srem(f'tagall2_{chat_id}',
mention_html(member.user.id, member.user.first_name))
message.reply_text("{} is successfully removed from {}'s list.".format(
mention_html(member.user.id, member.user.first_name), chat.title),
parse_mode=ParseMode.HTML)
def restr_members(bot,
chat_id,
members,
messages=False,
media=False,
other=False,
previews=False):
for mem in members:
if mem.user in OFFICERS:
pass
user = update.effective_user
approve_list = list(REDIS.sunion(f'approve_list_{chat_id}'))
target_user = mention_html(user.id, user.first_name)
if target_user in approve_list:
pass
try:
bot.restrict_chat_member(
chat_id,
mem.user,
can_send_messages=messages,
can_send_media_messages=media,
can_send_other_messages=other,
can_add_web_page_previews=previews,
)
except TelegramError:
pass
def unapprove(update, context):
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
args = context.args
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 == context.bot.id:
message.reply_text("how I supposed to approve or unapprove myself")
return
chat_id = str(chat.id)[1:]
approve_list = list(REDIS.sunion(f'approve_list_{chat_id}'))
target_user = mention_html(member.user.id, member.user.first_name)
if target_user not in approve_list:
message.reply_text("{} isn't approved yet.".format(
mention_html(member.user.id, member.user.first_name)),
parse_mode=ParseMode.HTML)
return
member = chat.get_member(int(user_id))
chat_id = str(chat.id)[1:]
REDIS.srem(f'approve_list_{chat_id}',
mention_html(member.user.id, member.user.first_name))
message.reply_text("{} is no longer approved in {}.".format(
mention_html(member.user.id, member.user.first_name), chat.title),
parse_mode=ParseMode.HTML)
def tagall(update, context):
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
args = context.args
query = " ".join(args)
if not query:
message.reply_text("Please give a reason why are you want to tag all!")
return
chat_id = str(chat.id)[1:]
tagall = list(REDIS.sunion(f'tagall2_{chat_id}'))
tagall.sort()
tagall = ", ".join(tagall)
if tagall:
tagall_reason = query
if message.reply_to_message:
message.reply_to_message.reply_text(
"{}"
"\n\n<b>Tagged Reason:</b>"
"\n{}".format(tagall, tagall_reason),
parse_mode=ParseMode.HTML
)
else:
message.reply_text(
"{}"
"\n\n<b>Tagged Reason:</b>"
"\n{}".format(tagall, tagall_reason),
parse_mode=ParseMode.HTML
)
else:
message.reply_text(
"Tagall list is empty!"
)
def reply_filter(update: Update, context: CallbackContext) -> str:
chat: Optional[Chat] = update.effective_chat
message: Optional[Message] = update.effective_message
user: Optional[User] = update.effective_user
chat_id = str(chat.id)[1:]
approve_list = list(REDIS.sunion(f'approve_list_{chat_id}'))
target_user = mention_html(user.id, user.first_name)
if target_user in approve_list:
return
if not user: #Ignore channel
return
if user.id == 777000:
return
chat_warn_filters = sql.get_chat_warn_triggers(chat.id)
to_match = extract_text(message)
if not to_match:
return ""
for keyword in chat_warn_filters:
pattern = r"( |^|[^\w])" + re.escape(keyword) + r"( |$|[^\w])"
if re.search(pattern, to_match, flags=re.IGNORECASE):
user: Optional[User] = update.effective_user
warn_filter = sql.get_warn_filter(chat.id, keyword)
return warn(user, chat, warn_filter.reply, message)
return ""
def unapproveall(update, context):
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
chat_id = str(chat.id)[1:]
approve_list = list(REDIS.sunion(f'approve_list_{chat_id}'))
for target_user in approve_list:
REDIS.srem(f'approve_list_{chat_id}', target_user)
message.reply_text("Successully unapproved all users from {}.".format(
chat.title))
def untagall(update, context):
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
chat_id = str(chat.id)[1:]
tagall_list = list(REDIS.sunion(f'tagall2_{chat_id}'))
for tag_user in tagall_list:
REDIS.srem(f'tagall2_{chat_id}', tag_user)
message.reply_text(
"Successully removed all users from {}'s tag list.".format(chat.title))
def watchlist(update, context):
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
watchlist = list(REDIS.sunion(f'anime_watch_list{user.id}'))
watchlist.sort()
watchlist = "\n• ".join(watchlist)
if watchlist:
message.reply_text("{}<b>'s Watchlist:</b>"
"\n• {}".format(
mention_html(user.id, user.first_name),
watchlist),
parse_mode=ParseMode.HTML)
else:
message.reply_text("You havn't added anything in your watchlist!")
def readmanga(update, context):
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
manga_list = list(REDIS.sunion(f'anime_mangaread{user.id}'))
manga_list.sort()
manga_list = "\n• ".join(manga_list)
if manga_list:
message.reply_text("{}<b>'s Manga Lists:</b>"
"\n• {}".format(
mention_html(user.id, user.first_name),
manga_list),
parse_mode=ParseMode.HTML)
else:
message.reply_text("You havn't added anything in your manga list!")
def fvrtchar(update, context):
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
fvrt_char = list(REDIS.sunion(f'anime_fvrtchar{user.id}'))
fvrt_char.sort()
fvrt_char = "\n• ".join(fvrt_char)
if fvrt_char:
message.reply_text("{}<b>'s Favorite Characters List:</b>"
"\n• {}".format(
mention_html(user.id, user.first_name),
fvrt_char),
parse_mode=ParseMode.HTML)
else:
message.reply_text(
"You havn't added anything in your favorite characters list!")
def untagme(update, context):
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
chat_id = str(chat.id)[1:]
tagall_list = list(REDIS.sunion(f'tagall2_{chat_id}'))
match_user = mention_html(user.id, user.first_name)
if match_user not in tagall_list:
message.reply_text(
"You're already doesn't exist in {}'s tag list!".format(
chat.title))
return
REDIS.srem(f'tagall2_{chat_id}', mention_html(user.id, user.first_name))
message.reply_text("{} has been removed from {}'s tag list.".format(
mention_html(user.id, user.first_name), chat.title),
parse_mode=ParseMode.HTML)
def tagme(update, context):
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
chat_id = str(chat.id)[1:]
tagall_list = list(REDIS.sunion(f'tagall2_{chat_id}'))
match_user = mention_html(user.id, user.first_name)
if match_user in tagall_list:
message.reply_text("You're Already Exist In {}'s Tag List!".format(
chat.title))
return
REDIS.sadd(f'tagall2_{chat_id}', mention_html(user.id, user.first_name))
message.reply_text(
"{} has been successfully added in {}'s tag list.".format(
mention_html(user.id, user.first_name), chat.title),
parse_mode=ParseMode.HTML)
def approved(update, context):
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
chat_id = str(chat.id)[1:]
approved_list = list(REDIS.sunion(f'approve_list_{chat_id}'))
approved_list.sort()
approved_list = ", ".join(approved_list)
if approved_list:
message.reply_text("The Following Users Are Approved: \n"
"{}".format(approved_list),
parse_mode=ParseMode.HTML)
else:
message.reply_text("No users are are approved in {}.".format(
chat.title),
parse_mode=ParseMode.HTML)
def addtag(update, context):
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
args = context.args
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 == context.bot.id:
message.reply_text("how I supposed to tag myself")
return
chat_id = str(chat.id)[1:]
tagall_list = list(REDIS.sunion(f'tagall2_{chat_id}'))
match_user = mention_html(member.user.id, member.user.first_name)
if match_user in tagall_list:
message.reply_text(
"{} is already exist in {}'s tag list.".format(mention_html(member.user.id, member.user.first_name),
chat.title),
parse_mode=ParseMode.HTML
)
return
message.reply_text(
"{} accept this, if you want to add yourself into {}'s tag list! or just simply decline this.".format(mention_html(member.user.id, member.user.first_name),
chat.title),
reply_markup=InlineKeyboardMarkup(
[
[
InlineKeyboardButton(text="Accept", callback_data=f"tagall_accept={user_id}"),
InlineKeyboardButton(text="Decline", callback_data=f"tagall_dicline={user_id}")
]
]
),
parse_mode=ParseMode.HTML
)
def approval(update: Update, context: CallbackContext) -> str:
bot = context.bot
args = context.args
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
args = context.args
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 == context.bot.id:
message.reply_text("How I supposed to approve myself")
return
chat_id = str(chat.id)[1:]
approve_list = list(REDIS.sunion(f'approve_list_{chat_id}'))
target_user = mention_html(member.user.id, member.user.first_name)
if target_user in approve_list:
message.reply_text(
"{} is an approved user. Auto Warns, antiflood, and blocklists won't apply to them.".format(mention_html(member.user.id, member.user.first_name)),
parse_mode=ParseMode.HTML
)
return
if target_user not in approve_list:
message.reply_text(
"{} is not an approved user. They are affected by normal commands.".format(mention_html(member.user.id, member.user.first_name)),
parse_mode=ParseMode.HTML
)
return
def removemangalist(update, context):
user = update.effective_user
message = update.effective_message
removewlist = message.text.split(' ', 1)
args = context.args
query = " ".join(args)
if not query:
message.reply_text(
"Please enter a manga name to remove from your manga list.")
return
fvrt_char = list(REDIS.sunion(f'anime_mangaread{user.id}'))
removewlist = removewlist[1]
if removewlist not in fvrt_char:
message.reply_text(
f"<code>{removewlist}</code> doesn't exist in your manga list.",
parse_mode=ParseMode.HTML)
else:
message.reply_text(
f"<code>{removewlist}</code> has been removed from your favorite characters list.",
parse_mode=ParseMode.HTML)
REDIS.srem(f'anime_mangaread{user.id}', removewlist)
def removewatchlist(update, context):
user = update.effective_user
message = update.effective_message
removewlist = message.text.split(' ', 1)
args = context.args
query = " ".join(args)
if not query:
message.reply_text(
"Please enter a anime name to remove from your watchlist.")
return
watchlist = list(REDIS.sunion(f'anime_watch_list{user.id}'))
removewlist = removewlist[1]
if removewlist not in watchlist:
message.reply_text(
f"<code>{removewlist}</code> doesn't exist in your watch list.",
parse_mode=ParseMode.HTML)
else:
message.reply_text(
f"<code>{removewlist}</code> has been removed from your watch list.",
parse_mode=ParseMode.HTML)
REDIS.srem(f'anime_watch_list{user.id}', removewlist)
def del_lockables(update, context):
chat = update.effective_chat # type: Optional[Chat]
message = update.effective_message # type: Optional[Message]
user = update.effective_user
chat_id = str(chat.id)[1:]
approve_list = list(REDIS.sunion(f'approve_list_{chat_id}'))
target_user = mention_html(user.id, user.first_name)
if target_user in approve_list:
return
for lockable, filter in LOCK_TYPES.items():
if lockable == "rtl":
if sql.is_locked(chat.id, lockable) and can_delete(
chat, context.bot.id):
if message.caption:
check = ad.detect_alphabet(u"{}".format(message.caption))
if "ARABIC" in check:
try:
message.delete()
except BadRequest as excp:
if excp.message == "Message to delete not found":
pass
else:
LOGGER.exception("ERROR in lockables")
break
if message.text:
check = ad.detect_alphabet(u"{}".format(message.text))
if "ARABIC" in check:
try:
message.delete()
except BadRequest as excp:
if excp.message == "Message to delete not found":
pass
else:
LOGGER.exception("ERROR in lockables")
break
continue
if lockable == "button":
if sql.is_locked(chat.id, lockable) and can_delete(
chat, context.bot.id):
if message.reply_markup and message.reply_markup.inline_keyboard:
try:
message.delete()
except BadRequest as excp:
if excp.message == "Message to delete not found":
pass
else:
LOGGER.exception("ERROR in lockables")
break
continue
if lockable == "inline":
if sql.is_locked(chat.id, lockable) and can_delete(
chat, context.bot.id):
if message and message.via_bot:
try:
message.delete()
except BadRequest as excp:
if excp.message == "Message to delete not found":
pass
else:
LOGGER.exception("ERROR in lockables")
break
continue
if (filter(update) and sql.is_locked(chat.id, lockable)
and can_delete(chat, context.bot.id)):
if lockable == "bots":
new_members = update.effective_message.new_chat_members
for new_mem in new_members:
if new_mem.is_bot:
if not is_bot_admin(chat, context.bot.id):
send_message(
update.effective_message,
"I see a bot and I've been told to stop them from joining..."
"but I'm not admin!",
)
return
chat.kick_member(new_mem.id)
send_message(
update.effective_message,
"Only admins are allowed to add bots in this chat! Get outta here.",
)
break
else:
try:
message.delete()
except BadRequest as excp:
if excp.message == "Message to delete not found":
pass
else:
LOGGER.exception("ERROR in lockables")
break
def check_flood(update, context) -> str:
user = update.effective_user # type: Optional[User]
chat = update.effective_chat # type: Optional[Chat]
msg = update.effective_message # type: Optional[Message]
chat_id = str(chat.id)[1:]
approve_list = list(REDIS.sunion(f'approve_list_{chat_id}'))
target_user = mention_html(user.id, user.first_name)
if target_user in approve_list:
return
if not user: # ignore channels
return ""
# ignore admins
if is_user_admin(chat, user.id):
sql.update_flood(chat.id, None)
return ""
should_ban = sql.update_flood(chat.id, user.id)
if not should_ban:
return ""
try:
getmode, getvalue = sql.get_flood_setting(chat.id)
if getmode == 1:
chat.kick_member(user.id)
execstrings = "Banned"
tag = "BANNED"
elif getmode == 2:
chat.kick_member(user.id)
chat.unban_member(user.id)
execstrings = "Kicked"
tag = "KICKED"
elif getmode == 3:
context.bot.restrict_chat_member(
chat.id,
user.id,
permissions=ChatPermissions(can_send_messages=False))
execstrings = "Muted"
tag = "MUTED"
elif getmode == 4:
bantime = extract_time(msg, getvalue)
chat.kick_member(user.id, until_date=bantime)
execstrings = "Banned for {}".format(getvalue)
tag = "TBAN"
elif getmode == 5:
mutetime = extract_time(msg, getvalue)
context.bot.restrict_chat_member(
chat.id,
user.id,
until_date=mutetime,
permissions=ChatPermissions(can_send_messages=False),
)
execstrings = "Muted for {}".format(getvalue)
tag = "TMUTE"
send_message(
update.effective_message,
"Great, I like to leave flooding to staff members but you, "
"you were just a disappointment. {}!".format(execstrings),
)
return ("<b>{}:</b>"
"\n#{}"
"\n<b>User:</b> {}"
"\nFlooded the group.".format(
html.escape(chat.title), tag,
mention_html(user.id, user.first_name)))
except BadRequest:
msg.reply_text(
"I can't restrict people here, give me permissions first! Until then, I'll disable anti-flood."
)
sql.set_flood(chat.id, 0)
return (
"<b>{}:</b>"
"\n#INFO"
"\nDon't have enough permission to restrict users so automatically disabled anti-flood"
.format(chat.title))
def del_blacklist(update, context):
chat = update.effective_chat
message = update.effective_message
user = update.effective_user
bot = context.bot
to_match = extract_text(message)
if not to_match:
return
chat_id = str(chat.id)[1:]
approve_list = list(REDIS.sunion(f'approve_list_{chat_id}'))
target_user = mention_html(user.id, user.first_name)
if target_user in approve_list:
return
getmode, value = sql.get_blacklist_setting(chat.id)
chat_filters = sql.get_chat_blacklist(chat.id)
for trigger in chat_filters:
pattern = r"( |^|[^\w])" + re.escape(trigger) + r"( |$|[^\w])"
if re.search(pattern, to_match, flags=re.IGNORECASE):
try:
if getmode == 0:
return
elif getmode == 1:
try:
message.delete()
except BadRequest:
pass
elif getmode == 2:
try:
message.delete()
except BadRequest:
pass
warn(
update.effective_user,
chat,
("Using blacklisted trigger: {}".format(trigger)),
message,
update.effective_user,
)
return
elif getmode == 3:
message.delete()
bot.restrict_chat_member(
chat.id,
update.effective_user.id,
permissions=ChatPermissions(can_send_messages=False),
)
bot.sendMessage(
chat.id,
f"Muted {user.first_name} for using Blacklisted word: {trigger}!",
)
return
elif getmode == 4:
message.delete()
res = chat.unban_member(update.effective_user.id)
if res:
bot.sendMessage(
chat.id,
f"Kicked {user.first_name} for using Blacklisted word: {trigger}!",
)
return
elif getmode == 5:
message.delete()
chat.kick_member(user.id)
bot.sendMessage(
chat.id,
f"Banned {user.first_name} for using Blacklisted word: {trigger}",
)
return
elif getmode == 6:
message.delete()
bantime = extract_time(message, value)
chat.kick_member(user.id, until_date=bantime)
bot.sendMessage(
chat.id,
f"Banned {user.first_name} until '{value}' for using Blacklisted word: {trigger}!",
)
return
elif getmode == 7:
message.delete()
mutetime = extract_time(message, value)
bot.restrict_chat_member(
chat.id,
user.id,
until_date=mutetime,
permissions=ChatPermissions(can_send_messages=False),
)
bot.sendMessage(
chat.id,
f"Muted {user.first_name} until '{value}' for using Blacklisted word: {trigger}!",
)
return
except BadRequest as excp:
if excp.message == "Message to delete not found":
pass
else:
LOGGER.exception("Error while deleting blacklist message.")
break
def del_blackliststicker(update, context):
bot = context.bot
chat = update.effective_chat # type: Optional[Chat]
message = update.effective_message # type: Optional[Message]
user = update.effective_user
to_match = message.sticker
if not to_match:
return
chat_id = str(chat.id)[1:]
approve_list = list(REDIS.sunion(f'approve_list_{chat_id}'))
target_user = mention_html(user.id, user.first_name)
if target_user in approve_list:
return
bot = context.bot
getmode, value = sql.get_blacklist_setting(chat.id)
chat_filters = sql.get_chat_stickers(chat.id)
for trigger in chat_filters:
if to_match.set_name.lower() == trigger.lower():
try:
if getmode == 0:
return
elif getmode == 1:
message.delete()
elif getmode == 2:
message.delete()
warn(update.effective_user,
chat,
"Using sticker '{}' which in blacklist stickers".
format(trigger),
message,
update.effective_user,
conn=False)
return
elif getmode == 3:
message.delete()
bot.restrict_chat_member(
chat.id,
update.effective_user.id,
permissions=ChatPermissions(can_send_messages=False))
bot.sendMessage(
chat.id,
"{} muted because using '{}' which in blacklist stickers"
.format(mention_markdown(user.id, user.first_name),
trigger),
parse_mode="markdown")
return
elif getmode == 4:
message.delete()
res = chat.unban_member(update.effective_user.id)
if res:
bot.sendMessage(
chat.id,
"{} kicked because using '{}' which in blacklist stickers"
.format(mention_markdown(user.id, user.first_name),
trigger),
parse_mode="markdown")
return
elif getmode == 5:
message.delete()
chat.kick_member(user.id)
bot.sendMessage(
chat.id,
"{} banned because using '{}' which in blacklist stickers"
.format(mention_markdown(user.id, user.first_name),
trigger),
parse_mode="markdown")
return
elif getmode == 6:
message.delete()
bantime = extract_time(message, value)
chat.kick_member(user.id, until_date=bantime)
bot.sendMessage(
chat.id,
"{} banned for {} because using '{}' which in blacklist stickers"
.format(mention_markdown(user.id, user.first_name),
value, trigger),
parse_mode="markdown")
return
elif getmode == 7:
message.delete()
mutetime = extract_time(message, value)
bot.restrict_chat_member(chat.id,
user.id,
permissions=ChatPermissions(
can_send_messages=False,
until_date=mutetime))
bot.sendMessage(
chat.id,
"{} muted for {} because using '{}' which in blacklist stickers"
.format(mention_markdown(user.id, user.first_name),
value, trigger),
parse_mode="markdown")
return
except BadRequest as excp:
if excp.message == "Message to delete not found":
pass
else:
LOGGER.exception("Error while deleting blacklist message.")
break
