smart-bot-factory 0.3.2__py3-none-any.whl → 0.3.3__py3-none-any.whl

smart_bot_factory/admin/admin_logic.py

@@ -20,6 +20,42 @@ def setup_admin_handlers(dp):
     """Настройка админских обработчиков"""
     dp.include_router(admin_router)
 
+@admin_router.message(Command(commands=["отмена", "cancel"]))
+async def cancel_handler(message: Message, state: FSMContext):
+    """Отмена текущего действия и очистка state"""
+    from ..handlers.handlers import get_global_var
+    admin_manager = get_global_var('admin_manager')
+    
+    # Получаем текущий state
+    current_state = await state.get_state()
+    
+    # Очищаем state
+    await state.clear()
+    
+    if current_state:
+        logger.info(f"State очищен для пользователя {message.from_user.id}: {current_state}")
+        
+        # Если это админ, возвращаем в админ режим
+        if admin_manager.is_admin(message.from_user.id):
+            await state.set_state(AdminStates.admin_mode)
+            await message.answer(
+                "✅ Текущее действие отменено\n"
+                "Вы вернулись в админ режим\n\n"
+                "Используйте /admin для просмотра доступных команд",
+                parse_mode='Markdown'
+            )
+        else:
+            await message.answer(
+                "✅ Текущее действие отменено\n\n"
+                "Используйте /start для начала работы",
+                parse_mode='Markdown'
+            )
+    else:
+        await message.answer(
+            "ℹ️ Нет активных действий для отмены",
+            parse_mode='Markdown'
+        )
+
 async def admin_start_handler(message: Message, state: FSMContext):
     """Обработчик /start для админов в режиме администратора"""
     from ..handlers.handlers import get_global_var
@@ -43,16 +79,22 @@ async def admin_start_handler(message: Message, state: FSMContext):
 
 Доступные команды:
 • `/стат` - статистика воронки
-• `/история <user_id>` - история пользователя
-• `/чат <user_id>` - начать диалог
+• `/история user_id` - история пользователя
+• `/чат user_id` - начать диалог
 • `/чаты` - активные диалоги
 • `/стоп` - завершить диалог
 • `/админ` - переключить режим
