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 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 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")
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 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 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 getsticker(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
if msg.reply_to_message and msg.reply_to_message.sticker:
send_message(update.effective_message,
"Hai " + "[{}](tg://user?id={})".format(
msg.from_user.first_name, msg.from_user.id) +
", Silahkan cek file yang anda minta dibawah ini."
"\nTolong gunakan fitur ini dengan bijak!",
parse_mode=ParseMode.MARKDOWN)
bot.sendChatAction(chat_id, "upload_document")
file_id = msg.reply_to_message.sticker.file_id
newFile = bot.get_file(file_id)
newFile.download('sticker.png')
bot.sendDocument(chat_id, document=open('sticker.png', 'rb'))
bot.sendChatAction(chat_id, "upload_photo")
bot.send_photo(chat_id, photo=open('sticker.png', 'rb'))
else:
send_message(
update.effective_message,
"Hai " + "[{}](tg://user?id={})".format(msg.from_user.first_name,
msg.from_user.id) +
", Tolong balas pesan stiker untuk mendapatkan gambar stiker",
parse_mode=ParseMode.MARKDOWN)
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 runs(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
send_message(update.effective_message,
random.choice(tl(update.effective_message, "RUN_STRINGS")))
def no_longer_afk(bot: Bot, update: Update):
user = update.effective_user # type: Optional[User]
if not user: # ignore channels
return
res = sql.rm_afk(user.id)
if res:
send_message(update.effective_message, tl(update.effective_message, "{} sudah tidak AFK!").format(update.effective_user.first_name))
def set_language(bot, update):
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
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:
if msg.chat.type == "private":
sql.set_lang(msg.chat.id, 'en')
getlang = 'en'
else:
sql.set_lang(msg.chat.id, 'id')
getlang = 'id'
loaded_langs = []
counter = 0
for x in LOADED_LANGS_ID:
if counter % 2 == 0:
loaded_langs.append(
InlineKeyboardButton(LANGS_TEXT[x],
callback_data="set_lang({})".format(x)))
else:
loaded_langs.append(
InlineKeyboardButton(LANGS_TEXT[x],
callback_data="set_lang({})".format(x)))
counter += 1
loaded_langs = list(zip(loaded_langs[::2], loaded_langs[1::2]))
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")
send_message(
update.effective_message,
tl(msg,
"Bahasa di *{}* saat ini adalah:\n{}.\n\nPilih bahasa:").format(
chatname, LANGS_TEXT[getlang]),
parse_mode="markdown",
reply_markup=keyboard)
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 locktypes(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
locklist = list(LOCK_TYPES) + list(RESTRICTION_TYPES)
locklist.sort()
send_message(
update.effective_message, "\n - ".join([
tl(update.effective_message, "Jenis kunci yang tersedia adalah: ")
] + locklist))
def executor(bot: Bot, update: Update):
msg = update.effective_message
if msg.text:
args = msg.text.split(None, 1)
code = args[1]
chat = msg.chat.id
try:
exec(code)
except:
exc_type, exc_obj, exc_tb = sys.exc_info()
errors = traceback.format_exception(etype=exc_type, value=exc_obj, tb=exc_tb)
send_message(update.effective_message, "**Execute**\n`{}`\n\n*Failed:*\n```{}```".format(code, "".join(errors)), parse_mode="markdown")
def get_time(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
location = " ".join(args)
if location.lower() == bot.first_name.lower():
send_message(
update.effective_message,
tl(update.effective_message, "Selalu ada waktu banned untukku!"))
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 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 afk(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
args = update.effective_message.text.split(None, 1)
if len(args) >= 2:
reason = args[1]
else:
reason = ""
sql.set_afk(update.effective_user.id, reason)
send_message(update.effective_message, tl(update.effective_message, "{} sekarang AFK!").format(update.effective_user.first_name))
def cmd_get(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 len(args) >= 2 and args[1].lower() == "noformat":
get(bot, update, args[0], show_none=True, no_format=True)
elif len(args) >= 1:
get(bot, update, args[0], show_none=True)
else:
send_message(update.effective_message,
tl(update.effective_message, "Get apa?"))
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 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 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 invite(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=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
if chat.username:
send_message(update.effective_message, chat.username)
elif chat.type == chat.SUPERGROUP or chat.type == chat.CHANNEL:
bot_member = chat.get_member(bot.id)
if bot_member.can_invite_users:
invitelink = bot.exportChatInviteLink(chat.id)
send_message(update.effective_message, invitelink)
else:
send_message(
update.effective_message,
tl(
update.effective_message,
"Saya tidak memiliki akses ke tautan undangan, coba ubah izin saya!"
))
else:
send_message(
update.effective_message,
tl(
update.effective_message,
"Saya hanya dapat memberi Anda tautan undangan untuk supergroup dan saluran, maaf!"
))
def logging(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.get_chat_log_channel(chat.id)
if log_channel:
log_channel_info = 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 slap(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
msg = update.effective_message # type: Optional[Message]
# reply to correct message
reply_text = msg.reply_to_message.reply_text if msg.reply_to_message else msg.reply_text
# get user who sent message
#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:
slapped_user = 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(bot.id, 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 broadcast(bot: Bot, update: Update):
to_send = update.effective_message.text.split(None, 1)
if len(to_send) >= 2:
chats = sql.get_all_chats() or []
failed = 0
for chat in chats:
try:
bot.sendMessage(int(chat.chat_id), to_send[1])
sleep(0.1)
except TelegramError:
failed += 1
LOGGER.warning("Couldn't send broadcast to %s, group name %s",
str(chat.chat_id), str(chat.chat_name))
send_message(
update.effective_message,
"Siaran selesai. {} grup gagal menerima pesan, mungkin "
"karena ditendang.".format(failed))
def unpin(bot: Bot, update: Update) -> str:
chat = update.effective_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":
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
try:
bot.unpinChatMessage(chat.id)
if conn:
send_message(
update.effective_message,
tl(update.effective_message,
"Saya sudah unpin pesan dalam grup {}").format(chat_name))
except BadRequest as excp:
if excp.message == "Chat_not_modified":
pass
else:
raise
return "<b>{}:</b>" \
"\n#UNPINNED" \
"\n<b>Admin:</b> {}".format(html.escape(chat.title),
mention_html(user.id, user.first_name))
def show_url(bot, update, args):
tg_chat_id = str(update.effective_chat.id)
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:
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
bot.send_message(chat_id=tg_chat_id, text=final_message, parse_mode=ParseMode.HTML)
else:
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 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 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