def set_about_bio(update, context): 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 permanent_pin(update, context): user = update.effective_user # type: Optional[User] chat = update.effective_chat # type: Optional[Chat] message = update.effective_message args = context.args get_permapin = sql.get_permapin(chat.id) if get_permapin and not user.id == context.bot.id: try: to_del = context.bot.pinChatMessage(chat.id, get_permapin, disable_notification=True) except BadRequest: sql.set_permapin(chat.id, 0) if chat.username: old_pin = "https://t.me/{}/{}".format(chat.username, get_permapin) else: old_pin = "https://t.me/c/{}/{}".format( str(chat.id)[4:], get_permapin) send_message( update.effective_message, tl( update.effective_message, "*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: context.bot.deleteMessage(chat.id, message.message_id + 1) except BadRequest: print("Permanent pin error: cannot delete pin msg")
def log_user(update, context): chat = update.effective_chat # type: Optional[Chat] msg = update.effective_message # type: Optional[Message] """text = msg.text if msg.text else "" uid = msg.from_user.id uname = msg.from_user.name print("{} | {} | {} | {}".format(text, uname, uid, chat.title))""" fed_id = fedsql.get_fed_id(chat.id) if fed_id: user = update.effective_user if user: fban, fbanreason, fbantime = fedsql.get_fban_user(fed_id, user.id) if fban: send_message( update.effective_message, languages.tl( update.effective_message, "Pengguna ini dilarang di federasi saat ini!\nAlasan: `{}`" ).format(fbanreason), parse_mode="markdown") try: context.bot.kick_chat_member(chat.id, user.id) except: print("Fban: cannot banned this user") sql.update_user(msg.from_user.id, msg.from_user.username, chat.id, chat.title) if msg.reply_to_message: sql.update_user(msg.reply_to_message.from_user.id, msg.reply_to_message.from_user.username, chat.id, chat.title) if msg.forward_from: sql.update_user(msg.forward_from.id, msg.forward_from.username)
def slap(update, context): args = context.args 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 and user_id != "error": slapped_user = context.bot.get_chat(user_id) user1 = curr_user #if slapped_user.username: # user2 = "@" + escape_markdown(slapped_user.username) #else: user2 = "{}".format(mention_markdown(slapped_user.id, slapped_user.first_name)) # if no target found, bot targets the sender else: user1 = "{}".format(mention_markdown(context.bot.id, context.bot.first_name)) user2 = curr_user temp = random.choice(tl(update.effective_message, "SLAP_TEMPLATES")) item = random.choice(tl(update.effective_message, "ITEMS")) hit = random.choice(tl(update.effective_message, "HIT")) throw = random.choice(tl(update.effective_message, "THROW")) repl = temp.format(user1=user1, user2=user2, item=item, hits=hit, throws=throw) send_message(update.effective_message, repl, parse_mode=ParseMode.MARKDOWN)
def permapin(update, context): chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] message = update.effective_message # type: Optional[Message] args = context.args conn = connected(context.bot, update, chat, user.id, need_admin=False) if conn: chat = dispatcher.bot.getChat(conn) chat_id = conn chat_name = dispatcher.bot.getChat(conn).title else: if update.effective_message.chat.type == "private": send_message( update.effective_message, tl(update.effective_message, "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 = context.bot.send_message( chat_id, text, parse_mode="markdown", disable_web_page_preview=True, reply_markup=InlineKeyboardMarkup(tombol)) except BadRequest: context.bot.send_message( chat_id, tl( update.effective_message, "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: context.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 commands(update, context): chat = update.effective_chat user = update.effective_user conn = connected(context.bot, update, chat, user.id, need_admin=True) if conn: chat = dispatcher.bot.getChat(conn) chat_id = conn chat_name = dispatcher.bot.getChat(conn).title else: if update.effective_message.chat.type == "private": send_message( update.effective_message, languages.tl( update.effective_message, "Anda bisa lakukan command ini pada grup, bukan pada PM" )) return "" chat = update.effective_chat chat_id = update.effective_chat.id chat_name = update.effective_message.chat.title text = build_curr_disabled(chat.id) send_message(update.effective_message, text, parse_mode=ParseMode.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 cmd_get(update, context): args = context.args if len(args) >= 2 and args[1].lower() == "noformat": get(context.bot, update, args[0], show_none=True, no_format=True) elif len(args) >= 1: get(context.bot, update, args[0], show_none=True) else: send_message(update.effective_message, tl(update.effective_message, "Get apa?"))
def help_connect_chat(update, context): context.args if update.effective_message.chat.type != "private": send_message(update.effective_message, "PM me with that command to get help.") return else: send_message(update.effective_message, CONN_HELP, parse_mode="markdown")
def disconnect_chat(update, context): if update.effective_chat.type == 'private': disconnection_status = sql.disconnect(update.effective_message.from_user.id) if disconnection_status: sql.disconnected_chat = send_message(update.effective_message, 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 setlog(update, context): message = update.effective_message # type: Optional[Message] chat = update.effective_chat # type: Optional[Chat] if chat.type == chat.CHANNEL: send_message( update.effective_message, tl( update.effective_message, "Sekarang, teruskan /setlog ke grup yang Anda ingin ikat saluran ini!" )) elif message.forward_from_chat: sql.set_chat_log_channel(chat.id, message.forward_from_chat.id) try: message.delete() except BadRequest as excp: if excp.message == "Message to delete not found": pass else: LOGGER.exception( "Error deleting message in log channel. Should work anyway though." ) try: context.bot.send_message( message.forward_from_chat.id, tl( update.effective_message, "Saluran ini telah ditetapkan sebagai saluran log untuk {}." ).format(chat.title or chat.first_name)) except Unauthorized as excp: if excp.message == "Forbidden: bot is not a member of the channel chat": context.bot.send_message( chat.id, tl( update.effective_message, "Gagal menyetel saluran log!\nSaya mungkin bukan admin di channel tersebut." )) sql.stop_chat_logging(chat.id) return else: LOGGER.exception("ERROR in setting the log channel.") context.bot.send_message( chat.id, tl(update.effective_message, "Berhasil mengatur saluran log!")) else: send_message( update.effective_message, tl( update.effective_message, "Langkah-langkah untuk mengatur saluran log adalah:\n" " - tambahkan bot ke saluran yang diinginkan\n" " - Kirimkan /setlog ke saluran\n" " - Teruskan /setlog ke grup\n"))
def help_connect_chat(update, context): chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] args = context.args 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 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 set_verify_welcome(update, context): args = context.args chat = update.effective_chat # type: Optional[Chat] getcur, extra_verify, cur_value, timeout, timeout_mode, cust_text = sql.welcome_security( chat.id) if len(args) >= 1: var = args[0].lower() if (var == "yes" or var == "ya" or var == "on"): check = context.bot.getChatMember(chat.id, context.bot.id) if check.status == 'member' or check[ 'can_restrict_members'] == False: text = tl( update.effective_message, "Saya tidak bisa membatasi orang di sini! Pastikan saya admin agar bisa membisukan seseorang!" ) send_message(update.effective_message, text, parse_mode="markdown") return "" sql.set_welcome_security(chat.id, getcur, True, str(cur_value), str(timeout), int(timeout_mode), cust_text) send_message( update.effective_message, tl( update.effective_message, "Keamanan untuk member baru di aktifkan! Pengguna baru di wajibkan harus menyelesaikan verifikasi untuk chat" )) elif (var == "no" or var == "ga" or var == "off"): sql.set_welcome_security(chat.id, getcur, False, str(cur_value), str(timeout), int(timeout_mode), cust_text) send_message( update.effective_message, tl( update.effective_message, "Di nonaktifkan, pengguna dapat mengklik tombol untuk langsung chat" )) else: send_message(update.effective_message, tl(update.effective_message, "Silakan tulis `on`/`ya`/`off`/`ga`!"), parse_mode=ParseMode.MARKDOWN) else: getcur, extra_verify, cur_value, timeout, timeout_mode, cust_text = sql.welcome_security( chat.id) if cur_value[:1] == "0": cur_value = tl(update.effective_message, "Selamanya") text = tl( update.effective_message, "Pengaturan saat ini adalah:\nWelcome security: `{}`\nVerify security: `{}`\nMember akan di mute selama: `{}`\nWaktu verifikasi timeout: `{}`\nTombol unmute custom: `{}`" ).format(getcur, extra_verify, cur_value, make_time(int(timeout)), cust_text) send_message(update.effective_message, text, parse_mode="markdown")
def no_longer_afk(update, context): 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 afk(update, context): 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 set_about_me(update, context): message = update.effective_message # type: Optional[Message] user_id = message.from_user.id text = message.text info = text.split(None, 1) # use python's maxsplit to only remove the cmd, hence keeping newlines. if len(info) == 2: if len(info[1]) < MAX_MESSAGE_LENGTH // 4: sql.set_user_me_info(user_id, info[1]) send_message(update.effective_message, tl(update.effective_message, "Info Anda Diperbarui!")) else: send_message(update.effective_message, tl(update.effective_message, "Info Anda harus di bawah {} karakter! Kamu punya {}.").format(MAX_MESSAGE_LENGTH // 4, len(info[1])))
def disconnect_chat(update, context): if update.effective_chat.type == "private": disconnection_status = sql.disconnect(update.effective_message.from_user.id) if disconnection_status: sql.disconnected_chat = send_message( update.effective_message, "Disconnected from chat!" ) else: send_message(update.effective_message, "You're not connected!") else: send_message(update.effective_message, "This command is only available in PM.")
def purge(update, context): args = context.args msg = update.effective_message # type: Optional[Message] if msg.reply_to_message: user = update.effective_user # type: Optional[User] chat = update.effective_chat # type: Optional[Chat] if user_can_delete(chat, user, context.bot.id): message_id = msg.reply_to_message.message_id if args and args[0].isdigit(): delete_to = message_id + int(args[0]) else: delete_to = msg.message_id - 1 for m_id in range(delete_to, message_id - 1, -1): # Reverse iteration over message ids try: context.bot.deleteMessage(chat.id, m_id) except BadRequest as err: if err.message == "Message can't be deleted": send_message( update.effective_message, tl( update.effective_message, "Tidak dapat menghapus semua pesan. Pesannya mungkin terlalu lama, saya mungkin " "tidak memiliki hak menghapus, atau ini mungkin bukan supergrup." )) elif err.message != "Message to delete not found": LOGGER.exception("Error while purging chat messages.") try: msg.delete() except BadRequest as err: if err.message == "Message can't be deleted": send_message( update.effective_message, tl( update.effective_message, "Tidak dapat menghapus semua pesan. Pesannya mungkin terlalu lama, saya mungkin " "tidak memiliki hak menghapus, atau ini mungkin bukan supergrup." )) elif err.message != "Message to delete not found": LOGGER.exception("Error while purging chat messages.") send_message(update.effective_message, tl(update.effective_message, "Pembersihan selesai.")) return "<b>{}:</b>" \ "\n#PURGE" \ "\n<b>Admin:</b> {}" \ "\nPurged <code>{}</code> messages.".format(html.escape(chat.title), mention_html(user.id, user.first_name), delete_to - message_id) else: send_message( update.effective_message, tl(update.effective_message, "Balas pesan untuk memilih tempat mulai membersihkan.")) return ""
def get_time_alt(update, context): args = context.args if args: location = " ".join(args) if location.lower() == context.bot.first_name.lower(): send_message(update.effective_message, "Selalu ada waktu banned untukku!") context.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 save(update, context): chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] 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": chat_name = "catatan lokal" else: chat_name = chat.title msg = update.effective_message # type: Optional[Message] checktext = msg.text.split() if msg.reply_to_message: if len(checktext) <= 1: send_message(update.effective_message, tl(update.effective_message, "Anda harus memberi nama untuk catatan ini!")) return else: if len(checktext) <= 2: send_message(update.effective_message, tl(update.effective_message, "Anda harus memberi nama untuk catatan ini!")) return note_name, text, data_type, content, buttons = get_note_type(msg) if data_type is None: send_message(update.effective_message, tl(update.effective_message, "Tidak ada catatan!")) return if len(text.strip()) == 0: text = "`" + note_name + "`" sql.add_note_to_db(chat_id, note_name, text, data_type, buttons=buttons, file=content) if conn: savedtext = tl(update.effective_message, "Ok, catatan `{note_name}` disimpan di *{chat_name}*.").format(note_name=note_name, chat_name=chat_name) else: savedtext = tl(update.effective_message, "Ok, catatan `{note_name}` disimpan.").format(note_name=note_name) try: send_message(update.effective_message, savedtext, parse_mode=ParseMode.MARKDOWN) except BadRequest: if conn: savedtext = tl(update.effective_message, "Ok, catatan <code>{note_name}</code> disimpan di <b>{chat_name}</b>.").format(note_name=note_name, chat_name=chat_name) else: savedtext = tl(update.effective_message, "Ok, catatan <code>{note_name}</code> disimpan.").format(note_name=note_name) send_message(update.effective_message, savedtext, parse_mode=ParseMode.HTML)
def list_cmds(update, context): if DISABLE_CMDS + DISABLE_OTHER: result = "" for cmd in set(DISABLE_CMDS + DISABLE_OTHER): result += " - `{}`\n".format(escape_markdown(cmd)) send_message( update.effective_message, languages.tl( update.effective_message, "Perintah berikut dapat diubah:\n{}").format(result), parse_mode=ParseMode.MARKDOWN) else: send_message( update.effective_message, languages.tl(update.effective_message, "Tidak ada perintah yang dapat dinonaktifkan."))
def executor(update, context): 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 gbanlist(update, context): banned_users = sql.get_gban_list() if not banned_users: send_message(update.effective_message, tl(update.effective_message, "Tidak ada pengguna yang dilarang global! Anda lebih baik dari yang saya harapkan...")) return banfile = tl(update.effective_message, 'Persetan orang-orang ini.\n') for user in banned_users: banfile += "[x] {} - {}\n".format(user["name"], user["user_id"]) if user["reason"]: banfile += "Alasan: {}\n".format(user["reason"]) with BytesIO(str.encode(banfile)) as output: output.name = "gbanlist.txt" update.effective_message.reply_document(document=output, filename="gbanlist.txt", caption=tl(update.effective_message, "Berikut adalah daftar pengguna yang saat ini dilarang secara global."))
def del_message(update, context) -> str: if update.effective_message.reply_to_message: user = update.effective_user # type: Optional[User] chat = update.effective_chat # type: Optional[Chat] if user_can_delete(chat, user, context.bot.id): update.effective_message.reply_to_message.delete() update.effective_message.delete() return "<b>{}:</b>" \ "\n#DEL" \ "\n<b>Admin:</b> {}" \ "\nMessage deleted.".format(html.escape(chat.title), mention_html(user.id, user.first_name)) else: send_message(update.effective_message, tl(update.effective_message, "Apa yang ingin di hapus?")) return ""
def broadcast(update, context): 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: context.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 blackliststicker(update, context): msg = update.effective_message # type: Optional[Message] chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] args = context.args conn = connected(context.bot, update, chat, user.id, need_admin=False) if conn: chat_id = conn chat_name = dispatcher.bot.getChat(conn).title else: if chat.type == "private": return else: chat_id = update.effective_chat.id chat_name = chat.title sticker_list = tl( update.effective_message, "<b>Daftar hitam stiker saat saat ini di {}:</b>\n").format(chat_name) all_stickerlist = sql.get_chat_stickers(chat_id) if len(args) > 0 and args[0].lower() == 'copy': for trigger in all_stickerlist: sticker_list += "<code>{}</code>\n".format(html.escape(trigger)) elif len(args) == 0: for trigger in all_stickerlist: sticker_list += " - <code>{}</code>\n".format(html.escape(trigger)) split_text = split_message(sticker_list) for text in split_text: if sticker_list == tl( update.effective_message, "<b>Daftar hitam stiker saat saat ini di {}:</b>\n").format( chat_name).format(chat_name): send_message( update.effective_message, tl(update.effective_message, "Tidak ada stiker daftar hitam stiker di <b>{}</b>!"). format(chat_name), parse_mode=ParseMode.HTML) return send_message(update.effective_message, text, parse_mode=ParseMode.HTML)
def disable(update, context): chat = update.effective_chat # type: Optional[Chat] user = update.effective_user args = context.args conn = connected(context.bot, update, chat, user.id, need_admin=True) if conn: chat = dispatcher.bot.getChat(conn) chat_id = conn chat_name = dispatcher.bot.getChat(conn).title else: if update.effective_message.chat.type == "private": send_message( update.effective_message, languages.tl( update.effective_message, "Anda bisa lakukan command ini pada grup, bukan pada PM" )) return "" chat = update.effective_chat chat_id = update.effective_chat.id chat_name = update.effective_message.chat.title if len(args) >= 1: disable_cmd = args[0] if disable_cmd.startswith(CMD_STARTERS): disable_cmd = disable_cmd[1:] if disable_cmd in set(DISABLE_CMDS + DISABLE_OTHER): sql.disable_command(chat.id, disable_cmd) if conn: text = languages.tl( update.effective_message, "Menonaktifkan penggunaan `{}` pada *{}*").format( disable_cmd, chat_name) else: text = languages.tl( update.effective_message, "Menonaktifkan penggunaan `{}`").format(disable_cmd) send_message(update.effective_message, text, parse_mode=ParseMode.MARKDOWN) else: send_message( update.effective_message, languages.tl(update.effective_message, "Perintah itu tidak bisa dinonaktifkan")) else: send_message( update.effective_message, languages.tl(update.effective_message, "Apa yang harus saya nonaktifkan?"))
def invite(update, context): chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] args = context.args conn = connected(context.bot, update, chat, user.id, need_admin=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(context.bot.id) if bot_member.can_invite_users: invitelink = context.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 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!"))