def cleanservice(bot: Bot, update: Update, args: List[str]) -> str:
chat = update.effective_chat # type: Optional[Chat]
if chat.type != chat.PRIVATE:
if len(args) >= 1:
var = args[0]
if (var == "no" or var == "off"):
sql.set_clean_service(chat.id, False)
update.effective_message.reply_text(
'Welcome clean service is : off')
elif (var == "yes" or var == "on"):
sql.set_clean_service(chat.id, True)
update.effective_message.reply_text(
'Welcome clean service is : on')
else:
update.effective_message.reply_text(
"Invalid option", parse_mode=ParseMode.MARKDOWN)
else:
update.effective_message.reply_text("Usage is on/yes or off/no",
parse_mode=ParseMode.MARKDOWN)
else:
curr = sql.clean_service(chat.id)
if curr:
update.effective_message.reply_text(
'Welcome clean service is : on', parse_mode=ParseMode.MARKDOWN)
else:
update.effective_message.reply_text(
'Welcome clean service is : off',
parse_mode=ParseMode.MARKDOWN)
def cleanservice(update: Update, context: CallbackContext) -> str:
args = context.args
chat = update.effective_chat # type: Optional[Chat]
if chat.type == chat.PRIVATE:
curr = sql.clean_service(chat.id)
if curr:
update.effective_message.reply_text(
"Welcome clean service is : on", parse_mode=ParseMode.MARKDOWN)
else:
update.effective_message.reply_text(
"Welcome clean service is : off",
parse_mode=ParseMode.MARKDOWN)
elif len(args) >= 1:
var = args[0]
if var in ("no", "off"):
sql.set_clean_service(chat.id, False)
update.effective_message.reply_text(
"Welcome clean service is : off")
elif var in ("yes", "on"):
sql.set_clean_service(chat.id, True)
update.effective_message.reply_text(
"Welcome clean service is : on")
else:
update.effective_message.reply_text("Invalid option",
parse_mode=ParseMode.MARKDOWN)
else:
update.effective_message.reply_text("Usage is on/yes or off/no",
parse_mode=ParseMode.MARKDOWN)
def cleanservice(update, context):
chat = update.effective_chat
args = context.args
if chat.type != chat.PRIVATE:
if len(args) >= 1:
var = args[0]
if var == "no" or var == "off":
sql.set_clean_service(chat.id, False)
update.effective_message.reply_text(
"Turned off service messages cleaning.")
elif var == "yes" or var == "on":
sql.set_clean_service(chat.id, True)
update.effective_message.reply_text(
"Turned on service messages cleaning!")
else:
update.effective_message.reply_text(
"Invalid option", parse_mode=ParseMode.MARKDOWN)
else:
update.effective_message.reply_text("Usage is on/yes or off/no",
parse_mode=ParseMode.MARKDOWN)
else:
curr = sql.clean_service(chat.id)
if curr:
update.effective_message.reply_text(
"Welcome clean service is : on", parse_mode=ParseMode.MARKDOWN)
else:
update.effective_message.reply_text(
"Welcome clean service is : off",
parse_mode=ParseMode.MARKDOWN)
def cleanservice(bot: Bot, update: Update, args: List[str]) -> str:
chat = update.effective_chat # type: Optional[Chat]
if chat.type != chat.PRIVATE:
if len(args) >= 1:
var = args[0]
if (var == "no" or var == "off"):
sql.set_clean_service(chat.id, False)
update.effective_message.reply_text(
tld(chat.id, 'welcome_clean_service_off'))
elif (var == "yes" or var == "on"):
sql.set_clean_service(chat.id, True)
update.effective_message.reply_text(
tld(chat.id, 'welcome_clean_service_on'))
else:
update.effective_message.reply_text(
tld(chat.id, 'common_invalid_arg'),
parse_mode=ParseMode.MARKDOWN)
else:
update.effective_message.reply_text(tld(chat.id,
'common_invalid_arg'),
parse_mode=ParseMode.MARKDOWN)
else:
curr = sql.clean_service(chat.id)
if curr:
update.effective_message.reply_text(tld(
chat.id, 'welcome_clean_service_on'),
parse_mode=ParseMode.MARKDOWN)
else:
update.effective_message.reply_text(tld(
chat.id, 'welcome_clean_service_off'),
parse_mode=ParseMode.MARKDOWN)
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:
# 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("Its My 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,
escape_markdown(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)
#Clean service goodbye
if sql.clean_service(chat.id) == True:
bot.delete_message(chat.id, update.message.message_id)
def send(update, message, keyboard, backup_message):
chat = update.effective_chat
cleanserv = sql.clean_service(chat.id)
reply = update.message.message_id
# Clean service welcome
if cleanserv:
try:
dispatcher.bot.delete_message(chat.id, update.message.message_id)
except BadRequest:
pass
reply = False
try:
msg = update.effective_message.reply_text(
message,
parse_mode=ParseMode.MARKDOWN,
reply_markup=keyboard,
reply_to_message_id=reply)
except BadRequest as excp:
if excp.message == "Button_url_invalid":
msg = update.effective_message.reply_text(
markdown_parser(
backup_message +
"\nNote: the current message has an invalid url "
"in one of its buttons. Please update."),
parse_mode=ParseMode.MARKDOWN,
reply_to_message_id=reply)
elif excp.message == "Unsupported url protocol":
msg = update.effective_message.reply_text(
markdown_parser(
backup_message +
"\nNote: the current message has buttons which "
"use url protocols that are unsupported by "
"telegram. Please update."),
parse_mode=ParseMode.MARKDOWN,
reply_to_message_id=reply)
elif excp.message == "Wrong url host":
msg = update.effective_message.reply_text(
markdown_parser(
backup_message +
"\nNote: the current message has some bad urls. "
"Please update."),
parse_mode=ParseMode.MARKDOWN,
reply_to_message_id=reply)
LOGGER.warning(message)
LOGGER.warning(keyboard)
LOGGER.exception("Could not parse! got invalid url host errors")
else:
msg = update.effective_message.reply_text(
markdown_parser(backup_message +
"\nNote: An error occured when sending the "
"custom message. Please update."),
parse_mode=ParseMode.MARKDOWN,
reply_to_message_id=reply)
LOGGER.exception()
return msg
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 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 welcome(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat # type: Optional[Chat]
# if no args, show current replies.
if len(args) == 0 or args[0].lower() == "noformat":
noformat = args and args[0].lower() == "noformat"
pref, welcome_m, cust_content, welcome_type = sql.get_welc_pref(
chat.id)
prev_welc = sql.get_clean_pref(chat.id)
if prev_welc:
prev_welc = True
else:
prev_welc = False
cleanserv = sql.clean_service(chat.id)
getcur, cur_value, cust_text = sql.welcome_security(chat.id)
if getcur:
welcsec = "True "
else:
welcsec = "False "
if cur_value[:1] == "0":
welcsec += tld(chat.id, 'welcome_mute_time_short_none')
else:
welcsec += tld(chat.id,
'welcome_mute_time_short').format(cur_value)
text = tld(chat.id,
'welcome_settings').format(pref, prev_welc, cleanserv,
welcsec, cust_text)
update.effective_message.reply_text(text,
parse_mode=ParseMode.MARKDOWN)
if welcome_type == sql.Types.BUTTON_TEXT or welcome_type == sql.Types.TEXT:
buttons = sql.get_welc_buttons(chat.id)
if noformat:
welcome_m += revert_buttons(buttons)
update.effective_message.reply_text(welcome_m)
else:
keyb = build_keyboard_parser(bot, chat.id, buttons)
keyboard = InlineKeyboardMarkup(keyb)
send(update, welcome_m, keyboard, sql.DEFAULT_WELCOME)
else:
buttons = sql.get_welc_buttons(chat.id)
if noformat:
welcome_m += revert_buttons(buttons)
ENUM_FUNC_MAP[welcome_type](chat.id,
cust_content,
caption=welcome_m)
else:
keyb = build_keyboard_parser(bot, chat.id, buttons)
keyboard = InlineKeyboardMarkup(keyb)
ENUM_FUNC_MAP[welcome_type](chat.id,
cust_content,
caption=welcome_m,
reply_markup=keyboard,
parse_mode=ParseMode.HTML,
disable_web_page_preview=True)
elif len(args) >= 1:
if args[0].lower() in ("on", "yes"):
sql.set_welc_preference(str(chat.id), True)
update.effective_message.reply_text(
tld(chat.id, 'welcome_greet_set_on'))
elif args[0].lower() in ("off", "no"):
sql.set_welc_preference(str(chat.id), False)
update.effective_message.reply_text(
tld(chat.id, 'welcome_greet_set_off'))
else:
# idek what you're writing, say yes or no
update.effective_message.reply_text(
tld(chat.id, 'common_invalid_arg'))
async def delete_service(event):
clean = sql.clean_service(event.chat_id)
if not clean:
return
await event.delete()
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 send(update, message, keyboard, backup_message):
chat = update.effective_chat
cleanserv = sql.clean_service(chat.id)
reply = update.message.message_id
# Clean service welcome
if cleanserv:
try:
dispatcher.bot.delete_message(chat.id, update.message.message_id)
except BadRequest:
pass
reply = False
try:
msg = update.effective_message.reply_text(
message,
parse_mode=ParseMode.MARKDOWN,
reply_markup=keyboard,
reply_to_message_id=reply,
)
except BadRequest as excp:
if excp.message == 'Button_url_invalid':
msg = update.effective_message.reply_text(
markdown_parser((
backup_message +
'\nNote: the current message has an invalid url in one of its buttons. Please update.'
)),
parse_mode=ParseMode.MARKDOWN,
reply_to_message_id=reply,
)
elif excp.message == 'Have no rights to send a message':
return
elif excp.message == 'Reply message not found':
msg = update.effective_message.reply_text(
message,
parse_mode=ParseMode.MARKDOWN,
reply_markup=keyboard,
quote=False,
)
elif excp.message == 'Unsupported url protocol':
msg = update.effective_message.reply_text(
markdown_parser((
backup_message +
'\nNote: the current message has buttons which use url protocols that are unsupported by telegram. Please update.'
)),
parse_mode=ParseMode.MARKDOWN,
reply_to_message_id=reply,
)
elif excp.message == 'Wrong url host':
msg = update.effective_message.reply_text(
markdown_parser((
backup_message +
'\nNote: the current message has some bad urls. Please update.'
)),
parse_mode=ParseMode.MARKDOWN,
reply_to_message_id=reply,
)
log.warning(message)
log.warning(keyboard)
log.exception('Could not parse! got invalid url host errors')
else:
msg = update.effective_message.reply_text(
markdown_parser((
backup_message +
'\nNote: An error occured when sending the custom message. Please update.'
)),
parse_mode=ParseMode.MARKDOWN,
reply_to_message_id=reply,
)
log.exception()
return msg
def left_member(bot: Bot, update: Update):
chat = update.effective_chat # type: Optional[Chat]
should_goodbye, cust_goodbye, cust_content, goodbye_type = sql.get_gdbye_pref(
chat.id)
cust_goodbye = markdown_to_html(cust_goodbye)
if should_goodbye:
left_mem = update.effective_message.left_chat_member
if left_mem:
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(
tld(chat.id, 'welcome_bot_owner_left'))
return
# if media goodbye, use appropriate function for it
if goodbye_type != sql.Types.TEXT and goodbye_type != sql.Types.BUTTON_TEXT:
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
# Formatting text
first_name = left_mem.first_name or "PersonWithNoName" # edge case of empty name - occurs for some bugs.
if left_mem.last_name:
fullname = "{} {}".format(first_name, left_mem.last_name)
else:
fullname = first_name
count = chat.get_members_count()
mention = mention_html(left_mem.id, first_name)
if left_mem.username:
username = "******" + escape(left_mem.username)
else:
username = mention
rules = "http://t.me/" + bot.username + "?start=" + str(
chat.id)
buttons = sql.get_gdbye_buttons(chat.id)
keyb = build_keyboard_parser(bot, chat.id, buttons)
formatted_text = cust_goodbye.format(
first=escape(first_name),
last=escape(left_mem.last_name or first_name),
fullname=escape(fullname),
username=username,
mention=mention,
count=count,
chatname=escape(chat.title),
id=left_mem.id,
rules=keyb.append(
[InlineKeyboardButton("Rules", url=rules)]))
# Build keyboard
keyboard = InlineKeyboardMarkup(keyb)
# Send message
ENUM_FUNC_MAP[goodbye_type](chat.id,
cust_content,
caption=formatted_text,
reply_markup=keyboard,
parse_mode="html",
reply_to_message_id=reply)
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_html(left_mem.id, first_name)
if left_mem.username:
username = "******" + escape(left_mem.username)
else:
username = mention
rules = "http://t.me/" + bot.username + "?start=" + str(
chat.id)
buttons = sql.get_gdbye_buttons(chat.id)
keyb = build_keyboard_parser(bot, chat.id, buttons)
valid_format = escape_invalid_curly_brackets(
cust_goodbye, VALID_WELCOME_FORMATTERS)
res = valid_format.format(first=escape(first_name),
last=escape(left_mem.last_name
or first_name),
fullname=escape(fullname),
username=username,
mention=mention,
count=count,
chatname=escape(chat.title),
id=left_mem.id,
rules=keyb.append([
InlineKeyboardButton("Rules",
url=rules)
]))
keyb = build_keyboard_parser(bot, chat.id, buttons)
else:
res = sql.DEFAULT_GOODBYE
keyb = []
keyboard = InlineKeyboardMarkup(keyb)
send(update, res, keyboard, sql.DEFAULT_GOODBYE)
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:
# Give the owner a special welcome
if new_mem.id == OWNER_ID:973682688
update.effective_message.reply_text("Yeah Chef, lass' uns diese Party rocken!")
continue
# Give start information when add bot to group
elif new_mem.id == bot.id:
continue
update.effective_message.reply_text("Danka, dass du mich hinzugefügt hast!")
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]
#Clean service welcome
if sql.clean_service(chat.id) == True:
bot.delete_message(chat.id, update.message.message_id)
#If user ban protected don't apply security on him
if is_user_ban_protected(chat, new_mem.id, chat.get_member(new_mem.id)):
continue
#Security soft mode
if sql.welcome_security(chat.id) == "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)))
#Add "I'm not bot button if enabled hard security"
if sql.welcome_security(chat.id) == "hard":
try:
#Mute user
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)
update.effective_message.reply_text("Hi {}, Klicke auf den Knopf unten, um zu bestätigen, dass du kein Bot bist!.".format(new_mem.first_name),
reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton(text="Ich bin kein Bot!",
callback_data="check_bot_({})".format(new_mem.id)) ]]))
except BadRequest:
update.effective_message.reply_text("Ich benötige die Berechtigung, Nutzer stummzuschalten, um Welcomesecurity zu aktivieren! :/")
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]
delete_join(bot, update)
#Clean service welcome
if sql.clean_service(chat.id) == True:
bot.delete_message(chat.id, update.message.message_id)
#If user ban protected don't apply security on him
if is_user_ban_protected(chat, new_mem.id, chat.get_member(new_mem.id)):
continue
#Security soft mode
if sql.welcome_security(chat.id) == "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)))
#Add "I'm not bot button if enabled hard security"
if sql.welcome_security(chat.id) == "hard":
update.effective_message.reply_text("Hi {}, click on button below for been unmuted.".format(new_mem.first_name),
reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton(text="I'm not a bot!",
callback_data="check_bot_({})".format(new_mem.id)) ]]))
def left_member(update, context):
chat = update.effective_chat
should_goodbye, cust_goodbye, goodbye_type = sql.get_gdbye_pref(chat.id)
cust_goodbye = markdown_to_html(cust_goodbye)
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:
# Ignore gbanned users
if is_user_gbanned(left_mem.id):
return
# Ignore spamwatch banned users
try:
sw = spamwtc.get_ban(int(left_mem.id))
if sw:
return
except BaseException:
pass
# Ignore bot being kicked
if left_mem.id == context.bot.id:
return
# Give the owner a special goodbye
if left_mem.id == OWNER_ID:
update.effective_message.reply_text("RIP Master",
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 left_mem.last_name:
fullname = "{} {}".format(first_name, left_mem.last_name)
else:
fullname = first_name
count = chat.get_members_count()
mention = mention_html(left_mem.id, first_name)
if left_mem.username:
username = "******" + escape(left_mem.username)
else:
username = mention
valid_format = escape_invalid_curly_brackets(
cust_goodbye, VALID_WELCOME_FORMATTERS)
res = valid_format.format(
first=escape(first_name),
last=escape(left_mem.last_name or first_name),
fullname=escape(fullname),
username=username,
mention=mention,
count=count,
chatname=escape(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 new_member(update, context):
chat = update.effective_chat
user = update.effective_user
msg = update.effective_message
chat_name = chat.title or chat.first or chat.username
should_welc, cust_welcome, cust_content, welc_type = sql.get_welc_pref(
chat.id)
cust_welcome = markdown_to_html(cust_welcome)
welc_mutes = sql.welcome_mutes(chat.id)
user_id = user.id
human_checks = sql.get_human_checks(user_id, chat.id)
if should_welc:
sent = None
new_members = update.effective_message.new_chat_members
for new_mem in new_members:
reply = update.message.message_id
cleanserv = sql.clean_service(chat.id)
# Clean service welcome
if cleanserv:
reply = False
try:
dispatcher.bot.delete_message(chat.id,
update.message.message_id)
except BadRequest:
pass
# Ignore spamwatch banned users
try:
sw = spamwtc.get_ban(int(new_mem.id))
if sw:
return
except Exception:
pass
# Ignore gbanned users
if is_user_gbanned(new_mem.id):
return
# Give the owner a special welcome
if new_mem.id == OWNER_ID:
update.effective_message.reply_text(
"My master joined ur chat !",
reply_to_message_id=reply,
)
continue
# Give the DEV a special welcome
if new_mem.id in DEV_USERS:
update.effective_message.reply_text(
"My Dev Here,All welcome him ",
reply_to_message_id=reply,
)
continue
# Make bot greet admins
if new_mem.id == context.bot.id:
update.effective_message.reply_text(
"Hey {}, I'm {}! Thank you for adding me to {}".format(
user.first_name, context.bot.first_name, chat_name),
reply_to_message_id=reply,
)
context.bot.send_message(
MESSAGE_DUMP,
"Saber have been added to <pre>{}</pre> with ID: \n<pre>{}</pre>"
.format(chat.title, chat.id),
parse_mode=ParseMode.HTML,
)
else:
# If welcome message is media, send with appropriate function
if welc_type != sql.Types.TEXT and welc_type != sql.Types.BUTTON_TEXT:
# edge case of empty name - occurs for some bugs.
first_name = new_mem.first_name or "PersonWithNoName"
# Start formating text
if new_mem.last_name:
fullname = "{} {}".format(first_name,
new_mem.last_name)
else:
fullname = first_name
count = chat.get_members_count()
mention = mention_html(new_mem.id, first_name)
if new_mem.username:
username = "******" + escape(new_mem.username)
else:
username = mention
valid_format = escape_invalid_curly_brackets(
cust_welcome, VALID_WELCOME_FORMATTERS)
formated_text = valid_format.format(
first=escape(first_name),
last=escape(new_mem.last_name or first_name),
fullname=escape(fullname),
username=username,
mention=mention,
count=count,
chatname=escape(chat.title),
id=new_mem.id,
)
# build the button
buttons = sql.get_welc_buttons(chat.id)
if buttons:
keyb = build_keyboard_parser(context.bot, chat.id,
buttons)
keyboard = InlineKeyboardMarkup(keyb)
else:
keyboard = None
sent = ENUM_FUNC_MAP[welc_type](
chat.id,
cust_content,
caption=formated_text,
reply_markup=keyboard,
parse_mode="html",
reply_to_message_id=reply,
)
# else, move on
else:
# edge case of empty name - occurs for some bugs.
first_name = new_mem.first_name or "PersonWithNoName"
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_html(new_mem.id, first_name)
if new_mem.username:
username = "******" + escape(new_mem.username)
else:
username = mention
valid_format = escape_invalid_curly_brackets(
cust_welcome, VALID_WELCOME_FORMATTERS)
res = valid_format.format(
first=escape(first_name),
last=escape(new_mem.last_name or first_name),
fullname=escape(fullname),
username=username,
mention=mention,
count=count,
chatname=escape(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),
)
if (is_user_ban_protected(
chat,
new_mem.id,
chat.get_member(new_mem.id) or new_mem.is_bot,
) or human_checks):
continue
# Join welcome: soft mute
if welc_mutes == "soft":
context.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)),
),
)
# Join welcome: strong mute
if welc_mutes == "strong":
new_join_mem = "Hey {}!".format(
mention_html(user.id, new_mem.first_name))
msg.reply_text(
"{}\nClick the button below to start talking.".
format(new_join_mem),
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton(
text="Yus, I'm a human",
callback_data="user_join_({})".format(
new_mem.id),
)
]]),
parse_mode=ParseMode.HTML,
reply_to_message_id=reply,
)
context.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,
),
)
prev_welc = sql.get_clean_pref(chat.id)
if prev_welc:
try:
context.bot.delete_message(chat.id, prev_welc)
except BadRequest:
pass
if sent:
sql.set_clean_welcome(chat.id, sent.message_id)
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:
# 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
# Give start information when add bot to group
elif 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)
continue
update.effective_message.reply_text("Thanks for adding me!")
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]
#Clean service welcome
if sql.clean_service(chat.id) == True:
bot.delete_message(chat.id, update.message.message_id)
#If user ban protected don't apply security on him
if is_user_ban_protected(chat, new_mem.id,
chat.get_member(new_mem.id)):
continue
#Security soft mode
if sql.welcome_security(chat.id) == "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)))
#Add "I'm not bot button if enabled hard security"
if sql.welcome_security(chat.id) == "hard":
update.effective_message.reply_text(
"Hi {}, click on button below to prove you're human.".
format(new_mem.first_name),
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton(
text="I'm not a bot!",
callback_data="check_bot_({})".format(
new_mem.id))
]]))
#Mute user
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)
prev_welc = sql.get_clean_pref(chat.id)
if prev_welc:
try:
bot.delete_message(chat.id, prev_welc)
except BadRequest as excp:
pass
if sent:
sql.set_clean_welcome(chat.id, sent.message_id)
def new_member(bot: Bot, update: Update):
chat = update.effective_chat # type: Optional[Chat]
should_welc, cust_welcome, cust_content, welc_type = sql.get_welc_pref(
chat.id)
cust_welcome = markdown_to_html(cust_welcome)
if should_welc:
sent = None
new_members = update.effective_message.new_chat_members
for new_mem in new_members:
# Give start information when add bot to group
if is_user_gbanned(new_mem.id):
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)
bot.send_message(chat.id, tld(chat.id, 'welcome_added_to_grp'))
else:
if is_user_gbanned(new_mem.id):
return
# If welcome message is media, send with appropriate function
if welc_type != sql.Types.TEXT and welc_type != sql.Types.BUTTON_TEXT:
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
# Formatting text
first_name = new_mem.first_name or "PersonWithNoName" # edge case of empty name - occurs for some bugs.
if new_mem.last_name:
fullname = "{} {}".format(first_name,
new_mem.last_name)
else:
fullname = first_name
count = chat.get_members_count()
mention = mention_html(new_mem.id, first_name)
if new_mem.username:
username = "******" + escape(new_mem.username)
else:
username = mention
rules = "http://t.me/" + bot.username + "?start=" + str(
chat.id)
# Build keyboard
buttons = sql.get_welc_buttons(chat.id)
keyb = build_keyboard_parser(bot, chat.id, buttons)
formatted_text = cust_welcome.format(
first=escape(first_name),
last=escape(new_mem.last_name or first_name),
fullname=escape(fullname),
username=username,
mention=mention,
count=count,
chatname=escape(chat.title),
id=new_mem.id,
rules=keyb.append(
[InlineKeyboardButton("Rules", url=rules)]))
getsec, mutetime, custom_text = sql.welcome_security(
chat.id)
member = chat.get_member(new_mem.id)
# If user ban protected don't apply security on him
if is_user_ban_protected(chat, new_mem.id,
chat.get_member(new_mem.id)):
pass
elif getsec:
# If mute time is turned on
if mutetime:
if mutetime[:1] == "0":
if member.can_send_messages is None or member.can_send_messages:
try:
bot.restrict_chat_member(
chat.id,
new_mem.id,
can_send_messages=False)
canrest = True
except BadRequest:
canrest = False
else:
canrest = False
else:
mutetime = extract_time(
update.effective_message, mutetime)
if member.can_send_messages is None or member.can_send_messages:
try:
bot.restrict_chat_member(
chat.id,
new_mem.id,
until_date=mutetime,
can_send_messages=False)
canrest = True
except BadRequest:
canrest = False
else:
canrest = False
# If security welcome is turned on
if canrest:
sql.add_to_userlist(chat.id, new_mem.id)
keyb.append([
InlineKeyboardButton(
text=str(custom_text),
callback_data="check_bot_({})".format(
new_mem.id))
])
keyboard = InlineKeyboardMarkup(keyb)
# Send message
ENUM_FUNC_MAP[welc_type](chat.id,
cust_content,
caption=formatted_text,
reply_markup=keyboard,
parse_mode="html",
reply_to_message_id=reply)
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_html(new_mem.id, first_name)
if new_mem.username:
username = "******" + escape(new_mem.username)
else:
username = mention
rules = "http://t.me/" + bot.username + "?start=" + str(
chat.id)
valid_format = escape_invalid_curly_brackets(
cust_welcome, VALID_WELCOME_FORMATTERS)
buttons = sql.get_welc_buttons(chat.id)
keyb = build_keyboard_parser(bot, chat.id, buttons)
res = valid_format.format(
first=escape(first_name),
last=escape(new_mem.last_name or first_name),
fullname=escape(fullname),
username=username,
mention=mention,
count=count,
chatname=escape(chat.title),
id=new_mem.id,
rules=keyb.append(
[InlineKeyboardButton("Rules", url=rules)]))
else:
res = sql.DEFAULT_WELCOME.format(first=first_name)
keyb = []
getsec, mutetime, custom_text = sql.welcome_security(chat.id)
member = chat.get_member(new_mem.id)
# If user ban protected don't apply security on him
if is_user_ban_protected(chat, new_mem.id,
chat.get_member(new_mem.id)):
pass
elif getsec:
if mutetime:
if mutetime[:1] == "0":
if member.can_send_messages is None or member.can_send_messages:
try:
bot.restrict_chat_member(
chat.id,
new_mem.id,
can_send_messages=False)
canrest = True
except BadRequest:
canrest = False
else:
canrest = False
else:
mutetime = extract_time(update.effective_message,
mutetime)
if member.can_send_messages is None or member.can_send_messages:
try:
bot.restrict_chat_member(
chat.id,
new_mem.id,
until_date=mutetime,
can_send_messages=False)
canrest = True
except BadRequest:
canrest = False
else:
canrest = False
if canrest:
sql.add_to_userlist(chat.id, new_mem.id)
keyb.append([
InlineKeyboardButton(
text=str(custom_text),
callback_data="check_bot_({})".format(
new_mem.id))
])
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 as excp:
pass
if sent:
sql.set_clean_welcome(chat.id, sent.message_id)
