vpnflow 1.0.0__py3-none-any.whl

vpnflow/__init__.py

@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+__author__ = "Michael R. Kisel"
+__copyright__ = "Michael R. Kisel"
+__license__ = "AGPL"
+__version__ = "1.0.0"
+__maintainer__ = "Michael R. Kisel"
+__email__ = "aioboy@yandex.com"
+__status__ = "Stable"

vpnflow/__main__.py

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+from asyncio import get_event_loop
+from logging import getLogger
+
+import uvicorn
+from aiogram.exceptions import TelegramRetryAfter
+
+from vpnflow.bot.base import create_dispatcher
+from vpnflow.cli import create_parser, show_art
+from vpnflow.db.tools import init_db
+from vpnflow.flows._schedule import run_scheduled_tasks
+from vpnflow.misc import load_log_conf
+from vpnflow.settings import settings
+
+logger = getLogger(__name__)
+
+
+def main():
+    """⭐"""
+    show_art()
+    parser, loop = create_parser(), get_event_loop()
+
+    args = parser.parse_args()
+
+    if args.log_conf_file:
+        load_log_conf(args.log_conf_file)
+
+    logger.debug(f"Run with args: {args}, settings: {settings}")
+
+    if args.run_scheduled_tasks:
+        run_scheduled_tasks()
+
+    if args.command == "db":
+        loop.run_until_complete(init_db(args))
+
+    if settings.telegram.webhook_use:
+        uvicorn.run(
+            "vpnflow.web.app:app",
+            host=settings.webserver.host, port=settings.webserver.port,
+            workers=settings.webserver.workers, reload=settings.webserver.reload
+            )
+    else:
+        bot_dispatcher = create_dispatcher()
+        try:
+            loop.run_until_complete(
+                bot_dispatcher.start_polling(
+                    bot_dispatcher.bot,
+                    allowed_updates=bot_dispatcher.resolve_used_update_types(),
+                    polling_timeout=60, skip_updates=True
+                    )
+                )
+        except KeyboardInterrupt:
+            loop.run_until_complete(bot_dispatcher.stop_polling())
+        except TelegramRetryAfter as exc:
+            logger.error(exc)
+        except Exception as exc:
+            logger.exception(exc)
+
+
+if __name__ == "__main__":
+    main()

vpnflow/bot/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

vpnflow/bot/base.py

