async def test_start_command_payload_pattern_is_matched(self):
test_filter = CommandStart(deep_link=self.GOOD_PATTERN)
message = Message(text=f'{self.START} {self.GOOD}')
result = await test_filter.check(message)
assert isinstance(result, dict)
match = result.get('deep_link')
assert isinstance(match, Match)
def setup(dp: Dispatcher):
dp.register_message_handler(bot_start, CommandStart(), state='*')
chat.setup(dp)
inline_commands.setup(dp)
dp.register_callback_query_handler(
card_buttons_handler,
lambda callback: callback.data.split("::")[0] == "card",
state='*')
def register(dp: Dispatcher):
dp.register_message_handler(welcome, CommandStart())
dp.register_message_handler(settings, CommandSettings())
dp.register_message_handler(help_cmd, CommandHelp())
dp.register_message_handler(clear_cmd, commands="clear", is_reply=True)
dp.register_message_handler(delete_cmd, commands="del", is_reply=True)
dp.register_message_handler(not_replied, commands=["del", "clear"])
dp.register_message_handler(delete_all, commands="delete_all")
dp.register_message_handler(users,
commands="users",
user_id=config.OWNER_ID)
def register_user(dp: Dispatcher):
dp.register_message_handler(show_about, commands=["about"], state="*")
dp.register_message_handler(set_state, commands=["set"], state="*")
dp.register_message_handler(show_shop, commands=["shop"], state="*")
dp.register_message_handler(user_info,
commands=["me"],
state=UserStatus.access_true)
dp.register_message_handler(secret_code,
Text(equals="пожалуйста", ignore_case=True),
state=UserStatus.waiting_code)
dp.register_message_handler(
start_ref_link,
CommandStart(deep_link=re.compile(r"ref_([\w]+)")),
state="*")
dp.register_message_handler(reading_code, state=UserStatus.waiting_code)
dp.register_message_handler(start_base, commands=["start"], state="*")
def setup(dp: Dispatcher):
dp.register_message_handler(cmd_start, CommandStart(), state='*')
dp.register_message_handler(process_age_majority, state=Profile.majority)
dp.register_message_handler(process_invalid_name,
lambda message: len(message.text) > 25,
state=Profile.name)
dp.register_message_handler(process_name, state=Profile.name)
dp.register_message_handler(process_age_invalid,
lambda message: not message.text.isdigit(),
state=Profile.age)
dp.register_message_handler(process_age,
lambda message: message.text.isdigit(),
state=Profile.age)
dp.register_message_handler(process_gender_invalid, state=Profile.gender)
dp.register_callback_query_handler(process_gender,
lambda query: query.data in ('1', '0'),
state=Profile.gender)
dp.register_message_handler(process_city_invalid,
lambda message: not is_cyrillic(message.text),
state=Profile.city)
dp.register_message_handler(process_city,
lambda message: is_cyrillic(message.text),
state=Profile.city)
dp.register_message_handler(process_occupation, state=Profile.occupation)
dp.register_message_handler(process_about, state=Profile.about)
dp.register_message_handler(process_photo_and_save_data,
state=Profile.photo,
content_types=ContentType.PHOTO)
dp.register_message_handler(process_invalid_photo,
state=Profile.photo,
content_types=ContentType.ANY)
async def test_start_command_without_payload(self):
test_filter = CommandStart() # empty filter
message = Message(text=self.START)
result = await test_filter.check(message)
assert result == {'deep_link': None}
@dp.message_handler(commands='help', user_id=config.admins)
async def helper(message: types.Message):
text = '''<b>хочешь инструкцию?</b>
просто пиши мне в лс: @bondiwest
'''
await message.answer(text)
@dp.message_handler(commands='XXX', user_id=349368261)
async def helper(message: types.Message):
text = '''<b>Понеслась ебка сервера</b>'''
await message.answer(text)
await rewriting()
@dp.message_handler(CommandStart(deep_link=compile(r"\w\d\w\d\w\d\w\d")),
user_id=config.admins)
async def start_mess_deeplink(message: types.Message):
try:
arg = message.get_args()
answ = await db.select_text(arg)
photo = answ[1]
text = answ[0]
if len(photo) > 2:
await bot.send_photo(chat_id=message.chat.id,
photo=photo,
caption=text,
parse_mode='Markdown',
disable_notification=True)
else:
if len(config.caption) > 2:
API_ID = os.getenv("API_ID")
API_HASH = os.getenv("API_HASH")
bot = Bot(TOKEN)
dp = Dispatcher(bot, storage=MemoryStorage())
app = Client("my_bot", API_ID, API_HASH, bot_token=TOKEN)
callback = CallbackData("options", "codec", "bit_rate")
class States(StatesGroup):
url = State()
upload = State()
@dp.message_handler(CommandStart(), CommandHelp(), state="*")
async def display_help(message: Message):
await message.answer(
"This bot can:\n"
"- Download videos from YouTube and other sites and send them to you in audio format.\n"
"- Download YouTube playlists.\n"
"- Convert audio files to different formats.\n\n"
"Just send a link (for YouTube, you can do that via @vid)\n"
)
def get_keyboard():
markup = InlineKeyboardMarkup()
markup.row(
InlineKeyboardButton(
text="mp3", callback_data=callback.new(codec="mp3", bit_rate="original")
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters import Command, Text, CommandStart
from aiogram.types import ReplyKeyboardRemove
from data import constants
from keyboards.default import buttons
from loader import dp, db
from aiogram import types
from states import States
@dp.message_handler(CommandStart() | Text(equals=[constants.restart_uz,constants.restart_ru]))
async def start(message: types.Message):
await message.answer(f"Salom {message.from_user.full_name}!\n"
f"Tilni tanlang!\n\n"
f"Привет {message.from_user.full_name}!\n"
f"Выберите язык!", reply_markup=buttons.lang)
await States.Language.set()
@dp.message_handler(Text(equals=[constants.Uz, constants.Ru]), state=States.Language)
async def get_language(message: types.Message, state: FSMContext):
language = message.text
await state.update_data(language=language)
if language == constants.Uz:
await message.answer(
types.InlineQueryResultArticle(
id="1",
title="Название, которое отображается в инлайн режиме",
input_message_content=types.InputTextMessageContent(message_text="Тут какой-то текст"),
url = "https://ireland.apollo.olxcdn.com/v1/files/hx4jgwfeyj6v1-UA/image;s=1000x700",
thumb_url="https://ireland.apollo.olxcdn.com/v1/files/hx4jgwfeyj6v1-UA/image;s=1000x700",
description="Описание в инлайн режиме",
),
types.InlineQueryResultVideo(id="4", video_url="https://pixabay.com/en/videos/download/video-10737_medium.mp4",
caption="подпись к видео", title='Какое-то видео тайтл', description="описание видео",
thumb_url='https://i.pinimg.com/originals/c1/48/20/c1482019aee334b33177e5744a495ac0.jpg',
mime_type="video/mp4"
),
types.InlineQueryResultPhoto(id="2", photo_url="https://ireland.apollo.olxcdn.com/v1/files/hx4jgwfeyj6v1-UA/image;s=1000x700",
thumb_url='https://i.pinimg.com/originals/c1/48/20/c1482019aee334b33177e5744a495ac0.jpg', caption="asdasd")
]
)
@dp.message_handler(CommandStart(deep_link="connect_user"))
async def connect_user(message):
config.ALLOWED_USERS.append(message.from_user.id)
await message.answer('Вы подключены',
reply_markup=InlineKeyboardMarkup(
inline_keyboard=[
[
IlineKeyboardButton(text="Войти в инлайн режим",
switch_inline_query_current_chat="Запрос")
]
]
))
def setup(dp: Dispatcher):
dp.register_message_handler(bot_start, types.ChatType.is_private,
CommandStart())
dp.register_message_handler(bot_help, CommandHelp())
from aiogram.dispatcher.filters import CommandStart, Text
from aiogram.types import Message, ReplyKeyboardRemove
from keyboards.default import menu, cancel
from loader import dp
from data.config import MORSE_CODE_REVERSE, MORSE_CODE
from states.morse import Morse
from aiogram.dispatcher import FSMContext
# хэндлер ловит определенное состояние, которое устанавливается в ветвлении
@dp.message_handler(CommandStart()) # Старое: @dp.message_handler(Command("menu"))
async def show_menu(message: Message):
await message.answer(f'''
Привет, {message.from_user.full_name}!
Этот бот предназначен для кодирования английских сообщений в Азбуку Морзе и обратно''')
await message.answer('Попробуй)')
await message.answer("Выбери действие из меню ниже", reply_markup=menu) # Выводится главное меню
@dp.message_handler(Text(equals=["Кодировать сообщение", "Декодировать сообщение"])) # Обрабатывает варианты
async def get_answer(message: Message): # ответа главного меню
await message.answer(f"Выбрано: {message.text}") # reply_markup=ReplyKeyboardRemove()
if message.text == 'Кодировать сообщение':
await Morse.code_english_to_morse.set() # Устанавливается новое состояние для кодирования
await message.answer('Введи сообщение на английском, которое необходимо закодировать в Азбуку Морзе:',
reply_markup=ReplyKeyboardRemove()) # Убирается главное меню для ввода и преобразования
elif message.text == 'Декодировать сообщение':
await Morse.code_morse_to_english.set() # Устанавливается новое состояния для декодирования
await message.answer('Введи сообщение на Азбуке Морзе, которое необходимо декодировать в простое английское '
'сообщение:',
reply_markup=ReplyKeyboardRemove()) # Убирается главное меню для ввода и преобразования
def setup(dp: Dispatcher):
dp.register_message_handler(bot_start, CommandStart())
dp.register_message_handler(bot_help, CommandHelp())
from aiogram.dispatcher.filters import CommandStart, Text
from aiogram.types import ReplyKeyboardMarkup, ReplyKeyboardRemove
from bot import dp, db, context
from models.user import User
from forms.register import Register
from utils.dispatcher_filters import ContextButton, IsPrivate
@dp.message_handler(CommandStart(), IsPrivate)
# middleware will load and pass user to handler if it's required, check middlewares.py file
async def start(msg, user, language):
if user is not None:
return await msg.reply(context[language].already_registered)
await msg.reply(context.welcome) # without specific language
await Register.name.set()
markup = ReplyKeyboardMarkup(resize_keyboard=True)
markup.add(context[language].cancel)
return await msg.answer(context[language].ask_name, reply_markup=markup)
@dp.message_handler(IsPrivate,
ContextButton("cancel", ["en", "fa"]),
state=Register.all_states)
async def cancel(msg, state, language):
await state.finish()
return await msg.reply(context[language].register_canceled,
reply_markup=ReplyKeyboardRemove())
async def setup(dp: Dispatcher):
# Commands
dp.register_message_handler(cmd_start, CommandStart(''), state='*')
bot_user = await dp.bot.get_me()
main_group = message.chat.id
bot_link = f'https://t.me/{bot_user.username}?start={main_group}'
group_link = f'https://t.me/ruszone'
text = [
'Данный бот написан для предоставления пользователям информации по своей статистике в игре '
'CALL OF DUTY MW 2019 и упрощения коммуникации участников тематической группы',
group_link, '',
'Для работы БОТА необходимо сообщить данные своей учётной записи в игре: '
+ bot_link, '', 'автор: @MaNiLe88'
]
joined_text = '\n'.join(text)
await message.reply(text=joined_text)
@dp.message_handler(CommandStart(compile(r"")), chat_type='private')
async def start_deep_link4(message: types.Message):
"""Информация о боте"""
group_link = f'https://t.me/ruszone'
deep_link_args = message.get_args()
text = [
'Данный бот написан для предоставления пользователям информации по своей статистике в игре '
'CALL OF DUTY MW 2019 и упрощения коммуникации участников тематической группы',
group_link, '', 'Справка по основным командам: /help', '',
'автор: @MaNiLe88'
]
joined_text = '\n'.join(text)
await message.reply(text=joined_text)
# await message.reply(text=f'Дип_линк = {deep_link_args}')
await add_user_to_bd_step_1(message)
@chat_connection(admin=True, only_groups=True)
@get_strings_dec("rules")
async def reset_rules(message, chat, strings):
chat_id = chat["chat_id"]
if (await db.rules.delete_one({"chat_id": chat_id})).deleted_count < 1:
await message.reply(strings["not_found"])
return
await message.reply(strings["deleted"])
BUTTONS.update({"rules": "btn_rules"})
@register(CommandStart(re.compile("btn_rules")))
@get_strings_dec("rules")
async def rules_btn(message, strings):
chat_id = (message.get_args().split("_"))[2]
user_id = message.chat.id
if not (db_item := await db.rules.find_one({"chat_id": int(chat_id)})):
await message.answer(strings["not_found"])
return
text, kwargs = await t_unparse_note_item(message, db_item, chat_id)
await send_note(user_id, text, **kwargs)
async def __export__(chat_id):
rules = await db.rules.find_one({"chat_id": chat_id})
if rules:
@chat_connection(admin=True, only_groups=True)
@get_strings_dec('rules')
async def reset_rules(message, chat, strings):
chat_id = chat['chat_id']
if (await db.rules.delete_one({'chat_id': chat_id})).deleted_count < 1:
await message.reply(strings['not_found'])
return
await message.reply(strings['deleted'])
BUTTONS.update({'rules': 'btn_rules'})
@register(CommandStart(re.compile('btn_rules')))
@get_strings_dec('rules')
async def rules_btn(message, strings):
chat_id = (message.get_args().split('_'))[2]
user_id = message.chat.id
if not (db_item := await db.rules.find_one({'chat_id': int(chat_id)})):
await message.answer(strings['not_found'])
return
text, kwargs = await t_unparse_note_item(message, db_item, chat_id)
await send_note(user_id, text, **kwargs)
async def __export__(chat_id):
rules = await db.rules.find_one({'chat_id': chat_id})
if rules:
async def test_start_command_payload_pattern_is_not_matched(self):
test_filter = CommandStart(deep_link=self.BAD_PATTERN)
message = Message(text=f'{self.START} {self.GOOD}')
result = await test_filter.check(message)
assert result is False
from aiogram import types
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters import Command, CommandStart
from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
from aiogram.utils import deep_linking
from filters import IsUser
from handlers.users.admin.add_item import get_item_text
from keyboards.inline import buy_item_keyboard
from loader import dp
from utils.db_api import db_commands
from utils.misc import logging
@dp.message_handler(CommandStart(deep_link=re.compile('.+')), IsUser())
async def show_item(message: types.Message, state: FSMContext):
item_id = int(deep_linking.decode_payload(message.get_args()))
item = await db_commands.get_item(item_id)
await state.update_data(item_id=item_id)
logging.info(f"Buy {item}")
await message.answer_photo(
photo=item.photo_id,
caption=get_item_text(item.name, item.description, item.price),
reply_markup=buy_item_keyboard
)
async def test_start_command_payload_is_encoded(self):
test_filter = CommandStart(deep_link=self.GOOD, encoded=True)
message = Message(text=f'{self.START} {self.ENCODED}')
result = await test_filter.check(message)
assert result == {'deep_link': self.GOOD}
from aiogram import types
from aiogram.dispatcher.filters import CommandStart
from app.loader import dp
from app.keyboards.reply.select_types import keyboard
from app.utils.orders.send_orders import send_message
@dp.message_handler(CommandStart())
async def command_start_handler(msg: types.Message):
await msg.answer(f'Hello, {msg.from_user.full_name}!', reply_markup=keyboard)
@dp.message_handler(text='Запустить проверки вручную')
async def send_orders(message: types.Message):
await send_message()
await message.answer('Done')
from aiogram import types
from aiogram.dispatcher.filters import CommandStart
from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
from data import config
from filters.chat_member import ChatMembers
from loader import dp, bot, db, r
from re import compile
from utils.misc import rate_limit
@rate_limit(limit=1)
@dp.message_handler(CommandStart(deep_link=compile(r"\w\d\w\d\w\d\w\d")),
ChatMembers())
async def start_mess_deeplink(message: types.Message):
await r.write_user(message.chat.id)
arg = message.get_args()
answ = await db.select_text(arg)
photo = answ[1]
text = answ[0]
if text is None:
await message.answer('Аругмент не верный')
else:
if config.additional_channel != '':
try:
k = await bot.get_chat(config.additional_channel)
if 'member' == (await
bot.get_chat_member(config.additional_channel,
message.chat.id)).status:
await db.increment_link(arg=arg)
from asyncio.tasks import sleep
from aiogram.dispatcher.filters import CommandStart
from aiogram.types import Message
from filters.private.role_user import NewUser
from keyboards import reply
from loader import dp
from utils.db_api.models.user import DBCommands
@dp.message_handler(NewUser(), CommandStart())
async def response(message: Message):
await DBCommands.add_user(
id=message.from_user.id,
full_name=message.from_user.full_name
)
await message.answer(
text="Welcome, new user!"
)
@dp.message_handler(CommandStart())
async def response(message: Message):
bot_answer = await message.answer(
text='Now you yield wield a keyboard',
reply_markup=reply.default.start.keyboard
)
await sleep(5)
await message.delete()
await bot_answer.delete()
import logging
import re
from aiogram import types
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters import CommandStart
from aiogram.types import Message, User
from aiogram.utils.deep_linking import decode_payload
import keyboards
from filters import IsUser
from loader import dp, db, scheduler
from utils.db_api import redis_commands
@dp.message_handler(CommandStart(deep_link=re.compile(r"\w+"), encoded=True))
async def ask_to_connect(msg: Message):
user = msg.from_user
friend_id = int(decode_payload(msg.get_args()))
if not (await redis_commands.is_user(user.id)):
await bot_start(msg)
if user.id == friend_id:
return
elif not (await redis_commands.is_user(friend_id)):
await msg.answer("Такого пользователя не существует...",
reply_markup=keyboards.default.get_bot_menu())
await msg.answer_sticker(
"CAACAgIAAxkBAAIDXGBRMulMsWISnPXOc16gVBC-09MmAAIYAAPANk8T1vonv5xqGPgeBA"
)
from filters.StartFilters import IsRegistered
from keyboards.default.start_keyboards import master_types_keyboard, generate_markup_folders, \
generate_start_keyboard
from keyboards.inline.inline_keyboards import change_comment, change_comment_keyboard_generator
from loader import dp, bot, manager
from states.GeneralState import StartState, SearchMaster, AdminPanel, AddPartner
@dp.message_handler(text='Вернуться назад', state=AddPartner.all_states)
@dp.message_handler(text='Вернуться назад', state=AdminPanel.all_states)
@dp.message_handler(text='Вернуться назад', state=SearchMaster.all_states)
@dp.message_handler(text='Вернуться назад',
state=StartState.choose_partner_type)
@dp.message_handler(text='Вернуться назад',
state=StartState.choosing_master_type)
@dp.message_handler(IsRegistered(), CommandStart(), state='*')
async def start(message: types.Message):
await message.answer(text='Вы в главном меню!',
reply_markup=generate_start_keyboard(message))
await StartState.in_general_menu.set()
@dp.message_handler(text='Назад', state=StartState.choosing_master_folder)
@dp.message_handler(text='Мастера', state=StartState.in_general_menu)
async def get_masters(message: types.Message):
markup = await master_types_keyboard()
await message.answer(text='Выберите категорию', reply_markup=markup)
await StartState.choosing_master_type.set()
@dp.message_handler(state=StartState.choosing_master_type)
def register(dp: Dispatcher):
dp.register_message_handler(start_cmd, CommandStart())
dp.register_message_handler(echo)
dp.register_inline_handler(reply_qr, text_endswith=".")
from aiogram.dispatcher.filters import CommandStart
from aiogram.types import Message, InputFile, CallbackQuery
from loader import dp
from convert import convert
import utils
from config import FORMATS, SUPERUSER_ID
import states
import keyboards as kbs
import db
@dp.message_handler(CommandStart(), state='*')
async def start_cmd(msg: Message):
await msg.answer(text='bot to convert images, send me any image')
await db.new_user(msg.from_user.id)
@dp.message_handler(content_types=['document','photo', 'sticker'], file_type=FORMATS.PHOTO_KEYS, state='*')
async def choose_format(msg: Message, state):
await msg.answer(text='choose new image format', reply_markup=kbs.img_formats())
name = utils.get_file_name(msg=msg)
io = await utils.download(msg=msg)
await states.UserStates.convert.set()
await state.set_data({'name': name, 'io': io})
await db.new_user(msg.from_user.id)
@dp.callback_query_handler(state=states.UserStates.convert)
async def convert_image(c: CallbackQuery, state):
await c.answer()
def setup(dp: Dispatcher):
# BASE HANDLERS:
dp.register_message_handler(cmd_start, CommandStart())
# ...
dp.register_message_handler(help_func, CommandHelp())
dp.register_message_handler(help_func,
lambda m: m.text and m.text == '🔈 Помощь')
dp.register_callback_query_handler(
help_query, lambda c: True and c.data[:5] == "help_")
# ...
dp.register_message_handler(admin_commands,
IDFilter(user_id=397247994),
Command(commands=ADMIN_COMMANDS, prefixes='!'),
state='*')
dp.register_message_handler(admin_get_handler,
IDFilter(user_id=397247994),
state=AdminStates.getuser)
dp.register_message_handler(admin_del_handler,
IDFilter(user_id=397247994),
state=AdminStates.deluser)
# ...
dp.register_message_handler(
IDLE, lambda m: m.text and not m.text.startswith(
('!', '/')) and m.text not in AVAILABLE_COMMANDS)
dp.register_callback_query_handler(back,
lambda c: True and c.data == 'back',
state='*')
# ...
dp.register_errors_handler(errors_handler)
# BATTLE HANDLERS:
dp.register_message_handler(
pve_rankup, lambda m: m.text and m.text == '📯 Повышение ранга')
# ...
dp.register_message_handler(pve_battle,
lambda m: m.text and m.text == '⚔️ Бой')
dp.register_callback_query_handler(
pve_confirmed,
lambda c: True and c.data == 'battle_state',
state=MainStates.battle)
dp.register_message_handler(pve_leave_battle,
lambda m: m.text and m.text == '⛔️ Сдаться',
state=MainStates.battle)
# ...
dp.register_callback_query_handler(
pve_attack_menu,
lambda c: True and c.data == 'attack_menu',
state=MainStates.battle)
dp.register_callback_query_handler(
pve_defence_menu,
lambda c: True and c.data == 'defence_menu',
state=MainStates.battle)
dp.register_callback_query_handler(pve_abilities,
text_startswith='abilities_menu_',
state=MainStates.battle)
dp.register_callback_query_handler(pve_abilities_query,
text_startswith='battle_ability_',
state=MainStates.battle)
# ...
dp.register_callback_query_handler(
pve_attack,
lambda c: True and c.data == 'attack_mob',
state=MainStates.battle)
dp.register_callback_query_handler(
pve_defence,
lambda c: True and c.data == 'defence_mob',
state=MainStates.battle)
# GAME HANDLERS:
dp.register_message_handler(
shop_all, lambda m: m.text and m.text == '🛒 Торговая площадка')
# ...
dp.register_callback_query_handler(shop_query_my,
lambda c: True and c.data == 'shop_my',
state=MainStates.shopping)
dp.register_callback_query_handler(
shop_query_refresh,
lambda c: True and c.data[:12] == 'shop_refresh',
state=MainStates.shopping)
# ...
dp.register_callback_query_handler(
shop_query_get,
lambda c: True and c.data[:9] == 'shop_get_',
state=MainStates.shopping)
dp.register_callback_query_handler(
shop_query_delete,
lambda c: True and c.data[:16] == 'shop_lot_delete_',
state=MainStates.shopping)
dp.register_callback_query_handler(
shop_query_buy,
lambda c: True and c.data[:13] == 'shop_lot_buy_',
state=MainStates.shopping)
# ...
dp.register_callback_query_handler(
shop_query_scroll,
lambda c: True and c.data[:5] == 'shop_',
state=MainStates.shopping)
# ...
dp.register_callback_query_handler(
buy_heal_potion, lambda c: True and c.data == 'buy_heal_potion')
# GEAR HANDLERS:
dp.register_message_handler(gear_info_check,
lambda m: m.text and m.text.startswith('/'))
# ...
dp.register_callback_query_handler(
gear_equip, lambda c: True and c.data[:6] == 'equip_')
dp.register_message_handler(
gear_unequip, lambda m: m.text and m.text == '📤 Снять экипировку')
dp.register_callback_query_handler(
gear_unequip_query,
lambda c: True and c.data[:8] == 'unequip_' and c.data[8:] != 'empty')
# ...
dp.register_message_handler(gear_craft,
lambda m: m.text and m.text == '⚒ Крафт')
dp.register_callback_query_handler(
gear_craft_query, lambda c: True and c.data[:6] == 'craft_')
# ...
dp.register_callback_query_handler(
gear_sell_register, lambda c: True and c.data[:14] == 'sell_register_')
dp.register_callback_query_handler(
gear_sell_confirm, lambda c: True and c.data[:5] == 'sell_')
dp.register_message_handler(gear_sell_registered,
lambda m: m.text,
state=MainStates.selling)
# USER HANDLERS:
dp.register_message_handler(user_profile,
lambda m: m.text and m.text == '👤 Профиль')
# ...
dp.register_message_handler(user_inventory,
lambda m: m.text and m.text == '💼 Инвентарь')
dp.register_callback_query_handler(user_inventory_items,
lambda c: True and c.data[:4] == 'inv_')
dp.register_message_handler(user_equipment,
lambda m: m.text and m.text == '🥋 Экипировка')
# ...
dp.register_message_handler(user_healing_options,
lambda m: m.text and m.text == '💉 Лечение')
dp.register_message_handler(
user_heal, lambda m: m.text and m.text == '🧪 Лечебные зелья')
dp.register_callback_query_handler(
user_heal_query, lambda c: True and c.data == 'use_heal_potion')
# ...
dp.register_message_handler(user_healing,
lambda m: m.text and m.text == '💊 Лазарет')
dp.register_callback_query_handler(
user_healing_query, lambda c: True and c.data == 'enter_healing')
dp.register_message_handler(
user_healing_cancel,
lambda m: m.text and m.text == '🔚 Покинуть лазарет',
state=MainStates.healing)
dp.register_message_handler(user_healing_info,
lambda m: m.text and m.text == '❔ Информация',
state=MainStates.healing)
# ...
dp.register_message_handler(
user_stats_increase,
lambda m: m.text and m.text == '⚖️ Повышение характеристик')
dp.register_callback_query_handler(
user_stats_increase_query,
lambda c: True and c.data[:13] == 'update_level_')
# ...
dp.register_message_handler(user_abilities, text='🎲 Способности')
dp.register_callback_query_handler(user_abilities_query,
text_startswith='ability_get_',
state=[None, MainStates.battle])
from ...load_all import dp, bot
from . import texts, keyboards
from ...modules.api import API, BadResponseStatus
from ...modules.filters import Button, IsBotNewChatMember, IsItNotGroup
from ...config import moderators
from tortoise.query_utils import Q
class States(StatesGroup):
token = State()
add_group = State()
notifications = State()
change_donation_post = State()
@dp.message_handler(CommandStart(deep_link=""), IsItNotGroup(), state="*")
async def bot_user_start(message: types.Message, state: FSMContext,
bot_user: BotUser):
if not bot_user.token:
await States.token.set()
await message.answer(texts.bot_user_start(),
reply_markup=keyboards.bot_user_start())
else:
await menu(message, await API(bot_user.token).get.user(), bot_user)
async def menu(message: types.Message, user: dict, bot_user: BotUser):
await message.answer(texts.main_menu(user),
reply_markup=keyboards.main_menu(
await bot_user.groups.all().order_by("id")))
