Add Docker build workflow and enhance admin functionalities

- Introduced a new GitHub Actions workflow for building and pushing the development Docker image.
- Added inline mode handling for user interactions, allowing users to share referral links and view statistics.
- Enhanced admin functionalities with new sections for user management, statistics, and promo code management.
- Implemented CSV export for logs and improved notification services for various events, including new user registrations and payment notifications.
- Updated localization files to support new features and commands.

.github/workflows/dev-docker-build.yml

@@ -0,0 +1,56 @@
+name: Build and Push Dev Docker Image
+
+on:
+  push:
+    branches:
+      - dev
+  pull_request:
+    branches:
+      - dev
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    - name: Log in to Container Registry
+      uses: docker/login-action@v3
+      with:
+        registry: ${{ env.REGISTRY }}
+        username: ${{ github.actor }}
+        password: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Extract metadata (tags, labels) for Docker
+      id: meta
+      uses: docker/metadata-action@v5
+      with:
+        images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+        tags: |
+          type=ref,event=branch
+          type=ref,event=pr
+          type=sha,prefix={{branch}}-
+        flavor: |
+          latest=false
+
+    - name: Build and push Docker image
+      uses: docker/build-push-action@v5
+      with:
+        context: .
+        push: true
+        tags: ${{ steps.meta.outputs.tags }}
+        labels: ${{ steps.meta.outputs.labels }}
+        cache-from: type=gha
+        cache-to: type=gha,mode=max
+
+    - name: Image digest
+      run: echo ${{ steps.meta.outputs.digest }}

bot/handlers/admin/common.py

@@ -6,7 +6,11 @@ from typing import Optional
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from config.settings import Settings
-from bot.keyboards.inline.admin_keyboards import get_admin_panel_keyboard
+from bot.keyboards.inline.admin_keyboards import (
+    get_admin_panel_keyboard, get_stats_monitoring_keyboard, 
+    get_user_management_keyboard, get_ban_management_keyboard,
+    get_promo_marketing_keyboard, get_system_functions_keyboard
+)
 from bot.middlewares.i18n import JsonI18n
 from bot.services.panel_api_service import PanelApiService
 from bot.services.subscription_service import SubscriptionService
