async def statisticsCallingCallbackHandler(callback_query: CallbackQuery,
isUpdate: bool = False):
message = callback_query.message
buttonsData = [["Обновить", "update"], ["←Назад", "back"]]
buttons = buttonsList(buttonsData, rowWidth=2)
reply_markup = inline_keyboard.InlineKeyboardMarkup(
row_width=2, inline_keyboard=buttons)
userStats = getUserStats(userID=callback_query.from_user.id)
text = markdown.bold("Ваша статистика:\n\n") + \
"Создано демотиваторов — " + markdown.italic(f"{userStats['demoCreated']}\n") + \
"Выполнено inline\-комманд — " + markdown.italic(f"{userStats['inlineAnswered']}\n")
try:
await bot.edit_message_text(text=text,
reply_markup=reply_markup,
parse_mode='MarkdownV2',
chat_id=message.chat.id,
message_id=message.message_id)
if isUpdate:
await callback_query.answer(text="Статистика обновлена")
except exceptions.MessageNotModified:
await callback_query.answer(text="Статистика не поменялась")
async def _get_seats_number(message: types.Message, state: FSMContext):
logger.info('User %s has set seats: %s', message.from_user.username,
message.text)
async with state.proxy() as data:
seats = message.text.split(',')
data['seats'] = seats
logger.info('Current state: %s', data)
markup = types.ReplyKeyboardMarkup(resize_keyboard=True,
selective=True)
markup.add("OK", "CANCEL")
await TicketOrderState.next()
msg = md.text(md.text('Всё правильно?'),
md.text(md.italic('Станция отправления: '),
md.code(data['from_station'])),
md.text(md.italic('Станция прибытия: '),
md.code(data['to_station'])),
md.text(md.italic('Дата отправления: '),
md.code(data['date'])),
md.text(md.italic('Номер вагона: '),
md.code(data['wagon_number'])),
md.text(md.italic('Бронируемые места: '),
md.code(','.join(data['seats']))),
sep='\n')
await message.reply(msg,
reply_markup=markup,
parse_mode=types.ParseMode.MARKDOWN)
async def process_iEvents(callback_query: types.CallbackQuery):
message_text = text(
bold('МЕРОПРИЯТИЯ 📌'), '\n\n1. Спортивное программирование',
italic('\nКогда: каждую пятницу в 16:00',
'\nГде: 13 кабинет'), '\n\n2. Открытие',
italic('\nКогда: каждую пятницу в 17:30', '\nГде: 13 кабинет'),
'\n\n3. Командный турнир ЦДЮТТ', italic('\nКогда: в конце апреля'))
await bot.send_message(callback_query.from_user.id,
message_text,
parse_mode=ParseMode.MARKDOWN)
async def process_age(message: types.Message, state: FSMContext):
await Form.next()
await state.update_data(age=int(message.text))
await bot.send_message(message.chat.id,
md.italic("3⃣Из какого вы города?🏭"),
parse_mode=ParseMode.MARKDOWN)
async def get_logs(message: types.Message):
check_id(message.from_user)
logger.info(f"{message.from_user.username} do getlog command")
if message.from_user.id == ADMIN_ID:
try:
int(message.text[9:])
except ValueError:
await message.chat.do(types.ChatActions.UPLOAD_DOCUMENT)
await message.reply_document(types.InputFile(f"logs/current.log"),
caption="The logs file",
reply_markup=key)
else:
await message.chat.do(types.ChatActions.TYPING)
logs = (open(f"logs/current.log",
"r").readlines())[-int(message.text[9:]):]
log = str()
for i in logs:
log += i
msg = markdown.text(markdown.italic("logs:"),
markdown.code(log),
sep="\n")
try:
await message.reply(msg,
parse_mode=ParseMode.MARKDOWN,
reply_markup=key)
except MessageIsTooLong:
await message.reply(markdown.bold("Too much logs ! ❌"),
reply_markup=key)
async def get_enumerated_list(dicts_list: list, key: str, start_with=1):
enumerated_list = list()
for number, data_dict in enumerate(dicts_list, start_with):
text = await update_image_sources(data_dict[key])
enumerated_list.append(
md.text(md.bold("/", number, sep=""), md.italic(text)))
return enumerated_list
async def updateNickname(message: Message, state: FSMContext) -> None:
if len(message.text) <= 20: # ограничение БД
userID = message.from_user.id
new_nickname = message.text
change_nickname(userID, new_nickname)
await message.answer(markdown.italic('Никнейм изменён на ') +
markdown.bold(f'{new_nickname}') + '.',
parse_mode='markdown')
### ПАСХАЛ(ОЧКА) ###
if message.text.lower() == 'попа':
await message.answer(
"Ого! Ты знаешь об этой секретной функции? Тогда тебе от меня тоже сюрприз!"
)
await message.answer('https://t.me/addstickers/rnfoxbot')
### ПАСХАЛ(ОЧКА) ###
# получение callback_query для изменения сообщения-настроек
async with state.proxy() as data:
callback_query = data['callback_query']
message = callback_query.message
await state.finish()
await settingsCallingHandler(message, isBack=True, userID=userID)
else:
await message.answer("Можно покороче?")
def __init__(self, product: Product, product_filters: ProductFilters, locale: str):
self.product = product
self.product_filters = product_filters
self._pictures_links = [picture.pic for picture in self.product.pictures]
self._product_link = md_link(self.product.name, self.product.url)
self._new_text = italic(_("New")) if self.product.is_new else ""
self._price_text = self.product.format_price(locale)
async def check_language(message: types.Message):
name = "test"
text = markdown.text(markdown.bold("{name}".format(name=name)),
markdown.text(' 🔸', markdown.bold('Code:'),
markdown.italic("RUS")),
sep='\n')
await message.reply(text)
async def any_format(message: types.Message):
msgtext = text(emojize("Я не знаю, что с этим делать :astonished:"),
italic('Я просто напомню, что есть'), code('команда'),
"/help")
await bot.send_message(message.from_user.id,
msgtext,
parse_mode=ParseMode.MARKDOWN)
async def cmd_start(message: types.Message):
# Create a temporary session
session = bot.create_temp_session()
content = []
# Make request (without proxy)
async with session.get(GET_IP_URL) as response:
content.append(
text(':globe_showing_Americas:', bold('IP:'),
code(await response.text())))
# This line is formatted to '🌎 *IP:* `YOUR IP`'
# Make request through proxy
async with session.get(GET_IP_URL,
proxy=bot.proxy,
proxy_auth=bot.proxy_auth) as response:
content.append(
text(':locked_with_key:', bold('IP:'), code(await response.text()),
italic('via proxy')))
# This line is formatted to '🔐 *IP:* `YOUR IP` _via proxy_'
# Send content
await bot.send_message(message.chat.id,
emojize(text(*content, sep='\n')),
parse_mode=ParseMode.MARKDOWN)
# Destroy temp session
bot.destroy_temp_session(session)
async def process_help_command(message: types.Message):
r = requests.get('https://back.qliento.com/news/')
data = json.loads(r.text)
msg = data[0]
picture = msg['image']
msgg = text(bold(msg['name'])) + '\n' + text(italic(msg['description']))
await message.reply(msgg, parse_mode=ParseMode.MARKDOWN)
await bot.send_photo(message.chat.id, types.InputFile.from_url(picture))
async def process_phone(message: types.Message, state: FSMContext):
await Form.next()
await state.update_data(phone=int(message.text))
await bot.send_message(
message.chat.id,
md.italic("5⃣Напишите, чтобы вы хотели заказть из меню📘"),
parse_mode=ParseMode.MARKDOWN)
async def process_city(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['city'] = message.text
await Form.next()
await bot.send_message(message.chat.id,
md.italic("4⃣Введите свой номер телефона📱"),
parse_mode=ParseMode.MARKDOWN)
async def unknown_message(msg: types.Message):
'''
echo bot for not message
'''
message_text = md.text(
emojize('I do not know what to do about it :astonished:'),
md.italic('\nI will just remind,'), 'you that there',
md.code('is a command'), '/help')
await msg.reply(message_text, parse_mode=types.ParseMode.MARKDOWN)
async def online_123(message: types.Message):
text1 = message.from_user.get_mention() + ', ты лучше всех!!!'
await message.answer(text1, parse_mode=ParseMode.MARKDOWN)
text2 = bold('Я могу ответить на следующие команды:') + italic(' но отвечать на них я не буду')
await message.answer(text2, parse_mode=ParseMode.MARKDOWN, disable_notification=True)
# text3 = message.from_user.id
# me = await dp.bot.get_chat_member(chat_id=COD_CHAT_ID, user_id=ADMIN_ID)
text5 = await message.chat.get_member(user_id=ADMIN_ID)
print(text5['user'])
async def eval_cmd(message: types.Message):
check_id(message.from_user)
logger.info(f"{message.from_user.username} do eval command")
if message.from_user.id == ADMIN_ID:
msg = markdown.text(markdown.italic("eval:"),
markdown.code(eval(message.text[6:])),
sep="\n")
await message.reply(msg,
parse_mode=ParseMode.MARKDOWN,
reply_markup=key)
async def send_right_answers(message: Message, question: dict):
response = requests.get("{}/questions/{}/answers".format(
config.host, question["id"]),
params={"where:status": "R"})
if response.status_code != 200:
await message.reply(md.bold(
emojize(
"К сожалению я пока не знаю ответа на этот вопрос :confused:")
),
reply=False,
parse_mode=ParseMode.MARKDOWN)
else:
media_group_content, right_answers_text, ps_message = list(), list(
), ""
title_text, title_photos = (await update_image_sources(
question["title"], False)).values()
media_group_content.extend(title_photos)
answers = response.json()["data"][0]["variants"]
for answer in answers:
answer_text, answer_photos = (await update_image_sources(
answer[-1], False, len(media_group_content))).values()
right_answers_text.append(
md.bold(emojize(":white_check_mark:"), answer_text))
media_group_content.extend(answer_photos)
if media_group_content:
ps_message = md.text(
"\n",
md.bold("P.S."),
" Текст может не отображать полной информации из картинок,",
" поэтому ниже я отправил изображения из теста.",
sep="")
await message.reply(md.text(md.text(
emojize(":nerd_face: Я нашел ответ на вопрос:")),
md.italic(title_text),
*right_answers_text,
ps_message,
sep="\n"),
reply=False,
parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True)
if media_group_content:
media_group = MediaGroup()
photos_map = map(lambda mgc: mgc[1], media_group_content)
names_map = map(lambda mgc: mgc[0], media_group_content)
media_group.attach_many(*photos_map)
media_group_messages = await message.reply_media_group(media_group,
reply=False)
for photo_name, photo_message in zip(names_map,
media_group_messages):
if (await file_id_storage.get_file_id(photo_name)) is None:
await file_id_storage.set_file_id(
photo_name, photo_message.photo[-1].file_id)
async def unknown_message(msg: types.Message):
message_text = text(emojize('Я не знаю, что с этим делать :astonished:'),
italic('\nЯ просто напомню,'), 'что есть',
code('команда'), '/help')
if msg.content_type == "text":
with open("source/history.txt", 'a') as f:
f.write(
str(msg.date) + " [" + str(msg.chat.id) + "] " +
msg.chat.first_name + ": " + msg.text + "\n")
await msg.reply(message_text, parse_mode=ParseMode.MARKDOWN)
async def process_contact(message: types.Message):
keyboards = InlineKeyboardMarkup(row_width=2, one_time_keyboard=True)
btn1 = InlineKeyboardButton(text='Вконтакте', url='https://vk.com/')
btn2 = InlineKeyboardButton(text='Инстаграм',
url='https://www.instagram.com/')
keyboards.add(btn1, btn2)
await bot.send_message(message.chat.id,
md.italic(
'Как с нами связаться📲\n'
'Наш телефон: +7911888888📞\n'
'Наш адресс: ул.Достоевског, д.15, оф.48🏢'),
reply_markup=keyboards,
parse_mode=ParseMode.MARKDOWN)
async def get_db(message: types.Message):
check_id(message.from_user)
logger.info(f"{message.from_user.username} do getdb command")
if message.from_user.id == ADMIN_ID:
with Session as session:
users = dict()
for u in session.query(User).all():
users[u] = u.__dict__
msg = markdown.text(markdown.italic("db:"),
markdown.code(users),
sep="\n")
await message.reply(msg,
parse_mode=ParseMode.MARKDOWN,
reply_markup=key)
async def process_name(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['name'] = message.text
await Form.next()
greet_kb = ReplyKeyboardMarkup(resize_keyboard=True,
one_time_keyboard=True)
button_cancel = ('/Отменить❌')
greet_kb.add(button_cancel)
await bot.send_message(message.chat.id,
md.italic(
f"2⃣Отлично, {message.from_user.first_name}\n"
"Сколько тебе лет?🔞"),
reply_markup=greet_kb,
parse_mode=ParseMode.MARKDOWN)
async def OrInlineQueryHandler(inline_query: InlineQuery):
answer = orDecider(inline_query.query).capitalize()
messToUser = markdown.bold(
inline_query.query) + '\n' + markdown.italic(answer)
items = [
InlineQueryResultArticle(id=str(time()),
title='Лис выбрал слово...',
description=inline_query.query,
thumb_url=foxLogoPreview,
input_message_content=InputTextMessageContent(
messToUser, parse_mode='MarkdownV2'))
]
await bot.answer_inline_query(inline_query.id, results=items, cache_time=0)
async def cmd_start(message: types.Message):
await Form.name.set()
greet_kb = ReplyKeyboardMarkup(resize_keyboard=True,
one_time_keyboard=True)
button_cancel = ('/Отменить❌')
greet_kb.add(button_cancel)
await bot.send_message(
message.chat.id,
md.italic(
"Если вы ознакомились с нашим меню, то для заполнения заявки нужно указать свои данные📝\n"
"Чтобы мы могли с вами связаться, вводите пожалуйста точную информаци, спасибо😊\n"
"Если вы ввели не те данные, нажмите Отменить❌\n"
"1⃣Введите свои инициалы(ФИО)"),
reply_markup=greet_kb,
parse_mode=ParseMode.MARKDOWN)
async def process_iOlimp(callback_query: types.CallbackQuery):
message_text = text(
'❗Участие в олимпиадах даёт право поступления в ВУЗ без вступительных испытаний или школьник получает 100 баллов по профильному предмету олимпиады.',
bold('\n\nПОЛЕЗНЫЕ РЕСУРСЫ ДЛЯ ПОДГОТОВКИ К ОЛИМПИАДАМ 💡'),
'\nolimpiada.ru - всё об олимпиадах для школьников'
'\npostypashki.ru - подготовка к олимпиадам, ЕГЭ и ДВИ'
'\nfoxford.ru - онлайн-школа'
'\nshkolkovo.net - образовательный портал для подготовки к ЕГЭ, ОГЭ, и олимпиадам'
'\nmathus.ru - материалы по математике: подготовка к олимпиадам и ЕГЭ',
bold('\n\nБЛИЖАЙШИЕ ОЛИМПИАДЫ:'),
'\n1. Командный турнир ЦДЮТТ (по 3 человека)',
italic('\nКогда: в конце апреля'))
await bot.send_message(callback_query.from_user.id,
message_text,
parse_mode=ParseMode.MARKDOWN,
reply_markup=kb.intexBack)
async def process_strength(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['strength'] = message.text
await Form.next()
greet_kb = ReplyKeyboardMarkup(resize_keyboard=True,
row_width=1,
one_time_keyboard=True)
button_cancel = ('/Отменить❌')
button_not = ('Нет')
greet_kb.add(button_cancel, button_not)
await bot.send_message(
message.chat.id,
md.text(md.italic("7⃣Вы хотели бы забронировать стол?⌚\n"),
"Если да то напишите дату, например 14.06.20 в 14:00"),
reply_markup=greet_kb,
parse_mode=ParseMode.MARKDOWN)
async def cmd_start(message: types.Message):
content = []
# Make request (without proxy)
ip = await fetch(GET_IP_URL)
content.append(text(':globe_showing_Americas:', bold('IP:'), code(ip)))
# This line is formatted to '🌎 *IP:* `YOUR IP`'
# Make request through proxy
ip = await fetch(GET_IP_URL, bot.proxy, bot.proxy_auth)
content.append(
text(':locked_with_key:', bold('IP:'), code(ip), italic('via proxy')))
# This line is formatted to '🔐 *IP:* `YOUR IP` _via proxy_'
# Send content
await bot.send_message(message.chat.id,
emojize(text(*content, sep='\n')),
parse_mode=ParseMode.MARKDOWN)
async def cmd_start(message: types.Message):
# fetching urls will take some time, so notify user that everything is OK
await types.ChatActions.typing()
content = []
# Make request (without proxy)
async with aiohttp.ClientSession() as session:
ip = await fetch(GET_IP_URL, session)
content.append(text(':globe_showing_Americas:', bold('IP:'), code(ip)))
# This line is formatted to '🌎 *IP:* `YOUR IP`'
# Make request through bot's proxy
ip = await fetch(GET_IP_URL, bot.session)
content.append(text(':locked_with_key:', bold('IP:'), code(ip), italic('via proxy')))
# This line is formatted to '🔐 *IP:* `YOUR IP` _via proxy_'
# Send content
await bot.send_message(message.chat.id, emojize(text(*content, sep='\n')), parse_mode=ParseMode.MARKDOWN)
async def qrInlineHandler(inline_query: InlineQuery):
awaitingButton = inline_keyboard.InlineKeyboardButton(
'Ожидайте...', callback_data='awaiting')
awaitingKeyboard = inline_keyboard.InlineKeyboardMarkup(
row_width=1).insert(awaitingButton)
items = [
InlineQueryResultPhoto(
id=str(time() + 1),
photo_url="https://i.ibb.co/n16zcs0/rnfoxbot-QR.jpg",
thumb_url='https://i.ibb.co/KsbFqjG/rnfoxbot-QR.jpg',
photo_width=200,
photo_height=200,
caption=markdown.italic("QR—code генерируется..."),
reply_markup=awaitingKeyboard,
parse_mode='MarkdownV2')
]
await bot.answer_inline_query(inline_query.id, results=items, cache_time=0)
async def randNumInlineQueryHandler(inline_query: InlineQuery):
num = [
int(i) for i in inline_query.query.lower().replace("num", "").split()
]
randomNumber = str(randint(num[0], num[1]))
messToUser = markdown.italic(f"Случайное число от {num[0]} до {num[1]}:") + '\n' + \
markdown.bold(f'{randomNumber}')
items = [
InlineQueryResultArticle(
id=str(time()),
title=f'Случайное число от {num[0]} до {num[1]}:',
thumb_url=foxLogoPreview,
description=f"{num[0]}, {num[1]}\n"
f"Что же он выберет?",
input_message_content=InputTextMessageContent(
messToUser, parse_mode='MarkdownV2'))
]
await bot.answer_inline_query(inline_query.id, results=items, cache_time=0)
