async def mute_user(message, user_id, chat_id, time_val, no_msg=False):
real_chat_id = message.chat.id
await update_admin_cache(real_chat_id)
if str(user_id) in WHITELISTED:
await message.reply("This user is whitelisted")
return
if user_id == BOT_ID:
await message.reply(
get_string("bans", "bot_cant_be_muted", real_chat_id))
return False
if await is_user_admin(chat_id, user_id) is None:
await message.reply(get_string("bans", "user_admin_mute",
real_chat_id))
return False
try:
await bot.restrict_chat_member(chat_id,
user_id,
permissions=ChatPermissions(
can_send_messages=False,
until_date=time_val))
except (NotEnoughRightsToRestrict, BadRequest):
await message.reply(
get_string("bans", "user_cannot_be_muted", real_chat_id))
return False
return True
async def process_callback_kb1btn1(callback_query: types.CallbackQuery):
code = callback_query.data
chat_id = callback_query.message.chat.id
member_id = callback_query.from_user.id
user_title = callback_query.from_user.mention
debug_id = f'{callback_query.message.chat.username}-({user_title})'
chat_title = callback_query.message.chat.title
log.info(f'{debug_id}: {code}')
_id = f'{callback_query.message.message_id}-{callback_query.message.chat.id}'
try:
pass_item = data_store.get_captcha(_id)
except KeyError:
log.error(f'Something gone wrong: {data_store} {_id}')
await bot.answer_callback_query(callback_query.id,
text=s('something_gone_wrong_warn',
{'lang': 'ru'}))
return
if not pass_item.user_check(callback_query.from_user.id):
await bot.answer_callback_query(callback_query.id,
text=s('not_for_you_warn',
{'lang': 'ru'}))
return
text = pass_item.new_char(code[-1:])
result = pass_item.check()
if result is CAPTCHA_STATE.INPUTING:
await bot.answer_callback_query(callback_query.id, text=text)
elif result is CAPTCHA_STATE.SUCSSES:
data_store.remove_captcha(_id)
log.info(f'{debug_id}: SUCSSES')
await bot.answer_callback_query(callback_query.id, text='SUCSSES')
try:
pass_item.messages.pop(MESSAGE_TYPES.LOGIN)
except KeyError:
pass
await clear(pass_item)
await bot.send_message(
callback_query.message.chat.id,
s('success_msg', {
'lang': 'ru',
'user_title': user_title,
'chat_title': chat_title
}))
unmute = ChatPermissions(can_send_messages=True,
can_send_media_messages=True,
can_add_web_page_previews=True,
can_send_other_messages=True,
can_send_polls=True)
await bot.restrict_chat_member(chat_id, member_id, permissions=unmute)
else:
data_store.remove_captcha(_id)
delay = datetime.now() + timedelta(minutes=1)
log.info(f'{debug_id}: FAIL, ban until {delay}')
# workaround to send new event.
await bot.kick_chat_member(chat_id, member_id, delay)
await bot.answer_callback_query(callback_query.id,
text=s('fail_msg', {'lang': 'ru'}))
await clear(pass_item)
# await bot.unban_chat_member(chat_id, member_id)
data_store.sync()
async def mute_user(chat_id, user_id, until_date=None):
await bot.restrict_chat_member(chat_id,
user_id,
permissions=ChatPermissions(
can_send_messages=False,
until_date=until_date),
until_date=until_date)
return True
async def restrict_user(chat_id, user_id, until_date=None):
await bot.restrict_chat_member(chat_id,
user_id,
permissions=ChatPermissions(
can_send_messages=True,
can_send_media_messages=False,
can_send_other_messages=False,
can_add_web_page_previews=False,
until_date=until_date),
until_date=until_date)
return True
async def capcha(message: types.Message):
mute = ChatPermissions(can_send_messages=False,
can_send_media_messages=False,
can_add_web_page_previews=False,
can_send_other_messages=False,
can_send_polls=False)
my_id = (await bot.me).id
for member in message.new_chat_members:
# Do not touch yourself
if member.id == my_id:
continue
if member.is_bot:
await bot.send_message(message.chat.id,
text=s('join_bot_msg', {'lang': 'ru'}),
reply_to_message_id=message.message_id)
continue
# mute user
user_title = member.mention
debug_id = f'{message.chat.username}-{user_title}'
log.info(f'{debug_id}: Start capcha')
try:
await bot.restrict_chat_member(message.chat.id, member.id, permissions=mute)
except NotEnoughRightsToRestrict as e:
log.info(f'{debug_id} can\'t restrict member : {e}')
continue
input_file, inline_kb_full, btn_pass = base_capthca('ru')
sent_message = await bot.send_photo(message.chat.id, input_file,
caption=s(
'join_msg', {'lang': 'ru', 'user_title': user_title}),
reply_markup=inline_kb_full,
reply_to_message_id=message.message_id)
_id = f'{sent_message.message_id}-{sent_message.chat.id}'
expired_time = datetime.now() + timedelta(minutes=5)
pass_item = PassStorage(
btn_pass, member.id, sent_message.chat.id, sent_message.message_id, expired_time)
pass_item.add_message_id(MESSAGE_TYPES.LOGIN, message.message_id)
pass_item.add_message_id(
MESSAGE_TYPES.CAPTCHA, sent_message.message_id)
data_store.new_captcha(_id, pass_item)
data_store.sync()
async def lock_cmd(message, chat, strings):
chat_id = chat['chat_id']
chat_title = chat['chat_title']
if (args := message.get_args().split(' ', 1)) == ['']:
await message.reply(strings['no_lock_args'])
return
async for lock, status in lock_parser(chat_id, rev=True):
if args[0] == lock[0]:
if status is True:
await message.reply(strings['already_locked'])
continue
to_lock = {lock[1]: False}
new_perm = ChatPermissions(**to_lock)
await bot.set_chat_permissions(chat_id, new_perm)
await message.reply(strings['locked_successfully'].format(
lock=lock[0], chat=chat_title))
@register(cmds="unlock",
user_can_restrict_members=True,
bot_can_restrict_members=True)
@chat_connection()
@get_strings_dec('locks')
async def unlock_cmd(message, chat, strings):
chat_id = chat['chat_id']
chat_title = chat['chat_title']
if (args := message.get_args().split(' ', 1)) == ['']:
'А вам, сударь, на броневичек-с!',
'Мама мыла раму!',
'Ты сделал все что мог!',
'С вашего счета списано 100$.',
'Таки зачем ви это делаете?',
'Грустно...',
'Лифт не приедет.',
'Ваш звонок очень важен для нас!',
'Вы успешно зарегистрированы на интеллектуальное соревнование. Соперник - хаса.',
'В упорной битве интеллектуалов ты с минимальным преимуществом побеждаешь хасу!',
'В упорной битве интеллектуалов ты с минимальным преимуществом уступаешь хасе!',
'',
]
RESTRICT_PERMISSIONS = ChatPermissions(can_send_messages=False,
can_send_media_messages=False,
can_send_other_messages=False)
ALLOW_PERMISSIONS = ChatPermissions(can_send_messages=True,
can_send_media_messages=True,
can_send_other_messages=True)
def get_keyboard(user_id: int) -> InlineKeyboardMarkup:
kb = InlineKeyboardMarkup()
kb.row_width = 5
answers = list(range(5))
random.shuffle(answers)
buttons = []
import random
from typing import List
from aiogram.types.chat_permissions import ChatPermissions
from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
RESTRICT_PERMISSIONS = ChatPermissions(
can_send_messages=False,
can_send_media_messages=False,
can_send_other_messages=False
)
ALLOW_PERMISSIONS = ChatPermissions(
can_send_messages=True,
can_send_media_messages=True,
can_send_other_messages=True,
can_add_web_page_previews=True,
can_send_polls=True,
can_invite_users=True,
can_pin_messages=True,
can_change_info=True
)
def get_keyboard(user_id: int, button_options: List[str]) -> InlineKeyboardMarkup:
kb = InlineKeyboardMarkup()
# kb.row_width = 5
random.shuffle(button_options)
row = []