@@ -0,0 +1,121 @@
+# -*- coding: utf-8 -*-
+from logging import getLogger
+from typing import Optional, Tuple
+
+from aiogram import Bot, Dispatcher
+from aiogram.client.default import DefaultBotProperties
+from aiogram.client.session.aiohttp import AiohttpSession
+from aiogram.enums import ParseMode
+from aiogram.fsm.storage.base import BaseStorage
+from aiogram.fsm.storage.memory import MemoryStorage
+from aiogram.fsm.storage.redis import RedisStorage
+from aiogram.types.bot_command_scope_chat import BotCommandScopeChat
+from aiogram.utils.callback_answer import CallbackAnswerMiddleware
+
+from vpnflow.bot import commands, middleware, routers
+from vpnflow.services import _redis
+from vpnflow.services._telegram import broadcast
+from vpnflow.services.cache import CacheRepository
+from vpnflow.settings import Settings, TelegramSettings, settings
+
+logger = getLogger(__name__)
+telegram_settings = settings.telegram
+
+
+async def on_startup_bot(
+    bot: Bot,
+    bot_dispatcher: Dispatcher,
+    settings_telegram: TelegramSettings = telegram_settings
+    ):
+    """⭐"""
+    logger.info("Startup bot")
+    bot_info = await bot.get_me()
+    logger.info(f"Name: {bot_info.full_name}. Username: @{bot_info.username}. ID: {bot_info.id}")
+    assert bot_info.username == settings.telegram.bot_name
+    await broadcast(bot, settings_telegram.messages["bot-on"], *settings_telegram.admins_id)
+    await bot.delete_my_commands()
+    await bot.set_my_commands(commands.user)
+    for admin_id in settings_telegram.admins_id:
+        await bot.set_my_commands(commands.admin, scope=BotCommandScopeChat(chat_id=admin_id))
+    if settings_telegram.webhook_use:
+        webhook_info = await bot.get_webhook_info()
+        logger.info(f"Webhook info: {webhook_info}")
+        if webhook_info.url != settings_telegram.webhook_url:
+            await bot.delete_webhook(drop_pending_updates=True)
+            await bot.set_webhook(
+                url=settings_telegram.webhook_url, drop_pending_updates=True,
+                allowed_updates=bot_dispatcher.resolve_used_update_types(),
+                max_connections=settings_telegram.webhook_max_connections,
+                secret_token=settings_telegram.webhook_secret_token.get_secret_value()
+                )
+    is_health = await CacheRepository.check_health()
+    assert is_health
+
+
+async def on_shutdown_bot(
+    bot: Bot,
+    bot_dispatcher: Dispatcher,
+    settings_telegram: TelegramSettings = telegram_settings
+    ):
+    """⭐"""
+    logger.info("Shutdown bot")
+    if isinstance(bot_dispatcher.storage, RedisStorage):
+        await bot_dispatcher.storage.close()
+        await bot_dispatcher.fsm.storage.close()
+    await broadcast(bot, settings_telegram.messages["bot-off"], *settings_telegram.admins_id)
+    # if settings_telegram.webhook_use:
+    #     await bot.delete_webhook(drop_pending_updates=True)
+    await bot.session.close()
+    await bot.close()
+    await CacheRepository.close()
+
+
+async def on_startup_bot_dispatcher(dispatcher) -> None:
+    """⭐"""
+    logger.info("Startup bot dispatcher")
+    await on_startup_bot(dispatcher.bot, dispatcher)
+
+
+async def on_shutdown_bot_dispatcher(dispatcher) -> None:
+    """⭐"""
+    logger.info("Shutdown bot dispatcher")
+    await on_shutdown_bot(dispatcher.bot, dispatcher)
+
+
+def create_bot(
+    settings_telegram: TelegramSettings = telegram_settings,
+    session: Optional[AiohttpSession] = None
+    ) -> Bot:
+    """⭐"""
+    if session is None:
+        session: AiohttpSession = AiohttpSession()
+    return Bot(
+        token=settings_telegram.bot_token.get_secret_value(),
+        default=DefaultBotProperties(parse_mode=ParseMode.HTML),
+        session=session
+        )
+
+
+def create_dispatcher(
+    bot: Bot = create_bot(),
+    middlewares: Tuple = middleware.ALL,
+    routers: Tuple = routers.ALL,
+    settings: Settings = settings,
+    on_startup = on_startup_bot_dispatcher,
+    on_shutdown = on_shutdown_bot_dispatcher
+    ) -> Dispatcher:
+    """⭐"""
+    redis_url = settings.telegram.redis_url.get_secret_value()
+    if redis_url:
+        storage: BaseStorage = RedisStorage(redis=_redis.create_client(redis_url))
+    else:
+        storage: BaseStorage = MemoryStorage()
+    dispatcher = Dispatcher(name="bot_dispatcher", storage=storage)
+    dispatcher.bot = bot
+    for _middleware in middlewares:
+        dispatcher.update.middleware.register(_middleware)
+    dispatcher.callback_query.middleware(CallbackAnswerMiddleware())
+    dispatcher.include_routers(*routers)
+    dispatcher.startup.register(on_startup)
+    dispatcher.shutdown.register(on_shutdown)
+    return dispatcher

