async def view_locks(_, m: Message): ( v_perm, vmsg, vmedia, vstickers, vanimations, vgames, vinlinebots, vwebprev, vpolls, vinfo, vinvite, vpin, ) = ("", "", "", "", "", "", "", "", "", "", "", "") chkmsg = await m.reply_text(tlang(m, "locks.check_perm_msg")) v_perm = m.chat.permissions async def convert_to_emoji(val: bool): if val is True: return "✅" return "❌" vmsg = await convert_to_emoji(v_perm.can_send_messages) vmedia = await convert_to_emoji(v_perm.can_send_media_messages) vstickers = await convert_to_emoji(v_perm.can_send_stickers) vanimations = await convert_to_emoji(v_perm.can_send_animations) vgames = await convert_to_emoji(v_perm.can_send_games) vinlinebots = await convert_to_emoji(v_perm.can_use_inline_bots) vwebprev = await convert_to_emoji(v_perm.can_add_web_page_previews) vpolls = await convert_to_emoji(v_perm.can_send_polls) vinfo = await convert_to_emoji(v_perm.can_change_info) vinvite = await convert_to_emoji(v_perm.can_invite_users) vpin = await convert_to_emoji(v_perm.can_pin_messages) if v_perm is not None: try: permission_view_str = (tlang(m, "locks.view_perm")).format( vmsg=vmsg, vmedia=vmedia, vstickers=vstickers, vanimations=vanimations, vgames=vgames, vinlinebots=vinlinebots, vwebprev=vwebprev, vpolls=vpolls, vinfo=vinfo, vinvite=vinvite, vpin=vpin, ) LOGGER.info(f"{m.from_user.id} used locks cmd in {m.chat.id}") await chkmsg.edit_text(permission_view_str) except RPCError as e_f: await chkmsg.edit_text(tlang(m, "general.something_wrong")) await m.reply_text(e_f) return
async def ban_usr(_, m: Message): user_id, user_first_name = await extract_user(m) try: await m.chat.kick_member(user_id) await m.reply_text( tlang(m, "admin.banned_user").format( admin=(await mention_html(m.from_user.first_name, m.from_user.id)), banned=(await mention_html(user_first_name, user_id)), chat_title=f"<b>{m.chat.title}</b>", ), ) except ChatAdminRequired: await m.reply_text(tlang(m, "admin.not_admin")) except RightForbidden: await m.reply_text(tlang(m, tlang(m, "admin.bot_no_ban_right"))) except RPCError as ef: await m.reply_text( tlang(m, "general.some_error").format( SUPPORT_GROUP=f"@{SUPPORT_GROUP}", ef=f"<code>{ef}</code>", ), ) LOGGER.error(ef) return
async def view_locks(c: Alita, m: Message): v_perm = "" vmsg = "" vmedia = "" vstickers = "" vanimations = "" vgames = "" vinlinebots = "" vwebprev = "" vpolls = "" vinfo = "" vinvite = "" vpin = "" chkmsg = await m.reply_text(tlang(m, "locks.check_perm_msg")) v_perm = await c.get_chat(m.chat.id) async def convert_to_emoji(val: bool): if val is True: return "✅" return "❌" vmsg = await convert_to_emoji(v_perm.permissions.can_send_messages) vmedia = await convert_to_emoji(v_perm.permissions.can_send_media_messages) vstickers = await convert_to_emoji(v_perm.permissions.can_send_stickers) vanimations = await convert_to_emoji(v_perm.permissions.can_send_animations ) vgames = await convert_to_emoji(v_perm.permissions.can_send_games) vinlinebots = await convert_to_emoji(v_perm.permissions.can_use_inline_bots ) vwebprev = await convert_to_emoji( v_perm.permissions.can_add_web_page_previews) vpolls = await convert_to_emoji(v_perm.permissions.can_send_polls) vinfo = await convert_to_emoji(v_perm.permissions.can_change_info) vinvite = await convert_to_emoji(v_perm.permissions.can_invite_users) vpin = await convert_to_emoji(v_perm.permissions.can_pin_messages) if v_perm is not None: try: permission_view_str = tlang(m, "locks.view_perm").format( vmsg=vmsg, vmedia=vmedia, vstickers=vstickers, vanimations=vanimations, vgames=vgames, vinlinebots=vinlinebots, vwebprev=vwebprev, vpolls=vpolls, vinfo=vinfo, vinvite=vinvite, vpin=vpin, ) await chkmsg.edit_text(permission_view_str) except RPCError as e_f: await chkmsg.edit_text(tlang(m, "general.something_wrong")) await m.reply_text(e_f) return
async def get_rules(c: Alita, m: Message): chat_id = m.chat.id rules = db.get_rules(chat_id) if not rules: await m.reply_text(tlang(m, "rules.no_rules"), reply_to_message_id=m.message_id) return try: await c.send_message( m.from_user.id, tlang(m, "rules.get_rules").format( chat=f"<b>{m.chat.title}</b>", rules=rules, ), ) except UserIsBlocked: me_name = await get_key("BOT_USERNAME") pm_kb = InlineKeyboardMarkup( [[InlineKeyboardButton("PM", url=f"https://t.me/{me_name}?start")] ], ) await m.reply_text( tlang(m, "rules.pm_me"), reply_to_message_id=m.message_id, reply_markup=pm_kb, ) return await m.reply_text( tlang(m, "rules.sent_pm_rules"), reply_to_message_id=m.message_id, ) return
async def set_lang(_, m: Message): args = m.text.split() if len(args) > 2: await m.reply_text(tlang(m, "langs.correct_usage")) return if len(args) == 2: lang_code = args[1] avail_langs = set(lang_dict.keys()) if lang_code not in avail_langs: await m.reply_text( f"Please choose a valid language code from: {', '.join(avail_langs)}", ) return db.set_lang(m.chat.id, lang_code) LOGGER.info( f"{m.from_user.id} change language to {lang_code} in {m.chat.id}") await m.reply_text( f"🌐 {((tlang(m, 'langs.changed')).format(lang_code=lang_code))}", ) return await m.reply_text( (tlang(m, "langs.changelang")), reply_markup=InlineKeyboardMarkup([*(await gen_langs_kb())]), ) return
async def get_invitelink(c: Alita, m: Message): try: link = await c.export_chat_invite_link(m.chat.id) await m.reply_text( (tlang(m, "admin.invitelink")).format( chat_name=m.chat.id, link=link, ), disable_web_page_preview=True, ) LOGGER.info(f"{m.from_user.id} exported invite link in {m.chat.id}") except ChatAdminRequired: await m.reply_text(tlang(m, "admin.not_admin")) except ChatAdminInviteRequired: await m.reply_text(tlang(m, "admin.no_invite_perm")) except RightForbidden: await m.reply_text(tlang(m, "admin.no_user_invite_perm")) except RPCError as ef: await m.reply_text( (tlang(m, "general.some_error")).format( SUPPORT_GROUP=SUPPORT_GROUP, ef=ef, ), ) LOGGER.error(ef) LOGGER.error(format_exc()) return
async def unpinall_calllback(c: Alita, q: CallbackQuery): user_id = q.from_user.id user_status = (await q.message.chat.get_member(user_id)).status if user_status not in {"creator", "administrator"}: await q.answer( "You're not even an admin, don't try this explosive shit!", show_alert=True, ) return if user_status != "creator": await q.answer( "You're just an admin, not owner\nStay in your limits!", show_alert=True, ) return try: await c.unpin_all_chat_messages(q.message.chat.id) LOGGER.info( f"{q.from_user.id} unpinned all messages in {q.message.chat.id}") await q.message.edit_text(tlang(q, "pin.unpinned_all_msg")) except ChatAdminRequired: await q.message.edit_text(tlang(q, "admin.notadmin")) except RightForbidden: await q.message.edit_text(tlang(q, "pin.no_rights_unpin")) except RPCError as ef: await q.message.edit_text((tlang(q, "general.some_error")).format( SUPPORT_GROUP=SUPPORT_GROUP, ef=ef, ), ) LOGGER.error(ef) return
async def get_lyrics(_, m: Message): if len(m.text.split()) <= 1: await m.reply_text(tlang(m, "general.check_help")) return query = m.text.split(None, 1)[1] LOGGER.info(f"{m.from_user.id} used lyrics cmd in {m.chat.id}") song = "" if not query: await m.edit_text(tlang(m, "utils.song.no_song_given")) return em = await m.reply_text( (tlang(m, "utils.song.searching").format(song_name=query)), ) song = Song.find_song(query) if song: if song.lyrics: reply = song.format() else: reply = tlang(m, "utils.song.no_lyrics_found") else: reply = tlang(m, "utils.song.song_not_found") try: await em.edit_text(reply) except MessageTooLong: with BytesIO(str.encode(await remove_markdown_and_html(reply))) as f: f.name = "lyrics.txt" await m.reply_document(document=f, ) await em.delete() return
async def rm_blacklist(_, m: Message): chat_bl = db.get_chat_blacklist(m.chat.id) if not isinstance(chat_bl, bool): pass else: if len(m.text.split()) >= 2: bl_word = m.text.split(None, 1)[1] if bl_word in chat_bl: db.rm_from_blacklist(m.chat.id, bl_word.lower()) await m.reply_text( tlang(m, "blacklist.rm_blacklist").format( bl_word=f"<code>{bl_word}</code>", ), ) return await m.reply_text( tlang(m, "blacklist.no_bl_found").format( bl_word=f"<code>{bl_word}</code>", ), ) else: await m.reply_text( tlang(m, "general.check_help"), reply_to_message_id=m.message_id, ) return
async def commands_menu(_, q: CallbackQuery): keyboard = InlineKeyboardMarkup(inline_keyboard=[ *(await gen_cmds_kb(q)), [ InlineKeyboardButton( f"« {(tlang(q, 'general.back_btn'))}", callback_data="start_back", ), ], ], ) try: await q.message.edit_text( (tlang(q, "general.commands_available")), reply_markup=keyboard, ) except MessageNotModified: pass except QueryIdInvalid: await q.message.reply_text( (tlang(q, "general.commands_available")), reply_markup=keyboard, ) await q.answer() return
async def paste_it(_, m: Message): replymsg = await m.reply_text((tlang(m, "utils.paste.pasting")), quote=True) try: if m.reply_to_message: if m.reply_to_message.document: dl_loc = await m.reply_to_message.download() with open(dl_loc) as f: txt = f.read() remove(dl_loc) else: txt = m.reply_to_message.text else: txt = m.text.split(None, 1)[1] ur = "https://hastebin.com/documents" r = await http.post(ur, json={"content": txt}) url = f"https://hastebin.com/{r.json().get('key')}" await replymsg.edit_text( (tlang(m, "utils.paste.pasted_nekobin")), reply_markup=ikb([[((tlang(m, "utils.paste.nekobin_btn")), url, "url")]]), ) LOGGER.info(f"{m.from_user.id} used paste cmd in {m.chat.id}") except Exception as e: await replymsg.edit_text(f"Error: {e}") return return
async def get_invitelink(c: Alita, m: Message): try: link = await c.export_chat_invite_link(m.chat.id) await m.reply_text( tlang(m, "admin.invitelink").format( chat_name=f"<b>{m.chat.id}</b>", link=link, ), ) except ChatAdminRequired: await m.reply_text(tlang(m, "admin.not_admin")) except ChatAdminInviteRequired: await m.reply_text(tlang(m, "admin.noinviteperm")) except RightForbidden: await m.reply_text(tlang(m, "no_invite_perm")) except RPCError as ef: await m.reply_text( tlang(m, "general.some_error").format( SUPPORT_GROUP=f"@{SUPPORT_GROUP}", ef=f"<code>{ef}</code>", ), ) LOGGER.error(ef) return
async def weebify(_, m: Message): if len(m.text.split()) >= 2: args = m.text.split(None, 1)[1] elif m.reply_to_message and len(m.text.split()) == 1: args = m.reply_to_message.text else: await m.reply_text( "Please reply to a message or enter text after command to weebify it.", ) return if not args: await m.reply_text(tlang(m, "utils.weebify.weebify_what")) return # Use split to convert to list # Not using list itself becuase black changes it to long format... normiefont = "a b c d e f g h i j k l m n o p q r s t u v w x y z".split() weebyfont = "卂 乃 匚 刀 乇 下 厶 卄 工 丁 长 乚 从 𠘨 口 尸 㔿 尺 丂 丅 凵 リ 山 乂 丫 乙".split() string = " ".join(args).lower() for normiecharacter in string: if normiecharacter in normiefont: weebycharacter = weebyfont[normiefont.index(normiecharacter)] string = string.replace(normiecharacter, weebycharacter) await m.reply_text( (tlang(m, "utils.weebify.weebified_string").format(string=string)), ) LOGGER.info(f"{m.from_user.id} weebified '{args}' in {m.chat.id}") return
async def reload_admins(_, m: Message): ADMINDICT = await get_key("ADMINDICT") # Load ADMINDICT from string try: adminlist = [] async for i in m.chat.iter_members(filter="administrators"): if i.user.is_deleted: continue adminlist.append( ( i.user.id, f"@{i.user.username}" if i.user.username else i.user.first_name, ), ) ADMINDICT[str(m.chat.id)] = adminlist await set_key("ADMINDICT", ADMINDICT) await m.reply_text(tlang(m, "admin.adminlist.reloaded_admins")) except RPCError as ef: await m.reply_text( tlang(m, "general.some_error").format( SUPPORT_GROUP=f"@{SUPPORT_GROUP}", ef=f"<code>{ef}</code>", ), ) LOGGER.error(ef) return
async def clean_linked(_, m: Message): pinsdb = Pins(m.chat.id) if len(m.text.split()) == 1: status = pinsdb.get_settings()["cleanlinked"] await m.reply_text( tlang(m, "pin.antichannelpin.current_status").format( status=status, ), ) return if len(m.text.split()) == 2: if m.command[1] in ("yes", "on", "true"): pinsdb.cleanlinked_on() LOGGER.info(f"{m.from_user.id} enabled CleanLinked in {m.chat.id}") msg = "Turned on CleanLinked! Now all the messages from linked channel will be deleted!" elif m.command[1] in ("no", "off", "false"): pinsdb.cleanlinked_off() LOGGER.info( f"{m.from_user.id} disabled CleanLinked in {m.chat.id}") msg = "Turned off CleanLinked! Messages from linked channel will not be deleted!" else: await m.reply_text(tlang(m, "general.check_help")) return await m.reply_text(msg) return
async def anti_channel_pin(_, m: Message): pinsdb = Pins(m.chat.id) if len(m.text.split()) == 1: status = pinsdb.get_settings()["antichannelpin"] await m.reply_text( tlang(m, "pin.antichannelpin.current_status").format( status=status, ), ) return if len(m.text.split()) == 2: if m.command[1] in ("yes", "on", "true"): pinsdb.antichannelpin_on() LOGGER.info( f"{m.from_user.id} enabled antichannelpin in {m.chat.id}") msg = tlang(m, "pin.antichannelpin.turned_on") elif m.command[1] in ("no", "off", "false"): pinsdb.antichannelpin_off() LOGGER.info( f"{m.from_user.id} disabled antichannelpin in {m.chat.id}") msg = tlang(m, "pin.antichannelpin.turned_off") else: await m.reply_text(tlang(m, "general.check_help")) return await m.reply_text(msg) return
async def unmute_usr(c: Alita, m: Message): from alita import BOT_ID if len(m.text.split()) == 1 and not m.reply_to_message: await m.reply_text("I can't unmute nothing!") return user_id, user_first_name, _ = await extract_user(c, m) if user_id == BOT_ID: await m.reply_text( "Huh, why would I unmute myself if you are using me?") return try: await m.chat.restrict_member(user_id, m.chat.permissions) LOGGER.info(f"{m.from_user.id} unmuted {user_id} in {m.chat.id}") await m.reply_text((tlang(m, "admin.unmute.unmuted_user")).format( admin=(await mention_html(m.from_user.first_name, m.from_user.id)), unmuted=(await mention_html(user_first_name, user_id)), ), ) except ChatAdminRequired: await m.reply_text(tlang(m, "admin.not_admin")) except UserNotParticipant: await m.reply_text( "How can I unmute a user who is not a part of this chat?") except RightForbidden: await m.reply_text(tlang(m, "admin.unmute.bot_no_right")) except RPCError as ef: await m.reply_text((tlang(m, "general.some_error")).format( SUPPORT_GROUP=SUPPORT_GROUP, ef=ef, ), ) LOGGER.error(ef) return
async def reload_admins(_, m: Message): global TEMP_ADMIN_CACHE_BLOCK if m.chat.type != "supergroup": return await m.reply_text( "This command is made to be used in groups only!", ) if ((m.chat.id in set(TEMP_ADMIN_CACHE_BLOCK.keys())) and (m.from_user.id not in SUPPORT_STAFF) and TEMP_ADMIN_CACHE_BLOCK[m.chat.id] == "manualblock"): await m.reply_text("Can only reload admin cache once per 10 mins!") return try: await admin_cache_reload(m, "admincache") TEMP_ADMIN_CACHE_BLOCK[m.chat.id] = "manualblock" await m.reply_text(tlang(m, "admin.adminlist.reloaded_admins")) LOGGER.info(f"Admincache cmd use in {m.chat.id} by {m.from_user.id}") except RPCError as ef: await m.reply_text((tlang(m, "general.some_error")).format( SUPPORT_GROUP=SUPPORT_GROUP, ef=ef, ), ) LOGGER.error(ef) LOGGER.error(format_exc()) return
async def paste_it(_, m: Message): replymsg = await m.reply_text((tlang(m, "utils.paste.pasting")), quote=True) if m.reply_to_message: if m.reply_to_message.document: dl_loc = await m.reply_to_message.download() with open(dl_loc) as f: txt = f.read() remove(dl_loc) else: txt = m.reply_to_message.text else: txt = m.text.split(None, 1)[1] url = (await paste(txt))[0] await replymsg.edit_text( (tlang(m, "utils.paste.pasted_nekobin")), reply_markup=InlineKeyboardMarkup( [ [ InlineKeyboardButton( (tlang(m, "utils.paste.nekobin_btn")), url=url, ), ], ], ), ) LOGGER.info(f"{m.from_user.id} used paste cmd in {m.chat.id}") return
async def get_formatting_info(_, q: CallbackQuery): cmd = q.data.split(".")[1] kb = ikb([[((tlang(q, "general.back_btn")), "back.formatting")]]) if cmd == "md_formatting": await q.message.edit_text( tlang(q, "formatting.md_help"), reply_markup=kb, parse_mode="html", ) elif cmd == "fillings": await q.message.edit_text( tlang(q, "formatting.filling_help"), reply_markup=kb, parse_mode="html", ) elif cmd == "random_content": await q.message.edit_text( tlang(q, "formatting.random_help"), reply_markup=kb, parse_mode="html", ) await q.answer() return
async def add_blacklist(_, m: Message): db = Blacklist(m.chat.id) if len(m.text.split()) < 2: await m.reply_text(tlang(m, "general.check_help")) return bl_words = ((m.text.split(None, 1)[1]).lower()).split() all_blacklisted = db.get_blacklists() already_added_words, rep_text = [], "" for bl_word in bl_words: if bl_word in all_blacklisted: already_added_words.append(bl_word) continue db.add_blacklist(bl_word) if already_added_words: rep_text = ( ", ".join([f"<code>{i}</code>" for i in bl_words]) + " already added in blacklist, skipped them!" ) LOGGER.info(f"{m.from_user.id} added new blacklists ({bl_words}) in {m.chat.id}") await m.reply_text( (tlang(m, "blacklist.added_blacklist")).format( trigger=", ".join(f"<code>{i}</code>" for i in bl_words), ) + (f"\n{rep_text}" if rep_text else ""), ) await m.stop_propagation()
async def priv_rules(_, m: Message): chat_id = m.chat.id if len(m.text.split()) == 2: option = (m.text.split())[1] if option in ("on", "yes"): db.set_privrules(chat_id, True) LOGGER.info(f"{m.from_user.id} enabled privaterules in {m.chat.id}") msg = tlang(m, "rules.priv_rules.turned_on").format(chat_name=m.chat.title) elif option in ("off", "no"): db.set_privrules(chat_id, False) LOGGER.info(f"{m.from_user.id} disbaled privaterules in {m.chat.id}") msg = tlang(m, "rules.priv_rules.turned_off").format(chat_name=m.chat.title) else: msg = tlang(m, "rules.priv_rules.no_option") await m.reply_text(msg) elif len(m.text.split()) == 1: curr_pref = db.get_privrules(m.chat.id) msg = tlang(m, "rules.priv_rules.current_preference").format( current_option=curr_pref, ) LOGGER.info(f"{m.from_user.id} fetched privaterules preference in {m.chat.id}") await m.reply_text(msg) else: await m.replt_text(tlang(m, "general.check_help")) return
async def set_bl_action(_, m: Message): db = Blacklist(m.chat.id) if len(m.text.split()) == 2: action = m.text.split(None, 1)[1] valid_actions = ("ban", "kick", "mute", "warn", "none") if action not in valid_actions: await m.reply_text( ( "Choose a valid blacklist action from " + ", ".join(f"<code>{i}</code>" for i in valid_actions) ), ) return db.set_action(action) LOGGER.info( f"{m.from_user.id} set blacklist action to '{action}' in {m.chat.id}", ) await m.reply_text( (tlang(m, "blacklist.action_set")).format(action=action), ) elif len(m.text.split()) == 1: action = db.get_action() LOGGER.info(f"{m.from_user.id} checking blacklist action in {m.chat.id}") await m.reply_text( (tlang(m, "blacklist.action_get")).format(action=action), ) else: await m.reply_text(tlang(m, "general.check_help")) return
async def view_blacklist(_, m: Message): db = Blacklist(m.chat.id) LOGGER.info(f"{m.from_user.id} checking blacklists in {m.chat.id}") chat_title = m.chat.title blacklists_chat = (tlang(m, "blacklist.curr_blacklist_initial")).format( chat_title=chat_title, ) all_blacklisted = db.get_blacklists() if not all_blacklisted: await m.reply_text( (tlang(m, "blacklist.no_blacklist")).format( chat_title=chat_title, ), ) return blacklists_chat += "\n".join( f" • <code>{escape(i)}</code>" for i in all_blacklisted ) await m.reply_text(blacklists_chat) return
async def rm_blacklist(_, m: Message): db = Blacklist(m.chat.id) if len(m.text.split()) < 2: await m.reply_text(tlang(m, "general.check_help")) return chat_bl = db.get_blacklists() non_found_words, rep_text = [], "" bl_words = ((m.text.split(None, 1)[1]).lower()).split() for bl_word in bl_words: if bl_word not in chat_bl: non_found_words.append(bl_word) continue db.remove_blacklist(bl_word) if non_found_words == bl_words: return await m.reply_text("Blacklists not found!") if non_found_words: rep_text = ( "Could not find " + ", ".join(f"<code>{i}</code>" for i in non_found_words) ) + " in blcklisted words, skipped them." LOGGER.info(f"{m.from_user.id} removed blacklists ({bl_words}) in {m.chat.id}") await m.reply_text( (tlang(m, "blacklist.rm_blacklist")).format( bl_words=", ".join(f"<code>{i}</code>" for i in bl_words), ) + (f"\n{rep_text}" if rep_text else ""), ) await m.stop_propagation()
async def pin_message(c: Alita, m: Message): pin_args = m.text.split(None, 1) if m.reply_to_message: try: disable_notification = True if len(pin_args) >= 2 and pin_args[1] in [ "alert", "notify", "loud" ]: disable_notification = False await c.pin_chat_message( m.chat.id, m.reply_to_message.message_id, disable_notification=disable_notification, ) await m.reply_text(tlang(m, "pin.pinned_msg")) except ChatAdminRequired: await m.reply_text(tlang(m, "admin.not_admin")) except RightForbidden: await m.reply_text(tlang(m, "pin.no_rights_pin")) except RPCError as ef: await m.reply_text( tlang(m, "general.some_error").format( SUPPORT_GROUP=f"@{SUPPORT_GROUP}", ef=f"<code>{ef}</code>", ), ) LOGGER.error(ef) else: await m.reply_text(tlang(m, "admin.nopinmsg")) return
async def spurge(c: Alita, m: Message): if m.chat.type != "supergroup": await m.reply_text(tlang(m, "purge.err_basic")) return if m.reply_to_message: message_ids = list(range(m.reply_to_message.message_id, m.message_id)) def divide_chunks(l: list, n: int = 100): for i in range(0, len(l), n): yield l[i:i + n] # Dielete messages in chunks of 100 messages m_list = list(divide_chunks(message_ids)) try: for plist in m_list: await c.delete_messages( chat_id=m.chat.id, message_ids=plist, revoke=True, ) await m.delete() except MessageDeleteForbidden: await m.reply_text(tlang(m, "purge.old_msg_err")) return except RPCError as ef: await m.reply_text((tlang(m, "general.some_error")).format( SUPPORT_GROUP=SUPPORT_GROUP, ef=ef, ), ) return await m.reply_text("Reply to a message to start spurge !") return
async def gban_list(_, m: Message): banned_users = db.load_from_db() if not banned_users: await m.reply_text(tlang(m, "antispam.none_gbanned")) return banfile = tlang(m, "antispam.here_gbanned_start") for user in banned_users: banfile += f"[x] <b>{Users.get_user_info(user['_id'])['name']}</b> - <code>{user['_id']}</code>\n" if user["reason"]: banfile += f"<b>Reason:</b> {user['reason']}\n" try: await m.reply_text(banfile) except MessageTooLong: with BytesIO(str.encode(await remove_markdown_and_html(banfile))) as f: f.name = "gbanlist.txt" await m.reply_document( document=f, caption=tlang(m, "antispam.here_gbanned_start"), ) LOGGER.info(f"{m.from_user.id} exported gbanlist in {m.chat.id}") return
async def smute_usr(c: Alita, m: Message): if len(m.text.split()) == 1 and not m.reply_to_message: await m.reply_text("Я не могу никого замьютить!") return try: user_id, _, _ = await extract_user(c, m) except Exception: return if not user_id: await m.reply_text("Cannot find user to mute") return if user_id == Config.BOT_ID: await m.reply_text("Huh, why would I mute myself?") return if user_id in SUPPORT_STAFF: LOGGER.info( f"{m.from_user.id} trying to mute {user_id} (SUPPORT_STAFF) in {m.chat.id}", ) await m.reply_text(tlang(m, "admin.support_cannot_restrict")) return try: admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]} except KeyError: admins_group = await admin_cache_reload(m, "mute") if user_id in admins_group: await m.reply_text(tlang(m, "admin.mute.admin_cannot_mute")) return try: await m.chat.restrict_member( user_id, ChatPermissions(), ) LOGGER.info(f"{m.from_user.id} smuted {user_id} in {m.chat.id}") await m.delete() if m.reply_to_message: await m.reply_to_message.delete() return return except ChatAdminRequired: await m.reply_text(tlang(m, "admin.not_admin")) except RightForbidden: await m.reply_text(tlang(m, "admin.mute.bot_no_right")) except UserNotParticipant: await m.reply_text( "How can I mute a user who is not a part of this chat?") except RPCError as ef: await m.reply_text((tlang(m, "general.some_error")).format( SUPPORT_GROUP=SUPPORT_GROUP, ef=ef, ), ) LOGGER.error(ef) return
async def perform_action_blacklist(m: Message, action: str, trigger: str): if action == "kick": await m.chat.kick_member(m.from_user.id, int(time() + 45)) await m.reply_text( tlang(m, "blacklist.bl_watcher.action_kick").format( user=m.from_user.username or f"<b>{m.from_user.first_name}</b>", ), ) elif action == "ban": (await m.chat.kick_member(m.from_user.id, )) await m.reply_text( tlang(m, "blacklist.bl_watcher.action_ban").format( user=m.from_user.username or f"<b>{m.from_user.first_name}</b>", ), ) elif action == "mute": await m.chat.restrict_member( m.from_user.id, ChatPermissions(), ) await m.reply_text( tlang(m, "blacklist.bl_watcher.action_mute").format( user=m.from_user.username or f"<b>{m.from_user.first_name}</b>", ), ) elif action == "warn": warns_settings_db = WarnSettings(m.chat.id) warns_db = Warns(m.chat.id) warn_settings = warns_settings_db.get_warnings_settings() warn_reason = bl_db.get_reason() _, num = warns_db.warn_user(m.from_user.id, warn_reason) if num >= warn_settings["warn_limit"]: if warn_settings["warn_mode"] == "kick": await m.chat.ban_member( m.from_user.id, until_date=int(time() + 45), ) action = "kicked" elif warn_settings["warn_mode"] == "ban": await m.chat.ban_member(m.from_user.id) action = "banned" elif warn_settings["warn_mode"] == "mute": await m.chat.restrict_member(m.from_user.id, ChatPermissions()) action = "muted" await m.reply_text(( f"Warnings {num}/{warn_settings['warn_limit']}\n" f"{(await mention_html(m.from_user.first_name, m.from_user.id))} has been <b>{action}!</b>" ), ) return await m.reply_text( ( f"{(await mention_html(m.from_user.first_name, m.from_user.id))} warned {num}/{warn_settings['warn_limit']}\n" # f"Last warn was for:\n<i>{warn_reason}</i>" f"Last warn was for:\n<i>{warn_reason.format(trigger)}</i>" ), ) return