def init_bot():
"""
"""
bot = Bot(token=BOT_TOKEN)
dp = Dispatcher(bot)
dp.middleware.setup(LoggingMiddleware())
return bot, dp
def setup(dispatcher: Dispatcher):
logger.info("Configure middlewares...")
from app.misc import i18n
dispatcher.middleware.setup(LoggingMiddleware("bot"))
dispatcher.middleware.setup(ACLMiddleware())
dispatcher.middleware.setup(i18n)
def setup(dp: Dispatcher, config: dict, pool: sessionmaker):
environment_data = {
"config": config,
}
dp.setup_middleware(LoggingMiddleware())
dp.setup_middleware(EnvironmentMiddleware(context=environment_data))
dp.setup_middleware(DatabaseMiddleware(pool))
dp.setup_middleware(DataMiddleware())
def start_polling():
dispatcher = Dispatcher(bot.obj)
dispatcher.middleware.setup(LoggingMiddleware())
admin.init(dispatcher)
auth.init(dispatcher)
cashier.init(dispatcher)
executor.start_polling(dispatcher, skip_updates=True)
def setup():
"""Set API token from config to bot and setup dispatcher."""
with open(config.TOKEN_FILENAME, "r") as token_file:
tg._ctx_token.set(token_file.read().strip())
dp.storage = MongoStorage()
i18n.reload()
dp.middleware.setup(i18n)
logging.basicConfig(level=config.LOGGER_LEVEL)
dp.middleware.setup(LoggingMiddleware())
async def main():
bot = Bot(token=settings.telegram_token)
dp = Dispatcher(bot, storage=MemoryStorage())
dp.middleware.setup(LoggingMiddleware())
dp.middleware.setup(AccessMiddleware(settings.telegram_chat_id))
register_handlers_notify(dp)
register_handlers_bonds(dp)
await set_commands(bot)
notify_listener = RedisListener()
try:
await asyncio.gather(dp.start_polling(),
notify_listener.start(bot=bot, queue=settings.redis_notification_queue))
finally:
await dp.storage.close()
await dp.storage.wait_closed()
await bot.close()
def set_up_app() -> None:
"""
:return:
"""
logging.basicConfig(filename="base.log", level=logging.INFO)
log = logging.getLogger("bot")
uvloop.install()
vars_json = var.Var()
loop = asyncio.get_event_loop()
loop.run_until_complete(
vars_json.set_var_from_file(path=os.path.abspath("config.json")))
bot = Bot(token=vars_json.token,
loop=loop,
parse_mode=types.ParseMode.HTML)
dp = Dispatcher(bot, storage=MemoryStorage())
dp.middleware.setup(LoggingMiddleware())
register(dp=dp, logger=log)
executor.start_polling(dp, on_shutdown=shutdown, loop=loop)
def setup(dispatcher: Dispatcher):
dispatcher.middleware.setup(LoggingMiddleware("bot"))
dispatcher.middleware.setup(ContextMiddleware())
def setup(dispatcher: Dispatcher, debug: bool = False):
dispatcher.middleware.setup(DBMiddleware())
if debug:
dispatcher.middleware.setup(LoggingMiddleware())
def main() -> NoReturn:
dispatcher.middleware.setup(LoggingMiddleware(logger))
dispatcher.middleware.setup(AccessMiddleware(ACCESS_IDS))
executor.start_polling(dispatcher, skip_updates=True, timeout=60)
def setup(dp: Dispatcher):
dp.middleware.setup_handlers(LoggingMiddleware())
dp.middleware.setup_handlers(FSMMiddleware())
logger.info('Middlewares are successfully configured')
from aiogram.contrib.middlewares.logging import LoggingMiddleware
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram.types import *
from aiogram.utils.helper import HelperMode
from config import settings
from crypto.btc import make_keys
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger('bot')
bot = Bot(token=settings.telegram.token, parse_mode=types.ParseMode.HTML)
storage = RedisStorage2()
dp = Dispatcher(bot, storage=storage)
dp.middleware.setup(LoggingMiddleware(logger))
class SwapStates(StatesGroup):
mode = HelperMode.snake_case
START = State()
ASK_SOURCE = State()
ASK_DEST = State()
ASK_DEST_ADDRESS = State()
CONFIRM = State()
FINISHED = State()
@dp.message_handler(content_types=types.ContentTypes.STICKER, state='*')
async def handle_sticker(message: types.Message, state: FSMContext):
from aiogram.contrib.middlewares.logging import LoggingMiddleware from misc import disp disp.middleware.setup(LoggingMiddleware(__name__)) """ Logging middleware is used to log bot-related events """
from aiogram import Bot, Dispatcher
from aiogram.contrib.fsm_storage.memory import MemoryStorage
from aiogram.contrib.middlewares.logging import LoggingMiddleware
from aiogram.types import ParseMode
from aiogram.utils.executor import Executor
import sentry_sdk
from core import config
from core.packages import PackagesLoader
from mixpanel import Mixpanel
logging.basicConfig(level=logging.INFO)
log = logging.getLogger('{{cookiecutter.bot_name}}')
loop = asyncio.get_event_loop()
bot = Bot(config.bot_token, parse_mode=ParseMode.HTML, validate_token=False)
storage = MemoryStorage()
dp = Dispatcher(bot, storage=storage, loop=loop)
runner = Executor(dp, skip_updates=config.skip_updates)
loader = PackagesLoader()
dp.middleware.setup(LoggingMiddleware('bot'))
mp = Mixpanel(config.mixpanel_key)
if config.sentry_url:
sentry_sdk.init(config.sentry_url)
def setup(dp: Dispatcher):
dp.middleware.setup(i18n.i18n)
dp.middleware.setup(client_middleware.ClientMiddleware())
dp.middleware.setup(LoggingMiddleware())
from aiogram.types import Message, ContentTypes
from aiogram.utils import executor
from lesson14_telegram_bot.config import TOKEN
BOT_DIR = Path(__file__).resolve().parent
STICKERS_DIR: Path = BOT_DIR / "stickers"
STICKERS_DIR.mkdir(exist_ok=True)
logging.basicConfig(level=logging.DEBUG)
bot = Bot(TOKEN)
dp = Dispatcher(bot)
logging_middleware = LoggingMiddleware()
dp.middleware.setup(logging_middleware)
@dp.message_handler()
async def echo_message(message: Message):
return await message.answer(message.text)
# await bot.send_message()
@dp.message_handler(content_types=ContentTypes.PHOTO)
async def echo_photo(message: Message):
return await message.answer_photo(
message.photo[-1].file_id,
caption=f"You wrote: {message.caption!r}",
)
from aiogram import executor, types, Dispatcher, filters
from models import *
from config import bot
from aiogram.contrib.middlewares.logging import LoggingMiddleware
from lang import Lang
from utils.graber import swaps_worker
import re
import logging
logging.basicConfig(format='%(asctime)s %(message)s', level=logging.INFO)
log = logging.getLogger()
dp = Dispatcher(bot)
logger_middleware = LoggingMiddleware()
dp.middleware.setup(logger_middleware)
@dp.message_handler(lambda x: x.reply_markup)
async def pass_msg_with_btns(message):
pass
@dp.message_handler(commands=['live', 'blive'])
async def live_handler(message: types.Message):
try:
_, pair = message.text.split()
if match := re.match(r"0x\w{40}", pair):
live_obj = await LiveGate.create(chat_id=message.chat.id,
active=True)
live_obj.pair = match.group(0)
from aiogram import executor, types, Dispatcher
from StateHandler import StateHandler
from CallbackHandler import CallbackHandler
from InlineSearchHandler import InlineSearchHandler, ProcessChosen
from models.db import User
from config import bot, logger
from aiogram.contrib.middlewares.logging import LoggingMiddleware
from lang import Lang
dp = Dispatcher(bot)
logger_middleware = LoggingMiddleware()
logger_middleware.logger = logger
dp.middleware.setup(logger_middleware)
@dp.message_handler(
lambda x: x.text in [Lang.inline_send_file, Lang.inline_empty_result
] or x.reply_markup)
async def pass_msg_with_btns(message):
pass
@dp.message_handler(commands=['start'])
async def start_cmd_handler(message: types.Message):
user = await User(message.from_user).create()
user['state'] = "start"
await StateHandler(user, message, first=True)
@dp.message_handler(content_types=['text', 'photo', 'location', 'document'])
def middlewares_setup(dispatcher: Dispatcher):
logger.info("Configure middlewares")
dispatcher.middleware.setup(LoggingMiddleware("bot"))
dispatcher.middleware.setup(ACLMiddleware())
def setup(dp: Dispatcher):
logger.info("Configure middlewares...")
dp.middleware.setup(ThrottlingMiddleware())
dp.middleware.setup(LoggingMiddleware())
logger.info("Middlewares are successfully configured")
from aiogram import Dispatcher from aiogram.contrib.middlewares.logging import LoggingMiddleware from ppm_telegram_bot.telegram.bot import bot dispatcher = Dispatcher(bot) dispatcher.middleware.setup(LoggingMiddleware())
def register(dispatcher: Dispatcher, session: orm.Session) -> None:
dispatcher.middleware.setup(LoggingMiddleware("bot"))
dispatcher.middleware.setup(ACLMiddleware(session))
def build_bot(app):
# pylint: disable=unused-variable
bot = aiogram.Bot(token=BOT_TOKEN)
dp = aiogram.Dispatcher(bot)
dp.middleware.setup(LoggingMiddleware())
async def get_page(user_id, page=1):
keyboard = aiogram.types.InlineKeyboardMarkup()
async with get_database_connection(user_id) as db:
async with db.execute(
f'SELECT question FROM questions ORDER BY id LIMIT 6 OFFSET {(page - 1) * 6}'
) as cursor:
async for row in cursor:
keyboard.row(
aiogram.types.InlineKeyboardButton(
text=row[0], callback_data=row[0][:32]))
keyboard.row(*[
aiogram.types.InlineKeyboardButton(text=wrap_if(
f'{opage * 6 - 5}–{opage * 6}', page == opage),
callback_data=f'page:{opage}')
for opage in range(1, 4)
])
return keyboard
@dp.inline_handler()
async def search(inline_query: aiogram.types.InlineQuery):
if not inline_query.query:
return AnswerInlineQuery(inline_query.id, [])
user_id = inline_query.from_user.id
if not database_exists(user_id):
return AnswerInlineQuery(
inline_query.id, [],
is_personal=True,
cache_time=3,
switch_pm_text='Авторизуйтесь с персональной ссылкой')
results = []
try:
async with get_database_connection(user_id) as db:
if "'" in inline_query.query:
print("support: hacking attempt",
user_id,
inline_query.query.encode(),
flush=True)
async with db.execute(
'SELECT * FROM questions WHERE question LIKE \'%' +
inline_query.query + '%\' LIMIT 50') as cursor:
async for row in cursor:
if len(results) == 50:
break
results.append(
aiogram.types.InlineQueryResultArticle(
id=f'{user_id}-{gen_id(row)}',
title=row[1],
input_message_content=aiogram.types.
InputTextMessageContent(
f'\u2753 *{row[1]}*\n\n\U0001F4AC {row[2]}',
parse_mode='Markdown'),
reply_markup=aiogram.types.
InlineKeyboardMarkup(inline_keyboard=[[
aiogram.types.InlineKeyboardButton(
text='\U0001F44D Спасибо!',
callback_data='like')
]]),
description=truncate(row[2])))
except aiosqlite.OperationalError:
pass
return AnswerInlineQuery(inline_query.id,
results,
is_personal=True,
cache_time=20)
@dp.callback_query_handler()
async def navigate(callback_query: aiogram.types.CallbackQuery):
user_id = callback_query.from_user.id
if callback_query.data == 'like':
return AnswerCallbackQuery(callback_query.id,
text='Ваше мнение очень важно для нас!',
show_alert=True)
if callback_query.data.startswith('page:'):
try:
page = int(callback_query.data[5:])
except ValueError:
return AnswerCallbackQuery(callback_query.id,
text='Нет такой страницы',
show_alert=True)
questions = await get_page(user_id, page)
try:
await bot.edit_message_text(
'Выберите интересующий вас вопрос:',
user_id,
callback_query.message.message_id,
reply_markup=questions)
except aiogram.utils.exceptions.MessageNotModified:
pass
else:
async with get_database_connection(user_id) as db:
async with db.execute(
'SELECT * FROM questions WHERE question LIKE \'' +
callback_query.data + '%\' LIMIT 1') as cursor:
async for row in cursor:
await bot.edit_message_text(
f'\u2753 *{row[1]}*\n\n\U0001F4AC {row[2]}',
user_id,
callback_query.message.message_id,
parse_mode='Markdown',
reply_markup=aiogram.types.InlineKeyboardMarkup(
inline_keyboard=[[
aiogram.types.InlineKeyboardButton(
text='\U0001F44D Спасибо!',
callback_data='like')
]]))
return AnswerCallbackQuery(callback_query.id)
@dp.message_handler()
async def echo(message: aiogram.types.Message):
user_id = message.from_user.id
if message.get_command() == '/start' and message.get_args() != '':
try:
token = message.get_args()
except ValueError:
return SendMessage(
user_id,
'Пожалуйста, используйте вашу персональную ссылку для входа.'
)
if not verify_token(token):
return SendMessage(
user_id,
'Ваша персональная ссылка устарела. Обратитесь в центр Клиентской Поддержки.'
)
await init_database(user_id, token)
text = 'Добро пожаловать в Департамент клиентской поддержки! Выберите интересующий вас вопрос:'
else:
text = 'К сожалению, все операторы отсутствуют. Ваш вопрос очень важен для нас, поэтому ответ на него наверняка найдётся ниже:'
if not database_exists(user_id):
return SendMessage(
user_id,
'Пожалуйста, используйте вашу персональную ссылку для входа.')
questions = await get_page(user_id)
return SendMessage(user_id, text, reply_markup=questions)
async def startup(_):
await bot.set_webhook(f'{HOST}{WEBHOOK_PATH}')
async def shutdown(_):
await bot.delete_webhook()
aiogram.utils.executor.set_webhook(dp,
WEBHOOK_PATH,
on_startup=startup,
on_shutdown=shutdown,
skip_updates=True,
web_app=app)
def register_middlewares(dp: Dispatcher):
dp.middleware.setup(AuthMiddleware())
dp.middleware.setup(LoggingMiddleware())
def setup(dp: Dispatcher):
dp.middleware.setup(ThrottlingMiddleware())
dp.middleware.setup(LoggingMiddleware())
def __init__(self, bot_token, telegram_client: SmartTelegramClient):
""" __init simply calls constructor of aiogram.Bot(),
with the token provided as an argument,
telegram_client is passed as well, so that bot would have access to the clients account
and would be able to add or remove orders,
get reports, change transfer rules, change preferences, etc
:param bot_token: Bots Token provided by botfather
:param telegram_client: The SmartTelegramClient instance which bot is supposed to control
"""
# webhook settings
self.WEBHOOK_HOST = 'https://smart-replier-staging.herokuapp.com/'
self.WEBHOOK_PATH = 'webhook/' + os.environ.get('TG_BOT_TOKEN')
self.WEBHOOK_URL = urljoin(self.WEBHOOK_HOST, self.WEBHOOK_PATH)
self.WEBAPP_HOST = '0.0.0.0'
self.WEBAPP_PORT = os.environ.get('PORT', 3000)
self.bot = Bot(token=bot_token)
self.dp = Dispatcher(bot=self.bot, storage=MemoryStorage())
self.dp.middleware.setup(LoggingMiddleware())
self.client = telegram_client
self.order_type = None
self.order_amount = None
self.order_opening_price = None
self.order_limit_price = None
self.order_today_tomorrow = None
# only allowed_ids can access inner_states
# self.allowed_ids = [550379443, 167539602, 760034850]
self.inner_states = BotStates.DEFAULT or \
BotStates.ENTER_TYPE or BotStates.ENTER_AMOUNT or \
BotStates.ENTER_PRICE or BotStates.ENTER_TODAY_TOMORROW or \
BotStates.SEARCH_MODE or BotStates.TRANSFER_MODE
# TODO OPENING_TIME and CHECK_OUT_TIME should be written to a file!
self.OPENING_TIME = time(10, 0)
self.CHECK_OUT_TIME = time(13, 15)
# General Buttons ==============================================================
@self.dp.message_handler(commands=['start'], state='*')
async def start_cmd(message: types.Message):
# sender = message.from_user['id']
# if sender not in self.allowed_ids:
# await message.reply("403! ACCESS FORBIDDEN!")
# await BotStates.PERMISSION_DENIED.set()
# else:
await message.reply("خوش آمدید!", reply_markup=keyboards.main_kb)
await BotStates.DEFAULT.set()
@self.dp.message_handler(commands=['help'], state=self.inner_states)
@self.dp.message_handler(lambda msg: msg.text == 'بازگشت',
state=self.inner_states)
@self.dp.message_handler(lambda msg: msg.text == 'بازگشت',
state=BotStates.ENTER_TYPE)
@self.dp.message_handler(lambda msg: msg.text == 'بازگشت',
state=BotStates.ENTER_AMOUNT)
@self.dp.message_handler(lambda msg: msg.text == 'بازگشت',
state=BotStates.ENTER_PRICE)
@self.dp.message_handler(lambda msg: msg.text == 'بازگشت',
state=BotStates.ENTER_TODAY_TOMORROW)
@self.dp.message_handler(lambda msg: msg.text == 'بازگشت',
state=BotStates.TRANSFER)
@self.dp.message_handler(lambda msg: msg.text == 'بازگشت',
state=BotStates.CHANGE_OPENING)
@self.dp.message_handler(lambda msg: msg.text == 'بازگشت',
state=BotStates.CHANGE_CHECKOUT)
async def help_cmd(message: types.Message):
if not self.is_order_none():
self.order_clear()
reply_message = self.client.account.account_status(
) + '\n' + self.settings_review() + 'دستور خود را وارد کنید.'
await message.reply(reply_message, reply_markup=keyboards.main_kb)
await BotStates.DEFAULT.set()
# Buy and Sell Buttons ========================================================
@self.dp.message_handler(lambda msg: msg.text == 'خرید و فروش',
state=BotStates.DEFAULT)
async def check_existing_order(message: types.Message):
if self.client.account.has_active_order():
reply_message = 'شما یک سفارش ناتمام دارید. \n سفارش مورد نظر:\n'
reply_message += self.client.account.get_last_order(
).short_report()
await message.reply(reply_message,
reply_markup=keyboards.order_active_kb)
else:
reply_message = 'سفارش فعالی وجود ندارد. '
await message.reply(reply_message,
reply_markup=keyboards.order_inactive_kb)
@self.dp.message_handler(lambda msg: msg.text == 'ایجاد سفارش جدید',
state=BotStates.DEFAULT)
@self.dp.message_handler(
lambda msg: msg.text == 'رها کردن سفارش قبلی و ایجاد سفارش جدید',
state=BotStates.DEFAULT)
async def ready_for_new_order(message: types.Message):
# TODO cancel_order should send NUN if needed!
response = await self.client.cancel_order()
if response == 0:
await message.reply('سفارش با موفقیت کنسل شد.')
reply_message = '❕ نوع سفارش را وارد کنید.'
await message.reply(reply_message,
reply_markup=keyboards.order_type_kb)
await BotStates.ENTER_TYPE.set()
@self.dp.message_handler(state=BotStates.ENTER_TYPE)
async def add_order_type(message: types.Message):
if message.text == 'خرید':
self.order_type = 'buy'
elif message.text == 'فروش':
self.order_type = 'sell'
reply_message = self.order_review()
reply_message += '❕ مقدار سفارش را وارد کنید.'
await message.reply(reply_message,
reply_markup=keyboards.cancel_kb)
await BotStates.ENTER_AMOUNT.set()
@self.dp.message_handler(state=BotStates.ENTER_AMOUNT)
async def add_order_amount(message: types.Message):
if str(message.text).isdigit():
self.order_amount = int(message.text)
reply_message = self.order_review()
reply_message += '❕ قیمت شروع و قیمت مرزی را وارد کنید.' + '\n'
reply_message += '(با فاصله) مثال: ۲۵ ۴۰'
await message.reply(reply_message,
reply_markup=keyboards.cancel_kb)
await BotStates.ENTER_PRICE.set()
else:
await message.reply('مقدار تشخیص داده نشد!',
reply_markup=keyboards.cancel_kb)
@self.dp.message_handler(state=BotStates.ENTER_PRICE)
async def add_order_price(message: types.Message):
prices = Translate.get_prices(str(message.text))
if prices is not None:
if self.order_type == 'buy':
self.order_opening_price = prices[0]
self.order_limit_price = prices[1]
elif self.order_type == 'sell':
self.order_opening_price = prices[1]
self.order_limit_price = prices[0]
reply_message = self.order_review()
if is_time_between(self.OPENING_TIME, self.CHECK_OUT_TIME,
datetime.now().time()):
reply_message += '❕ امروزی یا فردایی؟'
await message.reply(
reply_message,
reply_markup=keyboards.order_today_tomorrow_kb)
else:
reply_message += 'از ساعت تسویه حساب گذشته است. \nفقط سفارش امروزی ممکن میباشد.'
await message.reply(reply_message,
reply_markup=keyboards.order_today_kb)
await BotStates.ENTER_TODAY_TOMORROW.set()
else:
await message.reply('قیمتها تشخیص داده نشد!',
reply_markup=keyboards.cancel_kb)
@self.dp.message_handler(state=BotStates.ENTER_TODAY_TOMORROW)
async def add_order_today_tomorrow(message: types.Message):
if message.text == 'امروزی':
self.order_today_tomorrow = 'today'
elif message.text == 'فردایی' and is_time_between(
self.OPENING_TIME, self.CHECK_OUT_TIME,
datetime.now().time()):
self.order_today_tomorrow = 'tomorrow'
reply_message = self.order_review()
self.client.account.new_order(self.order_type, self.order_amount,
self.order_opening_price,
self.order_limit_price,
self.order_today_tomorrow)
reply_message += 'سفارش با موفقیت اضافه شد!'
await message.reply(reply_message,
reply_markup=keyboards.cancel_kb)
await BotStates.DEFAULT.set()
@self.dp.message_handler(lambda msg: msg.text == 'توقف سفارش',
state=self.inner_states)
async def cancel_order(message: types.Message):
response = self.client.account.cancel_order()
if response == 0:
await message.reply('سفارش با موفقیت کنسل شد.',
reply_markup=keyboards.main_kb)
elif response == -1:
await message.reply('سفارشی برای کنسل شدن یافت نشد.',
reply_markup=keyboards.main_kb)
# Transfer Buttons ===========================================================
@self.dp.message_handler(lambda msg: msg.text == 'جابهجایی',
state=BotStates.DEFAULT)
async def transfer_cmd(message: types.Message):
reply_message = 'جابهجایی '
if self.client.account.is_transfer_active():
reply_message += 'فعال است!' + '\n'
reply_message += 'دستور خود را وارد کنید'
await message.reply(reply_message,
reply_markup=keyboards.transfer_active_kb)
else:
reply_message += 'غیر فعال است!' + '\n'
reply_message += 'دستور خود را وارد کنید'
await message.reply(
reply_message, reply_markup=keyboards.transfer_inactive_kb)
await BotStates.TRANSFER.set()
@self.dp.message_handler(lambda msg: msg.text == 'فعال کردن جابهجایی',
state=BotStates.TRANSFER)
async def transfer_turn_on(message: types.Message):
if (self.client.account.transfer
is not None) and (self.client.account.transfer.is_active):
await message.reply('جابهجایی از قبل فعال است!',
reply_markup=keyboards.cancel_kb)
else:
self.client.account.new_transfer()
await message.reply('جابهجایی با موفقیت فعال شد!',
reply_markup=keyboards.cancel_kb)
@self.dp.message_handler(
lambda msg: msg.text == 'غیر فعال کردن جابهجایی',
state=BotStates.TRANSFER)
async def transfer_turn_off(message: types.Message):
if not self.client.account.transfer.is_active:
await message.reply('جابهجایی از قبل غیر فعال است!',
reply_markup=keyboards.cancel_kb)
else:
self.client.account.transfer.turn_off()
await message.reply('جابهجایی با موفقیت غیر فعال شد!',
reply_markup=keyboards.cancel_kb)
# Report Buttons =============================================================
@self.dp.message_handler(lambda msg: msg.text == 'گزارش',
state=self.inner_states)
async def report(message: types.Message):
await message.reply('گزارش کدام مورد؟',
reply_markup=keyboards.report_kb)
@self.dp.message_handler(
lambda msg: msg.text == 'گزارش خرید و فروشها',
state=self.inner_states)
async def report_order(message: types.Message):
await message.reply('شیوهی گزارشدهی را انتخاب کنید',
reply_markup=keyboards.report_order_kb)
@self.dp.message_handler(lambda msg: msg.text == '۵ سفارش آخر',
state=self.inner_states)
async def report_last_5(message: types.Message):
response = self.client.account.orders_report_by_num(5)
await message.reply(response, reply_markup=keyboards.cancel_kb)
@self.dp.message_handler(
lambda msg: msg.text == 'جست و جو بر اساس سفارش',
state=self.inner_states)
async def report_by_name(message: types.Message):
await BotStates.SEARCH_MODE.set()
await message.reply('برای جست و جو شرح سفارش را وارد کنید:',
reply_markup=keyboards.cancel_kb)
@self.dp.message_handler(state=BotStates.SEARCH_MODE)
async def report_complete(message: types.Message):
response = self.client.account.orders_report_by_name(message.text)
await message.reply(response, reply_markup=keyboards.main_kb)
await BotStates.DEFAULT.set()
@self.dp.message_handler(lambda msg: msg.text == 'گزارش جابهجاییها',
state=self.inner_states)
async def report_transfer(message: types.Message):
# TODO add transfer report
await message.reply(self.client.account.transfer_report(),
reply_markup=keyboards.cancel_kb)
# SETTINGS Buttons =============================================================
@self.dp.message_handler(lambda msg: msg.text == 'تنظیمات',
state=BotStates.DEFAULT)
async def change_settings(message: types.Message):
reply_message = self.settings_review()
reply_message += 'دستور خود را وارد کنید.'
await message.reply(reply_message,
reply_markup=keyboards.settings_kb)
@self.dp.message_handler(lambda msg: msg.text == 'تغییر ساعت شروع',
state=BotStates.DEFAULT)
async def ready_change_opening(message: types.Message):
reply_message = self.settings_review()
reply_message += 'ساعت شروع جدید را وارد کنید. \n(بین ۰ تا ۲۳)'
reply_message += 'مثال: ' + '10:00'
await message.reply(reply_message,
reply_markup=keyboards.cancel_kb)
await BotStates.CHANGE_OPENING.set()
@self.dp.message_handler(lambda msg: msg.text == 'تغییر ساعت تسویه',
state=BotStates.DEFAULT)
async def ready_change_checkout(message: types.Message):
reply_message = self.settings_review()
reply_message += 'ساعت تسویه جدید را وارد کنید. \n(بین ۰ تا ۲۳)'
reply_message += 'مثال: ' + '۱۳:۴۰'
await message.reply(reply_message,
reply_markup=keyboards.cancel_kb)
await BotStates.CHANGE_CHECKOUT.set()
@self.dp.message_handler(state=BotStates.CHANGE_OPENING)
async def change_opening(message: types.Message):
new_opening = Translate.get_time(message.text)
if new_opening is not None:
self.OPENING_TIME = new_opening
reply_message = 'ساعت شروع با موفقیت تغییر یافت.'
await message.reply(reply_message,
reply_markup=keyboards.cancel_kb)
await BotStates.DEFAULT.set()
@self.dp.message_handler(state=BotStates.CHANGE_CHECKOUT)
async def change_checkout(message: types.Message):
new_checkout = Translate.get_time(message.text)
if new_checkout is not None:
self.CHECK_OUT_TIME = new_checkout
reply_message = 'ساعت تسویه با موفقیت تغییر یافت.'
await message.reply(reply_message,
reply_markup=keyboards.cancel_kb)
await BotStates.DEFAULT.set()
from models import User, Serial
loop = asyncio.get_event_loop()
loop.run_until_complete(
asyncio.gather(User.init_manager(Config.RDB),
Serial.init_manager(Config.RDB)))
log = create_logger("bot")
logging.getLogger("aiogram").setLevel(logging.INFO)
bot = Bot(token=Config.BOT["token"], loop=loop)
# For example use simple MemoryStorage for Dispatcher.
storage = MemoryStorage()
dp = Dispatcher(bot, storage=storage)
dp.middleware.setup(LoggingMiddleware())
# States
NAME = "process_name"
VOICE = "process_voice"
@dp.callback_query_handler(
state="*", func=lambda x: x.data and x.data.endswith("_search_page"))
async def callback_serials_page(callback_query: types.CallbackQuery):
log.debug(f"Change page")
message = callback_query.message
state = dp.current_state(chat=message.chat.id)
data = await state.get_data()
log.debug(f"Change page state: {data}")
def setup(dispatcher: Dispatcher, config: Config):
logger.info("Configure middlewares...")
dispatcher.middleware.setup(
DBMiddleware(tg_client_config=config.tg_client))
dispatcher.middleware.setup(ConfigMiddleware(config))
dispatcher.middleware.setup(LoggingMiddleware())