vpnflow/bot/callbacks.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+from typing import Any, Optional, Union
+
+from aiogram.filters.callback_data import CallbackData
+
+
+class PayPlanCallback(CallbackData, prefix="payplan"):
+    """⭐"""
+    action: str
+    value: Union[int, str]
+
+
+class YesNoCallback(CallbackData, prefix="yesno"):
+    """⭐"""
+    value: bool
+
+
+class AdminCallback(CallbackData, prefix="admin"):
+    """⭐"""
+    action: str
+
+
+class SupportCallback(CallbackData, prefix="support"):
+    """⭐"""
+    action: str
+
+
+class UserCallback(CallbackData, prefix="user"):
+    """⭐"""
+    action: str
+    value: Optional[Any] = None
+
+
+class NotifyCallback(CallbackData, prefix="notify"):
+    """⭐"""
+    value: str

vpnflow/bot/commands.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+from aiogram.types import BotCommand
+
+from vpnflow.enums import BotCommands, BotCommandsAdmin
+from vpnflow.settings import settings
+
+
+def build_menu_from_enum(enum, commands_text=settings.telegram.messages["commands"]):
+    """⭐"""
+    for k, _ in enum.__members__.items():
+        yield BotCommand(command=f"/{k}", description=commands_text[k])
+
+
+user = list(build_menu_from_enum(BotCommands))
+admin = user + list(build_menu_from_enum(BotCommandsAdmin))

vpnflow/bot/filters.py

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+from aiogram.filters import BaseFilter
+from aiogram.types import Message
+
+from vpnflow.settings import settings
+
+
+class AdminFilter(BaseFilter):
+    """⭐"""
+
+    ADMINS = settings.telegram.admins_id
+
+    async def __call__(self, event: Message) -> bool:
+        user = event.from_user
+        if user:
+            return user.id in self.ADMINS
+        return False
+
+
+class BlacklistFilter(BaseFilter):
+    """⭐"""
+
+    BLACKLIST = set(settings.telegram.blacklist)
+
+    async def __call__(self, event: Message) -> bool:
+        user = event.from_user
+        if user:
+            return False if user.id in self.BLACKLIST else True

vpnflow/bot/keyboards/__init__.py

@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+from . import inline

vpnflow/bot/keyboards/inline.py

