def list_locks(bot: Bot, update: Update):
spam = spamfilters(update.effective_message.text,
update.effective_message.from_user.id,
update.effective_chat.id, update.effective_message)
if spam == True:
return
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user
# Connection check
conn = connected(bot, update, chat, user.id, need_admin=True)
if conn:
chat = dispatcher.bot.getChat(conn)
chat_id = conn
chat_name = chat.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
res = build_lock_message(chat.id)
if conn:
res = res.replace(tl(update.effective_message, 'obrolan ini'),
'*{}*'.format(chat_name))
send_message(update.effective_message, res, parse_mode=ParseMode.MARKDOWN)
def add_url(bot, update, args):
spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id, update.effective_message)
if spam == True:
return
if len(args) >= 1:
chat = update.effective_chat
tg_chat_id = str(update.effective_chat.id)
tg_feed_link = args[0]
link_processed = parse(tg_feed_link)
# check if link is a valid RSS Feed link
if link_processed.bozo == 0:
if len(link_processed.entries[0]) >= 1:
tg_old_entry_link = link_processed.entries[0].link
else:
tg_old_entry_link = ""
# gather the row which contains exactly that telegram group ID and link for later comparison
row = sql.check_url_availability(tg_chat_id, tg_feed_link)
# check if there's an entry already added to DB by the same user in the same group with the same link
if row:
send_message(update.effective_message, tl(update.effective_message, "URL ini sudah ditambahkan"))
else:
sql.add_url(tg_chat_id, tg_feed_link, tg_old_entry_link)
send_message(update.effective_message, tl(update.effective_message, "URL ditambahkan ke langganan"))
else:
send_message(update.effective_message, tl(update.effective_message, "Tautan ini bukan tautan Umpan RSS"))
else:
send_message(update.effective_message, tl(update.effective_message, "URL hilang"))
def leavechat(bot: Bot, update: Update, args: List[int]):
if args:
chat_id = int(args[0])
else:
send_message(
update.effective_message,
tl(update.effective_message,
"Anda sepertinya tidak mengacu pada obrolan"))
try:
chat = bot.getChat(chat_id)
titlechat = bot.get_chat(chat_id).title
bot.sendMessage(
chat_id, tl(update.effective_message, "Selamat tinggal semua 😁"))
bot.leaveChat(chat_id)
send_message(
update.effective_message,
tl(update.effective_message,
"Saya telah keluar dari grup {}").format(titlechat))
except BadRequest as excp:
if excp.message == "Chat not found":
send_message(
update.effective_message,
tl(
update.effective_message,
"Sepertinya saya sudah keluar atau di tendang di grup tersebut"
))
else:
return
def clear_rules(bot: Bot, update: Update):
spam = spamfilters(update.effective_message.text,
update.effective_message.from_user.id,
update.effective_chat.id, update.effective_message)
if spam == True:
return
chat = update.effective_chat
chat_id = update.effective_chat.id
user = update.effective_user
conn = connected(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
chat_id = update.effective_chat.id
sql.set_rules(chat_id, "")
send_message(update.effective_message,
tl(update.effective_message, "Berhasil membersihkan aturan!"))
def disconnect_chat(bot, update):
spam = spamfilters(update.effective_message.text,
update.effective_message.from_user.id,
update.effective_chat.id, update.effective_message)
if spam == True:
return
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,
languages.tl(update.effective_message,
"Terputus dari obrolan!"))
else:
send_message(
update.effective_message,
languages.tl(update.effective_message,
"Anda tidak terkoneksi!"))
else:
send_message(
update.effective_message,
languages.tl(update.effective_message,
"Penggunaan terbatas hanya untuk PM"))
def about_bio(bot: Bot, update: Update, args: List[str]):
spam = spamfilters(update.effective_message.text,
update.effective_message.from_user.id,
update.effective_chat.id, update.effective_message)
if spam == True:
return
message = update.effective_message # type: Optional[Message]
user_id = extract_user(message, args)
if user_id:
user = bot.get_chat(user_id)
else:
user = message.from_user
info = sql.get_user_bio(user.id)
if info:
send_message(update.effective_message,
"*{}*:\n{}".format(user.first_name,
escape_markdown(info)),
parse_mode=ParseMode.MARKDOWN)
elif message.reply_to_message:
username = user.first_name
send_message(
update.effective_message,
tl(update.effective_message,
"{} belum memiliki pesan tentang dirinya sendiri!").format(
username))
else:
send_message(
update.effective_message,
tl(update.effective_message,
"Anda belum memiliki bio set tentang diri Anda!"))
def get_settings(bot: Bot, update: Update):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
msg = update.effective_message # type: Optional[Message]
args = msg.text.split(None, 1)
spam = spamfilters(update.effective_message.text,
update.effective_message.from_user.id,
update.effective_chat.id, update.effective_message)
if spam == True:
return
# ONLY send settings in PM
if chat.type != chat.PRIVATE:
if is_user_admin(chat, user.id):
text = tl(
update.effective_message,
"Klik di sini untuk mendapatkan pengaturan obrolan ini, serta milik Anda."
)
msg.reply_text(text,
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton(
text="Pengaturan",
url="t.me/{}?start=stngs_{}".format(
bot.username, chat.id))
]]))
else:
text = tl(update.effective_message,
"Klik di sini untuk memeriksa pengaturan Anda.")
else:
send_settings(chat.id, user.id, True)
def connection_chat(bot, update):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
spam = spamfilters(update.effective_message.text,
update.effective_message.from_user.id,
update.effective_chat.id, update.effective_message)
if spam == True:
return
conn = connected(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 reply_afk(bot: Bot, update: Update):
message = update.effective_message # type: Optional[Message]
entities = message.parse_entities([MessageEntity.TEXT_MENTION, MessageEntity.MENTION])
if message.entities and entities:
for ent in entities:
if ent.type == MessageEntity.TEXT_MENTION:
user_id = ent.user.id
fst_name = ent.user.first_name
elif ent.type == MessageEntity.MENTION:
user_id = get_user_id(message.text[ent.offset:ent.offset + ent.length])
if not user_id:
# Should never happen, since for a user to become AFK they must have spoken. Maybe changed username?
return
try:
chat = bot.get_chat(user_id)
except BadRequest:
print("Error: Could not fetch userid {} for AFK module".off dulu yekan(user_id))
return
fst_name = chat.first_name
else:
return
if sql.is_afk(user_id):
valid, reason = sql.check_afk_status(user_id)
if valid:
if not reason:
res = tl(update.effective_message, "{} sedang AFK!").off dulu yekan(fst_name)
else:
res = tl(update.effective_message, "{} sedang AFK!\nKarena : {}").off dulu yekan(fst_name, reason)
send_message(update.effective_message, res)
def __chat_settings__(chat_id, user_id):
administrators = dispatcher.bot.getChatAdministrators(chat_id)
chat = dispatcher.bot.getChat(chat_id)
text = "Admin di *{}*:".format(chat.title or "chat ini")
for admin in administrators:
user = admin.user
status = admin.status
if user.first_name == '':
name = tl(user_id, "☠Akun Terhapus")
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, "☠Akun Terhapus")
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\nKamu adalah *{}*").format(
dispatcher.bot.get_chat_member(chat_id, user_id).status)
return text
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 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(bot, report_target)
if not a:
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:
bot.unbanChatMember(report_chat, report_target)
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)
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:
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:
bot.kickChatMember(report_chat, report_target)
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)
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:
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:
bot.deleteMessage(report_chat, report_target)
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:
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":
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 __chat_settings__(chat_id, user_id):
limit = sql.get_flood_limit(chat_id)
if limit == 0:
return tl(user_id,
"Saat ini *Tidak* menegakkan pengendalian pesan beruntun.")
else:
return tl(user_id,
"Anti Pesan Beruntun diatur ke `{}` pesan.").format(limit)
def build_curr_disabled(chat_id: Union[str, int]) -> str:
disabled = sql.get_all_disabled(chat_id)
if not disabled:
return languages.tl(update.effective_message, "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 add_blacklist(bot: Bot, update: Update):
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)
spam = spamfilters(update.effective_message.text,
update.effective_message.from_user.id,
update.effective_chat.id, update.effective_message)
if spam == True:
return
conn = connected(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 ramalan(bot: Bot, update: Update):
spam = spamfilters(update.effective_message.text,
update.effective_message.from_user.id,
update.effective_chat.id, update.effective_message)
if spam == True:
return
text = ""
if random.randint(1, 10) >= 7:
text += random.choice(tl(update.effective_message, "RAMALAN_FIRST"))
text += random.choice(tl(update.effective_message, "RAMALAN_STRINGS"))
send_message(update.effective_message, text)
def __user_info__(user_id, chat_id):
if user_id == dispatcher.bot.id:
return languages.tl(
chat_id,
"""Saya telah melihatnya... Wow. Apakah mereka menguntit saya? Mereka ada di semua tempat yang sama dengan saya... oh. Ini aku."""
)
num_chats = sql.get_user_num_chats(user_id)
return languages.tl(
chat_id,
"""Saya telah melihatnya <code>{}</code> obrolan total.""").format(
num_chats)
def set_about_bio(bot: Bot, update: Update):
spam = spamfilters(update.effective_message.text,
update.effective_message.from_user.id,
update.effective_chat.id, update.effective_message)
if spam == True:
return
message = update.effective_message # type: Optional[Message]
sender = update.effective_user # type: Optional[User]
if message.reply_to_message:
repl_message = message.reply_to_message
user_id = repl_message.from_user.id
if user_id == message.from_user.id:
send_message(
update.effective_message,
tl(
update.effective_message,
"Ha, Anda tidak dapat mengatur bio Anda sendiri! Anda berada di bawah belas kasihan orang lain di sini..."
))
return
elif user_id == bot.id and sender.id not in SUDO_USERS:
send_message(
update.effective_message,
tl(
update.effective_message,
"Umm ... yah, saya hanya mempercayai pengguna sudo untuk mengatur bio saya."
))
return
text = message.text
bio = text.split(
None, 1
) # use python's maxsplit to only remove the cmd, hence keeping newlines.
if len(bio) == 2:
if len(bio[1]) < MAX_MESSAGE_LENGTH // 4:
sql.set_user_bio(user_id, bio[1])
send_message(
update.effective_message,
tl(update.effective_message, "Bio {} diperbarui!").format(
repl_message.from_user.first_name))
else:
send_message(
update.effective_message,
tl(
update.effective_message,
"Biografi harus di bawah {} karakter! Anda mencoba mengatur {}."
).format(MAX_MESSAGE_LENGTH // 4, len(bio[1])))
else:
send_message(
update.effective_message,
tl(update.effective_message,
"Balas pesan seseorang untuk mengatur bio mereka!"))
def blacklist(bot: Bot, update: Update, args: List[str]):
msg = update.effective_message # type: Optional[Message]
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
spam = spamfilters(update.effective_message.text,
update.effective_message.from_user.id,
update.effective_chat.id, update.effective_message)
if spam == True:
return
conn = connected(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 = tl(
update.effective_message,
"<b>Kata daftar hitam saat ini di {}:</b>\n").format(chat_name)
all_blacklisted = sql.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 == tl(
update.effective_message,
"<b>Kata daftar hitam saat ini di {}:</b>\n").format(
chat_name):
send_message(
update.effective_message,
tl(update.effective_message,
"Tidak ada pesan daftar hitam di <b>{}</b>!").format(
chat_name),
parse_mode=ParseMode.HTML)
return
send_message(update.effective_message, text, parse_mode=ParseMode.HTML)
def list_cmds(bot: Bot, update: Update):
spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id, update.effective_message)
if spam == True:
return
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 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, "Saluran log ini telah dihapus - tidak bisa dibuka."))
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\nMemformat telah dinonaktifkan karena kesalahan tak terduga."))
def private_rules(bot: Bot, update: Update, args: List[str]):
spam = spamfilters(update.effective_message.text,
update.effective_message.from_user.id,
update.effective_chat.id, update.effective_message)
if spam == True:
return
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
conn = connected(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":
chat_name = chat.title
else:
chat_name = chat.title
if len(args) >= 1:
if args[0] in ("yes", "on", "ya"):
sql.private_rules(str(chat_id), True)
send_message(
update.effective_message,
tl(
update.effective_message,
"Private Rules di *aktifkan*, pesan peraturan akan di kirim di PM."
),
parse_mode="markdown")
elif args[0] in ("no", "off"):
sql.private_rules(str(chat_id), False)
send_message(
update.effective_message,
tl(
update.effective_message,
"Private Rules di *non-aktifkan*, pesan peraturan akan di kirim di grup."
),
parse_mode="markdown")
else:
send_message(
update.effective_message,
tl(update.effective_message,
"Argumen tidak dikenal - harap gunakan 'yes', atau 'no'."))
else:
is_private = sql.get_private_rules(chat_id)
send_message(update.effective_message,
tl(update.effective_message,
"Pengaturan Private Rules di {}: *{}*").format(
chat_name,
"Enabled" if is_private else "Disabled"),
parse_mode="markdown")
def unsetlog(bot: Bot, update: Update):
spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id, update.effective_message)
if spam == True:
return
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:
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 stop_filter(bot: Bot, update: Update):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
args = update.effective_message.text.split(None, 1)
spam = spamfilters(update.effective_message.text,
update.effective_message.from_user.id,
update.effective_chat.id, update.effective_message)
if spam == True:
return
conn = connected(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 = tl(update.effective_message, "catatan lokal")
else:
chat_name = chat.title
if len(args) < 2:
send_message(
update.effective_message,
tl(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,
tl(update.effective_message, "Tidak ada filter 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,
tl(update.effective_message,
"Ya, saya akan berhenti menjawabnya di *{}*.").format(
chat_name),
parse_mode=telegram.ParseMode.MARKDOWN)
raise DispatcherHandlerStop
send_message(
update.effective_message,
"Itu bukan filter aktif - jalankan /filter untuk semua filter aktif.")
def get_time_alt(bot: Bot, update: Update, args: List[str]):
spam = spamfilters(update.effective_message.text,
update.effective_message.from_user.id,
update.effective_chat.id, update.effective_message)
if spam == True:
return
if args:
location = " ".join(args)
if location.lower() == bot.first_name.lower():
send_message(update.effective_message,
"Selalu ada waktu banned untukku!")
bot.send_sticker(update.effective_chat.id, BAN_STICKER)
return
res = requests.get(
'https://dev.virtualearth.net/REST/v1/timezone/?query={}&key={}'.
format(location, MAPS_API))
if res.status_code == 200:
loc = res.json()
if len(loc['resourceSets'][0]['resources'][0]
['timeZoneAtLocation']) == 0:
send_message(
update.effective_message,
tl(update.effective_message, "Lokasi tidak di temukan!"))
return
placename = loc['resourceSets'][0]['resources'][0][
'timeZoneAtLocation'][0]['placeName']
localtime = loc['resourceSets'][0]['resources'][0][
'timeZoneAtLocation'][0]['timeZone'][0]['convertedTime'][
'localTime']
if lang_sql.get_lang(update.effective_chat.id) == "id":
locale.setlocale(locale.LC_TIME, 'id_ID.UTF-8')
time = datetime.strptime(
localtime,
'%Y-%m-%dT%H:%M:%S').strftime("%H:%M:%S hari %A, %d %B")
else:
time = datetime.strptime(
localtime,
'%Y-%m-%dT%H:%M:%S').strftime("%H:%M:%S %A, %d %B")
send_message(update.effective_message,
tl(update.effective_message,
"Sekarang pukul `{}` di `{}`").format(
time, placename),
parse_mode="markdown")
else:
send_message(update.effective_message,
tl(update.effective_message,
"Gunakan `/time nama daerah`\nMisal: `/time jakarta`"),
parse_mode="markdown")
def ungban(bot: Bot, update: Update, args: List[str]):
message = update.effective_message # type: Optional[Message]
user_id = extract_user(message, args)
if not user_id:
send_message(update.effective_message, tl(update.effective_message, "Anda sepertinya tidak mengacu pada pengguna."))
return
user_chat = bot.get_chat(user_id)
if user_chat.type != 'private':
send_message(update.effective_message, tl(update.effective_message, "Itu bukan pengguna!"))
return
if not sql.is_user_gbanned(user_id):
send_message(update.effective_message, tl(update.effective_message, "Pengguna ini tidak dilarang secara global!"))
return
banner = update.effective_user # type: Optional[User]
send_message(update.effective_message, tl(update.effective_message, "Saya akan berikan {} kesempatan kedua, secara global.").format(user_chat.first_name))
send_to_list(bot, SUDO_USERS + SUPPORT_USERS,
tl(update.effective_message, "{} telah menghapus larangan global untuk pengguna {}").format(mention_html(banner.id, banner.first_name),
mention_html(user_chat.id, user_chat.first_name)),
html=True)
sql.ungban_user(user_id)
chats = get_all_chats()
for chat in chats:
chat_id = chat.chat_id
# Check if this group has disabled gbans
if not sql.does_chat_gban(chat_id):
continue
try:
member = bot.get_chat_member(chat_id, user_id)
if member.status == 'kicked':
bot.unban_chat_member(chat_id, user_id)
except BadRequest as excp:
if excp.message in UNGBAN_ERRORS:
pass
else:
send_message(update.effective_message, tl(update.effective_message, "Tidak dapat menghapus larangan secara global karena: {}").format(excp.message))
bot.send_message(OWNER_ID, tl(update.effective_message, "Tidak dapat menghapus larangan secara global karena: {}").format(excp.message))
return
except TelegramError:
pass
send_to_list(bot, SUDO_USERS + SUPPORT_USERS, tl(update.effective_message, "Menghapus larangan global selesai!"))
send_message(update.effective_message, tl(update.effective_message, "Orang ini telah dihapus larangannya."))
def kickme(bot: Bot, update: Update):
user_id = update.effective_message.from_user.id
if is_user_admin(update.effective_chat, user_id):
send_message(update.effective_message, tl(update.effective_message, "Saya berharap saya bisa... tetapi Anda seorang admin 😒"))
return
spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id, update.effective_message)
if spam == True:
return
res = update.effective_chat.unban_member(user_id) # unban on current user = kick
if res:
send_message(update.effective_message, tl(update.effective_message, "Tidak masalah 😊"))
else:
send_message(update.effective_message, tl(update.effective_message, "Hah? Aku tidak bisa 🙄"))
def flood(bot: Bot, update: Update):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
spam = spamfilters(update.effective_message.text,
update.effective_message.from_user.id,
update.effective_chat.id, update.effective_message)
if spam == True:
return
conn = connected(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,
tl(update.effective_message,
"Anda bisa lakukan command ini pada grup, bukan pada 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 = tl(
update.effective_message,
"Saat ini saya tidak memberlakukan pengendalian pesan beruntun pada *{}*!"
).format(chat_name)
else:
text = tl(
update.effective_message,
"Saat ini saya tidak memberlakukan pengendalian pesan beruntun"
)
send_message(update.effective_message, text, parse_mode="markdown")
else:
if conn:
text = tl(
update.effective_message,
"Saat ini saya melarang pengguna jika mereka mengirim lebih dari *{}* pesan berturut-turut pada *{}*."
).format(limit, chat_name)
else:
text = tl(
update.effective_message,
"Saat ini saya melarang pengguna jika mereka mengirim lebih dari *{}* pesan berturut-turut."
).format(limit)
send_message(update.effective_message, text, parse_mode="markdown")
def log_user(bot: Bot, update: Update):
chat = update.effective_chat # type: Optional[Chat]
msg = update.effective_message # type: Optional[Message]
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:
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 permanent_pin(bot: Bot, update: Update):
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 == bot.id:
try:
to_del = 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,
"*Permanen pin error:*\nSaya tidak bisa menyematkan pesan di sini!\nPastikan saya admin dan dapat pin pesan.\n\nPermanen pin di nonaktifkan, [pesan permanen pin lama ada disini]({})"
).format(old_pin),
parse_mode="markdown")
return
if to_del:
try:
bot.deleteMessage(chat.id, message.message_id + 1)
except BadRequest:
print("Permanent pin error: cannot delete pin msg")
