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)
