def blackliststicker(update, context):
msg = update.effective_message # type: Optional[Message]
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[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
sticker_list = tl(update.effective_message, "<b>Daftar hitam stiker saat saat ini di {}:</b>\n").format(chat_name)
all_stickerlist = sql.get_chat_stickers(chat_id)
if len(args) > 0 and args[0].lower() == 'copy':
for trigger in all_stickerlist:
sticker_list += "<code>{}</code>\n".format(html.escape(trigger))
elif len(args) == 0:
for trigger in all_stickerlist:
sticker_list += " - <code>{}</code>\n".format(html.escape(trigger))
split_text = split_message(sticker_list)
for text in split_text:
if sticker_list == tl(update.effective_message, "<b>Daftar hitam stiker saat saat ini di {}:</b>\n").format(chat_name).format(chat_name):
send_message(update.effective_message, tl(update.effective_message, "Tidak ada stiker daftar hitam stiker di <b>{}</b>!").format(chat_name), parse_mode=ParseMode.HTML)
return
send_message(update.effective_message, text, parse_mode=ParseMode.HTML)
def report_alt(update, context) -> str:
message = update.effective_message # type: Optional[Message]
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
if chat and message.reply_to_message and sql.chat_should_report(chat.id):
reported_user = message.reply_to_message.from_user
admin_list = chat.get_administrators()
msg = tl(update.effective_message, "<b>{}:</b>" \
"\n<b>Pengguna yang dilaporkan:</b> {} (<code>{}</code>)" \
"\n<b>Dilaporkan oleh:</b> {} (<code>{}</code>)").format(html.escape(chat.title),
mention_html(
reported_user.id,
reported_user.first_name),
reported_user.id,
mention_html(user.id,
user.first_name),
user.id)
all_admins = []
for admin in admin_list:
if admin.user.is_bot: # don't tag bot
continue
if sql.user_should_report(admin.user.id):
all_admins.append("<a href='tg://user?id={}'></a>".format(admin.user.id))
context.bot.send_message(chat.id, tl(update.effective_message, "⚠️ {} <b>telah di laporkan ke admin!</b>{}").format(
mention_html(reported_user.id, reported_user.first_name),
"".join(all_admins)), parse_mode=ParseMode.HTML, reply_to_message_id=message.reply_to_message.message_id)
return msg
return ""
def __chat_settings__(chat_id, user_id):
administrators = dispatcher.bot.getChatAdministrators(chat_id)
chat = dispatcher.bot.getChat(chat_id)
text = "Admin in *{}*:".format(chat.title or "chat ini")
for admin in administrators:
user = admin.user
status = admin.status
if user.first_name == '':
name = tl(user_id, "☠Deleted Account")
else:
name = "{}".format(
mention_markdown(
user.id, user.first_name + " " + (user.last_name or "")))
#if user.username:
# name = escape_markdown("@" + user.username)
if status == "creator":
text += "\n 👑 Creator:"
text += "\n` • `{} \n\n 🔱 Admin:".format(name)
for admin in administrators:
user = admin.user
status = admin.status
if user.first_name == '':
name = tl(user_id, "☠Deleted Account")
else:
name = "{}".format(
mention_markdown(
user.id, user.first_name + " " + (user.last_name or "")))
#if user.username:
# name = escape_markdown("@" + user.username)
if status == "administrator":
text += "\n` • `{}".format(name)
text += tl(user_id, "\n\nYou are *{}*").format(
dispatcher.bot.get_chat_member(chat_id, user_id).status)
return text
def connection_chat(update, context):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
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":
return
chat = update.effective_chat
chat_id = update.effective_chat.id
chat_name = update.effective_message.chat.title
if conn:
teks = languages.tl(
update.effective_message,
"Saat ini Anda terhubung dengan {}.\n").format(chat_name)
else:
teks = languages.tl(update.effective_message,
"Saat ini Anda tidak terhubung dengan grup.\n")
teks += languages.tl(update.effective_message, "supportcmd")
send_message(update.effective_message, teks, parse_mode="markdown")
def button(update, context):
query = update.callback_query # type: Optional[CallbackQuery]
user = update.effective_user # type: Optional[User]
match = re.match(r"rm_warn\((.+?)\)", query.data)
if match:
user_id = match.group(1)
chat = update.effective_chat # type: Optional[Chat]
res = sql.remove_warn(user_id, chat.id)
if res:
update.effective_message.edit_text(tl(
update.effective_message,
"Peringatkan dihapus oleh {}.").format(
mention_html(user.id, user.first_name)),
parse_mode=ParseMode.HTML)
user_member = chat.get_member(user_id)
return "<b>{}:</b>" \
"\n#UNWARN" \
"\n<b>Admin:</b> {}" \
"\n<b>User:</b> {} (<code>{}</code>)".format(html.escape(chat.title),
mention_html(user.id, user.first_name),
mention_html(user_member.user.id, user_member.user.first_name),
user_member.user.id)
else:
update.effective_message.edit_text(tl(
update.effective_message,
"Pengguna sudah tidak memiliki peringatan.").format(
mention_html(user.id, user.first_name)),
parse_mode=ParseMode.HTML)
return ""
def enable(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_id = conn
chat_name = dispatcher.bot.getChat(conn).title
else:
if update.effective_message.chat.type == "private":
send_message(update.effective_message, languages.tl(update.effective_message, "Anda bisa lakukan command ini pada grup, bukan pada PM"))
return ""
chat = update.effective_chat
chat_id = update.effective_chat.id
chat_name = update.effective_message.chat.title
if len(args) >= 1:
enable_cmd = args[0]
if enable_cmd.startswith(CMD_STARTERS):
enable_cmd = enable_cmd[1:]
if sql.enable_command(chat.id, enable_cmd):
if conn:
text = languages.tl(update.effective_message, "Diaktifkan penggunaan `{}` pada *{}*").format(enable_cmd, chat_name)
else:
text = languages.tl(update.effective_message, "Diaktifkan penggunaan `{}`").format(enable_cmd)
send_message(update.effective_message, text,
parse_mode=ParseMode.MARKDOWN)
else:
send_message(update.effective_message, languages.tl(update.effective_message, "Apakah itu bahkan dinonaktifkan?"))
else:
send_message(update.effective_message, languages.tl(update.effective_message, "Apa yang harus saya aktifkan?"))
def __chat_settings__(chat_id, user_id):
log_channel = sql.get_chat_log_channel(chat_id)
if log_channel:
log_channel_info = dispatcher.bot.get_chat(log_channel)
return tl(user_id, "Grup ini memiliki semua log yang dikirim ke: {} (`{}`)").format(escape_markdown(log_channel_info.title),
log_channel)
return tl(user_id, "Tidak ada saluran masuk yang ditetapkan untuk grup ini!")
def connected(bot, update, chat, user_id, need_admin=True):
user = update.effective_user # type: Optional[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):
if need_admin == True:
if getstatusadmin.status in (
'administrator', 'creator') or user_id in SUDO_USERS:
return conn_id
else:
send_message(
update.effective_message,
languages.tl(
update.effective_message,
"Anda harus menjadi admin dalam grup yang terhubung!"
))
else:
return conn_id
else:
send_message(
update.effective_message,
languages.tl(
update.effective_message,
"Grup mengubah koneksi hak atau Anda bukan admin lagi.\nSaya putuskan koneksi Anda."
))
disconnect_chat(update, bot)
else:
return False
def permapin(update, context):
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=False)
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,
tl(update.effective_message,
"You can do this command in groups, not PM"))
return ""
chat = update.effective_chat
chat_id = update.effective_chat.id
chat_name = update.effective_message.chat.title
text, data_type, content, buttons = get_message_type(message)
tombol = build_keyboard_alternate(buttons)
try:
message.delete()
except BadRequest:
pass
if str(data_type) in ('Types.BUTTON_TEXT', 'Types.TEXT'):
try:
sendingmsg = context.bot.send_message(
chat_id,
text,
parse_mode="markdown",
disable_web_page_preview=True,
reply_markup=InlineKeyboardMarkup(tombol))
except BadRequest:
context.bot.send_message(
chat_id,
tl(
update.effective_message,
"Wrong markdown text!\nIf you don't know what markdown is, please type `/markdownhelp` in PM."
),
parse_mode="markdown")
return
else:
sendingmsg = ENUM_FUNC_MAP[str(data_type)](
chat_id,
content,
caption=text,
parse_mode="markdown",
disable_web_page_preview=True,
reply_markup=InlineKeyboardMarkup(tombol))
try:
context.bot.pinChatMessage(chat_id, sendingmsg.message_id)
except BadRequest:
send_message(
update.effective_message,
tl(update.effective_message,
"I don't have access to pin message!"))
def purge(update, context):
args = context.args
msg = update.effective_message # type: Optional[Message]
if msg.reply_to_message:
user = update.effective_user # type: Optional[User]
chat = update.effective_chat # type: Optional[Chat]
if user_can_delete(chat, user, context.bot.id):
message_id = msg.reply_to_message.message_id
if args and args[0].isdigit():
delete_to = message_id + int(args[0])
else:
delete_to = msg.message_id - 1
for m_id in range(delete_to, message_id - 1,
-1): # Reverse iteration over message ids
try:
context.bot.deleteMessage(chat.id, m_id)
except BadRequest as err:
if err.message == "Message can't be deleted":
send_message(
update.effective_message,
tl(
update.effective_message,
"Tidak dapat menghapus semua pesan. Pesannya mungkin terlalu lama, saya mungkin "
"tidak memiliki hak menghapus, atau ini mungkin bukan supergrup."
))
elif err.message != "Message to delete not found":
LOGGER.exception("Error while purging chat messages.")
try:
msg.delete()
except BadRequest as err:
if err.message == "Message can't be deleted":
send_message(
update.effective_message,
tl(
update.effective_message,
"Tidak dapat menghapus semua pesan. Pesannya mungkin terlalu lama, saya mungkin "
"tidak memiliki hak menghapus, atau ini mungkin bukan supergrup."
))
elif err.message != "Message to delete not found":
LOGGER.exception("Error while purging chat messages.")
send_message(update.effective_message,
tl(update.effective_message, "Pembersihan selesai."))
return "<b>{}:</b>" \
"\n#PURGE" \
"\n<b>Admin:</b> {}" \
"\nPurged <code>{}</code> messages.".format(html.escape(chat.title),
mention_html(user.id, user.first_name),
delete_to - message_id)
else:
send_message(
update.effective_message,
tl(update.effective_message,
"Balas pesan untuk memilih tempat mulai membersihkan."))
return ""
def setlog(update, context):
message = update.effective_message # type: Optional[Message]
chat = update.effective_chat # type: Optional[Chat]
if chat.type == chat.CHANNEL:
send_message(update.effective_message, tl(update.effective_message, "Sekarang, teruskan /setlog ke grup yang Anda ingin ikat saluran ini!"))
elif message.forward_from_chat:
sql.set_chat_log_channel(chat.id, message.forward_from_chat.id)
try:
message.delete()
except BadRequest as excp:
if excp.message == "Message to delete not found":
pass
else:
LOGGER.exception("Error deleting message in log channel. Should work anyway though.")
try:
context.bot.send_message(message.forward_from_chat.id,
tl(update.effective_message, "Saluran ini telah ditetapkan sebagai saluran log untuk {}.").format(
chat.title or chat.first_name))
except Unauthorized as excp:
if excp.message == "Forbidden: bot is not a member of the channel chat":
context.bot.send_message(chat.id, tl(update.effective_message, "Gagal menyetel saluran log!\nSaya mungkin bukan admin di channel tersebut."))
sql.stop_chat_logging(chat.id)
return
else:
LOGGER.exception("ERROR in setting the log channel.")
context.bot.send_message(chat.id, tl(update.effective_message, "Berhasil mengatur saluran log!"))
else:
send_message(update.effective_message, tl(update.effective_message, "Langkah-langkah untuk mengatur saluran log adalah:\n"
" - tambahkan bot ke saluran yang diinginkan\n"
" - Kirimkan /setlog ke saluran\n"
" - Teruskan /setlog ke grup\n"))
def buttonask(bot, update):
query = update.callback_query
splitter = query.data.replace("ak_", "").split("+")
isyes = splitter[1].split('|')[0]
report_chat = splitter[1].split('|')[1].split('=')[0]
report_target = splitter[1].split('|')[1].split('=')[1]
chat = update.effective_chat
msg = CURRENT_REPORT.get(str(report_chat))
userinfo = CURRENT_REPORT.get(str(report_chat)+"user")
key = CURRENT_REPORT.get(str(report_chat)+"key")
if isyes == "y":
a, b = user_protection_checker(context.bot, report_target)
if not a:
context.bot.edit_message_text(text=msg + b,
chat_id=query.message.chat_id,
message_id=query.message.message_id, parse_mode=ParseMode.HTML)
return
if splitter[0] == "1":
try:
context.bot.unbanChatMember(report_chat, report_target)
context.bot.sendMessage(report_chat, text=tl(update.effective_message, "{} telah di tendang!\nOleh: {}").format(\
mention_markdown(userinfo['id'], userinfo['name']), mention_markdown(chat.id, chat.first_name)), \
parse_mode=ParseMode.MARKDOWN)
context.bot.edit_message_text(text=msg + tl(update.effective_message, "\n\n{} telah di tendang!").format(mention_html(userinfo['id'], userinfo['name'])),
chat_id=query.message.chat_id,
message_id=query.message.message_id, parse_mode=ParseMode.HTML)
except Exception as err:
context.bot.edit_message_text(text=msg + "\n\nError: {}".format(err),
chat_id=query.message.chat_id,
message_id=query.message.message_id, parse_mode=ParseMode.HTML)
elif splitter[0] == "2":
try:
context.bot.kickChatMember(report_chat, report_target)
context.bot.sendMessage(report_chat, text=tl(update.effective_message, "{} telah di banned!\nOleh: {}").format(\
mention_markdown(userinfo['id'], userinfo['name']), mention_markdown(chat.id, chat.first_name)), \
parse_mode=ParseMode.MARKDOWN)
context.bot.edit_message_text(text=msg + tl(update.effective_message, "\n\n{} telah di banned!").format(mention_html(userinfo['id'], userinfo['name'])),
chat_id=query.message.chat_id,
message_id=query.message.message_id, parse_mode=ParseMode.HTML)
except Exception as err:
context.bot.edit_message_text(text=msg + "\n\nError: {}".format(err),
chat_id=query.message.chat_id,
message_id=query.message.message_id, parse_mode=ParseMode.HTML)
elif splitter[0] == "3":
try:
context.bot.deleteMessage(report_chat, report_target)
context.bot.edit_message_text(text=msg + tl(update.effective_message, "\n\nPesan dihapus!"),
chat_id=query.message.chat_id,
message_id=query.message.message_id, parse_mode=ParseMode.HTML)
except Exception as err:
context.bot.edit_message_text(text=msg + "\n\nError: {}".format(err),
chat_id=query.message.chat_id,
message_id=query.message.message_id, parse_mode=ParseMode.HTML)
elif isyes == "n":
context.bot.edit_message_text(text=msg,
chat_id=query.message.chat_id,
message_id=query.message.message_id, parse_mode=ParseMode.HTML,
reply_markup=key)
def start(update, context):
if update.effective_chat.type == "private":
args = context.args
if len(args) >= 1:
if args[0].lower() == "help":
send_help(update.effective_chat.id, tl(update.effective_message, HELP_STRINGS))
elif args[0].lower() == "get_notes":
update.effective_message.reply_text(tl(update.effective_message, "Now you can get notes in group."))
elif args[0].lower().startswith("stngs_"):
match = re.match("stngs_(.*)", args[0].lower())
chat = dispatcher.bot.getChat(match.group(1))
if is_user_admin(chat, update.effective_user.id):
send_settings(match.group(1), update.effective_user.id, False)
else:
send_settings(match.group(1), update.effective_user.id, True)
elif args[0][1:].isdigit() and "rules" in IMPORTED:
IMPORTED["rules"].send_rules(update, args[0], from_pm=True)
elif args[0][:4] == "wiki":
wiki = args[0].split("-")[1].replace('_', ' ')
message = update.effective_message
getlang = langsql.get_lang(message)
if getlang == "pt":
wikipedia.set_lang("pt")
pagewiki = wikipedia.page(wiki)
judul = pagewiki.title
summary = pagewiki.summary
if len(summary) >= 4096:
summary = summary[:4000]+"..."
message.reply_text("<b>{}</b>\n{}".format(judul, summary), parse_mode=ParseMode.HTML,
reply_markup=InlineKeyboardMarkup(
[[InlineKeyboardButton(text=tl(update.effective_message, "Read on Wikipedia"), url=pagewiki.url)]]))
elif args[0][:6].lower() == "verify":
chat_id = args[0].split("_")[1]
verify_welcome(update, context, chat_id)
elif args[0][:6].lower() == "verify":
chat_id = args[0].split("_")[1]
verify_welcome(update, context, chat_id)
else:
first_name = update.effective_user.first_name
buttons = InlineKeyboardMarkup(
[[InlineKeyboardButton(text="📃 Half_SATAN's Docs", url="https://telegra.ph/")],
[InlineKeyboardButton(text="⚙️ Connections", callback_data="main_connect")],
[InlineKeyboardButton(text="🇺🇸 Language", callback_data="main_setlang"), InlineKeyboardButton(text="❓ Help", callback_data="help_back")]])
update.effective_message.reply_text(
tl(update.effective_message, PM_START_TEXT).format(escape_markdown(first_name), escape_markdown(context.bot.first_name), OWNER_ID),
disable_web_page_preview=True,
parse_mode=ParseMode.MARKDOWN,
reply_markup=buttons)
else:
update.effective_message.reply_text(tl(update.effective_message, "Is there anything I can help? 😊"))
def build_curr_disabled(chat_id: Union[str, int]) -> str:
disabled = sql.get_all_disabled(chat_id)
if not disabled:
return languages.tl(chat_id, "Tidak ada perintah yang dinonaktifkan!")
result = ""
for cmd in disabled:
result += " - `{}`\n".format(escape_markdown(cmd))
return languages.tl(chat_id, "Perintah-perintah berikut saat ini dibatasi:\n{}").format(result)
def list_cmds(update, context):
if DISABLE_CMDS + DISABLE_OTHER:
result = ""
for cmd in set(DISABLE_CMDS + DISABLE_OTHER):
result += " - `{}`\n".format(escape_markdown(cmd))
send_message(update.effective_message, languages.tl(update.effective_message, "Perintah berikut dapat diubah:\n{}").format(result),
parse_mode=ParseMode.MARKDOWN)
else:
send_message(update.effective_message, languages.tl(update.effective_message, "Tidak ada perintah yang dapat dinonaktifkan."))
def add_warn_filter(update, context):
chat = update.effective_chat # type: Optional[Chat]
msg = update.effective_message # type: Optional[Message]
user = update.effective_user # type: Optional[User]
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,
tl(update.effective_message,
"Anda bisa lakukan command ini pada grup, bukan pada PM"))
return ""
chat = update.effective_chat
chat_id = update.effective_chat.id
chat_name = update.effective_message.chat.title
args = msg.text.split(
None,
1) # use python's maxsplit to separate Cmd, keyword, and reply_text
if len(args) < 2:
return
extracted = split_quotes(args[1])
if len(extracted) >= 2:
# set trigger -> lower, so as to avoid adding duplicate filters with different cases
keyword = extracted[0].lower()
content = extracted[1]
else:
return
# Note: perhaps handlers can be removed somehow using sql.get_chat_filters
for handler in dispatcher.handlers.get(WARN_HANDLER_GROUP, []):
if handler.filters == (keyword, chat.id):
dispatcher.remove_handler(handler, WARN_HANDLER_GROUP)
sql.add_warn_filter(chat.id, keyword, content)
if conn:
text = tl(
update.effective_message,
"Peringatkan handler yang ditambahkan untuk '{}' pada *{}*!"
).format(keyword, chat_name)
else:
text = tl(
update.effective_message,
"Peringatkan handler yang ditambahkan untuk '{}'!").format(keyword)
send_message(update.effective_message, text, parse_mode="markdown")
raise DispatcherHandlerStop
def unsetlog(update, context):
message = update.effective_message # type: Optional[Message]
chat = update.effective_chat # type: Optional[Chat]
log_channel = sql.stop_chat_logging(chat.id)
if log_channel:
context.bot.send_message(log_channel, tl(update.effective_message, "Channel telah dibatalkan tautannya {}").format(chat.title))
send_message(update.effective_message, tl(update.effective_message, "Log saluran telah dinonaktifkan."))
else:
send_message(update.effective_message, tl(update.effective_message, "Belum ada saluran log yang ditetapkan!"))
def send_log(bot: Bot, log_chat_id: str, orig_chat_id: str, result: str):
try:
bot.send_message(log_chat_id, result, parse_mode=ParseMode.HTML)
except BadRequest as excp:
if excp.message == "Chat not found":
bot.send_message(orig_chat_id, tl(update.effective_message, "This log channel has been deleted - unsetting."))
sql.stop_chat_logging(orig_chat_id)
else:
LOGGER.warning(excp.message)
LOGGER.warning(result)
LOGGER.exception("Could not parse")
bot.send_message(log_chat_id, result + tl(update.effective_message, "\n\nFormatting has been disabled due to an unexpected error."))
def add_blacklist(update, context):
msg = update.effective_message # type: Optional[Message]
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[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:
sql.add_to_blacklist(chat_id, trigger.lower())
if len(to_blacklist) == 1:
send_message(
update.effective_message,
tl(
update.effective_message,
"<code>{}</code> ditambahkan ke daftar hitam di <b>{}</b>!"
).format(html.escape(to_blacklist[0]), chat_name),
parse_mode=ParseMode.HTML)
else:
send_message(
update.effective_message,
tl(
update.effective_message,
"<code>{}</code> Pemicu ditambahkan ke daftar hitam di <b>{}</b>!"
).format(len(to_blacklist), chat_name),
parse_mode=ParseMode.HTML)
else:
send_message(
update.effective_message,
tl(
update.effective_message,
"Beri tahu saya kata-kata apa yang ingin Anda hapus dari daftar hitam."
))
def logging(update, context):
message = update.effective_message # type: Optional[Message]
chat = update.effective_chat # type: Optional[Chat]
log_channel = sql.get_chat_log_channel(chat.id)
if log_channel:
log_channel_info = context.bot.get_chat(log_channel)
send_message(update.effective_message,
tl(update.effective_message, "These group have all logs sent to: {} (`{}`)").format(escape_markdown(log_channel_info.title),
log_channel),
parse_mode=ParseMode.MARKDOWN)
else:
send_message(update.effective_message, tl(update.effective_message, "Tidak ada saluran log yang telah ditetapkan untuk grup ini!"))
def log_user(update, context):
chat = update.effective_chat # type: Optional[Chat]
msg = update.effective_message # type: Optional[Message]
"""text = msg.text if msg.text else ""
uid = msg.from_user.id
uname = msg.from_user.name
print("{} | {} | {} | {}".format(text, uname, uid, chat.title))"""
fed_id = fedsql.get_fed_id(chat.id)
if fed_id:
user = update.effective_user
if user:
fban, fbanreason, fbantime = fedsql.get_fban_user(fed_id, user.id)
if fban:
send_message(update.effective_message, languages.tl(update.effective_message, "Pengguna ini dilarang di federasi saat ini!\nAlasan: `{}`").format(fbanreason), parse_mode="markdown")
try:
context.bot.kick_chat_member(chat.id, user.id)
except:
print("Fban: cannot banned this user")
sql.update_user(msg.from_user.id,
msg.from_user.username,
chat.id,
chat.title)
if msg.reply_to_message:
sql.update_user(msg.reply_to_message.from_user.id,
msg.reply_to_message.from_user.username,
chat.id,
chat.title)
if msg.forward_from:
sql.update_user(msg.forward_from.id,
msg.forward_from.username)
def shout(update, context):
message = update.effective_message
chat = update.effective_chat
args = context.args
noreply = False
if message.reply_to_message:
data = message.reply_to_message.text
elif args:
noreply = True
data = " ".join(args)
else:
noreply = True
data = tl(chat.id, "I need a message to meme.")
msg = "```"
result = []
result.append(' '.join([s for s in data]))
for pos, symbol in enumerate(data[1:]):
result.append(symbol + ' ' + ' ' * pos + symbol)
result = list("\n".join(result))
result[0] = data[0]
result = "".join(result)
msg = "```\n" + result + "```"
return update.effective_message.reply_text(msg, parse_mode="MARKDOWN")
def deepfryer(update, context):
message = update.effective_message
chat = update.effective_chat
if message.reply_to_message:
data = message.reply_to_message.photo
data2 = message.reply_to_message.sticker
else:
data = []
data2 = []
# check if message does contain media and cancel when not
if not data and not data2:
message.reply_text(tl(chat.id, "What am I supposed to do with this?!"))
return
# download last photo (highres) as byte array
if data:
photodata = data[len(data) - 1].get_file().download_as_bytearray()
image = Image.open(io.BytesIO(photodata))
elif data2:
sticker = context.bot.get_file(data2.file_id)
sticker.download('cache/sticker.png')
image = Image.open("cache/sticker.png")
# the following needs to be executed async (because dumb lib)
bot = context.bot
loop = asyncio.new_event_loop()
loop.run_until_complete(
process_deepfry(image, message.reply_to_message, bot, context))
loop.close()
def permanent_pin(update, context):
user = update.effective_user # type: Optional[User]
chat = update.effective_chat # type: Optional[Chat]
message = update.effective_message
get_permapin = sql.get_permapin(chat.id)
if get_permapin and not user.id == context.bot.id:
try:
to_del = context.bot.pinChatMessage(chat.id,
get_permapin,
disable_notification=True)
except BadRequest:
sql.set_permapin(chat.id, 0)
if chat.username:
old_pin = "https://t.me/{}/{}".format(chat.username,
get_permapin)
else:
old_pin = "https://t.me/c/{}/{}".format(
str(chat.id)[4:], get_permapin)
send_message(
update.effective_message,
tl(
update.effective_message,
"*Permanent pin error:*\nI can't pin messages here!\nMake sure I'm admin and can pin messages.\n\nPermanent pin disabled now, [here is your old pinned message]({})"
).format(old_pin),
parse_mode="markdown")
return
if to_del:
try:
context.bot.deleteMessage(chat.id, message.message_id + 1)
except BadRequest:
print("Permanent pin error: cannot delete pin msg")
def timeout_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, tl(update.effective_message, "Anda bisa lakukan command ini pada grup, bukan pada PM"))
return ""
chat = update.effective_chat
chat_id = update.effective_chat.id
chat_name = update.effective_message.chat.title
getcur, extra_verify, cur_value, timeout, timeout_mode, cust_text = sql.welcome_security(chat.id)
if args:
if args[0].lower() == 'kick' or args[0].lower() == 'tendang' or args[0].lower() == 'leave':
settypeblacklist = tl(update.effective_message, 'kick')
sql.set_welcome_security(chat.id, getcur, extra_verify, cur_value, timeout, 1, cust_text)
elif args[0].lower() == 'ban' or args[0].lower() == 'banned':
settypeblacklist = tl(update.effective_message, 'banned')
sql.set_welcome_security(chat.id, getcur, extra_verify, cur_value, timeout, 2, cust_text)
else:
send_message(update.effective_message, tl(update.effective_message, "Saya hanya mengerti kick/banned!"))
return
if conn:
text = tl(update.effective_message, "Mode timeout diubah, Pengguna akan di `{}` pada *{}*!").format(settypeblacklist, chat_name)
else:
text = tl(update.effective_message, "Mode timeout diubah, Pengguna akan di `{}`!").format(settypeblacklist)
send_message(update.effective_message, text, parse_mode="markdown")
else:
if timeout_mode == 1:
settypeblacklist = tl(update.effective_message, "kick")
elif timeout_mode == 2:
settypeblacklist = tl(update.effective_message, "banned")
if conn:
text = tl(update.effective_message, "Mode timeout saat ini disetel ke *{}* pada *{}*.").format(settypeblacklist, chat_name)
else:
text = tl(update.effective_message, "Mode timeout saat ini disetel ke *{}*.").format(settypeblacklist)
send_message(update.effective_message, text, parse_mode=ParseMode.MARKDOWN)
return
def pin_rights(update, context, *args, **kwargs):
if update.effective_chat.get_member(context.bot.id).can_pin_messages:
return func(update, context, *args, **kwargs)
else:
update.effective_message.reply_text(
languages.tl(
update.effective_message, "I can't pin messages here! "
"Make sure I'm admin and can pin messages."))
def pat(update, context):
args = context.args
chat_id = update.effective_chat.id
msg = str(update.message.text)
try:
msg = msg.split(" ", 1)[1]
except IndexError:
msg = ""
msg_id = update.effective_message.reply_to_message.message_id if update.effective_message.reply_to_message else update.effective_message.message_id
pats = []
pats = json.loads(urllib.request.urlopen(urllib.request.Request(
'http://headp.at/js/pats.json',
headers={'User-Agent': 'Mozilla/5.0 (X11; U; Linux i686) '
'Gecko/20071127 Firefox/2.0.0.11'}
)).read().decode('utf-8'))
if "@" in msg and len(msg) > 5:
context.bot.send_photo(chat_id, f'https://headp.at/pats/{urllib.parse.quote(random.choice(pats))}', caption=msg)
else:
context.bot.send_photo(chat_id, f'https://headp.at/pats/{urllib.parse.quote(random.choice(pats))}', reply_to_message_id=msg_id)
#if msg.from_user.username:
# curr_user = "******" + escape_markdown(msg.from_user.username)
#else:
curr_user = "******".format(mention_markdown(msg.from_user.id, msg.from_user.first_name))
user_id = extract_user(update.effective_message, args)
if user_id and user_id != "error":
slapped_user = context.bot.get_chat(user_id)
user1 = curr_user
#if slapped_user.username:
# user2 = "@" + escape_markdown(slapped_user.username)
#else:
user2 = "{}".format(mention_markdown(slapped_user.id, slapped_user.first_name))
# if no target found, bot targets the sender
else:
user1 = "{}".format(mention_markdown(context.bot.id, context.bot.first_name))
user2 = curr_user
temp = random.choice(tl(update.effective_message, "SLAP_TEMPLATES"))
item = random.choice(tl(update.effective_message, "ITEMS"))
hit = random.choice(tl(update.effective_message, "HIT"))
throw = random.choice(tl(update.effective_message, "THROW"))
repl = temp.format(user1=user1, user2=user2, item=item, hits=hit, throws=throw)
send_message(update.effective_message, repl, parse_mode=ParseMode.MARKDOWN)
def stickerid(update, context):
msg = update.effective_message
if msg.reply_to_message and msg.reply_to_message.sticker:
send_message(
update.effective_message,
tl(update.effective_message,
"Hai {}, Id stiker yang anda balas adalah :\n```{}```").format(
mention_markdown(msg.from_user.id,
msg.from_user.first_name),
msg.reply_to_message.sticker.file_id),
parse_mode=ParseMode.MARKDOWN)
else:
send_message(
update.effective_message,
tl(update.effective_message,
"Tolong balas pesan stiker untuk mendapatkan id stiker"),
parse_mode=ParseMode.MARKDOWN)
def disable_del(update, context):
msg = update.effective_message
chat = update.effective_chat
if len(msg.text.split()) >= 2:
args = msg.text.split(None, 1)[1]
if args == "yes" or args == "on" or args == "ya":
sql.disabledel_set(chat.id, True)
send_message(update.effective_message, languages.tl(update.effective_message, "Ketika command di nonaktifkan, maka saya *akan menghapus* pesan command tsb."), parse_mode="markdown")
return
elif args == "no" or args == "off":
sql.disabledel_set(chat.id, False)
send_message(update.effective_message, languages.tl(update.effective_message, "Saya *tidak akan menghapus* pesan dari command yang di nonaktifkan."), parse_mode="markdown")
return
else:
send_message(update.effective_message, languages.tl(update.effective_message, "Argumen tidak dikenal - harap gunakan 'yes', atau 'no'."))
else:
send_message(update.effective_message, languages.tl(update.effective_message, "Opsi disable del saat ini: *{}*").format("Enabled" if sql.is_disable_del(chat.id) else "Disabled"), parse_mode="markdown")
def delete_rights(update, context, *args, **kwargs):
if can_delete(update.effective_chat, context.bot.id):
return func(update, context, *args, **kwargs)
else:
update.effective_message.reply_text(
languages.tl(
update.effective_message, "I can't delete messages here! "
"Make sure I'm admin and can delete other user's messages."
))
