async def on_pre_process_aiogd_update(self, event: DialogUpdateEvent,
data: dict):
proxy = StorageProxy(
storage=self.storage,
user_id=event.from_user.id,
chat_id=event.chat.id,
state_groups=self.state_groups,
)
data[STORAGE_KEY] = proxy
if event.intent_id is not None:
context = await proxy.load_context(event.intent_id)
stack = await proxy.load_stack(context.stack_id)
elif event.stack_id is not None:
stack = await proxy.load_stack(event.stack_id)
if stack.empty():
if event.intent_id is not None:
logger.warning(f"Outdated intent id ({event.intent_id}) "
f"for empty stack ({stack.id})")
raise CancelHandler()
context = None
else:
if event.intent_id is not None and event.intent_id != stack.last_intent_id(
):
logger.warning(f"Outdated intent id ({event.intent_id}) "
f"for stack ({stack.id})")
raise CancelHandler()
context = await proxy.load_context(stack.last_intent_id())
else:
raise InvalidStackIdError(
f"Both stack id and intent id are None: {event}")
data[STACK_KEY] = stack
data[CONTEXT_KEY] = context
async def get_employee(msg: types.Message, state: FSMContext):
default_number = msg.text
if not re.match(NUMBER_PATTERN, default_number):
logger.info("Invalid number at get_employee handler")
await msg.answer('Вы ввели номер телефона в неверном формате.\n'
'Попробуйте ввести ещё раз!')
raise CancelHandler()
number = parse_number(default_number)
master = await manager.employee.select_master_by_phone(
phone_number=number,
default_number=default_number
)
if not isinstance(master, Record):
await msg.answer('Такого мастера не найдено.\n'
'Можешь добавить его в базу, нажав на кнопку ниже', reply_markup=add_master_keyboard)
await state.update_data(
phone_number=default_number
)
await SearchMaster.add_master.set()
raise CancelHandler()
text = f"""Номер в базе данных: {master.get('employee_id')}
Имя: {master.get('name')}
Номер: {master.get('phone_number')}
Комментарий: {master.get('comment') if master.get('comment') is not None else '-'}\n"""
await msg.answer(
text=text,
reply_markup=generate_start_keyboard(msg)
)
await StartState.in_general_menu.set()
async def on_pre_process_message(self, message: types.Message, data: dict):
self.logger.info('New message: %s', message)
try:
user_id = message.from_user.id
except AttributeError as e:
self.logger.error('Unable to get user id: %s', e)
raise CancelHandler()
else:
if user_id not in self.authorized_users:
self.logger.warning('User is not authorized!')
raise CancelHandler()
self.logger.info('User is authorized.')
async def on_process_message(self, message: types.Message, data):
user = await db.is_registered(message.from_user.id)
if not user:
await db.register_user(message.from_user.id)
if message.text != "/start":
await message.reply("Нажмите /start")
raise CancelHandler()
if user and await db.is_banned(message.from_user.id):
date, reason = await db.check_ban(message.from_user.id)
await message.answer(
f"<i>{texts.user_banned[await db.user_data(message.from_user.id, 'language')].format(reason, date[:16])}</i>",
)
raise CancelHandler()
async def on_process_message(self, message: types.Message, _):
if self.access_id == 0:
return
if int(message.from_user.id) != int(self.access_id):
await message.answer("Access Denied")
raise CancelHandler()
async def on_process_message(self, message: types.Message, _):
if int(message.from_user.id) != int(self.access_id):
await message.answer("Access Denied")
print("Неавторизованный пользователь! ID - %i" %
int(message.from_user.id))
print(message)
raise CancelHandler()
async def on_process_message(self, message: types.Message, data: dict):
"""
This handler is called when dispatcher receives a message
:param message:
:param data:
"""
# Get current handler
handler = current_handler.get()
# Get dispatcher from context
dispatcher = Dispatcher.get_current()
# If handler was configured, get rate limit and key from handler
if handler:
limit = getattr(handler, "throttling_rate_limit", self.rate_limit)
key = getattr(handler, "throttling_key",
f"{self.prefix}_{handler.__name__}")
else:
limit = self.rate_limit
key = f"{self.prefix}_message"
# Use Dispatcher.throttle method.
try:
await dispatcher.throttle(key, rate=limit)
except Throttled as t:
# Execute action
await self.message_throttled(message, t)
# Cancel current handler
raise CancelHandler()
async def on_pre_process_update(self, update: types.Update, data: dict):
if update.message:
user = update.message.from_user.id
if update.message.text in ['/start', '/help']:
return
elif update.callback_query:
user = update.callback_query.from_user.id
if update.callback_query.data == "check_subs":
return
else:
return
logging.info(user)
result = "<b>Botdan foydalanish uchun quyidagi kanallarga obuna bo'ling:</b>\n\n"
final_status = True
for channel in CHANNELS:
status = await subscription.check(user_id=user, channel=channel)
final_status *= status
channel = await bot.get_chat(channel)
if not status:
invite_link = await channel.export_invite_link()
result += (
f"👉 <a href='{invite_link}'><i>{channel.title}</i></a>\n"
)
if not final_status:
await update.message.answer(result, disable_web_page_preview=True)
raise CancelHandler()
async def check_and_change_master_param(message: types.Message,
state: FSMContext):
async with state.proxy() as data:
contact_name = data.get('contact_name')
employee_id = data.get('employee_id')
update_param = data.get('update_param')
value = message.text
if update_param == 'phone_number':
default_number = message.text
if not re.match(NUMBER_PATTERN, default_number):
logger.info("Invalid number at get_employee handler")
await message.answer(
'Вы ввели номер телефона в неверном формате.\n'
'Попробуйте ввести ещё раз!')
raise CancelHandler()
value = parse_number(default_number)
if value.find("+") == -1:
value = "+" + value
await message.answer(
f'Вы успешно изменили номер телефона {contact_name}',
reply_markup=generate_start_keyboard(message))
elif update_param == 'name':
await message.answer(
f'Вы успешно изменили имя мастера на {message.text}',
reply_markup=generate_start_keyboard(message))
else:
await message.answer(
f'Вы успешно изменили комментарий мастера на "{message.text}"',
reply_markup=generate_start_keyboard(message))
await manager.employee.update_entry(update_values={update_param: value},
employee_id=employee_id)
await StartState.in_general_menu.set()
async def on_pre_process_callback_query(self, event: CallbackQuery,
data: dict):
proxy = StorageProxy(
storage=self.storage,
user_id=event.from_user.id,
chat_id=event.message.chat.id,
state_groups=self.state_groups,
)
data[STORAGE_KEY] = proxy
original_data = event.data
intent_id, callback_data = remove_indent_id(event.data)
if intent_id:
context = await proxy.load_context(intent_id)
stack = await proxy.load_stack(context.stack_id)
if stack.last_intent_id() != intent_id:
logger.warning(
f"Outdated intent id ({intent_id}) for stack ({stack.id})")
raise CancelHandler()
event.data = callback_data
else:
context = None
stack = await proxy.load_stack()
data[STACK_KEY] = stack
data[CONTEXT_KEY] = context
data[CALLBACK_DATA_KEY] = original_data
async def process_next_week(query: types.CallbackQuery):
logger.info(f'User {query.from_user.id} request increase a page')
state = dp.current_state(user=query.from_user.id)
user_data = await state.get_data()
# Check state
if not await check_state(query, state):
raise CancelHandler()
# Increase weeks
current_week = user_data['page']
if not (parser.get_WeekNumber(current_week) >= 17):
current_week += datetime.timedelta(days=7)
await state.update_data(page=current_week)
text = craft_schedule(user_data['group'],
mode=2,
special_date=current_week)
keyboard = craft_paging_keyboard()
try:
await query.message.edit_text(text, reply_markup=keyboard)
await bot.answer_callback_query(query.id)
except aiogram.utils.exceptions.MessageNotModified:
await bot.answer_callback_query(
query.id,
text='Вы достигли конца расписания\nДальше двигаться некуда',
show_alert=True)
async def on_process_message(self, message: types.Message, _):
if int(message.from_user.id) != int(self.access_id):
header = MarkdownFormatter.bold('Access Denied') + '\n'
msg_body = 'This is beta bot. You can request access by creating issue: ' \
'https://github.com/a0l6g0r8a9l2/investHelperBE/issues/new/choose'
await message.answer(header + msg_body, parse_mode="Markdown")
raise CancelHandler()
async def setup_chat(data: dict,
user: types.User,
chat: Optional[types.Chat] = None):
user_id = user.id
chat_id = chat.id if chat else user.id
chat_type = chat.type if chat else "private"
if chat_type != "private":
logger.info(
"User {user} tried to chat with bot in non-private chat, which is not permitted!",
user=user,
)
raise CancelHandler()
user = await User.get(user_id)
if user is None:
user = await User.create(id=user_id)
logger.info("User {user} created!", user=user)
chat = await Chat.get(chat_id)
if chat is None:
chat = await Chat.create(id=chat_id, type=chat_type)
logger.info("Chat {chat} created!", chat=chat)
data["user"] = user
data["chat"] = chat
async def on_process_callback_query(self, cb: types.CallbackQuery,
data: dict):
"""
This handler is called when dispatcher receives a message
"""
# Get current handler
handler = current_handler.get()
# Get dispatcher from context
dispatcher = Dispatcher.get_current()
# If handler was configured, get rate limit and key from handler
if handler:
limit = getattr(handler, 'throttling_rate_limit', self.rate_limit)
key = getattr(handler, 'throttling_key',
f"{self.prefix}_{handler.__name__}")
else:
limit = self.rate_limit
key = f"{self.prefix}_callback"
# Use Dispatcher.throttle method.
try:
await dispatcher.throttle(key, rate=limit)
except Throttled as t:
# Execute action
await self.callback_throttled(cb, t)
# Cancel current handler
raise CancelHandler()
async def on_process_message(self, message: types.Message, data: dict):
if self._is_public_command(): # Public commands allowed
return
if message.chat.id < 0: # Group chats are not allowed
await message.answer("Для общения с ботом используйте личные сообщения")
raise CancelHandler()
privileges = await _get_privileges(message.from_user.id, self._access_chat_id)
if privileges < Privileges.user:
await message.answer("Вы должны быть участником тематического чата для доступа к Конструктору Плакатов")
raise CancelHandler()
if self._is_root_command() and privileges < Privileges.admin:
await message.answer("Вы должны быть администратором чата для доступа к этому функционалу")
raise CancelHandler()
async def check(self, obj: types.Update) -> bool:
if isinstance(obj, types.Message):
msg: types.Message = obj
elif isinstance(obj, types.CallbackQuery):
msg: types.CallbackQuery = obj
else:
raise CancelHandler()
return str(msg.from_user.id) in ADMINS
def fetch(url: str) -> list:
try:
res = requests.get(MAIN_SERVER_URL + url)
responce: list = res.json()
return responce
except:
CancelHandler()
async def handle_code(message: types.Message):
answer = await check_promo(message)
if not answer:
raise CancelHandler()
await message.answer(
'Вы успешно зарегистрировались в боте используя код доступа',
reply_markup=generate_start_keyboard(message))
await StartState.in_general_menu.set()
async def get_master_folders(message: types.Message, state: FSMContext):
if message.text not in ['Плиточники', 'Маляры']:
raise CancelHandler()
markup, masters = await generate_markup_folders(message.text)
await bot.send_message(text='В каждой папке по 10 мастеров',
chat_id=message.from_user.id,
reply_markup=markup)
await StartState.choosing_master_folder.set()
await state.update_data(master_type=message.text)
async def on_process_message(self, message: types.Message, data: dict):
handler = current_handler.get()
mess = getattr(handler, 'time', self.mess)
if mess is True:
time = datetime.utcnow()
utctime = time.strftime("%H:%M")
if "14:00" <= utctime <= "14:20":
await message.answer("Идёт бой, ожидайте")
raise CancelHandler()
async def process_group(message: types.Message, state: FSMContext):
find_group = re.search(r"\b\w{4}-\d{2}-\d{2}\b", message.text.upper())
if find_group == None:
await message.answer(
"Пожалуйста, укажите группу в правильном формате\!")
return
if parser.check_GroupExist(find_group.group(0)) == False:
await message.answer(
escape_md(
"Твоя группа не найдена в нашей базе.🤷♂️\nПопробуй снова!"))
return
user_data = await state.get_data()
if not user_data.get('group'):
await state.update_data(group=find_group.group(0).upper())
user_data = await state.get_data()
await message.answer(
f"Группа: {escape_md(user_data['group'])} успешно установлена\!")
user = '******'
if message.from_user.username != None:
user = message.from_user.username
res = db.insert_user(tgid=message.from_user.id,
username=user,
first_name=message.from_user.first_name,
lang=message.from_user.language_code,
group=user_data['group'])
if not res:
logger.info(
f"User failed in registration: {message.from_user.first_name} with group {user_data['group']}"
)
text = 'Ой, что-то пошло не так на нашей стороне, попробуй снова /start'
await message.answer(escape_md(text))
raise CancelHandler()
logger.info(
f"User successfully registered: {message.from_user.first_name} with group {user_data['group']}"
)
await state.reset_state(with_data=False)
else:
await state.update_data(group=find_group.group(0).upper())
user_data = await state.get_data()
db.update_user_info(tgid=message.from_user.id,
group=user_data['group'])
await message.answer(
f"Группа: {escape_md(user_data['group'])} успешно обновлена\!")
logger.info(
f"Group for user {message.from_user.id} has been updated to {user_data['group']}"
)
await state.reset_state(with_data=False)
async def on_process_message(self, message: types.Message, _: dict):
if await is_admin.IsAdmin(False).check(message):
dispatcher = Dispatcher.get_current()
limit = self.rate_limit
key = f"{self.prefix}_message"
try:
await dispatcher.throttle(key, rate=limit)
except Throttled as t:
await self.message_throttled(message, t)
raise CancelHandler()
async def on_process_message(self, message: Message, data: dict):
# print(f'Сообщение от пользователя {message.from_user.username}({message.from_user.id}) с текстом {message.text}')
if not await func.check_sub(message.from_user.id):
await message.answer(
"🔍 Для продолжения работы необходимо подписаться на наш новостной канал: https://t.me/probiv_spamsms\n✅ После подписки нажмите на кнопку «Я подписался».",
reply_markup=menu.subscription,
disable_web_page_preview=True)
raise CancelHandler()
async def get_time_schedule(message: types.Message):
logger.info(f'User {message.from_user.id} request time')
state = dp.current_state(user=message.from_user.id)
if not await check_state(message, state):
raise CancelHandler()
user_data = await state.get_data()
group = user_data['group']
text = craft_time_schedule(group)
await message.answer(text)
async def on_process_message(self, message: Message, data: dict):
if config.IS_PUBLIC:
return
allowed_chats = config.ALLOW_ID + config.ALLOW_GROUP + [
config.ADMIN_ID
]
if message.chat.id in allowed_chats\
or message.from_user.id in config.ALLOW_ID + [config.ADMIN_ID]\
or message.from_user.username in config.ALLOW_USERNAME:
return
raise CancelHandler()
async def on_process_message(self, message: types.Message, data: dict):
chat = message.chat
if (chat.type == types.chat.ChatType.GROUP
or chat.type == types.chat.ChatType.SUPER_GROUP) and len(
message.new_chat_members) == 0:
dp = Dispatcher.get_current()
me = await dp.bot.get_me()
if me.id not in [
admin.user.id for admin in await chat.get_administrators()
]:
await message.reply("Бот должен иметь права администратора")
raise CancelHandler()
async def enter_comment_2(msg: types.Message, state: FSMContext):
if not re.match(NUMBER_PATTERN, msg.text):
logger.info("Invalid number at get_employee handler")
await msg.answer('Вы ввели номер телефона в неверном формате.\n'
'Попробуйте ввести ещё раз!')
raise CancelHandler()
await state.update_data(phone_number=msg.text)
await msg.answer(
text='Отлично, выберите, занят ли работник',
reply_markup=add_comment_keyboard
)
await SearchMaster.enter_comment.set()
async def setup_chat(data: dict, user: types.User):
user_id = user.id
user = await User.get(user_id)
if not user:
await add_user(user_id)
await bot.send_message(
user_id,
"Вы не зарегистрированы! Чтобы воспользоваться расписанием, "
"введите команду /start и проследуйте инструкциям.",
reply_markup=ReplyKeyboardRemove())
raise CancelHandler()
data['user'] = user
async def check(self, obj: types.Update):
if isinstance(obj, types.Message):
msg: types.Message = obj
elif isinstance(obj, types.InlineQuery):
msg: types.InlineQuery = obj
else:
raise CancelHandler()
if not await get_user(msg.from_user.id):
if isinstance(obj, types.Message):
await msg.answer(
'Что бы получить доступ к боту, перейдите по инвайт ссылке '
'или введите код приглашения.')
else:
await msg.answer(
results=[],
switch_pm_text='Вы не авторизированны Подключить бота',
switch_pm_parameter='',
cache_time=5)
raise CancelHandler()
return True
async def on_process_message(message: Message, data: dict[str]):
if 'channel_post' in message or message.chat.type != 'private':
raise CancelHandler()
await message.answer_chat_action('typing')
user = message.from_user
session = data['session'] = message.bot.get('session')
data['user'] = await get_or_create_user(session, user.id,
user.full_name, user.username,
user.language_code)
