149 lines
5.0 KiB
Python
149 lines
5.0 KiB
Python
import logging
|
|
from typing import Any, Awaitable, Callable, Dict, Optional
|
|
|
|
from aiogram import BaseMiddleware
|
|
from aiogram.types import (
|
|
CallbackQuery,
|
|
Message,
|
|
Update,
|
|
)
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from bot.keyboards.inline.user_keyboards import get_channel_subscription_keyboard
|
|
from bot.middlewares.i18n import JsonI18n
|
|
from bot.utils.channel_subscription import (
|
|
normalize_required_channel_id,
|
|
resolve_required_channel_link,
|
|
)
|
|
from config.settings import Settings
|
|
from db.dal import user_dal
|
|
|
|
|
|
class ChannelSubscriptionMiddleware(BaseMiddleware):
|
|
"""
|
|
Blocks access to handlers for users who have not yet passed the required channel subscription check.
|
|
The /start command is allowed through so that the handler can re-run the verification.
|
|
""" # noqa: E501
|
|
|
|
def __init__(self, settings: Settings, i18n_instance: JsonI18n):
|
|
super().__init__()
|
|
self.settings = settings
|
|
self.i18n_main_instance = i18n_instance
|
|
|
|
async def __call__(
|
|
self,
|
|
handler: Callable[[Update, Dict[str, Any]], Awaitable[Any]],
|
|
event: Update,
|
|
data: Dict[str, Any],
|
|
) -> Any:
|
|
required_channel_id = normalize_required_channel_id(self.settings.REQUIRED_CHANNEL_ID)
|
|
if not required_channel_id:
|
|
return await handler(event, data)
|
|
|
|
event_user = data.get("event_from_user")
|
|
if not event_user or event_user.id in self.settings.ADMIN_IDS:
|
|
return await handler(event, data)
|
|
|
|
callback_query = event.callback_query
|
|
if (
|
|
callback_query
|
|
and callback_query.data
|
|
and callback_query.data == "channel_subscription:verify"
|
|
):
|
|
return await handler(event, data)
|
|
|
|
# Allow /start to reach the handler so the check can be re-run.
|
|
message_object: Optional[Message] = event.message
|
|
if message_object and message_object.text and message_object.text.startswith("/start"):
|
|
return await handler(event, data)
|
|
|
|
session: AsyncSession = data["session"]
|
|
try:
|
|
db_user = await user_dal.get_user_by_id(session, event_user.id)
|
|
except Exception as db_error:
|
|
logging.error(
|
|
"ChannelSubscriptionMiddleware: failed to fetch user %s: %s",
|
|
event_user.id,
|
|
db_error,
|
|
exc_info=True,
|
|
)
|
|
return await handler(event, data)
|
|
|
|
if not db_user:
|
|
return await handler(event, data)
|
|
|
|
if (
|
|
db_user.channel_subscription_verified
|
|
and db_user.channel_subscription_verified_for == required_channel_id
|
|
):
|
|
return await handler(event, data)
|
|
|
|
i18n_payload: Dict[str, Any] = data.get("i18n_data", {})
|
|
current_lang: str = i18n_payload.get("current_language", self.settings.DEFAULT_LANGUAGE)
|
|
i18n_instance: Optional[JsonI18n] = i18n_payload.get(
|
|
"i18n_instance", self.i18n_main_instance
|
|
)
|
|
|
|
def translate(key: str) -> str:
|
|
if i18n_instance:
|
|
return i18n_instance.gettext(current_lang, key)
|
|
return key
|
|
|
|
bot_instance = data.get("bot") or data.get("bot_instance")
|
|
channel_link = await resolve_required_channel_link(
|
|
bot_instance,
|
|
required_channel_id,
|
|
self.settings.REQUIRED_CHANNEL_LINK,
|
|
)
|
|
keyboard = (
|
|
get_channel_subscription_keyboard(current_lang, i18n_instance, channel_link)
|
|
if i18n_instance
|
|
else None
|
|
)
|
|
prompt_text = translate("channel_subscription_required")
|
|
|
|
if event.callback_query:
|
|
await self._handle_callback(event.callback_query, prompt_text, keyboard, data)
|
|
return
|
|
|
|
if message_object:
|
|
await message_object.answer(prompt_text, reply_markup=keyboard)
|
|
else:
|
|
bot_instance = data["bot"]
|
|
await bot_instance.send_message(
|
|
chat_id=event_user.id,
|
|
text=prompt_text,
|
|
reply_markup=keyboard,
|
|
)
|
|
return
|
|
|
|
async def _handle_callback(
|
|
self,
|
|
callback: CallbackQuery,
|
|
prompt_text: str,
|
|
keyboard,
|
|
data: Dict[str, Any],
|
|
) -> None:
|
|
try:
|
|
await callback.answer(prompt_text, show_alert=True)
|
|
except Exception:
|
|
pass
|
|
|
|
if callback.message:
|
|
try:
|
|
await callback.message.answer(prompt_text, reply_markup=keyboard)
|
|
except Exception as send_error:
|
|
logging.error(
|
|
"ChannelSubscriptionMiddleware: failed to send prompt for callback in chat %s: %s", # noqa: E501
|
|
callback.message.chat.id,
|
|
send_error,
|
|
exc_info=True,
|
|
)
|
|
else:
|
|
bot_instance = data["bot"]
|
|
await bot_instance.send_message(
|
|
chat_id=callback.from_user.id,
|
|
text=prompt_text,
|
|
reply_markup=keyboard,
|
|
)
|