def get_exception(excp, filt, chat):
if excp.message == "Protokol url tidak didukung":
return "Anda tampaknya mencoba menggunakan protokol URL yang tidak didukung. Telegram tidak mendukung kunci untuk beberapa protokol, seperti tg://. Silahkan coba lagi!"
elif excp.message == "Pesan balasan tidak ditemukan":
return "tak ada jawaban"
else:
LOGGER.warning("Pesan %s tidak dapat diurai", str(filt.reply))
LOGGER.exception("Tidak dapat mengurai filter %s dalam obrolan %s",
str(filt.keyword), str(chat.id))
return "Data ini tidak dapat dikirim karena formatnya salah."
def import_data(update, context):
msg = update.effective_message
chat = update.effective_chat
user = update.effective_user
# TODO: izinkan mengunggah dokumen dengan perintah, bukan hanya sebagai balasan
# hanya bekerja dengan seorang dokter
conn = connected(context.bot, update, chat, user.id, need_admin=True)
if conn:
chat = dispatcher.bot.getChat(conn)
chat_name = dispatcher.bot.getChat(conn).title
else:
if update.effective_message.chat.type == "private":
update.effective_message.reply_text("Ini adalah perintah khusus grup!")
return ""
chat = update.effective_chat
chat_name = update.effective_message.chat.title
if msg.reply_to_message and msg.reply_to_message.document:
try:
file_info = context.bot.get_file(msg.reply_to_message.document.file_id)
except BadRequest:
msg.reply_text(
"Coba unduh dan unggah file sendiri lagi, Yang ini sepertinya rusak bagi saya!"
)
return
with BytesIO() as file:
file_info.download(out=file)
file.seek(0)
data = json.load(file)
# hanya mengimpor satu grup
if len(data) > 1 and str(chat.id) not in data:
msg.reply_text(
"Ada lebih dari satu grup di file ini dan chat.id tidak sama! Bagaimana saya bisa mengimpornya?"
)
return
# Periksa apakah cadangan obrolan ini
try:
if data.get(str(chat.id)) is None:
if conn:
text = "Cadangan berasal dari obrolan lain, saya tidak dapat mengembalikan obrolan lain ke obrolan *{}*".format(
chat_name
)
else:
text = "Cadangan berasal dari obrolan lain, saya tidak dapat mengembalikan obrolan lain ke obrolan ini"
return msg.reply_text(text, parse_mode="markdown")
except Exception:
return msg.reply_text("Ada masalah saat mengimpor data!")
# Periksa apakah cadangan dari diri sendiri
try:
if str(context.bot.id) != str(data[str(chat.id)]["bot"]):
return msg.reply_text(
"Cadangan dari bot lain yang tidak disarankan dapat menyebabkan masalah, dokumen, foto, video, audio, catatan mungkin tidak berfungsi sebagaimana mestinya."
)
except Exception:
pass
# Pilih sumber data
if str(chat.id) in data:
data = data[str(chat.id)]["hashes"]
else:
data = data[list(data.keys())[0]]["hashes"]
try:
for mod in DATA_IMPORT:
mod.__import_data__(str(chat.id), data)
except Exception:
msg.reply_text(
f"Terjadi kesalahan saat memulihkan data Anda. Prosesnya gagal. Jika Anda mengalami masalah dengan ini, harap bawa ke @{SUPPORT_CHAT}"
)
LOGGER.exception(
"Impor untuk obrolan %s dengan nama %s gagal.",
str(chat.id),
str(chat.title),
)
return
# TODO: beberapa logika tautan itu
# CATATAN: pertimbangkan hal-hal perizinan default?
if conn:
text = "Cadangan sepenuhnya dipulihkan pada *{}*.".format(chat_name)
else:
text = "Cadangan sepenuhnya dipulihkan"
msg.reply_text(text, parse_mode="markdown")
def reply_filter(update, context):
chat = update.effective_chat
message = update.effective_message
if not update.effective_user or update.effective_user.id == 777000:
return
to_match = extract_text(message)
if not to_match:
return
chat_filters = sql.get_chat_triggers(chat.id)
for keyword in chat_filters:
pattern = r"( |^|[^\w])" + re.escape(keyword) + r"( |$|[^\w])"
if re.search(pattern, to_match, flags=re.IGNORECASE):
if MessageHandlerChecker.check_user(update.effective_user.id):
return
filt = sql.get_filter(chat.id, keyword)
if filt.reply == "harus ada balasan baru":
buttons = sql.get_buttons(chat.id, filt.keyword)
keyb = build_keyboard_parser(context.bot, chat.id, buttons)
keyboard = InlineKeyboardMarkup(keyb)
VALID_WELCOME_FORMATTERS = [
"first",
"last",
"fullname",
"username",
"id",
"chatname",
"mention",
]
if filt.reply_text:
if "%%%" in filt.reply_text:
split = filt.reply_text.split("%%%")
if all(split):
text = random.choice(split)
else:
text = filt.reply_text
else:
text = filt.reply_text
if text.startswith("~!") and text.endswith("!~"):
sticker_id = text.replace("~!", "").replace("!~", "")
try:
context.bot.send_sticker(
chat.id,
sticker_id,
reply_to_message_id=message.message_id,
)
return
except BadRequest as excp:
if (excp.message ==
"Pengenal file jarak jauh yang salah ditentukan: padding yang salah dalam string"
):
context.bot.send_message(
chat.id,
"Pesan tidak dapat dikirim, Apakah id stiker valid?",
)
return
else:
LOGGER.exception("Kesalahan dalam filter: " +
excp.message)
return
valid_format = escape_invalid_curly_brackets(
text, VALID_WELCOME_FORMATTERS)
if valid_format:
filtext = valid_format.format(
first=escape(message.from_user.first_name),
last=escape(message.from_user.last_name
or message.from_user.first_name),
fullname=" ".join(
[
escape(message.from_user.first_name),
escape(message.from_user.last_name),
] if message.from_user.last_name else
[escape(message.from_user.first_name)]),
username="******" + escape(message.from_user.username)
if message.from_user.username else mention_html(
message.from_user.id,
message.from_user.first_name),
mention=mention_html(message.from_user.id,
message.from_user.first_name),
chatname=escape(message.chat.title)
if message.chat.type != "private" else escape(
message.from_user.first_name),
id=message.from_user.id,
)
else:
filtext = ""
else:
filtext = ""
if filt.file_type in (sql.Types.BUTTON_TEXT, sql.Types.TEXT):
try:
context.bot.send_message(
chat.id,
markdown_to_html(filtext),
reply_to_message_id=message.message_id,
parse_mode=ParseMode.HTML,
disable_web_page_preview=True,
reply_markup=keyboard,
)
except BadRequest as excp:
error_catch = get_exception(excp, filt, chat)
if error_catch == "noreply":
try:
context.bot.send_message(
chat.id,
markdown_to_html(filtext),
parse_mode=ParseMode.HTML,
disable_web_page_preview=True,
reply_markup=keyboard,
)
except BadRequest as excp:
LOGGER.exception("Error in filters: " +
excp.message)
send_message(
update.effective_message,
get_exception(excp, filt, chat),
)
else:
try:
send_message(
update.effective_message,
get_exception(excp, filt, chat),
)
except BadRequest as excp:
LOGGER.exception("Gagal mengirim pesan: " +
excp.message)
pass
else:
try:
ENUM_FUNC_MAP[filt.file_type](
chat.id,
filt.file_id,
caption=markdown_to_html(filtext),
reply_to_message_id=message.message_id,
parse_mode=ParseMode.HTML,
disable_web_page_preview=True,
reply_markup=keyboard,
)
except BadRequest:
send_message(
message,
"Saya tidak memiliki izin untuk mengirim konten filter.",
)
break
else:
if filt.is_sticker:
message.reply_sticker(filt.reply)
elif filt.is_document:
message.reply_document(filt.reply)
elif filt.is_image:
message.reply_photo(filt.reply)
elif filt.is_audio:
message.reply_audio(filt.reply)
elif filt.is_voice:
message.reply_voice(filt.reply)
elif filt.is_video:
message.reply_video(filt.reply)
elif filt.has_markdown:
buttons = sql.get_buttons(chat.id, filt.keyword)
keyb = build_keyboard_parser(context.bot, chat.id, buttons)
keyboard = InlineKeyboardMarkup(keyb)
try:
send_message(
update.effective_message,
filt.reply,
parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True,
reply_markup=keyboard,
)
except BadRequest as excp:
if excp.message == "Protokol url tidak didukung":
try:
send_message(
update.effective_message,
"Anda tampaknya mencoba menggunakan protokol url yang tidak didukung. "
"Telegram tidak mendukung tombol untuk beberapa protokol, seperti tg://. Silahkan dicoba "
"lagi...",
)
except BadRequest as excp:
LOGGER.exception("Kesalahan dalam filter: " +
excp.message)
pass
elif excp.message == "Pesan balasan tidak ditemukan":
try:
context.bot.send_message(
chat.id,
filt.reply,
parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True,
reply_markup=keyboard,
)
except BadRequest as excp:
LOGGER.exception("Kesalahan dalam filter: " +
excp.message)
pass
else:
try:
send_message(
update.effective_message,
"Pesan ini tidak dapat dikirim karena formatnya salah.",
)
except BadRequest as excp:
LOGGER.exception("Error in filters: " +
excp.message)
pass
LOGGER.warning("Message %s tidak dapat diurai",
str(filt.reply))
LOGGER.exception(
"Tidak dapat mengurai filter %s dalam obrolan %s",
str(filt.keyword),
str(chat.id),
)
else:
try:
send_message(update.effective_message, filt.reply)
except BadRequest as excp:
LOGGER.exception("Kesalahan dalam filter: " +
excp.message)
pass
break
def del_blackliststicker(update: Update, context: CallbackContext):
bot = context.bot
chat = update.effective_chat
message = update.effective_message
user = update.effective_user
to_match = message.sticker
if not to_match or not to_match.set_name:
return
bot = context.bot
getmode, value = sql.get_blacklist_setting(chat.id)
chat_filters = sql.get_chat_stickers(chat.id)
for trigger in chat_filters:
if to_match.set_name.lower() == trigger.lower():
try:
if getmode == 0:
return
elif getmode == 1:
message.delete()
elif getmode == 2:
message.delete()
warn(
update.effective_user,
chat,
"Menggunakan stiker '{}' yang di blacklist stiker".
format(trigger),
message,
update.effective_user,
)
return
elif getmode == 3:
message.delete()
bot.restrict_chat_member(
chat.id,
update.effective_user.id,
permissions=ChatPermissions(can_send_messages=False),
)
bot.sendMessage(
chat.id,
"{} dibungkam karena menggunakan '{}' yang di blacklist stiker"
.format(mention_markdown(user.id, user.first_name),
trigger),
parse_mode="markdown",
)
return
elif getmode == 4:
message.delete()
res = chat.unban_member(update.effective_user.id)
if res:
bot.sendMessage(
chat.id,
"{} ditendang karena menggunakan '{}' yang di blacklist stiker"
.format(mention_markdown(user.id, user.first_name),
trigger),
parse_mode="markdown",
)
return
elif getmode == 5:
message.delete()
chat.kick_member(user.id)
bot.sendMessage(
chat.id,
"{} dilarang karena menggunakan '{}' yang di blacklist stiker"
.format(mention_markdown(user.id, user.first_name),
trigger),
parse_mode="markdown",
)
return
elif getmode == 6:
message.delete()
bantime = extract_time(message, value)
chat.kick_member(user.id, until_date=bantime)
bot.sendMessage(
chat.id,
"{} dilarang untuk {} karena menggunakan '{}' yang di blacklist stiker"
.format(mention_markdown(user.id, user.first_name),
value, trigger),
parse_mode="markdown",
)
return
elif getmode == 7:
message.delete()
mutetime = extract_time(message, value)
bot.restrict_chat_member(
chat.id,
user.id,
permissions=ChatPermissions(can_send_messages=False),
until_date=mutetime,
)
bot.sendMessage(
chat.id,
"{} dibungkam untuk {} karena menggunakan '{}' yang di blacklist stiker"
.format(mention_markdown(user.id, user.first_name),
value, trigger),
parse_mode="markdown",
)
return
except BadRequest as excp:
if excp.message != "Pesan untuk dihapus tidak ditemukan":
LOGGER.exception(
"Kesalahan saat menghapus pesan daftar hitam.")
break
def ban(update: Update, context: CallbackContext) -> str:
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
log_message = ""
bot = context.bot
args = context.args
user_id, reason = extract_user_and_text(message, args)
if not user_id:
message.reply_text("Saya ragu itu adalah pengguna.")
return log_message
try:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message != "Pengguna tidak ditemukan ":
raise
message.reply_text("Sepertinya tidak dapat menemukan orang ini.")
return log_message
if user_id == bot.id:
message.reply_text("Oh ya, larang diriku sendiri, baka!")
return log_message
if is_user_ban_protected(chat, user_id, member) and user not in DEV_USERS:
if user_id == OWNER_ID:
message.reply_text(
"Mencoba menempatkanku pada bencana tingkat Dewa ya?")
elif user_id in DEV_USERS:
message.reply_text("Aku tidak bisa melawan kita sendiri.")
elif user_id in DRAGONS:
message.reply_text(
"Melawan Naga ini di sini akan membahayakan nyawa warga sipil."
)
elif user_id in DEMONS:
message.reply_text(
"Bawalah perintah dari asosiasi Pahlawan untuk melawan bencana Iblis."
)
elif user_id in TIGERS:
message.reply_text(
"Bawa perintah dari asosiasi Pahlawan untuk melawan bencana Harimau."
)
elif user_id in WOLVES:
message.reply_text("Kemampuan serigala membuat mereka kebal!")
else:
message.reply_text(
"Pengguna ini memiliki kekebalan dan tidak dapat diblokir.")
return log_message
if message.text.startswith("/s"):
silent = True
if not can_delete(chat, context.bot.id):
return ""
else:
silent = False
log = (
f"<b>{html.escape(chat.title)}:</b>\n"
f"#{'S' if silent else ''}BANNED\n"
f"<b>Admin:</b> {mention_html(user.id, html.escape(user.first_name))}\n"
f"<b>User:</b> {mention_html(member.user.id, html.escape(member.user.first_name))}"
)
if reason:
log += "\n<b>Reason:</b> {}".format(reason)
try:
chat.kick_member(user_id)
if silent:
if message.reply_to_message:
message.reply_to_message.delete()
message.delete()
return log
reply = (
f"<code>❕</code><b>Ban Event</b>\n"
f"<code> </code><b>• User:</b> {mention_html(member.user.id, html.escape(member.user.first_name))}"
)
if reason:
reply += f"\n<code> </code><b>• Reason:</b> \n{html.escape(reason)}"
bot.sendMessage(chat.id, reply, parse_mode=ParseMode.HTML, quote=False)
return log
except BadRequest as excp:
if excp.message == "Pesan balasan tidak ditemukan":
# Jangan dibalas
if silent:
return log
message.reply_text("Banned!", quote=False)
return log
else:
LOGGER.warning(update)
LOGGER.exception(
"ERROR banning user %s in chat %s (%s) due to %s",
user_id,
chat.title,
chat.id,
excp.message,
)
message.reply_text("Uhm ... itu tidak berhasil ...")
return log_message
def temp_ban(update: Update, context: CallbackContext) -> str:
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
log_message = ""
bot, args = context.bot, context.args
user_id, reason = extract_user_and_text(message, args)
if not user_id:
message.reply_text("Saya ragu itu adalah pengguna.")
return log_message
try:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message != "Pengguna tidak ditemukan":
raise
message.reply_text("Saya tidak dapat menemukan pengguna ini.")
return log_message
if user_id == bot.id:
message.reply_text(
"Aku tidak akan melarang diriku sendiri, apakah kamu gila?")
return log_message
if is_user_ban_protected(chat, user_id, member):
message.reply_text("Saya tidak merasa seperti itu.")
return log_message
if not reason:
message.reply_text(
"Anda belum menentukan waktu untuk mencekal pengguna ini!")
return log_message
split_reason = reason.split(None, 1)
time_val = split_reason[0].lower()
reason = split_reason[1] if len(split_reason) > 1 else ""
bantime = extract_time(message, time_val)
if not bantime:
return log_message
log = (
f"<b>{html.escape(chat.title)}:</b>\n"
"#TEMP BANNED\n"
f"<b>Admin:</b> {mention_html(user.id, html.escape(user.first_name))}\n"
f"<b>User:</b> {mention_html(member.user.id, html.escape(member.user.first_name))}\n"
f"<b>Time:</b> {time_val}")
if reason:
log += "\n<b>Reason:</b> {}".format(reason)
try:
chat.kick_member(user_id, until_date=bantime)
bot.sendMessage(
chat.id,
f"Banned! Pengguna {mention_html(member.user.id, html.escape(member.user.first_name))} "
f"akan dilarang selama {time_val}.",
parse_mode=ParseMode.HTML,
)
return log
except BadRequest as excp:
if excp.message == "Pesan balasan tidak ditemukan":
# Jangan dibalas
message.reply_text(f"Banned! Pengguna akan diblokir {time_val}.",
quote=False)
return log
else:
LOGGER.warning(update)
LOGGER.exception(
"ERROR banning user %s in chat %s (%s) due to %s",
user_id,
chat.title,
chat.id,
excp.message,
)
message.reply_text("Sial, saya tidak bisa melarang pengguna itu.")
return log_message
def del_blacklist(update, context):
chat = update.effective_chat
message = update.effective_message
user = update.effective_user
bot = context.bot
to_match = extract_text(message)
if not to_match:
return
if is_approved(chat.id, user.id):
return
getmode, value = sql.get_blacklist_setting(chat.id)
chat_filters = sql.get_chat_blacklist(chat.id)
for trigger in chat_filters:
pattern = r"( |^|[^\w])" + re.escape(trigger) + r"( |$|[^\w])"
if re.search(pattern, to_match, flags=re.IGNORECASE):
try:
if getmode == 0:
return
elif getmode == 1:
try:
message.delete()
except BadRequest:
pass
elif getmode == 2:
try:
message.delete()
except BadRequest:
pass
warn(
update.effective_user,
chat,
("Menggunakan pemicu daftar hitam: {}".format(trigger)),
message,
update.effective_user,
)
return
elif getmode == 3:
message.delete()
bot.restrict_chat_member(
chat.id,
update.effective_user.id,
permissions=ChatPermissions(can_send_messages=False),
)
bot.sendMessage(
chat.id,
f"Muted {user.first_name} untuk menggunakan kata dalam Daftar Hitam: {trigger}!",
)
return
elif getmode == 4:
message.delete()
res = chat.unban_member(update.effective_user.id)
if res:
bot.sendMessage(
chat.id,
f"Kicked {user.first_name} untuk menggunakan kata dalam Daftar Hitam: {trigger}!",
)
return
elif getmode == 5:
message.delete()
chat.kick_member(user.id)
bot.sendMessage(
chat.id,
f"Banned {user.first_name} untuk menggunakan kata dalam Daftar Hitam: {trigger}",
)
return
elif getmode == 6:
message.delete()
bantime = extract_time(message, value)
chat.kick_member(user.id, until_date=bantime)
bot.sendMessage(
chat.id,
f"Banned {user.first_name} sampai '{value}' untuk menggunakan kata dalam Daftar Hitam: {trigger}!",
)
return
elif getmode == 7:
message.delete()
mutetime = extract_time(message, value)
bot.restrict_chat_member(
chat.id,
user.id,
until_date=mutetime,
permissions=ChatPermissions(can_send_messages=False),
)
bot.sendMessage(
chat.id,
f"Muted {user.first_name} sampai '{value}' untuk menggunakan kata dalam Daftar Hitam: {trigger}!",
)
return
except BadRequest as excp:
if excp.message != "Pesan untuk dihapus tidak ditemukan":
LOGGER.exception("Kesalahan saat menghapus pesan daftar hitam.")
break
def settings_button(update: Update, context: CallbackContext):
query = update.callback_query
user = update.effective_user
bot = context.bot
mod_match = re.match(r"stngs_module\((.+?),(.+?)\)", query.data)
prev_match = re.match(r"stngs_prev\((.+?),(.+?)\)", query.data)
next_match = re.match(r"stngs_next\((.+?),(.+?)\)", query.data)
back_match = re.match(r"stngs_back\((.+?)\)", query.data)
try:
if mod_match:
chat_id = mod_match.group(1)
module = mod_match.group(2)
chat = bot.get_chat(chat_id)
text = "*{}* memiliki pengaturan berikut untuk *{}* module:\n\n".format(
escape_markdown(chat.title), CHAT_SETTINGS[module].__mod_name__
) + CHAT_SETTINGS[module].__chat_settings__(chat_id, user.id)
query.message.reply_text(
text=text,
parse_mode=ParseMode.MARKDOWN,
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton(
text="Back",
callback_data="stngs_back({})".format(chat_id),
)
]]),
)
elif prev_match:
chat_id = prev_match.group(1)
curr_page = int(prev_match.group(2))
chat = bot.get_chat(chat_id)
query.message.reply_text(
"Halo yang disana! Ada beberapa pengaturan untuk {} - lanjutkan dan pilih apa "
"Anda tertarik.".format(chat.title),
reply_markup=InlineKeyboardMarkup(
paginate_modules(curr_page - 1,
CHAT_SETTINGS,
"stngs",
chat=chat_id)),
)
elif next_match:
chat_id = next_match.group(1)
next_page = int(next_match.group(2))
chat = bot.get_chat(chat_id)
query.message.reply_text(
"Halo yang disana! Ada beberapa pengaturan untuk {} - lanjutkan dan pilih apa "
"Anda tertarik.".format(chat.title),
reply_markup=InlineKeyboardMarkup(
paginate_modules(next_page + 1,
CHAT_SETTINGS,
"stngs",
chat=chat_id)),
)
elif back_match:
chat_id = back_match.group(1)
chat = bot.get_chat(chat_id)
query.message.reply_text(
text=
"Halo yang disana! Ada beberapa pengaturan untuk {} - lanjutkan dan pilih apa "
"Anda tertarik.".format(escape_markdown(chat.title)),
parse_mode=ParseMode.MARKDOWN,
reply_markup=InlineKeyboardMarkup(
paginate_modules(0, CHAT_SETTINGS, "stngs", chat=chat_id)),
)
# pastikan tidak ada lingkaran putih keriting
bot.answer_callback_query(query.id)
query.message.delete()
except BadRequest as excp:
if excp.message not in [
"Pesan tidak diubah",
"Query_id_invalid",
"Pesan tidak dapat dihapus",
]:
LOGGER.exception("Pengecualian di tombol pengaturan. %s",
str(query.data))