async def is_user_admin(user_id: int, chat_id): if user_id in SUDO_USERS: return True try: participant = await tbot(GetParticipantRequest(chat_id, user_id)) return isinstance(participant.participant, (ChannelParticipantAdmin, ChannelParticipantCreator)) except TypeError: async for user in tbot.iter_participants( chat_id, filter=ChannelParticipantsAdmins): if user_id == user.id: return True return False
async def is_admin(catub, chat_id, userid): if not str(chat_id).startswith("-100"): return False try: req_jo = await catub(GetParticipantRequest(chat_id, userid)) chat_participant = req_jo.participant if isinstance(chat_participant, (ChannelParticipantCreator, ChannelParticipantAdmin)): return True except Exception as e: LOGS.info(str(e)) return False else: return False
async def is_admin(client, chat_id, user_id): if not str(chat_id).startswith("-100"): return False try: req_jo = await client( GetParticipantRequest(channel=chat_id, user_id=user_id)) chat_participant = req_jo.participant if isinstance(chat_participant, (ChannelParticipantCreator, ChannelParticipantAdmin)): return True except Exception: return False else: return False
async def leave_fed(event, chat_id, user): peep = await bot(GetParticipantRequest( channel=chat_id, user_id=user, )) if not peep.participant == ChannelParticipantCreator(user_id=user): await event.reply(get_string('feds', 'only_creators', chat_id)) return old = mongodb.fed_groups.delete_one({'chat_id': chat_id}).deleted_count if old < 1: # If chat not was in any federation await event.reply(get_string('feds', 'chat_not_in_fed', chat_id)) return return True
async def on_pm_click(event): hunter = (event.data_match.group(1)).decode("UTF-8") hell = hunter.split("+") if not event.sender_id == int(hell[0]): return await event.answer("This Ain't For You!!", alert=True) try: await bot(GetParticipantRequest(int(hell[1]), int(hell[0]))) except UserNotParticipantError: return await event.answer("You need to join the channel first.", alert=True) await bot.edit_permissions(event.chat_id, int(hell[0]), send_message=True, until_date=None) await event.edit("Yay! You can chat now !!")
async def diesoon(e): match = (e.data_match.group(1)).decode("UTF-8") spli = match.split("_") if not e.sender_id == int(spli[0]): return await e.answer("This Message is Not for You", alert=True) try: await ultroid_bot(GetParticipantRequest(int(spli[1]), int(spli[0]))) except UserNotParticipantError: return await e.answer( "Join that Channel first then click this button.", alert=True) await ultroid_bot.edit_permissions(e.chat_id, int(spli[0]), send_messages=True, until_date=None) await e.edit("User unmuted. Welcome to the group!")
async def diesoon(e): match = (e.data_match.group(1)).decode("UTF-8") spli = match.split("_") if e.sender_id != int(spli[0]): return await e.answer("This Message is Not for You", alert=True) try: await ultroid_bot(GetParticipantRequest(int(spli[1]), int(spli[0]))) except UserNotParticipantError: return await e.answer( "Please Join That Channel !\nThen Click This Button !", alert=True) await ultroid_bot.edit_permissions(e.chat_id, int(spli[0]), send_messages=True, until_date=None) await e.edit("Thanks For Joining ! ")
async def user_is_admin(user_id: int, message): if message.is_private or user_id in SUDO_USERS: return True if message.is_channel: participant = await tbot( GetParticipantRequest(message.chat_id, user_id)) return isinstance(participant.participant, (ChannelParticipantAdmin, ChannelParticipantCreator)) async for user in tbot.iter_participants(message.chat_id, filter=ChannelParticipantsAdmins): if user_id == user.id: return True return False
async def on_update_chan(e): channel_id = utils.get_peer_id(PeerChannel(e.channel_id)) entity = e._entities.get(channel_id) if isinstance(entity, tl.types.ChannelForbidden): return if isinstance(entity, tl.types.Channel) and entity.left: return channel = await borg.get_input_entity(channel_id) self_participant = await borg( GetParticipantRequest(channel, InputUserSelf())) if not isinstance( self_participant, (tl.types.ChannelParticipantSelf, tl.types.ChannelParticipantAdmin)): return inviter_id = self_participant.participant.inviter_id await on_added(inviter_id, channel_id)
async def leave_fed_comm(message, strings, **kwargs): chat_id = message.chat.id user = message.from_user.id peep = await tbot(GetParticipantRequest( channel=chat_id, user_id=user, )) if not peep.participant == ChannelParticipantCreator(user_id=user): await message.reply(get_string('feds', 'only_creators', chat_id)) return old = mongodb.fed_groups.delete_one({'chat_id': chat_id}).deleted_count if old < 1: # If chat not was in any federation await message.reply(get_string('feds', 'chat_not_in_fed', chat_id)) return await message.reply(strings['leave_fed_success'])
async def join_fed_comm(message, strings, status, chat_id, chat_title, **kwargs): fed_id = message.get_args().split(' ')[0] peep = await tbot( GetParticipantRequest( channel=chat_id, user_id=message.from_user.id, )) if not peep.participant == ChannelParticipantCreator( user_id=message.from_user.id): await message.reply(get_string('feds', 'only_creators', chat_id)) return # Assume Fed ID invalid if not (fed := await db.feds.find_one({'fed_id': fed_id})): await message.reply(get_string('feds', 'fed_id_invalid', chat_id)) return
async def admin(event): try: if str(event.chat_id).startswith("-100"): sender = await event.get_sender() member = await client( GetParticipantRequest(channel=event.chat_id, user_id=event.from_id)) if isinstance(member.participant, (ChannelParticipantAdmin, ChannelParticipantCreator)) and not sender.bot: return True else: return False else: return False except: return False
async def _can_use_commands(self, chat, tgid): if tgid in self.tg_whitelist: return True user = u.User.get_by_tgid(tgid) if user and user.is_admin: self.tg_whitelist.append(user.tgid) return True if self.whitelist_group_admins: if isinstance(chat, PeerChannel): p = await self.client(GetParticipantRequest(chat, tgid)) return isinstance(p, (ChannelParticipantCreator, ChannelParticipantAdmin)) elif isinstance(chat, PeerChat): chat = await self.client(GetFullChatRequest(chat.chat_id)) participants = chat.full_chat.participants.participants for p in participants: if p.user_id == tgid: return isinstance(p, (ChatParticipantCreator, ChatParticipantAdmin))
async def unban_user(message, user_id, chat_id): real_chat_id = message.chat.id if user_id == BOT_ID: await message.reply( get_string("bans", "bot_cant_be_unbanned", real_chat_id)) return False try: peep = await tbot(GetParticipantRequest(chat_id, user_id)) if not isinstance(peep.participant, ChannelParticipantBanned): await message.reply( get_string('bans', 'usernt_banned', real_chat_id)) return False except Exception: pass await bot.unban_chat_member(chat_id, user_id) return True
async def on_update_chan(e): channel_id = utils.get_peer_id(PeerChannel(e.channel_id)) entity = e._entities.get(channel_id) if isinstance(entity, tl.types.ChannelForbidden): return if isinstance(entity, tl.types.Channel) and (entity.left or not entity.broadcast): return channel = await borg.get_input_entity(channel_id) self_participant = await borg(GetParticipantRequest(channel, InputUserSelf())) if not hasattr(self_participant.participant, 'inviter_id'): return # assume the participant date is the added date (idk what else it could be) added_on = getattr(self_participant.participant, 'date', None) if not added_on: return if datetime.now(timezone.utc) - added_on > timedelta(seconds=2): return inviter_id = self_participant.participant.inviter_id await on_added(inviter_id, channel_id)
async def diesoon(e): match = (e.data_match.group(1)).decode("UTF-8") spli = match.split("_") if e.sender_id != int(spli[0]): return await e.answer(get_string("fsub_7"), alert=True) try: values = await ultroid_bot( GetParticipantRequest(int(spli[1]), int(spli[0]))) if isinstance(values.participant, ChannelParticipantLeft) or ( isinstance(values.participant, ChannelParticipantBanned) and values.left): raise UserNotParticipantError("") except UserNotParticipantError: return await e.answer( "Please Join That Channel !\nThen Click This Button !", alert=True) await ultroid_bot.edit_permissions(e.chat_id, int(spli[0]), send_messages=True, until_date=None) await e.edit(get_string("fsub_8"))
async def forcesub(ult): if not udB.get("FORCESUB"): return if not (ult.user_joined or ult.user_added): return if not get_forcesetting(ult.chat_id): return user = await ult.get_user() if user.bot: return joinchat = get_forcesetting(ult.chat_id) try: await ultroid_bot(GetParticipantRequest(int(joinchat), user.id)) except UserNotParticipantError: await ultroid_bot.edit_permissions(ult.chat_id, user.id, send_messages=False) res = await ultroid_bot.inline_query(asst.me.username, f"fsub {user.id}_{joinchat}") await res[0].click(ult.chat_id, reply_to=ult.action_message.id)
async def stop(chat: Channel, client: Client, db: Database, event: Command, tags: Tags): if not event.message.is_reply: return db_chat = await db.chats.get(event.chat_id) start_id = db_chat.raid_start reply_msg = await event.message.get_reply_message() end_id = reply_msg.id await db.chats.stop_raid(event.chat_id) raidno = tags.get('raidno', None) user_ids = set() message_ids = set() async for msg in client.iter_messages(chat, min_id=start_id-1, reverse=True): if msg.id >= end_id + 1: break if isinstance(msg.action, MessageActionChatAddUser): action: MessageActionChatAddUser = msg.action if msg.sender_id in action.users: uid = msg.sender_id user_ids.add(uid) message_ids.add(msg.id) await client(DeleteMessagesRequest(chat, list(message_ids))) for uid in user_ids: try: result = await client(GetParticipantRequest(chat, uid)) if not isinstance(result.participant, ChannelParticipantBanned): try: await client.ban(chat, uid) except FloodWaitError as e: flood_wait_message: Message = await client.send_message(chat, f'FloodWait for {e.seconds}') await asyncio.sleep(e.seconds) await flood_wait_message.delete() await client.ban(chat, uid) if raidno: await client.gban(uid, f'Raid[{raidno}]') await asyncio.sleep(0.5) except (UserNotParticipantError, BadRequestError): pass
async def unban(event, chat, chat_creator, chat_admin): """ <b>param:</b> <code>(required if not reply) user</code> <b>return:</b> <i>Un-Bans an user in the chat!</i> """ if chat_creator or chat_admin.can_ban: if event.is_reply: rep_msg = await event.get_reply_message() to_ban = rep_msg.from_id elif event.args.user: to_ban = event.args.user else: await event.reply("There's no user to unban!") return try: ent = await event.client.get_entity(to_ban) except Exception: await event.reply("I don't seem to find this user") return if isinstance(ent, User): try: chat_participant = await event.client(GetParticipantRequest(chat, ent.id)) except UserNotParticipantError: await event.reply("This user is not a participant of this chat!") return if isinstance( chat_participant.participant, (ChannelParticipantAdmin, ChannelParticipantCreator)): await event.reply("I can't unban chat admins because they can't be banned!") elif not isinstance(chat_participant.participant, ChannelParticipantBanned): await event.reply("This user isn't banned in this chat!") elif isinstance(chat_participant.participant, ChannelParticipantSelf): await event.reply("You can't unban yourself!") else: print(chat_participant.participant) await event.client(EditBannedRequest(chat, ent.id, ChatBannedRights(until_date=None, view_messages=None))) await event.reply("Un-Banned <code>{}</code>".format(ent.username or ent.first_name)) else: await event.reply("You don't have the rights to restrict users here!")
async def purge_messages(event): start = time.perf_counter() if event.from_id is None: return if not await user_is_admin(user_id=event.from_id, message=event): await event.reply("Only Admins are allowed to use this command") return result = await message.client( GetParticipantRequest(channel=chat_id, user_id=user_id)) if not await can_delete_messages(message=event): await event.reply("Can't seem to purge the message") return if not await user_can_delete_t(event.chat_id, event.from_id, event): await event.reply("You do not have enough rights to delete messages.") return reply_msg = await event.get_reply_message() if not reply_msg: await event.reply( "Reply to a message to select where to start purging from.") return messages = [] message_id = reply_msg.id delete_to = event.message.id messages.append(event.reply_to_msg_id) for msg_id in range(message_id, delete_to + 1): messages.append(msg_id) if len(messages) == 100: await event.client.delete_messages(event.chat_id, messages) messages = [] await event.client.delete_messages(event.chat_id, messages) time_ = time.perf_counter() - start text = f"Purged Successfully in {time_:0.2f} Second(s) This Message Self Destruct After 4 Seconds" x = await event.respond(text, parse_mode='markdown') await asyncio.sleep(4) await event.client.delete_messages(event.chat_id, x.id)
async def is_user_admin(chat_id: hints.EntityLike, user_id: hints.EntityLike) -> tuple[Optional[bool], Optional[str]]: """ Check if the user is an admin in the chat. :param chat_id: chat id :param user_id: user id :return: True if user is admin, False if not, None if self / the user not in the chat """ is_admin = None participant_type = None try: input_chat = await env.bot.get_input_entity(chat_id) input_user = await env.bot.get_input_entity(user_id) # noinspection PyTypeChecker participant: types.channels.ChannelParticipant = await env.bot( GetParticipantRequest(input_chat, input_user)) is_admin = isinstance(participant.participant, (types.ChannelParticipantAdmin, types.ChannelParticipantCreator)) participant_type = type(participant.participant).__name__ except (UserNotParticipantError, ValueError): pass return is_admin, participant_type
async def Function(cmd, event, delt, LANG): reply = await event.get_reply_message() result = await client( GetParticipantRequest(event.chat_id, event.message.from_id)) if isadmin(result) == True: if (cmd[0].lower() == "mute"): if not (reply): if len(cmd) == 2: try: await client( EditBannedRequest(event.chat_id, cmd[1], muted_rights)) await event.respond(lang['muteon']) except Exception as error: await event.respond(lang['notarg']) else: await event.respond(lang['notreply']) else: await client( EditBannedRequest(event.chat_id, reply.from_id, muted_rights)) await event.respond(lang['muteon']) elif (cmd[0].lower() == "unmute"): if not (reply): if len(cmd) == 2: try: await client( EditBannedRequest(event.chat_id, cmd[1], unmuted_rights)) await event.respond(lang['muteoff']) except Exception as error: await event.respond(lang['notarg']) else: await event.respond(lang['notreply']) else: await client( EditBannedRequest(event.chat_id, reply.from_id, unmuted_rights)) await event.respond(lang['muteoff'])
async def join_fed(event, chat_id, fed_id, user): peep = await bot(GetParticipantRequest( channel=chat_id, user_id=user, )) if not peep.participant == ChannelParticipantCreator(user_id=user): await event.reply(get_string('feds', 'only_creators', chat_id)) return check = mongodb.fed_list.find_one({'fed_id': fed_id}) if check is False: # Assume Fed ID invalid await event.reply(get_string('feds', 'fed_id_invalid', chat_id)) return old = mongodb.fed_groups.find_one({'chat_id': chat_id}) if old: # Assume chat already joined this/other fed await event.reply(get_string('feds', 'joined_fed_already', chat_id)) return join_data = {'chat_id': chat_id, 'fed_id': fed_id} mongodb.fed_groups.insert_one(join_data) return True
async def unban_user(event, user_id, chat_id): unbanned_rights = ChatBannedRights( until_date=None, view_messages=False, send_messages=False, send_media=False, send_stickers=False, send_gifs=False, send_games=False, send_inline=False, embed_links=False, ) bot_id = await bot.get_me() bot_id = bot_id.id if user_id == bot_id: await event.reply( get_string("bans", "bot_cant_be_unbanned", event.chat_id)) return False try: peep = await bot(GetParticipantRequest(chat_id, user_id)) if not isinstance(peep.participant, ChannelParticipantBanned): await event.reply(get_string('bans', 'usernt_banned', chat_id)) return False except Exception: pass try: await event.client(EditBannedRequest(chat_id, user_id, unbanned_rights)) except Exception as err: logger.error(str(err)) return False return True
async def unlock(client: Client, db: Database, chat, event: Command, msg: Message) -> KanTeXDocument: """Restore a chats previous permissions Arguments: `-self`: Use to make other Kantek instances ignore your command Examples: {cmd} """ participant = (await client(GetParticipantRequest(chat, msg.sender_id))).participant permitted = False if isinstance(participant, ChannelParticipantCreator): permitted = True elif isinstance(participant, ChannelParticipantAdmin): rights = participant.admin_rights permitted = rights.ban_users if not permitted: return KanTeXDocument('Insufficient permission.') dbchat = await db.chats.get(event.chat_id) permissions = chat.default_banned_rights.to_dict() del permissions['_'] if dbchat.locked: new_rights = permissions.copy() for k, v in dbchat.permissions.items(): new_rights[k] = v try: await client(EditChatDefaultBannedRightsRequest( chat, banned_rights=ChatBannedRights(**new_rights))) except ChatNotModifiedError: pass await db.chats.unlock(event.chat_id) return KanTeXDocument('Chat unlocked.') else: return KanTeXDocument('Chat not locked.')
async def _check(self, message, func): config = self.get_flags(func) if not config: # Either False or 0, either way we can failfast return False logger.debug("Checking security match for %d", config) f_owner = config & OWNER f_sudo = config & SUDO f_support = config & SUPPORT f_group_owner = config & GROUP_OWNER f_group_admin_add_admins = config & GROUP_ADMIN_ADD_ADMINS f_group_admin_change_info = config & GROUP_ADMIN_CHANGE_INFO f_group_admin_ban_users = config & GROUP_ADMIN_BAN_USERS f_group_admin_delete_messages = config & GROUP_ADMIN_DELETE_MESSAGES f_group_admin_pin_messages = config & GROUP_ADMIN_PIN_MESSAGES f_group_admin_invite_users = config & GROUP_ADMIN_INVITE_USERS f_group_admin = config & GROUP_ADMIN f_group_member = config & GROUP_MEMBER f_pm = config & PM f_group_admin_any = (f_group_admin_add_admins or f_group_admin_change_info or f_group_admin_ban_users or f_group_admin_delete_messages or f_group_admin_pin_messages or f_group_admin_invite_users or f_group_admin) if f_owner and message.from_id in self._owner: return True if f_sudo and message.from_id in self._sudo: return True if f_support and message.from_id in self._support: return True if message.from_id in self._db.get(main.__name__, "blacklist_users", []): return False if f_pm and message.is_private: return True if f_group_member and message.is_group: return True if f_group_admin_any or f_group_owner: if message.is_channel: if not message.is_group: if message.edit_date: return False # anyone can assume identity of another in channels # TODO: iter admin log and search for the edit event, to check who edited chat = await message.get_chat() if not chat.creator and not (chat.admin_rights and chat.admin_rights.post_messages): return False if self._any_admin and f_group_admin_any: return True if f_group_admin: return True # TODO: when running as bot, send an inline button which allows confirmation of command else: participant = await message.client(GetParticipantRequest(await message.get_input_chat(), await message.get_input_sender())) participant = participant.participant if isinstance(participant, telethon.types.ChannelParticipantCreator): return True if isinstance(participant, telethon.types.ChannelParticipantAdmin): if self._any_admin and f_group_admin_any: return True rights = participant.admin_rights if f_group_admin: return True if f_group_admin_add_admins and rights.add_admins: return True if f_group_admin_change_info and rights.change_info: return True if f_group_admin_ban_users and rights.ban_users: return True if f_group_admin_delete_messages and rights.delete_messages: return True if f_group_admin_pin_messages and rights.pin_messages: return True if f_group_admin_invite_users and rights.invite_users: return True elif message.is_group: full_chat = await message.client(telethon.functions.messages.GetFullChatRequest(message.chat_id)) participants = full_chat.full_chat.participants.participants participant = None for possible_participant in participants: if possible_participant.user_id == message.from_id: participant = possible_participant break if not participant: return if isinstance(participant, telethon.types.ChatParticipantCreator): return True if isinstance(participant, telethon.types.ChatParticipantAdmin): if f_group_admin_any: return True return False
async def challenge_user(event): global config, current_challenges bot = event.client chat = event.chat target = event.user if event.user_added: me = await bot.get_me() if me.id in event.user_ids: async with config_lock: group_config = config.get(str(event.chat.id), config['*']) await event.respond( message=group_config['msg_self_introduction']) return None elif not event.user_joined: return None # get previous restriction data async with upr_lock: key = '{chat}|{user}'.format(chat=chat.id, user=target.id) # a record probably means the user didn't pass the challenge previously # (and is fully restricted) # this time they leave & rejoin the group in order to pass the test # so we won't update the record which is likely fully restricted if not user_previous_restrictions.get(key): try: member = await bot(GetParticipantRequest(chat, target)) member = member.participant user_previous_restrictions[key] = member except errors.UserNotParticipantError: logging.warning( f'UserNotParticipantError on challenge_user: user={target.id}, chat={chat.id}' ) # Attempt to restrict the user try: await bot( EditBannedRequest( chat, target, ChatBannedRights(until_date=None, view_messages=None, send_messages=True, send_media=True, send_stickers=True, send_gifs=True, send_games=True, send_inline=True, send_polls=True, embed_links=True, invite_users=True))) except errors.ChatAdminRequiredError: return None async with config_lock: group_config = config.get(str(chat.id), config['*']) challenge = Challenge() def challenge_to_buttons(ch): # There can be 8 buttons per row at most (more are ignored). buttons = [ KeyboardButtonCallback(text=str(c), data=str(c)) for c in ch.choices() ] choices = [ buttons[i * 8:i * 8 + 8] for i in range((len(buttons) + 7) // 8) ] # manual approval/refusal by group admins choices.extend([[ KeyboardButtonCallback(text=group_config['msg_approve_manually'], data='+'), KeyboardButtonCallback(text=group_config['msg_refuse_manually'], data='-') ]]) return choices timeout = group_config['challenge_timeout'] try: bot_msg_id = await event.reply( message=group_config['msg_challenge'].format( timeout=timeout, challenge=challenge.qus()), buttons=challenge_to_buttons(challenge)) bot_msg_id = bot_msg_id.id except errors.BadRequestError: # msg to reply not found bot_msg_id = await event.respond( message=group_config['msg_challenge'].format( timeout=timeout, challenge=challenge.qus()), buttons=challenge_to_buttons(challenge)) bot_msg_id = bot_msg_id.id timeout_event = asyncio.create_task( handle_challenge_timeout(bot, group_config['challenge_timeout'], chat, target, bot_msg_id)) async with cch_lock: current_challenges['{chat}|{msg}'.format( chat=chat.id, msg=bot_msg_id)] = (challenge, target.id, timeout_event) try: await timeout_event except asyncio.CancelledError: pass
async def handle_challenge_response(event): global config, current_challenges user_ans = event.data.decode() bot = event.client chat = event.chat user = await event.get_sender() username = '******' + user.username if user.username else ( user.first_name + (' ' + user.last_name if user.last_name else '')) bot_msg = event.message_id async with config_lock: group_config = config.get(str(chat.id), config['*']) # handle manual approval/refusal by group admins if user_ans in ['+', '-']: try: participant = await bot( GetParticipantRequest(channel=chat, user_id=user)) participant = participant.participant except errors.UserNotParticipantError: logging.warning( f'UserNotParticipantError on handle_challenge_response: user={user.id}, chat={chat.id}' ) await event.answer(message=group_config['msg_permission_denied']) return None can_ban = False try: if type( participant ) is ChannelParticipantCreator or participant.admin_rights.ban_users: can_ban = True except AttributeError: pass if not can_ban: await event.answer(message=group_config['msg_permission_denied']) return None ch_id = '{chat}|{msg}'.format(chat=chat.id, msg=bot_msg) async with cch_lock: challenge, target, timeout_event = current_challenges.get( ch_id, (None, None, None)) try: del current_challenges[ch_id] except KeyError: return None timeout_event.cancel() if user_ans == '+': try: await lift_restriction(bot, chat, target) except errors.ChatAdminRequiredError: await event.answer( message=group_config['msg_bot_no_permission']) try: await event.edit( text=group_config['msg_approved'].format(user=username), buttons=None) except errors.BadRequestError: # message to edit not found pass else: # user_ans == '-' try: await bot( EditBannedRequest( chat, target, ChatBannedRights(until_date=None, view_messages=True))) except errors.ChatAdminRequiredError: await event.answer( message=group_config['msg_bot_no_permission']) return None try: await event.edit( text=group_config['msg_refused'].format(user=username), buttons=None) except errors.BadRequestError: # message to edit not found pass async with upr_lock: member = user_previous_restrictions.get('{chat}|{user}'.format( chat=chat.id, user=target)) if member: del user_previous_restrictions['{chat}|{user}'.format( chat=chat.id, user=target)] await event.answer() return None ch_id = '{chat}|{msg}'.format(chat=chat.id, msg=bot_msg) async with cch_lock: challenge, target, timeout_event = current_challenges.get( ch_id, (None, None, None)) if user.id != target: await event.answer(message=group_config['msg_challenge_not_for_you']) return None timeout_event.cancel() async with cch_lock: del current_challenges[ch_id] await event.answer() # verify the ans correct = (str(challenge.ans()) == user_ans) delete = None if correct or not group_config.get('challenge_strict_mode'): try: await lift_restriction(bot, chat, target) except errors.ChatAdminRequiredError: # This my happen when the bot is deop-ed after the user join # and before the user click the button # TODO: design messages for this occation pass msg = 'msg_challenge_passed' if correct else 'msg_challenge_mercy_passed' if correct: if group_config['delete_passed_challenge']: delete = asyncio.create_task( safe_delete_message( bot, group_config['delete_passed_challenge_interval'], channel=chat, id=[bot_msg])) else: msg = 'msg_challenge_failed' await event.edit(text=group_config[msg], buttons=None) if delete: await delete
async def fwgban(client: Client, db: Database, tags: Tags, chat: Channel, msg: Message, args: List, kwargs: Dict, event: Command) -> Optional[KanTeXDocument]: """Globally ban a user. This will not actively ban them from any chats except the one command was issued in as reply. GBanned users will be automatically banned on join or when writing a message by the Grenzschutz module. When banning by reply the message content will be automatically sent to the SpamWatch API if enabled. Arguments: `reason`: Ban reason, defaults to `spam[gban]` Tags: gban: verbose: Send a message when a user was banned by id Examples (as replies): {cmd} "some reason here" {cmd} """ _gban = tags.get('gban') if event.is_private: admin = False else: admin = bool(chat.creator or chat.admin_rights) only_joinspam = kwargs.get('only_joinspam', False) or kwargs.get( 'oj', False) verbose = False if _gban == 'verbose' or event.is_private: verbose = True if msg.is_reply: bancmd = tags.get('gbancmd') reply_msg: Message = await msg.get_reply_message() forward: Forward = reply_msg.forward if forward.sender_id is None: raise Error('User has forward privacy enabled or is a Channel') uid = forward.sender_id if args: ban_reason = ' '.join(args) else: ban_reason = DEFAULT_REASON try: participant = await client( GetParticipantRequest(event.chat_id, reply_msg.from_id)) if not isinstance(participant.participant, ChannelParticipantCreator): join_date = participant.participant.date if (reply_msg.date - datetime.timedelta(hours=1)) < join_date: ban_reason = 'joinspam' elif only_joinspam: return except (UserNotParticipantError, TypeError): pass banned_uids: Dict = {} message = await helpers.textify_message(reply_msg) banned, reason = await client.gban(uid, ban_reason, message) banned_uids[reason] = banned_uids.get(reason, []) + [str(uid)] if verbose: sections = [] if not banned: sections.append(KeyValueItem(Bold('Error'), reason)) await client.respond(msg, KanTeXDocument(*sections), reply=True) return if banned_uids: bans = _build_message(banned_uids, message) sections.append(Section(f'GBanned User', *bans)) await client.respond(msg, KanTeXDocument(*sections), reply=True) return else: pass
async def is_admin(chat_id, user_id): req_jo = await bot(GetParticipantRequest(channel=chat_id, user_id=user_id)) chat_participant = req_jo.participant return isinstance( chat_participant, (ChannelParticipantCreator, ChannelParticipantAdmin) )