async def choose_sell(message: types.Message, state: FSMContext):
"""Set currency user wants to sell and ask for price."""
if message.text.startswith(emojize(":fast_reverse_button:")):
await OrderCreation.buy.set()
await tg.send_message(
message.chat.id,
i18n("ask_buy_currency"),
reply_markup=whitelist.currency_keyboard("buy"),
)
return
elif message.text.startswith(emojize(":x:")):
await cancel_order_creation(message.from_user.id, message.chat.id)
return
match = await match_currency("sell", message)
if not match:
return
order = await database.creation.find_one_and_update(
{"user_id": message.from_user.id, "buy": {"$ne": match}},
{"$set": {"sell": match, "price_currency": "sell"}},
return_document=ReturnDocument.AFTER,
)
if not order:
await tg.send_message(
message.chat.id,
i18n("same_currency_error"),
reply_markup=whitelist.currency_keyboard("sell"),
)
return
await set_price_state(message, order)
async def choose_sell_gateway(message: types.Message, state: FSMContext):
"""Set gateway of sell currency and ask for price."""
if message.text.startswith(emojize(":fast_reverse_button:")):
await OrderCreation.previous()
await tg.send_message(
message.chat.id,
i18n("ask_sell_currency"),
reply_markup=whitelist.currency_keyboard("sell"),
)
return
elif message.text.startswith(emojize(":x:")):
await cancel_order_creation(message.from_user.id, message.chat.id)
return
elif not message.text.startswith(emojize(":fast_forward:")):
order = await set_gateway("sell", message)
if not order:
return
else:
order = await database.creation.find_one_and_update(
{"user_id": message.from_user.id},
{"$set": {"price_currency": "sell"}},
return_document=ReturnDocument.AFTER,
)
await set_price_state(message, order)
async def answer_question(msg: types.Message):
global nq, tq
if msg.from_user.id in teams['user_id'].to_list():
team = teams.loc[teams['user_id'] == msg.from_user.id].index[0]
if nq != 0:
ta = int(time.time() - tq)
if ta < 61:
if pd.isna(teams['1_point' + str(nq)][team]):
answer = str(questions['answer'][nq]).lower().split('/ ')
if msg.text.lower() in answer:
await msg.reply('Вы ответили - "' + msg.text + '" за ' + str(int(ta)) + ' секунд')
teams['2_answer' + str(nq)][team] = msg.text
teams['3_time' + str(nq)][team] = int(ta)
teams['1_point' + str(nq)][team] = 1
else:
await msg.reply('Вы ответили - "' + msg.text + '" за ' + str(int(ta)) + ' секунд')
teams['2_answer' + str(nq)][team] = msg.text
teams['3_time' + str(nq)][team] = int(ta)
teams['1_point' + str(nq)][team] = 0
else:
await msg.reply(emojize(':man_shrugging:Вы уже ответили - "' + str(teams['2_answer' + str(nq)][team]) + '" /help'))
else:
await msg.reply(emojize(":hourglass:Время истекло! Ответы больше не принимаются. /help"))
else:
await msg.reply(emojize(":no_entry:Вопрос еще не задан! /help"))
def keyboard_factory(query_type, inline_query="", name=ANY_NAME):
keyboard_markup = types.InlineKeyboardMarkup()
search_text = {
QueryType.COMMAND: "Search by character",
QueryType.INLINE: "Search Again",
}
search_button = types.InlineKeyboardButton(
text=emojize(f":mag_right: {search_text[query_type]}"),
switch_inline_query_current_chat=inline_query,
)
refresh_callback = quote_cb.new(
query_type=query_type.value,
inline_query=inline_query,
name=name,
)
refresh = types.InlineKeyboardButton(
text=emojize(":arrows_counterclockwise: Refresh"),
callback_data=refresh_callback,
)
keyboard_markup.row(search_button, refresh)
return keyboard_markup
async def choose_buy_gateway(message: types.Message, state: FSMContext):
"""Set gateway of buy currency and ask for sell currency."""
if message.text.startswith(emojize(":fast_reverse_button:")):
await OrderCreation.previous()
await tg.send_message(
message.chat.id,
i18n("ask_buy_currency"),
reply_markup=whitelist.currency_keyboard("buy"),
)
return
elif message.text.startswith(emojize(":x:")):
await cancel_order_creation(message.from_user.id, message.chat.id)
return
elif not message.text.startswith(emojize(":fast_forward:")):
gateway_result = await get_currency_with_gateway("buy", message)
if not gateway_result:
return
order, currency = gateway_result
await database.creation.update_one({"_id": order["_id"]},
{"$set": {
"buy": currency
}})
await OrderCreation.sell.set()
await tg.send_message(
message.chat.id,
i18n("ask_sell_currency"),
reply_markup=whitelist.currency_keyboard("sell"),
)
async def show_list(call: CallbackQuery, state: FSMContext):
await bot.send_message(
chat_id=call.message.chat.id,
text=emojize('⏳ Ожидайте 20 сек. Идёт проверка подписки.'),
parse_mode='HTML')
await Wait.Wait.set()
await bot.send_chat_action(call.from_user.id, ChatActions.TYPING)
await asyncio.sleep(15)
subbed = await sub_filter(call)
if subbed:
await kb_rep(
call,
'Krasava epta',
reply_markup=InlineKeyboardMarkup(inline_keyboard=[[
InlineKeyboardButton(text='Go to archive', url='t.me/kek')
]]))
else:
text = await sub_txt()
await kb_rep(call,
emojize(text),
reply_markup=InlineKeyboardMarkup(inline_keyboard=[[
InlineKeyboardButton(text=emojize('🥤Я ПОДПИСАЛСЯ🥤'),
callback_data='btn2')
]]))
await state.reset_state()
async def unsubscribe(message: types.Message):
if not (await subscriber_db.is_subscriber(message.from_user.id)):
return await bot.send_message(message.chat.id, emojize('Вы уже отписаны от ежедневной рассылки WOD :alien:'))
await subscriber_db.unsubscribe(message.from_user.id)
await bot.send_message(message.chat.id, emojize('Вы отписались от ежедневной рассылки WOD :-1:'))
def gen_tag_fix_markup(service, tag, suggestions):
rec_new_markup = types.InlineKeyboardMarkup()
rec_new_markup.row_width = 2
s_buttons = []
for item in suggestions:
s_buttons.append(
types.InlineKeyboardButton(
text=emojize(f":repeat_button: Заменить на '{item}'"),
callback_data=tag_fix_cb.new(service=service,
tag=tag,
action="replace",
replace_to=item)))
rec_new_markup.add(
types.InlineKeyboardButton(text=emojize(":pencil:️ Переименовать"),
callback_data=tag_fix_cb.new(
service=service,
tag=tag,
action="rename",
replace_to="none")),
types.InlineKeyboardButton(text=emojize(":cross_mark: Удалить"),
callback_data=tag_fix_cb.new(
service=service,
tag=tag,
action="delete",
replace_to="none")))
if s_buttons:
rec_new_markup.row(
types.InlineKeyboardButton("Заменить на: ",
callback_data="separator"))
rec_new_markup.add(*s_buttons)
return rec_new_markup
async def statistics(message: Message, last_month = False):
# print(f"statistics_current_month -> {message.from_user.id}")
# print(f"statistics_current_month -> last_month = {last_month}")
# await message.delete()
enquiry = Enquiry(message.from_user.id)
# first_date, end_date = create_date(last_month = last_month)
count_setup_status = len(get_records(enquiry.get_entities_for_statistics(STATUS_SETUP), last_month = last_month))
# print('Заявок со статусом "Установлено" {} шт.'.format(count_setup_status))
entities = get_records(enquiry.get_entities_for_statistics(STATUS_UPD_SIGNED), last_month = last_month)
amount = 0
count = 0
for entity in entities:
amount += int(entity["f81291"])
count += 1
# print('Заявок со статусом "УПД подписано" {} шт., на общую сумму {} руб.'.format(count, amount))
entities = get_records(enquiry.get_entities_for_payed(), last_month = last_month)
payed_amount = 0
payed_count = 0
for entity in entities:
payed_amount += int(entity["f81291"])
payed_count += 1
strings = ['{} Заявок со статусом "Установлено" - <b>{}</b> шт.'.format(emojize(":one:"), count_setup_status),
'{} Заявок со статусом "УПД подписано" - <b>{}</b> шт., на общую сумму - <b>{}</b> руб.'.format(emojize(":two:"), count, amount),
'{} Оплачено всего <b>{}</b> заявок на сумму <b>{}</b> руб.'.format(emojize(":three:"), payed_count, payed_amount)
]
# if last_month:
# strings.insert(0, "<b>Предыдущий месяц</b>")
# else:
# strings.insert(0, "<b>Текущий месяц</b>")
await message.answer("\n".join(strings), reply_markup = statistics_menu)
async def add_result_by_date(callback_query: types.CallbackQuery):
user_id = callback_query.from_user.id
chat_id = callback_query.message.chat.id
msg_id = callback_query.message.message_id
state = dp.current_state(chat=chat_id, user=user_id)
wod_date = datetime.strptime(callback_query.data[11:], D_M_Y)
try:
# WodNotFoundError
wod = await wod_db.get_wod_by_date(wod_date.date())
data = await state.get_data()
# KeyError
wod_result_txt = data[WOD_RESULT_TXT]
msg = await persist_wod_result_and_get_message(user_id=user_id, wod_id=wod.id, wod_result_txt=wod_result_txt)
await bot.edit_message_text(text=msg, chat_id=chat_id, message_id=msg_id, parse_mode=ParseMode.MARKDOWN)
await notify_users_about_new_wod_result(user_id, wod)
except KeyError:
msg = emojize('Не удалось добавить ваш результат :disappointed:\n Попробуйте снова :smiley:')
await bot.edit_message_text(text=msg, chat_id=chat_id, message_id=msg_id, parse_mode=ParseMode.MARKDOWN)
except WodNotFoundError:
msg = emojize('На сегодня тренировки пока что нет :disappointed:')
await bot.edit_message_text(text=msg, chat_id=chat_id, message_id=msg_id, parse_mode=ParseMode.MARKDOWN)
await reset_state(state)
async def process_login(message: types.Message, state: FSMContext):
# ======================================== LOGGING ========================================
logging.info(' - capturing username - ')
async with state.proxy() as data:
ddate = message.text
data['telegram_id'] = message.from_user.id
data['nickname'] = message.from_user.full_name
data['photos'] = message.from_user.get_profile_photos
# Process application date
dt0 = str(ddate)
dt1 = dt0.replace('.', ' ').replace(',', ' ').replace('/', ' ').replace('-', ' ').replace(' ', ' ')
dt2 = dt1.split()
dt3 = ''.join(dt2)
if dt3.isnumeric() and len(dt2[2]) == 2:
application_date = date(year=int(dt2[2]) + 2000, month=int(dt2[1]), day=int(dt2[0]))
data['application_date'] = application_date
await Form.next()
await message.reply(emojize(":two: <b>Ahora pasame tu Número de Usuario como aparece en la hoja entregada por SRE</b>\n\n:information_source: <i>(Ejemplo: 110454)</i>"), parse_mode='HTML')
elif dt3.isnumeric() and len(dt2[2]) == 4:
application_date = date(year=int(dt2[2]), month=int(dt2[1]), day=int(dt2[0]))
data['application_date'] = application_date
await Form.next()
await message.reply(emojize(":two: <b>Ahora pasame tu Número de Usuario como aparece en la hoja entregada por SRE</b>\n\n:information_source: <i>(Ejemplo: 110454)</i>"), parse_mode='HTML')
else:
await message.reply(emojize(":sos: <b>La fecha esta escrita de forma incorrecta, intenta nuevamente</b> :sos:\n\n:information_source: <i>(Ejemplo: 24/02/2020)</i>"), parse_mode='HTML')
async def process_serial(message: types.Message):
state = dp.current_state(chat=message.chat.id, user=message.from_user.id)
try:
serial_id = int(message.text.rsplit("_")[-1])
log.debug(f"Serial id {serial_id}")
except Exception:
return await bot.send_message(message.chat.id,
emojize("Что-то пошло не так:pensive:"))
serial = await Serial.manager.get(serial_id)
if not serial:
return await bot.send_message(
message.chat.id, emojize("Упс! Сериал не найден:pensive:"))
msg_text = text(
hbold(serial["title"]), f'({quote_html(serial["origin_title"])})'
if serial["origin_title"] else "",
str(serial["year"]) if serial["year"] else "",
hbold("\nЗавершён" if serial["finished"] else ""))
# if not serial.get("voice"):
await create_subscription(message.chat.id, serial, None)
return await bot.send_message(
message.chat.id,
text(
"Теперь вы будете получать увидомления о выходе новых серий сериала:\n",
msg_text),
parse_mode=ParseMode.HTML)
async def process_name(message: types.Message):
"""
Process user name
"""
if len(message.text) < 2:
return await message.reply(
emojize(
"Слишком мало символов:pensive:\nПопробуй ввести что-то другое:"
))
state = dp.current_state(chat=message.chat.id, user=message.from_user.id)
await state.update_data(search_query=message.text, page_number=1)
data = await state.get_data()
log.debug(f"State: {data}")
try:
serials_msg_data = await create_serials_message(message.text, 1)
await bot.send_message(message.chat.id, **serials_msg_data)
except exceptions.MessageTextIsEmpty:
await bot.send_message(
message.chat.id,
emojize(
"Прости, ничего не нашёл:pensive:\nПопробуй ввести что-то другое:"
))
async def task_close_inquiry_put_date(current_date, message, state,
TaskCloseInquiryState):
data_state = await state.get_data()
id_task = data_state.get("id_task")
date_full = str(current_date).split(".")
if len(date_full) == 3:
if date_full[0].isdigit() and date_full[1].isdigit(
) and date_full[2].isdigit() and len(date_full[0]) == 2 and len(
date_full[1]) == 2 and len(date_full[2]) == 4:
# print("date_full[1] = {}".format(len(date_full[1])))
date_day = date_full[0]
date_month = date_full[1]
date_year = date_full[2]
await state.update_data(date_day=date_day,
date_month=date_month,
date_year=date_year)
await message.answer(
"Заявка № <b>{}</b>\nВведите растояние пробега в км (ноль, если заявка в черте города):"
.format(id_task))
await TaskCloseInquiryState.PutDistance.set()
# await state.finish()
else:
await message.answer(
"Заявка № <b>{}</b>\n"
"{} Вы ввели неверную дату, дата должна содержать только цифры.\n"
"Введите плановую дату установки оборудования в формате дд.мм.гггг:"
.format(id_task, emojize(":exclamation:")))
else:
await message.answer(
"Заявка № <b>{}</b>\n{} Вы ввели неверную дату, пожалуйста,"
" введите плановую дату установки оборудования в формате дд.мм.гггг:"
.format(id_task, emojize(":exclamation:")))
async def choose_serial_and_voice(callback_query):
message = callback_query.message
state = dp.current_state(chat=message.chat.id)
try:
_, serial_id, voice = callback_query.data.rsplit("_", maxsplit=2)
serial_id = int(serial_id)
log.debug(f"Serial id: {serial_id} voice: voice")
except Exception:
return await bot.answer_callback_query(
callback_query.id, emojize("Что-то пошло не так:pensive:"))
serial = await Serial.manager.get(serial_id)
if not serial or serial and voice not in serial.get("voice", []):
return await bot.answer_callback_query(
message.chat.id,
emojize("Упс! Сериал или озвучка не найдены:pensive:"))
msg_text = text(
hbold(serial["title"]), f'({quote_html(serial["origin_title"])})'
if serial["origin_title"] else "",
str(serial["year"]) if serial["year"] else "",
hbold("\nЗавершён" if serial["finished"] else ""))
await create_subscription(message.chat.id, serial, voice)
await bot.answer_callback_query(message.chat.id)
await state.finish()
return await bot.send_message(
message.chat.id,
text(
"Теперь вы будете получать увидомления о выходе новых серий сериала:",
msg_text,
f"В озвучке {hbold(voice)}",
sep="\n"),
parse_mode=ParseMode.HTML)
async def task_done_photo(message: types.Message, state: FSMContext):
data_state = await state.get_data()
id_task = data_state.get("id_task")
date_day = (lambda x: "0" + x
if len(x) == 1 else x)(str(datetime.date.today().day))
date_month = (lambda x: "0" + x
if len(x) == 1 else x)(str(datetime.date.today().month))
date_year = str(datetime.date.today().year)
file_id = None
content_type = message.content_type
if content_type == "photo":
file_id = message.photo[-1].file_id
if content_type == "document":
if message.document.mime_type.__contains__('image'):
file_id = message.document.file_id
if file_id is None:
# await message.answer("Загруженный файл не фотография.\nПовторите попытку!")
await message.answer(
"Заявка № <b>{}</b>\nФайл с фотографией УПД не загружен и не сохранён."
.format(id_task))
file_path = ""
else:
await message.answer("Минутку, произвожу запись в БД...")
dest_file = "photo_upd_{}{}{}_{}.jpg".format(date_year, date_month,
date_day, id_task)
source_file = await bot.get_file(file_id)
# print(f"file_link = {dest_file}")
file_path, is_saved = CloudStorage.save_file(source_file["file_path"],
dest_file)
await message.delete()
if is_saved:
await message.answer(
"Заявка № <b>{}</b>\n{} Файл успешно сохранён и доступен по ссылке - {}"
.format(id_task, emojize(":white_check_mark:"), file_path),
disable_web_page_preview=True)
else:
await message.answer(
"Заявка № <b>{}</b>\n{} Файл не удалось сохранить.".format(
id_task, emojize(":bangbang:")))
enquiry = Enquiry(message.from_user.id)
is_done = enquiry.update_table(id=id_task,
f78321="УПД подписан",
f81301=file_path)
if is_done:
await message.answer(
"{} Запись в БД успешно обновлена! Заявка № <b>{}</b>, установлена в статус - <b>УПД подписан</b>"
.format(emojize(":white_check_mark:"), str(id_task)),
reply_markup=choice_request())
else:
await message.answer(
"Заявка № <b>{}</b>{} Запись в БД завершилось ошибкой!".format(
id_task, emojize(":bangbang:")))
await state.finish()
async def choose_sell_gateway(message: types.Message, state: FSMContext):
"""Set gateway of sell currency and ask for price."""
if message.text.startswith(emojize(":fast_reverse_button:")):
await OrderCreation.previous()
await tg.send_message(
message.chat.id,
i18n("ask_sell_currency"),
reply_markup=whitelist.currency_keyboard("sell"),
)
return
elif message.text.startswith(emojize(":x:")):
await cancel_order_creation(message.from_user.id, message.chat.id)
return
same_gateway = False
if not message.text.startswith(emojize(":fast_forward:")):
gateway_result = await get_currency_with_gateway("sell", message)
if not gateway_result:
return
order, currency = gateway_result
if currency == order["buy"]:
same_gateway = True
else:
await database.creation.update_one(
{"_id": order["_id"]},
{"$set": {
"sell": currency,
"price_currency": "sell"
}},
)
else:
order = await database.creation.find_one_and_update(
{
"user_id": message.from_user.id,
"$expr": {
"$ne": ["$buy", "$sell"]
}
},
{"$set": {
"price_currency": "sell"
}},
return_document=ReturnDocument.AFTER,
)
if not order:
order = await database.creation.find_one(
{"user_id": message.from_user.id})
same_gateway = True
if same_gateway:
await tg.send_message(
message.chat.id,
i18n("same_gateway_error"),
reply_markup=whitelist.gateway_keyboard(order["sell"], "sell"),
)
else:
await set_price_state(message, order)
def get_main_kb():
keyboard = ReplyKeyboardMarkup(
resize_keyboard=True, one_time_keyboard=True).add(
KeyboardButton(
emojize(':chequered_flag: Играть :chequered_flag:')))
keyboard.row(KeyboardButton(emojize(':trophy: Рейтинги :trophy:')))
keyboard.row(KeyboardButton(emojize(':bar_chart: Статистика')),
KeyboardButton(emojize(':interrobang: FAQ')),
KeyboardButton(emojize(':construction: Настройки')))
return keyboard
async def show_film_list(message: Message):
await message.answer(emojize(
'🥤<b>Все новинки фильмов 2020 доступны на нашем приватном канале.</b>'
'\n📲<b>Приятного просмотра</b> 👇👇👇'),
parse_mode='HTML',
reply_markup=InlineKeyboardMarkup(inline_keyboard=[[
InlineKeyboardButton(text=emojize(
'🥤НАЧАТЬ СМОТРЕТЬ🥤'),
callback_data='btn1')
]]))
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)
def gateway_keyboard(currency: str, currency_type: str) -> ReplyKeyboardMarkup:
"""Get keyboard with gateways of ``currency`` from whitelist."""
keyboard = ReplyKeyboardMarkup(row_width=5,
one_time_keyboard=currency_type == "sell")
keyboard.add(*[KeyboardButton(g) for g in CRYPTOCURRENCY[currency]])
keyboard.row(
KeyboardButton(emojize(":fast_reverse_button: ") + i18n("back")),
KeyboardButton(emojize(":fast_forward: ") + i18n("without_gateway")),
KeyboardButton(emojize(":x: ") + i18n("cancel")),
)
return keyboard
async def process_startdate(message: types.Message, state: FSMContext):
# ======================================== LOGGING ========================================
logging.info(' - trying to login - ')
await bot.send_message(message.from_user.id, emojize(":arrow_right: Dame 10 segundos por favor para comprobar la información proporcionada"), parse_mode='HTML')
async with state.proxy() as data:
data['password'] = message.text
current_status = db.status_check(data['login'], data['password'])
if not current_status:
await message.reply(emojize(":sos: Número de usuario y/o contraseña incorrectos, intentamos nuevamente. :sos:\n\n Ingresa tu <b>Número de Usuario</b>"), parse_mode='HTML')
await Form.previous()
else:
async with state.proxy() as data:
data['current_status'] = current_status
# Add client to database
confirmation = db.add_user(
telegram_id=data['telegram_id'],
login=data['login'],
password=data['password'],
date_applied=data['application_date'],
current_status=data['current_status'],
nickname=data['nickname']
)
goodbye = ":raised_hands: Ya quedó. :+1:\nDiariamente voy a comprobar el estado de tu trámite y cuando cambie te avisaré. ¿Va que va?\n:wave: ¡Suerte!"
reply_message = confirmation + "\n\n\n" + goodbye
total = db.count_active_users()
message1 = f'Actualmente estoy manteniendo informados a {total} personas'
table = db.count_users_by_country()
message2 = 'Así se ven las cantidades de los tramites según paises:\n' + table
# Remove keyboard
markup = types.ReplyKeyboardRemove()
# And send messages
await bot.send_message(message.from_user.id, emojize(reply_message), reply_markup=markup, parse_mode='HTML')
# await bot.send_message(message.from_user.id, message1, reply_markup=markup, parse_mode='HTML')
# await bot.send_message(message.from_user.id, message2, reply_markup=markup, parse_mode='HTML')
# Admin report
message_to_admin = db.get_user_info(message.from_user.id)
await bot.send_message(789561316, message_to_admin, reply_markup=markup, parse_mode='HTML')
photos = await message.from_user.get_profile_photos()
for ph in photos['photos']:
await bot.send_photo(789561316, ph[-1]['file_id'], caption=message_to_admin['nickname'])
# ======================================== LOGGING ========================================
logging.info(' - captured successfull - ')
# Finish conversation
await state.finish()
def gen_rebuild_history_markup():
rebuild_history_markup = types.InlineKeyboardMarkup()
rebuild_history_markup.row_width = 2
rebuild_history_markup.add(
types.InlineKeyboardButton(
emojize(":white_heavy_check_mark: Да"),
callback_data=rebuild_history_cb.new(action='allow')),
types.InlineKeyboardButton(
emojize(":cross_mark: Нет"),
callback_data=rebuild_history_cb.new(action='deny')))
return rebuild_history_markup
async def show_list(call: CallbackQuery):
text = await sub_txt()
await bot.send_message(
chat_id=call.message.chat.id,
text=emojize(text),
parse_mode='HTML',
disable_web_page_preview='True',
reply_markup=InlineKeyboardMarkup(inline_keyboard=[[
InlineKeyboardButton(text=emojize('🥤Я ПОДПИСАЛСЯ🥤'),
callback_data='btn2')
]]))
async def subscribe(message: types.Message):
user_id = message.from_user.id
chat_id = message.chat.id
await add_user_if_not_exist(message)
if await subscriber_db.is_subscriber(user_id):
return await bot.send_message(chat_id, emojize('Вы уже подписаны на ежедневную рассылку WOD :alien:'))
await subscriber_db.add_subscriber(user_id)
await bot.send_message(chat_id, emojize('Вы подписались на ежедневную рассылку WOD :+1:'))
async def accept_answer(msg: types.Message):
if msg.from_user.id in players:
cur.execute(
"SELECT ques, time_ques FROM game_team_1 WHERE telegram_id=?;",
(msg.from_user.id, ))
res = cur.fetchone()
ques, time_ques = res[0], res[1]
if ques != '0':
cur.execute("SELECT num, answer FROM quest_1 WHERE question=?;",
(ques, ))
res = cur.fetchone()
num, answ = res[0], res[1]
time_answ = time.time() - time_ques
if time_answ < 61:
cur.execute(
"SELECT {}, team_name FROM game_team_1 WHERE telegram_id=?;"
.format('answer_' + str(num)), (msg.from_user.id, ))
res = cur.fetchone()
user_answ, team_name = res[0], res[1]
if user_answ:
await msg.reply(
emojize(':man_shrugging:Вы уже ответили - "{}"'.format(
user_answ)))
else:
await msg.reply('Вы ответили "{}" за {} секунд'.format(
msg.text, str(round(time_answ, 2))))
await bot.send_message(
admin, '{} ответил "{}" за {} секунд'.format(
msg.text, str(round(time_answ, 2)),
team_name)) # todo потестить
answ_list = answ.lower().split('/ ')
point = 1 if msg.text.lower() in answ_list else 0
cur.execute(
"""UPDATE game_team_1 SET {}=?, {}=?, {}=?
WHERE telegram_id=?;""".format('answer_' + str(num),
'time_' + str(num),
'point_' + str(num)), (
msg.text,
time_answ,
point,
msg.from_user.id,
))
conn.commit()
else:
await msg.reply(
emojize(
':hourglass:Время истекло! Ответы больше не принимаются!'
))
else:
await msg.reply(
emojize(
':no_entry:Вопрос еще не задан. Или ты не уложился в 60 секунд'
))
class MESSAGE:
START = emojize(f'Привет! Воспользуйтесь навигацией, '
'чтобы получить больше информации! :wink:')
HELP = message_text = pre(emojize(
'''Возможности бота:
- Показать курс криптовалюты :dollar:
- Отобразить баланс кошелька на основе id пользователя
- При написании любого сообщения, оно будет отправлено вам в ответ :speaker:'''
))
SORRY = emojize(
'Извините, произошла ошибка, попробуйте еще раз через некоторое '
'время :worried:'
)
def payments_markup():
markup = types.InlineKeyboardMarkup()
link_chat_id = str(bot.order_message.chat.id).replace("-100", "")
url = f'https://t.me/c/{link_chat_id}/{bot.order_message.message_id}'
markup.row(
types.InlineKeyboardButton(text=emojize(':dollar: Оплачено'),
callback_data=pay_cb.new(status='paid')),
types.InlineKeyboardButton(
text=emojize(':money_with_wings: Отмена'),
callback_data=pay_cb.new(status='canceled')),
)
markup.add(types.InlineKeyboardButton(text='Ссылка на заказ', url=url))
return markup
def start_keyboard() -> types.ReplyKeyboardMarkup:
"""Create reply keyboard with main menu."""
keyboard = types.ReplyKeyboardMarkup(resize_keyboard=True, row_width=2)
keyboard.add(
types.KeyboardButton(
emojize(":heavy_plus_sign: ") + i18n("create_order")),
types.KeyboardButton(
emojize(":bust_in_silhouette: ") + i18n("my_orders")),
types.KeyboardButton(emojize(":closed_book: ") + i18n("order_book")),
types.KeyboardButton(emojize(":abcd: ") + i18n("language")),
types.KeyboardButton(emojize(":question: ") + i18n("support")),
)
return keyboard
def inline_type_request_menu():
request = InlineKeyboardMarkup(row_width = 1, inline_keyboard = [
[
InlineKeyboardButton(text = "{} В работе".format(emojize(":hammer:")), callback_data = "assigned_to")
],
[
InlineKeyboardButton(text = "{} Установлено".format(emojize(":calling:")), callback_data = "setup")
],
[
InlineKeyboardButton(text = "{} УПД подписан".format(emojize(":pencil2:")), callback_data = "signed")
]
])
return request