+• `/отмена` - отменить текущее действие
+
+📅 **Управление событиями:**
+• `/создать_событие` - создать новое событие
+• `/список_событий` - список активных событий
+• `/удалить_событие название` - отменить событие
 """
 
     await message.answer(welcome_text, reply_markup=keyboard, parse_mode='Markdown')
 
-@admin_router.message(Command("стат"))
+@admin_router.message(Command(commands=["стат", "stats"]))
 async def admin_stats_handler(message: Message, state: FSMContext):
     """Статистика воронки"""
     from ..handlers.handlers import get_global_var
@@ -73,13 +115,13 @@ async def admin_stats_handler(message: Message, state: FSMContext):
         
         full_text = f"{funnel_text}\n\n{events_text}"
         
-        await message.answer(full_text, parse_mode='Markdown')
+        await message.answer(full_text)
         
     except Exception as e:
         logger.error(f"Ошибка получения статистики: {e}")
         await message.answer("❌ Ошибка получения статистики")
 
-@admin_router.message(Command("история"))
+@admin_router.message(Command(commands=["история", "history"]))
 async def admin_history_handler(message: Message, state: FSMContext):
     """История пользователя"""
     from ..handlers.handlers import get_global_var
@@ -115,7 +157,7 @@ async def admin_history_handler(message: Message, state: FSMContext):
         logger.error(f"Ошибка получения истории: {e}")
         await message.answer("❌ Ошибка получения истории")
 
-@admin_router.message(Command("чат"))
+@admin_router.message(Command(commands=["чат", "chat"]))
 async def admin_chat_handler(message: Message, state: FSMContext):
     """Начать диалог с пользователем"""
     from ..handlers.handlers import get_global_var
@@ -170,7 +212,7 @@ async def admin_chat_handler(message: Message, state: FSMContext):
         logger.error(f"❌ Ошибка начала диалога: {e}")
         await message.answer("❌ Ошибка начала диалога")
 
-@admin_router.message(Command("чаты"))
+@admin_router.message(Command(commands=["чаты", "chats"]))
 async def admin_active_chats_command(message: Message, state: FSMContext):
     """Показать активные диалоги админов"""
     from ..handlers.handlers import get_global_var
@@ -191,7 +233,7 @@ async def admin_active_chats_command(message: Message, state: FSMContext):
         logger.error(f"Ошибка получения активных чатов: {e}")
         await message.answer("❌ Ошибка получения активных диалогов")
 
-@admin_router.message(Command("стоп"))
+@admin_router.message(Command(commands=["стоп", "stop"]))
 async def admin_stop_handler(message: Message, state: FSMContext):
     """Завершить диалог"""
     from ..handlers.handlers import get_global_var
@@ -230,7 +272,7 @@ async def admin_stop_handler(message: Message, state: FSMContext):
         logger.error(f"Ошибка завершения диалога: {e}")
         await message.answer("❌ Ошибка завершения диалога")
 
-@admin_router.message(Command("админ"))
+@admin_router.message(Command(commands=["админ", "admin"]))
 async def admin_toggle_handler(message: Message, state: FSMContext):
     """Переключение режима админа"""
     from ..handlers.handlers import get_global_var
@@ -391,7 +433,7 @@ async def admin_callback_handler(callback: CallbackQuery, state: FSMContext):
         logger.error(f"Ошибка обработки callback {data}: {e}")
         await callback.answer("Ошибка")
 
-@admin_router.message(StateFilter(AdminStates.admin_mode, AdminStates.in_conversation))
+@admin_router.message(StateFilter(AdminStates.admin_mode, AdminStates.in_conversation), F.text, lambda message: not message.text.startswith('/'))
 async def admin_message_handler(message: Message, state: FSMContext):
     """Обработчик сообщений админов"""
     from ..handlers.handlers import get_global_var
@@ -417,8 +459,8 @@ async def admin_message_handler(message: Message, state: FSMContext):
 
 Доступные команды:
 • `/стат` - статистика воронки
-• `/история <user_id>` - история пользователя  
-• `/чат <user_id>` - начать диалог
+• `/история user_id` - история пользователя  
+• `/чат user_id` - начать диалог
 • `/стоп` - завершить диалог
 • `/админ` - переключить режим
 

smart_bot_factory/aiogram_calendar/__init__.py

@@ -0,0 +1,6 @@
+from .common import get_user_locale
+from .simple_calendar import SimpleCalendar
+from .dialog_calendar import DialogCalendar
+from .schemas import SimpleCalendarCallback, DialogCalendarCallback, CalendarLabels
+
+__all__ = ['SimpleCalendar', 'DialogCalendar', 'SimpleCalendarCallback', 'DialogCalendarCallback', 'CalendarLabels', 'get_user_locale']

smart_bot_factory/aiogram_calendar/common.py

@@ -0,0 +1,70 @@
+import calendar
+import locale
+
+from aiogram.types import User
+from datetime import datetime
+
+from .schemas import CalendarLabels
+
+
+async def get_user_locale(from_user: User) -> str:
+    "Returns user locale in format en_US, accepts User instance from Message, CallbackData etc"
+    loc = from_user.language_code
+    return locale.locale_alias[loc].split(".")[0]
+
+
+class GenericCalendar:
+
+    def __init__(
+        self,
+        locale: str = None,
+        cancel_btn: str = None,
+        today_btn: str = None,
+        show_alerts: bool = False
+    ) -> None:
+        """Pass labels if you need to have alternative language of buttons
+
+        Parameters:
+        locale (str): Locale calendar must have captions in (in format uk_UA), if None - default English will be used
+        cancel_btn (str): label for button Cancel to cancel date input
+        today_btn (str): label for button Today to set calendar back to todays date
+        show_alerts (bool): defines how the date range error would shown (defaults to False)
+        """
+        self._labels = CalendarLabels()
+        if locale:
+            # getting month names and days of week in specified locale
+            with calendar.different_locale(locale):
+                self._labels.days_of_week = list(calendar.day_abbr)
+                self._labels.months = calendar.month_abbr[1:]
+
+        if cancel_btn:
+            self._labels.cancel_caption = cancel_btn
+        if today_btn:
+            self._labels.today_caption = today_btn
+
+        self.min_date = None
+        self.max_date = None
+        self.show_alerts = show_alerts
+
+    def set_dates_range(self, min_date: datetime, max_date: datetime):
+        """Sets range of minimum & maximum dates"""
+        self.min_date = min_date
+        self.max_date = max_date
+
+    async def process_day_select(self, data, query):
+        """Checks selected date is in allowed range of dates"""
+        date = datetime(int(data.year), int(data.month), int(data.day))
+        if self.min_date and self.min_date > date:
+            await query.answer(
+                f'The date have to be later {self.min_date.strftime("%d/%m/%Y")}',
+                show_alert=self.show_alerts
+            )
+            return False, None
+        elif self.max_date and self.max_date < date:
+            await query.answer(
+                f'The date have to be before {self.max_date.strftime("%d/%m/%Y")}',
+                show_alert=self.show_alerts
+            )
+            return False, None
+        await query.message.delete_reply_markup()  # removing inline keyboard
+        return True, date

smart_bot_factory/aiogram_calendar/dialog_calendar.py

@@ -0,0 +1,197 @@
+import calendar
+from datetime import datetime
+
+from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+from aiogram.types import CallbackQuery
+
+from .schemas import DialogCalendarCallback, DialogCalAct, highlight, superscript
+from .common import GenericCalendar
+
+
+class DialogCalendar(GenericCalendar):
+
+    ignore_callback = DialogCalendarCallback(act=DialogCalAct.ignore).pack()    # placeholder for no answer buttons
+
+    async def _get_month_kb(self, year: int):
+        """Creates an inline keyboard with months for specified year"""
+
+        today = datetime.now()
+        now_month, now_year = today.month, today.year
+        now_year = today.year
+
+        kb = []
+        # first row with year button
+        years_row = []
+        years_row.append(
+            InlineKeyboardButton(
+                text=self._labels.cancel_caption,
+                callback_data=DialogCalendarCallback(act=DialogCalAct.cancel, year=year, month=1, day=1).pack()
+            )
+        )
+        years_row.append(InlineKeyboardButton(
+            text=str(year) if year != today.year else highlight(year),
+            callback_data=DialogCalendarCallback(act=DialogCalAct.start, year=year, month=-1, day=-1).pack()
+        ))
+        years_row.append(InlineKeyboardButton(text=" ", callback_data=self.ignore_callback))
+        kb.append(years_row)
+        # two rows with 6 months buttons
+        month6_row = []
+
+        def highlight_month():
+            month_str = self._labels.months[month - 1]
+            if now_month == month and now_year == year:
+                return highlight(month_str)
+            return month_str
+
+        for month in range(1, 7):
+            month6_row.append(InlineKeyboardButton(
+                text=highlight_month(),
+                callback_data=DialogCalendarCallback(
+                    act=DialogCalAct.set_m, year=year, month=month, day=-1
+                ).pack()
+            ))
+        month12_row = []
+
+        for month in range(7, 13):
+            month12_row.append(InlineKeyboardButton(
+                text=highlight_month(),
+                callback_data=DialogCalendarCallback(
+                    act=DialogCalAct.set_m, year=year, month=month, day=-1
+                ).pack()
+            ))
+
+        kb.append(month6_row)
+        kb.append(month12_row)
+        return InlineKeyboardMarkup(row_width=6, inline_keyboard=kb)
+
+    async def _get_days_kb(self, year: int, month: int):
+        """Creates an inline keyboard with calendar days of month for specified year and month"""
+
+        today = datetime.now()
+        now_weekday = self._labels.days_of_week[today.weekday()]
+        now_month, now_year, now_day = today.month, today.year, today.day
+
+        def highlight_month():
+            month_str = self._labels.months[month - 1]
+            if now_month == month and now_year == year:
+                return highlight(month_str)
+            return month_str
+
+        def highlight_weekday():
+            if now_month == month and now_year == year and now_weekday == weekday:
+                return highlight(weekday)
+            return weekday
+
+        def format_day_string():
+            date_to_check = datetime(year, month, day)
+            if self.min_date and date_to_check < self.min_date:
+                return superscript(str(day))
+            elif self.max_date and date_to_check > self.max_date:
+                return superscript(str(day))
+            return str(day)
+
+        def highlight_day():
+            day_string = format_day_string()
+            if now_month == month and now_year == year and now_day == day:
+                return highlight(day_string)
+            return day_string
+
+        kb = []
+        nav_row = []
+        nav_row.append(
+            InlineKeyboardButton(
+                text=self._labels.cancel_caption,
+                callback_data=DialogCalendarCallback(act=DialogCalAct.cancel, year=year, month=1, day=1).pack()
+            )
+        )
+        nav_row.append(InlineKeyboardButton(
+            text=str(year) if year != now_year else highlight(year),
+            callback_data=DialogCalendarCallback(act=DialogCalAct.start, year=year, month=-1, day=-1).pack()
+        ))
+        nav_row.append(InlineKeyboardButton(
+            text=highlight_month(),
+            callback_data=DialogCalendarCallback(act=DialogCalAct.set_y, year=year, month=-1, day=-1).pack()
+        ))
+        kb.append(nav_row)
+
+        week_days_labels_row = []
+        for weekday in self._labels.days_of_week:
+            week_days_labels_row.append(InlineKeyboardButton(
+                text=highlight_weekday(), callback_data=self.ignore_callback))
+        kb.append(week_days_labels_row)
+
+        month_calendar = calendar.monthcalendar(year, month)
+
+        for week in month_calendar:
+            days_row = []
+            for day in week:
+                if day == 0:
+                    days_row.append(InlineKeyboardButton(text=" ", callback_data=self.ignore_callback))
+                    continue
+                days_row.append(InlineKeyboardButton(
+                    text=highlight_day(),
+                    callback_data=DialogCalendarCallback(act=DialogCalAct.day, year=year, month=month, day=day).pack()
+                ))
+            kb.append(days_row)
+        return InlineKeyboardMarkup(row_width=7, inline_keyboard=kb)
+
+    async def start_calendar(
+        self,
+        year: int = datetime.now().year,
+        month: int = None
+    ) -> InlineKeyboardMarkup:
+        today = datetime.now()
+        now_year = today.year
+
+        if month:
+            return await self._get_days_kb(year, month)
+        kb = []
+        # inline_kb = InlineKeyboardMarkup(row_width=5)
+        # first row - years
+        years_row = []
+        for value in range(year - 2, year + 3):
+            years_row.append(InlineKeyboardButton(
+                text=str(value) if value != now_year else highlight(value),
+                callback_data=DialogCalendarCallback(act=DialogCalAct.set_y, year=value, month=-1, day=-1).pack()
+            ))
+        kb.append(years_row)
+        # nav buttons
+        nav_row = []
+        nav_row.append(InlineKeyboardButton(
+            text='<<',
+            callback_data=DialogCalendarCallback(act=DialogCalAct.prev_y, year=year, month=-1, day=-1).pack()
+        ))
+        nav_row.append(InlineKeyboardButton(
+            text=self._labels.cancel_caption,
+            callback_data=DialogCalendarCallback(act=DialogCalAct.cancel, year=year, month=1, day=1).pack()
+        ))
+        nav_row.append(InlineKeyboardButton(
+            text='>>',
+            callback_data=DialogCalendarCallback(act=DialogCalAct.next_y, year=year, month=1, day=1).pack()
+        ))
+        kb.append(nav_row)
+        return InlineKeyboardMarkup(row_width=5, inline_keyboard=kb)
+
+    async def process_selection(self, query: CallbackQuery, data: DialogCalendarCallback) -> tuple:
+        return_data = (False, None)
+        if data.act == DialogCalAct.ignore:
+            await query.answer(cache_time=60)
+        if data.act == DialogCalAct.set_y:
+            await query.message.edit_reply_markup(reply_markup=await self._get_month_kb(int(data.year)))
+        if data.act == DialogCalAct.prev_y:
+            new_year = int(data.year) - 5
+            await query.message.edit_reply_markup(reply_markup=await self.start_calendar(year=new_year))
+        if data.act == DialogCalAct.next_y:
+            new_year = int(data.year) + 5
+            await query.message.edit_reply_markup(reply_markup=await self.start_calendar(year=new_year))
+        if data.act == DialogCalAct.start:
+            await query.message.edit_reply_markup(reply_markup=await self.start_calendar(int(data.year)))
+        if data.act == DialogCalAct.set_m:
+            await query.message.edit_reply_markup(reply_markup=await self._get_days_kb(int(data.year), int(data.month)))
+        if data.act == DialogCalAct.day:
+
+            return await self.process_day_select(data, query)
+
+        if data.act == DialogCalAct.cancel:
+            await query.message.delete_reply_markup()
+        return return_data

smart_bot_factory/aiogram_calendar/schemas.py

@@ -0,0 +1,78 @@
+from typing import Optional
+from enum import Enum
+
+from pydantic import BaseModel, conlist, Field
+
+from aiogram.filters.callback_data import CallbackData
+
+
+class SimpleCalAct(str, Enum):
+    ignore = 'IGNORE'
+    prev_y = 'PREV-YEAR'
+    next_y = 'NEXT-YEAR'
+    prev_m = 'PREV-MONTH'
+    next_m = 'NEXT-MONTH'
+    cancel = 'CANCEL'
+    today = 'TODAY'
+    day = 'DAY'
+
+
+class DialogCalAct(str, Enum):
+    ignore = 'IGNORE'
+    set_y = 'SET-YEAR'
+    set_m = 'SET-MONTH'
+    prev_y = 'PREV-YEAR'
+    next_y = 'NEXT-YEAR'
+    cancel = 'CANCEL'
+    start = 'START'
+    day = 'SET-DAY'
+
+
+class CalendarCallback(CallbackData, prefix="calendar"):
+    act: str
+    year: Optional[int] = None
+    month: Optional[int] = None
+    day: Optional[int] = None
+
+
+class SimpleCalendarCallback(CalendarCallback, prefix="simple_calendar"):
+    act: SimpleCalAct
+
+
+class DialogCalendarCallback(CalendarCallback, prefix="dialog_calendar"):
+    act: DialogCalAct
+
+
+class CalendarLabels(BaseModel):
+    "Schema to pass labels for calendar. Can be used to put in different languages"
+    days_of_week: conlist(str, max_length=7, min_length=7) = ["Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"]
+    months: conlist(str, max_length=12, min_length=12) = [
+        "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+    ]
+    cancel_caption: str = Field(default='Cancel', description='Caprion for Cancel button')
+    today_caption: str = Field(default='Today', description='Caprion for Cancel button')
+
+
+HIGHLIGHT_FORMAT = "[{}]"
+
+
+def highlight(text):
+    return HIGHLIGHT_FORMAT.format(text)
+
+
+def superscript(text):
+    normal = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-=()"
+    super_s = "ᴬᴮᶜᴰᴱᶠᴳᴴᴵᴶᴷᴸᴹᴺᴼᴾQᴿˢᵀᵁⱽᵂˣʸᶻᵃᵇᶜᵈᵉᶠᵍʰᶦʲᵏˡᵐⁿᵒᵖ۹ʳˢᵗᵘᵛʷˣʸᶻ⁰¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾"
+    output = ''
+    for i in text:
+        output += (super_s[normal.index(i)] if i in normal else i)
+    return output
+
+
+def subscript(text):
+    normal = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-=()"
+    sub_s = "ₐ₈CDₑբGₕᵢⱼₖₗₘₙₒₚQᵣₛₜᵤᵥwₓᵧZₐ♭꜀ᑯₑբ₉ₕᵢⱼₖₗₘₙₒₚ૧ᵣₛₜᵤᵥwₓᵧ₂₀₁₂₃₄₅₆₇₈₉₊₋₌₍₎"
+    output = ''
+    for i in text:
+        output += (sub_s[normal.index(i)] if i in normal else i)
+    return output

smart_bot_factory/aiogram_calendar/simple_calendar.py

@@ -0,0 +1,180 @@
+import calendar
+from datetime import datetime, timedelta
+
+from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+from aiogram.types import CallbackQuery
+
+from .schemas import SimpleCalendarCallback, SimpleCalAct, highlight, superscript
+from .common import GenericCalendar
+
+
+class SimpleCalendar(GenericCalendar):
+
+    ignore_callback = SimpleCalendarCallback(act=SimpleCalAct.ignore).pack()  # placeholder for no answer buttons
+
+    async def start_calendar(
+        self,
+        year: int = datetime.now().year,
+        month: int = datetime.now().month
+    ) -> InlineKeyboardMarkup:
+        """
+        Creates an inline keyboard with the provided year and month
+        :param int year: Year to use in the calendar, if None the current year is used.
+        :param int month: Month to use in the calendar, if None the current month is used.
+        :return: Returns InlineKeyboardMarkup object with the calendar.
+        """
+
+        today = datetime.now()
+        now_weekday = self._labels.days_of_week[today.weekday()]
+        now_month, now_year, now_day = today.month, today.year, today.day
+
+        def highlight_month():
+            month_str = self._labels.months[month - 1]
+            if now_month == month and now_year == year:
+                return highlight(month_str)
+            return month_str
+
+        def highlight_weekday():
+            if now_month == month and now_year == year and now_weekday == weekday:
+                return highlight(weekday)
+            return weekday
+
+        def format_day_string():
+            date_to_check = datetime(year, month, day)
+            if self.min_date and date_to_check < self.min_date:
+                return superscript(str(day))
+            elif self.max_date and date_to_check > self.max_date:
+                return superscript(str(day))
+            return str(day)
+
+        def highlight_day():
+            day_string = format_day_string()
+            if now_month == month and now_year == year and now_day == day:
+                return highlight(day_string)
+            return day_string
+
+        # building a calendar keyboard
+        kb = []
+
+        # inline_kb = InlineKeyboardMarkup(row_width=7)
+        # First row - Year
+        years_row = []
+        years_row.append(InlineKeyboardButton(
+            text="<<",
+            callback_data=SimpleCalendarCallback(act=SimpleCalAct.prev_y, year=year, month=month, day=1).pack()
+        ))
+        years_row.append(InlineKeyboardButton(
+            text=str(year) if year != now_year else highlight(year),
+            callback_data=self.ignore_callback
+        ))
+        years_row.append(InlineKeyboardButton(
+            text=">>",
+            callback_data=SimpleCalendarCallback(act=SimpleCalAct.next_y, year=year, month=month, day=1).pack()
+        ))
+        kb.append(years_row)
+
+        # Month nav Buttons
+        month_row = []
+        month_row.append(InlineKeyboardButton(
+            text="<",
+            callback_data=SimpleCalendarCallback(act=SimpleCalAct.prev_m, year=year, month=month, day=1).pack()
+        ))
+        month_row.append(InlineKeyboardButton(
+            text=highlight_month(),
+            callback_data=self.ignore_callback
+        ))
+        month_row.append(InlineKeyboardButton(
+            text=">",
+            callback_data=SimpleCalendarCallback(act=SimpleCalAct.next_m, year=year, month=month, day=1).pack()
+        ))
+        kb.append(month_row)
+
+        # Week Days
+        week_days_labels_row = []
+        for weekday in self._labels.days_of_week:
+            week_days_labels_row.append(
+                InlineKeyboardButton(text=highlight_weekday(), callback_data=self.ignore_callback)
+            )
+        kb.append(week_days_labels_row)
+
+        # Calendar rows - Days of month
+        month_calendar = calendar.monthcalendar(year, month)
+
+        for week in month_calendar:
+            days_row = []
+            for day in week:
+                if day == 0:
+                    days_row.append(InlineKeyboardButton(text=" ", callback_data=self.ignore_callback))
+                    continue
+                days_row.append(InlineKeyboardButton(
+                    text=highlight_day(),
+                    callback_data=SimpleCalendarCallback(act=SimpleCalAct.day, year=year, month=month, day=day).pack()
+                ))
+            kb.append(days_row)
+
+        # nav today & cancel button
+        cancel_row = []
+        cancel_row.append(InlineKeyboardButton(
+            text=self._labels.cancel_caption,
+            callback_data=SimpleCalendarCallback(act=SimpleCalAct.cancel, year=year, month=month, day=day).pack()
+        ))
+        cancel_row.append(InlineKeyboardButton(text=" ", callback_data=self.ignore_callback))
+        cancel_row.append(InlineKeyboardButton(
+            text=self._labels.today_caption,
+            callback_data=SimpleCalendarCallback(act=SimpleCalAct.today, year=year, month=month, day=day).pack()
+        ))
+        kb.append(cancel_row)
+        return InlineKeyboardMarkup(row_width=7, inline_keyboard=kb)
+
+    async def _update_calendar(self, query: CallbackQuery, with_date: datetime):
+        await query.message.edit_reply_markup(
+            reply_markup=await self.start_calendar(int(with_date.year), int(with_date.month))
+        )
+
+    async def process_selection(self, query: CallbackQuery, data: SimpleCalendarCallback) -> tuple:
+        """
+        Process the callback_query. This method generates a new calendar if forward or
+        backward is pressed. This method should be called inside a CallbackQueryHandler.
+        :param query: callback_query, as provided by the CallbackQueryHandler
+        :param data: callback_data, dictionary, set by calendar_callback
+        :return: Returns a tuple (Boolean,datetime), indicating if a date is selected
+                    and returning the date if so.
+        """
+        return_data = (False, None)
+
+        # processing empty buttons, answering with no action
+        if data.act == SimpleCalAct.ignore:
+            await query.answer(cache_time=60)
+            return return_data
+
+        temp_date = datetime(int(data.year), int(data.month), 1)
+
+        # user picked a day button, return date
+        if data.act == SimpleCalAct.day:
+            return await self.process_day_select(data, query)
+
+        # user navigates to previous year, editing message with new calendar
+        if data.act == SimpleCalAct.prev_y:
+            prev_date = datetime(int(data.year) - 1, int(data.month), 1)
+            await self._update_calendar(query, prev_date)
+        # user navigates to next year, editing message with new calendar
+        if data.act == SimpleCalAct.next_y:
+            next_date = datetime(int(data.year) + 1, int(data.month), 1)
+            await self._update_calendar(query, next_date)
+        # user navigates to previous month, editing message with new calendar
+        if data.act == SimpleCalAct.prev_m:
+            prev_date = temp_date - timedelta(days=1)
+            await self._update_calendar(query, prev_date)
+        # user navigates to next month, editing message with new calendar
+        if data.act == SimpleCalAct.next_m:
+            next_date = temp_date + timedelta(days=31)
+            await self._update_calendar(query, next_date)
+        if data.act == SimpleCalAct.today:
+            # Возвращаем сегодняшнюю дату
+            await query.answer()
+            return (True, datetime.now())
+        if data.act == SimpleCalAct.cancel:
+            await query.message.delete_reply_markup()
+            return ('cancel', None)
+        # at some point user clicks DAY button, returning date
+        return return_data