Feature/notifications

.gitignore

@@ -20,3 +20,5 @@ broadcast
 broadcast/*
 Pipfile.lock
 /broadcast/*
+
+.python-version

zmanim_bot/handlers/__init__.py

@@ -6,9 +6,9 @@
 from zmanim_bot.helpers import CallbackPrefixes, LOCATION_PATTERN
 from zmanim_bot.misc import dp
 from zmanim_bot.states import FeedbackState, ConverterGregorianDateState, ConverterJewishDateState, \
-    LocationNameState, ZmanimGregorianDateState
+    LocationNameState, ZmanimGregorianDateState, CreateNotificationState
 from . import admin, converter, errors, festivals, forms, main, menus, settings, \
-    incorrect_text_handler, reset_handler, payments, geolocation
+    incorrect_text_handler, reset_handler, payments, geolocation, notifications
 from ..texts.single import buttons
 
 __all__ = ['register_handlers']
@@ -67,6 +67,7 @@ def register_handlers():
     dp.register_message_handler(menus.handle_settings_menu, commands=['settings'])
     dp.register_message_handler(menus.handle_settings_menu, text=buttons.mm_settings)
     dp.register_message_handler(menus.handle_donate, text=buttons.mm_donate)
+    dp.register_message_handler(menus.handle_notifications, text='Notifications')  # todo
 
     # festivals
     dp.register_message_handler(festivals.handle_fast, text=buttons.FASTS)
@@ -121,5 +122,12 @@ def register_handlers():
     dp.register_message_handler(payments.on_success_payment, content_types=[ContentType.SUCCESSFUL_PAYMENT])
     dp.register_message_handler(payments.on_success_payment, content_types=[ContentType])
 
+    # Notifications
+    dp.register_callback_query_handler(notifications.init_notification, text_startswith=CallbackPrefixes.init_notification_setup)
+    dp.register_callback_query_handler(notifications.init_zmanim_notification, text_startswith=CallbackPrefixes.select_notification_zmanim)
+    dp.register_message_handler(notifications.set_offset, state=CreateNotificationState.waiting_for_offset_state)
+    dp.register_message_handler(notifications.set_message, state=CreateNotificationState.waiting_for_message_text_state)
+    dp.register_message_handler(notifications.set_name, state=CreateNotificationState.waiting_for_name_state)
+
     # unknown messages (SHOULD BE LAST!)
     dp.register_message_handler(incorrect_text_handler.handle_incorrect_text)

zmanim_bot/handlers/menus.py

@@ -41,3 +41,10 @@ async def handle_settings_menu(msg: Message):
 @track('Donate button')
 async def handle_donate(msg: Message):
     await msg.reply(messages.donate_init, reply_markup=DONATE_KB)
+
+
+@chat_action('text')
+@track('.')  # todo
+async def handle_notifications(msg: Message):
+    kb = menus.get_notifications_welcome_menu(False)
+    await msg.reply('notifications management', reply_markup=kb)  # todo

zmanim_bot/handlers/notifications.py

@@ -0,0 +1,70 @@
+from aiogram import Bot
+from aiogram.dispatcher import FSMContext
+from aiogram.types import Message, CallbackQuery
+
+from zmanim_bot.helpers import CallbackPrefixes, FeatureType, ZmanimType
+from zmanim_bot.service import notifications_service
+from zmanim_bot.states import CreateNotificationState
+
+
+async def handle_new_notifications_menu(msg: Message):
+    resp = 'select notification type:'  # todo
+    kb = ''
+
+
+async def init_notification(call: CallbackQuery):
+    feature_type = call.data.split(CallbackPrefixes.init_notification_setup)[1]
+    resp, kb = notifications_service.process_init_notification(feature_type)
+    await Bot.get_current().send_message(call.message.chat.id, resp, reply_markup=kb)
+    await call.answer()
+
+
+async def init_zmanim_notification(call: CallbackQuery, state: FSMContext):
+    # todo hide zmanim buttons
+    zman_type = call.data.split(CallbackPrefixes.select_notification_zmanim)[1]
+
+    await CreateNotificationState.waiting_for_offset_state.set()
+    await state.update_data(
+        {
+            'feature': FeatureType.zmanim,
+            'zman_type': ZmanimType(zman_type).name  # todo get enum value!
+        }
+    )
+
+    resp = 'add offset to notification (send 0 for no ofset)'  # todo translate; +/- hint
+    await Bot.get_current().send_message(call.message.chat.id, resp)
+
+
+async def set_offset(msg: Message, state: FSMContext):
+    try:
+        offset = notifications_service.process_offset(msg.text)
+    except ValueError:
+        return await Bot.get_current().send_message(msg.from_user.id, 'incorrect offset')  # todo translate
+
+    await state.update_data({'offset': offset})
+
+    resp = 'write a message you want to get'  # todo translate
+    await msg.reply(resp)
+    await CreateNotificationState.next()
+
+
+async def set_message(msg: Message, state: FSMContext):
+    await state.update_data({'message': msg.text})
+
+    resp = 'write a name for your notification'  # todo translate
+    await msg.reply(resp)
+    await CreateNotificationState.next()
+
+
+async def set_name(msg: Message, state: FSMContext):
+    data = await state.get_data()
+    data['name'] = msg.text
+
+    await notifications_service.create_notification(data)
+
+    resp = f'notification {msg.text} saved, manage it in ssetings'  # todo translate
+    await msg.reply(resp)
+    await state.finish()
+
+
+# todo fix state-based routing

zmanim_bot/helpers.py

@@ -1,4 +1,5 @@
 from datetime import date
+from enum import Enum
 from typing import Tuple
 
 from zmanim_bot.exceptions import IncorrectGregorianDateException, IncorrectLocationException
@@ -40,6 +41,39 @@ class CallbackPrefixes:
     update_fast = 'uf:'
     update_yom_tov = 'uy:'
 
+    init_notification_setup = 'a:'
+    select_notification_zmanim = 'b:'
+
+
+class FeatureType:
+    zmanim = '0'
+    shabbat = '1'
+    rosh_chodesh = '2'
+    holiday = '3'
+    yom_tov = '4'
+    fast = '5'
+    daf_yomi = '6'
+
+
+class ZmanimType(str, Enum):
+    alos = 'a'
+    misheyakir_10_2 = 'b'
+    sunrise = 'c'
+    sof_zman_shema_ma = 'd'
+    sof_zman_shema_gra = 'e'
+    sof_zman_tefila_ma = 'f'
+    sof_zman_tefila_gra = 'g'
+    chatzos = 'h'
+    mincha_gedola = 'i'
+    mincha_ketana = 'j'
+    plag_mincha = 'k'
+    sunset = 'l'
+    tzeis_5_95_degrees = 'm'
+    tzeis_8_5_degrees = 'n'
+    tzeis_42_minutes = 'o'
+    tzeis_72_minutes = 'p'
+    chatzot_laila = 'q'
+
 
 def parse_coordinates(coordinates: str) -> Tuple[float, float]:
     try:

zmanim_bot/integrations/zmanim_api_client.py

@@ -26,7 +26,7 @@ async def get_zmanim(location: Tuple[float, float], zmanim_settings: dict, date_
     if date_:
         params['date'] = date_
 
-    async with bot.session.post(url, params=params, json=zmanim_settings) as resp:
+    async with (await bot.get_session()).post(url, params=params, json=zmanim_settings) as resp:
         raw_resp = await resp.json()
         return Zmanim(**raw_resp)
 
@@ -47,7 +47,7 @@ async def get_shabbat(
     if date_:
         params['date'] = date_
 
-    async with bot.session.get(url, params=params) as resp:
+    async with (await bot.get_session()).get(url, params=params) as resp:
         raw_resp = await resp.json()
         return Shabbat(**raw_resp)
 
@@ -56,7 +56,7 @@ async def get_daf_yomi(date_=None) -> DafYomi:
     url = config.ZMANIM_API_URL.format('daf_yomi')
     params = None if not date_ else {'date': date_}
 
-    async with bot.session.get(url, params=params) as resp:
+    async with (await bot.get_session()).get(url, params=params) as resp:
         raw_resp = await resp.json()
         return DafYomi(**raw_resp)
 
@@ -65,7 +65,7 @@ async def get_rosh_chodesh(date_=None) -> RoshChodesh:
     url = config.ZMANIM_API_URL.format('rosh_chodesh')
     params = None if not date_ else {'date': date_}
 
-    async with bot.session.get(url, params=params) as resp:
+    async with (await bot.get_session()).get(url, params=params) as resp:
         raw_resp = await resp.json()
         return RoshChodesh(**raw_resp)
 
@@ -85,7 +85,7 @@ async def get_generic_yomtov(
         'havdala': havdala_opinion
     }
 
-    async with bot.session.get(url, params=params) as resp:
+    async with (await bot.get_session()).get(url, params=params) as resp:
         raw_resp = await resp.json()
         return YomTov(**raw_resp)
 
@@ -99,7 +99,7 @@ async def get_generic_fast(name: str, location: Tuple[float, float], havdala_opi
         'havdala': havdala_opinion
     }
 
-    async with bot.session.get(url, params=params) as resp:
+    async with (await bot.get_session()).get(url, params=params) as resp:
         raw_resp = await resp.json()
         return Fast(**raw_resp)
 
@@ -108,7 +108,7 @@ async def get_generic_holiday(name: str) -> Holiday:
     url = config.ZMANIM_API_URL.format('holiday')
     params = {'holiday_name': name}
 
-    async with bot.session.get(url, params=params) as resp:
+    async with (await bot.get_session()).get(url, params=params) as resp:
         raw_resp = await resp.json()
         return Holiday(**raw_resp)
 
@@ -121,7 +121,7 @@ async def get_israel_holidays() -> IsraelHolidays:
     for name in ['yom_hashoah', 'yom_hazikaron', 'yom_haatzmaut', 'yom_yerushalaim']:
         params = {'holiday_name': name}
 
-        async with bot.session.get(url, params=params) as resp:
+        async with (await bot.get_session()).get(url, params=params) as resp:
             raw_resp = await resp.json()
             result.append((name, date.fromisoformat(raw_resp['date'])))
 

zmanim_bot/keyboards/menus.py

@@ -15,7 +15,7 @@ def get_main_menu() -> ReplyKeyboardMarkup:
     kb = ReplyKeyboardMarkup(resize_keyboard=True)
     kb.add(buttons.mm_zmanim.value, buttons.mm_shabbat.value, buttons.mm_holidays.value)
     kb.add(buttons.mm_rh.value, buttons.mm_daf_yomi.value, buttons.mm_fasts.value)
-    kb.add(buttons.mm_zmanim_by_date.value, buttons.mm_converter.value)
+    kb.add(buttons.mm_zmanim_by_date.value, 'Notifications', buttons.mm_converter.value)  # todo translate
     kb.add(buttons.hm_report.value, buttons.mm_donate.value, buttons.mm_settings.value)
 
     if i18n_.is_rtl():
@@ -113,3 +113,11 @@ def get_report_keyboard() -> ReplyKeyboardMarkup:
     kb = ReplyKeyboardMarkup(resize_keyboard=True)
     kb.row(buttons.cancel.value, buttons.done.value)
     return kb
+
+
+def get_notifications_welcome_menu(nothing_to_manage: bool) -> ReplyKeyboardMarkup:  # todo translate
+    kb = ReplyKeyboardMarkup(resize_keyboard=True)
+    row = ['Create new notification']
+    not nothing_to_manage and row.append('Manage my notifications')
+    kb.row(*row)
+    return kb

zmanim_bot/keyboards/notifications.py

@@ -0,0 +1,22 @@
+from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+
+from zmanim_bot.helpers import CallbackPrefixes, ZmanimType
+
+
+def add_notification_button_to_kb(kb: InlineKeyboardMarkup, feature_type: str) -> None:
+    # todo translate
+    kb.row(InlineKeyboardButton(
+        text='🔔 Create notification',
+        callback_data=f'{CallbackPrefixes.init_notification_setup}{feature_type}'
+    ))
+
+
+zmanim_notifications_kb = InlineKeyboardMarkup()
+
+for zman_type in ZmanimType:
+    zmanim_notifications_kb.row(
+        InlineKeyboardButton(
+            text=f'{zman_type.name}',
+            callback_data=f'{CallbackPrefixes.select_notification_zmanim}{zman_type.value}'
+        )
+    )

zmanim_bot/notificator/trigger.py

@@ -0,0 +1,32 @@
+from enum import Enum
+
+
+class TriggerType(Enum):
+    gregorian_date = 'gregorian_date'
+    hebrew_date = 'hebrew_date'
+    zman = 'zman'
+
+
+class ZmanType(Enum):
+    alos = 'alos'
+    misheyakir_10_2 = 'misheyakir_10_2'
+    sunrise = 'sunrise'
+    sof_zman_shema_ma = 'sof_zman_shema_ma'
+    sof_zman_shema_gra = 'sof_zman_shema_gra'
+    sof_zman_tefila_ma = 'sof_zman_tefila_ma'
+    sof_zman_tefila_gra = 'sof_zman_tefila_gra'
+    chatzos = 'chatzos'
+    mincha_gedola = 'mincha_gedola'
+    mincha_ketana = 'mincha_ketana'
+    plag_mincha = 'plag_mincha'
+    sunset = 'sunset'
+    tzeis_5_95_degrees = 'tzeis_5_95_degrees'
+    tzeis_8_5_degrees = 'tzeis_8_5_degrees'
+    tzeis_42_minutes = 'tzeis_42_minutes'
+    tzeis_72_minutes = 'tzeis_72_minutes'
+    chatzot_laila = 'chatzot_laila'
+
+
+
+
+