def connected(bot, update, chat, user_id, need_admin=True):
user = update.effective_user
if chat.type == chat.PRIVATE and sql.get_connected_chat(user_id):
conn_id = sql.get_connected_chat(user_id).chat_id
getstatusadmin = bot.get_chat_member(
conn_id, update.effective_message.from_user.id)
isadmin = getstatusadmin.status in ("administrator", "creator")
ismember = getstatusadmin.status in ("member")
isallow = sql.allow_connect_to_chat(conn_id)
if ((isadmin) or (isallow and ismember) or (user.id in SUDO_USERS)
or (user.id in DEV_USERS)):
if need_admin:
if (getstatusadmin.status in ("administrator", "creator")
or user_id in SUDO_USERS or user.id in DEV_USERS):
return conn_id
else:
send_message(
update.effective_message,
"Anda harus menjadi admin di grup yang terhubung!",
)
else:
return conn_id
else:
send_message(
update.effective_message,
"Grup mengubah hak koneksi atau Anda bukan lagi admin.\nSaya telah memutuskan Anda.",
)
disconnect_chat(update, bot)
else:
return False
def help_connect_chat(update, context):
if update.effective_message.chat.type != "private":
send_message(update.effective_message,
"PM saya dengan perintah itu untuk mendapatkan bantuan.")
return
else:
send_message(update.effective_message,
CONN_HELP,
parse_mode="markdown")
def disconnect_chat(update, context):
if update.effective_chat.type == "private":
disconnection_status = sql.disconnect(
update.effective_message.from_user.id)
if disconnection_status:
sql.disconnected_chat = send_message(update.effective_message,
"Terputus dari obrolan!")
else:
send_message(update.effective_message, "Anda tidak terhubung!")
else:
send_message(update.effective_message,
"Perintah ini hanya tersedia di PM.")
def check_and_ban(update, user_id, should_message=True):
try:
spmban = spamwtc.get_ban(int(user_id))
cas_banned = check_cas(user_id)
if spmban or cas_banned:
update.effective_chat.kick_member(user_id)
if should_message:
if spmban and cas_banned:
banner = "@Spamwatch and Combot Anti Spam"
reason = f"\n<code>{spmban.reason}</code>\n\nand <a href='{cas_banned}'>CAS Banned</a>"
elif cas_banned:
banner = "Combot Anti Spam"
reason = f"<a href='{cas_banned}''>CAS Banned</a>"
elif spmban:
banner = "@Spamwatch"
reason = f"<code>{spmban.reason}</code>"
send_message(
update.effective_message,
"#SPAM_SHIELD\n\nOrang ini telah terdeteksi sebagai robot spam"
f"oleh {banner} dan telah dihapusd!\nAlasan: {reason}",
parse_mode=ParseMode.HTML,
)
return
except Exception:
pass
if gban_db.is_user_gbanned(user_id):
update.effective_chat.kick_member(user_id)
if should_message:
usr = gban_db.get_gbanned_user(user_id)
greason = usr["reason"]
if not greason:
greason = "Tidak ada alasan yang diberikan"
send_message(
update.effective_message,
f"*Waspada! pengguna ini telah diblokir dan telah dihapus!*\n*Alasan*: {greason}",
parse_mode=ParseMode.MARKDOWN,
)
return
def commands(update, context):
chat = update.effective_chat
user = update.effective_user
conn = connected(context.bot, update, chat, user.id, need_admin=True)
if conn:
chat = dispatcher.bot.getChat(conn)
else:
if update.effective_message.chat.type == "private":
send_message(
update.effective_message,
"Perintah ini dimaksudkan untuk digunakan dalam grup bukan di PM",
)
return ""
chat = update.effective_chat
text = build_curr_disabled(chat.id)
send_message(update.effective_message,
text,
parse_mode=ParseMode.MARKDOWN)
def blacklist(update, context):
chat = update.effective_chat
user = update.effective_user
args = context.args
conn = connected(context.bot, update, chat, user.id, need_admin=False)
if conn:
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
else:
if chat.type == "private":
return
else:
chat_id = update.effective_chat.id
chat_name = chat.title
filter_list = "Kata-kata dalam daftar hitam saat ini dalam <b>{}</b>:\n".format(
chat_name)
all_blacklisted = blacklist_db.get_chat_blacklist(chat_id)
if len(args) > 0 and args[0].lower() == "copy":
for trigger in all_blacklisted:
filter_list += "<code>{}</code>\n".format(html.escape(trigger))
else:
for trigger in all_blacklisted:
filter_list += " - <code>{}</code>\n".format(html.escape(trigger))
# for trigger in all_blacklisted:
# filter_list += " - <code>{}</code>\n".format(html.escape(trigger))
split_text = split_message(filter_list)
for text in split_text:
if filter_list == "Kata-kata dalam daftar hitam saat ini dalam <b>{}</b>:\n".format(
chat_name):
send_message(
update.effective_message,
"Tidak ada kata dalam daftar hitam <b>{}</b>!".format(
chat_name),
parse_mode=ParseMode.HTML,
)
return
send_message(update.effective_message, text, parse_mode=ParseMode.HTML)
def flood(update, context):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
msg = update.effective_message
conn = connected(context.bot, update, chat, user.id, need_admin=False)
if conn:
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
else:
if update.effective_message.chat.type == "private":
send_message(
update.effective_message,
"Perintah ini dimaksudkan untuk digunakan dalam grup bukan di PM",
)
return
chat_id = update.effective_chat.id
chat_name = update.effective_message.chat.title
limit = sql.get_flood_limit(chat_id)
if limit == 0:
if conn:
text = (
"Saya tidak memaksakan pengendalian flood apa pun{}!".format(chat_name)
)
else:
text = ("Saya tidak memaksakan pengendalian flood di sini!")
else:
if conn:
text = (
"Saya saat ini membatasi anggota setelah {} pesan berurutan di {}.".format(
limit, chat_name
)
)
else:
text = (
"Saya saat ini membatasi anggota setelah {} pesan berturut-turut.".format(
limit
)
)
send_message(msg, text, parse_mode="markdown")
def connection_chat(update, context):
chat = update.effective_chat
user = update.effective_user
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":
return
chat = update.effective_chat
chat_name = update.effective_message.chat.title
if conn:
message = "Anda saat ini terhubung ke {}.\n".format(chat_name)
else:
message = "Anda saat ini tidak terhubung ke grup mana pun.\n"
send_message(update.effective_message, message, parse_mode="markdown")
def disable(update, context):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user
args = context.args
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":
send_message(
update.effective_message,
"Perintah ini dimaksudkan untuk digunakan di grup bukan di PM",
)
return ""
chat = update.effective_chat
chat_name = update.effective_message.chat.title
if len(args) >= 1:
disable_cmd = args[0]
if disable_cmd.startswith(CMD_STARTERS):
disable_cmd = disable_cmd[1:]
if disable_cmd in set(DISABLE_CMDS + DISABLE_OTHER):
disable_db.disable_command(chat.id, disable_cmd)
if conn:
text = "Menonaktifkan penggunaan perintah `{}` di *{}*!".format(
disable_cmd, chat_name
)
else:
text = "Menonaktifkan penggunaan perintah `{}`!".format(
disable_cmd
)
send_message(
update.effective_message,
text,
parse_mode=ParseMode.MARKDOWN,
)
else:
send_message(
update.effective_message, "Perintah ini tidak dapat dinonaktifkan"
)
else:
send_message(update.effective_message, "Apa yang harus saya nonaktifkan?")
def list_locks(update, context):
chat = update.effective_chat
user = update.effective_user
# Connection check
conn = connected(context.bot, update, chat, user.id, need_admin=True)
if conn:
chat = dispatcher.bot.getChat(conn)
chat_name = chat.title
else:
if update.effective_message.chat.type == "private":
send_message(
update.effective_message,
"Perintah ini dimaksudkan untuk digunakan dalam grup bukan di PM",
)
return ""
chat = update.effective_chat
chat_name = update.effective_message.chat.title
res = build_lock_message(chat.id)
if conn:
res = res.replace("Terkunci di", "*{}*".format(chat_name))
send_message(update.effective_message, res, parse_mode=ParseMode.MARKDOWN)
def stop_filter(update, context):
chat = update.effective_chat
user = update.effective_user
args = update.effective_message.text.split(None, 1)
conn = connected(context.bot, update, chat, user.id)
if not conn == False:
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
else:
chat_id = update.effective_chat.id
if chat.type == "private":
chat_name = "Local filters"
else:
chat_name = chat.title
if len(args) < 2:
send_message(update.effective_message, "Apa yang harus saya hentikan?")
return
chat_filters = sql.get_chat_triggers(chat_id)
if not chat_filters:
send_message(update.effective_message,
"Tidak ada filter yang aktif di sini!")
return
for keyword in chat_filters:
if keyword == args[1]:
sql.remove_filter(chat_id, args[1])
send_message(
update.effective_message,
"Oke, saya akan berhenti membalas filter itu *{}*.".format(
chat_name),
parse_mode=telegram.ParseMode.MARKDOWN,
)
raise DispatcherHandlerStop
send_message(
update.effective_message,
"Itu bukan filter - Klik: /filters untuk mendapatkan filter yang sedang aktif.",
)
def add_blacklist(update, context):
msg = update.effective_message
chat = update.effective_chat
user = update.effective_user
words = msg.text.split(None, 1)
conn = connected(context.bot, update, chat, user.id)
if conn:
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
else:
chat_id = update.effective_chat.id
if chat.type == "private":
return
else:
chat_name = chat.title
if len(words) > 1:
text = words[1]
to_blacklist = list(
set(trigger.strip() for trigger in text.split("\n")
if trigger.strip()))
for trigger in to_blacklist:
blacklist_db.add_to_blacklist(chat_id, trigger.lower())
if len(to_blacklist) == 1:
send_message(
update.effective_message,
"Menambahkan daftar hitam <code>{}</code> dalam obrolan: <b>{}</b>!"
.format(html.escape(to_blacklist[0]), chat_name),
parse_mode=ParseMode.HTML,
)
else:
send_message(
update.effective_message,
"Menambahkan pemicu daftar hitam: <code>{}</code> di <b>{}</b>!"
.format(len(to_blacklist), chat_name),
parse_mode=ParseMode.HTML,
)
else:
send_message(
update.effective_message,
"Beri tahu saya kata mana yang ingin Anda tambahkan ke daftar hitam.",
)
def list_handlers(update, context):
chat = update.effective_chat
user = update.effective_user
conn = connected(context.bot, update, chat, user.id, need_admin=False)
if not conn == False:
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
filter_list = "*Filter in {}:*\n"
else:
chat_id = update.effective_chat.id
if chat.type == "private":
chat_name = "Local filters"
filter_list = "*local filters:*\n"
else:
chat_name = chat.title
filter_list = "*Filters in {}*:\n"
all_handlers = sql.get_chat_triggers(chat_id)
if not all_handlers:
send_message(
update.effective_message,
"Tidak ada filter yang disimpan di {}!".format(chat_name),
)
return
for keyword in all_handlers:
entry = " × `{}`\n".format(escape_markdown(keyword))
if len(entry) + len(filter_list) > telegram.MAX_MESSAGE_LENGTH:
send_message(
update.effective_message,
filter_list.format(chat_name),
parse_mode=telegram.ParseMode.MARKDOWN,
)
filter_list = entry
else:
filter_list += entry
send_message(
update.effective_message,
filter_list.format(chat_name),
parse_mode=telegram.ParseMode.MARKDOWN,
)
def reply_filter(update, context):
chat = update.effective_chat
message = update.effective_message
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):
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:
valid_format = escape_invalid_curly_brackets(
filt.reply_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,
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,
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("Failed to send message: " +
excp.message)
else:
if (ENUM_FUNC_MAP[filt.file_type] ==
dispatcher.bot.send_sticker):
ENUM_FUNC_MAP[filt.file_type](
chat.id,
filt.file_id,
reply_to_message_id=message.message_id,
reply_markup=keyboard,
)
else:
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,
reply_markup=keyboard,
)
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,
reply_markup=keyboard,
)
except BadRequest as excp:
if excp.message == "Unsupported url protocol":
try:
send_message(
update.effective_message,
"Anda tampaknya mencoba menggunakan protokol url yang tidak didukung. "
"Telegram tidak mendukung tombol untuk beberapa protokol, seperti tg://. Silakan coba "
"lagi...",
)
except BadRequest as excp:
LOGGER.exception("Error in filters: " +
excp.message)
elif excp.message == "Pesan balasan tidak ditemukan":
try:
context.bot.send_message(
chat.id,
filt.reply,
parse_mode=ParseMode.MARKDOWN,
reply_markup=keyboard,
)
except BadRequest as excp:
LOGGER.exception("Error in filters: " +
excp.message)
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)
LOGGER.warning(
"Message %s could not be parsed",
str(filt.reply),
)
LOGGER.exception(
"Could not parse filter %s in chat %s",
str(filt.keyword),
str(chat.id),
)
else:
# LEGACY - all new filters will have has_markdown set to
# True.
try:
send_message(update.effective_message, filt.reply)
except BadRequest as excp:
LOGGER.exception("Error in filters: " + excp.message)
break
def unblacklist(update, context):
msg = update.effective_message
chat = update.effective_chat
user = update.effective_user
words = msg.text.split(None, 1)
conn = connected(context.bot, update, chat, user.id)
if conn:
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
else:
chat_id = update.effective_chat.id
if chat.type == "private":
return
else:
chat_name = chat.title
if len(words) > 1:
text = words[1]
to_unblacklist = list(
set(trigger.strip() for trigger in text.split("\n")
if trigger.strip()))
successful = 0
for trigger in to_unblacklist:
success = blacklist_db.rm_from_blacklist(chat_id, trigger.lower())
if success:
successful += 1
if len(to_unblacklist) == 1:
if successful:
send_message(
update.effective_message,
"Dihapus <code>{}</code> dari daftar hitam di <b>{}</b>!".
format(html.escape(to_unblacklist[0]), chat_name),
parse_mode=ParseMode.HTML,
)
else:
send_message(
update.effective_message,
"Ini bukan pemicu daftar hitam!",
)
elif successful == len(to_unblacklist):
send_message(
update.effective_message,
"Dihapus <code>{}</code> dari daftar hitam di <b>{}</b>!".
format(successful, chat_name),
parse_mode=ParseMode.HTML,
)
elif not successful:
send_message(
update.effective_message,
"Tidak satu pun pemicu ini ada sehingga tidak dapat dihapus.".
format(successful,
len(to_unblacklist) - successful),
parse_mode=ParseMode.HTML,
)
else:
send_message(
update.effective_message,
"Dihapus <code>{}</code> dari daftar hitam. {} Tidak ada, "
"jadi tidak dihapus.".format(successful,
len(to_unblacklist) - successful),
parse_mode=ParseMode.HTML,
)
else:
send_message(
update.effective_message,
"Beri tahu saya kata mana yang ingin Anda hapus dari daftar hitam!",
)
def set_flood_mode(update, context):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
msg = update.effective_message # type: Optional[Message]
args = context.args
conn = connected(context.bot, update, chat, user.id, need_admin=True)
if conn:
chat = dispatcher.bot.getChat(conn)
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
else:
if update.effective_message.chat.type == "private":
send_message(
update.effective_message,
"Perintah ini dimaksudkan untuk digunakan dalam grup tidak dalam PM",
)
return ""
chat = update.effective_chat
chat_id = update.effective_chat.id
chat_name = update.effective_message.chat.title
if args:
if args[0].lower() == "ban":
settypeflood = "ban"
sql.set_flood_strength(chat_id, 1, "0")
elif args[0].lower() == "kick":
settypeflood = "kick"
sql.set_flood_strength(chat_id, 2, "0")
elif args[0].lower() == "mute":
settypeflood = "mute"
sql.set_flood_strength(chat_id, 3, "0")
elif args[0].lower() == "tban":
if len(args) == 1:
teks = """Sepertinya Anda mencoba menetapkan nilai waktu untuk antiflood tetapi Anda tidak menentukan waktu; Coba `/setfloodmode tban <timevalue>`.
Contoh nilai waktu: 4m = 4 menit, 3h = 3 jam, 6d = 6 hari, 5w = 5 minggu."""
send_message(update.effective_message,
teks,
parse_mode="markdown")
return
settypeflood = "tban for {}".format(args[1])
sql.set_flood_strength(chat_id, 4, str(args[1]))
elif args[0].lower() == "tmute":
if len(args) == 1:
teks = (
update.effective_message,
"""Sepertinya Anda mencoba menetapkan nilai waktu untuk antiflood tetapi Anda tidak menentukan waktu; Coba, `/setfloodmode tmute <timevalue>`.
Contoh nilai waktu: 4m = 4 menit, 3h = 3 jam, 6d = 6 hari, 5w = 5 minggu.""",
)
send_message(update.effective_message,
teks,
parse_mode="markdown")
return
settypeflood = "tmute for {}".format(args[1])
sql.set_flood_strength(chat_id, 5, str(args[1]))
else:
send_message(
update.effective_message,
"Saya hanya mengerti ban/kick/mute/tban/tmute!",
)
return
if conn:
text = msg.reply_text(
"Melebihi batas flood berturut-turut akan mengakibatkan {} dalam {}!"
.format(settypeflood, chat_name))
else:
text = msg.reply_text(
"Melebihi batas flood berturut-turut akan {}!".format(
settypeflood))
return ("<b>{}:</b>\n"
"<b>Admin:</b> {}\n"
"Has changed antiflood mode. User will {}.".format(
settypeflood,
html.escape(chat.title),
mention_html(user.id, user.first_name),
))
else:
getmode, getvalue = sql.get_flood_setting(chat.id)
if getmode == 1:
settypeflood = "ban"
elif getmode == 2:
settypeflood = "kick"
elif getmode == 3:
settypeflood = "mute"
elif getmode == 4:
settypeflood = "tban for {}".format(getvalue)
elif getmode == 5:
settypeflood = "tmute for {}".format(getvalue)
if conn:
text = msg.reply_text(
"Mengirim lebih banyak pesan daripada batas flood akan mengakibatkan {} masuk {}."
.format(settypeflood, chat_name))
else:
text = msg.reply_text(
"Mengirim lebih banyak pesan daripada batas flood akan mengakibatkan {}."
.format(settypeflood))
return ""
def unlock(update, context) -> str:
args = context.args
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
if is_user_admin(chat, message.from_user.id):
if len(args) >= 1:
ltype = args[0].lower()
if ltype in LOCK_TYPES:
# Connection check
conn = connected(
context.bot, update, chat, user.id, need_admin=True
)
if conn:
chat = dispatcher.bot.getChat(conn)
chat_id = conn
chat_name = chat.title
text = "Pesan {} tidak terkunci untuk semua orang di {}!".format(
ltype, chat_name
)
else:
if update.effective_message.chat.type == "private":
send_message(
update.effective_message,
"Perintah ini dimaksudkan untuk digunakan dalam grup bukan di PM",
)
return ""
chat = update.effective_chat
chat_id = update.effective_chat.id
chat_name = update.effective_message.chat.title
text = "Pesan {} tidak terkunci untuk semua orang!".format(ltype)
sql.update_lock(chat.id, ltype, locked=False)
send_message(
update.effective_message, text, parse_mode="markdown"
)
return (
"<b>{}:</b>"
"\n#UNLOCK"
"\n<b>Admin:</b> {}"
"\nUnlocked <code>{}</code>.".format(
html.escape(chat.title),
mention_html(user.id, user.first_name),
ltype,
)
)
elif ltype in UNLOCK_CHAT_RESTRICTION:
# Connection check
conn = connected(
context.bot, update, chat, user.id, need_admin=True
)
if conn:
chat = dispatcher.bot.getChat(conn)
chat_id = conn
chat_name = chat.title
text = "Terbuka {} untuk semua orang di {}!".format(
ltype, chat_name
)
else:
if update.effective_message.chat.type == "private":
send_message(
update.effective_message,
"Perintah ini dimaksudkan untuk digunakan dalam grup bukan di PM",
)
return ""
chat = update.effective_chat
chat_id = update.effective_chat.id
chat_name = update.effective_message.chat.title
text = "Terbuka {} untuk semua orang!".format(ltype)
current_permission = context.bot.getChat(chat_id).permissions
context.bot.set_chat_permissions(
chat_id=chat_id,
permissions=get_permission_list(
eval(str(current_permission)),
UNLOCK_CHAT_RESTRICTION[ltype.lower()],
),
)
send_message(
update.effective_message, text, parse_mode="markdown"
)
return (
"<b>{}:</b>"
"\n#UNLOCK"
"\n<b>Admin:</b> {}"
"\nUnlocked <code>{}</code>.".format(
html.escape(chat.title),
mention_html(user.id, user.first_name),
ltype,
)
)
else:
send_message(
update.effective_message,
"Apa yang Anda coba buka kuncinya ...? Coba /locktypes untuk daftar yang dapat dikunci.",
)
else:
send_message(
update.effective_message, "Apa yang Anda coba buka kuncinya...?"
)
return ""
def set_flood(update, context) -> str:
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
message = update.effective_message # type: Optional[Message]
args = context.args
conn = connected(context.bot, update, chat, user.id, need_admin=True)
if conn:
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
else:
if update.effective_message.chat.type == "private":
send_message(
update.effective_message,
"Perintah ini dimaksudkan untuk digunakan dalam grupPerintah ini dimaksudkan untuk digunakan dalam grup tidak dalam PM tidak dalam PM",
)
return ""
chat_id = update.effective_chat.id
chat_name = update.effective_message.chat.title
if len(args) >= 1:
val = args[0].lower()
if val == "off" or val == "no" or val == "0":
sql.set_flood(chat_id, 0)
if conn:
text = message.reply_text(
"Antiflood telah dinon-fungsikan di {}.".format(chat_name))
else:
text = message.reply_text("Antiflood telah dinon-fungsikan.")
send_message(update.effective_message, text, parse_mode="markdown")
elif val.isdigit():
amount = int(val)
if amount <= 0:
sql.set_flood(chat_id, 0)
if conn:
text = message.reply_text(
"Antiflood telah dinon-fungsikan di{}.".format(
chat_name))
else:
text = message.reply_text(
"Antiflood telah dinon-fungsikan.")
return ("<b>{}:</b>"
"\n#SETFLOOD"
"\n<b>Admin:</b> {}"
"\nDisable antiflood.".format(
html.escape(chat_name),
mention_html(user.id, user.first_name),
))
elif amount < 3:
send_message(
update.effective_message,
"Antiflood must be either 0 (disabled) or number greater than 3!",
)
return ""
else:
sql.set_flood(chat_id, amount)
if conn:
text = ("Anti-flood telah diatur ke {} dalam obrolan: {}".
format(amount, chat_name))
else:
text = ("Berhasil memperbarui batas anti-flood ke {}!".
format(amount))
send_message(update.effective_message,
text,
parse_mode="markdown")
return ("<b>{}:</b>"
"\n#SETFLOOD"
"\n<b>Admin:</b> {}"
"\nSet antiflood to <code>{}</code>.".format(
html.escape(chat_name),
mention_html(user.id, user.first_name),
amount,
))
else:
message.reply_text(
"Invalid argument please use a number, 'off' or 'no'")
else:
message.reply_text(
("Gunakan `/setflood number` untuk mengaktifkan anti-flood.\nAtau gunakan `/setflood off` untuk menonaktifkan antiflood!."
),
parse_mode="markdown",
)
return ""
def check_flood(update, context) -> str:
user = update.effective_user # type: Optional[User]
chat = update.effective_chat # type: Optional[Chat]
msg = update.effective_message # type: Optional[Message]
if not user: # ignore channels
return ""
# ignore admins
if is_user_admin(chat, user.id):
sql.update_flood(chat.id, None)
return ""
should_ban = sql.update_flood(chat.id, user.id)
if not should_ban:
return ""
try:
getmode, getvalue = sql.get_flood_setting(chat.id)
if getmode == 1:
chat.kick_member(user.id)
execstrings = "Banned"
tag = "BANNED"
elif getmode == 2:
chat.kick_member(user.id)
chat.unban_member(user.id)
execstrings = "Kicked"
tag = "KICKED"
elif getmode == 3:
context.bot.restrict_chat_member(
chat.id,
user.id,
permissions=ChatPermissions(can_send_messages=False),
)
execstrings = "Muted"
tag = "MUTED"
elif getmode == 4:
bantime = extract_time(msg, getvalue)
chat.kick_member(user.id, until_date=bantime)
execstrings = "Dilarang ukepada {}".format(getvalue)
tag = "TBAN"
elif getmode == 5:
mutetime = extract_time(msg, getvalue)
context.bot.restrict_chat_member(
chat.id,
user.id,
until_date=mutetime,
permissions=ChatPermissions(can_send_messages=False),
)
execstrings = "Dibisukan kepada {}".format(getvalue)
tag = "TMUTE"
send_message(
update.effective_message,
"Bagus, aku suka meninggalkan flood tapi, "
"Anda hanya kecewa. {}!".format(execstrings),
)
return ("<b>{}:</b>"
"\n#{}"
"\n<b>Pengguna:</b> {}"
"\nFlooded the group.".format(
tag,
html.escape(chat.title),
mention_html(user.id, user.first_name),
))
except BadRequest:
msg.reply_text(
"Saya tidak bisa membatasi orang di sini, memberi saya izin terlebih dahulu! Sampai saat itu, aku akan menonaktifkan anti-flood."
)
sql.set_flood(chat.id, 0)
return (
"<b>{}:</b>"
"\n#INFO"
"\nTidak memiliki cukup izin untuk membatasi pengguna sehingga secara otomatis menonaktifkan anti-flood"
.format(chat.title))
def del_lockables(update, context):
chat = update.effective_chat
message = update.effective_message
for lockable, filter in LOCK_TYPES.items():
if lockable == "rtl":
if sql.is_locked(chat.id, lockable) and can_delete(
chat, context.bot.id
):
if message.caption:
check = ad.detect_alphabet(u"{}".format(message.caption))
if "ARABIC" in check:
try:
message.delete()
except BadRequest as excp:
if excp.message == "Pesan untuk dihapus tidak ditemukan":
pass
else:
LOGGER.exception("ERROR in lockables")
break
if message.text:
check = ad.detect_alphabet(u"{}".format(message.text))
if "ARABIC" in check:
try:
message.delete()
except BadRequest as excp:
if excp.message == "Message to delete not found":
pass
else:
LOGGER.exception("ERROR in lockables")
break
continue
if lockable == "button":
if sql.is_locked(chat.id, lockable) and can_delete(
chat, context.bot.id
):
if (
message.reply_markup
and message.reply_markup.inline_keyboard
):
try:
message.delete()
except BadRequest as excp:
if excp.message == "Message to delete not found":
pass
else:
LOGGER.exception("ERROR in lockables")
break
continue
if lockable == "inline":
if sql.is_locked(chat.id, lockable) and can_delete(
chat, context.bot.id
):
if message and message.via_bot:
try:
message.delete()
except BadRequest as excp:
if excp.message == "Message to delete not found":
pass
else:
LOGGER.exception("ERROR in lockables")
break
continue
if (
filter(update)
and sql.is_locked(chat.id, lockable)
and can_delete(chat, context.bot.id)
):
if lockable == "bots":
new_members = update.effective_message.new_chat_members
for new_mem in new_members:
if new_mem.is_bot:
if not is_bot_admin(chat, context.bot.id):
send_message(
update.effective_message,
"Saya melihat bot dan saya telah diberitahu untuk menghentikan mereka bergabung..."
"tapi saya bukan admin!",
)
return
chat.kick_member(new_mem.id)
send_message(
update.effective_message,
"Hanya admin yang diperbolehkan untuk menambahkan bot dalam obrolan ini! Keluar dari sini.",
)
break
else:
try:
message.delete()
except BadRequest as excp:
if excp.message == "Message to delete not found":
pass
else:
LOGGER.exception("ERROR in lockables")
break
def allow_connections(update, context) -> str:
chat = update.effective_chat
args = context.args
if chat.type != chat.PRIVATE:
if len(args) >= 1:
var = args[0]
if var == "no":
sql.set_allow_connect_to_chat(chat.id, False)
send_message(
update.effective_message,
"Sambungan untuk obrolan ini telah dinonaktifkan",
)
elif var == "yes":
sql.set_allow_connect_to_chat(chat.id, True)
send_message(
update.effective_message,
"Koneksi telah diaktifkan untuk obrolan ini",
)
else:
send_message(
update.effective_message,
"Silahkan masukkan `yes` atau `no`!",
parse_mode=ParseMode.MARKDOWN,
)
else:
get_settings = sql.allow_connect_to_chat(chat.id)
if get_settings:
send_message(
update.effective_message,
"Koneksi ke grup ini *Diizinkan* untuk anggota!",
parse_mode=ParseMode.MARKDOWN,
)
else:
send_message(
update.effective_message,
"Koneksi ke grup ini *Tidak Diizinkan* untuk anggota!",
parse_mode=ParseMode.MARKDOWN,
)
else:
send_message(
update.effective_message,
"Perintah ini hanya untuk grup. Tidak di PM!",
)
def connect_chat(update, context):
chat = update.effective_chat
user = update.effective_user
args = context.args
if update.effective_chat.type == "private":
if args and len(args) >= 1:
try:
connect_chat = int(args[0])
getstatusadmin = context.bot.get_chat_member(
connect_chat, update.effective_message.from_user.id)
except ValueError:
try:
connect_chat = str(args[0])
get_chat = context.bot.getChat(connect_chat)
connect_chat = get_chat.id
getstatusadmin = context.bot.get_chat_member(
connect_chat, update.effective_message.from_user.id)
except BadRequest:
send_message(update.effective_message,
"ID Obrolan Tidak Valid!")
return
except BadRequest:
send_message(update.effective_message,
"ID Obrolan Tidak Valid!")
return
isadmin = getstatusadmin.status in ("administrator", "creator")
ismember = getstatusadmin.status in ("member")
isallow = sql.allow_connect_to_chat(connect_chat)
if ((isadmin) or (isallow and ismember) or (user.id in SUDO_USERS)
or (user.id in DEV_USERS)):
connection_status = sql.connect(
update.effective_message.from_user.id, connect_chat)
if connection_status:
conn_chat = dispatcher.bot.getChat(
connected(
context.bot,
update,
chat,
user.id,
need_admin=False,
))
chat_name = conn_chat.title
send_message(
update.effective_message,
"Berhasil terhubung ke *{}*. \nGunakan /helpconnect untuk memeriksa perintah yang tersedia."
.format(chat_name),
parse_mode=ParseMode.MARKDOWN,
)
sql.add_history_conn(user.id, str(conn_chat.id), chat_name)
else:
send_message(update.effective_message, "Koneksi gagal!")
else:
send_message(
update.effective_message,
"Koneksi ke obrolan ini tidak diperbolehkan!",
)
else:
gethistory = sql.get_history_conn(user.id)
if gethistory:
buttons = [
InlineKeyboardButton(text="❎ Tutup",
callback_data="connect_close"),
InlineKeyboardButton(text="🧹 Hapus riwayat",
callback_data="connect_clear"),
]
else:
buttons = []
conn = connected(context.bot,
update,
chat,
user.id,
need_admin=False)
if conn:
connectedchat = dispatcher.bot.getChat(conn)
text = "Anda saat ini terhubung ke *{}* (`{}`)".format(
connectedchat.title, conn)
buttons.append(
InlineKeyboardButton(text="🔌 Disconnect",
callback_data="connect_disconnect"))
else:
text = "Tulis ID atau tag obrolan untuk terhubung!"
if gethistory:
text += "\n\n*Connection history:*\n"
text += "╒═══「 *Info* 」\n"
text += "│ Sorted: `Newest`\n"
text += "│\n"
buttons = [buttons]
for x in sorted(gethistory.keys(), reverse=True):
htime = time.strftime("%d/%m/%Y", time.localtime(x))
text += "╞═「 *{}* 」\n│ `{}`\n│ `{}`\n".format(
gethistory[x]["chat_name"],
gethistory[x]["chat_id"],
htime,
)
text += "│\n"
buttons.append([
InlineKeyboardButton(
text=gethistory[x]["chat_name"],
callback_data="connect({})".format(
gethistory[x]["chat_id"]),
)
])
text += "╘══「 Total {} Chats 」".format(
str(len(gethistory)) +
" (max)" if len(gethistory) == 5 else str(len(gethistory)))
conn_hist = InlineKeyboardMarkup(buttons)
elif buttons:
conn_hist = InlineKeyboardMarkup([buttons])
else:
conn_hist = None
send_message(
update.effective_message,
text,
parse_mode="markdown",
reply_markup=conn_hist,
)
else:
getstatusadmin = context.bot.get_chat_member(
chat.id, update.effective_message.from_user.id)
isadmin = getstatusadmin.status in ("administrator", "creator")
ismember = getstatusadmin.status in ("member")
isallow = sql.allow_connect_to_chat(chat.id)
if ((isadmin) or (isallow and ismember) or (user.id in SUDO_USERS)
or (user.id in DEV_USERS)):
connection_status = sql.connect(
update.effective_message.from_user.id, chat.id)
if connection_status:
chat_name = dispatcher.bot.getChat(chat.id).title
send_message(
update.effective_message,
"Berhasil terhubung ke *{}*.".format(chat_name),
parse_mode=ParseMode.MARKDOWN,
)
try:
sql.add_history_conn(user.id, str(chat.id), chat_name)
context.bot.send_message(
update.effective_message.from_user.id,
"Anda terhubung ke *{}*. \nUse `/helpconnect` untuk memeriksa perintah yang tersedia."
.format(chat_name),
parse_mode="markdown",
)
except BadRequest:
pass
except Unauthorized:
pass
else:
send_message(update.effective_message, "Koneksi gagal!")
else:
send_message(
update.effective_message,
"Koneksi ke obrolan ini tidak diperbolehkan!",
)
def filters(update, context):
chat = update.effective_chat
user = update.effective_user
msg = update.effective_message
args = msg.text.split(
None,
1) # use python's maxsplit to separate Cmd, keyword, and reply_text
conn = connected(context.bot, update, chat, user.id)
if not conn == False:
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
else:
chat_id = update.effective_chat.id
if chat.type == "private":
chat_name = "local filters"
else:
chat_name = chat.title
if not msg.reply_to_message and len(args) < 2:
send_message(
update.effective_message,
"Berikan kata kunci keyboard untuk membalas dengan filter ini!",
)
return
if msg.reply_to_message:
if len(args) < 2:
send_message(
update.effective_message,
"Berikan kata kunci untuk membalas dengan filter ini!",
)
return
else:
keyword = args[1]
else:
extracted = split_quotes(args[1])
if len(extracted) < 1:
return
# set trigger -> lower, so as to avoid adding duplicate filters with
# different cases
keyword = extracted[0].lower()
# Add the filter
# Note: perhaps handlers can be removed somehow using sql.get_chat_filters
for handler in dispatcher.handlers.get(HANDLER_GROUP, []):
if handler.filters == (keyword, chat_id):
dispatcher.remove_handler(handler, HANDLER_GROUP)
text, file_type, file_id = get_filter_type(msg)
if not msg.reply_to_message and len(extracted) >= 2:
offset = len(extracted[1]) - len(
msg.text) # set correct offset relative to command + notename
text, buttons = button_markdown_parser(extracted[1],
entities=msg.parse_entities(),
offset=offset)
text = text.strip()
if not text:
send_message(
update.effective_message,
"Tidak ada pesan catatan - Anda tidak bisa HANYA memiliki tombol, Anda perlu pesan untuk menyertainya!",
)
return
elif msg.reply_to_message and len(args) >= 2:
if msg.reply_to_message.text:
text_to_parsing = msg.reply_to_message.text
elif msg.reply_to_message.caption:
text_to_parsing = msg.reply_to_message.caption
else:
text_to_parsing = ""
offset = len(text_to_parsing
) # set correct offset relative to command + notename
text, buttons = button_markdown_parser(text_to_parsing,
entities=msg.parse_entities(),
offset=offset)
text = text.strip()
elif not text and not file_type:
send_message(
update.effective_message,
"Harap berikan kata kunci untuk balasan filter ini dengan!",
)
return
elif msg.reply_to_message:
if msg.reply_to_message.text:
text_to_parsing = msg.reply_to_message.text
elif msg.reply_to_message.caption:
text_to_parsing = msg.reply_to_message.caption
else:
text_to_parsing = ""
offset = len(text_to_parsing
) # set correct offset relative to command + notename
text, buttons = button_markdown_parser(text_to_parsing,
entities=msg.parse_entities(),
offset=offset)
text = text.strip()
if (msg.reply_to_message.text
or msg.reply_to_message.caption) and not text:
send_message(
update.effective_message,
"Tidak ada pesan catatan - Anda tidak bisa HANYA memiliki tombol, Anda perlu pesan untuk menyertainya!",
)
return
else:
send_message(update.effective_message, "Filter tidak valid!")
return
add = addnew_filter(update, chat_id, keyword, text, file_type, file_id,
buttons)
# This is an old method
# sql.add_filter(chat_id, keyword, content, is_sticker, is_document, is_image, is_audio, is_voice, is_video, buttons)
if add:
send_message(
update.effective_message,
"Filter tersimpan '{}' di *{}*!".format(keyword, chat_name),
parse_mode=telegram.ParseMode.MARKDOWN,
)
raise DispatcherHandlerStop
def lock(update, context) -> str:
args = context.args
chat = update.effective_chat
user = update.effective_user
if (
can_delete(chat, context.bot.id)
or update.effective_message.chat.type == "private"
):
if len(args) >= 1:
ltype = args[0].lower()
if ltype in LOCK_TYPES:
# Connection check
conn = connected(
context.bot, update, chat, user.id, need_admin=True
)
if conn:
chat = dispatcher.bot.getChat(conn)
chat_id = conn
chat_name = chat.title
text = (
"Mengunci semua {} pesan untuk non-admin di {}!".format(
ltype, chat_name
)
)
else:
if update.effective_message.chat.type == "private":
send_message(
update.effective_message,
"Perintah ini dimaksudkan untuk digunakan dalam grup bukan di PM",
)
return ""
chat = update.effective_chat
chat_id = update.effective_chat.id
chat_name = update.effective_message.chat.title
text = "Mengunci semua {} pesan untuk non-admin!".format(
ltype
)
sql.update_lock(chat.id, ltype, locked=True)
send_message(
update.effective_message, text, parse_mode="markdown"
)
return (
"<b>{}:</b>"
"\n#LOCK"
"\n<b>Admin:</b> {}"
"\nLocked <code>{}</code>.".format(
html.escape(chat.title),
mention_html(user.id, user.first_name),
ltype,
)
)
elif ltype in LOCK_CHAT_RESTRICTION:
# Connection check
conn = connected(
context.bot, update, chat, user.id, need_admin=True
)
if conn:
chat = dispatcher.bot.getChat(conn)
chat_id = conn
chat_name = chat.title
text = "Terkunci {} untuk semua non-admin di {}!".format(
ltype, chat_name
)
else:
if update.effective_message.chat.type == "private":
send_message(
update.effective_message,
"Perintah ini dimaksudkan untuk digunakan dalam grup bukan di PM.",
)
return ""
chat = update.effective_chat
chat_id = update.effective_chat.id
chat_name = update.effective_message.chat.title
text = "Terkunci {} untuk semua non-admin!".format(ltype)
current_permission = context.bot.getChat(chat_id).permissions
context.bot.set_chat_permissions(
chat_id=chat_id,
permissions=get_permission_list(
eval(str(current_permission)),
LOCK_CHAT_RESTRICTION[ltype.lower()],
),
)
send_message(
update.effective_message, text, parse_mode="markdown"
)
return (
"<b>{}:</b>"
"\n#Permission_LOCK"
"\n<b>Admin:</b> {}"
"\nLocked <code>{}</code>.".format(
html.escape(chat.title),
mention_html(user.id, user.first_name),
ltype,
)
)
else:
send_message(
update.effective_message,
"Apa yang kamu coba kunci ...? Coba /locktypes untuk daftar yang dapat dikunci",
)
else:
send_message(
update.effective_message, "Apa yang Anda coba kunci...?"
)
else:
send_message(
update.effective_message,
"Saya bukan administrator atau tidak punya cukup hak.",
)
return ""
def welcome(update, context):
chat = update.effective_chat
args = context.args
reply = update.message.message_id
# 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)
update.effective_message.reply_text(
"Obrolan ini memiliki setelan selamat datang yang disetel ke: `{}`.\n*Pengaturan saat ini "
"(tidak mengisi {{}}):*".format(pref),
parse_mode=ParseMode.MARKDOWN,
)
buttons = sql.get_welc_buttons(chat.id)
if (welcome_type == sql.Types.BUTTON_TEXT
or welcome_type == sql.Types.TEXT):
if noformat:
welcome_m += revert_buttons(buttons)
send_message(update.effective_message, welcome_m)
else:
if buttons:
keyb = build_keyboard(buttons)
keyboard = InlineKeyboardMarkup(keyb)
else:
keyboard = None
send(update, welcome_m, keyboard, sql.DEFAULT_WELCOME)
else:
if noformat:
welcome_m += revert_buttons(buttons)
ENUM_FUNC_MAP[welcome_type](chat.id,
cust_content,
caption=welcome_m)
else:
if buttons:
keyb = build_keyboard_parser(context.bot, chat.id, buttons)
keyboard = InlineKeyboardMarkup(keyb)
else:
keyboard = None
if ENUM_FUNC_MAP[welcome_type] == dispatcher.bot.send_sticker:
ENUM_FUNC_MAP[welcome_type](
chat.id,
cust_content,
reply_to_message_id=reply,
reply_markup=keyboard,
)
else:
ENUM_FUNC_MAP[welcome_type](
chat.id,
cust_content,
caption=welcome_m,
reply_markup=keyboard,
parse_mode=ParseMode.MARKDOWN,
)
elif len(args) >= 1:
if args[0].lower() in ("on", "yes"):
sql.set_welc_preference(str(chat.id), True)
update.effective_message.reply_text("I'll be polite!")
elif args[0].lower() in ("off", "no"):
sql.set_welc_preference(str(chat.id), False)
update.effective_message.reply_text(
"Aku akan diam, tidak akan menyapa lagi.")
else:
# idek what you're writing, say yes or no
update.effective_message.reply_text(
"Saya hanya mengerti 'on/yes' atau 'off/no' saja!")
def blacklist_mode(update, context):
chat = update.effective_chat
user = update.effective_user
msg = update.effective_message
args = context.args
conn = connected(context.bot, update, chat, user.id, need_admin=True)
if conn:
chat = dispatcher.bot.getChat(conn)
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
else:
if update.effective_message.chat.type == "private":
send_message(
update.effective_message,
"Perintah ini hanya dapat digunakan di grup bukan di PM",
)
return ""
chat = update.effective_chat
chat_id = update.effective_chat.id
chat_name = update.effective_message.chat.title
if args:
if (args[0].lower() == "off" or args[0].lower() == "nothing"
or args[0].lower() == "no"):
settypeblacklist = "do nothing"
blacklist_db.set_blacklist_strength(chat_id, 0, "0")
elif args[0].lower() == "del" or args[0].lower() == "delete":
settypeblacklist = "will delete blacklisted message"
blacklist_db.set_blacklist_strength(chat_id, 1, "0")
elif args[0].lower() == "warn":
settypeblacklist = "warn the sender"
blacklist_db.set_blacklist_strength(chat_id, 2, "0")
elif args[0].lower() == "mute":
settypeblacklist = "mute the sender"
blacklist_db.set_blacklist_strength(chat_id, 3, "0")
elif args[0].lower() == "kick":
settypeblacklist = "kick the sender"
blacklist_db.set_blacklist_strength(chat_id, 4, "0")
elif args[0].lower() == "ban":
settypeblacklist = "ban the sender"
blacklist_db.set_blacklist_strength(chat_id, 5, "0")
elif args[0].lower() == "tban":
if len(args) == 1:
teks = """Sepertinya Anda mencoba menyetel nilai waktu untuk daftar hitam tetapi Anda tidak menentukan waktu; Coba, `/blacklistmode tban <timevalue>`.
Contoh nilai waktu: 4m = 4 menit, 3h = 3 jam, 6d = 6 hari, 5w = 5 minggu."""
send_message(update.effective_message,
teks,
parse_mode="markdown")
return ""
restime = extract_time(msg, args[1])
if not restime:
teks = """Nilai waktu tidak valid!
Contoh nilai waktu: 4m = 4 menit, 3h = 3 jam, 6d = 6 hari, 5w = 5 minggu."""
send_message(update.effective_message,
teks,
parse_mode="markdown")
return ""
settypeblacklist = "larangan sementara untuk {}".format(args[1])
blacklist_db.set_blacklist_strength(chat_id, 6, str(args[1]))
elif args[0].lower() == "tmute":
if len(args) == 1:
teks = """Sepertinya Anda mencoba menyetel nilai waktu untuk daftar hitam tetapi Anda tidak menentukan waktu; Coba, `/blacklistmode tmute <timevalue>`.
Contoh nilai waktu: 4m = 4 menit, 3h = 3 jam, 6d = 6 hari, 5w = 5 minggu."""
send_message(update.effective_message,
teks,
parse_mode="markdown")
return ""
restime = extract_time(msg, args[1])
if not restime:
teks = """Nilai waktu tidak valid!
Contoh nilai waktu: 4m = 4 menit, 3h = 3 jam, 6d = 6 hari, 5w = 5 minggu."""
send_message(update.effective_message,
teks,
parse_mode="markdown")
return ""
settypeblacklist = "bisukan sementara untuk {}".format(args[1])
blacklist_db.set_blacklist_strength(chat_id, 7, str(args[1]))
else:
send_message(
update.effective_message,
"Saya hanya mengerti: off/del/warn/ban/kick/mute/tban/tmute!",
)
return ""
if conn:
text = "Modus daftar hitam diubah `{}` di *{}*!".format(
settypeblacklist, chat_name)
else:
text = "Modus daftar hitam diubah: `{}`!".format(settypeblacklist)
send_message(update.effective_message, text, parse_mode="markdown")
return ("<b>{}:</b>\n"
"<b>Admin:</b> {}\n"
"Changed the blacklist mode. will {}.".format(
html.escape(chat.title),
mention_html(user.id, user.first_name),
settypeblacklist,
))
else:
getmode, getvalue = blacklist_db.get_blacklist_setting(chat.id)
if getmode == 0:
settypeblacklist = "do nothing"
elif getmode == 1:
settypeblacklist = "delete"
elif getmode == 2:
settypeblacklist = "warn"
elif getmode == 3:
settypeblacklist = "mute"
elif getmode == 4:
settypeblacklist = "kick"
elif getmode == 5:
settypeblacklist = "ban"
elif getmode == 6:
settypeblacklist = "temporarily ban for {}".format(getvalue)
elif getmode == 7:
settypeblacklist = "temporarily mute for {}".format(getvalue)
if conn:
text = "Mode daftar hitam saat ini: *{}* di *{}*.".format(
settypeblacklist, chat_name)
else:
text = "Mode daftar hitam saat ini: *{}*.".format(settypeblacklist)
send_message(update.effective_message,
text,
parse_mode=ParseMode.MARKDOWN)
return ""
