def help_connect_chat(bot, update, args):
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
if update.effective_message.chat.type != "private":
send_message(
update.effective_message,
languages.
tl(update.effective_message,
"PM saya dengan command itu untuk mendapatkan bantuan Koneksi"))
return
else:
send_message(update.effective_message,
languages.tl(update.effective_message, "supportcmd"),
parse_mode="markdown")
def google(update, context):
# SHOW_DESCRIPTION = False
args = context.args
information = str(args)
input_str = information # + " -inurl:(htm|html|php|pls|txt) intitle:index.of \"last modified\" (mkv|mp4|avi|epub|pdf|mp3)"
input_url = "https://bots.shrimadhavuk.me/search/?q={}".format(input_str)
headers = {"USER-AGENT": "UniBorg"}
response = requests.get(input_url, headers=headers).json()
output_str = " "
for result in response["results"]:
text = result.get("title")
url = result.get("url")
description = result.get("description")
last = html2text.html2text(description)
output_str += "[{}]({})\n{}\n".format(text, url, last)
send_message(update.effective_message,
"{}".format(output_str),
link_preview=False,
parse_mode='Markdown')
def ping(update, context):
start_time = time.time()
test = send_message(update.effective_message, "Pong!")
end_time = time.time()
ping_time = float(end_time - start_time)
context.bot.editMessageText(
chat_id=update.effective_chat.id,
message_id=test.message_id,
text=tl(update.effective_message,
"Pong!\nKecepatannya: {0:.2f} detik").format(
round(ping_time, 2) % 60))
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 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]
is_pinned = False
if len(args) >= 2:
if args[1] == "pin":
is_pinned = True
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,
is_pinned)
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 permapin(bot: Bot, update: Update):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
message = update.effective_message # type: Optional[Message]
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 = 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
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 = bot.send_message(chat_id, text, parse_mode="markdown",
disable_web_page_preview=True, reply_markup=InlineKeyboardMarkup(tombol))
except BadRequest:
bot.send_message(chat_id, tl(update.effective_message, "Teks markdown salah!\nJika anda tidak tahu apa itu markdown, silahkan ketik `/markdownhelp` pada 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:
bot.pinChatMessage(chat_id, sendingmsg.message_id)
except BadRequest:
send_message(update.effective_message, tl(update.effective_message, "Saya tidak punya akses untuk pin pesan!"))
def get_time(update, context):
args = context.args
location = " ".join(args)
if location.lower() == context.bot.first_name.lower():
send_message(update.effective_message, tl(update.effective_message, "Selalu ada waktu banned untukku!"))
context.bot.send_sticker(update.effective_chat.id, BAN_STICKER)
return
res = requests.get(GMAPS_LOC, params=dict(address=location, key=MAPS_API))
print(res.text)
if res.status_code == 200:
loc = json.loads(res.text)
if loc.get('status') == 'OK':
lat = loc['results'][0]['geometry']['location']['lat']
long = loc['results'][0]['geometry']['location']['lng']
country = None
city = None
address_parts = loc['results'][0]['address_components']
for part in address_parts:
if 'country' in part['types']:
country = part.get('long_name')
if 'administrative_area_level_1' in part['types'] and not city:
city = part.get('long_name')
if 'locality' in part['types']:
city = part.get('long_name')
if city and country:
location = "{}, {}".format(city, country)
elif country:
location = country
timenow = int(datetime.utcnow().timestamp())
res = requests.get(GMAPS_TIME, params=dict(location="{},{}".format(lat, long), timestamp=timenow))
if res.status_code == 200:
offset = json.loads(res.text)['dstOffset']
timestamp = json.loads(res.text)['rawOffset']
time_there = datetime.fromtimestamp(timenow + timestamp + offset).strftime("%H:%M:%S hari %A %d %B")
send_message(update.effective_message, "Sekarang pukul {} di {}".format(time_there, location))
def connected(bot, update, chat, user_id, need_admin=True):
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
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!"
))
raise Exception("Bukan admin!")
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(bot, update)
raise Exception("Bukan admin!")
else:
return False
def kamusbesarbahasaindonesia(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
msg = update.effective_message
chat_id = update.effective_chat.id
try:
args = update.effective_message.text.split(None, 1)
teks = args[1]
message = update.effective_message
try:
api = requests.get(
'http://kateglo.com/api.php?format=json&phrase=' +
teks).json()
except json.decoder.JSONDecodeError:
send_message(update.effective_message,
"Hasil tidak ditemukan!",
parse_mode=ParseMode.MARKDOWN)
return
#kamusid = KBBI(teks)
parsing = "***Hasil dari kata {} ({}) di {}***\n\n".format(
api['kateglo']['phrase'], api['kateglo']['lex_class_name'],
api['kateglo']['ref_source_name'])
if len(api['kateglo']['definition']) >= 6:
jarak = 5
else:
jarak = len(api['kateglo']['definition'])
for x in range(jarak):
parsing += "*{}.* {}".format(
x + 1, api['kateglo']['definition'][x]['def_text'])
contoh = api['kateglo']['definition'][x]['sample']
if contoh:
parsing += "\nContoh: `{}`".format(
str(BeautifulSoup(contoh, "lxml")).replace(
'<html><body><p>', '').replace('</p></body></html>',
''))
parsing += "\n\n"
send_message(update.effective_message,
parsing,
parse_mode=ParseMode.MARKDOWN)
except IndexError:
send_message(
update.effective_message,
"Tulis pesan untuk mencari dari kamus besar bahasa indonesia")
except KBBI.TidakDitemukan:
send_message(update.effective_message, "Hasil tidak ditemukan")
else:
return
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 clear_rules(update, context):
chat = update.effective_chat
chat_id = update.effective_chat.id
user = update.effective_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
chat_id = update.effective_chat.id
sql.set_rules(chat_id, "")
send_message(update.effective_message, tl(update.effective_message, "Berhasil membersihkan aturan!"))
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,
"Grup ini memiliki semua log yang dikirim ke: {} (`{}`)").
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 leavechat(update, context):
args = context.args
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 = context.bot.getChat(chat_id)
titlechat = context.bot.get_chat(chat_id).title
context.bot.sendMessage(
chat_id, tl(update.effective_message,
"Selamat tinggal semua ЁЯШБ"))
context.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 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 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 show_url(update, context):
args = context.args
tg_chat_id = str(update.effective_chat.id)
if len(args) >= 1:
tg_feed_link = args[0]
link_processed = parse(tg_feed_link)
if link_processed.bozo == 0:
feed_title = link_processed.feed.get("title", default="Unknown")
feed_description = "<i>{}</i>".format(
re.sub('<[^<]+?>', '', link_processed.feed.get("description", default="Unknown")))
feed_link = link_processed.feed.get("link", default="Unknown")
feed_message = tl(update.effective_message, "<b>Judul Feed:</b> \n{}" \
"\n\n<b>Deskripsi Feed:</b> \n{}" \
"\n\n<b>Link Feed:</b> \n{}").format(html.escape(feed_title),
feed_description,
html.escape(feed_link))
if len(link_processed.entries) >= 1:
entry_title = link_processed.entries[0].get("title", default="Unknown")
entry_description = "<i>{}</i>".format(
re.sub('<[^<]+?>', '', link_processed.entries[0].get("description", default="Unknown")))
entry_link = link_processed.entries[0].get("link", default="Unknown")
entry_message = tl(update.effective_message, "\n\n<b>Judul Entri:</b> \n{}" \
"\n\n<b>Deskripsi Entri:</b> \n{}" \
"\n\n<b>Entri Masuk:</b> \n{}").format(html.escape(entry_title),
entry_description,
html.escape(entry_link))
final_message = feed_message + entry_message
context.bot.send_message(chat_id=tg_chat_id, text=final_message, parse_mode=ParseMode.HTML)
else:
context.bot.send_message(chat_id=tg_chat_id, text=feed_message, parse_mode=ParseMode.HTML)
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 pin(update, context):
user = update.effective_user # type: Optional[User]
chat = update.effective_chat # type: Optional[Chat]
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
if len(args) <= 1:
send_message(update.effective_message, tl(update.effective_message, "Gunakan /pin <notify/loud/silent/violent> <link pesan>"))
return ""
prev_message = args[1]
if "/" in prev_message:
prev_message = prev_message.split("/")[-1]
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
if update.effective_message.reply_to_message:
prev_message = update.effective_message.reply_to_message.message_id
else:
send_message(update.effective_message, tl(update.effective_message, "Balas pesan untuk pin pesan tersebut pada grup ini"))
return ""
is_group = chat.type != "private" and chat.type != "channel"
is_silent = True
if len(args) >= 1:
is_silent = not (args[0].lower() == 'silent' or args[0].lower() == 'off' or args[0].lower() == 'mute')
if prev_message and is_group:
try:
context.bot.pinChatMessage(chat.id, prev_message, disable_notification=is_silent)
if conn:
send_message(update.effective_message, tl(update.effective_message, "Saya sudah pin pesan dalam grup {}").format(chat_name))
except BadRequest as excp:
if excp.message == "Chat_not_modified":
pass
else:
raise
return "<b>{}:</b>" \
"\n#PINNED" \
"\n<b>Admin:</b> {}".format(html.escape(chat.title), mention_html(user.id, user.first_name))
return ""
def security_mute(bot: Bot, update: Update, args: List[str]) -> 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]
message = update.effective_message # type: Optional[Message]
getcur, cur_value, cust_text = sql.welcome_security(chat.id)
if len(args) >= 1:
var = args[0]
if var[:1] == "0":
mutetime = "0"
sql.set_welcome_security(chat.id, getcur, "0", cust_text)
text = tl(update.effective_message, "Setiap member baru akan di bisukan selamanya sampai dia menekan tombol selamat datang!")
else:
mutetime = extract_time(message, var)
if mutetime == "":
return
sql.set_welcome_security(chat.id, getcur, str(var), cust_text)
text = tl(update.effective_message, "Setiap member baru akan di bisukan selama {} sampai dia menekan tombol selamat datang!").format(var)
send_message(update.effective_message, text)
else:
if str(cur_value) == "0":
send_message(update.effective_message, tl(update.effective_message, "Pengaturan saat ini: member baru akan di bisukan selamanya sampai dia menekan tombol selamat datang!"))
else:
send_message(update.effective_message, tl(update.effective_message, "Pengaturan saat ini: member baru akan di bisukan selama {} sampai dia menekan tombol selamat datang!").format(cur_value))
def set_goodbye(bot: Bot, update: Update) -> 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]
msg = update.effective_message # type: Optional[Message]
# If user is not set text and not reply a message
if not msg.reply_to_message:
if len(msg.text.split()) == 1:
send_message(update.effective_message, tl(update.effective_message, "Anda harus memberikan isi dalam pesan selamat datang!\nKetik `/welcomehelp` untuk beberapa bantuan pada welcome"), parse_mode="markdown")
return ""
text, data_type, content, buttons = get_welcome_type(msg)
if data_type is None:
send_message(update.effective_message, tl(update.effective_message, "Anda tidak menentukan apa yang harus dibalas!"))
return ""
sql.set_custom_gdbye(chat.id, content, text, data_type, buttons)
send_message(update.effective_message, tl(update.effective_message, "Berhasil mengatur pesan selamat tinggal kustom!"))
return "<b>{}:</b>" \
"\n#SET_GOODBYE" \
"\n<b>Admin:</b> {}" \
"\nSet a goodbye message.".format(html.escape(chat.title),
mention_html(user.id, user.first_name))
def list_handlers(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=False)
if not conn == False:
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
filter_list = "*Filter di {}:*\n"
else:
chat_id = update.effective_chat.id
if chat.type == "private":
chat_name = tl(update.effective_message, "filter lokal")
filter_list = tl(update.effective_message, "*filter lokal:*\n")
else:
chat_name = chat.title
filter_list = tl(update.effective_message, "*Filter di {}*:\n")
all_handlers = sql.get_chat_triggers(chat_id)
if not all_handlers:
send_message(update.effective_message, tl(update.effective_message, "Tidak ada filter 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 set_language(update, context):
msg = update.effective_message # type: Optional[Message]
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
getlang = sql.get_lang(chat.id)
if getlang == 'None' or not getlang:
if msg.from_user.language_code:
sql.set_lang(msg.chat.id, msg.from_user.language_code)
getlang = msg.from_user.language_code
else:
sql.set_lang(msg.chat.id, 'en')
getlang = 'en'
loaded_langs = []
tmp_list = []
counter = 0
for x in LOADED_LANGS_ID:
counter += 1
tmp_list.append(InlineKeyboardButton(LANGS_TEXT[x], callback_data="set_lang({})".format(x)))
if counter % 2 == 0:
loaded_langs.append(tmp_list)
tmp_list = []
if counter == len(LOADED_LANGS_ID):
loaded_langs.append(tmp_list)
loaded_langs.append([InlineKeyboardButton("Translate", url="https://github.com/AyraHikari/EmiliaHikari/blob/master/TRANSLATION.md")])
keyboard = InlineKeyboardMarkup(loaded_langs)
if chat.title:
chatname = chat.title
else:
if chat.type == "private":
chatname = user.first_name
else:
chatname = tl(update.effective_message, "obrolan saat ini")
currlang = LANGS_TEXT[getlang] if LANGS_TEXT.get(getlang) else "(Deleted langs)"
send_message(update.effective_message, tl(msg, "Bahasa di *{}* saat ini adalah:\n{}.\n\nPilih bahasa:").format(chatname, currlang), parse_mode="markdown", reply_markup=keyboard)
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 gbanstat(update, context):
args = context.args
if len(args) > 0:
if args[0].lower() in ["on", "yes"]:
sql.enable_gbans(update.effective_chat.id)
send_message(
update.effective_message,
tl(
update.effective_message,
"I've enabled gbans in this group. This will help protect you from "
"spammers, unsavoury characters, and the biggest trolls."))
elif args[0].lower() in ["off", "no"]:
sql.disable_gbans(update.effective_chat.id)
send_message(
update.effective_message,
tl(
update.effective_message,
"I've disabled gbans in this group. GBans wont affect your users anymore. "
"You'll be less protected from any trolls and spammers though!"
))
else:
send_message(
update.effective_message,
tl(
update.effective_message,
"Give me some arguments to choose a setting! on/off, yes/no!\n\n"
"Your current setting is: {}\n"
"When True, any gbans that happen will also happen in your group. "
"When False, they won't, leaving you at the possible mercy of "
"spammers.").format(
sql.does_chat_gban(update.effective_chat.id)))
def gbanstat(update, context):
args = context.args
if len(args) > 0:
if args[0].lower() in ["on", "yes"]:
sql.enable_gbans(update.effective_chat.id)
send_message(
update.effective_message,
tl(
update.effective_message,
"Saya telah mengaktifkan larangan global dalam grup ini. Ini akan membantu melindungi Anda "
"dari spammer, karakter tidak menyenangkan, dan troll terbesar."
))
elif args[0].lower() in ["off", "no"]:
sql.disable_gbans(update.effective_chat.id)
send_message(
update.effective_message,
tl(
update.effective_message,
"Saya telah menonaktifkan larangan global dalam grup ini. Larangan global tidak akan memengaruhi pengguna Anda "
"lagi. Anda akan kurang terlindungi dari troll dan spammer sekalipun"
))
else:
send_message(
update.effective_message,
tl(
update.effective_message,
"Berikan saya beberapa argumen untuk memilih pengaturan! on/off, yes/no!\n\n"
"Pengaturan Anda saat ini: {}\n"
"Ketika Benar, setiap larangan global yang terjadi juga akan terjadi di grup Anda. "
"Ketika Salah, mereka tidak akan meninggalkan Anda pada belas kasihan yang mungkin dari "
"spammer.").format(sql.does_chat_gban(
update.effective_chat.id)))
def about_bio(update, context):
message = update.effective_message # type: Optional[Message]
args = context.args
user_id = extract_user(message, args)
if user_id and user_id != "error":
user = context.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 about_me(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_me_info(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 = message.reply_to_message.from_user.first_name
send_message(
update.effective_message,
username + tl(update.effective_message,
" belum mengatur pesan info tentang diri mereka!"))
else:
send_message(
update.effective_message,
tl(update.effective_message,
"Anda belum mengatur pesan info tentang diri Anda!"))
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 and user_id != "error":
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 flood(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=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 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 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".
format(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!").format(fst_name)
else:
res = tl(update.effective_message,
"{} sedang AFK!\nKarena : {}").format(
fst_name, reason)
send_message(update.effective_message, res)