@@ -75,6 +79,9 @@ async def admin_panel_actions_callback_handler(
     elif action == "create_promo":
         await admin_promo_handlers.create_promo_prompt_handler(
             callback, state, i18n_data, settings, session)
+    elif action == "create_bulk_promo":
+        await admin_promo_handlers.create_bulk_promo_prompt_handler(
+            callback, state, i18n_data, settings, session)
     elif action == "manage_promos":
         await admin_promo_handlers.manage_promo_codes_handler(
             callback, i18n_data, settings, session)
@@ -87,6 +94,10 @@ async def admin_panel_actions_callback_handler(
     elif action == "unban_user_prompt":
         await admin_user_mgmnt_handlers.unban_user_prompt_handler(
             callback, state, i18n_data, settings, session)
+    elif action == "users_management":
+        from . import user_management as admin_user_management_handlers
+        await admin_user_management_handlers.user_management_menu_handler(
+            callback, state, i18n_data, settings, session)
     elif action == "view_banned":
 
         await admin_user_mgmnt_handlers.view_banned_users_handler(
@@ -121,3 +132,58 @@ async def admin_panel_actions_callback_handler(
             f"Unknown admin_action received: {action} from callback {callback.data}"
         )
         await callback.answer(_("admin_unknown_action"), show_alert=True)
+
+
+@router.callback_query(F.data.startswith("admin_section:"))
+async def admin_section_handler(callback: types.CallbackQuery, state: FSMContext, 
+                               settings: Settings, i18n_data: dict, session: AsyncSession):
+    section = callback.data.split(":")[1]
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    if not i18n:
+        await callback.answer("Language error.", show_alert=True)
+        return
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs)
+
+    if not callback.message:
+        await callback.answer("Error: message context lost.", show_alert=True)
+        return
+
+    try:
+        if section == "stats_monitoring":
+            await callback.message.edit_text(
+                _("admin_stats_and_monitoring_section"),
+                reply_markup=get_stats_monitoring_keyboard(i18n, current_lang)
+            )
+        elif section == "user_management":
+            await callback.message.edit_text(
+                _("admin_user_management_section"),
+                reply_markup=get_user_management_keyboard(i18n, current_lang)
+            )
+        elif section == "ban_management":
+            await callback.message.edit_text(
+                _("admin_ban_management_section"),
+                reply_markup=get_ban_management_keyboard(i18n, current_lang)
+            )
+        elif section == "promo_marketing":
+            await callback.message.edit_text(
+                _("admin_promo_marketing_section"),
+                reply_markup=get_promo_marketing_keyboard(i18n, current_lang)
+            )
+        elif section == "system_functions":
+            await callback.message.edit_text(
+                _("admin_system_functions_section"),
+                reply_markup=get_system_functions_keyboard(i18n, current_lang)
+            )
+        else:
+            await callback.answer(_("admin_unknown_action"), show_alert=True)
+            return
+            
+        await callback.answer()
+    except Exception as e:
+        logging.error(f"Error handling admin section {section}: {e}")
+        await callback.message.answer(
+            _("error_occurred_try_again"),
+            reply_markup=get_admin_panel_keyboard(i18n, current_lang, settings)
+        )
+        await callback.answer()

bot/handlers/admin/logs_admin.py

@@ -1,6 +1,9 @@
 import logging
 import math
 import re
+import csv
+import io
+from datetime import datetime
 from aiogram import Router, F, types, Bot
 from aiogram.fsm.context import FSMContext
 from typing import Optional, List, Dict, Any
@@ -321,3 +324,106 @@ async def cancel_log_user_input_state_to_menu(callback: types.CallbackQuery,
     await state.clear()
 
     await display_logs_menu(callback, i18n_data, settings, session)
+
+
+@router.callback_query(F.data == "admin_logs:export_csv")
+async def export_logs_csv_handler(callback: types.CallbackQuery,
+                                 settings: Settings, i18n_data: dict,
+                                 session: AsyncSession):
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    if not i18n or not callback.message:
+        await callback.answer("Error processing CSV export.", show_alert=True)
+        return
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs)
+
+    await callback.answer(_(
+        "admin_logs_csv_export_started",
+        default="🔄 Начинаю экспорт логов в CSV..."
+    ))
+
+    try:
+        # Get all logs (limit to 10000 for performance)
+        logs_models = await message_log_dal.get_all_message_logs(
+            session, limit=10000, offset=0)
+        
+        if not logs_models:
+            await callback.message.answer(_(
+                "admin_logs_csv_no_data",
+                default="❌ Нет данных для экспорта"
+            ))
+            return
+
+        # Create CSV content
+        csv_buffer = io.StringIO()
+        csv_writer = csv.writer(csv_buffer, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL)
+        
+        # Write header
+        headers = [
+            _("admin_csv_header_log_id", default="Log ID"),
+            _("admin_csv_header_timestamp", default="Timestamp"),
+            _("admin_csv_header_user_id", default="User ID"),
+            _("admin_csv_header_telegram_username", default="Telegram Username"),
+            _("admin_csv_header_telegram_first_name", default="Telegram First Name"),
+            _("admin_csv_header_event_type", default="Event Type"),
+            _("admin_csv_header_content", default="Content"),
+            _("admin_csv_header_is_admin_event", default="Is Admin Event"),
+            _("admin_csv_header_target_user_id", default="Target User ID"),
+            _("admin_csv_header_raw_update_preview", default="Raw Update Preview")
+        ]
+        csv_writer.writerow(headers)
+        
+        # Write data rows
+        for log in logs_models:
+            # Format timestamp
+            timestamp_str = log.timestamp.strftime('%Y-%m-%d %H:%M:%S UTC') if log.timestamp else ''
+            
+            # Clean content and raw_update_preview (remove newlines and quotes for CSV)
+            content_clean = (log.content or '').replace('\n', ' ').replace('\r', ' ').strip()
+            raw_update_clean = (log.raw_update_preview or '').replace('\n', ' ').replace('\r', ' ').strip()
+            
+            row = [
+                log.log_id or '',
+                timestamp_str,
+                log.user_id or '',
+                log.telegram_username or '',
+                log.telegram_first_name or '',
+                log.event_type or '',
+                content_clean,
+                'Yes' if log.is_admin_event else 'No',
+                log.target_user_id or '',
+                raw_update_clean
+            ]
+            csv_writer.writerow(row)
+        
+        # Create file
+        csv_content = csv_buffer.getvalue()
+        csv_buffer.close()
+        
+        # Generate filename with current timestamp
+        now = datetime.now()
+        filename = f"message_logs_{now.strftime('%Y%m%d_%H%M%S')}.csv"
+        
+        # Send as document
+        csv_file = types.BufferedInputFile(
+            csv_content.encode('utf-8-sig'),  # BOM for Excel compatibility
+            filename=filename
+        )
+        
+        await callback.message.answer_document(
+            csv_file,
+            caption=_(
+                "admin_logs_csv_export_success",
+                default="✅ Экспорт логов завершен!\n\n📊 Записей: {count}\n📅 Дата экспорта: {date}",
+                count=len(logs_models),
+                date=now.strftime('%Y-%m-%d %H:%M:%S')
+            )
+        )
+        
+    except Exception as e:
+        logging.error(f"Error exporting logs to CSV: {e}", exc_info=True)
+        await callback.message.answer(_(
+            "admin_logs_csv_export_failed",
+            default="❌ Ошибка при экспорте логов: {error}",
+            error=str(e)
+        ))

bot/handlers/admin/promo_codes.py

@@ -1,4 +1,6 @@
 import logging
+import random
+import string
 from aiogram import Router, F, types, Bot
 from aiogram.filters import StateFilter
 from aiogram.fsm.context import FSMContext
@@ -340,6 +342,7 @@ async def promo_delete_handler(callback: types.CallbackQuery, i18n_data: dict,
     StateFilter(
         AdminStates.waiting_for_promo_details,
         AdminStates.waiting_for_promo_edit_details,
+        AdminStates.waiting_for_bulk_promo_details,
     ),
 )
 async def cancel_promo_creation_state_to_menu(callback: types.CallbackQuery,
@@ -365,3 +368,219 @@ async def cancel_promo_creation_state_to_menu(callback: types.CallbackQuery,
 
     await callback.answer(_("admin_action_cancelled_default_alert"))
     await state.clear()
+
+
+async def create_bulk_promo_prompt_handler(callback: types.CallbackQuery,
+                                          state: FSMContext, i18n_data: dict,
+                                          settings: Settings,
+                                          session: AsyncSession):
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    if not i18n or not callback.message:
+        await callback.answer("Error preparing bulk promo creation.",
+                              show_alert=True)
+        return
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs)
+
+    prompt_text = _(
+        "admin_bulk_promo_create_prompt",
+        default="📦 Массовое создание промокодов\n\nВведите данные в формате:\n<количество> <бонусные_дни> <максимальное_использование> [дни_действия]\n\nПример: 50 7 100 30\n(создаст 50 промокодов на 7 дней с лимитом 100 активаций каждый, действующих 30 дней)",
+        example_format="50 7 100 30"
+    )
+
+    try:
+        await callback.message.edit_text(
+            prompt_text,
+            reply_markup=get_back_to_admin_panel_keyboard(current_lang, i18n))
+    except Exception as e:
+        logging.warning(
+            f"Could not edit message for bulk promo prompt: {e}. Sending new.")
+        await callback.message.answer(
+            prompt_text,
+            reply_markup=get_back_to_admin_panel_keyboard(current_lang, i18n))
+    await callback.answer()
+    await state.set_state(AdminStates.waiting_for_bulk_promo_details)
+
+
+def generate_unique_promo_code(length: int = 8) -> str:
+    """Generate a unique promotional code"""
+    characters = string.ascii_uppercase + string.digits
+    # Exclude confusing characters
+    characters = characters.replace('0', '').replace('O', '').replace('1', '').replace('I', '').replace('L', '')
+    return ''.join(random.choice(characters) for _ in range(length))
+
+
+@router.message(AdminStates.waiting_for_bulk_promo_details, F.text)
+async def process_bulk_promo_details_handler(message: types.Message,
+                                            state: FSMContext,
+                                            i18n_data: dict,
+                                            settings: Settings,
+                                            session: AsyncSession):
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    if not i18n:
+        await message.reply("Language service error.")
+        return
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs)
+
+    if not message.text:
+        await message.answer(_("admin_promo_invalid_format"))
+        return
+
+    parts = message.text.strip().split()
+    if not (3 <= len(parts) <= 4):
+        await message.answer(_(
+            "admin_bulk_promo_invalid_format",
+            default="❌ Неверный формат. Используйте: <количество> <бонусные_дни> <максимальное_использование> [дни_действия]"
+        ))
+        return
+
+    try:
+        count = int(parts[0])
+        bonus_days = int(parts[1])
+        max_activations = int(parts[2])
+
+        if count <= 0 or count > 1000:
+            raise ValueError(_("admin_bulk_promo_invalid_count", default="Количество должно быть от 1 до 1000"))
+        
+        if bonus_days <= 0 or max_activations <= 0:
+            raise ValueError(_("admin_promo_invalid_bonus_or_activations"))
+
+        valid_until_date: Optional[datetime] = None
+        valid_until_str_display = _("admin_promo_valid_indefinitely")
+
+        if len(parts) == 4:
+            valid_days_from_now = int(parts[3])
+            if valid_days_from_now <= 0:
+                raise ValueError(_("admin_promo_invalid_validity_days"))
+            valid_until_date = datetime.now(
+                timezone.utc) + timedelta(days=valid_days_from_now)
+            valid_until_str_display = _(
+                "admin_promo_valid_until_display",
+                date=valid_until_date.strftime('%Y-%m-%d'))
+
+    except ValueError as e:
+        await message.answer(_(
+            "admin_bulk_promo_invalid_values",
+            default="❌ Неверные значения: {error}",
+            error=str(e)
+        ))
+        return
+    except Exception as e_parse:
+        logging.error(f"Error parsing bulk promo details '{message.text}': {e_parse}")
+        await message.answer(_("admin_promo_invalid_format_general"))
+        return
+
+    admin_id = message.from_user.id if message.from_user else 0
+
+    # Generate unique codes and create promo codes
+    created_codes = []
+    failed_codes = []
+    
+    await message.answer(_(
+        "admin_bulk_promo_creating",
+        default="🔄 Создаю {count} промокодов...",
+        count=count
+    ))
+
+    for i in range(count):
+        try:
+            # Generate unique code
+            attempts = 0
+            while attempts < 10:  # Max 10 attempts to generate unique code
+                code = generate_unique_promo_code()
+                
+                # Check if code already exists
+                existing_promo = await promo_code_dal.get_promo_code_by_code(session, code)
+                if not existing_promo:
+                    break
+                attempts += 1
+            
+            if attempts >= 10:
+                failed_codes.append(f"Failed to generate unique code #{i+1}")
+                continue
+
+            promo_data_to_create = {
+                "code": code,
+                "bonus_days": bonus_days,
+                "max_activations": max_activations,
+                "created_by_admin_id": admin_id,
+                "valid_until": valid_until_date,
+                "is_active": True,
+                "current_activations": 0
+            }
+
+            created_promo = await promo_code_dal.create_promo_code(
+                session, promo_data_to_create)
+            
+            if created_promo:
+                created_codes.append(created_promo.code)
+            else:
+                failed_codes.append(f"Failed to create code #{i+1}")
+
+        except Exception as e:
+            logging.error(f"Error creating bulk promo code #{i+1}: {e}")
+            failed_codes.append(f"Error creating code #{i+1}: {str(e)}")
+
+    try:
+        await session.commit()
+        
+        # Prepare success message
+        success_text_parts = [
+            _(
+                "admin_bulk_promo_created_success",
+                default="✅ Массовое создание завершено!\n\n📦 Создано промокодов: {created_count}\n💎 Бонусных дней: {bonus_days}\n🔄 Макс. активаций каждого: {max_activations}\n⏰ Действительны до: {valid_until}",
+                created_count=len(created_codes),
+                bonus_days=bonus_days,
+                max_activations=max_activations,
+                valid_until=valid_until_str_display
+            )
+        ]
+
+        if failed_codes:
+            success_text_parts.append(f"\n❌ Ошибок: {len(failed_codes)}")
+
+        if created_codes:
+            # Show first few codes as examples
+            codes_to_show = created_codes[:10]  # Show first 10
+            success_text_parts.append(f"\n📝 Примеры созданных кодов:")
+            success_text_parts.append("\n".join([f"• {code}" for code in codes_to_show]))
+            
+            if len(created_codes) > 10:
+                success_text_parts.append(f"... и еще {len(created_codes) - 10} кодов")
+
+        # Send codes as a file if many were created
+        if len(created_codes) > 20:
+            try:
+                codes_text = "\n".join(created_codes)
+                codes_file = types.BufferedInputFile(
+                    codes_text.encode('utf-8'),
+                    filename=f"promo_codes_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"
+                )
+                await message.answer_document(
+                    codes_file,
+                    caption=_(
+                        "admin_bulk_promo_codes_file",
+                        default="📄 Файл со всеми созданными промокодами"
+                    )
+                )
+            except Exception as e:
+                logging.error(f"Failed to send codes file: {e}")
+
+        final_text = "\n".join(success_text_parts)
+        await message.answer(
+            final_text,
+            reply_markup=get_back_to_admin_panel_keyboard(current_lang, i18n))
+
+    except Exception as e_db_commit:
+        await session.rollback()
+        logging.error(f"Failed to commit bulk promo codes creation: {e_db_commit}", exc_info=True)
+        await message.answer(_(
+            "admin_bulk_promo_creation_failed",
+            default="❌ Ошибка при сохранении промокодов в базу данных"
+        ))
+
+    await state.clear()
+
+
+

bot/handlers/admin/statistics.py

@@ -29,13 +29,52 @@ async def show_statistics_handler(callback: types.CallbackQuery,
 
     stats_text_parts = [f"<b>{_('admin_stats_header')}</b>"]
 
-    user_stats_dict = await user_dal.get_user_count_stats_dal(session)
+    # Enhanced user statistics
+    user_stats = await user_dal.get_enhanced_user_statistics(session)
+    
     stats_text_parts.append(
-        _("admin_stats_users",
-          total_users=user_stats_dict.get("total_users", 0),
-          banned_users=user_stats_dict.get("banned_users", 0),
-          active_subs=user_stats_dict.get("users_with_active_subscriptions",
-                                          0)))
+        f"\n<b>👥 {_('admin_enhanced_users_stats_header', default='Пользователи')}</b>"
+    )
+    stats_text_parts.append(
+        f"📊 Всего: <b>{user_stats['total_users']}</b>"
+    )
+    stats_text_parts.append(
+        f"📈 Активных сегодня: <b>{user_stats['active_today']}</b>"
+    )
+    stats_text_parts.append(
+        f"💳 С платной подпиской: <b>{user_stats['paid_subscriptions']}</b>"
+    )
+    stats_text_parts.append(
+        f"🆓 На пробном периоде: <b>{user_stats['trial_users']}</b>"
+    )
+    stats_text_parts.append(
+        f"😴 Неактивных: <b>{user_stats['inactive_users']}</b>"
+    )
+    stats_text_parts.append(
+        f"🚫 Заблокированных: <b>{user_stats['banned_users']}</b>"
+    )
+    stats_text_parts.append(
+        f"🎁 Привлечено по реферальной программе: <b>{user_stats['referral_users']}</b>"
+    )
+    
+    # Financial statistics
+    financial_stats = await payment_dal.get_financial_statistics(session)
+    
+    stats_text_parts.append(
+        f"\n<b>💰 {_('admin_financial_stats_header', default='Финансовая статистика')}</b>"
+    )
+    stats_text_parts.append(
+        f"📅 За сегодня: <b>{financial_stats['today_revenue']:.2f} RUB</b> ({financial_stats['today_payments_count']} платежей)"
+    )
+    stats_text_parts.append(
+        f"📅 За неделю: <b>{financial_stats['week_revenue']:.2f} RUB</b>"
+    )
+    stats_text_parts.append(
+        f"📅 За месяц: <b>{financial_stats['month_revenue']:.2f} RUB</b>"
+    )
+    stats_text_parts.append(
+        f"🏆 За все время: <b>{financial_stats['all_time_revenue']:.2f} RUB</b>"
+    )
 
     last_payments_models: List[
         Payment] = await payment_dal.get_recent_payment_logs_with_user(session,

bot/handlers/inline_mode.py

@@ -0,0 +1,351 @@
+import logging
+from aiogram import Router, types, Bot
+from aiogram.types import InlineQuery, InlineQueryResultArticle, InputTextMessageContent
+from typing import List, Optional
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from config.settings import Settings
+from db.dal import user_dal, payment_dal
+from bot.services.referral_service import ReferralService
+from bot.middlewares.i18n import JsonI18n
+
+router = Router(name="inline_mode_router")
+
+
+@router.inline_query()
+async def inline_query_handler(inline_query: InlineQuery,
+                               settings: Settings,
+                               i18n_data: dict,
+                               referral_service: ReferralService,
+                               bot: Bot,
+                               session: AsyncSession):
+    """Handle inline queries for referral links and admin statistics"""
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    if not i18n:
+        return
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs)
+
+    user_id = inline_query.from_user.id
+    query = inline_query.query.lower().strip()
+    
+    results: List[InlineQueryResultArticle] = []
+    
+    # Check if user is admin
+    is_admin = user_id in settings.ADMIN_IDS if settings.ADMIN_IDS else False
+    
+    try:
+        # For all users: referral functionality
+        if not query or "реф" in query or "ref" in query or "друг" in query or "friend" in query:
+            referral_result = await create_referral_result(
+                inline_query, bot, referral_service, i18n, current_lang
+            )
+            if referral_result:
+                results.append(referral_result)
+        
+        # For admins: statistics
+        if is_admin and (not query or "стат" in query or "stat" in query or "админ" in query or "admin" in query):
+            stats_results = await create_admin_stats_results(
+                session, i18n, current_lang
+            )
+            results.extend(stats_results)
+        
+        # Show help if no specific query
+        if not query:
+            help_result = await create_help_result(i18n, current_lang, is_admin)
+            results.append(help_result)
+        
+        # Limit results to 50 (Telegram limit)
+        results = results[:50]
+        
+        await inline_query.answer(
+            results=results,
+            cache_time=30,  # Cache for 30 seconds
+            is_personal=True  # Results are personalized
+        )
+        
+    except Exception as e:
+        logging.error(f"Error handling inline query from user {user_id}: {e}")
+        # Send empty results in case of error
+        await inline_query.answer(results=[], cache_time=10)
+
+
+async def create_referral_result(inline_query: InlineQuery, bot: Bot,
+                                referral_service: ReferralService,
+                                i18n_instance, lang: str) -> Optional[InlineQueryResultArticle]:
+    """Create referral link result for inline query"""
+    _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
+    
+    try:
+        bot_info = await bot.get_me()
+        bot_username = bot_info.username
+        if not bot_username:
+            return None
+        
+        user_id = inline_query.from_user.id
+        referral_link = referral_service.generate_referral_link(bot_username, user_id)
+        
+        # Create message content
+        message_text = _(
+            "inline_referral_message",
+            default="🚀 Привет! Попробуй этот крутой VPN сервис!\n\n"
+                   "✨ Быстрый и надежный\n"
+                   "🔒 Полная анонимность\n"
+                   "🌍 Серверы по всему миру\n"
+                   "💎 Бесплатный пробный период\n\n"
+                   "Переходи по ссылке: {referral_link}",
+            referral_link=referral_link
+        )
+        
+        return InlineQueryResultArticle(
+            id="referral_link",
+            title=_(
+                "inline_referral_title",
+                default="🎁 Пригласить друга"
+            ),
+            description=_(
+                "inline_referral_description", 
+                default="Поделиться реферальной ссылкой для получения бонусов"
+            ),
+            input_message_content=InputTextMessageContent(
+                message_text=message_text,
+                disable_web_page_preview=True
+            ),
+            thumbnail_url="https://cdn-icons-png.flaticon.com/512/1077/1077114.png"
+        )
+        
+    except Exception as e:
+        logging.error(f"Error creating referral result: {e}")
+        return None
+
+
+async def create_admin_stats_results(session: AsyncSession, i18n_instance, lang: str) -> List[InlineQueryResultArticle]:
+    """Create admin statistics results for inline query"""
+    _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
+    results = []
+    
+    try:
+        # Quick user stats
+        user_stats_result = await create_user_stats_result(session, i18n_instance, lang)
+        if user_stats_result:
+            results.append(user_stats_result)
+        
+        # Quick financial stats
+        financial_stats_result = await create_financial_stats_result(session, i18n_instance, lang)
+        if financial_stats_result:
+            results.append(financial_stats_result)
+        
+        # Quick system stats
+        system_stats_result = await create_system_stats_result(session, i18n_instance, lang)
+        if system_stats_result:
+            results.append(system_stats_result)
+            
+    except Exception as e:
+        logging.error(f"Error creating admin stats results: {e}")
+    
+    return results
+
+
+async def create_user_stats_result(session: AsyncSession, i18n_instance, lang: str) -> Optional[InlineQueryResultArticle]:
+    """Create user statistics result"""
+    _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
+    
+    try:
+        from db.dal.user_dal import get_enhanced_user_statistics
+        user_stats = await get_enhanced_user_statistics(session)
+        
+        stats_text = _(
+            "inline_user_stats_message",
+            default="👥 <b>Статистика пользователей</b>\n\n"
+                   "📊 Всего: <b>{total}</b>\n"
+                   "📈 Активных сегодня: <b>{active_today}</b>\n"
+                   "💳 С платной подпиской: <b>{paid}</b>\n"
+                   "🆓 На пробном периоде: <b>{trial}</b>\n"
+                   "😴 Неактивных: <b>{inactive}</b>\n"
+                   "🚫 Заблокированных: <b>{banned}</b>\n"
+                   "🎁 По реферальной программе: <b>{referral}</b>",
+            total=user_stats['total_users'],
+            active_today=user_stats['active_today'],
+            paid=user_stats['paid_subscriptions'],
+            trial=user_stats['trial_users'],
+            inactive=user_stats['inactive_users'],
+            banned=user_stats['banned_users'],
+            referral=user_stats['referral_users']
+        )
+        
+        return InlineQueryResultArticle(
+            id="admin_user_stats",
+            title=_(
+                "inline_admin_user_stats_title",
+                default="👥 Статистика пользователей"
+            ),
+            description=_(
+                "inline_admin_user_stats_desc",
+                default=f"Всего: {user_stats['total_users']}, Активных: {user_stats['paid_subscriptions']}"
+            ),
+            input_message_content=InputTextMessageContent(
+                message_text=stats_text,
+                parse_mode="HTML"
+            ),
+            thumbnail_url="https://cdn-icons-png.flaticon.com/512/681/681494.png"
+        )
+        
+    except Exception as e:
+        logging.error(f"Error creating user stats result: {e}")
+        return None
+
+
+async def create_financial_stats_result(session: AsyncSession, i18n_instance, lang: str) -> Optional[InlineQueryResultArticle]:
+    """Create financial statistics result"""
+    _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
+    
+    try:
+        from db.dal.payment_dal import get_financial_statistics
+        financial_stats = await get_financial_statistics(session)
+        
+        stats_text = _(
+            "inline_financial_stats_message",
+            default="💰 <b>Финансовая статистика</b>\n\n"
+                   "📅 За сегодня: <b>{today:.2f} RUB</b>\n"
+                   "   ({today_count} платежей)\n"
+                   "📅 За неделю: <b>{week:.2f} RUB</b>\n"
+                   "📅 За месяц: <b>{month:.2f} RUB</b>\n"
+                   "🏆 За все время: <b>{all_time:.2f} RUB</b>",
+            today=financial_stats['today_revenue'],
+            today_count=financial_stats['today_payments_count'],
+            week=financial_stats['week_revenue'],
+            month=financial_stats['month_revenue'],
+            all_time=financial_stats['all_time_revenue']
+        )
+        
+        return InlineQueryResultArticle(
+            id="admin_financial_stats",
+            title=_(
+                "inline_admin_financial_stats_title",
+                default="💰 Финансовая статистика"
+            ),
+            description=_(
+                "inline_admin_financial_stats_desc",
+                default=f"Сегодня: {financial_stats['today_revenue']:.2f} RUB"
+            ),
+            input_message_content=InputTextMessageContent(
+                message_text=stats_text,
+                parse_mode="HTML"
+            ),
+            thumbnail_url="https://cdn-icons-png.flaticon.com/512/2769/2769339.png"
+        )
+        
+    except Exception as e:
+        logging.error(f"Error creating financial stats result: {e}")
+        return None
+
+
+async def create_system_stats_result(session: AsyncSession, i18n_instance, lang: str) -> Optional[InlineQueryResultArticle]:
+    """Create system statistics result with online/offline/expired/limited info"""
+    _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
+    
+    try:
+        from datetime import datetime, timezone
+        from sqlalchemy import select, func, and_
+        from db.models import User, Subscription
+        
+        now = datetime.now(timezone.utc)
+        
+        # Count active subscriptions (online)
+        active_subs_stmt = select(func.count(Subscription.subscription_id)).where(
+            and_(
+                Subscription.is_active == True,
+                Subscription.end_date > now
+            )
+        )
+        active_subs = (await session.execute(active_subs_stmt)).scalar() or 0
+        
+        # Count expired subscriptions
+        expired_subs_stmt = select(func.count(Subscription.subscription_id)).where(
+            and_(
+                Subscription.is_active == True,
+                Subscription.end_date <= now
+            )
+        )
+        expired_subs = (await session.execute(expired_subs_stmt)).scalar() or 0
+        
+        # Count total users (approximation for "total")
+        total_users_stmt = select(func.count(User.user_id))
+        total_users = (await session.execute(total_users_stmt)).scalar() or 0
+        
+        # Offline = users without active subscriptions
+        offline_users = total_users - active_subs
+        
+        stats_text = _(
+            "inline_system_stats_message",
+            default="🖥 <b>Системная статистика</b>\n\n"
+                   "🟢 Онлайн: <b>{online}</b>\n"
+                   "🔴 Офлайн: <b>{offline}</b>\n"
+                   "⏰ Истекшие: <b>{expired}</b>\n"
+                   "👥 Всего пользователей: <b>{total}</b>",
+            online=active_subs,
+            offline=max(0, offline_users),
+            expired=expired_subs,
+            total=total_users
+        )
+        
+        return InlineQueryResultArticle(
+            id="admin_system_stats",
+            title=_(
+                "inline_admin_system_stats_title",
+                default="🖥 Системная статистика"
+            ),
+            description=_(
+                "inline_admin_system_stats_desc",
+                default=f"Онлайн: {active_subs}, Офлайн: {max(0, offline_users)}"
+            ),
+            input_message_content=InputTextMessageContent(
+                message_text=stats_text,
+                parse_mode="HTML"
+            ),
+            thumbnail_url="https://cdn-icons-png.flaticon.com/512/2920/2920277.png"
+        )
+        
+    except Exception as e:
+        logging.error(f"Error creating system stats result: {e}")
+        return None
+
+
+async def create_help_result(i18n_instance, lang: str, is_admin: bool) -> InlineQueryResultArticle:
+    """Create help result explaining inline mode features"""
+    _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
+    
+    if is_admin:
+        help_text = _(
+            "inline_admin_help_message",
+            default="🤖 <b>Inline режим бота</b>\n\n"
+                   "📱 <b>Доступные команды:</b>\n\n"
+                   "🎁 <b>реф/ref</b> - поделиться реферальной ссылкой\n"
+                   "👥 <b>стат/stat</b> - статистика пользователей\n"
+                   "💰 <b>финансы</b> - финансовая статистика\n"
+                   "🖥 <b>система</b> - системная статистика\n\n"
+                   "💡 Просто напишите @{bot_username} и начните вводить команду в любом чате!"
+        )
+        title = _("inline_admin_help_title", default="🤖 Inline помощь (Админ)")
+        description = _("inline_admin_help_desc", default="Доступны команды: реф, стат, финансы, система")
+    else:
+        help_text = _(
+            "inline_user_help_message", 
+            default="🤖 <b>Inline режим бота</b>\n\n"
+                   "📱 <b>Доступные команды:</b>\n\n"
+                   "🎁 <b>реф/ref</b> - поделиться реферальной ссылкой\n\n"
+                   "💡 Просто напишите @{bot_username} и начните вводить 'реф' в любом чате!"
+        )
+        title = _("inline_user_help_title", default="🤖 Inline помощь")
+        description = _("inline_user_help_desc", default="Доступна команда: реф (реферальная ссылка)")
+    
+    return InlineQueryResultArticle(
+        id="help",
+        title=title,
+        description=description,
+        input_message_content=InputTextMessageContent(
+            message_text=help_text,
+            parse_mode="HTML"
+        ),
+        thumbnail_url="https://cdn-icons-png.flaticon.com/512/906/906794.png"
+    )

bot/handlers/user/payment.py

@@ -20,7 +20,7 @@ from bot.services.panel_api_service import PanelApiService
 from bot.services.yookassa_service import YooKassaService
 from bot.middlewares.i18n import JsonI18n
 from config.settings import Settings
-from bot.services.notification_service import notify_admin_new_payment
+from bot.services.notification_service import notify_admin_new_payment, NotificationService
 from bot.keyboards.inline.user_keyboards import get_connect_and_main_keyboard
 
 payment_processing_lock = asyncio.Lock()
@@ -195,6 +195,22 @@ async def process_successful_payment(session: AsyncSession, bot: Bot,
                 f"Failed to send payment details message to user {user_id}: {e_notify}"
             )
 
+        # Send notification about payment
+        try:
+            notification_service = NotificationService(bot, settings, i18n)
+            user = await user_dal.get_user_by_id(session, user_id)
+            await notification_service.notify_payment_received(
+                user_id=user_id,
+                amount=payment_value,
+                currency=settings.DEFAULT_CURRENCY_SYMBOL,
+                months=subscription_months,
+                payment_provider="yookassa",  # This is specifically for YooKassa webhook
+                username=user.username if user else None
+            )
+        except Exception as e:
+            logging.error(f"Failed to send payment notification: {e}")
+        
+        # Legacy notification for backwards compatibility
         await notify_admin_new_payment(
             bot,
             settings,

bot/handlers/user/referral.py

@@ -87,7 +87,8 @@ async def referral_command_handler(event: Union[types.Message,
              referral_link=referral_link,
              bonus_details=bonus_details_str)
 
-    reply_markup_val = get_back_to_main_menu_markup(current_lang, i18n)
+    from bot.keyboards.inline.user_keyboards import get_referral_link_keyboard
+    reply_markup_val = get_referral_link_keyboard(current_lang, i18n)
 
     if isinstance(event, types.Message):
         await event.answer(text,
@@ -106,3 +107,37 @@ async def referral_command_handler(event: Union[types.Message,
                                        reply_markup=reply_markup_val,
                                        disable_web_page_preview=True)
         await event.answer()
+
+
+@router.callback_query(F.data.startswith("referral_action:"))
+async def referral_action_handler(callback: types.CallbackQuery, settings: Settings, 
+                                 i18n_data: dict, referral_service: ReferralService, 
+                                 bot: Bot, session: AsyncSession):
+    action = callback.data.split(":")[1]
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n = i18n_data.get("i18n_instance")
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs)
+
+    if action == "share_message":
+        try:
+            bot_info = await bot.get_me()
+            bot_username = bot_info.username
+            if not bot_username:
+                await callback.answer("Ошибка получения имени бота", show_alert=True)
+                return
+
+            inviter_user_id = callback.from_user.id
+            referral_link = referral_service.generate_referral_link(bot_username, inviter_user_id)
+            
+            friend_message = _("referral_friend_message", referral_link=referral_link)
+            
+            await callback.message.answer(
+                friend_message,
+                disable_web_page_preview=True
+            )
+            
+        except Exception as e:
+            logging.error(f"Error in referral share message: {e}")
+            await callback.answer("Произошла ошибка", show_alert=True)
+        
+    await callback.answer()

bot/handlers/user/start.py

@@ -129,6 +129,8 @@ async def start_command_handler(message: types.Message,
     user_id = user.id
 
     referred_by_user_id: Optional[int] = None
+    promo_code_to_apply: Optional[str] = None
+    
     if command and command.args:
         arg_payload = command.args
         if arg_payload.startswith("ref_"):
@@ -142,6 +144,14 @@ async def start_command_handler(message: types.Message,
                 logging.warning(
                     f"Could not parse referral from /start args '{arg_payload}': {e}"
                 )
+        elif arg_payload.startswith("promo_"):
+            try:
+                promo_code_to_apply = arg_payload.split("_")[1]
+                logging.info(f"User {user_id} started with promo code: {promo_code_to_apply}")
+            except (IndexError, ValueError) as e:
+                logging.warning(
+                    f"Could not parse promo code from /start args '{arg_payload}': {e}"
+                )
 
     db_user = await user_dal.get_user_by_id(session, user_id)
     if not db_user:
@@ -160,6 +170,19 @@ async def start_command_handler(message: types.Message,
             logging.info(
                 f"New user {user_id} added to session. Referred by: {referred_by_user_id or 'N/A'}."
             )
+            
+            # Send notification about new user registration
+            try:
+                from bot.services.notification_service import NotificationService
+                notification_service = NotificationService(message.bot, settings, i18n)
+                await notification_service.notify_new_user_registration(
+                    user_id=user_id,
+                    username=user.username,
+                    first_name=user.first_name,
+                    referred_by_id=referred_by_user_id
+                )
+            except Exception as e:
+                logging.error(f"Failed to send new user notification: {e}")
         except Exception as e_create:
 
             logging.error(
@@ -194,6 +217,53 @@ async def start_command_handler(message: types.Message,
                     exc_info=True)
 
     await message.answer(_(key="welcome", user_name=hd.quote(user.full_name)))
+    
+    # Auto-apply promo code if provided via start parameter
+    if promo_code_to_apply:
+        try:
+            from bot.services.promo_code_service import PromoCodeService
+            promo_code_service = PromoCodeService()
+            
+            success, result = await promo_code_service.apply_promo_code(
+                session, user_id, promo_code_to_apply, current_lang
+            )
+            
+            if success:
+                await session.commit()
+                logging.info(f"Auto-applied promo code '{promo_code_to_apply}' for user {user_id}")
+                
+                # Get updated subscription details
+                active = await subscription_service.get_active_subscription_details(session, user_id)
+                config_link = active.get("config_link") if active else None
+                config_link = config_link or _("config_link_not_available")
+                
+                from datetime import datetime
+                new_end_date = result if isinstance(result, datetime) else None
+                
+                promo_success_text = _(
+                    "promo_code_applied_success_full",
+                    end_date=(new_end_date.strftime("%d.%m.%Y %H:%M:%S") if new_end_date else "N/A"),
+                    config_link=config_link,
+                )
+                
+                from bot.keyboards.inline.user_keyboards import get_connect_and_main_keyboard
+                await message.answer(
+                    promo_success_text,
+                    reply_markup=get_connect_and_main_keyboard(current_lang, i18n, settings, config_link),
+                    parse_mode="HTML"
+                )
+                
+                # Don't show main menu if promo was successfully applied
+                return
+            else:
+                await session.rollback()
+                logging.warning(f"Failed to auto-apply promo code '{promo_code_to_apply}' for user {user_id}: {result}")
+                # Continue to show main menu if promo failed
+                
+        except Exception as e:
+            logging.error(f"Error auto-applying promo code '{promo_code_to_apply}' for user {user_id}: {e}")
+            await session.rollback()
+    
     await send_main_menu(message,
                          settings,
                          i18n_data,

bot/handlers/user/trial_handler.py

@@ -59,21 +59,94 @@ async def request_trial_confirmation_handler(
         await callback.answer()
         return
 
-    traffic_gb_display = (
-        str(settings.TRIAL_TRAFFIC_LIMIT_GB)
-        if settings.TRIAL_TRAFFIC_LIMIT_GB and settings.TRIAL_TRAFFIC_LIMIT_GB > 0
+    # Directly activate trial without confirmation
+    activation_result = await subscription_service.activate_trial_subscription(
+        session, user_id
+    )
+
+    final_message_text_in_chat = ""
+    show_trial_button_after_action = False
+
+    if activation_result and activation_result.get("activated"):
+        await callback.answer(_("trial_activated_alert"), show_alert=True)
+
+        end_date_obj = activation_result.get("end_date")
+        config_link_for_trial = activation_result.get("subscription_url") or _(
+            "config_link_not_available"
+        )
+
+        traffic_gb_val = activation_result.get(
+            "traffic_gb", settings.TRIAL_TRAFFIC_LIMIT_GB
+        )
+        traffic_display = (
+            f"{traffic_gb_val} GB"
+            if traffic_gb_val and traffic_gb_val > 0
             else _("traffic_unlimited")
         )
 
-    await callback.message.edit_text(
-        text=_(
-            "trial_confirm_prompt",
-            days=settings.TRIAL_DURATION_DAYS,
-            traffic_gb=traffic_gb_display,
+        final_message_text_in_chat = _(
+            "trial_activated_details_message",
+            days=activation_result.get("days", settings.TRIAL_DURATION_DAYS),
+            end_date=(
+                end_date_obj.strftime("%Y-%m-%d")
+                if isinstance(end_date_obj, datetime)
+                else "N/A"
             ),
-        reply_markup=get_trial_confirmation_keyboard(current_lang, i18n),
+            config_link=config_link_for_trial,
+            traffic_gb=traffic_display,
+        )
+        
+        # Send notification to admin about new trial
+        await notify_admin_new_trial(
+            callback.bot,
+            settings,
+            i18n,
+            user_id,
+            end_date_obj,
+        )
+    else:
+        message_key_from_service = (
+            activation_result.get("message_key", "trial_activation_failed")
+            if activation_result
+            else "trial_activation_failed"
+        )
+        final_message_text_in_chat = _(message_key_from_service)
+        await callback.answer(final_message_text_in_chat, show_alert=True)
+        if (
+            settings.TRIAL_ENABLED
+            and not await subscription_service.has_had_any_subscription(
+                session, user_id
+            )
+        ):
+            show_trial_button_after_action = True
+
+    try:
+        await callback.message.edit_text(
+            final_message_text_in_chat,
+            parse_mode="HTML",
+            reply_markup=get_main_menu_inline_keyboard(
+                current_lang, i18n, settings, show_trial_button_after_action
+            ),
+            disable_web_page_preview=True,
+        )
+    except Exception as e_edit:
+        logging.warning(
+            f"Could not edit trial result message: {e_edit}. Sending new one."
+        )
+
+        if (
+            callback.message
+            and hasattr(callback.message, "chat")
+            and callback.message.chat
+        ):
+            await callback.message.chat.send_message(
+                final_message_text_in_chat,
+                parse_mode="HTML",
+                reply_markup=get_main_menu_inline_keyboard(
+                    current_lang, i18n, settings, show_trial_button_after_action
+                ),
+                disable_web_page_preview=True,
             )
-    await callback.answer()
 
 
 @router.callback_query(F.data == "trial_action:confirm_activate")

bot/keyboards/inline/admin_keyboards.py

@@ -12,27 +12,105 @@ def get_admin_panel_keyboard(i18n_instance, lang: str,
                              settings: Settings) -> InlineKeyboardMarkup:
     _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
     builder = InlineKeyboardBuilder()
+    
+    # Статистика и мониторинг
+    builder.button(text=_(key="admin_stats_and_monitoring_section"),
+                   callback_data="admin_section:stats_monitoring")
+    
+    # Управление пользователями  
+    builder.button(text=_(key="admin_user_management_section"),
+                   callback_data="admin_section:user_management")
+    
+    # Промокоды и маркетинг
+    builder.button(text=_(key="admin_promo_marketing_section"),
+                   callback_data="admin_section:promo_marketing")
+    
+    # Системные функции
+    builder.button(text=_(key="admin_system_functions_section"),
+                   callback_data="admin_section:system_functions")
+    
+    builder.adjust(1)
+    return builder.as_markup()
+
+
+def get_stats_monitoring_keyboard(i18n_instance, lang: str) -> InlineKeyboardMarkup:
+    _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
+    builder = InlineKeyboardBuilder()
+    
     builder.button(text=_(key="admin_stats_button"),
                    callback_data="admin_action:stats")
-    builder.button(text=_(key="admin_broadcast_button"),
-                   callback_data="admin_action:broadcast")
-    builder.button(text=_(key="admin_create_promo_button"),
-                   callback_data="admin_action:create_promo")
-    builder.button(text=_(key="admin_manage_promos_button"),
-                   callback_data="admin_action:manage_promos")
-    builder.button(text=_(key="admin_view_promos_button"),
-                   callback_data="admin_action:view_promos")
+    builder.button(text=_(key="admin_view_logs_menu_button"),
+                   callback_data="admin_action:view_logs_menu")
+    
+    builder.button(text=_(key="back_to_admin_panel_button"),
+                   callback_data="admin_action:main")
+    builder.adjust(2, 1)
+    return builder.as_markup()
+
+
+def get_user_management_keyboard(i18n_instance, lang: str) -> InlineKeyboardMarkup:
+    _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
+    builder = InlineKeyboardBuilder()
+    
+    builder.button(text=_(key="admin_users_management_button"),
+                   callback_data="admin_action:users_management")
+    builder.button(text=_(key="admin_ban_management_section"),
+                   callback_data="admin_section:ban_management")
+    
+    builder.button(text=_(key="back_to_admin_panel_button"),
+                   callback_data="admin_action:main")
+    builder.adjust(2, 1)
+    return builder.as_markup()
+
+
+def get_ban_management_keyboard(i18n_instance, lang: str) -> InlineKeyboardMarkup:
+    _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
+    builder = InlineKeyboardBuilder()
+    
     builder.button(text=_(key="admin_ban_user_button"),
                    callback_data="admin_action:ban_user_prompt")
     builder.button(text=_(key="admin_unban_user_button"),
                    callback_data="admin_action:unban_user_prompt")
     builder.button(text=_(key="admin_view_banned_users_button"),
                    callback_data="admin_action:view_banned:0")
-    builder.button(text=_(key="admin_view_logs_menu_button"),
-                   callback_data="admin_action:view_logs_menu")
+    
+    builder.button(text=_(key="back_to_user_management_button"),
+                   callback_data="admin_section:user_management")
+    builder.adjust(2, 1, 1)
+    return builder.as_markup()
+
+
+def get_promo_marketing_keyboard(i18n_instance, lang: str) -> InlineKeyboardMarkup:
+    _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
+    builder = InlineKeyboardBuilder()
+    
+    builder.button(text=_(key="admin_create_promo_button"),
+                   callback_data="admin_action:create_promo")
+    builder.button(text=_(key="admin_create_bulk_promo_button"),
+                   callback_data="admin_action:create_bulk_promo")
+    builder.button(text=_(key="admin_manage_promos_button"),
+                   callback_data="admin_action:manage_promos")
+    builder.button(text=_(key="admin_view_promos_button"),
+                   callback_data="admin_action:view_promos")
+    
+    builder.button(text=_(key="back_to_admin_panel_button"),
+                   callback_data="admin_action:main")
+    builder.adjust(2, 2, 1)
+    return builder.as_markup()
+
+
+def get_system_functions_keyboard(i18n_instance, lang: str) -> InlineKeyboardMarkup:
+    _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
+    builder = InlineKeyboardBuilder()
+    
+    builder.button(text=_(key="admin_broadcast_button"),
+                   callback_data="admin_action:broadcast")
     builder.button(text=_(key="admin_sync_panel_button"),
                    callback_data="admin_action:sync_panel")
-    builder.adjust(2, 2, 2, 2, 1)
+    
+    builder.button(text=_(key="back_to_admin_panel_button"),
+                   callback_data="admin_action:main")
+    builder.adjust(2, 1)
     return builder.as_markup()
 
 
@@ -43,9 +121,12 @@ def get_logs_menu_keyboard(i18n_instance, lang: str) -> InlineKeyboardMarkup:
                    callback_data="admin_logs:view_all:0")
     builder.button(text=_(key="admin_view_user_logs_prompt_button"),
                    callback_data="admin_logs:prompt_user")
+    builder.button(text=_(key="admin_export_logs_csv_button"),
+                   callback_data="admin_logs:export_csv")
     builder.row(
         InlineKeyboardButton(text=_(key="back_to_admin_panel_button"),
                              callback_data="admin_action:main"))
+    builder.adjust(2, 1, 1)
     return builder.as_markup()
 
 

bot/keyboards/inline/user_keyboards.py

@@ -158,8 +158,11 @@ def get_referral_link_keyboard(lang: str,
                                i18n_instance) -> InlineKeyboardMarkup:
     _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
     builder = InlineKeyboardBuilder()
+    builder.button(text=_(key="referral_share_message_button"),
+                   callback_data="referral_action:share_message")
     builder.button(text=_(key="back_to_main_menu_button"),
                    callback_data="main_action:back_to_main")
+    builder.adjust(1)
     return builder.as_markup()
 
 

bot/main_bot.py

@@ -29,6 +29,7 @@ from bot.middlewares.action_logger_middleware import ActionLoggerMiddleware
 
 from bot.handlers.user import user_router_aggregate
 from bot.handlers.admin import admin_router_aggregate
+from bot.handlers import inline_mode
 from bot.filters.admin_filter import AdminFilter
 
 from bot.services.yookassa_service import YooKassaService
@@ -79,6 +80,9 @@ class DBSessionMiddleware(BaseMiddleware):
 async def register_all_routers(dp: Dispatcher, settings: Settings):
     dp.include_router(user_router_aggregate)
     
+    # Add inline mode router (available for all users)
+    dp.include_router(inline_mode.router)
+
     admin_main_router = Router(name="admin_main_filtered_router")
     admin_filter_instance = AdminFilter(admin_ids=settings.ADMIN_IDS)
 

bot/services/notification_service.py

@@ -3,13 +3,202 @@ import asyncio
 from aiogram import Bot
 from aiogram.utils.text_decorations import html_decoration as hd
 from datetime import datetime, timezone
+from typing import Optional, Union, Dict, Any
 
 from config.settings import Settings
-
 from sqlalchemy.orm import sessionmaker
 from bot.middlewares.i18n import JsonI18n
 
 
+class NotificationService:
+    """Enhanced notification service for sending messages to admins and log channels"""
+    
+    def __init__(self, bot: Bot, settings: Settings, i18n: Optional[JsonI18n] = None):
+        self.bot = bot
+        self.settings = settings
+        self.i18n = i18n
+    
+    async def _send_to_log_channel(self, message: str, thread_id: Optional[int] = None):
+        """Send message to configured log channel/group"""
+        if not self.settings.LOG_CHAT_ID:
+            return
+        
+        try:
+            # Use thread_id if provided, otherwise use from settings
+            final_thread_id = thread_id or self.settings.LOG_THREAD_ID
+            
+            kwargs = {
+                "chat_id": self.settings.LOG_CHAT_ID,
+                "text": message,
+                "parse_mode": "HTML",
+                "disable_web_page_preview": True
+            }
+            
+            # Add thread ID for supergroups if specified
+            if final_thread_id:
+                kwargs["message_thread_id"] = final_thread_id
+            
+            await self.bot.send_message(**kwargs)
+            
+        except Exception as e:
+            logging.error(f"Failed to send notification to log channel {self.settings.LOG_CHAT_ID}: {e}")
+    
+    async def _send_to_admins(self, message: str):
+        """Send message to all admin users"""
+        if not self.settings.ADMIN_IDS:
+            return
+        
+        for admin_id in self.settings.ADMIN_IDS:
+            try:
+                await self.bot.send_message(
+                    chat_id=admin_id,
+                    text=message,
+                    parse_mode="HTML",
+                    disable_web_page_preview=True
+                )
+            except Exception as e:
+                logging.error(f"Failed to send notification to admin {admin_id}: {e}")
+    
+    async def notify_new_user_registration(self, user_id: int, username: Optional[str] = None, 
+                                         first_name: Optional[str] = None, 
+                                         referred_by_id: Optional[int] = None):
+        """Send notification about new user registration"""
+        if not self.settings.LOG_NEW_USERS:
+            return
+        
+        admin_lang = self.settings.DEFAULT_LANGUAGE
+        _ = lambda k, **kw: self.i18n.gettext(admin_lang, k, **kw) if self.i18n else k
+        
+        user_display = first_name or f"ID {user_id}"
+        if username:
+            user_display += f" (@{username})"
+        
+        referral_text = ""
+        if referred_by_id:
+            referral_text = _("log_referral_suffix", default=" (реферал от {referrer_id})", referrer_id=referred_by_id)
+        
+        message = _(
+            "log_new_user_registration",
+            default="👤 <b>Новый пользователь</b>\n\n"
+                   "🆔 ID: <code>{user_id}</code>\n"
+                   "👤 Имя: {user_display}{referral_text}\n"
+                   "📅 Время: {timestamp}",
+            user_id=user_id,
+            user_display=user_display,
+            referral_text=referral_text,
+            timestamp=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        )
+        
+        # Send to log channel
+        await self._send_to_log_channel(message)
+    
+    async def notify_payment_received(self, user_id: int, amount: float, currency: str,
+                                    months: int, payment_provider: str, 
+                                    username: Optional[str] = None):
+        """Send notification about successful payment"""
+        if not self.settings.LOG_PAYMENTS:
+            return
+        
+        admin_lang = self.settings.DEFAULT_LANGUAGE
+        _ = lambda k, **kw: self.i18n.gettext(admin_lang, k, **kw) if self.i18n else k
+        
+        user_display = f"ID {user_id}"
+        if username:
+            user_display += f" (@{username})"
+        
+        provider_emoji = {
+            "yookassa": "💳",
+            "cryptopay": "₿",
+            "stars": "⭐",
+            "tribute": "💎"
+        }.get(payment_provider.lower(), "💰")
+        
+        message = _(
+            "log_payment_received",
+            default="{provider_emoji} <b>Получен платеж</b>\n\n"
+                   "👤 Пользователь: {user_display}\n"
+                   "💰 Сумма: <b>{amount} {currency}</b>\n"
+                   "📅 Период: <b>{months} мес.</b>\n"
+                   "🏦 Провайдер: {payment_provider}\n"
+                   "🕐 Время: {timestamp}",
+            provider_emoji=provider_emoji,
+            user_display=user_display,
+            amount=amount,
+            currency=currency,
+            months=months,
+            payment_provider=payment_provider,
+            timestamp=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        )
+        
+        # Send to log channel
+        await self._send_to_log_channel(message)
+    
+    async def notify_promo_activation(self, user_id: int, promo_code: str, bonus_days: int,
+                                    username: Optional[str] = None):
+        """Send notification about promo code activation"""
+        if not self.settings.LOG_PROMO_ACTIVATIONS:
+            return
+        
+        admin_lang = self.settings.DEFAULT_LANGUAGE
+        _ = lambda k, **kw: self.i18n.gettext(admin_lang, k, **kw) if self.i18n else k
+        
+        user_display = f"ID {user_id}"
+        if username:
+            user_display += f" (@{username})"
+        
+        message = _(
+            "log_promo_activation",
+            default="🎁 <b>Активирован промокод</b>\n\n"
+                   "👤 Пользователь: {user_display}\n"
+                   "🏷 Код: <code>{promo_code}</code>\n"
+                   "🎯 Бонус: <b>+{bonus_days} дн.</b>\n"
+                   "🕐 Время: {timestamp}",
+            user_display=user_display,
+            promo_code=promo_code,
+            bonus_days=bonus_days,
+            timestamp=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        )
+        
+        # Send to log channel
+        await self._send_to_log_channel(message)
+    
+    async def notify_trial_activation(self, user_id: int, end_date: datetime,
+                                    username: Optional[str] = None):
+        """Send notification about trial activation"""
+        if not self.settings.LOG_TRIAL_ACTIVATIONS:
+            return
+        
+        admin_lang = self.settings.DEFAULT_LANGUAGE
+        _ = lambda k, **kw: self.i18n.gettext(admin_lang, k, **kw) if self.i18n else k
+        
+        user_display = f"ID {user_id}"
+        if username:
+            user_display += f" (@{username})"
+        
+        message = _(
+            "log_trial_activation",
+            default="🆓 <b>Активирован триал</b>\n\n"
+                   "👤 Пользователь: {user_display}\n"
+                   "⏰ Действует до: <b>{end_date}</b>\n"
+                   "🕐 Время: {timestamp}",
+            user_display=user_display,
+            end_date=end_date.strftime("%Y-%m-%d %H:%M"),
+            timestamp=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        )
+        
+        # Send to log channel
+        await self._send_to_log_channel(message)
+    
+    async def send_custom_notification(self, message: str, to_admins: bool = False, 
+                                     to_log_channel: bool = True, thread_id: Optional[int] = None):
+        """Send custom notification message"""
+        if to_log_channel:
+            await self._send_to_log_channel(message, thread_id)
+        if to_admins:
+            await self._send_to_admins(message)
+
+
+# Legacy functions for backward compatibility
 async def notify_admins(bot: Bot, settings: Settings, i18n: JsonI18n,
                         message_key: str, parse_mode: str | None = None,
                         **kwargs) -> None:
@@ -26,15 +215,9 @@ async def notify_admins(bot: Bot, settings: Settings, i18n: JsonI18n,
 
 async def notify_admin_new_trial(bot: Bot, settings: Settings, i18n: JsonI18n,
                                  user_id: int, end_date: datetime) -> None:
-    end_date_str = end_date.strftime('%Y-%m-%d') if isinstance(end_date, datetime) else str(end_date)
-    await notify_admins(
-        bot,
-        settings,
-        i18n,
-        "admin_new_trial_notification",
-        user_id=user_id,
-        end_date=end_date_str,
-    )
+    """Send notification to admins about new trial activation (legacy)"""
+    notification_service = NotificationService(bot, settings, i18n)
+    await notification_service.notify_trial_activation(user_id, end_date)
 
 
 async def notify_admin_new_payment(bot: Bot, settings: Settings, i18n: JsonI18n,

bot/services/promo_code_service.py

@@ -11,7 +11,7 @@ from db.models import PromoCode, User
 
 from .subscription_service import SubscriptionService
 from bot.middlewares.i18n import JsonI18n
-from .notification_service import notify_admin_promo_activation
+from .notification_service import notify_admin_promo_activation, NotificationService
 
 
 class PromoCodeService:
@@ -62,6 +62,20 @@ class PromoCodeService:
                 session, promo_data.promo_code_id)
 
             if activation_recorded and promo_incremented:
+                # Send notification about promo activation
+                try:
+                    notification_service = NotificationService(self.bot, self.settings, self.i18n)
+                    user = await user_dal.get_user_by_id(session, user_id)
+                    await notification_service.notify_promo_activation(
+                        user_id=user_id,
+                        promo_code=code_input_upper,
+                        bonus_days=bonus_days,
+                        username=user.username if user else None
+                    )
+                except Exception as e:
+                    logging.error(f"Failed to send promo activation notification: {e}")
+                
+                # Legacy notification for backwards compatibility
                 await notify_admin_promo_activation(
                     self.bot,
                     self.settings,

bot/states/admin_states.py

@@ -7,7 +7,13 @@ class AdminStates(StatesGroup):
     confirming_broadcast = State()
     waiting_for_promo_details = State()
     waiting_for_promo_edit_details = State()
+    waiting_for_bulk_promo_details = State()
     waiting_for_user_id_to_ban = State()
     waiting_for_user_id_to_unban = State()
 
     waiting_for_user_id_for_logs = State()
+    
+    # User management states
+    waiting_for_user_search = State()
+    waiting_for_subscription_days_to_add = State()
+    waiting_for_direct_message_to_user = State()

config/settings.py

@@ -289,6 +289,16 @@ class Settings(BaseSettings):
             bonuses[12] = self.REFERRAL_BONUS_DAYS_REFEREE_12_MONTHS
         return bonuses
     
+    # Logging Configuration
+    LOG_CHAT_ID: Optional[int] = Field(default=None, description="Telegram chat/group ID for sending notifications")
+    LOG_THREAD_ID: Optional[int] = Field(default=None, description="Thread ID for supergroup messages (optional)")
+    
+    # Notification types
+    LOG_NEW_USERS: bool = Field(default=True, description="Send notifications for new user registrations")
+    LOG_PAYMENTS: bool = Field(default=True, description="Send notifications for successful payments")
+    LOG_PROMO_ACTIVATIONS: bool = Field(default=True, description="Send notifications for promo code activations")
+    LOG_TRIAL_ACTIVATIONS: bool = Field(default=True, description="Send notifications for trial activations")
+
     model_config = SettingsConfigDict(env_file='.env',
                                       env_file_encoding='utf-8',
                                       extra='ignore',

db/dal/payment_dal.py

@@ -155,3 +155,67 @@ async def update_provider_payment_and_status(
             f"Payment record with DB ID {payment_db_id} not found for provider update."
         )
     return payment
+
+
+async def get_financial_statistics(session: AsyncSession) -> Dict[str, Any]:
+    """Get comprehensive financial statistics."""
+    from datetime import datetime, timedelta
+    from sqlalchemy import and_, text
+    
+    now = datetime.utcnow()
+    today_start = now.replace(hour=0, minute=0, second=0, microsecond=0)
+    week_start = today_start - timedelta(days=7)
+    month_start = today_start - timedelta(days=30)
+    
+    # Today's revenue
+    stmt_today = select(func.sum(Payment.amount)).where(
+        and_(
+            Payment.status == 'succeeded',
+            Payment.created_at >= today_start
+        )
+    )
+    today_revenue = await session.execute(stmt_today)
+    today_amount = today_revenue.scalar() or 0
+    
+    # Week revenue
+    stmt_week = select(func.sum(Payment.amount)).where(
+        and_(
+            Payment.status == 'succeeded',
+            Payment.created_at >= week_start
+        )
+    )
+    week_revenue = await session.execute(stmt_week)
+    week_amount = week_revenue.scalar() or 0
+    
+    # Month revenue
+    stmt_month = select(func.sum(Payment.amount)).where(
+        and_(
+            Payment.status == 'succeeded',
+            Payment.created_at >= month_start
+        )
+    )
+    month_revenue = await session.execute(stmt_month)
+    month_amount = month_revenue.scalar() or 0
+    
+    # All time revenue
+    stmt_all = select(func.sum(Payment.amount)).where(Payment.status == 'succeeded')
+    all_revenue = await session.execute(stmt_all)
+    all_amount = all_revenue.scalar() or 0
+    
+    # Count of successful payments today
+    stmt_count_today = select(func.count(Payment.payment_id)).where(
+        and_(
+            Payment.status == 'succeeded',
+            Payment.created_at >= today_start
+        )
+    )
+    today_count = await session.execute(stmt_count_today)
+    today_payments_count = today_count.scalar() or 0
+    
+    return {
+        "today_revenue": float(today_amount),
+        "week_revenue": float(week_amount),
+        "month_revenue": float(month_amount),
+        "all_time_revenue": float(all_amount),
+        "today_payments_count": today_payments_count
+    }

db/dal/promo_code_dal.py

@@ -26,6 +26,13 @@ async def get_promo_code_by_id(session: AsyncSession,
     return await session.get(PromoCode, promo_code_id)
 
 
+async def get_promo_code_by_code(session: AsyncSession, code_str: str) -> Optional[PromoCode]:
+    """Get promo code by code string (regardless of active status)"""
+    stmt = select(PromoCode).where(PromoCode.code == code_str.upper())
+    result = await session.execute(stmt)
+    return result.scalar_one_or_none()
+
+
 async def get_active_promo_code_by_code_str(
         session: AsyncSession, code_str: str) -> Optional[PromoCode]:
     stmt = select(PromoCode).where(

db/dal/user_dal.py

@@ -149,3 +149,70 @@ async def get_all_users_with_panel_uuid(session: AsyncSession) -> List[User]:
     stmt = select(User).where(User.panel_user_uuid.is_not(None))
     result = await session.execute(stmt)
     return result.scalars().all()
+
+
+async def get_enhanced_user_statistics(session: AsyncSession) -> Dict[str, Any]:
+    """Get comprehensive user statistics including active users, trial users, etc."""
+    from datetime import datetime, timedelta
+    
+    now = datetime.utcnow()
+    today_start = now.replace(hour=0, minute=0, second=0, microsecond=0)
+    
+    # Total users
+    total_users_stmt = select(func.count(User.user_id))
+    total_users = (await session.execute(total_users_stmt)).scalar() or 0
+    
+    # Banned users
+    banned_users_stmt = select(func.count(User.user_id)).where(User.is_banned == True)
+    banned_users = (await session.execute(banned_users_stmt)).scalar() or 0
+    
+    # Active users today (users with login activity - for now using registration as proxy)
+    active_today_stmt = select(func.count(User.user_id)).where(
+        User.registration_date >= today_start
+    )
+    active_today = (await session.execute(active_today_stmt)).scalar() or 0
+    
+    # Users with active paid subscriptions
+    paid_subs_stmt = (
+        select(func.count(func.distinct(Subscription.user_id)))
+        .join(User, Subscription.user_id == User.user_id)
+        .where(
+            and_(
+                Subscription.is_active == True,
+                Subscription.end_date > now,
+                Subscription.provider.is_not(None)  # Not trial
+            )
+        )
+    )
+    paid_subs_users = (await session.execute(paid_subs_stmt)).scalar() or 0
+    
+    # Users on trial period
+    trial_subs_stmt = (
+        select(func.count(func.distinct(Subscription.user_id)))
+        .join(User, Subscription.user_id == User.user_id)
+        .where(
+            and_(
+                Subscription.is_active == True,
+                Subscription.end_date > now,
+                Subscription.provider.is_(None)  # Trial subscriptions
+            )
+        )
+    )
+    trial_users = (await session.execute(trial_subs_stmt)).scalar() or 0
+    
+    # Inactive users (no active subscription)
+    inactive_users = total_users - paid_subs_users - trial_users - banned_users
+    
+    # Users attracted via referral
+    referral_users_stmt = select(func.count(User.user_id)).where(User.referred_by_id.is_not(None))
+    referral_users = (await session.execute(referral_users_stmt)).scalar() or 0
+    
+    return {
+        "total_users": total_users,
+        "banned_users": banned_users,
+        "active_today": active_today,
+        "paid_subscriptions": paid_subs_users,
+        "trial_users": trial_users,
+        "inactive_users": max(0, inactive_users),
+        "referral_users": referral_users
+    }

locales/en.json

@@ -82,6 +82,8 @@
   "no_bonus_days": "0",
   "referral_no_bonuses_configured": "\nNo referral bonuses configured.",
   "referral_link_for_copying_reminder": "The link is above. Press and hold to copy.",
+  "referral_share_message_button": "📩 Message for friend",
+  "referral_friend_message": "🚀 Hey! Try this VPN - it's fast, reliable and affordable!\n\n🎁 Use my link to get bonus days with your subscription!\n\n{referral_link}",
   "friend_placeholder": "friend",
   "referral_bonus_inviter_notification_extended": "🎉 Congrats! Your friend {referee_name} paid for a subscription. You received {days} bonus days! Your subscription is now active until {new_end_date}.",
   "referral_bonus_inviter_notification_new_sub": "🎉 Congrats! Your friend {referee_name} paid for a subscription. You received a {days}-day bonus subscription! It is active until {new_end_date}.",
@@ -92,6 +94,7 @@
   "admin_stats_button": "📊 Statistics",
   "admin_broadcast_button": "📢 Broadcast",
   "admin_create_promo_button": "🎁 Create Promo",
+  "admin_create_bulk_promo_button": "📦 Bulk Create",
   "admin_manage_promos_button": "🛠 Manage Promos",
   "admin_view_promos_button": "👀 Promo List",
   "admin_ban_user_button": "🚫 Ban User",
@@ -100,11 +103,21 @@
   "admin_view_logs_menu_button": "📄 Logs",
   "admin_sync_panel_button": "🔄 Sync",
   "admin_unknown_action": "Unknown admin action.",
+  
+  "admin_stats_and_monitoring_section": "📊 Statistics & Monitoring",
+  "admin_user_management_section": "👥 User Management",
+  "admin_promo_marketing_section": "🎁 Promos & Marketing",
+  "admin_system_functions_section": "⚙️ System Functions",
+  "admin_ban_management_section": "🚫 Ban Management",
+  "admin_users_management_button": "👤 User Management",
+  "back_to_user_management_button": "⬅️ Back to User Management",
   "admin_action_cancelled_default": "Action cancelled. Returning to menu.",
   "admin_action_cancelled_default_alert": "Action cancelled",
   "back_to_admin_panel_button": "⬅️ Back to Admin",
 
   "admin_stats_header": "📊 Bot Statistics",
+  "admin_enhanced_users_stats_header": "Users",
+  "admin_financial_stats_header": "Financial Statistics",
   "admin_stats_users": "👥 Users: Total - {total_users}, Banned - {banned_users}, Active Subs - {active_subs}",
   "admin_stats_recent_payments_header": "Recent Payments:",
   "admin_stats_payment_item": "{status_emoji} {amount} {currency} from {user_info} ({p_status}) [{p_date}]",
@@ -193,6 +206,7 @@
   "admin_logs_menu_title": "Logs Menu:",
   "admin_view_all_logs_button": "📜 All Message Logs",
   "admin_view_user_logs_prompt_button": "👤 User Logs",
+  "admin_export_logs_csv_button": "📄 Export to CSV",
   "admin_all_logs_title": "All Logs (page {current_page}/{total_pages}):",
   "admin_no_logs_found": "No logs found.",
   "admin_log_entry_format": "<code>{timestamp_str}</code> - <b>{user_display}</b> (ID: {user_id})\n  <i>{event_type}</i>: {content_preview}",
@@ -223,5 +237,67 @@
   "admin_new_payment_notification": "\ud83d\udcb3 Payment received from user {user_id}: {months} mo. for {amount} {currency}.",
   "admin_promo_activation_notification": "\ud83c\udf81 Promo code {code} activated by user {user_id} (+{bonus_days}d).",
 
-  "error_unknown": "An unknown error occurred."
+  "error_unknown": "An unknown error occurred.",
+  
+  "admin_user_management_prompt": "👤 User Management\n\nEnter user ID or @username to search:",
+  "admin_user_card_title": "User Card",
+  "admin_user_subscription_info": "Subscription Information:",
+  "admin_user_reset_trial_button": "🔄 Reset Trial",
+  "admin_user_add_subscription_button": "➕ Add Days",
+  "admin_user_toggle_ban_button": "🚫 Block/Unblock",
+  "admin_user_send_message_button": "✉️ Send Message",
+  "admin_user_view_logs_button": "📜 User Actions",
+  "admin_user_refresh_button": "🔄 Refresh",
+  "admin_user_search_new_button": "🔍 Find Another",
+  "admin_user_view_all_logs_button": "📋 All Actions",
+  "admin_user_back_to_card_button": "🔙 Back to Card",
+  
+  "admin_user_not_found": "❌ User not found: {input}",
+  "admin_user_not_found_action": "User not found",
+  "admin_user_card_error": "❌ Error displaying user card",
+  "admin_user_trial_reset_success": "✅ Trial reset! User can activate trial again.",
+  "admin_user_trial_reset_error": "❌ Error resetting trial",
+  "admin_user_add_subscription_prompt": "➕ Adding subscription days for user {user_id}\n\nEnter number of days to add:",
+  "admin_user_invalid_days": "❌ Invalid number of days. Enter number from 1 to 3650.",
+  "admin_user_subscription_added_success": "✅ Successfully added {days} days to user {user_id}",
+  "admin_user_subscription_added_error": "❌ Error adding subscription days",
+  "admin_user_ban_toggle_success": "✅ User {status}",
+  "admin_user_ban_toggle_error": "❌ Error changing ban status",
+  "admin_user_send_message_prompt": "✉️ Sending message to user {user_id}\n\nEnter message text:",
+  "admin_user_message_too_long": "❌ Message too long (maximum 4000 characters)",
+  "admin_user_message_sent_success": "✅ Message sent to user {user_id}",
+  "admin_user_message_sent_error": "❌ Error sending message",
+  "admin_user_no_logs": "📜 User has no actions",
+  "admin_user_logs_error": "❌ Error loading user actions",
+  "admin_direct_message_signature": "\n\n---\n💬 Message from administrator",
+  
+  "inline_referral_message": "🚀 Hey! Try this awesome VPN service!\n\n✨ Fast and reliable\n🔒 Complete anonymity\n🌍 Servers worldwide\n💎 Free trial period\n\nCheck it out: {referral_link}",
+  "inline_referral_title": "🎁 Invite a Friend",
+  "inline_referral_description": "Share referral link to get bonuses",
+  
+  "inline_user_stats_message": "👥 <b>User Statistics</b>\n\n📊 Total: <b>{total}</b>\n📈 Active today: <b>{active_today}</b>\n💳 With paid subscription: <b>{paid}</b>\n🆓 On trial period: <b>{trial}</b>\n😴 Inactive: <b>{inactive}</b>\n🚫 Banned: <b>{banned}</b>\n🎁 Via referral program: <b>{referral}</b>",
+  "inline_admin_user_stats_title": "👥 User Statistics",
+  "inline_admin_user_stats_desc": "Total: {total}, Active: {paid}",
+  
+  "inline_financial_stats_message": "💰 <b>Financial Statistics</b>\n\n📅 Today: <b>{today:.2f} RUB</b>\n   ({today_count} payments)\n📅 Week: <b>{week:.2f} RUB</b>\n📅 Month: <b>{month:.2f} RUB</b>\n🏆 All time: <b>{all_time:.2f} RUB</b>",
+  "inline_admin_financial_stats_title": "💰 Financial Statistics",
+  "inline_admin_financial_stats_desc": "Today: {today:.2f} RUB",
+  
+  "inline_system_stats_message": "🖥 <b>System Statistics</b>\n\n🟢 Online: <b>{online}</b>\n🔴 Offline: <b>{offline}</b>\n⏰ Expired: <b>{expired}</b>\n👥 Total users: <b>{total}</b>",
+  "inline_admin_system_stats_title": "🖥 System Statistics",
+  "inline_admin_system_stats_desc": "Online: {online}, Offline: {offline}",
+  
+  "inline_admin_help_message": "🤖 <b>Bot Inline Mode</b>\n\n📱 <b>Available commands:</b>\n\n🎁 <b>ref</b> - share referral link\n👥 <b>stat</b> - user statistics\n💰 <b>financial</b> - financial statistics\n🖥 <b>system</b> - system statistics\n\n💡 Just type @{bot_username} and start typing a command in any chat!",
+  "inline_admin_help_title": "🤖 Inline Help (Admin)",
+  "inline_admin_help_desc": "Available commands: ref, stat, financial, system",
+  
+  "inline_user_help_message": "🤖 <b>Bot Inline Mode</b>\n\n📱 <b>Available commands:</b>\n\n🎁 <b>ref</b> - share referral link\n\n💡 Just type @{bot_username} and start typing 'ref' in any chat!",
+  "inline_user_help_title": "🤖 Inline Help",
+  "inline_user_help_desc": "Available command: ref (referral link)",
+  
+  "log_referral_suffix": " (referral from {referrer_id})",
+  "log_new_user_registration": "👤 <b>New User</b>\n\n🆔 ID: <code>{user_id}</code>\n👤 Name: {user_display}{referral_text}\n📅 Time: {timestamp}",
+  "log_payment_received": "{provider_emoji} <b>Payment Received</b>\n\n👤 User: {user_display}\n💰 Amount: <b>{amount} {currency}</b>\n📅 Period: <b>{months} mo.</b>\n🏦 Provider: {payment_provider}\n🕐 Time: {timestamp}",
+  "log_promo_activation": "🎁 <b>Promo Code Activated</b>\n\n👤 User: {user_display}\n🏷 Code: <code>{promo_code}</code>\n🎯 Bonus: <b>+{bonus_days}d</b>\n🕐 Time: {timestamp}",
+  "log_trial_activation": "🆓 <b>Trial Activated</b>\n\n👤 User: {user_display}\n⏰ Valid until: <b>{end_date}</b>\n🕐 Time: {timestamp}"
 }

locales/ru.json

@@ -82,6 +82,8 @@
   "no_bonus_days": "0",
   "referral_no_bonuses_configured": "\nРеферальные бонусы не настроены.",
   "referral_link_for_copying_reminder": "Ссылка выше. Нажмите и удерживайте для копирования.",
+  "referral_share_message_button": "📩 Сообщение для друга",
+  "referral_friend_message": "🚀 Привет! Попробуй этот VPN - быстрый, надёжный и доступный!\n\n🎁 По моей ссылке тебе дадут бонусные дни к подписке!\n\n{referral_link}",
   "friend_placeholder": "друг",
   "referral_bonus_inviter_notification_extended": "🎉 Поздравляем! Ваш друг {referee_name} оплатил подписку. Вам начислено {days} бонусных дней! Ваша подписка теперь активна до {new_end_date}.",
   "referral_bonus_inviter_notification_new_sub": "🎉 Поздравляем! Ваш друг {referee_name} оплатил подписку. Вам начислена бонусная подписка на {days} дней! Она активна до {new_end_date}.",
@@ -92,6 +94,7 @@
   "admin_stats_button": "📊 Статистика",
   "admin_broadcast_button": "📢 Рассылка",
   "admin_create_promo_button": "🎁 Создать промо",
+  "admin_create_bulk_promo_button": "📦 Массовое создание",
   "admin_manage_promos_button": "🛠 Управление промо",
   "admin_view_promos_button": "👀 Список промо",
   "admin_ban_user_button": "🚫 Забанить",
@@ -100,11 +103,21 @@
   "admin_view_logs_menu_button": "📄 Логи",
   "admin_sync_panel_button": "🔄 Синхронизация",
   "admin_unknown_action": "Неизвестное действие администратора.",
+  
+  "admin_stats_and_monitoring_section": "📊 Статистика и мониторинг",
+  "admin_user_management_section": "👥 Управление пользователями",
+  "admin_promo_marketing_section": "🎁 Промокоды и маркетинг",
+  "admin_system_functions_section": "⚙️ Системные функции",
+  "admin_ban_management_section": "🚫 Управление блокировками",
+  "admin_users_management_button": "👤 Управление пользователями",
+  "back_to_user_management_button": "⬅️ К управлению пользователями",
   "admin_action_cancelled_default": "Действие отменено. Возврат в меню.",
   "admin_action_cancelled_default_alert": "Действие отменено",
   "back_to_admin_panel_button": "⬅️ В админку",
 
   "admin_stats_header": "📊 Статистика Бота",
+  "admin_enhanced_users_stats_header": "Пользователи",
+  "admin_financial_stats_header": "Финансовая статистика",
   "admin_stats_users": "👥 Пользователи: Всего - {total_users}, Забанено - {banned_users}, С активной подпиской - {active_subs}",
   "admin_stats_recent_payments_header": "Последние платежи:",
   "admin_stats_payment_item": "{status_emoji} {amount} {currency} от {user_info} ({p_status}) [{p_date}]",
@@ -193,6 +206,7 @@
   "admin_logs_menu_title": "Меню логов:",
   "admin_view_all_logs_button": "📜 Все логи сообщений",
   "admin_view_user_logs_prompt_button": "👤 Логи пользователя",
+  "admin_export_logs_csv_button": "📄 Экспорт в CSV",
   "admin_all_logs_title": "Все логи (стр. {current_page}/{total_pages}):",
   "admin_no_logs_found": "Логи не найдены.",
   "admin_log_entry_format": "<code>{timestamp_str}</code> - <b>{user_display}</b> (ID: {user_id})\n  <i>{event_type}</i>: {content_preview}",
@@ -223,5 +237,67 @@
   "admin_new_payment_notification": "\ud83d\udcb3 Получен платеж от пользователя {user_id}: {months} мес. за {amount} {currency}.",
   "admin_promo_activation_notification": "\ud83c\udf81 Пользователь {user_id} активировал промокод {code} (+{bonus_days} дн.)",
 
-  "error_unknown": "Произошла неизвестная ошибка."
+  "error_unknown": "Произошла неизвестная ошибка.",
+  
+  "admin_user_management_prompt": "👤 Управление пользователями\n\nВведите ID пользователя или @username для поиска:",
+  "admin_user_card_title": "Карточка пользователя",
+  "admin_user_subscription_info": "Информация о подписке:",
+  "admin_user_reset_trial_button": "🔄 Сбросить триал",
+  "admin_user_add_subscription_button": "➕ Добавить дни",
+  "admin_user_toggle_ban_button": "🚫 Заблокировать/Разблокировать",
+  "admin_user_send_message_button": "✉️ Отправить сообщение",
+  "admin_user_view_logs_button": "📜 Действия пользователя",
+  "admin_user_refresh_button": "🔄 Обновить",
+  "admin_user_search_new_button": "🔍 Найти другого",
+  "admin_user_view_all_logs_button": "📋 Все действия",
+  "admin_user_back_to_card_button": "🔙 К карточке",
+  
+  "admin_user_not_found": "❌ Пользователь не найден: {input}",
+  "admin_user_not_found_action": "Пользователь не найден",
+  "admin_user_card_error": "❌ Ошибка отображения карточки пользователя",
+  "admin_user_trial_reset_success": "✅ Триал сброшен! Пользователь может активировать триал заново.",
+  "admin_user_trial_reset_error": "❌ Ошибка сброса триала",
+  "admin_user_add_subscription_prompt": "➕ Добавление дней подписки для пользователя {user_id}\n\nВведите количество дней для добавления:",
+  "admin_user_invalid_days": "❌ Неверное количество дней. Введите число от 1 до 3650.",
+  "admin_user_subscription_added_success": "✅ Успешно добавлено {days} дней подписки пользователю {user_id}",
+  "admin_user_subscription_added_error": "❌ Ошибка добавления дней подписки",
+  "admin_user_ban_toggle_success": "✅ Пользователь {status}",
+  "admin_user_ban_toggle_error": "❌ Ошибка изменения статуса блокировки",
+  "admin_user_send_message_prompt": "✉️ Отправка сообщения пользователю {user_id}\n\nВведите текст сообщения:",
+  "admin_user_message_too_long": "❌ Сообщение слишком длинное (максимум 4000 символов)",
+  "admin_user_message_sent_success": "✅ Сообщение отправлено пользователю {user_id}",
+  "admin_user_message_sent_error": "❌ Ошибка отправки сообщения",
+  "admin_user_no_logs": "📜 У пользователя нет действий",
+  "admin_user_logs_error": "❌ Ошибка загрузки действий пользователя",
+  "admin_direct_message_signature": "\n\n---\n💬 Сообщение от администратора",
+  
+  "inline_referral_message": "🚀 Привет! Попробуй этот крутой VPN сервис!\n\n✨ Быстрый и надежный\n🔒 Полная анонимность\n🌍 Серверы по всему миру\n💎 Бесплатный пробный период\n\nПереходи по ссылке: {referral_link}",
+  "inline_referral_title": "🎁 Пригласить друга",
+  "inline_referral_description": "Поделиться реферальной ссылкой для получения бонусов",
+  
+  "inline_user_stats_message": "👥 <b>Статистика пользователей</b>\n\n📊 Всего: <b>{total}</b>\n📈 Активных сегодня: <b>{active_today}</b>\n💳 С платной подпиской: <b>{paid}</b>\n🆓 На пробном периоде: <b>{trial}</b>\n😴 Неактивных: <b>{inactive}</b>\n🚫 Заблокированных: <b>{banned}</b>\n🎁 По реферальной программе: <b>{referral}</b>",
+  "inline_admin_user_stats_title": "👥 Статистика пользователей",
+  "inline_admin_user_stats_desc": "Всего: {total}, Активных: {paid}",
+  
+  "inline_financial_stats_message": "💰 <b>Финансовая статистика</b>\n\n📅 За сегодня: <b>{today:.2f} RUB</b>\n   ({today_count} платежей)\n📅 За неделю: <b>{week:.2f} RUB</b>\n📅 За месяц: <b>{month:.2f} RUB</b>\n🏆 За все время: <b>{all_time:.2f} RUB</b>",
+  "inline_admin_financial_stats_title": "💰 Финансовая статистика", 
+  "inline_admin_financial_stats_desc": "Сегодня: {today:.2f} RUB",
+  
+  "inline_system_stats_message": "🖥 <b>Системная статистика</b>\n\n🟢 Онлайн: <b>{online}</b>\n🔴 Офлайн: <b>{offline}</b>\n⏰ Истекшие: <b>{expired}</b>\n👥 Всего пользователей: <b>{total}</b>",
+  "inline_admin_system_stats_title": "🖥 Системная статистика",
+  "inline_admin_system_stats_desc": "Онлайн: {online}, Офлайн: {offline}",
+  
+  "inline_admin_help_message": "🤖 <b>Inline режим бота</b>\n\n📱 <b>Доступные команды:</b>\n\n🎁 <b>реф/ref</b> - поделиться реферальной ссылкой\n👥 <b>стат/stat</b> - статистика пользователей\n💰 <b>финансы</b> - финансовая статистика\n🖥 <b>система</b> - системная статистика\n\n💡 Просто напишите @{bot_username} и начните вводить команду в любом чате!",
+  "inline_admin_help_title": "🤖 Inline помощь (Админ)",
+  "inline_admin_help_desc": "Доступны команды: реф, стат, финансы, система",
+  
+  "inline_user_help_message": "🤖 <b>Inline режим бота</b>\n\n📱 <b>Доступные команды:</b>\n\n🎁 <b>реф/ref</b> - поделиться реферальной ссылкой\n\n💡 Просто напишите @{bot_username} и начните вводить 'реф' в любом чате!",
+  "inline_user_help_title": "🤖 Inline помощь",
+  "inline_user_help_desc": "Доступна команда: реф (реферальная ссылка)",
+  
+  "log_referral_suffix": " (реферал от {referrer_id})",
+  "log_new_user_registration": "👤 <b>Новый пользователь</b>\n\n🆔 ID: <code>{user_id}</code>\n👤 Имя: {user_display}{referral_text}\n📅 Время: {timestamp}",
+  "log_payment_received": "{provider_emoji} <b>Получен платеж</b>\n\n👤 Пользователь: {user_display}\n💰 Сумма: <b>{amount} {currency}</b>\n📅 Период: <b>{months} мес.</b>\n🏦 Провайдер: {payment_provider}\n🕐 Время: {timestamp}",
+  "log_promo_activation": "🎁 <b>Активирован промокод</b>\n\n👤 Пользователь: {user_display}\n🏷 Код: <code>{promo_code}</code>\n🎯 Бонус: <b>+{bonus_days} дн.</b>\n🕐 Время: {timestamp}",
+  "log_trial_activation": "🆓 <b>Активирован триал</b>\n\n👤 Пользователь: {user_display}\n⏰ Действует до: <b>{end_date}</b>\n🕐 Время: {timestamp}"
 }