async def receive_new_project_settings(message: types.Message, user: User,
state: FSMContext):
file = await bot.get_file(message.document['file_id'])
settings = io.BytesIO()
await file.download(settings)
try:
s = json.load(settings)
async with OrmSession() as session:
async with state.proxy() as data:
project = await session.get(Project, data['project_id'])
project.settings = s
await session.commit()
await message.reply(text(text('Проект', project.name),
text('Новые настройки для проекта',
project.name),
code(json.dumps(s, indent=4, sort_keys=True)),
sep='\n'),
parse_mode=types.ParseMode.MARKDOWN)
await state.finish()
except json.decoder.JSONDecodeError:
await message.reply(
'Это совсем не похоже на json-файл, пришлите другой файл',
reply_markup=types.ForceReply(selective=True))
except UnicodeDecodeError:
await message.reply(
'Это совсем не похоже на json-файл, у него вообще неизвестный бинарный формат, пришлите другой файл',
reply_markup=types.ForceReply(selective=True))
async def callback_add_user_definition_action(query: types.CallbackQuery,
callback_data: dict):
logger.debug(
'callback_add_user_definition_action Got this callback data: ',
callback_data)
await query.answer()
session, isValid = await authorize(query.from_user.id)
if not isValid:
return
if callback_data.get('data') == "1":
await bot.send_message(query.from_user.id, "OK, skipping")
if session.list_hid_word is not None:
await wordlist.adding_list_words(None, query, None)
else:
if session.words_to_add is None:
logger.error("{} session.words_to_add is None", query.from_user.id)
await bot.send_message(
query.message.chat.id,
"Sorry, no definitions found. Make sure you added your definition"
)
return
session.status = 'adding_user_definition'
word = session.words_to_add[0]
await bot.send_message(query.message.chat.id,
"Type in your definition for {}".format(word),
reply_markup=types.ForceReply())
async def process_project_settigns_file(message: types.Message, user: User, chat: Chat, state: FSMContext):
dt = message.date
file = await bot.get_file(message.document['file_id'])
settings = io.BytesIO()
await file.download(settings)
try:
s = json.load(settings)
async with OrmSession() as session:
async with state.proxy() as data:
project = Project(
owner_user_id=user.id,
name=data['project_name'],
chat_id=chat.id,
period_bucket_mode=human_period_bucket_modes[data['human_period_bucket_mode']],
created_dt=dt,
settings=s
)
session.add(project)
await session.commit()
await message.reply(
text(
text('Проект', project.name, 'создан'),
text('Примененные настройки:'),
code(json.dumps(s, indent=4, sort_keys=True)),
sep='\n'
),
parse_mode=types.ParseMode.MARKDOWN
)
await state.finish()
except json.decoder.JSONDecodeError:
await message.reply(
'Это совсем не похоже на json-файл, пришлите другой файл',
reply_markup=types.ForceReply(selective=True)
)
async def process_project_name(message: types.Message, user: User, state: FSMContext):
async with OrmSession() as session:
select_stmt = select(Project) \
.where(
Project.name == message.text,
Project.owner_user_id == user.id,
)
projects_result = await session.execute(select_stmt)
project = projects_result.scalars().first()
if not project:
await state.update_data(project_name=message.text)
await NewProjectForm.next()
keyboard = [
[types.KeyboardButton(mode_name)]
for mode_name in human_period_bucket_modes.keys()
]
await message.reply(
f'Выберите, когда обновлять списки задач',
reply_markup=types.ReplyKeyboardMarkup(keyboard=keyboard, selective=True)
)
else:
await message.reply(
f'Проект "{message.text}" уже существует, выберите другое имя',
reply_markup=types.ForceReply(selective=True)
)
async def process_project_period_bucket_mode(message: types.Message, state: FSMContext):
await state.update_data(human_period_bucket_mode=message.text)
await NewProjectForm.next()
await message.reply(
f'Теперь пришлите json-файл с настройками для нового проекта',
reply_markup=types.ForceReply(selective=True)
)
async def process_item_id(message: types.Message, state: FSMContext):
async with state.proxy() as data:
mo = re.match(r'(\d+)(?:\. )?(.*)', message.text)
if mo:
item_in_list_pos = int(mo.group(1)) - 1
text_fragment = mo.group(2)
if not text_fragment or text_fragment == data['items_texts'][
item_in_list_pos] or data['items_texts'][
item_in_list_pos].startswith(text_fragment[:-3]):
items_num = data['items_num']
if item_in_list_pos < items_num:
data['item_in_list_pos'] = item_in_list_pos
item_text = data['items_texts'][item_in_list_pos]
await AddNoteToItemForm.next()
await message.reply(
emojize(
text(text('Выбранный вами пункт:'),
text(' :pushpin:', item_text),
text('Теперь напишите само сообщение'),
sep='\n')),
reply_markup=types.ForceReply(selective=True),
disable_web_page_preview=True)
else:
await message.reply(
f'В вашем сегодняшнем плане нет столько пунктов, напишите число от 1 до {items_num}'
)
else:
await message.reply(
'Укажите, пожалуйста, либо просто порядковый номер без всего, либо нажмите на предложенную кнопку'
)
else:
await message.reply(
'Укажите, пожалуйста, либо просто порядковый номер без всего, либо нажмите на предложенную кнопку'
)
async def set_time2(message: types.Message):
text = message.text.split()
if len(text) == 4:
if all(map(lambda x: x.isdigit() and int(x) in range(1, 1000), text)):
db.set_config(message.from_user.id, text[0], text[1], text[2],
text[3])
await message.answer("Новые параметры успешно установлены",
reply_markup=keyboard)
else:
await message.answer(
"Ошибка, введите 4 целых числа в пределах от 1 до 999",
reply_markup=types.ForceReply())
else:
await message.answer(
"Ошибка, введите 4 целых числа в пределах от 1 до 999",
reply_markup=types.ForceReply())
async def para_summarization(session):
para = session.get_current_word()
await bot.send_message(session.get_user_id(),
'Rewrite this paragraph')
await bot.send_message(session.get_user_id(),
para[0],
reply_markup=types.ForceReply())
async def settings_message(message: types.Message):
logger.info(str(message.from_user.id) + ' /settings command')
session, isValid = await authorize(message.from_user.id, with_lang=True)
if not isValid:
return
await bot.send_message(message.from_user.id, "A few settings to make.")
await bot.send_message(message.from_user.id, "*If you have questions, you can ask them at https://t.me/OppiWords*")
m = await bot.send_message(message.from_user.id,
"Please, specify *your language*, the language in which you want to get definitions (e.g. Russian or German or any other language name) "
"of words and phrases", reply_markup=types.ForceReply())
session.status = m.message_id + 1
async def setlanguage_command_message(message: types.Message):
logger.debug(message)
session, isValid = await authorize(message.from_user.id)
if not isValid:
return
session.status = 'setlanguage'
if " " in message.text or message.text != '/setlanguage':
await setlanguage_message(message)
else:
forced_reply = types.ForceReply()
await message.reply(
"Type the name of the *language to learn* (e.g. English, Finnish or other.\n"
"You can always change it with /setlanguage",
reply_markup=forced_reply)
async def new_member_handler(message: types.Message, state: FSMContext):
question, answer = make_question()
bot_message = await message.reply_photo(
make_image(question, TIME),
reply_markup=types.ForceReply(selective=True))
await state.update_data(answer=answer, bot_message=bot_message)
await Check.check.set()
await asyncio.sleep(TIME)
data = await state.get_data()
if data and data[
'bot_message'] == bot_message: # Если пользователь не ответил то data еще не очищен
await kick_user(message.chat, message.from_user
) # и bot_message-ы совпадают. в таком случае кикаем
await state.finish()
with suppress(exceptions.MessageToDeleteNotFound):
await bot_message.delete()
async def log_message_about_work(message: types.Message, chat: Chat,
state: FSMContext):
dt = message.date
async with OrmSession() as session:
select_stmt = select(Project) \
.where(
Project.chat_id == chat.id
) \
.order_by(Project.id)
projects_result = await session.execute(select_stmt)
project = projects_result.scalars().first()
bucket = PeriodBucket.new(project.period_bucket_mode, dt)
items_list = await project.get_for_period(session, bucket)
items_num = len(items_list.items) if items_list else 0
if items_num > 0:
items_texts = [item.text for item in items_list.items]
await state.update_data(items_num=items_num)
await state.update_data(items_texts=items_texts)
await state.update_data(
items_ids=[item.id for item in items_list.items])
if items_num > 1:
await AddNoteToItemForm.item_id.set()
keyboard = [[
types.KeyboardButton(
f'{i+1}. {txt if len(txt) < 32 else txt[:29] + "..."}')
] for i, txt in enumerate(items_texts)]
await message.reply(
f'Напишите, пожалуйста, порядковый номер сегодняшней задачи от 1 до {items_num}',
reply_markup=types.ReplyKeyboardMarkup(keyboard=keyboard,
selective=True))
else:
await state.update_data(item_in_list_pos=0)
await AddNoteToItemForm.note_text.set()
await message.reply(
emojize(
text(text('В плане один единственный пункт:'),
text(' :pushpin:', items_texts[0]),
text('Напишите свое сообщение и я его сохраню'),
sep='\n')),
reply_markup=types.ForceReply(selective=True),
disable_web_page_preview=True)
else:
await message.answer(
'Извините, записи можно вести пока только по сегодняшним планам, '
'а у вас ничего не запланировано')
async def receive_project_name(message: types.Message, user: User,
state: FSMContext):
async with OrmSession() as session:
select_stmt = select(Project) \
.where(
Project.name == message.text,
Project.owner_user_id == user.id,
)
projects_result = await session.execute(select_stmt)
project = projects_result.scalars().first()
if project:
await state.update_data(project_id=project.id)
await UpdateProjectSettingsForm.next()
await message.reply(
'Проект ' + message.text +
'\nПришлите, пожалуйста, json-файл с настройками',
reply_markup=types.ForceReply(selective=True))
else:
await message.reply(f'Проекта "{message.text}" не существует')
async def new_message(callback: types.CallbackQuery):
await callback.answer(show_alert=False)
query_info = query(callback.data)
if query_info.module == "main":
if query_info.event == "timer":
msg, kb = generate.set_timer()
elif query_info.event == "create_task":
msg, kb = constants["create_task"], types.ForceReply()
else:
msg, kb = "Not available", None
else:
msg, kb = "Not available", None
new_msg = await callback.message.reply(msg, reply_markup=kb, reply=False)
if query_info.event == "timer":
print(query_info.query)
timers.append([new_msg, event("До конца осталось:\n{time}", int(time.time()) + query_info.duration * 60)])
async def handle_alive_callback(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
user_id = int(callback_query.data.split()[2])
username = callback_query.data.split()[1]
chat_id = callback_query.message.chat.id
if user_id != callback_query.from_user.id:
return
await bot.restrict_chat_member(chat_id,
user_id,
can_send_messages=True,
can_add_web_page_previews=True,
can_send_media_messages=True,
can_send_other_messages=True)
await bot.send_message(
chat_id, f'{username} с нами! Представтесь, пожалуйста, '
'или вы будете автоматически удалены через несколько часов.',
reply_markup=types.ForceReply(selective=True))
await bot.send_sticker(chat_id, config.new_member_sticker)
await callback_query.message.delete()
async def start_lookup(message: types.Message):
logging.info(f'Received message {message.text}')
response = ''
m_split = message.text.strip().split(' ')
if len(m_split) == 1:
range_ = 500
else:
try:
range_ = t.ToInt(gte=1, lte=5000).check(m_split[1].strip())
except t.DataError as e:
logging.error(e)
range_ = 500
response = '반경이 너무 크거나 작아요. 기본값인 500미터로 고정할게요.\n'
response += '이 메세지의 답변 메세지로 현재 위치를 보내주세요.'
sent_message = await bot.send_message(
message.chat.id,
response,
reply_to_message_id=message.message_id,
reply_markup=types.ForceReply(selective=True))
store_range_info[(
sent_message.message_id,
message.chat.id,
)] = range_
async def user_btn_feedback_handler(
message: types.Message): # Кнопка 'Обратная связь'
await message.answer(texts.FEEDBACK, reply_markup=types.ForceReply())
async def start_new_project_creation(message: types.Message):
await NewProjectForm.project_name.set()
await message.reply(
'Напишите короткое имя проекта',
reply_markup=types.ForceReply(selective=True)
)
async def process_project_name_invalid(message: types.Message):
await message.reply(
f'Ваш текст содержит много символов, целых {len(message.text)}, а можно максимум 150',
reply_markup=types.ForceReply(selective=True)
)
async def message_handler(message):
# Пользователь скинул аудио
if message.audio and message.chat.id != ADMINS_CHAT_ID:
return await bot.send_audio(message.chat.id,
message.audio.file_id,
'Теперь выбери день',
reply_markup=bot_utils.keyboard_day())
# Форс реплаи
if message.reply_to_message and message.reply_to_message.from_user.id == (
await bot.me).id:
# Одменские команды
if message.chat.id == ADMINS_CHAT_ID:
# Одмены отвечают
if message.reply_to_message.audio or message.reply_to_message.forward_from:
await core.admin_reply(message)
# Ввод названия песни
if message.reply_to_message.text == bot_utils.TEXT[
'predlozka_choose_song']:
await core.search_audio(message)
# Обратная связь
if message.reply_to_message.text == bot_utils.TEXT['feedback']:
await bot.send_message(message.chat.id,
bot_utils.TEXT['feedback_thanks'],
reply_markup=bot_utils.keyboard_start)
await bot.forward_message(ADMINS_CHAT_ID, message.chat.id,
message.message_id)
return
if message.chat.id < 0:
return
# Кнопки
# Кнопка 'Что играет?'
if message.text == bot_utils.btn['what_playing']:
playback = await playlist_api.get_now()
if not playback:
await bot.send_message(
message.chat.id,
"Не знаю(",
reply_markup=bot_utils.keyboard_what_playing)
else:
await bot.send_message(
message.chat.id,
bot_utils.TEXT['what_playing'].format(*playback),
reply_markup=bot_utils.keyboard_what_playing)
# Кнопка 'Предложить песню'
elif message.text == bot_utils.btn['predlozka'] or message.text == '/song':
await bot.send_message(message.chat.id,
bot_utils.TEXT['predlozka_choose_song'],
reply_markup=types.ForceReply())
await bot.send_message(
message.chat.id,
bot_utils.TEXT['predlozka_inline_search'],
reply_markup=bot_utils.keyboard_predlozka_inline)
# Кнопка 'Хочу в команду'
elif message.text == bot_utils.btn['feedback']:
await bot.send_message(message.chat.id,
bot_utils.TEXT['feedback'],
reply_markup=types.ForceReply())
elif message.text == bot_utils.btn['help'] or message.text == '/help':
await bot.send_message(message.chat.id,
bot_utils.TEXT['help']['first_msg'],
reply_markup=bot_utils.keyboard_help)
else:
await bot.forward_message(ADMINS_CHAT_ID, message.chat.id,
message.message_id)
await bot.send_message(message.chat.id,
bot_utils.TEXT['unknown_cmd'],
reply_markup=bot_utils.keyboard_start)
async def message_handler(message):
# Пользователь скинул аудио
if message.audio and message.chat.id != ADMINS_CHAT_ID:
return await bot.send_audio(message.chat.id,
message.audio.file_id,
consts.text['order_choose_day'],
reply_markup=await keyboards.choice_day())
# Форс реплаи
if message.reply_to_message and message.reply_to_message.from_user.id == (
await bot.me).id:
# Одменские команды
if message.chat.id == ADMINS_CHAT_ID:
# Одмены отвечают
if message.reply_to_message.audio or message.reply_to_message.forward_from:
await core.admin_reply(message)
# Ввод названия песни
if message.reply_to_message.text == consts.text['order_choose_song']:
await core.search_audio(message)
# Обратная связь
if message.reply_to_message.text == consts.text['feedback']:
await bot.send_message(message.chat.id,
consts.text['feedback_thanks'],
reply_markup=keyboards.start)
await bot.forward_message(ADMINS_CHAT_ID, message.chat.id,
message.message_id)
return
if message.chat.id < 0:
return
# Кнопки
# Кнопка 'Что играет?'
if message.text == keyboards.btn['what_playing']:
await core.song_now(message)
# Кнопка 'Предложить песню'
elif message.text == keyboards.btn['order'] or message.text == '/song':
await bot.send_message(message.chat.id,
consts.text['order_choose_song'],
reply_markup=types.ForceReply())
await bot.send_message(message.chat.id,
consts.text['order_inline_search'],
reply_markup=keyboards.order_inline)
# Кнопка 'Обратная связь'
elif message.text == keyboards.btn['feedback']:
await bot.send_message(message.chat.id,
consts.text['feedback'],
reply_markup=types.ForceReply())
# Кнопка 'Помощь'
elif message.text == keyboards.btn['help'] or message.text == '/help':
await bot.send_message(message.chat.id,
consts.helps['first_msg'],
reply_markup=keyboards.choice_help)
else:
await bot.forward_message(ADMINS_CHAT_ID, message.chat.id,
message.message_id)
await bot.send_message(message.chat.id,
consts.text['unknown_cmd'],
reply_markup=keyboards.start)
async def user_btn_order_handler(
message: types.Message): # Кнопка 'Заказать песню'
await message.answer(texts.ORDER_CHOOSE_SONG,
reply_markup=types.ForceReply())
await message.answer(texts.ORDER_INLINE_SEARCH,
reply_markup=kb.ORDER_INLINE)
def force_reply():
return types.ForceReply()
async def set_time(message: types.Message):
await message.answer(
"Введите через пробел 4 числа:\nжелаемое время для W, R, W2 и R2 соответственно (в минутах)",
reply_markup=types.ForceReply())
