def check_and_ban(update, user_id, should_message=True):
chat = update.effective_chat # type: Optional[Chat]
try:
sw_ban = sw.get_ban(int(user_id))
except AttributeError:
sw_ban = None
except (SpamWatchError, Error, UnauthorizedError, NotFoundError, Forbidden,
TooManyRequests) as e:
log.warning(f" SpamWatch Error: {e}")
sw_ban = None
if sw_ban:
update.effective_chat.kick_member(user_id)
if should_message:
update.effective_message.reply_text(
f"This person has been detected as a spammer by @SpamWatch and has been removed!\nReason: <code>{sw_ban.reason}</code>",
parse_mode=ParseMode.HTML,
)
return
if sql.is_user_gbanned(user_id):
update.effective_chat.kick_member(user_id)
if should_message:
text = (f"<b>Alert</b>: this user is globally banned.\n"
f"<code>*bans them from here*</code>.\n"
f"<b>Appeal chat</b>: @yuiichansupport\n"
f"<b>User ID</b>: <code>{user_id}</code>")
user = sql.get_gbanned_user(user_id)
if user.reason:
text += f"\n<b>Ban Reason:</b> <code>{html.escape(user.reason)}</code>"
update.effective_message.reply_text(text,
parse_mode=ParseMode.HTML)
def left_member(bot: Bot, update: Update):
chat = update.effective_chat # type: Optional[Chat]
should_goodbye, cust_goodbye, goodbye_type = sql.get_gdbye_pref(chat.id)
if should_goodbye:
left_mem = update.effective_message.left_chat_member
if left_mem:
if sw != None:
sw_ban = sw.get_ban(left_mem.id)
if sw_ban:
return
# Ignore bot being kicked
if left_mem.id == bot.id:
return
# Give the owner a special goodbye
if left_mem.id == OWNER_ID:
update.effective_message.reply_text("RIP Master")
return
# if media goodbye, use appropriate function for it
if goodbye_type != sql.Types.TEXT and goodbye_type != sql.Types.BUTTON_TEXT:
ENUM_FUNC_MAP[goodbye_type](chat.id, cust_goodbye)
return
first_name = left_mem.first_name or "PersonWithNoName" # edge case of empty name - occurs for some bugs.
if cust_goodbye:
if left_mem.last_name:
fullname = "{} {}".format(first_name, left_mem.last_name)
else:
fullname = first_name
count = chat.get_members_count()
mention = mention_markdown(left_mem.id, first_name)
if left_mem.username:
username = "******" + escape_markdown(left_mem.username)
else:
username = mention
valid_format = escape_invalid_curly_brackets(
cust_goodbye, VALID_WELCOME_FORMATTERS)
res = valid_format.format(
first=escape_markdown(first_name),
last=escape_markdown(left_mem.last_name or first_name),
fullname=escape_markdown(fullname),
username=username,
mention=mention,
count=count,
chatname=escape_markdown(chat.title),
id=left_mem.id)
buttons = sql.get_gdbye_buttons(chat.id)
keyb = build_keyboard(buttons)
else:
res = sql.DEFAULT_GOODBYE
keyb = []
keyboard = InlineKeyboardMarkup(keyb)
send(update, res, keyboard, sql.DEFAULT_GOODBYE)
def check_and_ban(update, user_id, should_message=True):
chat = update.effective_chat # type: Optional[Chat]
try:
sw_ban = sw.get_ban(int(user_id))
except AttributeError:
sw_ban = None
if sw_ban:
update.effective_chat.kick_member(user_id)
if should_message:
update.effective_message.reply_text(
f"This person has been detected as a spammer by @SpamWatch and has been removed!\nReason: <code>{sw_ban.reason}</code>",
parse_mode=ParseMode.HTML,
)
return
if sql.is_user_gbanned(user_id):
update.effective_chat.kick_member(user_id)
if should_message:
text = (f"<b>Alert</b>: this user is globally banned.\n"
f"<code>*bans them from here*</code>.\n"
f"<b>Appeal chat</b>: @YorkTownEagleUnion\n"
f"<b>User ID</b>: <code>{user_id}</code>")
user = sql.get_gbanned_user(user_id)
if user.reason:
text += f"\n<b>Ban Reason:</b> <code>{html.escape(user.reason)}</code>"
update.effective_message.reply_text(text,
parse_mode=ParseMode.HTML)
def check_and_ban(update, user_id, should_message=True):
from tg_bot import SPB_MODE
chat = update.effective_chat # type: Optional[Chat]
if SPB_MODE:
try:
apst = requests.get(
f'https://api.intellivoid.net/spamprotection/v1/lookup?query={update.effective_user.id}')
api_status = apst.status_code
if api_status == 200:
try:
status = client.raw_output(int(user_id))
try:
bl_check = (status["results"]["attributes"]["is_blacklisted"])
except:
bl_check = False
if bl_check:
bl_res = (status["results"]["attributes"]["blacklist_reason"])
update.effective_chat.kick_member(user_id)
if should_message:
update.effective_message.reply_text(
f"This person was blacklisted on @SpamProtectionBot and has been removed!\nReason: <code>{bl_res}</code>",
parse_mode=ParseMode.HTML,
)
except HostDownError:
log.warning("Spam Protection API is unreachable.")
except BaseException as e:
log.info(f'SpamProtection was disabled due to {e}')
try:
sw_ban = sw.get_ban(int(user_id))
except AttributeError:
sw_ban = None
except (SpamWatchError, Error, UnauthorizedError, NotFoundError, Forbidden, TooManyRequests) as e:
log.warning(f" SpamWatch Error: {e}")
sw_ban = None
if sw_ban:
update.effective_chat.kick_member(user_id)
if should_message:
update.effective_message.reply_text(
f"This person has been detected as a spammer by @SpamWatch and has been removed!\nReason: <code>{sw_ban.reason}</code>",
parse_mode=ParseMode.HTML,
)
return
if sql.is_user_gbanned(user_id):
update.effective_chat.kick_member(user_id)
if should_message:
text = (
f"<b>Alert</b>: this user is globally banned.\n"
f"<code>*bans them from here*</code>.\n"
f"<b>Appeal chat</b>: @zerounions\n"
f"<b>User ID</b>: <code>{user_id}</code>"
)
user = sql.get_gbanned_user(user_id)
if user.reason:
text += f"\n<b>Ban Reason:</b> <code>{html.escape(user.reason)}</code>"
update.effective_message.reply_text(text, parse_mode=ParseMode.HTML)
def check_and_ban(update, user_id, should_message=True):
chat = update.effective_chat # type: Optional[Chat]
if SPB_MODE:
try:
status = client.raw_output(int(user_id))
try:
bl_check = status["results"]["attributes"]["is_blacklisted"]
except:
bl_check = False
if bl_check is True:
bl_res = status["results"]["attributes"]["blacklist_reason"]
update.effective_chat.kick_member(user_id)
if should_message:
update.effective_message.reply_text(
f"This person was blacklisted on @SpamProtectionBot and has been removed!\nReason: <code>{bl_res}</code>",
parse_mode=ParseMode.HTML,
)
except HostDownError:
log.warning("Spam Protection API is unreachable.")
try:
sw_ban = sw.get_ban(int(user_id))
except AttributeError:
sw_ban = None
except (
SpamWatchError,
Error,
UnauthorizedError,
NotFoundError,
Forbidden,
TooManyRequests,
) as e:
log.warning(f" SpamWatch Error: {e}")
sw_ban = None
if sw_ban:
update.effective_chat.kick_member(user_id)
if should_message:
update.effective_message.reply_text(
f"This person has been detected as a spammer by @SpamWatch and has been removed!\nReason: <code>{sw_ban.reason}</code>",
parse_mode=ParseMode.HTML,
)
return
if sql.is_user_gbanned(user_id):
update.effective_chat.kick_member(user_id)
if should_message:
text = (f"<b>Alert</b>: this user is globally banned.\n"
f"<code>*bans them from here*</code>.\n"
f"<b>Appeal chat</b>: @YorkTownEagleUnion\n"
f"<b>User ID</b>: <code>{user_id}</code>")
user = sql.get_gbanned_user(user_id)
if user.reason:
text += f"\n<b>Ban Reason:</b> <code>{html.escape(user.reason)}</code>"
update.effective_message.reply_text(text,
parse_mode=ParseMode.HTML)
def check_and_ban(update, user_id, should_message=True):
sw_ban = sw.get_ban(int(user_id))
if sw_ban:
update.effective_chat.kick_member(user_id)
if should_message:
update.effective_message.reply_markdown(
"**This user is detected as spam bot by SpamWatch and have been removed!**\n\nPlease visit @SpamWatchSupport to appeal!"
)
return
else:
return
if sql.is_user_gbanned(user_id):
update.effective_chat.kick_member(user_id)
if should_message:
update.effective_message.reply_text(
"This is a bad person, they shouldn't be here!")
def check_and_ban(update, user_id, should_message=True):
chat = update.effective_chat # type: Optional[Chat]
sw_ban = sw.get_ban(int(user_id))
if sw_ban:
update.effective_chat.kick_member(user_id)
if should_message:
update.effective_message.reply_markdown("**This user is detected as spam bot by SpamWatch and have been removed!**\n\nPlease visit @SpamWatchSupport to appeal!")
return
else:
return
if sql.is_user_gbanned(user_id):
update.effective_chat.kick_member(user_id)
if should_message:
update.effective_message.reply_text("Alert: This user is globally banned.\n"
"*bans them from here*.\n"
f"Appeal chat: {SUPPORT_CHAT}")
return
def check_and_ban(update, user_id, should_message=True):
chat = update.effective_chat # type: Optional[Chat]
sw_ban = sw.get_ban(int(user_id))
if sw_ban:
update.effective_chat.kick_member(user_id)
if should_message:
update.effective_message.reply_markdown(
"**Pengguna ini terdeteksi sebagai bot spam oleh SpamWatch dan telah dihapus!**"
)
return
else:
return
if sql.is_user_gbanned(user_id):
update.effective_chat.kick_member(user_id)
if should_message:
update.effective_message.reply_text(
"Peringatan: Pengguna ini diblokir secara global.\n"
"*melarang mereka dari sini*.\n"
"Appeal chat: PM My Master")
def info(update: Update, context: CallbackContext):
bot = context.bot
args = context.args
message = update.effective_message
chat = update.effective_chat
user_id = extract_user(update.effective_message, args)
if user_id:
user = bot.get_chat(user_id)
elif not message.reply_to_message and not args:
user = message.from_user
elif not message.reply_to_message and (
not args or
(len(args) >= 1 and not args[0].startswith("@")
and not args[0].isdigit()
and not message.parse_entities([MessageEntity.TEXT_MENTION]))):
message.reply_text("I can't extract a user from this.")
return
else:
return
text = (f"<b>General:</b>\n"
f"ID: <code>{user.id}</code>\n"
f"First Name: {html.escape(user.first_name)}")
if user.last_name:
text += f"\nLast Name: {html.escape(user.last_name)}"
if user.username:
text += f"\nUsername: @{html.escape(user.username)}"
text += f"\nPermanent user link: {mention_html(user.id, 'link')}"
try:
spamwtc = sw.get_ban(int(user.id))
if spamwtc:
text += "<b>\n\nSpamWatch:\n</b>"
text += "<b>This person is banned in Spamwatch!</b>"
text += f"\nReason: <pre>{spamwtc.reason}</pre>"
text += "\nAppeal at @SpamWatchSupport"
else:
text += "<b>\n\nSpamWatch:</b>\n Not banned"
except:
pass # don't crash if api is down somehow...
Nation_level_present = False
num_chats = sql.get_user_num_chats(user.id)
text += f"\nChat count: <code>{num_chats}</code>"
try:
user_member = chat.get_member(user.id)
if user_member.status == "administrator":
result = requests.post(
f"https://api.telegram.org/bot{TOKEN}/getChatMember?chat_id={chat.id}&user_id={user.id}"
)
result = result.json()["result"]
if "custom_title" in result.keys():
custom_title = result["custom_title"]
text += f"\nThis user holds the title <b>{custom_title}</b> here."
except BadRequest:
pass
if user.id == OWNER_ID:
text += f"\nThis person is my master"
Nation_level_present = True
elif user.id in DEV_USERS:
text += f"\nThis Person is a part of Yuii Chan Club"
Nation_level_present = True
elif user.id in SUDO_USERS:
text += f"\nThis person is a sudo user"
Nation_level_present = True
elif user.id in SUPPORT_USERS:
text += f"\nThis person is one of my support user"
Nation_level_present = True
elif user.id in TIGER_USERS:
text += f"\nThis person is a tiger user"
Nation_level_present = True
elif user.id in WHITELIST_USERS:
text += f"\nThis person is a whitelist user"
Nation_level_present = True
if Nation_level_present:
text += ' [<a href="https://t.me/yuiichansupport/3655">?</a>]'.format(
bot.username)
text += "\n"
for mod in USER_INFO:
if mod.__mod_name__ == "Users":
continue
try:
mod_info = mod.__user_info__(user.id)
except TypeError:
mod_info = mod.__user_info__(user.id, chat.id)
if mod_info:
text += "\n" + mod_info
if INFOPIC:
try:
profile = bot.get_user_profile_photos(user.id).photos[0][-1]
_file = bot.get_file(profile["file_id"])
_file.download(f"{user.id}.png")
message.reply_document(
document=open(f"{user.id}.png", "rb"),
caption=(text),
parse_mode=ParseMode.HTML,
)
os.remove(f"{user.id}.png")
# Incase user don't have profile pic, send normal text
except IndexError:
message.reply_text(text,
parse_mode=ParseMode.HTML,
disable_web_page_preview=True)
else:
message.reply_text(text,
parse_mode=ParseMode.HTML,
disable_web_page_preview=True)
def new_member(bot: Bot, update: Update, job_queue: JobQueue):
chat = update.effective_chat
user = update.effective_user
msg = update.effective_message
should_welc, cust_welcome, welc_type = sql.get_welc_pref(chat.id)
welc_mutes = sql.welcome_mutes(chat.id)
human_checks = sql.get_human_checks(user.id, chat.id)
new_members = update.effective_message.new_chat_members
for new_mem in new_members:
welcome_log = None
sent = None
should_mute = True
welcome_bool = True
if sw != None:
sw_ban = sw.get_ban(new_mem.id)
if sw_ban:
return
if should_welc:
# Give the owner a special welcome
if new_mem.id == OWNER_ID:
update.effective_message.reply_text(
"Oh, Kamu ya? Mari kita mulai.")
welcome_log = (
f"{html.escape(chat.title)}\n"
f"#USER_JOINED\n"
f"Pemilik Bot baru saja bergabung dalam obrolan")
# Welcome Devs
elif new_mem.id in DEV_USERS:
update.effective_message.reply_text(
"Wah! Seorang anggota baru saja bergabung!")
# Welcome Sudos
elif new_mem.id in SUDO_USERS:
update.effective_message.reply_text(
"Huh! A Royal Nation just joined! Stay Alert!")
# Welcome Support
elif new_mem.id in SUPPORT_USERS:
update.effective_message.reply_text(
"Huh! Someone with a Sakura Nation level just joined!")
# Welcome Whitelisted
elif new_mem.id in SARDEGNA_USERS:
update.effective_message.reply_text(
"Oof! A Sardegna Nation just joined!")
# Welcome Sardegnas
elif new_mem.id in WHITELIST_USERS:
update.effective_message.reply_text(
"Oof! A Neptunia Nation just joined!")
# Welcome yourself
elif new_mem.id == bot.id:
update.effective_message.reply_text(
"Terima kasih telah menambahkan saya!")
else:
# If welcome message is media, send with appropriate function
if welc_type not in (sql.Types.TEXT, sql.Types.BUTTON_TEXT):
ENUM_FUNC_MAP[welc_type](chat.id, cust_welcome)
continue
# else, move on
first_name = (
new_mem.first_name or "PersonWithNoName"
) # edge case of empty name - occurs for some bugs.
if cust_welcome:
if cust_welcome == sql.DEFAULT_WELCOME:
cust_welcome = random.choice(
sql.DEFAULT_WELCOME_MESSAGES).format(
first=escape_markdown(first_name))
if new_mem.last_name:
fullname = escape_markdown(
f"{first_name} {new_mem.last_name}")
else:
fullname = escape_markdown(first_name)
count = chat.get_members_count()
mention = mention_markdown(new_mem.id,
escape_markdown(first_name))
if new_mem.username:
username = "******" + escape_markdown(new_mem.username)
else:
username = mention
valid_format = escape_invalid_curly_brackets(
cust_welcome, VALID_WELCOME_FORMATTERS)
res = valid_format.format(
first=escape_markdown(first_name),
last=escape_markdown(new_mem.last_name or first_name),
fullname=escape_markdown(fullname),
username=username,
mention=mention,
count=count,
chatname=escape_markdown(chat.title),
id=new_mem.id,
)
buttons = sql.get_welc_buttons(chat.id)
keyb = build_keyboard(buttons)
else:
res = random.choice(sql.DEFAULT_WELCOME_MESSAGES).format(
first=escape_markdown(first_name))
keyb = []
backup_message = random.choice(
sql.DEFAULT_WELCOME_MESSAGES).format(
first=escape_markdown(first_name))
keyboard = InlineKeyboardMarkup(keyb)
else:
welcome_bool = False
res = None
keyboard = None
backup_message = None
# User exceptions from welcomemutes
if (is_user_ban_protected(chat, new_mem.id, chat.get_member(
new_mem.id)) or human_checks):
should_mute = False
# Join welcome: soft mute
if new_mem.is_bot:
should_mute = False
if user.id == new_mem.id:
if should_mute:
if welc_mutes == "soft":
bot.restrict_chat_member(
chat.id,
new_mem.id,
can_send_messages=True,
can_send_media_messages=False,
can_send_other_messages=False,
can_add_web_page_previews=False,
until_date=(int(time.time() + 24 * 60 * 60)),
)
if welc_mutes == "strong":
welcome_bool = False
VERIFIED_USER_WAITLIST.update({
new_mem.id: {
"should_welc": should_welc,
"status": False,
"update": update,
"res": res,
"keyboard": keyboard,
"backup_message": backup_message,
}
})
new_join_mem = f"[{escape_markdown(new_mem.first_name)}](tg://user?id={user.id})"
message = msg.reply_text(
f"{new_join_mem}, klik tombol di bawah untuk membuktikan bahwa Anda adalah manusia.\nWaktumu 160 detik.",
reply_markup=InlineKeyboardMarkup([{
InlineKeyboardButton(
text="Ya, saya manusia.",
callback_data=f"user_join_({new_mem.id})",
)
}]),
parse_mode=ParseMode.MARKDOWN,
)
bot.restrict_chat_member(
chat.id,
new_mem.id,
can_send_messages=False,
can_send_media_messages=False,
can_send_other_messages=False,
can_add_web_page_previews=False,
)
job_queue.run_once(
partial(check_not_bot, new_mem, chat.id,
message.message_id),
160,
name="welcomemute",
)
if welcome_bool:
sent = send(update, res, keyboard, backup_message)
prev_welc = sql.get_clean_pref(chat.id)
if prev_welc:
try:
bot.delete_message(chat.id, prev_welc)
except BadRequest:
pass
if sent:
sql.set_clean_welcome(chat.id, sent.message_id)
if welcome_log:
return welcome_log
return (f"{html.escape(chat.title)}\n"
f"#USER_JOINED\n"
f"<b>Pengguna</b>: {mention_html(user.id, user.first_name)}\n"
f"<b>ID</b>: <code>{user.id}</code>")
return ""
def inlineinfo(query: str, update: Update, context: CallbackContext) -> None:
"""Handle the inline query."""
bot = context.bot
query = update.inline_query.query
log.info(query)
user_id = update.effective_user.id
try:
search = query.split(" ", 1)[1]
except IndexError:
search = user_id
try:
user = bot.get_chat(int(search))
except (BadRequest, ValueError):
user = bot.get_chat(user_id)
chat = update.effective_chat
sql.update_user(user.id, user.username)
text = (f"<b>Information:</b>\n"
f"• ID: <code>{user.id}</code>\n"
f"• First Name: {html.escape(user.first_name)}")
if user.last_name:
text += f"\n• Last Name: {html.escape(user.last_name)}"
if user.username:
text += f"\n• Username: @{html.escape(user.username)}"
text += f"\n• Permanent user link: {mention_html(user.id, 'link')}"
nation_level_present = False
if user.id == OWNER_ID:
text += f"\n\nThis person is my owner"
nation_level_present = True
elif user.id in DEV_USERS:
text += f"\n\nThis Person is a part of Eagle Union"
nation_level_present = True
elif user.id in SUDO_USERS:
text += f"\n\nThe Nation level of this person is Royal"
nation_level_present = True
elif user.id in SUPPORT_USERS:
text += f"\n\nThe Nation level of this person is Sakura"
nation_level_present = True
elif user.id in SARDEGNA_USERS:
text += f"\n\nThe Nation level of this person is Sardegna"
nation_level_present = True
elif user.id in WHITELIST_USERS:
text += f"\n\nThe Nation level of this person is Neptunia"
nation_level_present = True
if nation_level_present:
text += ' [<a href="https://t.me/{}?start=nations">?</a>]'.format(
bot.username)
try:
spamwtc = sw.get_ban(int(user.id))
if spamwtc:
text += "<b>\n\n• SpamWatched:\n</b> Yes"
text += f"\n• Reason: <pre>{spamwtc.reason}</pre>"
text += "\n• Appeal at @SpamWatchSupport"
else:
text += "<b>\n\n• SpamWatched:</b> No"
except:
pass # don't crash if api is down somehow...
num_chats = sql.get_user_num_chats(user.id)
text += f"\n• <b>Chat count</b>: <code>{num_chats}</code>"
kb = InlineKeyboardMarkup([
[
InlineKeyboardButton(
text="Report Error",
url=f"https://t.me/YorktownEagleUnion",
),
InlineKeyboardButton(
text="Search again",
switch_inline_query_current_chat=".info ",
),
],
])
results = [
InlineQueryResultArticle(
id=str(uuid4()),
title=f"User info of {html.escape(user.first_name)}",
input_message_content=InputTextMessageContent(
text, parse_mode=ParseMode.HTML,
disable_web_page_preview=True),
reply_markup=kb),
]
update.inline_query.answer(results, cache_time=5)
def new_member(bot: Bot, update: Update, job_queue: JobQueue):
chat = update.effective_chat
user = update.effective_user
msg = update.effective_message
should_welc, cust_welcome, welc_type = sql.get_welc_pref(chat.id)
welc_mutes = sql.welcome_mutes(chat.id)
human_checks = sql.get_human_checks(user.id, chat.id)
new_members = update.effective_message.new_chat_members
for new_mem in new_members:
welcome_log = None
sent = None
should_mute = True
welcome_bool = True
if sw != None:
sw_ban = sw.get_ban(new_mem.id)
if sw_ban:
return
if new_mem.id == bot.id:
bot.send_message(
MESSAGE_DUMP,
"I have been added to {} with ID: <pre>{}</pre>".format(
chat.title, chat.id),
parse_mode=ParseMode.HTML)
if should_welc:
reply = update.message.message_id
cleanserv = sql.clean_service(chat.id)
# Clean service welcome
if cleanserv:
try:
dispatcher.bot.delete_message(chat.id,
update.message.message_id)
except BadRequest:
pass
reply = False
# Give the owner a special welcome
if new_mem.id == OWNER_ID:
update.effective_message.reply_text(
"Oh, Genos? Let's get this moving.",
reply_to_message_id=reply)
welcome_log = (f"{html.escape(chat.title)}\n"
f"#USER_JOINED\n"
f"Bot Owner just joined the chat")
# Welcome Devs
elif new_mem.id in DEV_USERS:
update.effective_message.reply_text(
"Whoa! A member of the Heroes Association just joined!",
reply_to_message_id=reply)
# Welcome Sudos
elif new_mem.id in SUDO_USERS:
update.effective_message.reply_text(
"Huh! A Dragon disaster just joined! Stay Alert!",
reply_to_message_id=reply)
# Welcome Support
elif new_mem.id in SUPPORT_USERS:
update.effective_message.reply_text(
"Huh! Someone with a Demon disaster level just joined!",
reply_to_message_id=reply)
# Welcome Whitelisted
elif new_mem.id in TIGER_USERS:
update.effective_message.reply_text(
"Oof! A Tiger disaster just joined!",
reply_to_message_id=reply)
# Welcome Tigers
elif new_mem.id in WHITELIST_USERS:
update.effective_message.reply_text(
"Oof! A Wolf disaster just joined!",
reply_to_message_id=reply)
# Welcome yourself
elif new_mem.id == bot.id:
update.effective_message.reply_text(
"Thanks for Adding me ! My Support Channel is @ebruiser ",
reply_to_message_id=reply)
else:
# If welcome message is media, send with appropriate function
if welc_type not in (sql.Types.TEXT, sql.Types.BUTTON_TEXT):
ENUM_FUNC_MAP[welc_type](chat.id, cust_welcome)
continue
# else, move on
first_name = new_mem.first_name or "PersonWithNoName" # edge case of empty name - occurs for some bugs.
if cust_welcome:
if cust_welcome == sql.DEFAULT_WELCOME:
cust_welcome = random.choice(
sql.DEFAULT_WELCOME_MESSAGES).format(
first=escape_markdown(first_name))
if new_mem.last_name:
fullname = escape_markdown(
f"{first_name} {new_mem.last_name}")
else:
fullname = escape_markdown(first_name)
count = chat.get_members_count()
mention = mention_markdown(new_mem.id,
escape_markdown(first_name))
if new_mem.username:
username = "******" + escape_markdown(new_mem.username)
else:
username = mention
valid_format = escape_invalid_curly_brackets(
cust_welcome, VALID_WELCOME_FORMATTERS)
res = valid_format.format(
first=escape_markdown(first_name),
last=escape_markdown(new_mem.last_name or first_name),
fullname=escape_markdown(fullname),
username=username,
mention=mention,
count=count,
chatname=escape_markdown(chat.title),
id=new_mem.id)
buttons = sql.get_welc_buttons(chat.id)
keyb = build_keyboard(buttons)
else:
res = random.choice(sql.DEFAULT_WELCOME_MESSAGES).format(
first=escape_markdown(first_name))
keyb = []
backup_message = random.choice(
sql.DEFAULT_WELCOME_MESSAGES).format(
first=escape_markdown(first_name))
keyboard = InlineKeyboardMarkup(keyb)
else:
welcome_bool = False
res = None
keyboard = None
backup_message = None
# User exceptions from welcomemutes
if is_user_ban_protected(chat, new_mem.id, chat.get_member(
new_mem.id)) or human_checks:
should_mute = False
# Join welcome: soft mute
if new_mem.is_bot:
should_mute = False
if user.id == new_mem.id:
if should_mute:
if welc_mutes == "soft":
bot.restrict_chat_member(chat.id,
new_mem.id,
can_send_messages=True,
can_send_media_messages=False,
can_send_other_messages=False,
can_add_web_page_previews=False,
until_date=(int(time.time() +
24 * 60 * 60)))
if welc_mutes == "strong":
welcome_bool = False
VERIFIED_USER_WAITLIST.update({
new_mem.id: {
"should_welc": should_welc,
"status": False,
"update": update,
"res": res,
"keyboard": keyboard,
"backup_message": backup_message
}
})
new_join_mem = f"[{escape_markdown(new_mem.first_name)}](tg://user?id={user.id})"
message = msg.reply_text(
f"{new_join_mem}, click the button below to prove you're human.\nYou have 160 seconds.",
reply_markup=InlineKeyboardMarkup([{
InlineKeyboardButton(
text="Yes, I'm human.",
callback_data=f"user_join_({new_mem.id})")
}]),
parse_mode=ParseMode.MARKDOWN,
reply_to_message_id=reply)
bot.restrict_chat_member(chat.id,
new_mem.id,
can_send_messages=False,
can_send_media_messages=False,
can_send_other_messages=False,
can_add_web_page_previews=False)
job_queue.run_once(partial(check_not_bot, new_mem, chat.id,
message.message_id),
160,
name="welcomemute")
if welcome_bool:
sent = send(update, res, keyboard, backup_message)
prev_welc = sql.get_clean_pref(chat.id)
if prev_welc:
try:
bot.delete_message(chat.id, prev_welc)
except BadRequest:
pass
if sent:
sql.set_clean_welcome(chat.id, sent.message_id)
if welcome_log:
return welcome_log
return (f"{html.escape(chat.title)}\n"
f"#USER_JOINED\n"
f"<b>User</b>: {mention_html(user.id, user.first_name)}\n"
f"<b>ID</b>: <code>{user.id}</code>")
return ""
def left_member(bot: Bot, update: Update):
chat = update.effective_chat
user = update.effective_user
should_goodbye, cust_goodbye, goodbye_type = sql.get_gdbye_pref(chat.id)
if user.id == bot.id:
return
if should_goodbye:
reply = update.message.message_id
cleanserv = sql.clean_service(chat.id)
# Clean service welcome
if cleanserv:
try:
dispatcher.bot.delete_message(chat.id,
update.message.message_id)
except BadRequest:
pass
reply = False
left_mem = update.effective_message.left_chat_member
if left_mem:
if sw != None:
sw_ban = sw.get_ban(left_mem.id)
if sw_ban:
return
# Dont say goodbyes to gbanned users
if is_user_gbanned(left_mem.id):
return
# Ignore bot being kicked
if left_mem.id == bot.id:
return
# Give the owner a special goodbye
if left_mem.id == OWNER_ID:
update.effective_message.reply_text("Oi! Genos! He left..",
reply_to_message_id=reply)
return
# Give the devs a special goodbye
elif left_mem.id in DEV_USERS:
update.effective_message.reply_text(
"See you later at the Hero's Association!",
reply_to_message_id=reply)
return
# if media goodbye, use appropriate function for it
if goodbye_type != sql.Types.TEXT and goodbye_type != sql.Types.BUTTON_TEXT:
ENUM_FUNC_MAP[goodbye_type](chat.id, cust_goodbye)
return
first_name = left_mem.first_name or "PersonWithNoName" # edge case of empty name - occurs for some bugs.
if cust_goodbye:
if cust_goodbye == sql.DEFAULT_GOODBYE:
cust_goodbye = random.choice(
sql.DEFAULT_GOODBYE_MESSAGES).format(
first=escape_markdown(first_name))
if left_mem.last_name:
fullname = escape_markdown(
f"{first_name} {left_mem.last_name}")
else:
fullname = escape_markdown(first_name)
count = chat.get_members_count()
mention = mention_markdown(left_mem.id, first_name)
if left_mem.username:
username = "******" + escape_markdown(left_mem.username)
else:
username = mention
valid_format = escape_invalid_curly_brackets(
cust_goodbye, VALID_WELCOME_FORMATTERS)
res = valid_format.format(
first=escape_markdown(first_name),
last=escape_markdown(left_mem.last_name or first_name),
fullname=escape_markdown(fullname),
username=username,
mention=mention,
count=count,
chatname=escape_markdown(chat.title),
id=left_mem.id)
buttons = sql.get_gdbye_buttons(chat.id)
keyb = build_keyboard(buttons)
else:
res = random.choice(
sql.DEFAULT_GOODBYE_MESSAGES).format(first=first_name)
keyb = []
keyboard = InlineKeyboardMarkup(keyb)
send(
update, res, keyboard,
random.choice(
sql.DEFAULT_GOODBYE_MESSAGES).format(first=first_name))
def new_member(update: Update,
context: CallbackContext): # sourcery no-metrics
bot, job_queue = context.bot, context.job_queue
chat = update.effective_chat
user = update.effective_user
msg = update.effective_message
should_welc, cust_welcome, cust_content, welc_type = sql.get_welc_pref(
chat.id)
welc_mutes = sql.welcome_mutes(chat.id)
human_checks = sql.get_human_checks(user.id, chat.id)
new_members = update.effective_message.new_chat_members
for new_mem in new_members:
welcome_log = None
res = None
sent = None
should_mute = True
welcome_bool = True
media_wel = False
if sw != None:
sw_ban = sw.get_ban(new_mem.id)
if sw_ban:
return
reply = update.message.message_id
cleanserv = sql.clean_service(chat.id)
# Clean service welcome
if cleanserv:
try:
dispatcher.bot.delete_message(chat.id,
update.message.message_id)
except BadRequest:
pass
reply = False
if should_welc:
# Give the owner a special welcome
if new_mem.id == OWNER_ID:
update.effective_message.reply_text("Oh hi, my creator.",
reply_to_message_id=reply)
welcome_log = (f"{html.escape(chat.title)}\n"
f"#USER_JOINED\n"
f"Bot Owner just joined the chat")
continue
# Welcome Devs
elif new_mem.id in DEV_USERS:
update.effective_message.reply_text(
"Whoa! A member of the Eagle Union just joined!",
reply_to_message_id=reply,
)
continue
# Welcome Sudos
elif new_mem.id in SUDO_USERS:
update.effective_message.reply_text(
"Huh! A Royal Nation just joined! Stay Alert!",
reply_to_message_id=reply,
)
continue
# Welcome Support
elif new_mem.id in SUPPORT_USERS:
update.effective_message.reply_text(
"Huh! Someone with a Sakura Nation level just joined!",
reply_to_message_id=reply,
)
continue
# Welcome Whitelisted
elif new_mem.id in SARDEGNA_USERS:
update.effective_message.reply_text(
"Oof! A Sadegna Nation just joined!",
reply_to_message_id=reply)
continue
# Welcome SARDEGNA_USERS
elif new_mem.id in WHITELIST_USERS:
update.effective_message.reply_text(
"Oof! A Neptuia Nation just joined!",
reply_to_message_id=reply)
continue
# Welcome yourself
elif new_mem.id == bot.id:
update.effective_message.reply_text(
"Thanks for adding me! Join @YorkTownEagleUnion for support.",
reply_to_message_id=reply,
)
continue
else:
buttons = sql.get_welc_buttons(chat.id)
keyb = build_keyboard(buttons)
if welc_type not in (sql.Types.TEXT, sql.Types.BUTTON_TEXT):
media_wel = True
first_name = (
new_mem.first_name or "PersonWithNoName"
) # edge case of empty name - occurs for some bugs.
if cust_welcome:
if cust_welcome == sql.DEFAULT_WELCOME:
cust_welcome = random.choice(
sql.DEFAULT_WELCOME_MESSAGES).format(
first=escape_markdown(first_name))
if new_mem.last_name:
fullname = escape_markdown(
f"{first_name} {new_mem.last_name}")
else:
fullname = escape_markdown(first_name)
count = chat.get_members_count()
mention = mention_markdown(new_mem.id,
escape_markdown(first_name))
if new_mem.username:
username = "******" + escape_markdown(new_mem.username)
else:
username = mention
valid_format = escape_invalid_curly_brackets(
cust_welcome, VALID_WELCOME_FORMATTERS)
res = valid_format.format(
first=escape_markdown(first_name),
last=escape_markdown(new_mem.last_name or first_name),
fullname=escape_markdown(fullname),
username=username,
mention=mention,
count=count,
chatname=escape_markdown(chat.title),
id=new_mem.id,
)
else:
res = random.choice(sql.DEFAULT_WELCOME_MESSAGES).format(
first=escape_markdown(first_name))
keyb = []
backup_message = random.choice(
sql.DEFAULT_WELCOME_MESSAGES).format(
first=escape_markdown(first_name))
keyboard = InlineKeyboardMarkup(keyb)
else:
welcome_bool = False
res = None
keyboard = None
backup_message = None
reply = None
# User exceptions from welcomemutes
if (is_user_ban_protected(chat, new_mem.id, chat.get_member(
new_mem.id)) or human_checks):
should_mute = False
# Join welcome: soft mute
if new_mem.is_bot:
should_mute = False
if user.id == new_mem.id and should_mute:
if welc_mutes == "soft":
bot.restrict_chat_member(
chat.id,
new_mem.id,
permissions=ChatPermissions(
can_send_messages=True,
can_send_media_messages=False,
can_send_other_messages=False,
can_invite_users=False,
can_pin_messages=False,
can_send_polls=False,
can_change_info=False,
can_add_web_page_previews=False,
),
until_date=(int(time.time() + 24 * 60 * 60)),
)
if welc_mutes == "strong":
welcome_bool = False
if not media_wel:
VERIFIED_USER_WAITLIST.update({
(chat.id, new_mem.id): {
"should_welc": should_welc,
"media_wel": False,
"status": False,
"update": update,
"res": res,
"keyboard": keyboard,
"backup_message": backup_message,
}
})
else:
VERIFIED_USER_WAITLIST.update({
(chat.id, new_mem.id): {
"should_welc": should_welc,
"chat_id": chat.id,
"status": False,
"media_wel": True,
"cust_content": cust_content,
"welc_type": welc_type,
"res": res,
"keyboard": keyboard,
}
})
new_join_mem = f"[{escape_markdown(new_mem.first_name)}](tg://user?id={user.id})"
message = msg.reply_text(
f"{new_join_mem}, click the button below to prove you're human.\nYou have 120 seconds.",
reply_markup=InlineKeyboardMarkup([{
InlineKeyboardButton(
text="Yes, I'm human.",
callback_data=f"user_join_({new_mem.id})",
)
}]),
parse_mode=ParseMode.MARKDOWN,
reply_to_message_id=reply,
)
bot.restrict_chat_member(
chat.id,
new_mem.id,
permissions=ChatPermissions(
can_send_messages=False,
can_invite_users=False,
can_pin_messages=False,
can_send_polls=False,
can_change_info=False,
can_send_media_messages=False,
can_send_other_messages=False,
can_add_web_page_previews=False,
),
)
job_queue.run_once(
partial(check_not_bot, new_mem, chat.id,
message.message_id),
120,
name="welcomemute",
)
if welc_mutes == "captcha":
btn = []
# Captcha image size number (2 -> 640x360)
CAPCTHA_SIZE_NUM = 2
# Create Captcha Generator object of specified size
generator = CaptchaGenerator(CAPCTHA_SIZE_NUM)
# Generate a captcha image
captcha = generator.gen_captcha_image(difficult_level=3)
# Get information
image = captcha["image"]
characters = captcha["characters"]
#print(characters)
fileobj = BytesIO()
fileobj.name = f'captcha_{new_mem.id}.png'
image.save(fp=fileobj)
fileobj.seek(0)
CAPTCHA_ANS_DICT[(chat.id, new_mem.id)] = int(characters)
welcome_bool = False
if not media_wel:
VERIFIED_USER_WAITLIST.update({
(chat.id, new_mem.id): {
"should_welc": should_welc,
"media_wel": False,
"status": False,
"update": update,
"res": res,
"keyboard": keyboard,
"backup_message": backup_message,
"captcha_correct": characters,
}
})
else:
VERIFIED_USER_WAITLIST.update({
(chat.id, new_mem.id): {
"should_welc": should_welc,
"chat_id": chat.id,
"status": False,
"media_wel": True,
"cust_content": cust_content,
"welc_type": welc_type,
"res": res,
"keyboard": keyboard,
"captcha_correct": characters,
}
})
nums = [random.randint(1000, 9999) for _ in range(7)]
nums.append(characters)
random.shuffle(nums)
to_append = []
#print(nums)
for a in nums:
to_append.append(
InlineKeyboardButton(
text=str(a),
callback_data=
f"user_captchajoin_({chat.id},{new_mem.id})_({a})")
)
if len(to_append) > 2:
btn.append(to_append)
to_append = []
if to_append:
btn.append(to_append)
message = msg.reply_photo(
fileobj,
caption=
f'Welcome [{escape_markdown(new_mem.first_name)}](tg://user?id={user.id}). Click the correct button to get unmuted!',
reply_markup=InlineKeyboardMarkup(btn),
parse_mode=ParseMode.MARKDOWN,
reply_to_message_id=reply,
)
bot.restrict_chat_member(
chat.id,
new_mem.id,
permissions=ChatPermissions(
can_send_messages=False,
can_invite_users=False,
can_pin_messages=False,
can_send_polls=False,
can_change_info=False,
can_send_media_messages=False,
can_send_other_messages=False,
can_add_web_page_previews=False,
),
)
if welcome_bool:
if media_wel:
if ENUM_FUNC_MAP[welc_type] == dispatcher.bot.send_sticker:
sent = ENUM_FUNC_MAP[welc_type](
chat.id,
cust_content,
reply_markup=keyboard,
reply_to_message_id=reply,
)
else:
sent = ENUM_FUNC_MAP[welc_type](
chat.id,
cust_content,
caption=res,
reply_markup=keyboard,
reply_to_message_id=reply,
parse_mode="markdown",
)
else:
sent = send(update, res, keyboard, backup_message)
prev_welc = sql.get_clean_pref(chat.id)
if prev_welc:
try:
bot.delete_message(chat.id, prev_welc)
except BadRequest:
pass
if sent:
sql.set_clean_welcome(chat.id, sent.message_id)
if welcome_log:
return welcome_log
return (f"{html.escape(chat.title)}\n"
f"#USER_JOINED\n"
f"<b>User</b>: {mention_html(user.id, user.first_name)}\n"
f"<b>ID</b>: <code>{user.id}</code>")
return ""
def inlineinfo(query: str, update: Update, context: CallbackContext) -> None:
"""Handle the inline query."""
bot = context.bot
query = update.inline_query.query
log.info(query)
user_id = update.effective_user.id
try:
search = query.split(" ", 1)[1]
except IndexError:
search = user_id
try:
user = bot.get_chat(int(search))
except (BadRequest, ValueError):
user = bot.get_chat(user_id)
chat = update.effective_chat
sql.update_user(user.id, user.username)
text = (f"<b>Information:</b>\n"
f"• ID: <code>{user.id}</code>\n"
f"• First Name: {html.escape(user.first_name)}")
if user.last_name:
text += f"\n• Last Name: {html.escape(user.last_name)}"
if user.username:
text += f"\n• Username: @{html.escape(user.username)}"
text += f"\n• Permanent user link: {mention_html(user.id, 'link')}"
nation_level_present = False
if user.id == OWNER_ID:
text += f"\n\nThis person is my owner"
nation_level_present = True
elif user.id in DEV_USERS:
text += f"\n\nThis Person is a part of Eagle Union"
nation_level_present = True
elif user.id in SUDO_USERS:
text += f"\n\nThe Nation level of this person is Royal"
nation_level_present = True
elif user.id in SUPPORT_USERS:
text += f"\n\nThe Nation level of this person is Sakura"
nation_level_present = True
elif user.id in SARDEGNA_USERS:
text += f"\n\nThe Nation level of this person is Sardegna"
nation_level_present = True
elif user.id in WHITELIST_USERS:
text += f"\n\nThe Nation level of this person is Neptunia"
nation_level_present = True
if nation_level_present:
text += ' [<a href="https://t.me/{}?start=nations">?</a>]'.format(
bot.username)
try:
spamwtc = sw.get_ban(int(user.id))
if spamwtc:
text += "<b>\n\n• SpamWatched:\n</b> Yes"
text += f"\n• Reason: <pre>{spamwtc.reason}</pre>"
text += "\n• Appeal at @SpamWatchSupport"
else:
text += "<b>\n\n• SpamWatched:</b> No"
except:
pass # don't crash if api is down somehow...
apst = requests.get(
f'https://api.intellivoid.net/spamprotection/v1/lookup?query={context.bot.username}'
)
api_status = apst.status_code
if (api_status == 200):
try:
status = client.raw_output(int(user.id))
# ptid = status["results"]["private_telegram_id"]
op = status["results"]["attributes"]["is_operator"]
ag = status["results"]["attributes"]["is_agent"]
wl = status["results"]["attributes"]["is_whitelisted"]
ps = status["results"]["attributes"]["is_potential_spammer"]
sp = status["results"]["spam_prediction"]["spam_prediction"]
hamp = status["results"]["spam_prediction"]["ham_prediction"]
blc = status["results"]["attributes"]["is_blacklisted"]
if blc:
blres = status["results"]["attributes"]["blacklist_reason"]
else:
blres = None
text += "\n\n<b>SpamProtection:</b>"
# text += f"<b>\n• Private Telegram ID:</b> <code>{ptid}</code>\n"
text += f"<b>\n• Operator:</b> <code>{op}</code>\n"
text += f"<b>• Agent:</b> <code>{ag}</code>\n"
text += f"<b>• Whitelisted:</b> <code>{wl}</code>\n"
text += f"<b>• Spam/Ham Prediction:</b> <code>{round((sp/hamp*100), 3)}%</code>\n"
text += f"<b>• Potential Spammer:</b> <code>{ps}</code>\n"
text += f"<b>• Blacklisted:</b> <code>{blc}</code>\n"
text += f"<b>• Blacklist Reason:</b> <code>{blres}</code>\n"
except HostDownError:
text += "\n\n<b>SpamProtection:</b>"
text += "\nCan't connect to Intellivoid SpamProtection API\n"
else:
text += "\n\n<b>SpamProtection:</b>"
text += f"\n<code>API RETURNED: {api_status}</code>\n"
num_chats = sql.get_user_num_chats(user.id)
text += f"\n• Chat count: <code>{num_chats}</code>"
kb = InlineKeyboardMarkup([
[
InlineKeyboardButton(
text="Report Error",
url=f"https://t.me/YorktownEagleUnion",
),
InlineKeyboardButton(
text="Search again",
switch_inline_query_current_chat=".info ",
),
],
])
results = [
InlineQueryResultArticle(
id=str(uuid4()),
title=f"User info of {html.escape(user.first_name)}",
input_message_content=InputTextMessageContent(
text, parse_mode=ParseMode.HTML,
disable_web_page_preview=True),
reply_markup=kb),
]
update.inline_query.answer(results, cache_time=5)
def info(update: Update, context: CallbackContext):
bot = context.bot
args = context.args
message = update.effective_message
chat = update.effective_chat
user_id = extract_user(update.effective_message, args)
if user_id:
user = bot.get_chat(user_id)
elif not message.reply_to_message and not args:
user = message.from_user
elif not message.reply_to_message and (
not args
or (
len(args) >= 1
and not args[0].startswith("@")
and not args[0].isdigit()
and not message.parse_entities([MessageEntity.TEXT_MENTION])
)
):
message.reply_text("I can't extract a user from this.")
return
else:
return
text = (
f"<b>General:</b>\n"
f"ID: <code>{user.id}</code>\n"
f"First Name: {html.escape(user.first_name)}"
)
if user.last_name:
text += f"\nLast Name: {html.escape(user.last_name)}"
if user.username:
text += f"\nUsername: @{html.escape(user.username)}"
text += f"\nPermanent user link: {mention_html(user.id, 'link')}"
try:
spamwtc = sw.get_ban(int(user.id))
if spamwtc:
text += "<b>\n\nSpamWatch:\n</b>"
text += "<b>This person is banned in Spamwatch!</b>"
text += f"\nReason: <pre>{spamwtc.reason}</pre>"
text += "\nAppeal at @SpamWatchSupport"
else:
text += "<b>\n\nSpamWatch:</b>\n Not banned"
except:
pass # don't crash if api is down somehow...
apst = requests.get(f'https://api.intellivoid.net/spamprotection/v1/lookup?query={context.bot.username}')
api_status = apst.status_code
if (api_status == 200):
try:
status = client.raw_output(int(user.id))
ptid = status["results"]["private_telegram_id"]
op = status["results"]["attributes"]["is_operator"]
ag = status["results"]["attributes"]["is_agent"]
wl = status["results"]["attributes"]["is_whitelisted"]
ps = status["results"]["attributes"]["is_potential_spammer"]
sp = status["results"]["spam_prediction"]["spam_prediction"]
hamp = status["results"]["spam_prediction"]["ham_prediction"]
blc = status["results"]["attributes"]["is_blacklisted"]
if blc:
blres = status["results"]["attributes"]["blacklist_reason"]
else:
blres = None
text += "\n\n<b>SpamProtection:</b>"
text += f"<b>\nPrivate Telegram ID:</b> <code>{ptid}</code>\n"
text += f"<b>Operator:</b> <code>{op}</code>\n"
text += f"<b>Agent:</b> <code>{ag}</code>\n"
text += f"<b>Whitelisted:</b> <code>{wl}</code>\n"
text += f"<b>Spam Prediction:</b> <code>{sp}</code>\n"
text += f"<b>Ham Prediction:</b> <code>{hamp}</code>\n"
text += f"<b>Potential Spammer:</b> <code>{ps}</code>\n"
text += f"<b>Blacklisted:</b> <code>{blc}</code>\n"
text += f"<b>Blacklist Reason:</b> <code>{blres}</code>\n"
except HostDownError:
text += "\n\n<b>SpamProtection:</b>"
text += "\nCan't connect to Intellivoid SpamProtection API\n"
else:
text += "\n\n<b>SpamProtection:</b>"
text += f"\n<code>API RETURNED: {api_status}</code>\n"
Nation_level_present = False
num_chats = sql.get_user_num_chats(user.id)
text += f"\nChat count: <code>{num_chats}</code>"
try:
user_member = chat.get_member(user.id)
if user_member.status == "administrator":
result = requests.post(
f"https://api.telegram.org/bot{TOKEN}/getChatMember?chat_id={chat.id}&user_id={user.id}"
)
result = result.json()["result"]
if "custom_title" in result.keys():
custom_title = result["custom_title"]
text += f"\nThis user holds the title <b>{custom_title}</b> here."
except BadRequest:
pass
if user.id == OWNER_ID:
text += f"\nThis person is my owner"
Nation_level_present = True
elif user.id in DEV_USERS:
text += f"\nThis Person is a part of Eagle Union"
Nation_level_present = True
elif user.id in SUDO_USERS:
text += f"\nThe Nation level of this person is Royal"
Nation_level_present = True
elif user.id in SUPPORT_USERS:
text += f"\nThe Nation level of this person is Sakura"
Nation_level_present = True
elif user.id in SARDEGNA_USERS:
text += f"\nThe Nation level of this person is Sardegna"
Nation_level_present = True
elif user.id in WHITELIST_USERS:
text += f"\nThe Nation level of this person is Neptunia"
Nation_level_present = True
if Nation_level_present:
text += ' [<a href="https://t.me/{}?start=nations">?</a>]'.format(bot.username)
text += "\n"
for mod in USER_INFO:
if mod.__mod_name__ == "Users":
continue
try:
mod_info = mod.__user_info__(user.id)
except TypeError:
mod_info = mod.__user_info__(user.id, chat.id)
if mod_info:
text += "\n" + mod_info
if INFOPIC:
try:
profile = bot.get_user_profile_photos(user.id).photos[0][-1]
_file = bot.get_file(profile["file_id"])
_file.download(f"{user.id}.png")
message.reply_document(
document=open(f"{user.id}.png", "rb"),
caption=(text),
parse_mode=ParseMode.HTML,
)
os.remove(f"{user.id}.png")
# Incase user don't have profile pic, send normal text
except IndexError:
message.reply_text(
text, parse_mode=ParseMode.HTML, disable_web_page_preview=True
)
else:
message.reply_text(
text, parse_mode=ParseMode.HTML, disable_web_page_preview=True
)
def left_member(bot: Bot, update: Update):
chat = update.effective_chat
user = update.effective_user
should_goodbye, cust_goodbye, goodbye_type = sql.get_gdbye_pref(chat.id)
if user.id == bot.id:
return
if should_goodbye:
left_mem = update.effective_message.left_chat_member
if left_mem:
if sw != None:
sw_ban = sw.get_ban(left_mem.id)
if sw_ban:
return
# Ignore bot being kicked
if left_mem.id == bot.id:
return
# Give the owner a special goodbye
if left_mem.id == OWNER_ID:
update.effective_message.reply_text(
"H-Hey, where are you going..? ˃ᆺ˂")
return
# Give the devs a special goodbye
elif left_mem.id in DEV_USERS:
update.effective_message.reply_text(
"See you later at the Dev Union!")
return
# if media goodbye, use appropriate function for it
if goodbye_type != sql.Types.TEXT and goodbye_type != sql.Types.BUTTON_TEXT:
ENUM_FUNC_MAP[goodbye_type](chat.id, cust_goodbye)
return
first_name = left_mem.first_name or "PersonWithNoName" # edge case of empty name - occurs for some bugs.
if cust_goodbye:
if cust_goodbye == sql.DEFAULT_GOODBYE:
cust_goodbye = random.choice(
sql.DEFAULT_GOODBYE_MESSAGES).format(
first=escape_markdown(first_name))
if left_mem.last_name:
fullname = escape_markdown(
f"{first_name} {left_mem.last_name}")
else:
fullname = escape_markdown(first_name)
count = chat.get_members_count()
mention = mention_markdown(left_mem.id, first_name)
if left_mem.username:
username = "******" + escape_markdown(left_mem.username)
else:
username = mention
valid_format = escape_invalid_curly_brackets(
cust_goodbye, VALID_WELCOME_FORMATTERS)
res = valid_format.format(
first=escape_markdown(first_name),
last=escape_markdown(left_mem.last_name or first_name),
fullname=escape_markdown(fullname),
username=username,
mention=mention,
count=count,
chatname=escape_markdown(chat.title),
id=left_mem.id)
buttons = sql.get_gdbye_buttons(chat.id)
keyb = build_keyboard(buttons)
else:
res = random.choice(
sql.DEFAULT_GOODBYE_MESSAGES).format(first=first_name)
keyb = []
keyboard = InlineKeyboardMarkup(keyb)
send(
update, res, keyboard,
random.choice(
sql.DEFAULT_GOODBYE_MESSAGES).format(first=first_name))
def info(update: Update, context: CallbackContext): # sourcery no-metrics
bot = context.bot
args = context.args
message = update.effective_message
chat = update.effective_chat
user_id = extract_user(update.effective_message, args)
if user_id:
user = bot.get_chat(user_id)
elif not message.reply_to_message and not args:
user = message.from_user
elif not message.reply_to_message and (
not args or
(len(args) >= 1 and not args[0].startswith("@")
and not args[0].isdigit()
and not message.parse_entities([MessageEntity.TEXT_MENTION]))):
message.reply_text("I can't extract a user from this.")
return
else:
return
text = (f"<b>General:</b>\n"
f"ID: <code>{user.id}</code>\n"
f"First Name: {html.escape(user.first_name)}")
if user.last_name:
text += f"\nLast Name: {html.escape(user.last_name)}"
if user.username:
text += f"\nUsername: @{html.escape(user.username)}"
text += f"\nPermanent user link: {mention_html(user.id, 'link')}"
try:
spamwtc = sw.get_ban(int(user.id))
if spamwtc:
text += "<b>\n\nSpamWatch:\n</b>"
text += "<b>This person is banned in Spamwatch!</b>"
text += f"\nReason: <pre>{spamwtc.reason}</pre>"
text += "\nAppeal at @SpamWatchSupport"
else:
text += "<b>\n\nSpamWatch:</b>\n Not banned"
except:
pass # don't crash if api is down somehow...
Nation_level_present = False
num_chats = sql.get_user_num_chats(user.id)
text += f"\n<b>Chat count</b>: <code>{num_chats}</code>"
try:
user_member = chat.get_member(user.id)
if user_member.status == "administrator":
result = bot.get_chat_member(chat.id, user.id)
if result.custom_title:
text += f"\nThis user holds the title <b>{result.custom_title}</b> here."
except BadRequest:
pass
if user.id == OWNER_ID:
text += '\nThis person is my owner'
Nation_level_present = True
elif user.id in DEV_USERS:
text += '\nThis Person is a part of Eagle Union'
Nation_level_present = True
elif user.id in SUDO_USERS:
text += '\nThe Nation level of this person is Royal'
Nation_level_present = True
elif user.id in SUPPORT_USERS:
text += '\nThe Nation level of this person is Sakura'
Nation_level_present = True
elif user.id in SARDEGNA_USERS:
text += '\nThe Nation level of this person is Sardegna'
Nation_level_present = True
elif user.id in WHITELIST_USERS:
text += '\nThe Nation level of this person is Neptunia'
Nation_level_present = True
if Nation_level_present:
text += ' [<a href="https://t.me/{}?start=nations">?</a>]'.format(
bot.username)
text += "\n"
for mod in USER_INFO:
if mod.__mod_name__ == "Users":
continue
try:
mod_info = mod.__user_info__(user.id)
except TypeError:
mod_info = mod.__user_info__(user.id, chat.id)
if mod_info:
text += "\n" + mod_info
if INFOPIC:
try:
profile = bot.get_user_profile_photos(user.id).photos[0][-1]
_file = bot.get_file(profile["file_id"])
_file = _file.download(out=BytesIO())
_file.seek(0)
message.reply_document(
document=_file,
caption=(text),
parse_mode=ParseMode.HTML,
)
# Incase user don't have profile pic, send normal text
except IndexError:
message.reply_text(text,
parse_mode=ParseMode.HTML,
disable_web_page_preview=True)
else:
message.reply_text(text,
parse_mode=ParseMode.HTML,
disable_web_page_preview=True)
def info(bot: Bot, update: Update, args: List[str]):
message = update.effective_message
chat = update.effective_chat
user_id = extract_user(update.effective_message, args)
if user_id:
user = bot.get_chat(user_id)
elif not message.reply_to_message and not args:
user = message.from_user
elif not message.reply_to_message and (
not args or
(len(args) >= 1 and not args[0].startswith("@")
and not args[0].isdigit()
and not message.parse_entities([MessageEntity.TEXT_MENTION]))):
message.reply_text("Saya tidak dapat mengekstrak pengguna dari ini.")
return
else:
return
text = (f"<b>Karakteristik:</b>\n"
f"ID: <code>{user.id}</code>\n"
f"Nama depan: {html.escape(user.first_name)}")
if user.last_name:
text += f"\nNama Belakang: {html.escape(user.last_name)}"
if user.username:
text += f"\nNama pengguna: @{html.escape(user.username)}"
text += f"\nTautan pengguna permanen: {mention_html(user.id, 'link')}"
try:
spamwtc = sw.get_ban(int(user.id))
if spamwtc:
text += "\n\n<b>Orang ini dilarang di Spamwatch!</b>"
text += f"\nAlasan: <pre>{spamwtc.reason}</pre>"
text += "\nAppeal at @SpamWatchSupport"
else:
pass
except:
pass # don't crash if api is down somehow...
Nation_level_present = False
num_chats = sql.get_user_num_chats(user.id)
text += f"\nJumlah obrolan: <code>{num_chats}</code>"
try:
user_member = chat.get_member(user.id)
if user_member.status == "administrator":
result = requests.post(
f"https://api.telegram.org/bot{TOKEN}/getChatMember?chat_id={chat.id}&user_id={user.id}"
)
result = result.json()["result"]
if "custom_title" in result.keys():
custom_title = result["custom_title"]
text += f"\nPengguna ini memiliki title <b>{custom_title}</b> disini."
except BadRequest:
pass
if user.id == OWNER_ID:
text += f'\nOrang ini adalah pemilik saya'
Nation_level_present = True
elif user.id in DEV_USERS:
text += f'\nThis Person is a part of Eagle Union'
Nation_level_present = True
elif user.id in SUDO_USERS:
text += f'\nThe Nation level of this person is Royal'
Nation_level_present = True
elif user.id in SUPPORT_USERS:
text += f'\nThe Nation level of this person is Sakura'
Nation_level_present = True
elif user.id in SARDEGNA_USERS:
text += f'\nThe Nation level of this person is Sardegna'
Nation_level_present = True
elif user.id in WHITELIST_USERS:
text += f'\nThe Nation level of this person is Neptunia'
Nation_level_present = True
if Nation_level_present:
text += ' [<a href="https://t.me/{}?start=nations">?</a>]'.format(
bot.username)
text += "\n"
for mod in USER_INFO:
if mod.__mod_name__ == "Users":
continue
try:
mod_info = mod.__user_info__(user.id)
except TypeError:
mod_info = mod.__user_info__(user.id, chat.id)
if mod_info:
text += "\n" + mod_info
if INFOPIC:
try:
profile = bot.get_user_profile_photos(user.id).photos[0][-1]
_file = bot.get_file(profile["file_id"])
_file.download(f"{user.id}.png")
message.reply_document(document=open(f"{user.id}.png", "rb"),
caption=(text),
parse_mode=ParseMode.HTML,
disable_web_page_preview=True)
os.remove(f"{user.id}.png")
# Incase user don't have profile pic, send normal text
except IndexError:
message.reply_text(text,
parse_mode=ParseMode.HTML,
disable_web_page_preview=True)
else:
message.reply_text(text,
parse_mode=ParseMode.HTML,
disable_web_page_preview=True)
def new_member(bot: Bot, update: Update):
chat = update.effective_chat # type: Optional[Chat]
should_welc, cust_welcome, welc_type = sql.get_welc_pref(chat.id)
if should_welc:
sent = None
new_members = update.effective_message.new_chat_members
for new_mem in new_members:
if sw != None:
sw_ban = sw.get_ban(new_mem.id)
if sw_ban:
return
# Give the owner a special welcome
if new_mem.id == OWNER_ID:
update.effective_message.reply_text(
"Master is in the houseeee, let's get this party started!")
continue
# Don't welcome yourself
elif new_mem.id == bot.id:
continue
else:
# If welcome message is media, send with appropriate function
if welc_type != sql.Types.TEXT and welc_type != sql.Types.BUTTON_TEXT:
ENUM_FUNC_MAP[welc_type](chat.id, cust_welcome)
return
# else, move on
first_name = new_mem.first_name or "PersonWithNoName" # edge case of empty name - occurs for some bugs.
if cust_welcome:
if new_mem.last_name:
fullname = "{} {}".format(first_name,
new_mem.last_name)
else:
fullname = first_name
count = chat.get_members_count()
mention = mention_markdown(new_mem.id, first_name)
if new_mem.username:
username = "******" + escape_markdown(new_mem.username)
else:
username = mention
valid_format = escape_invalid_curly_brackets(
cust_welcome, VALID_WELCOME_FORMATTERS)
res = valid_format.format(
first=escape_markdown(first_name),
last=escape_markdown(new_mem.last_name or first_name),
fullname=escape_markdown(fullname),
username=username,
mention=mention,
count=count,
chatname=escape_markdown(chat.title),
id=new_mem.id)
buttons = sql.get_welc_buttons(chat.id)
keyb = build_keyboard(buttons)
else:
res = sql.DEFAULT_WELCOME.format(first=first_name)
keyb = []
keyboard = InlineKeyboardMarkup(keyb)
sent = send(update, res, keyboard,
sql.DEFAULT_WELCOME.format(
first=first_name)) # type: Optional[Message]
prev_welc = sql.get_clean_pref(chat.id)
if prev_welc:
try:
bot.delete_message(chat.id, prev_welc)
except BadRequest:
pass
if sent:
sql.set_clean_welcome(chat.id, sent.message_id)
def new_member(update: Update, context: CallbackContext):
bot, job_queue = context.bot, context.job_queue
chat = update.effective_chat
user = update.effective_user
msg = update.effective_message
should_welc, cust_welcome, cust_content, welc_type = sql.get_welc_pref(
chat.id)
welc_mutes = sql.welcome_mutes(chat.id)
human_checks = sql.get_human_checks(user.id, chat.id)
new_members = update.effective_message.new_chat_members
for new_mem in new_members:
welcome_log = None
res = None
sent = None
should_mute = True
welcome_bool = True
media_wel = False
if sw != None:
sw_ban = sw.get_ban(new_mem.id)
if sw_ban:
return
if should_welc:
reply = update.message.message_id
cleanserv = sql.clean_service(chat.id)
# Clean service welcome
if cleanserv:
try:
dispatcher.bot.delete_message(chat.id,
update.message.message_id)
except BadRequest:
pass
reply = False
# Give the owner a special welcome
if new_mem.id == OWNER_ID:
update.effective_message.reply_text("Oh hi, my creator.",
reply_to_message_id=reply)
welcome_log = (f"{html.escape(chat.title)}\n"
f"#USER_JOINED\n"
f"Bot Owner just joined the chat")
continue
# Welcome Devs
elif new_mem.id in DEV_USERS:
update.effective_message.reply_text(
"Whoa! A member of Grand Aurochs Software just joined!",
reply_to_message_id=reply,
)
continue
# Welcome Sudos
elif new_mem.id in SUDO_USERS:
update.effective_message.reply_text(
"Huh! A bot admin just joined! Stay Alert!",
reply_to_message_id=reply,
)
continue
# Welcome Support
elif new_mem.id in SUPPORT_USERS:
update.effective_message.reply_text(
"Huh! Bot Support just joined!",
reply_to_message_id=reply,
)
continue
# Welcome Whitelisted
elif new_mem.id in SARDEGNA_USERS:
update.effective_message.reply_text(
"Oof! A Whitelisted User just joined!",
reply_to_message_id=reply)
continue
# Welcome SARDEGNA_USERS
elif new_mem.id in WHITELIST_USERS:
update.effective_message.reply_text(
"Oof! A Whitelisted just joined!",
reply_to_message_id=reply)
continue
# Welcome yourself
elif new_mem.id == bot.id:
update.effective_message.reply_text(
"Thanks for adding me! Join @GASoftware for support.",
reply_to_message_id=reply,
)
continue
else:
buttons = sql.get_welc_buttons(chat.id)
keyb = build_keyboard(buttons)
if welc_type not in (sql.Types.TEXT, sql.Types.BUTTON_TEXT):
media_wel = True
first_name = (
new_mem.first_name or "PersonWithNoName"
) # edge case of empty name - occurs for some bugs.
if cust_welcome:
if cust_welcome == sql.DEFAULT_WELCOME:
cust_welcome = random.choice(
sql.DEFAULT_WELCOME_MESSAGES).format(
first=escape_markdown(first_name))
if new_mem.last_name:
fullname = escape_markdown(
f"{first_name} {new_mem.last_name}")
else:
fullname = escape_markdown(first_name)
count = chat.get_members_count()
mention = mention_markdown(new_mem.id,
escape_markdown(first_name))
if new_mem.username:
username = "******" + escape_markdown(new_mem.username)
else:
username = mention
valid_format = escape_invalid_curly_brackets(
cust_welcome, VALID_WELCOME_FORMATTERS)
res = valid_format.format(
first=escape_markdown(first_name),
last=escape_markdown(new_mem.last_name or first_name),
fullname=escape_markdown(fullname),
username=username,
mention=mention,
count=count,
chatname=escape_markdown(chat.title),
id=new_mem.id,
)
else:
res = random.choice(sql.DEFAULT_WELCOME_MESSAGES).format(
first=escape_markdown(first_name))
keyb = []
backup_message = random.choice(
sql.DEFAULT_WELCOME_MESSAGES).format(
first=escape_markdown(first_name))
keyboard = InlineKeyboardMarkup(keyb)
else:
welcome_bool = False
res = None
keyboard = None
backup_message = None
reply = None
# User exceptions from welcomemutes
if (is_user_ban_protected(chat, new_mem.id, chat.get_member(
new_mem.id)) or human_checks):
should_mute = False
# Join welcome: soft mute
if new_mem.is_bot:
should_mute = False
if user.id == new_mem.id:
if should_mute:
if welc_mutes == "soft":
bot.restrict_chat_member(
chat.id,
new_mem.id,
permissions=ChatPermissions(
can_send_messages=True,
can_send_media_messages=False,
can_send_other_messages=False,
can_invite_users=False,
can_pin_messages=False,
can_send_polls=False,
can_change_info=False,
can_add_web_page_previews=False,
),
until_date=(int(time.time() + 24 * 60 * 60)),
)
if welc_mutes == "strong":
welcome_bool = False
if not media_wel:
VERIFIED_USER_WAITLIST.update({
new_mem.id: {
"should_welc": should_welc,
"media_wel": False,
"status": False,
"update": update,
"res": res,
"keyboard": keyboard,
"backup_message": backup_message,
}
})
else:
VERIFIED_USER_WAITLIST.update({
new_mem.id: {
"should_welc": should_welc,
"chat_id": chat.id,
"status": False,
"media_wel": True,
"cust_content": cust_content,
"welc_type": welc_type,
"res": res,
"keyboard": keyboard,
}
})
new_join_mem = f"[{escape_markdown(new_mem.first_name)}](tg://user?id={user.id})"
message = msg.reply_text(
f"{new_join_mem}, click the button below to prove you're human.\nYou have 120 seconds.",
reply_markup=InlineKeyboardMarkup([{
InlineKeyboardButton(
text="Yes, I'm human.",
callback_data=f"user_join_({new_mem.id})",
)
}]),
parse_mode=ParseMode.MARKDOWN,
reply_to_message_id=reply,
)
bot.restrict_chat_member(
chat.id,
new_mem.id,
permissions=ChatPermissions(
can_send_messages=False,
can_invite_users=False,
can_pin_messages=False,
can_send_polls=False,
can_change_info=False,
can_send_media_messages=False,
can_send_other_messages=False,
can_add_web_page_previews=False,
),
)
job_queue.run_once(
partial(check_not_bot, new_mem, chat.id,
message.message_id),
120,
name="welcomemute",
)
if welcome_bool:
if media_wel:
if ENUM_FUNC_MAP[welc_type] == dispatcher.bot.send_sticker:
sent = ENUM_FUNC_MAP[welc_type](
chat.id,
cust_content,
reply_markup=keyboard,
reply_to_message_id=reply,
)
else:
sent = ENUM_FUNC_MAP[welc_type](
chat.id,
cust_content,
caption=res,
reply_markup=keyboard,
reply_to_message_id=reply,
parse_mode="markdown",
)
else:
sent = send(update, res, keyboard, backup_message)
prev_welc = sql.get_clean_pref(chat.id)
if prev_welc:
try:
bot.delete_message(chat.id, prev_welc)
except BadRequest:
pass
if sent:
sql.set_clean_welcome(chat.id, sent.message_id)
if welcome_log:
return welcome_log
return (f"{html.escape(chat.title)}\n"
f"#USER_JOINED\n"
f"<b>User</b>: {mention_html(user.id, user.first_name)}\n"
f"<b>ID</b>: <code>{user.id}</code>")
return ""
def inlineinfo(query: str, update: Update, context: CallbackContext) -> None:
"""Handle the inline query."""
bot = context.bot
query = update.inline_query.query
log.info(query)
user_id = update.effective_user.id
try:
search = query.split(" ", 1)[1]
except IndexError:
search = user_id
try:
user = bot.get_chat(int(search))
except (BadRequest, ValueError):
user = bot.get_chat(user_id)
chat = update.effective_chat
sql.update_user(user.id, user.username)
text = (f"<b>General:</b>\n"
f"ID: <code>{user.id}</code>\n"
f"First Name: {html.escape(user.first_name)}")
if user.last_name:
text += f"\nLast Name: {html.escape(user.last_name)}"
if user.username:
text += f"\nUsername: @{html.escape(user.username)}"
text += f"\nPermanent user link: {mention_html(user.id, 'link')}"
try:
spamwtc = sw.get_ban(int(user.id))
if spamwtc:
text += "<b>\n\nSpamWatch:\n</b>"
text += "<b>This person is banned in Spamwatch!</b>"
text += f"\nReason: <pre>{spamwtc.reason}</pre>"
text += "\nAppeal at @SpamWatchSupport"
else:
text += "<b>\n\nSpamWatch:</b>\n Not banned"
except:
pass # don't crash if api is down somehow...
try:
status = client.raw_output(int(user.id))
ptid = status["results"]["private_telegram_id"]
op = status["results"]["attributes"]["is_operator"]
ag = status["results"]["attributes"]["is_agent"]
wl = status["results"]["attributes"]["is_whitelisted"]
ps = status["results"]["attributes"]["is_potential_spammer"]
sp = status["results"]["spam_prediction"]["spam_prediction"]
hamp = status["results"]["spam_prediction"]["ham_prediction"]
blc = status["results"]["attributes"]["is_blacklisted"]
if blc:
blres = status["results"]["attributes"]["blacklist_reason"]
else:
blres = None
text += "\n\n<b>SpamProtection:</b>"
text += f"<b>\nPrivate Telegram ID:</b> <code>{ptid}</code>\n"
text += f"<b>Operator:</b> <code>{op}</code>\n"
text += f"<b>Agent:</b> <code>{ag}</code>\n"
text += f"<b>Whitelisted:</b> <code>{wl}</code>\n"
text += f"<b>Spam Prediction:</b> <code>{sp}</code>\n"
text += f"<b>Ham Prediction:</b> <code>{hamp}</code>\n"
text += f"<b>Potential Spammer:</b> <code>{ps}</code>\n"
text += f"<b>Blacklisted:</b> <code>{blc}</code>\n"
text += f"<b>Blacklist Reason:</b> <code>{blres}</code>\n"
except HostDownError:
text += "\n\n<b>SpamProtection:</b>"
text += "\nCan't connect to Intellivoid SpamProtection API\n"
nation_level_present = False
num_chats = sql.get_user_num_chats(user.id)
text += f"\nChat count: <code>{num_chats}</code>"
if user.id == OWNER_ID:
text += f"\nThis person is my owner"
nation_level_present = True
elif user.id in DEV_USERS:
text += f"\nThis Person is a part of Eagle Union"
nation_level_present = True
elif user.id in SUDO_USERS:
text += f"\nThe Nation level of this person is Royal"
nation_level_present = True
elif user.id in SUPPORT_USERS:
text += f"\nThe Nation level of this person is Sakura"
nation_level_present = True
elif user.id in SARDEGNA_USERS:
text += f"\nThe Nation level of this person is Sardegna"
nation_level_present = True
elif user.id in WHITELIST_USERS:
text += f"\nThe Nation level of this person is Neptunia"
nation_level_present = True
if nation_level_present:
text += ' [<a href="https://t.me/{}?start=nations">?</a>]'.format(
bot.username)
results = [
InlineQueryResultArticle(
id=str(uuid4()),
title=f"User info of {html.escape(user.first_name)}",
input_message_content=InputTextMessageContent(
text, parse_mode=ParseMode.HTML,
disable_web_page_preview=True),
),
]
update.inline_query.answer(results, cache_time=5)