@@ -0,0 +1,162 @@
+# -*- coding: utf-8 -*-
+from functools import lru_cache
+
+from aiogram.types import WebAppInfo
+from aiogram.utils.keyboard import InlineKeyboardBuilder, InlineKeyboardMarkup
+
+from vpnflow.bot import callbacks as cb
+from vpnflow.settings import settings
+
+buttons_text = settings.telegram.messages["buttons"]
+
+
+def create_inline_keyboard(*buttons_data, rows_num=None, cols_num=None, attach=None, as_markup=True):
+    """⭐"""
+    kb = InlineKeyboardBuilder()
+    for button_text, button_callback in buttons_data:
+        kb.button(text=button_text, callback_data=button_callback)
+    if attach:
+        kb.attach(attach)
+    if rows_num:
+        if cols_num:
+            kb.adjust(rows_num, cols_num)
+        else:
+            kb.adjust(rows_num)
+    if as_markup:
+        return kb.as_markup()
+    return kb
+
+
+@lru_cache(maxsize=32)
+def build_referral(url: str) -> InlineKeyboardMarkup:
+    """⭐"""
+    kb = InlineKeyboardBuilder()
+    kb.button(text=buttons_text["referral-share"], url=f"https://telegram.me/share/url?url={url}")
+    kb.button(text=buttons_text["start"], callback_data=cb.UserCallback(action="start"))
+    kb.adjust(1)
+    return kb.as_markup()
+
+
+@lru_cache(maxsize=32)
+def build_setup(url: str) -> InlineKeyboardMarkup:
+    """⭐"""
+    kb = InlineKeyboardBuilder()
+    kb.button(text=buttons_text["setup-open"], web_app=WebAppInfo(url=url))
+    return kb.as_markup()
+
+
+async def build_pay_plans(pay_plans_agenerator) -> InlineKeyboardMarkup:
+    """⭐"""
+    kb_data = []
+    async for pay_plan in pay_plans_agenerator:
+        kb_data.append(
+            (
+                pay_plan.button_text,
+                cb.PayPlanCallback(action="choice-pay-plan", value=pay_plan.id))
+                )
+    kb_data.append((buttons_text["back"], cb.UserCallback(action="start")))
+    return create_inline_keyboard(*kb_data, rows_num=1)
+
+
+def build_pay_plan_prices(pay_plan) -> InlineKeyboardMarkup:
+    """⭐"""
+    kb_data = []
+    for pay_plan_price in pay_plan.prices:
+        kb_data.append(
+            (
+                pay_plan_price.currency.symbol,
+                cb.PayPlanCallback(action="choice-pay-method", value=pay_plan_price.payment_method))
+            )
+    return create_inline_keyboard(*kb_data, rows_num=2)
+
+
+@lru_cache(maxsize=32)
+def build_setup_steps(download_url: str, add_url: str) -> InlineKeyboardMarkup:
+    """⭐"""
+    kb = InlineKeyboardBuilder()
+    kb.button(text=buttons_text["setup-download"], url=download_url)
+    kb.button(text=buttons_text["setup-add"], url=add_url)
+    kb.button(text=buttons_text["start"], callback_data=cb.UserCallback(action="start"))
+    kb.adjust(1)
+    return kb.as_markup()
+
+
+support = InlineKeyboardBuilder()
+support.button(text=buttons_text["help-faq"], web_app=WebAppInfo(url=settings.business.url_faq))
+support.button(text=buttons_text["help-ask"], url=settings.business.url_support)
+support.button(text=buttons_text["setup-help"], callback_data=cb.UserCallback(action="setup-help"))
+support.button(text=buttons_text["back"], callback_data=cb.UserCallback(action="start"))
+support.adjust(1)
+support = support.as_markup()
+
+support_back = InlineKeyboardBuilder()
+support_back.button(text=buttons_text["back"], callback_data=cb.UserCallback(action="help"))
+support_back.adjust(1)
+support_back = support_back.as_markup()
+
+yes_no_menu = create_inline_keyboard(
+    *(
+        (buttons_text["choice-yes"], cb.YesNoCallback(value=True)),
+        (buttons_text["choice-no"], cb.YesNoCallback(value=False))
+    ), rows_num=2
+)
+
+user_promo = create_inline_keyboard(
+    *(
+        (buttons_text["promo-again"], cb.UserCallback(action="promo")),
+        (buttons_text["start"], cb.UserCallback(action="start"))
+    ), rows_num=1
+)
+
+user_welcome = InlineKeyboardBuilder()
+user_welcome.button(text=buttons_text["start-accept"], callback_data=cb.UserCallback(action="sign_up"))
+user_welcome.adjust(1)
+user_welcome = user_welcome.as_markup()
+
+user_start = InlineKeyboardBuilder()
+user_start.button(text=buttons_text["start"], callback_data=cb.UserCallback(action="start"))
+user_start = user_start.as_markup()
+
+user_start_new = InlineKeyboardBuilder()
+user_start_new.button(text=buttons_text["start-setup"], callback_data=cb.UserCallback(action="setup"))
+user_start_new = user_start_new.as_markup()
+
+user_setup_platform = create_inline_keyboard(
+    *(
+        (
+            platform, cb.UserCallback(action="setup-platform", value=platform)
+            ) for platform in settings.business.supported_platforms
+    ), rows_num=4
+)
+
+user = create_inline_keyboard(
+    *(
+        (
+            buttons_text[k], cb.UserCallback(action=k)
+            ) for k in ("pay", "setup", "promo", "invite", "help")
+    ), rows_num=1
+)
+
+
+admin = create_inline_keyboard(
+    *(
+        (
+            buttons_text[f"admin-{k}"], cb.AdminCallback(action=k)
+            ) for k in ("stats", "notify", "coupons", "services")
+    ), rows_num=1
+)
+
+admin_notify = create_inline_keyboard(
+    *(
+        (buttons_text["admin-notify-all"], cb.NotifyCallback(value="all")),
+        (buttons_text["admin-notify-active"], cb.NotifyCallback(value="active")),
+        (buttons_text["admin-notify-expired"], cb.NotifyCallback(value="expired")),
+        (buttons_text["admin-notify-pay-expired"], cb.NotifyCallback(value="pay-expired")),
+        (buttons_text["admin-notify-pay-no-expired"], cb.NotifyCallback(value="pay-no-expired")),
+        (buttons_text["back"], cb.AdminCallback(action="panel"))
+    ), rows_num=1
+)
+
+admin_start = InlineKeyboardBuilder()
+admin_start.button(text=buttons_text["panel"], callback_data=cb.AdminCallback(action="panel"))
+admin_start = admin_start.as_markup()

