async def buying_apples(call: CallbackQuery, callback_data: dict): await call.answer(cache_time=60) callback_data = call.data await call.message.chat.restrict( call.from_user.id, permissions=types.ChatPermissions(can_send_messages=True)) await call.message.delete()
async def callback_handler(call: types.CallbackQuery): """ Keyboard buttons handler :param call: Callback with action put into call.data field """ if call.data.startswith("del_"): await bot.delete_message(config.group_main, int(call.data.split("_")[1])) await bot.edit_message_text(chat_id=config.group_reports, message_id=call.message.message_id, text=call.message.text + lang.get_string("action_deleted")) await bot.answer_callback_query(call.id, "Done") return elif call.data.startswith("delban_"): await bot.delete_message(config.group_main, int(call.data.split("_")[1])) await bot.kick_chat_member(chat_id=config.group_main, user_id=call.data.split("_")[2]) await bot.edit_message_text(chat_id=config.group_reports, message_id=call.message.message_id, text=call.message.text + lang.get_string("action_deleted_banned")) await bot.answer_callback_query(call.id, "Done") return elif call.data.startswith("mute_"): await bot.delete_message(config.group_main, int(call.data.split("_")[1])) await bot.restrict_chat_member(chat_id=config.group_main, user_id=call.data.split("_")[2], permissions=types.ChatPermissions(), until_date=int(time()) + 7200) # 2 hours from now await bot.edit_message_text(chat_id=config.group_reports, message_id=call.message.message_id, text=call.message.text + lang.get_string("action_deleted_readonly")) await bot.answer_callback_query(call.id, "Done") return
async def cmd_readonly(message: types.Message): """ Handler for /ro command in chat. Reports which are not replies are ignored. Only admins can use this command. A time period may be set after command, f.ex. /ro 2d, anything else is treated as commentary with no effect. :param message: Telegram message with /ro command and optional time """ # Check if command is sent as reply to some message if not message.reply_to_message: await message.reply(localization.get_string("error_no_reply")) return # Admins cannot be restricted user = await message.bot.get_chat_member(config.groups.main, message.reply_to_message.from_user.id) if user.is_chat_admin(): await message.reply(localization.get_string("error_restrict_admin")) return words = message.text.split() restriction_time: int = 0 if len(words) > 1: # /ro with arg restriction_time = utils.get_restriction_time(words[1]) if not restriction_time: await message.reply(localization.get_string("error_wrong_time_format")) return await message.bot.restrict_chat_member(config.groups.main, message.reply_to_message.from_user.id, types.ChatPermissions(), until_date=int(time()) + restriction_time ) await message.reply(localization.get_string("resolved_readonly").format(restriction_time=words[1] if len(words) > 1 else localization.get_string("restriction_forever")))
def set_new_user_permissions(): new_permissions = copy(default_permissions) new_permissions.update( can_send_messages=False, can_send_media_messages=False, ) return types.ChatPermissions(**new_permissions)
async def cmd_ro(message: types.Message, lang: str): """ Handle /ro command in main group :param message: Telegram message starting with /ro :param lang: preferred bot language """ readonly_to = await message.chat.get_member( message.reply_to_message.from_user.id) if readonly_to.is_chat_admin(): await message.reply(get_string(lang, "error_restrict_admin")) return user = await message.chat.get_member(message.from_user.id) if not user.is_chat_admin() or user.can_restrict_members is False: return ro_period = get_restriction_period(message.text) ro_end_date = message.date + timedelta(seconds=ro_period) await message.chat.restrict(user_id=message.reply_to_message.from_user.id, permissions=types.ChatPermissions(), until_date=ro_end_date) if ro_period == 0: await message.reply(get_string(lang, "readonly_forever")) else: await message.reply( get_string(lang, "readonly_temporary").format( time=ro_end_date.strftime("%d.%m.%Y %H:%M")))
async def cmd_nomedia(message: types.Message): """ Handle /nomedia command in main group :param message: Telegram message starting with /nomedia """ lang = message.bot.get("config").lang nomedia_to = await message.chat.get_member(message.reply_to_message.from_user.id) if nomedia_to.is_chat_admin(): await message.reply(get_string(lang, "error_restrict_admin")) return user = await message.chat.get_member(message.from_user.id) if not user.is_chat_admin() or user.can_restrict_members is False: return nomedia_period = get_restriction_period(message.text) nomedia_end_date = message.date + timedelta(seconds=nomedia_period) await message.chat.restrict( user_id=message.reply_to_message.from_user.id, permissions=types.ChatPermissions(can_send_messages=True), until_date=nomedia_end_date ) if nomedia_period == 0: await message.reply(get_string(lang, "nomedia_forever")) else: await message.reply( get_string(lang, "nomedia_temporary").format(time=nomedia_end_date.strftime("%d.%m.%Y %H:%M")) )
def set_new_user_approved_permissions(member, default_permissions): return types.ChatPermissions(**update_permissions( member, default_permissions=default_permissions, can_send_messages=True, can_send_polls=True, ))
def set_new_user_permissions(member, default_permissions): return types.ChatPermissions(**update_permissions( member=member, default_permissions=default_permissions, can_send_messages=False, can_send_media_messages=False, ))
async def handle_captcha_callback(self, callback: types.CallbackQuery): chat_id = callback.message.chat.id message_id = callback.message.message_id from_user_id = callback.from_user.id pending_user = self.__get_pending_user(message_id, chat_id) pending_user_id = pending_user.user_id if pending_user_id != from_user_id: await self.bot.answer_callback_query( callback.id, text="We are waiting for {0} to click".format( (await callback.message.chat.get_member(pending_user_id) ).user.first_name), show_alert=False) else: congrats = await self.bot.edit_message_text( chat_id=chat_id, message_id=message_id, text="Congrats {0}, captcha passed".format( self.__get_mention(callback.from_user)), parse_mode=ParseMode.HTML, reply_markup=None) await self.bot.restrict_chat_member( chat_id, from_user_id, types.ChatPermissions(True, True, True, True, True, True, True, True)) self.pending_users.remove(pending_user) await self.__delay_delete_message(DELAY_DELETE_CONGRATS, congrats)
async def mute(message: types.Message): try: user = await bot.get_chat_member( chat_id=message.chat.id, user_id=message.reply_to_message.from_user.id) if not message.reply_to_message: return await message.reply( "<b> SPECIFY SOMEONE TO MUTE PLEASE !!!</b>") if user.is_chat_admin(): await message.reply("<b> IT WASN'T FUNNY </b>") return if len(message.text.split()) == 2: until_mute = int(message.text.split()[1]) # Converting seconds to minute :| until_mute = until_mute * 60 await bot.restrict_chat_member( chat_id=message.chat.id, user_id=message.reply_to_message.from_user.id, permissions=types.ChatPermissions( can_send_message=False, can_pin_messages=False, can_send_other_messages=False, can_invite_users=False), until_date=int(time()) + int(until_mute)) hours = int(until_mute) / 3600 await message.reply( f'{message.reply_to_message.from_user.first_name} is Muted for {str(hours)} hours' ) else: await bot.restrict_chat_member( chat_id=message.chat.id, user_id=message.reply_to_message.from_user.id, permissions=types.ChatPermissions( can_send_message=False, can_pin_messages=False, can_send_other_messages=False, can_invite_users=False), until_date=int(time()) + 7200) await message.reply( f'{message.reply_to_message.from_user.first_name} is Muted for 2 hours !!!' ) except: await message.reply("Error Do I have Enough permissions to do this ? ")
def set_user_ro_permissions(): new_permissions = copy(default_permissions) new_permissions.update(can_send_messages=False, can_send_media_messages=False, can_send_polls=False, can_send_other_messages=False, can_add_web_page_previews=False, can_invite_users=False) return types.ChatPermissions(**new_permissions)
async def new_chat_member(message: types.Message): user = message.from_user.id chat = message.chat.id random.shuffle(choice_buttons) await message.chat.restrict( message.from_user.id, permissions=types.ChatPermissions(can_send_messages=False)) await message.reply(f'Привет, {message.from_user.full_name}!\n{first_digit} + {second_digit} ?', reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[choice_buttons]))
async def unlock_contents(message: types.Message): try: await bot.set_chat_permissions(chat_id=message.chat.id, permissions=types.ChatPermissions( can_send_media_messages=True, can_send_other_messages=True, can_pin_messages=False, can_change_info=False, can_invite_users=True, can_add_web_page_previews=False)) await message.reply("Successfully unlocked Media ") except: await message.reply("Error Do I have Enough permissions to do this ? ")
async def process_callback_private(callback_query: types.CallbackQuery): if user.Check_User(callback_query.from_user.id) == False: if callback_query.data != "2": await callback_query.answer(("Ты ошибся.."), show_alert=True) await asyncio.sleep(2) await callback_query.message.chat.kick(callback_query.from_user.id) await callback_query.message.chat.unban(callback_query.from_user.id ) else: await callback_query.answer(("Правильный ответ!")) user.Save(callback_query.from_user.id) await callback_query.message.chat.restrict( callback_query.from_user.id, permissions=types.ChatPermissions(can_send_messages=True)) await callback_query.message.delete() await bot.answer_callback_query(callback_query.id)
async def test_restrict_chat_member(bot: Bot, event_loop): """ restrictChatMember method test """ from .types.dataset import USER, CHAT user = types.User(**USER) chat = types.Chat(**CHAT) async with FakeTelegram(message_data=True, loop=event_loop): result = await bot.restrict_chat_member( chat_id=chat.id, user_id=user.id, permissions=types.ChatPermissions(can_add_web_page_previews=False, can_send_media_messages=False, can_send_messages=False, can_send_other_messages=False), until_date=123) assert isinstance(result, bool) assert result is True
async def handler_new_member(message): if user.Check_User(message.from_user.id)==False: user_name = message.from_user.first_name keyboard = InlineKeyboardMarkup() layer = ["Бот", "Человек", "Вомбат", "Дракон", "Утка"] random.shuffle(layer) for i in layer: if i == "Человек": keyboard.add(InlineKeyboardButton(i, callback_data=2)) else: keyboard.add(InlineKeyboardButton(i, callback_data=1)) await bot.send_message(message.chat.id, "Привет, {0}!\nТы кто ???".format(user_name), reply_markup=keyboard) await message.chat.restrict( message.from_user.id, permissions=types.ChatPermissions(can_send_messages=False) ) else: await bot.send_message(message.chat.id,"Рад видеть тебя снова!")
async def callback_handler(call: types.CallbackQuery): """ Keyboard buttons handler :param call: Callback with action put into call.data field """ if call.data.startswith("del_"): await call.message.bot.delete_message(Config.GROUP_MAIN, int(call.data.split("_")[1])) await call.message.bot.edit_message_text( chat_id=Config.GROUP_REPORTS, message_id=call.message.message_id, text=call.message.text + localization.get_string("action_deleted")) await call.answer(text="Done") elif call.data.startswith("delban_"): await call.message.bot.delete_message(Config.GROUP_MAIN, int(call.data.split("_")[1])) await call.message.bot.kick_chat_member( chat_id=Config.GROUP_MAIN, user_id=call.data.split("_")[2]) await call.message.bot.edit_message_text( chat_id=Config.GROUP_REPORTS, message_id=call.message.message_id, text=call.message.text + localization.get_string("action_deleted_banned")) await call.answer(text="Done") elif call.data.startswith("mute_"): await call.message.bot.delete_message(Config.GROUP_MAIN, int(call.data.split("_")[1])) await call.message.bot.restrict_chat_member( chat_id=Config.GROUP_MAIN, user_id=call.data.split("_")[2], permissions=types.ChatPermissions(), until_date=int(time()) + 7200) # 2 hours from now await call.message.bot.edit_message_text( chat_id=Config.GROUP_REPORTS, message_id=call.message.message_id, text=call.message.text + localization.get_string("action_deleted_readonly")) await call.answer(text="Done")
async def cq_join_list(query: types.CallbackQuery, callback_data: dict): answer = callback_data["answer"] logger.info( "User {user} choose answer {answer} in join-list in chat {chat} and message {message}", user=query.from_user.id, chat=query.message.chat.id, answer=repr(answer), message=query.message.message_id, ) in_list = await join_list.pop_user_from_list( chat_id=query.message.chat.id, message_id=query.message.message_id, user_id=query.from_user.id, ) if not in_list: return await query.answer(_("This message is not for you!"), show_alert=True) if answer == "human": await query.answer(_("Good answer!")) await query.message.chat.restrict( query.from_user.id, permissions=types.ChatPermissions(can_send_messages=True), until_date=config.JOIN_NO_MEDIA_DURATION, ) else: await query.answer(_("Bad answer."), show_alert=True) await asyncio.sleep(2) await query.message.chat.kick(query.from_user.id) await query.message.chat.unban(query.from_user.id) users_list = await join_list.check_list( chat_id=query.message.chat.id, message_id=query.message.message_id) if not users_list: with suppress(MessageToDeleteNotFound): await query.message.delete() return True
async def unmute_command(msg: types.Message): chat_id = msg.chat.id admins = [ admin.user for admin in await walle.get_chat_administrators(chat_id) ] try: sndr = msg.from_user target = msg.reply_to_message.from_user if sndr in admins: await walle.restrict_chat_member(chat_id, target.id, permissions=types.ChatPermissions( True, True, True, True, True, False, True, False)) await msg.reply(task_done, parse_mode='MarkdownV2') else: await msg.reply(not_admin, parse_mode='MarkdownV2') except AttributeError: await msg.reply(point_target, parse_mode='MarkdownV2') except Exception as e: print(e)
async def unmute(message: types.Message): try: user = await bot.get_chat_member(message.chat.id, message.reply_to_message.from_user.id) await bot.restrict_chat_member( chat_id=message.chat.id, user_id=message.reply_to_message.from_user.id, permissions=types.ChatPermissions(can_send_message=True, can_pin_messages=True, can_send_other_messages=True, can_invite_users=True), ) if not message.reply_to_message: return await message.reply( "<b> :| YOU DIDN'T SPECIFY SOME ONE !!</b>") if user.is_chat_admin(): await message.reply("<b>lol it wasn't funny </b>") return await message.reply( f'{message.reply_to_message.from_user.first_name} is Now Unmuted !!!' ) except: await message.reply("Error Do I have Enough permissions to do this ? ")
async def mute_command(msg: types.Message): chat_id = msg.chat.id admins = [ admin.user for admin in await walle.get_chat_administrators(chat_id) ] try: sndr = msg.from_user target = msg.reply_to_message.from_user period_command_arg = msg.text.split(' ')[1] try: period_time = int(period_command_arg[:-1:]) except ValueError: await msg.reply(not_int_argument, parse_mode='MarkdownV2') if period_command_arg.endswith('h'): period = datetime.datetime.now() + datetime.timedelta( hours=period_time) if period_command_arg.endswith('m'): period = datetime.datetime.now() + datetime.timedelta( minutes=period_time) if sndr in admins: await walle.restrict_chat_member(chat_id, target.id, permissions=types.ChatPermissions( False, False, False, False, False, False, False, False, ), until_date=period) await walle.send_message( -1001471262276, mute_used.format( returnNoneReserved(sndr.first_name), sndr.url, returnNoneReserved(target.first_name), target.url, returnNoneReserved( formatted_date.format(str(msg.date.day), str(msg.date.month), str(msg.date.year), str(msg.date.hour + 4), str(msg.date.minute), str(msg.date.second)))), parse_mode='MarkdownV2') await msg.reply(task_done, parse_mode='MarkdownV2') else: await msg.reply(not_admin, parse_mode='MarkdownV2') except IndexError: await msg.reply(missing_argument, parse_mode='MarkdownV2') except AttributeError: await msg.reply(point_target, parse_mode='MarkdownV2') except Exception as e: print(e)
async def new_chat_member(message: types.Message, chat: Chat): if not chat.join_filter: return False if message.date < datetime.datetime.now() - datetime.timedelta(minutes=1): logger.warning( "Join message {message} in chat {chat} is too old. Skip filtering. (Age: {age})", message=message.message_id, chat=chat.id, age=datetime.datetime.now() - message.date, ) return False if message.from_user not in message.new_chat_members: logger.opt(lazy=True).info( "User {user} add new members to chat {chat}: {new_members}", user=lambda: message.from_user.id, chat=lambda: message.chat.id, new_members=lambda: ", ".join([str(u.id) for u in message.new_chat_members]), ) # TODO: Validate is admin add new members else: logger.opt(lazy=True).info( "New chat members in chat {chat}: {new_members}", chat=lambda: message.chat.id, new_members=lambda: ", ".join([str(u.id) for u in message.new_chat_members]), ) users = {} for new_member in message.new_chat_members: try: chat_member = await message.chat.get_member(new_member.id) if chat_member.status == "restricted": return False # ignore user that's been restricted to avoid capcha abusing. else: await message.chat.restrict( new_member.id, permissions=types.ChatPermissions(can_send_messages=False) ) users[new_member.id] = new_member.get_mention() except BadRequest as e: logger.error( "Cannot restrict chat member {user} in chat {chat} with error: {error}", user=new_member.id, chat=chat.id, error=e, ) continue buttons = [ types.InlineKeyboardButton(_("I'm human"), callback_data=cb_join_list.new(answer="human")), types.InlineKeyboardButton(_("I'm bot"), callback_data=cb_join_list.new(answer="bot")), types.InlineKeyboardButton(_("I'm pet"), callback_data=cb_join_list.new(answer="pet")), ] random.shuffle(buttons) msg = await message.reply( _( "{users}, Welcome to the chat. \n" "Please confirm that you are a human. " "User filter is enabled in this chat, so if you don't answer my question, " "I will be forced to remove you from this chat." ).format(users=", ".join(users.values())), reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[buttons]), ) await join_list.create_list( chat_id=message.chat.id, message_id=msg.message_id, users=users.keys() ) return True
from aiogram import types # Права пользователя, только вошедшего в чат new_user_added = types.ChatPermissions( can_send_messages=False, can_send_media_messages=False, can_send_polls=False, can_send_other_messages=False, can_add_web_page_previews=False, can_invite_users=False, can_change_info=False, can_pin_messages=False, ) # Права пользователя, подтвердившего, что он не бот user_allowed = types.ChatPermissions( can_send_messages=True, can_send_media_messages=True, can_send_polls=True, can_send_other_messages=True, can_add_web_page_previews=True, can_invite_users=True, can_change_info=False, can_pin_messages=False, ) # Права пользователя в муте user_ro = types.ChatPermissions( can_send_messages=False, can_send_media_messages=False, can_send_polls=False,
def set_new_user_approved_permissions(): return types.ChatPermissions(**default_permissions)