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