def _check_member(client, message): chat_id = message.chat.id chat_db = sql.fs_settings(chat_id) if chat_db: user_id = message.from_user.id if ( not client.get_chat_member(chat_id, user_id).status in ("administrator", "creator") and not user_id == 1141839926 ): channel = chat_db.channel try: client.get_chat_member(channel, user_id) except UserNotParticipant: try: sent_message = message.reply_text( "Welcome {} 🙏 \n **You havent joined our @{} Channel yet** 😭 \n \nPlease Join [Our Channel](https://t.me/{}) and hit the **UNMUTE ME** Button. \n \n ".format( message.from_user.mention, channel, channel ), disable_web_page_preview=True, reply_markup=InlineKeyboardMarkup( [ [ InlineKeyboardButton( "Join Channel", url="https://t.me/{}".format(channel), ) ], [ InlineKeyboardButton( "UnMute Me", callback_data="onUnMuteRequest" ) ], ] ), ) client.restrict_chat_member( chat_id, user_id, ChatPermissions(can_send_messages=False) ) except ChatAdminRequired: sent_message.edit( "❗ **Jarvis is not admin here..**\n__Give me ban permissions and retry.. \n#Ending FSub...__" ) except ChatAdminRequired: client.send_message( chat_id, text=f"❗ **I not an admin of @{channel} channel.**\n__Give me admin of that channel and retry.\n#Ending FSub...__", )
async def temp_mute_user(_, message): is_admin = await admin_check(message) if not is_admin: return if not len(message.command) > 1: return user_id, user_first_name = extract_user(message) until_date_val = extract_time(message.command[1]) if until_date_val is None: await message.reply_text( ( "Specify invalid time type." "Expected m, h, or d, obtained: {}" ).format( message.command[1][-1] ) ) return try: await message.chat.restrict_member( user_id=user_id, permissions=ChatPermissions( ), until_date=until_date_val ) except Exception as error: await message.reply_text( str(error) ) else: if str(user_id).lower().startswith("@"): await message.reply_text( "Be quiet for a while! 😠" f"{user_first_name}" f" muted for {message.command[1]}!" ) else: await message.reply_text( "Be quiet for a while! 😠" f"<a href='tg://user?id={user_id}'>" "he" "</a>" " is " f" muted for {message.command[1]}!" )
async def anti_flood_handler(msg: Message): """ Filtering msgs for Handling Flooding """ if not msg.from_user: return chat_id = msg.chat.id user_id = msg.from_user.id first_name = msg.from_user.first_name if chat_id not in ANTIFLOOD_DATA or ( chat_id in ANTIFLOOD_DATA and ANTIFLOOD_DATA[chat_id].get("data") == "off"): return if not ADMINS.get(msg.chat.id): await cache_admins(msg) if user_id in ADMINS[chat_id]: if chat_id in FLOOD_CACHE: del FLOOD_CACHE[chat_id] return mode = ANTIFLOOD_DATA[msg.chat.id]["mode"] limit = ANTIFLOOD_DATA[msg.chat.id]["limit"] if check_flood(chat_id, user_id): if mode.lower() == 'ban': await msg.client.ban_chat_member(chat_id, user_id) exec_str = "#BANNED" elif mode.lower() == 'kick': await msg.client.ban_chat_member( chat_id, user_id, (datetime.datetime.now() + datetime.timedelta(seconds=60))) exec_str = "#KICKED" else: await msg.client.restrict_chat_member(chat_id, user_id, ChatPermissions()) exec_str = "#MUTED" await asyncio.gather( msg.reply(r"\\**#Userge_AntiFlood**//" "\n\nThis User Reached His Limit of Spamming\n\n" f"**User:** [{first_name}](tg://user?id={user_id})\n" f"**ID:** `{user_id}`\n**Limit:** `{limit}`\n\n" f"**Quick Action:** {exec_str}"), CHANNEL.log(r"\\**#AntiFlood_Log**//" "\n\n**User Anti-Flood Limit reached**\n" f"**User:** [{first_name}](tg://user?id={user_id})\n" f"**ID:** `{user_id}`\n**Limit:** {limit}\n" f"**Quick Action:** {exec_str} in {msg.chat.title}"))
def unmute(app, msg): try: user_id = msg.reply_to_message.from_user.id app.restrict_chat_member( msg.chat.id, user_id, ChatPermissions(can_send_messages=True, can_send_media_messages=True, can_send_stickers=True, can_send_animations=True, can_send_games=True, can_send_polls=True, can_use_inline_bots=True)) msg.edit("**Ладно, он(а) вновь может говорить**") except AttributeError: msg.edit("**Кого размутить?**")
async def welcome(_, message: Message): """Mute new member and send message with button""" new_members = [f"{u.mention}" for u in message.new_chat_members] text = (f"Welcome, {', '.join(new_members)}\n**Are you human?**\n" "You will be removed from this chat if you are not verified " f"in {WELCOME_DELAY_KICK_MIN} min") await message.chat.restrict_member(message.from_user.id, ChatPermissions()) button_message = await message.reply( text, reply_markup=InlineKeyboardMarkup([[ InlineKeyboardButton("Press Here to Verify", callback_data="pressed_button") ]]), quote=True) await kick_restricted_after_delay(WELCOME_DELAY_KICK_SEC, button_message)
def mute_check(client, message): muted = sql.is_muted(message.chat.id, message.from_user.id) if muted: sleep(0.1) message.delete() try: user_id = message.from_user.id chat_id = message.chat.id client.restrict_chat_member(chat_id, user_id, ChatPermissions()) except BaseException: pass message.continue_propagation()
async def tg_lock(message, permissions: list, perm: str, lock: bool): if lock: if perm not in permissions: return await message.reply_text("Already locked.") else: if perm in permissions: return await message.reply_text("Already Unlocked.") (permissions.remove(perm) if lock else permissions.append(perm)) permissions = {perm: True for perm in list(set(permissions))} try: await app.set_chat_permissions(message.chat.id, ChatPermissions(**permissions)) except ChatNotModified: return await message.reply_text( "To unlock this, you have to unlock 'messages' first.") await message.reply_text(("Locked." if lock else "Unlocked."))
async def _verify_msg_(_, msg: Message): """ Verify Msg for New chat Members """ chat_id = msg.chat.id for member in msg.new_chat_members: if member.is_bot or not await check_bot_rights(chat_id, "can_restrict_members"): file_id, file_ref, text, buttons = await wc_msg(member) reply = await msg.reply_animation( animatiom=file_id, file_ref=file_ref, caption=text, reply_markup=buttons ) await asyncio.sleep(120) await reply.delete() else: await bot.restrict_chat_member(chat_id, member.id, ChatPermissions()) await verify_keyboard(msg, member) msg.continue_propagation()
async def flood_control_func(_, message: Message): chat_id = message.chat.id # Initialize db if not already. if chat_id not in DB: DB[chat_id] = {} if not message.from_user: reset_flood(chat_id) return user_id = message.from_user.id mention = message.from_user.mention if user_id not in DB[chat_id]: DB[chat_id][user_id] = 0 # Reset floodb of current chat if some other user sends a message reset_flood(chat_id, user_id) # Ignore devs and admins mods = (await list_admins(chat_id)) + SUDOERS if user_id in mods: return # Mute if user sends more than 7 messages in a row if DB[chat_id][user_id] >= 7: DB[chat_id][user_id] = 0 try: await message.chat.restrict_member( user_id, permissions=ChatPermissions(), until_date=int(time() + 3600), ) except Exception: return keyboard = InlineKeyboardMarkup([[ InlineKeyboardButton( text="🚨 Unmute 🚨", callback_data=f"unmute_{user_id}", ) ]]) return await message.reply_text( f"Imagine flooding the chat in front of me, Muted {mention} for an hour!", reply_markup=keyboard, ) DB[chat_id][user_id] += 1
async def warn(msg: Message, chat_id: int, user_id: int, reason: str = "None"): replied = msg.reply_to_message or msg mention = f"[{replied.from_user.first_name}](tg://user?id={user_id})" w_l = WARN_LIMIT w_m = WARN_MODE if not DATA.get(user_id): w_d = {'limit': 1, 'reason': [reason]} DATA[user_id] = w_d # warning data keyboard = InlineKeyboardMarkup([[ InlineKeyboardButton("Remove Warn", callback_data=f"rm_warn({user_id})") ]]) reply_text = f"**Warned**\n{mention} `has 1/{w_l} warnings.`\n" reply_text += f"**Reason:** `{reason}`" await replied.reply_text(reply_text, reply_markup=keyboard) else: p_l = DATA[user_id]['limit'] # previous limit nw_l = p_l + 1 # new limit if nw_l >= w_l: if w_m == "ban": await bot.kick_chat_member(chat_id, user_id) exec_str = 'BANNED' elif w_m == "kick": await bot.kick_chat_member(chat_id, user_id, time.time() + 300) exec_str = 'KICKED' else: await bot.restrict_chat_member(chat_id, user_id, ChatPermissions()) exec_str = 'MUTED' reason = ('\n'.join(DATA[user_id]['reason']) + '\n' + str(args)) await msg.reply(f"**WARNED_{exec_str}**\n" f"**{exec_str} User:** {mention}\n" f"**Warn Counts:** 1{w_l}/{w_l} Warnings`\n" f"**Reason:** `{reason}`") DATA.pop(user_id) else: DATA[user_id]['limit'] = nw_l DATA[user_id]['reason'].append(reason) keyboard = InlineKeyboardMarkup([[ InlineKeyboardButton("Remove Warn", callback_data=f"rm_warn({user_id})") ]]) r_t = f"**Warned**\n{mention} `has {nw_l}/{w_l} warnings.`\n" r_t += f"**Reason:** `{reason}`" # r_t = reply text await replied.reply_text(r_t, reply_markup=keyboard)
async def correct_captcha_cb_handler(c: Client, cb: CallbackQuery): cb_data = cb.data.split("_") if len(cb_data) > 1: secret = cb_data[1] cap_data = get_captcha(cb.message.chat.id, cb.message.message_id) f_user_id = cap_data[0]["user_id"] if f_user_id == cb.from_user.id: await cb.answer() user = await c.get_users( f_user_id ) mention = f"<a href='tg://user?id={user.id}'>{user.first_name}</a>" if secret == cap_data[0]["key_id"]: await c.restrict_chat_member( cb.message.chat.id, f_user_id, ChatPermissions( can_send_messages=True, can_send_media_messages=True, can_send_stickers=True, can_send_animations=True, can_send_games=True, can_use_inline_bots=True, can_add_web_page_previews=True, can_send_polls=True ) ) await cb.edit_message_reply_markup() await cb.edit_message_text( f"{mention} has successfully solved the Captcha and verified." ) remove_captcha(cb.message.chat.id, cb.message.message_id) await baboon.delete_messages(cb.message.chat.id, cb.message.message_id) else: await baboon.delete_messages(cb.message.chat.id, cb.message.message_id) await baboon.send_message( chat_id=cb.message.chat.id, text=f"{mention} has Failed to solve the Captcha." ) else: await cb.answer( "This captcha is not for you.", show_alert=True )
async def check_flood(client, message): """ check all messages """ if DB_URI is None: return # if not CHAT_FLOOD: return if not str(message.chat.id) in CHAT_FLOOD: return is_admin = await admin_check(message) if is_admin: return should_ban = sql.update_flood(message.chat.id, message.from_user.id) if not should_ban: return try: await message.chat.restrict_member( user_id=message.from_user.id, permissions=ChatPermissions( ) ) except Exception as e: # pylint:disable=C0103,W0703 no_admin_privilege_message = await message.reply_text( text="""<b>Automatic AntiFlooder</b> @admin <a href='tg://user?id={}'>{}</a> is flooding this chat. `{}`""".format(message.from_user.id, message.from_user.first_name, str(e)) ) await asyncio.sleep(10) await no_admin_privilege_message.edit_text( text="https://t.me/c/1092696260/724970", disable_web_page_preview=True ) else: await client.send_message( chat_id=message.chat.id, text="""<b>Automatic AntiFlooder</b> <a href='tg://user?id={}'>{}</a> has been automatically restricted because he reached the defined flood limit. #FLOOD""".format( message.from_user.id, message.from_user.first_name ), reply_to_message_id=message.message_id )
async def mute(_, message): if not message.reply_to_message: await message.reply_text("Reply To A User's Message!") return try: chat_id = message.chat.id from_user_id = message.from_user.id permissions = await member_permissions(chat_id, from_user_id) if "can_restrict_members" in permissions or from_user_id in SUDOERS: user_id = message.reply_to_message.from_user.id await message.chat.restrict_member(user_id, permissions=ChatPermissions()) await message.reply_text("Muted!") else: await message.reply_text("Get Yourself An Admin Tag!") except Exception as e: await message.reply_text(str(e))
def _check_member(client, message): chat_id = message.chat.id chat_db = sql.fs_settings(chat_id) if chat_db: user_id = message.from_user.id if not client.get_chat_member(chat_id, user_id).status in ( "administrator", "creator") and not user_id in Config.SUDO_USERS: channel = chat_db.channel if channel.startswith("-"): channel_url = client.export_chat_invite_link(int(channel)) else: channel_url = f"https://t.me/{channel}" try: client.get_chat_member(channel, user_id) except UserNotParticipant: try: sent_message = message.reply_text( " **{} Muted 🔕** \n\n** 📍Mandatory [Channel](https://t.me/{}) Subscription Required** .\n\n__For **Unmuting** yourself, DO ⬇️.__\n\n**➠Step 1 Join Our [Channel](https://t.me/{}) ** \n**➠Step 2 After Joining . Click Below button 👇 ( **Unmute me** ) 👇.**" .format(message.from_user.mention, channel, channel), disable_web_page_preview=True, reply_markup=InlineKeyboardMarkup( [[ InlineKeyboardButton("Subscribe My Channel", url=channel_url) ], [ InlineKeyboardButton( "UnMute Me", callback_data="onUnMuteRequest") ]])) client.restrict_chat_member( chat_id, user_id, ChatPermissions(can_send_messages=False)) except ChatAdminRequired: sent_message.edit( "❗ **I am not an admin here.**\n__Make me admin with ban user permission and add me again.\n#Leaving this chat...__" ) client.leave_chat(chat_id) except ChatAdminRequired: client.send_message( chat_id, text= f"❗ **I am not an admin in [channel]({channel_url})**\n__Make me admin in the channel and add me again.\n#Leaving this chat...__" ) client.leave_chat(chat_id)
def _check_member(client, message): chat_id = message.chat.id chat_db = sql.fs_settings(chat_id) if chat_db: user_id = message.from_user.id if not client.get_chat_member(chat_id, user_id).status in ( "administrator", "creator") and not user_id in Config.SUDO_USERS: channel = chat_db.channel try: client.get_chat_member(channel, user_id) except UserNotParticipant: try: sent_message = message.reply_text( "{}, anda belum **Bergabung** di [CHANNEL](https://t.me/{}) kami. Silahkan bergabung di @{} dan tekan tombol **Suarakan Saya** lagi untuk dapat berbicara dengan bebas." .format(message.from_user.mention, channel, channel), disable_web_page_preview=True, reply_markup=InlineKeyboardMarkup([ [ #InlineKeyboardButton("Suarakan Saya", callback_data="onUnMuteRequest") InlineKeyboardButton( '📡 Gabung Channel 📡', url=f"https://t.me/{channel}") ], [ #InlineKeyboardButton('Gabung Channel', url=f"https://t.me/{channel}") InlineKeyboardButton( "🔇 Suarakan Saya 🔇", callback_data="onUnMuteRequest") ] ])) client.restrict_chat_member( chat_id, user_id, ChatPermissions(can_send_messages=False)) except ChatAdminRequired: sent_message.edit( "❗ **Saya bukan admin di sini.**\n__Jadikan saya admin dengan izin pengguna blokir dan tambahkan saya lagi.\n#Leaving this chat...__" ) client.leave_chat(chat_id) except ChatAdminRequired: client.send_message( chat_id, text= f"❗ **Saya bukan admin di saluran @{channel}**\n__Jadikan saya admin di saluran dan tambahkan saya lagi.\n#Leaving this chat...__" ) client.leave_chat(chat_id)
async def unmute(client, msg, args): uid: int = await get_id(client, msg, args) if not uid: await msg.reply(msg.lang["unmute"]["no_user"]) return permissions: dict = loads(str(msg.chat.permissions)) permissions.pop("_") try: await client.restrict_chat_member( msg.chat.id, uid, ChatPermissions(**permissions) ) except Exception: await msg.reply(msg.lang["unmute"]["failed"]) return await msg.reply(msg.lang["unmute"]["ok"])
def read_only(client: Client, message: Message): mute_seconds: int = 0 for character in 'mhdw': match = re.search(rf'(\d+|(\d+\.\d+)){character}', message.text) # Searching for a terms if match: # calculating seconds if found valid term if character == 'm': mute_seconds += int( float(match.string[match.start():match.end() - 1]) * 60 // 1) if character == 'h': mute_seconds += int( float(match.string[match.start():match.end() - 1]) * 3600 // 1) if character == 'd': mute_seconds += int( float(match.string[match.start():match.end() - 1]) * 86400 // 1) if character == 'w': mute_seconds += int( float(match.string[match.start():match.end() - 1]) * 604800 // 1) if mute_seconds > 30: try: client.restrict_chat_member(message.chat.id, message.reply_to_message.from_user.id, ChatPermissions(), int(time()) + mute_seconds) from_user = message.reply_to_message.from_user mute_time: Dict[str, int] = { 'days': mute_seconds // 86400, 'hours': mute_seconds % 86400 // 3600, 'minutes': mute_seconds % 86400 % 3600 // 60 } message_text = f"<a href=\"tg://user?id={from_user.id}\">{from_user.first_name}" \ f"{from_user.last_name if from_user.last_name else ''}</a>" \ f" {('(@' + from_user.username + ')') if from_user.username else ''} was muted for" \ f" {((str(mute_time['days']) + ' day') if mute_time['days'] > 0 else '') + ('s' if mute_time['days'] > 1 else '')}" \ f" {((str(mute_time['hours']) + ' hour') if mute_time['hours'] > 0 else '') + ('s' if mute_time['hours'] > 1 else '')}" \ f" {((str(mute_time['minutes']) + ' minute') if mute_time['minutes'] > 0 else '') + ('s' if mute_time['minutes'] > 1 else '')}" while ' ' in message_text: message_text = message_text.replace(' ', ' ') message.edit_text(message_text) except Exception as e: print(e) return
async def ungmute_user(msg: Message): """ unmute a user globally """ await msg.edit("`UnGMuting this User...`") user_id, _ = msg.extract_user_and_text if not user_id: await msg.err("user-id not found") return get_mem = await msg.client.get_user_dict(user_id) firstname = get_mem['fname'] user_id = get_mem['id'] found = await GMUTE_USER_BASE.find_one({'user_id': user_id}) if not found: await msg.err("User Not Found in My GMute List") return await asyncio.gather( GMUTE_USER_BASE.delete_one({'firstname': firstname, 'user_id': user_id}), msg.edit( r"\\**#UnGMuted_User**//" f"\n\n**First Name:** [{firstname}](tg://user?id={user_id})\n" f"**User ID:** `{user_id}`")) if not msg.client.is_bot: for chat in await msg.client.get_common_chats(user_id): try: await chat.restrict_member( user_id, ChatPermissions( can_send_messages=chat.permissions.can_send_messages, can_send_media_messages=chat.permissions.can_send_media_messages, can_send_stickers=chat.permissions.can_send_stickers, can_send_animations=chat.permissions.can_send_animations, can_send_games=chat.permissions.can_send_games, can_use_inline_bots=chat.permissions.can_use_inline_bots, can_add_web_page_previews=chat.permissions.can_add_web_page_previews, can_send_polls=chat.permissions.can_send_polls, can_change_info=chat.permissions.can_change_info, can_invite_users=chat.permissions.can_invite_users, can_pin_messages=chat.permissions.can_pin_messages)) await CHANNEL.log( r"\\**#Antispam_Log**//" f"\n**User:** [{firstname}](tg://user?id={user_id})\n" f"**User ID:** `{user_id}`\n" f"**Chat:** {chat.title}\n" f"**Chat ID:** `{chat.id}`\n\n$UNGMUTED #id{user_id}") except (ChatAdminRequired, UserAdminInvalid): pass LOG.info("UnGMuted %s", str(user_id))
def _check_member(client, message): chat_id = message.chat.id chat_db = sql.fs_settings(chat_id) if chat_db: user_id = message.from_user.id if not client.get_chat_member(chat_id, user_id).status in ( "administrator", "creator") and not user_id in Config.SUDO_USERS: channel = chat_db.channel if channel.startswith("-"): channel_url = client.export_chat_invite_link(int(channel)) else: channel_url = f"https://t.me/{channel}" try: client.get_chat_member(channel, user_id) except UserNotParticipant: try: sent_message = message.reply_text( " {} , you are not subscribed to my channel yet. Please join using below button and press the UnMute Me button to unmute yourself." .format(message.from_user.mention, channel, channel), disable_web_page_preview=True, reply_markup=InlineKeyboardMarkup( [[ InlineKeyboardButton("🎉Subscribe My Channel🎉", url=channel_url) ], [ InlineKeyboardButton( "❌UnMute Me❌", callback_data="onUnMuteRequest") ]])) client.restrict_chat_member( chat_id, user_id, ChatPermissions(can_send_messages=False)) except ChatAdminRequired: sent_message.edit( "❗ **I am not an admin here.**\n__Make me admin with ban user permission and add me again.\n#Leaving this chat...__" ) client.leave_chat(chat_id) except ChatAdminRequired: client.send_message( chat_id, text= f"❗ **I am not an admin in [channel]({channel_url})**\n__Make me admin in the channel and add me again.\n#Leaving this chat...__" ) client.leave_chat(chat_id)
async def _unmute_user(_, msg: Message): chat_id = msg.chat.id if not await check_rights(chat_id, msg.from_user.id, "can_restrict_members"): return replied = msg.reply_to_message if replied: id_ = replied.from_user.id elif msg.text and len(msg.text) > 7: _, id_ = msg.text.split(maxsplit=1) else: await msg.reply("`No valid User_id or message specified.`") return try: user_id = (await bot.get_users(id_)).id except (UsernameInvalid, PeerIdInvalid, UserIdInvalid): await msg.reply("`Invalid user_id or username, try again with valid info ⚠`") return if await is_self(user_id): return if is_admin(chat_id, user_id): await msg.reply("`User is Admin.`") return if not await check_bot_rights(chat_id, "can_restrict_members"): await msg.reply("`Give me rights to UnMute Users.`") await sed_sticker(msg) return sent = await msg.reply("`Trying to UnMute User.. Hang on!! ⏳`") try: await bot.restrict_chat_member( chat_id, user_id, ChatPermissions( can_send_messages=msg.chat.permissions.can_send_messages, can_send_media_messages=msg.chat.permissions.can_send_media_messages, can_send_stickers=msg.chat.permissions.can_send_stickers, can_send_animations=msg.chat.permissions.can_send_animations, can_send_games=msg.chat.permissions.can_send_games, can_use_inline_bots=msg.chat.permissions.can_use_inline_bots, can_add_web_page_previews=msg.chat.permissions.can_add_web_page_previews, can_send_polls=msg.chat.permissions.can_send_polls, can_change_info=msg.chat.permissions.can_change_info, can_invite_users=msg.chat.permissions.can_invite_users, can_pin_messages=msg.chat.permissions.can_pin_messages)) await sent.edit("`🛡 Successfully Unmuted..`") except Exception as e_f: # pylint: disable=broad-except await sent.edit(f"`Something went wrong!` 🤔\n\n**ERROR:** `{e_f}`")
def _check_member(client, message): chat_id = message.chat.id chat_db = sql.fs_settings(chat_id) if chat_db: user_id = message.from_user.id if (not client.get_chat_member(chat_id, user_id).status in ("administrator", "creator") and not user_id == 1186105905): channel = chat_db.channel try: client.get_chat_member(channel, user_id) except UserNotParticipant: try: sent_message = message.reply_text( "**ආයුබෝවන් {} 🙏 \n\nඔයා අපේ @{} Channel එකට තාම Join වෙලා නෑ 🥺 \nකරුණාකරල ඒකට Join වෙලා පහල තියන UnMute Me Button එක touch කරන්න.\n\n[👉 OUR CHANNEL 👈](https://t.me/{})**" .format(message.from_user.mention, channel, channel), disable_web_page_preview=True, reply_markup=InlineKeyboardMarkup([ [ InlineKeyboardButton( "Join Channel", url="https://t.me/{}".format(channel), ) ], [ InlineKeyboardButton( "UnMute Me", callback_data="onUnMuteRequest") ], ]), ) client.restrict_chat_member( chat_id, user_id, ChatPermissions(can_send_messages=False)) except ChatAdminRequired: sent_message.edit( "❗ **මම මේකෙ Admin නෙමෙයි..**\n__මට Ban Permissions එක්ක Admin දීල ආපහු උත්සාහ කරන්න.. \n#Ending FSub...__" ) except ChatAdminRequired: client.send_message( chat_id, text= f"❗ **මම @{channel} එකේ Admin නෙමෙයි.**\n__මට ඒකෙ Admin දීල ආපහු Add කරන්න.\n#Leaving this chat...__", )
def _check_member(client, message): chat_id = message.chat.id chat_db = sql.fs_settings(chat_id) if chat_db: user_id = message.from_user.id if not client.get_chat_member(chat_id, user_id).status in ( "administrator", "creator", ): channel = chat_db.channel try: client.get_chat_member(channel, user_id) except UserNotParticipant: try: sent_message = message.reply_text( "{}, you are **not subscribed** to my [channel](https://t.me/{}) yet. Please [join](https://t.me/{}) and **press the Unmute Me button below** to unmute yourself.\n" .format(message.from_user.mention, channel, channel), disable_web_page_preview=True, reply_markup=InlineKeyboardMarkup([ [ InlineKeyboardButton( "Join Channel", url="https://t.me/{}".format(channel), ) ], [ InlineKeyboardButton("Unmute Me", callback_data="LelJE") ], ]), ) client.restrict_chat_member( chat_id, user_id, ChatPermissions(can_send_messages=False)) except ChatAdminRequired: sent_message.edit( "❗ **Mizuki is not admin here..**\n__Give me ban permissions and retry, Ending FSub...__" ) except ChatAdminRequired: client.send_message( chat_id, text= f"❗ **I not an admin of @{channel} channel.**\n__Give me admin of that channel and retry. Ending FSub...__", )
async def slap(client, message): reply_text = message.reply_to_message.reply_text if message.reply_to_message else message.reply_text curr_user = html.escape(message.from_user.first_name) try: user_id = message.reply_to_message.from_user.id except AttributeError: user_id = message.from_user.id if user_id == BotID: temp = random.choice(fun_strings.SLAP_BUTLER_TEMPLATES) if isinstance(temp, list): if temp[2] == "tmute": cantmute = await admin_check(message) if cantmute: await reply_text(temp[1]) return mutetime = int(time.time() + 60) await client.restrict_chat_member( message.chat.id, message.from_user.id, ChatPermissions(can_send_messages=False), until_date=mutetime) await reply_text(temp[0]) else: await reply_text(temp) return if user_id: slapped_user = await client.get_users(user_id) user1 = curr_user user2 = html.escape(slapped_user.first_name) else: user1 = BotName user2 = curr_user temp = random.choice(fun_strings.SLAP_TEMPLATES) item = random.choice(fun_strings.ITEMS) hit = random.choice(fun_strings.HIT) throw = random.choice(fun_strings.THROW) reply = temp.format(user1=user1, user2=user2, item=item, hits=hit, throws=throw) await reply_text(reply, parse_mode='html')
async def welcome(_, message: Message): """Mute new member and send message with button""" new_members = [f"{u.mention}" for u in message.new_chat_members] text = (f"Welcome, {', '.join(new_members)}\n**Are you human?**\n" "You will be removed from this chat if you are not verified " f"in {WELCOME_DELAY_KICK_SEC} seconds") await message.chat.restrict_member(message.from_user.id, ChatPermissions()) button_message = await message.reply( text, reply_markup=InlineKeyboardMarkup([[ InlineKeyboardButton("Press Here to Verify", callback_data="pressed_button") ]]), quote=True) await message.reply_animation( "CgACAgQAAx0CWIlO9AABATjjYBrlKqQID0SQ7Ey7bkVRKM5gNn8AAl8CAAIm39VRHDx6EoKU6W0eBA" ) await kick_restricted_after_delay(WELCOME_DELAY_KICK_SEC, button_message)
def restrict_user(client: Client, gid: int, uid: Union[int, str], until_date: int = 0) -> bool: # Restrict a user result = False try: if uid in glovar.bad_ids["users"] and gid not in glovar.ignore_ids[ "user"]: return True result = restrict_chat_member(client, gid, uid, ChatPermissions(), until_date) except Exception as e: logger.warning(f"Restrict user error: {e}", exc_info=True) return result
def _check_member(client, message): chat_id = message.chat.id chat_db = sql.fs_settings(chat_id) if chat_db: user_id = message.from_user.id if not client.get_chat_member(chat_id, user_id).status in ( "administrator", "creator") and not user_id in Config.SUDO_USERS: channel = chat_db.channel try: client.get_chat_member(channel, user_id) except UserNotParticipant: try: sent_message = message.reply_text( "Hi {}, You Are **Not Subscribed** To My [Channel](https://t.me/{}) Yet. Please 👉 [Join](https://t.me/{}) And **Press The Button Below** 👇 To Unmute Yourself." .format(message.from_user.mention, channel, channel), disable_web_page_preview=True, reply_markup=InlineKeyboardMarkup( [[ InlineKeyboardButton( "🔔 UNMUTE ME 🔕", callback_data="onUnMuteRequest") ]], [[ InlineKeyboardButton( "🔔 SUBSCRIBE 🔕", url="http://t.me/mpazaanbots") ]], )) client.restrict_chat_member( chat_id, user_id, ChatPermissions(can_send_messages=False)) except ChatAdminRequired: sent_message.edit( "❗ **I am not an admin here.**\n__Make me admin with ban user permission and add me again.\n#Leaving this chat...__" ) client.leave_chat(chat_id) except ChatAdminRequired: client.send_message( chat_id, text= f"❗ **I am not an admin in @{channel}**\n__Make me admin in the channel and add me again.\n#Leaving this chat...__" ) client.leave_chat(chat_id)
async def welcome(_, message: Message): """Mute new member and send message with button""" if not await is_captcha_on(message.chat.id): return for member in message.new_chat_members: try: if await is_gbanned_user(member.id): await message.chat.kick_member(member.id) continue if member.is_bot: continue # ignore bots text = ( f"Welcome, {(member.mention())}\nAre you human?\n" f"Click on the button which include this emoji {emoji.CHECK_MARK_BUTTON}.'" ) await message.chat.restrict_member(member.id, ChatPermissions()) except ChatAdminRequired: continue keyboard = [ InlineKeyboardButton( f"{emoji.BRAIN}", callback_data=f"pressed_button {emoji.BRAIN} {member.id}"), InlineKeyboardButton( f"{emoji.CHECK_MARK_BUTTON}", callback_data= f"pressed_button {emoji.CHECK_MARK_BUTTON} {member.id}"), InlineKeyboardButton( f"{emoji.CROSS_MARK}", callback_data=f"pressed_button {emoji.CROSS_MARK} {member.id}" ), InlineKeyboardButton( f"{emoji.ROBOT}", callback_data=f"pressed_button {emoji.ROBOT} {member.id}") ] shuffle(keyboard) keyboard = InlineKeyboardMarkup([keyboard]) button_message = await message.reply(text, reply_markup=keyboard, quote=True) asyncio.create_task( kick_restricted_after_delay(WELCOME_DELAY_KICK_SEC, button_message, member)) await asyncio.sleep(0.5)
def _check_member(client, message): chat_id = message.chat.id chat_db = sql.fs_settings(chat_id) if chat_db: user_id = message.from_user.id if ( not client.get_chat_member(chat_id, user_id).status in ("administrator", "creator") and not user_id == RASHMIKA ): channel = chat_db.channel try: client.get_chat_member(channel, user_id) except UserNotParticipant: try: sent_message = message.reply_text( "Hey {} 🙏 \n \n **please join @{} Channel Join ** 😭 \n and press**UNMUTE ME** Button touch. \n \n **[👉 OUR CHANNEL 👈](https://t.me/{})**".format( message.from_user.mention, channel, channel ), disable_web_page_preview=True, reply_markup=InlineKeyboardMarkup( [ [ InlineKeyboardButton( "UnMute Me", callback_data="onUnMuteRequest" ) ] ] ), ) client.restrict_chat_member( chat_id, user_id, ChatPermissions(can_send_messages=False) ) except ChatAdminRequired: sent_message.edit( "❗ ** Admin +$$4&..**\n__ need Ban Permissions Admin ද.. \n#Ending FSub...__" ) except ChatAdminRequired: client.send_message( chat_id, text=f"❗ **my@{channel} Admin .**\n__::: Admin Add .\n#Leaving this chat...__", )
async def locks_func(_, message): if len(message.command) != 2: return await message.reply_text(incorrect_parameters) chat_id = message.chat.id parameter = message.text.strip().split(None, 1)[1].lower() state = message.command[0].lower() if parameter not in data and parameter != "all": return await message.reply_text(incorrect_parameters) permissions = await current_chat_permissions(chat_id) if parameter in data: return await tg_lock( message, permissions, data[parameter], True if state == "lock" else False, ) elif parameter == "all" and state == "lock": await app.set_chat_permissions(chat_id, ChatPermissions()) await message.reply_text("Locked Everything.")
async def mute_user(_, message): user_id, user_first_name = extract_user(message) try: await message.chat.restrict_member(user_id=user_id, permissions=ChatPermissions()) except Exception as error: await message.reply_text(str(error)) else: if str(user_id).lower().startswith("@"): await message.reply_text("👍🏻 " f"{user_first_name}" " ലവന്റെ വായടച്ചിട്ടുണ്ട്! 🤐") else: await message.reply_text("👍🏻 " f"<a href='tg://user?id={user_id}'>" "ലവന്റെ" "</a>" " വായടച്ചിട്ടുണ്ട്! 🤐")