async def filters_active(event): """ For .filters command, lists all of the active filters in a chat. """ if not is_mongo_alive() or not is_redis_alive(): await event.edit("`Database connections failing!`") return transact = "`There are no filters in this chat.`" filters = await get_filters(event.chat_id) for filt in filters: if transact == "`There are no filters in this chat.`": transact = "Active filters in this chat:\n" transact += " • **{}** - `{}`\n".format(filt["keyword"], filt["msg"]) else: transact += " • **{}** - `{}`\n".format(filt["keyword"], filt["msg"]) await event.edit(transact)
async def lists_active(event): """ For .lists command, list all of the lists saved in a chat. """ if not is_mongo_alive() or not is_redis_alive(): await event.edit(DB_FAILED) return message = NO_LISTS lists = await get_lists(event.chat_id) if lists.count() != 0: message = "Lists saved in this chat:\n" for _list in lists: message += "🔹 **{} ({})**\n".format( _list["name"], "Local" if (_list["chat_id"] != 0) else "Global") await event.edit(message)
async def gspider(gspdr): """ For .gmute command, gmutes the target in the userbot """ cmd = gspdr.text[0] if not cmd.isalpha() and cmd not in ("/", "#", "@", "!"): # Admin or creator check chat = await gspdr.get_chat() admin = chat.admin_rights creator = chat.creator # If not admin and not creator, return if not admin and not creator: await gspdr.edit(NO_ADMIN) return # Check if the function running under SQL mode if not is_mongo_alive() or not is_redis_alive(): await gspdr.edit(NO_SQL) return user = await get_user_from_event(gspdr) if user: pass else: return # If the targeted user is a SUDO if user.id in BRAIN_CHECKER: await gspdr.edit( "`Errore Mute Globale! Non posso mutare globalmente questo utente.`" ) return # If pass, inform and start gmuting await gspdr.edit("`Prendi un enorme nastro, e mutalo dappertutto!`") if await gmute(user.id) is False: await gspdr.edit( '`Errore! Utente probabilmente già globalmente mutato.`') else: await gspdr.edit("`Mutato globalmente!`") if BOTLOG: await gspdr.client.send_message( BOTLOG_CHATID, "#GMUTE\n" f"USER: [{user.first_name}](tg://user?id={user.id})\n" f"CHAT: {gspdr.chat.title}(`{gspdr.chat_id}`)")
async def unmoot(unmot): """ For .unmute command, unmute the target """ if not unmot.text[0].isalpha() and unmot.text[0] \ not in ("/", "#", "@", "!"): # Admin or creator check chat = await unmot.get_chat() admin = chat.admin_rights creator = chat.creator # If not admin and not creator, return if not admin and not creator: await unmot.edit(NO_ADMIN) return # Check if the function running under SQL mode if not is_mongo_alive() or not is_redis_alive(): await unmot.edit(NO_SQL) return # If admin or creator, inform the user and start unmuting await unmot.edit('```Unmutando...```') user = await get_user_from_event(unmot) if user: pass else: return if await unmute(unmot.chat_id, user.id) is False: return await unmot.edit( "`Errore! Utente probabilmente già mutato.`") else: try: await unmot.client( EditBannedRequest(unmot.chat_id, user.id, UNMUTE_RIGHTS)) await unmot.edit("```Unmutato con successo!```") except UserIdInvalidError: await unmot.edit("`Uh oh my unmute logic broke!`") return if BOTLOG: await unmot.client.send_message( BOTLOG_CHATID, "#UNMUTE\n" f"USER: [{user.first_name}](tg://user?id={user.id})\n" f"CHAT: {unmot.chat.title}(`{unmot.chat_id}`)")
async def auto_accept(event): """ Will approve automatically if you texted them first. """ if event.is_private and not (await event.get_sender()).bot: if not is_mongo_alive() or not is_redis_alive(): return chat = await event.get_chat() if isinstance(chat, User): if is_approved(event.chat_id): return async for message in event.client.iter_messages(chat.id, reverse=True, limit=1): if message.from_id == (await event.client.get_me()).id: approve(chat.id) if BOTLOG: await event.client.send_message( BOTLOG_CHATID, "#AUTO-APPROVED\n" + "User: "******"[{chat.first_name}](tg://user?id={chat.id})", )
async def notes_active(event): """ For .saved command, list all of the notes saved in a chat. """ cmd = event.text[0] if not cmd.isalpha() and cmd not in ("/", "#", "@", "!"): if not is_mongo_alive() or not is_redis_alive(): await event.edit("`Database connections failing!`") return message = "`There are no saved notes in this chat`" notes = await get_notes(event.chat_id) for note in notes: if message == "`There are no saved notes in this chat`": message = "Notes saved in this chat:\n" message += "🔹 **{}**\n".format(note["name"]) else: message += "🔹 **{}**\n".format(note["name"]) await event.edit(message)
async def gspider(gspdr): """ For .gmute command, gmutes the target in the userbot """ cmd = gspdr.text[0] if not cmd.isalpha() and cmd not in ("/", "#", "@", "!"): # Admin or creator check chat = await gspdr.get_chat() admin = chat.admin_rights creator = chat.creator # If not admin and not creator, return if not admin and not creator: await gspdr.edit(NO_ADMIN) return # Check if the function running under SQL mode if not is_mongo_alive() or not is_redis_alive(): await gspdr.edit(NO_SQL) return user = await get_user_from_event(gspdr) if user: pass else: return # If the targeted user is a SUDO if user.id in BRAIN_CHECKER: await gspdr.edit("`Gmute Error! Couldn't gmute this user`") return # If pass, inform and start gmuting await gspdr.edit("`Grabs a huge, sticky duct tape!`") if await gmute(user.id) is False: await gspdr.edit('`Error! User probably already gmuted.`') else: await gspdr.edit("`Globally taped!`") if BOTLOG: await gspdr.client.send_message( BOTLOG_CHATID, "#GMUTE\n" f"USER: [{user.first_name}](tg://user?id={user.id})\n" f"CHAT: {gspdr.chat.title}(`{gspdr.chat_id}`)" )
async def setliststate(event): """ For .setlist command, changes the state of a list. """ if environ.get("isSuspended") == "True": return if not is_mongo_alive() or not is_redis_alive(): await event.edit(DB_FAILED) return _futureState = event.pattern_match.group(2) changeToGlobal = None if _futureState == "global": changeToGlobal = True elif _futureState == "local": changeToGlobal = False textx = await event.get_reply_message() listname = None if textx: x = re.search(r"\[Paperplane-List] List \*\*(\w*)", textx.text) listname = x.group(1) elif event.pattern_match.group(1): listname = event.pattern_match.group(1) else: await event.edit(f"`Pass a list to remove!` {CHK_HELP}") return _list = await get_list(event.chat_id, listname) chatid = 0 if changeToGlobal else event.chat_id msg = f"`The state of list {listname} changed to \ {_futureState} successfully.`" if await set_list(_list['chat_id'], listname, chatid) is True: await event.edit(msg) else: await event.edit(f"`List {listname} not found!`") if BOTLOG: await event.client.send_message( BOTLOG_CHATID, f"Changed state of list {listname} to {_futureState}")
async def add_new_filter(event): """ Command for adding a new filter """ cmd = event.text[0] if not cmd.isalpha() and cmd not in ("/", "#", "@", "!"): if not is_mongo_alive() or not is_redis_alive(): await event.edit("`Database connections failing!`") return message = event.text keyword = message.split() string = "" for i in range(2, len(keyword)): string = string + " " + str(keyword[i]) msg = "`Filter` **{}** `{} successfully`" if await add_filter(event.chat_id, keyword[1], string[1:]) is True: await event.edit(msg.format(keyword[1], 'added')) else: await event.edit(msg.format(keyword[1], 'updated'))
async def lists_active(event): """ For .lists command, list all of the lists saved in a chat. """ cmd = event.text[0] if not cmd.isalpha() and cmd not in ("/", "#", "@", "!"): if not is_mongo_alive() or not is_redis_alive(): await event.edit("`Database connections failing!`") return message = "`There are no saved lists in this chat`" lists = await get_lists(event.chat_id) if lists.count() != 0: message = "Lists saved in this chat:\n" for _list in lists: message += "🔹 **{} ({})**\n".format( _list["name"], "Local" if (_list["chat_id"] != 0) else "Global") await event.edit(message)
async def filter_incoming_handler(handler): """Checks if the incoming message contains handler of a filter""" try: if not (await handler.get_sender()).bot: if not is_mongo_alive() or not is_redis_alive(): await handler.edit("`Database connections failing!`") return filters = await get_filters(handler.chat_id) if not filters: return for trigger in filters: pattern = (r"( |^|[^\w])" + re.escape(trigger["keyword"]) + r"( |$|[^\w])") if re.search(pattern, handler.text, flags=re.IGNORECASE): await handler.reply(trigger["msg"]) return except AttributeError: pass
async def add_filter(event): """ For .save command, saves notes in a chat. """ cmd = event.text[0] if not cmd.isalpha() and cmd not in ("/", "#", "@", "!"): if not is_mongo_alive() or not is_redis_alive(): await event.edit("`Database connections failing!`") return notename = event.pattern_match.group(1) string = event.text.partition(notename)[2] if event.reply_to_msg_id: string = " " + (await event.get_reply_message()).text msg = "`Note {} successfully. Use` #{} `to get it`" if await add_note(event.chat_id, notename, string[1:]) is False: return await event.edit(msg.format('updated', notename)) else: return await event.edit(msg.format('added', notename))
async def unmoot(unmot): """ For .unmute command, unmute the target """ # Admin or creator check chat = await unmot.get_chat() admin = chat.admin_rights creator = chat.creator # If not admin and not creator, return if not admin and not creator: await unmot.edit(NO_ADMIN) return # Check if the function running under SQL mode if not is_mongo_alive() or not is_redis_alive(): await unmot.edit(NO_SQL) return # If admin or creator, inform the user and start unmuting await unmot.edit('```Unmuting...```') user = await get_user_from_event(unmot) # Do we need a reason to unmute ? user = user[0] if user: pass else: return if await unmute(unmot.chat_id, user.id) is False: return await unmot.edit("`Error! User probably already unmuted.`") else: try: await unmot.client( EditBannedRequest(unmot.chat_id, user.id, UNMUTE_RIGHTS)) await unmot.edit("```Unmuted Successfully```") except UserIdInvalidError: await unmot.edit("`Uh oh my unmute logic broke!`") return if BOTLOG: await unmot.client.send_message( BOTLOG_CHATID, "#UNMUTE\n" f"USER: [{user.first_name}](tg://user?id={user.id})\n" f"CHAT: {unmot.chat.title}(`{unmot.chat_id}`)")
async def unmoot(unmot): """For .unmute command, unmute the target""" # Admin or creator check chat = await unmot.get_chat() admin = chat.admin_rights creator = chat.creator # If not admin and not creator, return if not admin and not creator: await unmot.edit(NO_ADMIN) return # Check if the function running under SQL mode if not is_mongo_alive() or not is_redis_alive(): await unmot.edit(NO_SQL) return # If admin or creator, inform the user and start unmuting await unmot.edit("```Unmuting...```") user = await helpers.get_user_from_event(unmot) if not user: await unmoot.edit( "`Missing user to unmute! Either reply to message, mention the user or specify a valid ID!`" ) if await unmute(unmot.chat_id, user.id) is False: return await unmot.edit("`Error! User is probably already unmuted.`") try: await unmot.client( EditBannedRequest(unmot.chat_id, user.id, UNMUTE_RIGHTS)) await unmot.edit("```Unmuted!```") except UserIdInvalidError: await unmot.edit("`Uh oh, my unmute logic broke!`") return if BOTLOG: await unmot.client.send_message( BOTLOG_CHATID, "#UNMUTE\n" f"USER: [{user.first_name}](tg://user?id={user.id})\n" f"CHAT: {unmot.chat.title}(`{unmot.chat_id}`)", )
async def ungmoot(un_gmute): """ For .ungmute command, ungmutes the target in the userbot """ if not un_gmute.text[0].isalpha() and un_gmute.text[0] \ not in ("/", "#", "@", "!"): # Admin or creator check chat = await un_gmute.get_chat() admin = chat.admin_rights creator = chat.creator # If not admin and not creator, return if not admin and not creator: await un_gmute.edit(NO_ADMIN) return # Check if the function running under SQL mode if not is_mongo_alive() or not is_redis_alive(): await un_gmute.edit(NO_SQL) return user = await get_user_from_event(un_gmute) if user: pass else: return # If pass, inform and start ungmuting await un_gmute.edit('```Ungmuting...```') if await ungmute(user.id) is False: await un_gmute.edit("`Error! User probably not gmuted.`") else: # Inform about success await un_gmute.edit("```Ungmuted Successfully```") if BOTLOG: await un_gmute.client.send_message( BOTLOG_CHATID, "#UNGMUTE\n" f"USER: [{user.first_name}](tg://user?id={user.id})\n" f"CHAT: {un_gmute.chat.title}(`{un_gmute.chat_id}`)" )
async def filter_incoming_handler(handler): """ Checks if the incoming message contains handler of a filter """ try: if not (await handler.get_sender()).bot: if not is_mongo_alive() or not is_redis_alive(): await handler.edit("`Database connections failing!`") return incoming_message = handler.text filters = await get_filters(handler.chat_id) if not filters: return for trigger in filters: pro = re.fullmatch(trigger["keyword"], incoming_message, flags=re.IGNORECASE) if pro: await handler.reply(trigger["msg"]) return except AttributeError: pass
async def add_new_filter(event): """ Command for adding a new filter """ if not is_mongo_alive() or not is_redis_alive(): await event.edit("`Database connections failing!`") return message = event.text keyword = message.split() string = "" for i in range(2, len(keyword)): string = string + " " + str(keyword[i]) if event.reply_to_msg_id: string = " " + (await event.get_reply_message()).text msg = "`Filter` **{}** `{} successfully`" if await add_filter(event.chat_id, keyword[1], string[1:]) is True: await event.edit(msg.format(keyword[1], 'added')) else: await event.edit(msg.format(keyword[1], 'updated'))
async def add_filter(event): """ For .save command, saves notes in a chat. """ if not is_mongo_alive() or not is_redis_alive(): await event.edit("`Database connections failing!`") return notename = event.pattern_match.group(1) string = event.pattern_match.group(2) if event.reply_to_msg_id: string = (await event.get_reply_message()).text msg = "`{} note #{}`" if await add_note(event.chat_id, notename, string) is False: message = msg.format('Updated', notename) return await event.edit(message, delete_in=3) else: message = msg.format('Added', notename) return await event.edit(message, delete_in=3)
async def edit_list_item(event): """ For .editlistitem command, edit an individual item on a list. """ cmd = event.text[0] if not cmd.isalpha() and cmd not in ("/", "#", "@", "!"): if not is_mongo_alive() or not is_redis_alive(): await event.edit(DB_FAILED) return textx = await event.get_reply_message() listname = None if textx: x = re.search(r"\[Paperplane-List] List \*\*(\w*)", textx.text) listname = x.group(1) elif event.pattern_match.group(1): listname = event.pattern_match.group(1) else: await event.edit(f"`Pass a list!` {CHK_HELP}") return item_number = int(event.pattern_match.group(2)) _list = await get_list(event.chat_id, listname) content = _list['items'] content[item_number - 1] = event.pattern_match.group(3) msg = f"`Item {item_number} edited successfully.\n" msg += f"Use` ${listname} `to get the list.`" if await add_list(event.chat_id, listname, content) is False: await event.edit(msg) else: await event.edit(LIST_NOT_FOUND.format(listname)) if BOTLOG: listat = "global storage" if _list['chat_id'] else str( event.chat_id) log = "Edited item {item_number} of " log += f"{listname} in {listat} successfully." await event.client.send_message(BOTLOG_CHATID, log)
async def removelists(event): """ For .rmlist command, delete list with the given name.""" cmd = event.text[0] if not cmd.isalpha() and cmd not in ("/", "#", "@", "!"): if not is_mongo_alive() or not is_redis_alive(): await event.edit("`Database connections failing!`") return listname = event.pattern_match.group(1) _list = await get_list(event.chat_id, listname) if await delete_list(event.chat_id, listname) is False: await event.edit("`Couldn't find list:` **{}**".format(listname)) else: await event.edit( "`Successfully deleted list:` **{}**".format(listname)) if BOTLOG: listat = "global storage" if _list['chat_id'] == 0 else str( event.chat_id) await event.client.send_message( BOTLOG_CHATID, f"Removed list {listname} from {listat}")
async def lists_logic(event): """ Lists logic. """ try: if not (await event.get_sender()).bot: if not is_mongo_alive() or not is_redis_alive(): return listname = event.text[1:] _list = await get_list(event.chat_id, listname) if _list: return_str = "" if _list['items']: for i, item in enumerate(_list['items']): return_str += f"{i+1}. {item}\n" else: return_str = "`This list is empty!`" await event.reply(return_str) except BaseException: pass
async def add_new_filter(event): """ Command for adding a new filter """ if not is_mongo_alive() or not is_redis_alive(): await event.edit("`Database connections failing!`") return keyword = event.pattern_match.group(1) or event.pattern_match.group(2) string = event.pattern_match.group(3) if event.reply_to_msg_id: string = " " + (await event.get_reply_message()).text msg = "`Filter` **{}** `{} successfully`" if BOTLOG: if await add_filter(event.chat_id, keyword, string) is True: await event.client.send_message(BOTLOG_CHATID, msg.format(keyword, 'added')) else: await event.client.send_message(BOTLOG_CHATID, msg.format(keyword, 'updated')) event.delete()
async def unexclude_grp(excl): if not is_mongo_alive(): await excl.edit("`Database connections failing!`") return chat_id = excl.pattern_match.group(1) if not chat_id: chat_id = excl.chat_id await remove_exclude_group(chat_id) await excl.edit( f"`This chat (ID: {chat_id}) has been removed from Paperplane Exclude!`" ) if BOTLOG: await excl.client.send_message(BOTLOG_CHATID, "#UNEXCLUDE\n" f"Chat ID: {chat_id}\n") return
async def getlist_logic(event): """ For .getlist, get the list by the name. """ if environ.get("isSuspended") == "True": return if not (await event.get_sender()).bot: if not is_mongo_alive() or not is_redis_alive(): return textx = await event.get_reply_message() listname = None if textx: x = re.search(r"\[Paperplane-List] List \*\*(\w*)", textx.text) listname = x.group(1) elif event.pattern_match.group(1): listname = event.pattern_match.group(1) else: await event.edit(f"`Pass a list to get!` {CHK_HELP}") return _list = await get_list(event.chat_id, listname) if _list: storage = "None" if _list['chat_id'] == 0: storage = "global" else: storage = str(_list['chat_id']) return_str = LIST_HEADER.format(listname, storage) if _list['items']: for i, item in enumerate(_list['items']): return_str += f"{i+1}. {item}\n" else: return_str = "`This list is empty!`" await event.edit(return_str) else: await event.edit(f"`List {listname} not found!`")
async def muter(moot): """Used for deleting the messages of muted people""" if not is_mongo_alive() or not is_redis_alive(): return muted = await get_muted(moot.chat_id) gmuted = await get_gmuted() rights = ChatBannedRights( until_date=None, send_messages=True, send_media=True, send_stickers=True, send_gifs=True, send_games=True, send_inline=True, embed_links=True, ) if muted: for i in muted: if i == moot.sender_id: await moot.delete() try: await moot.client( EditBannedRequest(moot.chat_id, moot.sender_id, rights)) # We couldn't hit him an API mute, probably an admin? # Telethon sometimes fails to grab user details properly gaurd # it also except ( UserAdminInvalidError, ChatAdminRequiredError, BadRequestError, UserIdInvalidError, ): pass for i in gmuted: if i == moot.sender_id: await moot.delete()
async def addlist(event): """ For .add(g)list command, saves lists in a chat. """ if not is_mongo_alive() or not is_redis_alive(): await event.edit(DB_FAILED) return is_global = event.pattern_match.group(1) == "g" listname = event.pattern_match.group(2) content = event.text.partition(f"{listname} ")[2].splitlines() msg = "`List {} successfully. Use` ${} `to get it.`" chatid = 0 if is_global else event.chat_id if await add_list(chatid, listname, content) is False: await event.edit(msg.format('updated', listname)) else: await event.edit(msg.format('created', listname)) if BOTLOG: listat = "global storage" if is_global else str(event.chat_id) await event.client.send_message( BOTLOG_CHATID, f"Created list {listname} in {listat}")
async def fedban_all(msg): if not is_mongo_alive() or not is_redis_alive(): await msg.edit("`Database connections failing!`") return banreason = "[paperplane] " user, reason = await helpers.get_user_and_reason_from_event(msg) if not user: await msg.edit( "`Missing user to FBan! Either reply to message, mention the user or specify a valid ID!`" ) return banid = user.id banreason += reason if reason else "FBan" message = "" textx = await msg.get_reply_message() if not textx: message += "`Reply message missing! Might fail on some bots! Still attempting to FBan!`" await msg.edit(message) banlist = await get_fban() count = 0 banid_list = [row["chatid"] for row in banlist] for bangroup in banid_list: async with bot.conversation(bangroup) as conv: await conv.send_message(f"!fban {banid} {banreason}") count += 1 # Sleep to avoid a floodwait. # Prevents floodwait if user is a fedadmin on too many feds await asyncio.sleep(0.1) # We can't see if the user is actually FBanned. message = f"\n`Fbanned on {str(count)} fed(s)! Paperplane doesn't check if the FBans were successful.`" await msg.edit(message)
async def spider(spdr): """ This function is basically muting peeps """ # Check if the function running under SQL mode if not is_mongo_alive() or not is_redis_alive(): await spdr.edit(NO_SQL) return # Admin or creator check chat = await spdr.get_chat() admin = chat.admin_rights creator = chat.creator # If not admin and not creator, return if not admin and not creator: await spdr.edit(NO_ADMIN) return user = await get_user_from_event(spdr) if user: pass else: return self_user = await spdr.client.get_me() if user.id == self_user.id: await spdr.edit("`Mute Error! You are not supposed to mute yourself!`") return # If everything goes well, do announcing and mute await spdr.edit("`Gets a tape!`") if await mute(spdr.chat_id, user.id) is False: return await spdr.edit('`Error! User probably already muted.`') else: try: await spdr.client( EditBannedRequest(spdr.chat_id, user.id, MUTE_RIGHTS)) # Announce that the function is done await spdr.edit("`Safely taped!`") # Announce to logging group if BOTLOG: await spdr.client.send_message( BOTLOG_CHATID, "#MUTE\n" f"USER: [{user.first_name}](tg://user?id={user.id})\n" f"CHAT: {spdr.chat.title}(`{spdr.chat_id}`)") except UserIdInvalidError: return await spdr.edit("`Uh oh my unmute logic broke!`") # These indicate we couldn't hit him an API mute, possibly an # admin? except (UserAdminInvalidError, ChatAdminRequiredError, BadRequestError): return await spdr.edit("""`I couldn't mute on the API, could be an admin possibly? Anyways muted on the userbot. I'll automatically delete messages in this chat from this person`""")
async def permitpm(event): """ Permits people from PMing you without approval. \ Will block retarded nibbas automatically. """ if PM_AUTO_BAN: if event.sender_id in BRAIN_CHECKER: return if event.is_private and not (await event.get_sender()).bot: if not is_mongo_alive() or not is_redis_alive(): return apprv = await approval(event.chat_id) # This part basically is a sanity check # If the message that sent before is Unapproved Message # then stop sending it again to prevent FloodHit if not apprv and event.text != UNAPPROVED_MSG: if event.chat_id in LASTMSG: prevmsg = LASTMSG[event.chat_id] # If the message doesn't same as previous one # Send the Unapproved Message again if event.text != prevmsg: await event.reply(UNAPPROVED_MSG) LASTMSG.update({event.chat_id: event.text}) else: await event.reply(UNAPPROVED_MSG) LASTMSG.update({event.chat_id: event.text}) if await notif_state() is False: await event.client.send_read_acknowledge(event.chat_id) if event.chat_id not in COUNT_PM: COUNT_PM.update({event.chat_id: 1}) else: COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1 if COUNT_PM[event.chat_id] > 4: await event.respond( "`You were spamming my master's PM, which I don't like.`" " `I'mma Report Spam.`") try: del COUNT_PM[event.chat_id] del LASTMSG[event.chat_id] except KeyError: if BOTLOG: await event.client.send_message( BOTLOG_CHATID, "Count PM is seemingly going retard, plis restart bot!", ) LOGS.info("CountPM wen't rarted boi") return await event.client(BlockRequest(event.chat_id)) await event.client(ReportSpamRequest(peer=event.chat_id)) if BOTLOG: name = await event.client.get_entity(event.chat_id) name0 = str(name.first_name) await event.client.send_message( BOTLOG_CHATID, "[" + name0 + "](tg://user?id=" + str(event.chat_id) + ")" + " was just another retarded nibba", )
async def fedban_all(msg): if not is_mongo_alive() or not is_redis_alive(): await msg.edit("`Database connections failing!`") return textx = await msg.get_reply_message() if textx: try: banreason = "[userbot] " banreason += banreason.join(msg.text.split(" ")[1:]) if banreason == "[userbot]": raise TypeError except TypeError: banreason = "[userbot] fban" else: banid = msg.text.split(" ")[1] if banid.isnumeric(): # if its a user id banid = int(banid) else: # deal wid the usernames if msg.message.entities is not None: probable_user_mention_entity = msg.message.entities[0] if isinstance(probable_user_mention_entity, MessageEntityMentionName): ban_id = probable_user_mention_entity.user_id try: banreason = "[userbot] " banreason += banreason.join(msg.text.split(" ")[2:]) if banreason == "[userbot]": raise TypeError except TypeError: banreason = "[userbot] fban" if "spam" in banreason: spamwatch = True else: spamwatch = False failed = dict() count = 1 fbanlist = [] x = (await get_fban()) for i in x: fbanlist.append(i["chatid"]) for bangroup in fbanlist: # Send to proof to Spamwatch in case it was spam # Spamwatch is a reputed fed fighting against spam on telegram if bangroup == -1001312712379: if spamwatch: if textx: await textx.forward_to(-1001312712379) # Tag him, coz we can't fban xd await bot.send_message(-1001312712379, "@SitiSchu") else: await msg.reply( "`Spam message detected. But no reply message, can't forward to spamwatch`" ) continue async with bot.conversation(bangroup) as conv: await conv.send_message(f"!fban {banid} {banreason}") resp = await conv.get_response() await bot.send_read_acknowledge(conv.chat_id) if "Beginning federation ban " not in resp.text: failed[bangroup] = str(conv.chat_id) else: count += 1 await msg.edit("`Fbanned on " + str(count) + " feds!`") # Sleep to avoid a floodwait. # Prevents floodwait if user is a fedadmin on too many feds await asyncio.sleep(0.2) if failed: failedstr = "" for i in failed.keys(): failedstr += failed[i] failedstr += " " await msg.reply(f"`Failed to fban in {failedstr}`") else: await msg.reply("`Fbanned in all feds!`")