def set_rules(bot: Bot, update: Update): chat = update.effective_chat user = update.effective_user msg = update.effective_message if conn := connected(bot, update, chat, user.id): chat_id = conn
def list_notes(bot: Bot, update: Update): chat = update.effective_chat user = update.effective_user if conn := connected(bot, update, chat, user.id, need_admin=False): chat_id = conn chat_name = dispatcher.bot.getChat(conn).title msg = tld(chat.id, "note_in_chat")
def mute(bot: Bot, update: Update, args: List[str]) -> str: chat = update.effective_chat user = update.effective_user message = update.effective_message if conn := connected(bot, update, chat, user.id): chatD = dispatcher.bot.getChat(conn)
def list_handlers(bot: Bot, update: Update): chat = update.effective_chat user = update.effective_user if conn := connected(bot, update, chat, user.id, need_admin=False): chat_id = conn chat_name = dispatcher.bot.getChat(conn).title
def stop_filter(bot: Bot, update: Update): chat = update.effective_chat user = update.effective_user args = update.effective_message.text.split(None, 1) if conn := connected(bot, update, chat, user.id): chat_id = conn chat_name = dispatcher.bot.getChat(conn).title
def blacklist(bot: Bot, update: Update, args: List[str]): msg = update.effective_message chat = update.effective_chat user = update.effective_user if conn := connected(bot, update, chat, user.id, need_admin=False): chat_id = conn chat_name = dispatcher.bot.getChat(conn).title
def get_rules(bot: Bot, update: Update): chat = update.effective_chat user = update.effective_user msg = update.effective_message from_pm = False if conn := connected(bot, update, chat, user.id): chat_id = conn from_pm = True
def add_blacklist(bot: Bot, update: Update): msg = update.effective_message chat = update.effective_chat user = update.effective_user words = msg.text.split(None, 1) if conn := connected(bot, update, chat, user.id): chat_id = conn chat_name = dispatcher.bot.getChat(conn).title
def filters(bot: Bot, update: Update): chat = update.effective_chat user = update.effective_user msg = update.effective_message args = msg.text.split( None, 1) # use python's maxsplit to separate Cmd, keyword, and reply_text if conn := connected(bot, update, chat, user.id): chat_id = conn chat_name = dispatcher.bot.getChat(conn).title
def invite(bot: Bot, update: Update): chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] conn = connected(bot, update, chat, user.id, need_admin=False) if conn: chatP = dispatcher.bot.getChat(conn) else: chatP = update.effective_chat if chat.type == "private": exit(1) if chatP.username: update.effective_message.reply_text(chatP.username) elif chatP.type == chatP.SUPERGROUP or chatP.type == chatP.CHANNEL: bot_member = chatP.get_member(bot.id) if bot_member.can_invite_users: invitelink = chatP.invite_link # print(invitelink) if not invitelink: invitelink = bot.exportChatInviteLink(chatP.id) update.effective_message.reply_text(invitelink) else: update.effective_message.reply_text( tld( chat.id, "I don't have access to the invite link, try changing my permissions!" )) else: update.effective_message.reply_text( tld( chat.id, "Sorry, but I can give invite links only for supergroups and channels!" ))
def blacklist(bot: Bot, update: Update, args: List[str]): msg = update.effective_message chat = update.effective_chat user = update.effective_user 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 = tld(chat.id, "blacklist_active_list").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)) split_text = split_message(filter_list) for text in split_text: if filter_list == tld(chat.id, "blacklist_active_list").format( chat_name): #We need to translate msg.reply_text(tld(chat.id, "blacklist_no_list").format(chat_name), parse_mode=ParseMode.HTML) return msg.reply_text(text, parse_mode=ParseMode.HTML)
def list_locks(update, context): chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # Connection check conn = connected(context.bot, update, chat, user.id, need_admin=True) if conn: chat = dispatcher.bot.getChat(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_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 invite(bot: Bot, update: Update): chat = update.effective_chat user = update.effective_user conn = connected(bot, update, chat, user.id, need_admin=False) if conn: chatP = dispatcher.bot.getChat(conn) else: chatP = update.effective_chat if chat.type == "private": return if chatP.username: update.effective_message.reply_text(chatP.username) elif chatP.type == chatP.SUPERGROUP or chatP.type == chatP.CHANNEL: bot_member = chatP.get_member(bot.id) if bot_member.can_invite_users: invitelink = chatP.invite_link #print(invitelink) if not invitelink: invitelink = bot.exportChatInviteLink(chatP.id) update.effective_message.reply_text(invitelink) else: update.effective_message.reply_text( tld(chat.id, "admin_err_no_perm_invitelink")) else: update.effective_message.reply_text( tld(chat.id, "admin_err_chat_no_invitelink"))
def private_rules(update, context): args = context.args chat = update.effective_chat user = update.effective_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 = 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 mute(bot: Bot, update: Update, args: List[str]) -> str: chat = update.effective_chat user = update.effective_user message = update.effective_message conn = connected(bot, update, chat, user.id) if conn: chatD = dispatcher.bot.getChat(conn) else: if chat.type == "private": return "" else: chatD = chat user_id = extract_user(message, args) if not user_id: message.reply_text(tld(chat.id, "mute_invalid")) return "" if user_id == bot.id: message.reply_text(tld(chat.id, "mute_not_myself")) return "" member = chatD.get_member(int(user_id)) if member: if user_id in SUDO_USERS: message.reply_text(tld(chat.id, "mute_not_sudo")) elif is_user_admin(chatD, user_id, member=member): message.reply_text(tld(chat.id, "mute_not_m_admin")) elif member.can_send_messages is None or member.can_send_messages: bot.restrict_chat_member(chatD.id, user_id, can_send_messages=False) keyboard = [] reply = tld(chat.id, "mute_success").format( mention_html(member.user.id, member.user.first_name), chatD.title) message.reply_text(reply, reply_markup=keyboard, parse_mode=ParseMode.HTML) return "<b>{}:</b>" \ "\n#MUTE" \ "\n<b>Admin:</b> {}" \ "\n<b>User:</b> {}".format(html.escape(chatD.title), mention_html( user.id, user.first_name), mention_html(member.user.id, member.user.first_name)) else: message.reply_text( tld(chat.id, "mute_already_mute").format(chatD.title)) else: message.reply_text( tld(chat.id, "mute_not_in_chat").format(chatD.title)) return ""
def adminlist(bot, update): chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] conn = connected(bot, update, chat, user.id, need_admin=False) if conn: chatP = dispatcher.bot.getChat(conn) else: chatP = update.effective_chat if chat.type == "private": exit(1) administrators = chatP.get_administrators() text = tld(chat.id, "Admins in") + " *{}*:".format( chatP.title or tld(chat.id, "this chat")) for admin in administrators: user = admin.user status = admin.status if status == "creator": name = user.first_name + (user.last_name or "") + tld( chat.id, " (Creator)") else: name = user.first_name + (user.last_name or "") text += f"\n• `{name}`" update.effective_message.reply_text(text, parse_mode=ParseMode.MARKDOWN)
def list_handlers(update, context): chat = update.effective_chat # type: Optional[Chat] user = update.effective_user conn = connected(context.bot, update, chat, user.id, need_admin=False) if conn is not 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 stop_filter(update, context): chat = update.effective_chat # type: Optional[Chat] user = update.effective_user args = update.effective_message.text.split(None, 1) conn = connected(context.bot, update, chat, user.id) if conn is not 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].lower(): sql.remove_filter(chat_id, args[1].lower()) 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 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, "You can do this command in groups, not 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, "Wrong markdown text!\nIf you don't know what markdown is, please type `/markdownhelp` in 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, "I don't have access to pin message!"))
def set_rules(bot: Bot, update: Update): chat = update.effective_chat user = update.effective_user msg = update.effective_message conn = connected(bot, update, chat, user.id) if conn: chat_id = conn else: if chat.type == 'private': msg.reply_text(tld(chat.id, 'common_cmd_group_only')) return chat_id = chat.id raw_text = msg.text args = raw_text.split(None, 1) # use python's maxsplit to separate cmd and args if len(args) == 2: txt = args[1] offset = len(txt) - len( raw_text) # set correct offset relative to command markdown_rules = markdown_parser(txt, entities=msg.parse_entities(), offset=offset) sql.set_rules(chat_id, markdown_rules) msg.reply_text(tld(chat.id, "rules_success"))
def set_warn_limit(update, context) -> str: 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_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_name = update.effective_message.chat.title if args: if args[0].isdigit(): if int(args[0]) < 3: send_message( update.effective_message, tl(update.effective_message, "Batas peringatan minimum adalah 3!")) else: sql.set_warn_limit(chat.id, int(args[0])) if conn: text = tl( update.effective_message, "Diperbarui batas untuk diperingatkan {} pada *{}*" ).format(args[0], chat_name) else: text = tl( update.effective_message, "Diperbarui batas untuk diperingatkan {}").format( args[0]) send_message(update.effective_message, text, parse_mode="markdown") return "<b>{}:</b>" \ "\n#SET_WARN_LIMIT" \ "\n<b>Admin:</b> {}" \ "\nSet the warn limit to <code>{}</code>".format(html.escape(chat.title), mention_html(user.id, user.first_name), args[0]) else: send_message(update.effective_message, tl(update.effective_message, "Beri aku angkanya!")) else: limit, soft_warn, warn_mode = sql.get_warn_setting(chat.id) if conn: text = tl(update.effective_message, "Batas peringatan saat ini adalah {} pada *{}*").format( limit, chat_name) else: text = tl(update.effective_message, "Batas peringatan saat ini adalah {}").format(limit) send_message(update.effective_message, text, parse_mode="markdown") return ""
def add_blacklist(bot: Bot, update: Update): msg = update.effective_message # type: Optional[Message] chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] words = msg.text.split(None, 1) 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": exit(1) 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: msg.reply_text(tld(chat.id, "Added <code>{}</code> to the blacklist in <b>{}</b>!").format( html.escape(to_blacklist[0]), chat_name), parse_mode=ParseMode.HTML) else: msg.reply_text(tld(chat.id, "Added <code>{}</code> to the blacklist in <b>{}</b>!").format(len(to_blacklist)), chat_name, parse_mode=ParseMode.HTML) else: msg.reply_text(tld(chat.id, "Tell me what words you would like to add to the blacklist."))
def nomedia(bot: Bot, update: Update, args: List[str]) -> str: chat = update.effective_chat user = update.effective_user message = update.effective_message conn = connected(bot, update, chat, user.id) if conn: chatD = dispatcher.bot.getChat(conn) else: if chat.type == "private": return "" else: chatD = chat user_id = extract_user(message, args) if not user_id: message.reply_text(tld(chat.id, "restrict_invalid")) return "" if user_id == bot.id: message.reply_text(tld(chat.id, "restrict_is_bot")) return "" member = chatD.get_member(int(user_id)) if member: if is_user_admin(chatD, user_id, member=member): message.reply_text(tld(chat.id, "restrict_is_admin")) elif member.can_send_messages is None or member.can_send_messages: bot.restrict_chat_member(chatD.id, user_id, can_send_messages=True, can_send_media_messages=False, can_send_other_messages=False, can_add_web_page_previews=False) keyboard = [] reply = tld(chat.id, "restrict_success").format( mention_html(member.user.id, member.user.first_name), chatD.title) message.reply_text(reply, reply_markup=keyboard, parse_mode=ParseMode.HTML) return "<b>{}:</b>" \ "\n#RESTRICTED" \ "\n<b>• Admin:</b> {}" \ "\n<b>• User:</b> {}" \ "\n<b>• ID:</b> <code>{}</code>".format(html.escape(chatD.title), mention_html( user.id, user.first_name), mention_html(member.user.id, member.user.first_name), user_id) else: message.reply_text(tld(chat.id, "restrict_already_restricted")) else: message.reply_text( tld(chat.id, "mute_not_in_chat").format(chatD.title)) return ""
def adminlist(update, context): chat = update.effective_chat user = update.effective_user conn = connected(context.bot, update, chat, user.id, need_admin=False) if conn: chat = dispatcher.bot.getChat(conn) chat_id = conn else: if update.effective_message.chat.type == "private": send_message( update.effective_message, tl(update.effective_message, "You can do this command in groups, not PM")) return "" chat = update.effective_chat chat_id = update.effective_chat.id administrators = context.bot.getChatAdministrators(chat_id) text = tl(update.effective_message, "Admin in *{}*:").format( update.effective_chat.title or tl(update.effective_message, "chat ini")) for admin in administrators: user = admin.user status = admin.status if user.first_name == '': name = tl(update.effective_message, "☠Deleted Account") else: name = "{}".format( mention_markdown( user.id, user.first_name + " " + (user.last_name or ""))) # if user.username: # name = escape_markdown("@" + user.username) if status == "creator": text += "\n 👑 Creator:" text += "\n` • `{} \n\n 🔱 Admins:".format(name) for admin in administrators: user = admin.user status = admin.status if user.first_name == '': name = tl(update.effective_message, "☠Deleted Account") else: name = "{}".format( mention_markdown( user.id, user.first_name + " " + (user.last_name or ""))) # if user.username: # name = escape_markdown("@" + user.username) if status == "administrator": text += "\n` • `{}".format(name) try: send_message(update.effective_message, text, parse_mode=ParseMode.MARKDOWN) except BadRequest: send_message(update.effective_message, text, parse_mode=ParseMode.MARKDOWN, quote=False)
def demote(bot: Bot, update: Update, args: List[str]) -> str: chat = update.effective_chat message = update.effective_message user = update.effective_user conn = connected(bot, update, chat, user.id) if conn: chatD = dispatcher.bot.getChat(conn) else: chatD = update.effective_chat if chat.type == "private": return "" if not chatD.get_member(bot.id).can_promote_members: update.effective_message.reply_text(tld(chat.id, "admin_err_no_perm")) return "" user_id = extract_user(message, args) if not user_id: message.reply_text(tld(chat.id, "common_err_no_user")) return "" user_member = chatD.get_member(user_id) if user_member.status == 'creator': message.reply_text(tld(chat.id, "admin_err_demote_creator")) return "" if not user_member.status == 'administrator': message.reply_text(tld(chat.id, "admin_err_demote_noadmin")) return "" if user_id == bot.id: message.reply_text(tld(chat.id, "admin_err_self_demote")) return "" try: bot.promoteChatMember(int(chatD.id), int(user_id), can_change_info=False, can_post_messages=False, can_edit_messages=False, can_delete_messages=False, can_invite_users=False, can_restrict_members=False, can_pin_messages=False, can_promote_members=False) message.reply_text(tld(chat.id, "admin_demote_success").format( mention_html(user.id, user.first_name), mention_html(user_member.user.id, user_member.user.first_name), html.escape(chatD.title)), parse_mode=ParseMode.HTML) return f"<b>{html.escape(chatD.title)}:</b>" \ "\n#DEMOTED" \ f"\n<b>Admin:</b> {mention_html(user.id, user.first_name)}" \ f"\n<b>User:</b> {mention_html(user_member.user.id, user_member.user.first_name)}" except BadRequest: message.reply_text(tld(chat.id, "admin_err_cant_demote")) return ""
def promote(bot: Bot, update: Update, args: List[str]) -> str: message = update.effective_message # type: Optional[Message] user = update.effective_user # type: Optional[User] chat = update.effective_chat # type: Optional[Chat] conn = connected(bot, update, chat, user.id) if conn: chatD = dispatcher.bot.getChat(conn) else: chatD = update.effective_chat if chat.type == "private": exit(1) if not chatD.get_member(bot.id).can_promote_members: update.effective_message.reply_text( "I can't promote/demote people here! " "Make sure I'm admin and can appoint new admins.") user_id = extract_user(message, args) if not user_id: message.reply_text( tld(chat.id, "You don't seem to be referring to a user.")) return "" user_member = chatD.get_member(user_id) if user_member.status == 'administrator' or user_member.status == 'creator': message.reply_text( tld(chat.id, "How am I meant to promote someone who's already an admin?")) return "" if user_id == bot.id: message.reply_text( tld(chat.id, "I can't promote myself! Get an admin to do it for me.")) return "" # set same perms as bot - bot can't assign higher perms than itself! bot_member = chatD.get_member(bot.id) bot.promoteChatMember( chatD.id, user_id, can_change_info=bot_member.can_change_info, can_post_messages=bot_member.can_post_messages, can_edit_messages=bot_member.can_edit_messages, can_delete_messages=bot_member.can_delete_messages, # can_invite_users=bot_member.can_invite_users, can_restrict_members=bot_member.can_restrict_members, can_pin_messages=bot_member.can_pin_messages, can_promote_members=bot_member.can_promote_members) message.reply_text(tld(chat.id, f"Successfully promoted in *{chatD.title}*!"), parse_mode=ParseMode.MARKDOWN) return f"<b>{html.escape(chatD.title)}:</b>" \ "\n#PROMOTED" \ f"\n<b>• Admin:</b> {mention_html(user.id, user.first_name)}" \ f"\n<b>• User:</b> {mention_html(user_member.user.id, user_member.user.first_name)}"
def unblacklist(bot: Bot, update: Update): msg = update.effective_message chat = update.effective_chat user = update.effective_user words = msg.text.split(None, 1) conn = connected(bot, update, chat, user.id) if conn: chat_id = conn chat_name = dispatcher.bot.getChat(conn).title else: chat_id = update.effective_chat.id if chat.type == "private": return else: chat_name = chat.title if len(words) > 1: text = words[1] to_unblacklist = list({ trigger.strip() for trigger in text.split("\n") if trigger.strip() }) successful = 0 for trigger in to_unblacklist: success = sql.rm_from_blacklist(chat_id, trigger.lower()) if success: successful += 1 if len(to_unblacklist) == 1: if successful: msg.reply_text(tld(chat.id, "blacklist_del").format( html.escape(to_unblacklist[0]), chat_name), parse_mode=ParseMode.HTML) else: msg.reply_text(tld(chat.id, "blacklist_err_not_trigger")) elif successful == len(to_unblacklist): msg.reply_text(tld(chat.id, "blacklist_multi_del").format( successful, chat_name), parse_mode=ParseMode.HTML) elif not successful: msg.reply_text(tld(chat.id, "blacklist_err_multidel_no_trigger").format( successful, len(to_unblacklist) - successful), parse_mode=ParseMode.HTML) else: msg.reply_text(tld( chat.id, "blacklist_err_multidel_some_no_trigger").format( successful, chat_name, len(to_unblacklist) - successful), parse_mode=ParseMode.HTML) else: msg.reply_text(tld(chat.id, "blacklist_err_del_no_args"))
def private_note(bot: Bot, update: Update, args: List[str]): 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"): if len(args) >= 2: if args[1] == "del": sql.private_note(str(chat_id), True, True) send_message(update.effective_message, (tld( chat.id, "Private Note is *activated*, when a user retrieves a note, a note message will be sent to the PM and the user's message will be immediately deleted." )), parse_mode="markdown") else: sql.private_note(str(chat_id), True, False) send_message(update.effective_message, (tld( chat.id, "Private Note is *activated*, when a user retrieves a note, a note message will be sent to the PM." )), parse_mode="markdown") else: sql.private_note(str(chat_id), True, False) send_message(update.effective_message, (tld( chat.id, "Private Note is *activated*, when a user retrieves a note, a note message will be sent to the PM." )), parse_mode="markdown") elif args[0] in ("no", "off"): sql.private_note(str(chat_id), False, False) send_message(update.effective_message, (tld( chat.id, "Private Note is *deactivated*, note messages will be sent to the group." )), parse_mode="markdown") else: send_message(update.effective_message, (tld( chat.id, "Unknown argument - please use 'yes', or 'no'."))) else: is_private, is_delete = sql.get_private_note(chat_id) print(is_private, is_delete) send_message( update.effective_message, (tld(chat.id, "Private note settings at {}: *{}*{}").format( chat_name, "Enabled" if is_private else "Disabled", " - *Hash will be deleted*" if is_delete else "")), parse_mode="markdown")
def promote(bot: Bot, update: Update, args: List[str]) -> str: message = update.effective_message user = update.effective_user chat = update.effective_chat conn = connected(bot, update, chat, user.id) if conn: chatD = dispatcher.bot.getChat(conn) else: chatD = update.effective_chat if chat.type == "private": return "" if user_can_promote(chat, user, bot.id) is False: message.reply_text(tld(chat.id, "admin_no_promote_perm")) return "" if not chatD.get_member(bot.id).can_promote_members: message.reply_text(tld(chat.id, "admin_err_no_perm")) return "" user_id = extract_user(message, args) if not user_id: message.reply_text(tld(chat.id, "common_err_no_user")) return "" user_member = chatD.get_member(user_id) if user_member.status == 'administrator' or user_member.status == 'creator': message.reply_text(tld(chat.id, "admin_err_user_admin")) return "" if user_id == bot.id: message.reply_text(tld(chat.id, "admin_err_self_promote")) return "" # set same perms as bot - bot can't assign higher perms than itself! bot_member = chatD.get_member(bot.id) bot.promoteChatMember(chatD.id, user_id, can_change_info=bot_member.can_change_info, can_post_messages=bot_member.can_post_messages, can_edit_messages=bot_member.can_edit_messages, can_delete_messages=bot_member.can_delete_messages, can_invite_users=bot_member.can_invite_users, can_restrict_members=bot_member.can_restrict_members, can_pin_messages=bot_member.can_pin_messages, can_promote_members=bot_member.can_promote_members) message.reply_text(tld(chat.id, "admin_promote_success").format( mention_html(user.id, user.first_name), mention_html(user_member.user.id, user_member.user.first_name), html.escape(chatD.title)), parse_mode=ParseMode.HTML) return f"<b>{html.escape(chatD.title)}:</b>" \ "\n#PROMOTED" \ f"\n<b>• Admin:</b> {mention_html(user.id, user.first_name)}" \ f"\n<b>• User:</b> {mention_html(user_member.user.id, user_member.user.first_name)}"
def set_blue_text_must_click(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_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, "You can do this command in groups, not PM")) return "" chat_id = update.effective_chat.id chat_name = update.effective_message.chat.title if len(args) >= 1: val = args[0].lower() if val == "off" or val == "no": sql.set_cleanbt(chat_id, False) if conn: text = tl(update.effective_message, "Blue text cleaner was *disabled* in *{}*.").format( chat_name) else: text = tl(update.effective_message, "Blue text cleaner was *disabled*.") send_message(update.effective_message, text, parse_mode="markdown") elif val == "yes" or val == "on": sql.set_cleanbt(chat_id, True) if conn: text = tl(update.effective_message, "Blue text cleaner was *enabled* in *{}*.").format( chat_name) else: text = tl(update.effective_message, "Blue text cleaner was *enabled*.") send_message(update.effective_message, text, parse_mode="markdown") else: send_message( update.effective_message, tl(update.effective_message, "Unknown argument - please use 'yes', or 'no'.")) else: send_message( update.effective_message, tl(update.effective_message, "Curent settings for Blue text cleaner at {}: *{}*").format( chat_name, "Enabled" if sql.is_enable(chat_id) else "Disabled"), parse_mode="markdown")