async def personal_reminder_about_cleaning(
chat_id, campus_number, is_day_before: bool = False
):
from core.strings.scripts import i18n
if is_day_before:
text = _(
"personal_reminder_cleaning_day_before",
locale=await i18n.get_user_locale(None, None, user_id=chat_id),
)
else:
text = _(
"personal_reminder_cleaning, formats: number",
locale=await i18n.get_user_locale(None, None, user_id=chat_id),
)
try:
await bot.send_message(chat_id, text.format(number=campus_number))
except TelegramAPIError as e:
logger.exception(
f"TelegramAPIError while sending reminder({chat_id}, {campus_number})"
f"message={text}, locale={await i18n.get_user_locale(None, None, user_id=chat_id)}"
f": {e}"
)
if is_day_before:
await bot.send_message(
chat_id, f"Завтра уборка в кампусе <b>{campus_number}</b>"
)
else:
await bot.send_message(
chat_id, f"Сегодня уборка в кампусе <b>{campus_number}</b>"
)
async def off_cleaning_reminder_command_handler(msg: types.Message, state: FSMContext):
reminders_day_before = _get_existing_reminder_day_before_the_cleaning(
msg.from_user.id
)
reminders_at_the_day = _get_existing_reminder_at_the_day_of_cleaning(
msg.from_user.id
)
if not reminders_day_before and not reminders_at_the_day:
await msg.answer(_("no_reminders_set"))
return
else:
if reminders_at_the_day and reminders_day_before:
await msg.answer(
_("remove_set_is_day_before"),
reply_markup=markups.inline.get_set_is_day_before_kb(),
)
await OffCleaningReminderStates.enter_is_day_before.set()
else:
async with state.proxy() as proxy:
proxy["is_day_before"] = bool(reminders_day_before)
await send_inline_kb_campus_numbers_to_remove_reminders(
msg.from_user.id, proxy["is_day_before"]
)
await OffCleaningReminderStates.enter_campus_number.set()
async def schedule_command_handler(msg: types.Message):
from core.strings.scripts import i18n
next_cleaning_dates = []
now = datetime.datetime.now(consts.default_timezone).replace(tzinfo=None)
text = [
_("schedule_command_text"),
]
for base_dates in consts.base_dates_campus_cleaning.values():
days_left = consts.cleaning_interval
for base_date in base_dates:
if base_date:
base_date = datetime.datetime(
year=base_date.year, month=base_date.month, day=base_date.day,
)
days_left = min(
consts.cleaning_interval
- (now - base_date).days % consts.cleaning_interval,
days_left,
)
next_cleaning = now + datetime.timedelta(days=days_left)
next_cleaning_dates.append((next_cleaning.strftime("%d.%m.%Y (%A)"), days_left))
text.extend(
[
_("scheduled_cleaning").format(
campus_number=index + 1, date=date, days_left=days_left
)
for (index, (date, days_left)) in enumerate(next_cleaning_dates)
]
)
await bot.send_message(msg.chat.id, "\n".join(map(str, text)))
def get_set_is_day_before_kb():
from core.strings.scripts import _
set_is_day_before_kb = InlineKeyboardMarkup(row_width=1)
set_is_day_before_kb.add(
InlineKeyboardButton(
_("is_day_before_inline_kb_false"),
callback_data=set_is_day_before.new(value="1"),
),
InlineKeyboardButton(
_("is_day_before_inline_kb_true"),
callback_data=set_is_day_before.new(value="0"),
),
)
return set_is_day_before_kb
async def language_cmd_handler(msg: types.Message):
await bot.send_message(
msg.from_user.id,
text=_("choose language"),
reply_markup=available_languages_markup,
)
await ChooseLanguageDialog.enter_language_callback.set()
async def set_cleaning_reminder_time_cb_handler(
query: types.CallbackQuery, state: FSMContext, callback_data: Dict[str, str]
):
await query.answer()
reminder_time = inline_timepicker.handle(query.from_user.id, callback_data)
if reminder_time:
await bot.edit_message_text(
_("cleaning_reminder_set"),
chat_id=query.from_user.id,
message_id=query.message.message_id,
)
async with state.proxy() as proxy:
loop.run_in_executor(
None,
set_cleaning_reminder,
query.from_user.id,
proxy["campus_number_set_reminder"],
reminder_time,
proxy["is_day_before"],
)
await state.finish()
else:
await bot.edit_message_reply_markup(
query.from_user.id,
message_id=query.message.message_id,
reply_markup=inline_timepicker.get_keyboard(),
)
async def language_choice_handler(query: types.CallbackQuery,
state: FSMContext, callback_data: dict):
await query.answer()
await db.update_user(query.from_user.id,
locale=callback_data['user_locale'])
from core.strings.scripts import i18n
i18n.ctx_locale.set(callback_data['user_locale'])
await bot.send_message(query.from_user.id, _("language is set"))
await state.finish()
async def personal_reminder_about_cleaning(chat_id, campus_number):
from core.strings.scripts import i18n
try:
await bot.send_message(
chat_id,
_("personal_reminder_cleaning, formats: number",
locale=await i18n.get_user_locale(
None, None, user_id=chat_id)).format(number=campus_number))
except TelegramAPIError as e:
msg_text = _("personal_reminder_cleaning, formats: number",
locale=await i18n.get_user_locale(
None, None,
user_id=chat_id)).format(number=campus_number)
logger.exception(
f"TelegramAPIError while sending reminder({chat_id}, {campus_number})"
f"message={msg_text}, locale={await i18n.get_user_locale(None, None, user_id=chat_id)}"
f": {e}")
await bot.send_message(
chat_id, f"Сегодня уборка в кампусе <b>{campus_number}</b>")
async def off_cleaning_reminder_cb_handler(query: types.CallbackQuery,
state: FSMContext,
callback_data: Dict[str, str]):
campus = int(callback_data['number'])
for i in range(0, 4):
if consts.base_dates_campus_cleaning[campus][i]:
scheduler.remove_job(job_id=consts.job_id_format.format(
chat_id=query.from_user.id, campus_number=campus, index=i))
await bot.edit_message_text(_("reminder_is_off"),
chat_id=query.from_user.id,
message_id=query.message.message_id)
await state.finish()
async def off_cleaning_reminder_command_handler(msg: types.Message):
from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
campus_set = set()
for campus in range(1, 5):
for ind in range(0, 4):
if scheduler.get_job(
consts.job_id_format.format(chat_id=msg.from_user.id,
campus_number=campus,
index=ind)):
campus_set.add(str(campus))
if campus_set:
campus_set = sorted(campus_set)
kb = InlineKeyboardMarkup(row_width=2)
kb.add(*list(
InlineKeyboardButton(str(campus),
callback_data=markups.callbacks.
choose_campus_number.new(number=campus))
for campus in campus_set))
await msg.answer(_("choose_campus"), reply_markup=kb)
await OffCleaningReminderStates.enter_campus_number.set()
else:
await msg.answer(_("no_reminders_set"))
async def set_is_day_before_cb_handler(
query: types.CallbackQuery, state: FSMContext, callback_data: Dict[str, str]
):
await query.answer()
await query.message.delete()
async with state.proxy() as proxy:
proxy["is_day_before"] = callback_data.get("value") == "1"
await bot.send_message(
query.from_user.id,
_("choose_campus"),
reply_markup=markups.inline.campus_numbers,
)
await SetCleaningReminderStates.enter_campus_number.set()
async def set_campus_number_cb_handler(query: types.CallbackQuery,
state: FSMContext,
callback_data: Dict[str, str]):
await query.answer()
await query.message.delete()
async with state.proxy() as proxy:
proxy['campus_number_set_reminder'] = callback_data['number']
inline_timepicker.init(
base_time=datetime.time(12, 0),
min_time=datetime.time(0, 15),
max_time=datetime.time(23, 45),
)
await bot.send_message(query.from_user.id,
_("choose_cleaning_reminder_time"),
reply_markup=inline_timepicker.get_keyboard())
await SetCleaningReminderStates.enter_time.set()
async def send_inline_kb_campus_numbers_to_remove_reminders(user_id, is_day_before):
from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
existing_reminder_campuses = (
_get_existing_reminder_day_before_the_cleaning(user_id)
if is_day_before
else _get_existing_reminder_at_the_day_of_cleaning(user_id)
)
existing_reminder_campuses = sorted(existing_reminder_campuses)
kb = InlineKeyboardMarkup(row_width=2)
kb.add(
*[
InlineKeyboardButton(
str(campus),
callback_data=markups.callbacks.choose_campus_number.new(number=campus),
)
for campus in existing_reminder_campuses
]
)
await bot.send_message(user_id, _("choose_campus"), reply_markup=kb)
async def off_cleaning_reminder_cb_handler(
query: types.CallbackQuery, state: FSMContext, callback_data: Dict[str, str]
):
async with state.proxy() as proxy:
is_day_before = bool(proxy.get("is_day_before"))
campus = int(callback_data["number"])
for i in range(0, 4):
if consts.base_dates_campus_cleaning[campus][i]:
scheduler.remove_job(
job_id=consts.job_id_format.format(
chat_id=query.from_user.id, campus_number=campus, index=i
)
+ (":day_before" if is_day_before else "")
)
await bot.edit_message_text(
_("reminder_is_off"),
chat_id=query.from_user.id,
message_id=query.message.message_id,
)
await state.finish()
async def on_cleaning_reminder(msg: types.Message):
await msg.answer(_("choose_campus"),
reply_markup=markups.inline.campus_numbers)
await SetCleaningReminderStates.enter_campus_number.set()
async def help_command_handler(msg: types.Message):
user = await db.get_user(chat_id=msg.from_user.id)
await bot.send_message(
msg.chat.id,
_("help_cmd_text, formats: {name}").format(name=user.first_name))
async def start_command_handler(msg: types.Message):
await bot.send_message(msg.chat.id, _("start_cmd_text"))
async def cancel_handler(msg: types.Message, state: FSMContext):
await state.finish()
await bot.send_message(msg.from_user.id, _("cancel"))
async def mailing_everyone_handler(msg: types.Message, state: FSMContext):
await bot.send_message(msg.chat.id, _("sent_to_everyone"))
scheduler.add_job(send_to_everyone, args=[msg.text])
await state.finish()
async def send_to_everyone_command_handler(msg: types.Message):
await bot.send_message(msg.chat.id, _("mailing_everyone"))
await MailingEveryoneDialog.first()
async def on_cleaning_reminder(msg: types.Message):
await msg.answer(
_("set_is_day_before"), reply_markup=markups.inline.get_set_is_day_before_kb()
)
await SetCleaningReminderStates.set_is_day_before.set()
async def send_to_everyone_command_handler(msg: types.Message):
#NOTE: i am not sure where it works
await bot.send_message(msg.chat.id, _("mailing_everyone"))
await MailingEveryoneDialog.first()