vpnflow/bot/middleware.py

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+from logging import getLogger
+from typing import Any, Awaitable, Callable, Dict
+
+from aiogram import BaseMiddleware
+from aiogram.types import CallbackQuery, Message, TelegramObject
+
+from vpnflow.bot import keyboards as kbs
+from vpnflow.bot.callbacks import UserCallback
+from vpnflow.services import business
+from vpnflow.services._telegram import edit_callback
+from vpnflow.settings import settings
+
+logger = getLogger(__name__)
+messages = settings.telegram.messages
+
+
+class CheckAcceptMiddleware(BaseMiddleware):
+    """⭐"""
+
+    def __init__(
+        self,
+        callbacks = ("start", "pay", "setup", "promo", "invite", "help", "setup-platform", "setup-help")
+        ) -> None:
+        self.callbacks = callbacks
+
+    async def __call__(
+            self,
+            handler: Callable[[TelegramObject, Dict[str, Any]], Awaitable[Any]],
+            event: TelegramObject,
+            data: Dict[str, Any],
+    ) -> Any:
+        if isinstance(event, Message) and "/start" not in str(event.text):
+            user = await business.get_user(telegram_id=event.from_user.id)
+            if user and user.marzban_username is None:
+                await event.answer(messages["start-welcome"], reply_markup=kbs.inline.user_welcome)
+                return
+            else:
+                data["user"] = user
+                if user is None:
+                    logger.warning(f"User is None, {event.from_user.id}")
+                    return
+        if isinstance(event, CallbackQuery):
+            callback_data = data.get("callback_data")
+            if (
+                callback_data and
+                isinstance(callback_data, UserCallback) and
+                callback_data.action in self.callbacks
+            ):
+                user = await business.get_user(telegram_id=event.from_user.id)
+                if user and user.marzban_username is None:
+                    await edit_callback(event, messages["start-welcome"], reply_markup=kbs.inline.user_welcome)
+                    return
+                else:
+                    data["user"] = user
+                    if user is None:
+                        logger.warning(f"User is None, {event.from_user.id}")
+                        return
+        result = await handler(event, data)
+        return result
+
+
+class FilterNoUserMiddleware(BaseMiddleware):
+    """⭐"""
+
+    async def __call__(
+            self,
+            handler: Callable[[TelegramObject, Dict[str, Any]], Awaitable[Any]],
+            event: TelegramObject,
+            data: Dict[str, Any],
+    ) -> Any:
+        if isinstance(event, (CallbackQuery, Message)) and event.from_user is None:
+            return
+        result = await handler(event, data)
+        return result
+
+
+ALL = (FilterNoUserMiddleware(), )

vpnflow/bot/routers/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+from vpnflow.bot.routers import admin, base, errors
+
+ALL = (base.router, errors.router, admin.router)