Enhance promo code management and add bulk creation functionality

- Refactored the promo code creation process into a step-by-step flow, improving user guidance and validation.
- Introduced bulk promo code creation with a structured multi-step process, allowing admins to create multiple codes efficiently.
- Added new states for managing the promo code creation process and bulk operations.
- Implemented panel statistics retrieval to provide admins with insights into system performance and user activity.
- Updated localization files to support new messages and prompts related to promo code management and statistics.

bot/handlers/admin/promo_codes.py

@@ -32,25 +32,31 @@ async def create_promo_prompt_handler(callback: types.CallbackQuery,
         return
     _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs)
 
-    prompt_text = _("admin_promo_create_prompt",
+    # Step 1: Ask for promo code
-                    example_format="MYPROMO20 7 100 30")
+    prompt_text = _(
+        "admin_promo_step1_code",
+        default="🎟 <b>Создание промокода</b>\n\n<b>Шаг 1 из 5:</b> Код промокода\n\nВведите код промокода (3-30 символов, только буквы и цифры):"
+    )
 
     try:
         await callback.message.edit_text(
             prompt_text,
-            reply_markup=get_back_to_admin_panel_keyboard(current_lang, i18n))
+            reply_markup=get_back_to_admin_panel_keyboard(current_lang, i18n),
+            parse_mode="HTML")
     except Exception as e:
         logging.warning(
             f"Could not edit message for promo prompt: {e}. Sending new.")
         await callback.message.answer(
             prompt_text,
-            reply_markup=get_back_to_admin_panel_keyboard(current_lang, i18n))
+            reply_markup=get_back_to_admin_panel_keyboard(current_lang, i18n),
+            parse_mode="HTML")
     await callback.answer()
-    await state.set_state(AdminStates.waiting_for_promo_details)
+    await state.set_state(AdminStates.waiting_for_promo_code)
 
 
-@router.message(AdminStates.waiting_for_promo_details, F.text)
+# Step 1: Process promo code
-async def process_promo_code_details_handler(message: types.Message,
+@router.message(AdminStates.waiting_for_promo_code, F.text)
+async def process_promo_code_handler(message: types.Message,
                                     state: FSMContext,
                                     i18n_data: dict,
                                     settings: Settings,
@@ -62,87 +68,457 @@ async def process_promo_code_details_handler(message: types.Message,
         return
     _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs)
 
-    if not message.text:
+    try:
-        await message.answer(_("admin_promo_invalid_format"))
+        code_str = message.text.strip().upper()
+        if not (3 <= len(code_str) <= 30 and code_str.isalnum()):
+            await message.answer(_(
+                "admin_promo_invalid_code_format",
+                default="❌ Код промокода должен содержать 3-30 символов (только буквы и цифры)"
+            ))
             return
         
-    parts = message.text.strip().split()
+        # Check if code already exists
-    if not (3 <= len(parts) <= 4):
+        existing_promo = await promo_code_dal.get_promo_code_by_code(session, code_str)
-        await message.answer(_("admin_promo_invalid_format"))
+        if existing_promo:
+            await message.answer(_(
+                "admin_promo_code_already_exists",
+                default="❌ Промокод с таким кодом уже существует"
+            ))
             return
         
+        await state.update_data(promo_code=code_str)
+        
+        # Step 2: Ask for bonus days
+        prompt_text = _(
+            "admin_promo_step2_bonus_days",
+            default="🎟 <b>Создание промокода</b>\n\n<b>Шаг 2 из 5:</b> Бонусные дни\n\nКод: <b>{code}</b>\n\nВведите количество бонусных дней (1-365):",
+            code=code_str
+        )
+        
+        await message.answer(
+            prompt_text,
+            reply_markup=get_back_to_admin_panel_keyboard(current_lang, i18n),
+            parse_mode="HTML"
+        )
+        await state.set_state(AdminStates.waiting_for_promo_bonus_days)
+        
+    except Exception as e:
+        logging.error(f"Error processing promo code: {e}")
+        await message.answer(_(
+            "admin_promo_processing_error",
+            default="❌ Ошибка обработки промокода"
+        ))
+
+# Step 2: Process bonus days
+@router.message(AdminStates.waiting_for_promo_bonus_days, F.text)
+async def process_promo_bonus_days_handler(message: types.Message,
+                                          state: FSMContext,
+                                          i18n_data: dict,
+                                          settings: Settings):
+    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)
+
     try:
-        code_str = parts[0].upper()
+        bonus_days = int(message.text.strip())
-        if not (3 <= len(code_str) <= 30 and code_str.isalnum()):
+        if bonus_days <= 0 or bonus_days > 365:
-            raise ValueError(_("admin_promo_invalid_code_format"))
+            await message.answer(_(
+                "admin_promo_invalid_bonus_days",
+                default="❌ Бонусные дни должны быть от 1 до 365"
+            ))
+            return
         
-        bonus_days = int(parts[1])
+        data = await state.get_data()
-        max_activations = int(parts[2])
+        await state.update_data(bonus_days=bonus_days)
         
+        # Step 3: Ask for max activations
+        prompt_text = _(
+            "admin_promo_step3_max_activations",
+            default="🎟 <b>Создание промокода</b>\n\n<b>Шаг 3 из 5:</b> Максимальные активации\n\nКод: <b>{code}</b>\nБонусные дни: <b>{bonus_days}</b>\n\nВведите максимальное количество активаций (1-10000):",
+            code=data['promo_code'],
+            bonus_days=bonus_days
+        )
+        
+        await message.answer(
+            prompt_text,
+            reply_markup=get_back_to_admin_panel_keyboard(current_lang, i18n),
+            parse_mode="HTML"
+        )
+        await state.set_state(AdminStates.waiting_for_promo_max_activations)
+        
+    except ValueError:
+        await message.answer(_(
+            "admin_promo_invalid_bonus_days",
+            default="❌ Бонусные дни должны быть от 1 до 365"
+        ))
+
+# Step 3: Process max activations
+@router.message(AdminStates.waiting_for_promo_max_activations, F.text)
+async def process_promo_max_activations_handler(message: types.Message,
+                                               state: FSMContext,
+                                               i18n_data: dict,
+                                               settings: Settings):
+    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)
+
+    try:
+        max_activations = int(message.text.strip())
+        if max_activations <= 0 or max_activations > 10000:
+            await message.answer(_(
+                "admin_promo_invalid_max_activations",
+                default="❌ Максимальные активации должны быть от 1 до 10000"
+            ))
+            return
+        
+        data = await state.get_data()
+        await state.update_data(max_activations=max_activations)
+        
+        # Step 4: Ask for validity days (with buttons)
+        keyboard = InlineKeyboardBuilder()
+        keyboard.row(
+            InlineKeyboardButton(
+                text=_("admin_promo_unlimited_validity", default="♾️ Неограниченно"),
+                callback_data="promo_unlimited_validity"
+            )
+        )
+        keyboard.row(
+            InlineKeyboardButton(
+                text=_("admin_promo_set_validity", default="⏰ Установить срок"),
+                callback_data="promo_set_validity"
+            )
+        )
+        keyboard.row(
+            InlineKeyboardButton(
+                text=_("admin_panel_back_button", default="⬅️ Назад"),
+                callback_data="admin_panel_back"
+            )
+        )
+        
+        prompt_text = _(
+            "admin_promo_step4_validity",
+            default="🎟 <b>Создание промокода</b>\n\n<b>Шаг 4 из 5:</b> Срок действия\n\nКод: <b>{code}</b>\nБонусные дни: <b>{bonus_days}</b>\nМакс. активации: <b>{max_activations}</b>\n\nВыберите срок действия промокода:",
+            code=data['promo_code'],
+            bonus_days=data['bonus_days'],
+            max_activations=max_activations
+        )
+        
+        await message.answer(
+            prompt_text,
+            reply_markup=keyboard.as_markup(),
+            parse_mode="HTML"
+        )
+        await state.set_state(AdminStates.waiting_for_promo_validity_days)
+        
+    except ValueError:
+        await message.answer(_(
+            "admin_promo_invalid_max_activations",
+            default="❌ Максимальные активации должны быть от 1 до 10000"
+        ))
+
+# Handle validity choice buttons
+@router.callback_query(F.data == "promo_unlimited_validity", StateFilter(AdminStates.waiting_for_promo_validity_days))
+async def process_promo_unlimited_validity(callback: types.CallbackQuery,
+                                          state: FSMContext,
+                                          i18n_data: dict,
+                                          settings: Settings):
+    await state.update_data(validity_days=None)
+    await ask_for_promo_description(callback, state, i18n_data, settings)
+
+@router.callback_query(F.data == "promo_set_validity", StateFilter(AdminStates.waiting_for_promo_validity_days))
+async def process_promo_set_validity(callback: types.CallbackQuery,
+                                    state: FSMContext,
+                                    i18n_data: dict,
+                                    settings: Settings):
+    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 service error.", show_alert=True)
+        return
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs)
+
+    prompt_text = _(
+        "admin_promo_enter_validity_days",
+        default="⏰ Введите количество дней действия промокода (1-365):"
+    )
+    
+    try:
+        await callback.message.edit_text(
+            prompt_text,
+            reply_markup=get_back_to_admin_panel_keyboard(current_lang, i18n)
+        )
+    except Exception as e:
+        await callback.message.answer(
+            prompt_text,
+            reply_markup=get_back_to_admin_panel_keyboard(current_lang, i18n)
+        )
+    await callback.answer()
+
+# Step 4: Process validity days (when user chooses to set)
+@router.message(AdminStates.waiting_for_promo_validity_days, F.text)
+async def process_promo_validity_days_handler(message: types.Message,
+                                             state: FSMContext,
+                                             i18n_data: dict,
+                                             settings: Settings):
+    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)
+
+    try:
+        validity_days = int(message.text.strip())
+        if validity_days <= 0 or validity_days > 365:
+            await message.answer(_(
+                "admin_promo_invalid_validity_days",
+                default="❌ Дни действия должны быть от 1 до 365"
+            ))
+            return
+        
+        await state.update_data(validity_days=validity_days)
+        
+        # Create a fake callback for consistency
+        fake_callback = types.CallbackQuery(
+            id="fake",
+            from_user=message.from_user,
+            chat_instance="fake",
+            message=message,
+            data="fake"
+        )
+        
+        await ask_for_promo_description(fake_callback, state, i18n_data, settings)
+        
+    except ValueError:
+        await message.answer(_(
+            "admin_promo_invalid_validity_days",
+            default="❌ Дни действия должны быть от 1 до 365"
+        ))
+
+async def ask_for_promo_description(callback_or_message,
+                                   state: FSMContext,
+                                   i18n_data: dict,
+                                   settings: Settings):
+    """Ask for promo description (final step)"""
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    if not i18n:
+        if hasattr(callback_or_message, 'answer'):
+            await callback_or_message.answer("Language service error.", show_alert=True)
+        else:
+            await callback_or_message.reply("Language service error.")
+        return
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs)
+
+    data = await state.get_data()
+    validity_days = data.get('validity_days')
+    validity_text = "Неограниченно" if validity_days is None else f"{validity_days} дн."
+    
+    # Step 5: Ask for description (optional)
+    keyboard = InlineKeyboardBuilder()
+    keyboard.row(
+        InlineKeyboardButton(
+            text=_("admin_promo_skip_description", default="⏭️ Пропустить"),
+            callback_data="promo_skip_description"
+        )
+    )
+    keyboard.row(
+        InlineKeyboardButton(
+            text=_("admin_panel_back_button", default="⬅️ Назад"),
+            callback_data="admin_panel_back"
+        )
+    )
+    
+    prompt_text = _(
+        "admin_promo_step5_description",
+        default="🎟 <b>Создание промокода</b>\n\n<b>Шаг 5 из 5:</b> Описание (опционально)\n\nКод: <b>{code}</b>\nБонусные дни: <b>{bonus_days}</b>\nМакс. активации: <b>{max_activations}</b>\nДействует: <b>{validity}</b>\n\nВведите описание промокода или нажмите \"Пропустить\":",
+        code=data['promo_code'],
+        bonus_days=data['bonus_days'],
+        max_activations=data['max_activations'],
+        validity=validity_text
+    )
+    
+    if hasattr(callback_or_message, 'message'):
+        try:
+            await callback_or_message.message.edit_text(
+                prompt_text,
+                reply_markup=keyboard.as_markup(),
+                parse_mode="HTML"
+            )
+        except:
+            await callback_or_message.message.answer(
+                prompt_text,
+                reply_markup=keyboard.as_markup(),
+                parse_mode="HTML"
+            )
+        if hasattr(callback_or_message, 'answer'):
+            await callback_or_message.answer()
+    else:
+        await callback_or_message.answer(
+            prompt_text,
+            reply_markup=keyboard.as_markup(),
+            parse_mode="HTML"
+        )
+    
+    await state.set_state(AdminStates.waiting_for_promo_description)
+
+# Handle skip description button
+@router.callback_query(F.data == "promo_skip_description", StateFilter(AdminStates.waiting_for_promo_description))
+async def process_promo_skip_description(callback: types.CallbackQuery,
+                                        state: FSMContext,
+                                        i18n_data: dict,
+                                        settings: Settings,
+                                        session: AsyncSession):
+    await state.update_data(description=None)
+    await create_promo_code_final(callback, state, i18n_data, settings, session)
+
+# Step 5: Process description (optional)
+@router.message(AdminStates.waiting_for_promo_description, F.text)
+async def process_promo_description_handler(message: types.Message,
+                                           state: FSMContext,
+                                           i18n_data: dict,
+                                           settings: Settings,
+                                           session: AsyncSession):
+    description = message.text.strip()
+    if len(description) > 200:
+        current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+        i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+        if i18n:
+            _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs)
+            await message.answer(_(
+                "admin_promo_description_too_long",
+                default="❌ Описание не должно превышать 200 символов"
+            ))
+        else:
+            await message.answer("Description too long")
+        return
+    
+    await state.update_data(description=description)
+    
+    # Create a fake callback for consistency
+    fake_callback = types.CallbackQuery(
+        id="fake",
+        from_user=message.from_user,
+        chat_instance="fake",
+        message=message,
+        data="fake"
+    )
+    
+    await create_promo_code_final(fake_callback, state, i18n_data, settings, session)
+
+async def create_promo_code_final(callback_or_message,
+                                 state: FSMContext,
+                                 i18n_data: dict,
+                                 settings: Settings,
+                                 session: AsyncSession):
+    """Final step to create the promo code"""
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    if not i18n:
+        if hasattr(callback_or_message, 'answer'):
+            await callback_or_message.answer("Language service error.", show_alert=True)
+        else:
+            await callback_or_message.reply("Language service error.")
+        return
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs)
+
+    data = await state.get_data()
+    promo_code = data['promo_code']
+    bonus_days = data['bonus_days']
+    max_activations = data['max_activations']
+    validity_days = data.get('validity_days')
+    description = data.get('description')
+    
+    # Create validity date
     valid_until_date: Optional[datetime] = None
-        valid_until_str_display = _("admin_promo_valid_indefinitely")
+    valid_until_str_display = _("admin_promo_valid_indefinitely", default="Неограниченно")
     
-        if len(parts) == 4:
+    if validity_days:
-            valid_days_from_now = int(parts[3])
+        valid_until_date = datetime.now(timezone.utc) + timedelta(days=validity_days)
-            if valid_days_from_now <= 0:
+        valid_until_str_display = valid_until_date.strftime('%Y-%m-%d')
-                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'))
 
-        if bonus_days <= 0 or max_activations <= 0:
+    # Show creating message
-            raise ValueError(_("admin_promo_invalid_bonus_or_activations"))
+    creating_text = _(
+        "admin_promo_creating",
+        default="⏳ Создаю промокод..."
+    )
     
-    except ValueError as e:
+    if hasattr(callback_or_message, 'message'):
-        await message.answer(_("admin_promo_invalid_values", error=str(e)))
+        try:
-        return
+            await callback_or_message.message.edit_text(creating_text)
-    except Exception as e_parse:
+        except:
-        logging.error(
+            await callback_or_message.message.answer(creating_text)
-            f"Error parsing promo details '{message.text}': {e_parse}")
+        if hasattr(callback_or_message, 'answer'):
-        await message.answer(_("admin_promo_invalid_format_general"))
+            await callback_or_message.answer()
-        return
+    else:
+        await callback_or_message.answer(creating_text)
 
-    admin_id = message.from_user.id if message.from_user else 0
+    # Create promo code
-
+    try:
-    promo_data_to_create = {
+        promo_data = {
-        "code": code_str,
+            "code": promo_code,
             "bonus_days": bonus_days,
             "max_activations": max_activations,
-        "created_by_admin_id": admin_id,
+            "current_activations": 0,
-        "valid_until": valid_until_date,
             "is_active": True,
-        "current_activations": 0
+            "valid_until": valid_until_date,
+            "description": description
         }
         
-    try:
+        await promo_code_dal.create_promo_code(session, promo_data)
-        created_promo = await promo_code_dal.create_promo_code(
-            session, promo_data_to_create)
         await session.commit()
         
-        if created_promo:
+        # Send success message
-            success_text = _("admin_promo_created_success",
+        success_text = _(
-                             code=created_promo.code,
+            "admin_promo_created_success",
-                             bonus_days=created_promo.bonus_days,
+            default="✅ Промокод создан!\n\n🎟 Код: <b>{code}</b>\n🎁 Бонусные дни: <b>{days}</b>\n🔢 Максимальные активации: <b>{max_act}</b>\n⏰ Действует до: <b>{validity}</b>\n📝 Описание: {description}",
-                             max_activations=created_promo.max_activations,
+            code=promo_code,
-                             valid_until_str=valid_until_str_display)
+            days=bonus_days,
-            await message.answer(success_text,
+            max_act=max_activations,
-                                 reply_markup=get_back_to_admin_panel_keyboard(
+            validity=valid_until_str_display,
-                                     current_lang, i18n))
+            description=description or "Не указано"
-        else:
+        )
-            await message.answer(
-                _("admin_promo_creation_failed_duplicate", code=code_str))
         
-    except Exception as e_db_create:
+        if hasattr(callback_or_message, 'message'):
+            target_message = callback_or_message.message
+        else:
+            target_message = callback_or_message
+            
+        await target_message.answer(
+            success_text,
+            reply_markup=get_back_to_admin_panel_keyboard(current_lang, i18n),
+            parse_mode="HTML"
+        )
+        
+    except Exception as e:
+        logging.error(f"Error creating promo code: {e}")
         await session.rollback()
-        logging.error(
+        error_text = _(
-            f"Failed to create promo code '{code_str}' in DB: {e_db_create}",
+            "admin_promo_creation_failed",
-            exc_info=True)
+            default="❌ Ошибка создания промокода: {error}",
-        await message.answer(_("admin_promo_creation_failed"))
+            error=str(e)
+        )
+        
+        if hasattr(callback_or_message, 'message'):
+            target_message = callback_or_message.message
+        else:
+            target_message = callback_or_message
+            
+        await target_message.answer(
+            error_text,
+            reply_markup=get_back_to_admin_panel_keyboard(current_lang, i18n)
+        )
     
     await state.clear()
 
+# Legacy handler removed - using step-by-step creation now
+
 
 async def view_promo_codes_handler(callback: types.CallbackQuery,
                                    i18n_data: dict, settings: Settings,
@@ -341,8 +717,17 @@ async def promo_delete_handler(callback: types.CallbackQuery, i18n_data: dict,
     F.data == "admin_action:main",
     StateFilter(
         AdminStates.waiting_for_promo_details,
+        AdminStates.waiting_for_promo_code,
+        AdminStates.waiting_for_promo_bonus_days,
+        AdminStates.waiting_for_promo_max_activations,
+        AdminStates.waiting_for_promo_validity_days,
+        AdminStates.waiting_for_promo_description,
         AdminStates.waiting_for_promo_edit_details,
         AdminStates.waiting_for_bulk_promo_details,
+        AdminStates.waiting_for_bulk_promo_quantity,
+        AdminStates.waiting_for_bulk_promo_bonus_days,
+        AdminStates.waiting_for_bulk_promo_max_activations,
+        AdminStates.waiting_for_bulk_promo_validity_days,
     ),
 )
 async def cancel_promo_creation_state_to_menu(callback: types.CallbackQuery,
@@ -382,24 +767,26 @@ async def create_bulk_promo_prompt_handler(callback: types.CallbackQuery,
         return
     _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs)
 
+    # Step 1: Ask for quantity
     prompt_text = _(
-        "admin_bulk_promo_create_prompt",
+        "admin_bulk_promo_step1_quantity",
-        default="📦 Массовое создание промокодов\n\nВведите данные в формате:\n<количество> <бонусные_дни> <максимальное_использование> [дни_действия]\n\nПример: 50 7 100 30\n(создаст 50 промокодов на 7 дней с лимитом 100 активаций каждый, действующих 30 дней)",
+        default="📦 <b>Массовое создание промокодов</b>\n\n<b>Шаг 1 из 4:</b> Количество промокодов\n\nВведите количество промокодов для создания (1-1000):"
-        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))
+            reply_markup=get_back_to_admin_panel_keyboard(current_lang, i18n),
+            parse_mode="HTML")
     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))
+            reply_markup=get_back_to_admin_panel_keyboard(current_lang, i18n),
+            parse_mode="HTML")
     await callback.answer()
-    await state.set_state(AdminStates.waiting_for_bulk_promo_details)
+    await state.set_state(AdminStates.waiting_for_bulk_promo_quantity)
 
 
 def generate_unique_promo_code(length: int = 8) -> str:
@@ -410,6 +797,386 @@ def generate_unique_promo_code(length: int = 8) -> str:
     return ''.join(random.choice(characters) for _ in range(length))
 
 
+# Step 1: Process quantity
+@router.message(AdminStates.waiting_for_bulk_promo_quantity, F.text)
+async def process_bulk_promo_quantity_handler(message: types.Message,
+                                             state: FSMContext,
+                                             i18n_data: dict,
+                                             settings: Settings):
+    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)
+
+    try:
+        quantity = int(message.text.strip())
+        if quantity <= 0 or quantity > 1000:
+            await message.answer(_(
+                "admin_bulk_promo_invalid_quantity",
+                default="❌ Количество должно быть от 1 до 1000"
+            ))
+            return
+        
+        await state.update_data(quantity=quantity)
+        
+        # Step 2: Ask for bonus days
+        prompt_text = _(
+            "admin_bulk_promo_step2_bonus_days",
+            default="📦 <b>Массовое создание промокодов</b>\n\n<b>Шаг 2 из 4:</b> Бонусные дни\n\nКоличество: <b>{quantity}</b>\n\nВведите количество бонусных дней (1-365):",
+            quantity=quantity
+        )
+        
+        await message.answer(
+            prompt_text,
+            reply_markup=get_back_to_admin_panel_keyboard(current_lang, i18n),
+            parse_mode="HTML"
+        )
+        await state.set_state(AdminStates.waiting_for_bulk_promo_bonus_days)
+        
+    except ValueError:
+        await message.answer(_(
+            "admin_bulk_promo_invalid_quantity",
+            default="❌ Количество должно быть от 1 до 1000"
+        ))
+
+# Step 2: Process bonus days
+@router.message(AdminStates.waiting_for_bulk_promo_bonus_days, F.text)
+async def process_bulk_promo_bonus_days_handler(message: types.Message,
+                                               state: FSMContext,
+                                               i18n_data: dict,
+                                               settings: Settings):
+    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)
+
+    try:
+        bonus_days = int(message.text.strip())
+        if bonus_days <= 0 or bonus_days > 365:
+            await message.answer(_(
+                "admin_bulk_promo_invalid_bonus_days", 
+                default="❌ Бонусные дни должны быть от 1 до 365"
+            ))
+            return
+        
+        data = await state.get_data()
+        await state.update_data(bonus_days=bonus_days)
+        
+        # Step 3: Ask for max activations
+        prompt_text = _(
+            "admin_bulk_promo_step3_max_activations",
+            default="📦 <b>Массовое создание промокодов</b>\n\n<b>Шаг 3 из 4:</b> Максимальные активации\n\nКоличество: <b>{quantity}</b>\nБонусные дни: <b>{bonus_days}</b>\n\nВведите максимальное количество активаций для каждого промокода (1-10000):",
+            quantity=data['quantity'],
+            bonus_days=bonus_days
+        )
+        
+        await message.answer(
+            prompt_text,
+            reply_markup=get_back_to_admin_panel_keyboard(current_lang, i18n),
+            parse_mode="HTML"
+        )
+        await state.set_state(AdminStates.waiting_for_bulk_promo_max_activations)
+        
+    except ValueError:
+        await message.answer(_(
+            "admin_bulk_promo_invalid_bonus_days",
+            default="❌ Бонусные дни должны быть от 1 до 365"
+        ))
+
+# Step 3: Process max activations
+@router.message(AdminStates.waiting_for_bulk_promo_max_activations, F.text)
+async def process_bulk_promo_max_activations_handler(message: types.Message,
+                                                    state: FSMContext,
+                                                    i18n_data: dict,
+                                                    settings: Settings):
+    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)
+
+    try:
+        max_activations = int(message.text.strip())
+        if max_activations <= 0 or max_activations > 10000:
+            await message.answer(_(
+                "admin_bulk_promo_invalid_max_activations",
+                default="❌ Максимальные активации должны быть от 1 до 10000"
+            ))
+            return
+        
+        data = await state.get_data()
+        await state.update_data(max_activations=max_activations)
+        
+        # Step 4: Ask for validity days (optional)
+        keyboard = InlineKeyboardBuilder()
+        keyboard.row(
+            InlineKeyboardButton(
+                text=_("admin_bulk_promo_unlimited_validity", default="♾️ Неограниченно"),
+                callback_data="bulk_promo_unlimited_validity"
+            )
+        )
+        keyboard.row(
+            InlineKeyboardButton(
+                text=_("admin_bulk_promo_set_validity", default="⏰ Установить срок"),
+                callback_data="bulk_promo_set_validity"
+            )
+        )
+        keyboard.row(
+            InlineKeyboardButton(
+                text=_("admin_panel_back_button", default="⬅️ Назад"),
+                callback_data="admin_panel_back"
+            )
+        )
+        
+        prompt_text = _(
+            "admin_bulk_promo_step4_validity",
+            default="📦 <b>Массовое создание промокодов</b>\n\n<b>Шаг 4 из 4:</b> Срок действия\n\nКоличество: <b>{quantity}</b>\nБонусные дни: <b>{bonus_days}</b>\nМакс. активации: <b>{max_activations}</b>\n\nВыберите срок действия промокодов:",
+            quantity=data['quantity'],
+            bonus_days=data['bonus_days'],
+            max_activations=max_activations
+        )
+        
+        await message.answer(
+            prompt_text,
+            reply_markup=keyboard.as_markup(),
+            parse_mode="HTML"
+        )
+        await state.set_state(AdminStates.waiting_for_bulk_promo_validity_days)
+        
+    except ValueError:
+        await message.answer(_(
+            "admin_bulk_promo_invalid_max_activations",
+            default="❌ Максимальные активации должны быть от 1 до 10000"
+        ))
+
+# Handle validity choice buttons
+@router.callback_query(F.data == "bulk_promo_unlimited_validity", StateFilter(AdminStates.waiting_for_bulk_promo_validity_days))
+async def process_bulk_promo_unlimited_validity(callback: types.CallbackQuery,
+                                               state: FSMContext,
+                                               i18n_data: dict,
+                                               settings: Settings,
+                                               session: AsyncSession):
+    await state.update_data(validity_days=None)
+    await create_bulk_promo_codes_final(callback, state, i18n_data, settings, session)
+
+@router.callback_query(F.data == "bulk_promo_set_validity", StateFilter(AdminStates.waiting_for_bulk_promo_validity_days))
+async def process_bulk_promo_set_validity(callback: types.CallbackQuery,
+                                         state: FSMContext,
+                                         i18n_data: dict,
+                                         settings: Settings):
+    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 service error.", show_alert=True)
+        return
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs)
+
+    prompt_text = _(
+        "admin_bulk_promo_enter_validity_days",
+        default="⏰ Введите количество дней действия промокодов (1-365):"
+    )
+    
+    try:
+        await callback.message.edit_text(
+            prompt_text,
+            reply_markup=get_back_to_admin_panel_keyboard(current_lang, i18n)
+        )
+    except Exception as e:
+        await callback.message.answer(
+            prompt_text,
+            reply_markup=get_back_to_admin_panel_keyboard(current_lang, i18n)
+        )
+    await callback.answer()
+
+# Step 4: Process validity days (when user chooses to set)
+@router.message(AdminStates.waiting_for_bulk_promo_validity_days, F.text)
+async def process_bulk_promo_validity_days_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)
+
+    try:
+        validity_days = int(message.text.strip())
+        if validity_days <= 0 or validity_days > 365:
+            await message.answer(_(
+                "admin_bulk_promo_invalid_validity_days",
+                default="❌ Дни действия должны быть от 1 до 365"
+            ))
+            return
+        
+        await state.update_data(validity_days=validity_days)
+        
+        # Create a fake callback for consistency
+        fake_callback = types.CallbackQuery(
+            id="fake",
+            from_user=message.from_user,
+            chat_instance="fake",
+            message=message,
+            data="fake"
+        )
+        
+        await create_bulk_promo_codes_final(fake_callback, state, i18n_data, settings, session)
+        
+    except ValueError:
+        await message.answer(_(
+            "admin_bulk_promo_invalid_validity_days",
+            default="❌ Дни действия должны быть от 1 до 365"
+        ))
+
+async def create_bulk_promo_codes_final(callback_or_message,
+                                       state: FSMContext,
+                                       i18n_data: dict,
+                                       settings: Settings,
+                                       session: AsyncSession):
+    """Final step to create all promo codes"""
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    if not i18n:
+        if hasattr(callback_or_message, 'answer'):
+            await callback_or_message.answer("Language service error.", show_alert=True)
+        else:
+            await callback_or_message.reply("Language service error.")
+        return
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs)
+
+    data = await state.get_data()
+    quantity = data['quantity']
+    bonus_days = data['bonus_days']
+    max_activations = data['max_activations']
+    validity_days = data.get('validity_days')
+    
+    # Create validity date
+    valid_until_date: Optional[datetime] = None
+    valid_until_str_display = _("admin_promo_valid_indefinitely", default="Неограниченно")
+    
+    if validity_days:
+        valid_until_date = datetime.now(timezone.utc) + timedelta(days=validity_days)
+        valid_until_str_display = valid_until_date.strftime('%Y-%m-%d')
+
+    # Show creating message
+    creating_text = _(
+        "admin_bulk_promo_creating",
+        default="⏳ Создаю {quantity} промокодов...",
+        quantity=quantity
+    )
+    
+    if hasattr(callback_or_message, 'message'):
+        try:
+            await callback_or_message.message.edit_text(creating_text)
+        except:
+            await callback_or_message.message.answer(creating_text)
+        if hasattr(callback_or_message, 'answer'):
+            await callback_or_message.answer()
+    else:
+        await callback_or_message.answer(creating_text)
+
+    # Generate and create promo codes
+    created_codes = []
+    try:
+        for i in range(quantity):
+            # Generate unique code
+            promo_code = generate_unique_promo_code()
+            
+            # Ensure uniqueness
+            existing_promo = await promo_code_dal.get_promo_code_by_code(session, promo_code)
+            retries = 0
+            while existing_promo and retries < 10:
+                promo_code = generate_unique_promo_code()
+                existing_promo = await promo_code_dal.get_promo_code_by_code(session, promo_code)
+                retries += 1
+            
+            if retries >= 10:
+                raise Exception("Не удалось создать уникальный промокод")
+            
+            # Create promo code
+            promo_data = {
+                "code": promo_code,
+                "bonus_days": bonus_days,
+                "max_activations": max_activations,
+                "current_activations": 0,
+                "is_active": True,
+                "valid_until": valid_until_date,
+                "description": f"Bulk created #{i+1}/{quantity}"
+            }
+            
+            await promo_code_dal.create_promo_code(session, promo_data)
+            created_codes.append(promo_code)
+        
+        await session.commit()
+        
+        # Send success message
+        codes_text = " ".join(created_codes)
+        success_text = _(
+            "admin_bulk_promo_created_success",
+            default="✅ Создано {count} промокодов на {days} дней!\n\nДействуют до: {validity}\nМакс. активации: {max_act}\n\nПромокоды:\n{codes}",
+            count=quantity,
+            days=bonus_days,
+            validity=valid_until_str_display,
+            max_act=max_activations,
+            codes=codes_text[:3500] + "..." if len(codes_text) > 3500 else codes_text
+        )
+        
+        if hasattr(callback_or_message, 'message'):
+            target_message = callback_or_message.message
+        else:
+            target_message = callback_or_message
+            
+        await target_message.answer(
+            success_text,
+            reply_markup=get_back_to_admin_panel_keyboard(current_lang, i18n),
+            parse_mode="HTML"
+        )
+        
+        # Send codes as file if too many
+        if len(codes_text) > 3500:
+            codes_file_content = "\n".join(created_codes)
+            codes_file = types.BufferedInputFile(
+                codes_file_content.encode('utf-8'),
+                filename=f"bulk_promo_codes_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"
+            )
+            
+            await target_message.answer_document(
+                codes_file,
+                caption=_(
+                    "admin_bulk_promo_codes_file",
+                    default="📄 Все созданные промокоды в файле",
+                    count=quantity
+                )
+            )
+        
+    except Exception as e:
+        logging.error(f"Error creating bulk promo codes: {e}")
+        await session.rollback()
+        error_text = _(
+            "admin_bulk_promo_creation_failed",
+            default="❌ Ошибка создания промокодов: {error}",
+            error=str(e)
+        )
+        
+        if hasattr(callback_or_message, 'message'):
+            target_message = callback_or_message.message
+        else:
+            target_message = callback_or_message
+            
+        await target_message.answer(
+            error_text,
+            reply_markup=get_back_to_admin_panel_keyboard(current_lang, i18n)
+        )
+    
+    await state.clear()
+
 @router.message(AdminStates.waiting_for_bulk_promo_details, F.text)
 async def process_bulk_promo_details_handler(message: types.Message,
                                             state: FSMContext,

bot/handlers/admin/statistics.py

@@ -8,6 +8,7 @@ from config.settings import Settings
 
 from db.dal import user_dal, payment_dal, panel_sync_dal
 from db.models import Payment, PanelSyncStatus
+from bot.services.panel_api_service import PanelApiService
 
 from bot.keyboards.inline.admin_keyboards import get_back_to_admin_panel_keyboard
 from bot.middlewares.i18n import JsonI18n
@@ -137,6 +138,49 @@ async def show_statistics_handler(callback: types.CallbackQuery,
     else:
         stats_text_parts.append(f"\n{_('admin_sync_status_never_run')}")
 
+    # Panel Statistics
+    try:
+        panel_service = PanelApiService(settings)
+        
+        # Get panel system statistics
+        panel_stats = await panel_service.get_panel_statistics()
+        nodes_stats = await panel_service.get_nodes_statistics()
+        online_count = await panel_service.get_online_users_count()
+        users_activity = await panel_service.get_users_activity_stats()
+        
+        stats_text_parts.append(f"\n<b>🖥 {_('admin_panel_stats_header', default='Статистика панели')}</b>")
+        
+        if online_count is not None:
+            stats_text_parts.append(f"🟢 Онлайн сейчас: <b>{online_count}</b>")
+        
+        if users_activity:
+            today_connected = users_activity.get('today_connected', 'N/A')
+            week_connected = users_activity.get('week_connected', 'N/A')
+            never_connected = users_activity.get('never_connected', 'N/A')
+            stats_text_parts.append(f"📅 Подключались сегодня: <b>{today_connected}</b>")
+            stats_text_parts.append(f"📅 Подключались за неделю: <b>{week_connected}</b>")
+            stats_text_parts.append(f"❌ Никогда не подключались: <b>{never_connected}</b>")
+        
+        if nodes_stats:
+            active_nodes = len([node for node in nodes_stats if node.get('status') == 'active'])
+            total_nodes = len(nodes_stats)
+            stats_text_parts.append(f"🔗 Активных нод: <b>{active_nodes}/{total_nodes}</b>")
+        
+        if panel_stats:
+            system_info = panel_stats.get('system', {})
+            if system_info:
+                memory_usage = system_info.get('memory_usage_percent', 'N/A')
+                cpu_usage = system_info.get('cpu_usage_percent', 'N/A')
+                stats_text_parts.append(f"💾 Использование RAM: <b>{memory_usage}%</b>")
+                stats_text_parts.append(f"🔄 Загрузка CPU: <b>{cpu_usage}%</b>")
+        
+        await panel_service.close()
+        
+    except Exception as e:
+        logging.warning(f"Failed to fetch panel statistics: {e}")
+        stats_text_parts.append(f"\n<b>🖥 Статистика панели</b>")
+        stats_text_parts.append("❌ Не удалось получить данные с панели")
+
     final_text = "\n".join(stats_text_parts)
 
     try:

bot/services/panel_api_service.py

@@ -460,3 +460,43 @@ class PanelApiService:
     async def get_bot_db_last_sync_status(
             self, session: AsyncSession) -> Optional[PanelSyncStatus]:
         return await panel_sync_dal.get_panel_sync_status(session)
+    
+    
+    async def get_panel_statistics(self) -> Optional[Dict[str, Any]]:
+        """Get general panel statistics"""
+        response_data = await self._request("GET", "/admin/stats", log_full_response=False)
+        if response_data and not response_data.get("error") and "response" in response_data:
+            return response_data.get("response")
+        return None
+    
+    
+    async def get_nodes_statistics(self) -> Optional[List[Dict[str, Any]]]:
+        """Get nodes statistics"""
+        response_data = await self._request("GET", "/admin/nodes/stats", log_full_response=False)
+        if response_data and not response_data.get("error") and "response" in response_data:
+            return response_data.get("response", {}).get("nodes", [])
+        return None
+    
+    
+    async def get_system_info(self) -> Optional[Dict[str, Any]]:
+        """Get system information"""
+        response_data = await self._request("GET", "/admin/system/info", log_full_response=False)
+        if response_data and not response_data.get("error") and "response" in response_data:
+            return response_data.get("response")
+        return None
+    
+    
+    async def get_online_users_count(self) -> Optional[int]:
+        """Get count of currently online users"""
+        response_data = await self._request("GET", "/admin/stats/online-users", log_full_response=False)
+        if response_data and not response_data.get("error") and "response" in response_data:
+            return response_data.get("response", {}).get("count", 0)
+        return None
+    
+    
+    async def get_users_activity_stats(self) -> Optional[Dict[str, Any]]:
+        """Get users activity statistics (today, week, never connected)"""
+        response_data = await self._request("GET", "/admin/stats/users-activity", log_full_response=False)
+        if response_data and not response_data.get("error") and "response" in response_data:
+            return response_data.get("response")
+        return None

bot/states/admin_states.py

@@ -6,8 +6,17 @@ class AdminStates(StatesGroup):
     waiting_for_broadcast_message = State()
     confirming_broadcast = State()
     waiting_for_promo_details = State()
+    waiting_for_promo_code = State()
+    waiting_for_promo_bonus_days = State()
+    waiting_for_promo_max_activations = State()
+    waiting_for_promo_validity_days = State()
+    waiting_for_promo_description = State()
     waiting_for_promo_edit_details = State()
     waiting_for_bulk_promo_details = State()
+    waiting_for_bulk_promo_quantity = State()
+    waiting_for_bulk_promo_bonus_days = State()
+    waiting_for_bulk_promo_max_activations = State()
+    waiting_for_bulk_promo_validity_days = State()
     waiting_for_user_id_to_ban = State()
     waiting_for_user_id_to_unban = State()
 

locales/en.json

@@ -323,5 +323,42 @@
   "admin_csv_header_raw_update_preview": "Update Preview",
   
   "admin_banned_users_empty": "📋 Banned Users\n\nList is empty",
-  "admin_banned_users_list": "📋 Banned Users ({count}):\n\n{users}"
+  "admin_banned_users_list": "📋 Banned Users ({count}):\n\n{users}",
+  
+  "admin_panel_stats_header": "Panel Statistics",
+  "admin_bulk_promo_invalid_values": "❌ Invalid values: {error}",
+  
+  "admin_bulk_promo_step1_quantity": "📦 <b>Bulk Promo Code Creation</b>\n\n<b>Step 1 of 4:</b> Quantity\n\nEnter the number of promo codes to create (1-1000):",
+  "admin_bulk_promo_step2_bonus_days": "📦 <b>Bulk Promo Code Creation</b>\n\n<b>Step 2 of 4:</b> Bonus Days\n\nQuantity: <b>{quantity}</b>\n\nEnter the number of bonus days (1-365):",
+  "admin_bulk_promo_step3_max_activations": "📦 <b>Bulk Promo Code Creation</b>\n\n<b>Step 3 of 4:</b> Max Activations\n\nQuantity: <b>{quantity}</b>\nBonus days: <b>{bonus_days}</b>\n\nEnter the maximum number of activations for each promo code (1-10000):",
+  "admin_bulk_promo_step4_validity": "📦 <b>Bulk Promo Code Creation</b>\n\n<b>Step 4 of 4:</b> Validity Period\n\nQuantity: <b>{quantity}</b>\nBonus days: <b>{bonus_days}</b>\nMax activations: <b>{max_activations}</b>\n\nChoose the validity period for promo codes:",
+  
+  "admin_bulk_promo_invalid_quantity": "❌ Quantity must be between 1 and 1000",
+  "admin_bulk_promo_invalid_bonus_days": "❌ Bonus days must be between 1 and 365",
+  "admin_bulk_promo_invalid_max_activations": "❌ Max activations must be between 1 and 10000",
+  "admin_bulk_promo_invalid_validity_days": "❌ Validity days must be between 1 and 365",
+  
+  "admin_bulk_promo_unlimited_validity": "♾️ Unlimited",
+  "admin_bulk_promo_set_validity": "⏰ Set Period",
+  "admin_bulk_promo_enter_validity_days": "⏰ Enter the number of validity days for promo codes (1-365):",
+  
+  "admin_bulk_promo_creating": "⏳ Creating {quantity} promo codes...",
+  
+  "admin_promo_step1_code": "🎟 <b>Create Promo Code</b>\n\n<b>Step 1 of 5:</b> Promo Code\n\nEnter promo code (3-30 characters, letters and numbers only):",
+  "admin_promo_step2_bonus_days": "🎟 <b>Create Promo Code</b>\n\n<b>Step 2 of 5:</b> Bonus Days\n\nCode: <b>{code}</b>\n\nEnter the number of bonus days (1-365):",
+  "admin_promo_step3_max_activations": "🎟 <b>Create Promo Code</b>\n\n<b>Step 3 of 5:</b> Max Activations\n\nCode: <b>{code}</b>\nBonus days: <b>{bonus_days}</b>\n\nEnter the maximum number of activations (1-10000):",
+  "admin_promo_step4_validity": "🎟 <b>Create Promo Code</b>\n\n<b>Step 4 of 5:</b> Validity Period\n\nCode: <b>{code}</b>\nBonus days: <b>{bonus_days}</b>\nMax activations: <b>{max_activations}</b>\n\nChoose the validity period for the promo code:",
+  "admin_promo_step5_description": "🎟 <b>Create Promo Code</b>\n\n<b>Step 5 of 5:</b> Description (optional)\n\nCode: <b>{code}</b>\nBonus days: <b>{bonus_days}</b>\nMax activations: <b>{max_activations}</b>\nValid until: <b>{validity}</b>\n\nEnter promo code description or click \"Skip\":",
+  
+  "admin_promo_invalid_code_format": "❌ Promo code must contain 3-30 characters (letters and numbers only)",
+  "admin_promo_code_already_exists": "❌ A promo code with this code already exists",
+  "admin_promo_processing_error": "❌ Error processing promo code",
+  "admin_promo_unlimited_validity": "♾️ Unlimited",
+  "admin_promo_set_validity": "⏰ Set Period",
+  "admin_promo_enter_validity_days": "⏰ Enter the number of validity days for the promo code (1-365):",
+  "admin_promo_skip_description": "⏭️ Skip",
+  "admin_promo_description_too_long": "❌ Description must not exceed 200 characters",
+  "admin_promo_creating": "⏳ Creating promo code...",
+  "admin_promo_created_success": "✅ Promo code created!\n\n🎟 Code: <b>{code}</b>\n🎁 Bonus days: <b>{days}</b>\n🔢 Max activations: <b>{max_act}</b>\n⏰ Valid until: <b>{validity}</b>\n📝 Description: {description}",
+  "admin_promo_creation_failed": "❌ Error creating promo code: {error}"
 }

locales/ru.json

@@ -323,5 +323,42 @@
   "admin_csv_header_raw_update_preview": "Превью обновления",
   
   "admin_banned_users_empty": "📋 Заблокированные пользователи\n\nСписок пуст",
-  "admin_banned_users_list": "📋 Заблокированные пользователи ({count}):\n\n{users}"
+  "admin_banned_users_list": "📋 Заблокированные пользователи ({count}):\n\n{users}",
+  
+  "admin_panel_stats_header": "Статистика панели",
+  "admin_bulk_promo_invalid_values": "❌ Неверные значения: {error}",
+  
+  "admin_bulk_promo_step1_quantity": "📦 <b>Массовое создание промокодов</b>\n\n<b>Шаг 1 из 4:</b> Количество промокодов\n\nВведите количество промокодов для создания (1-1000):",
+  "admin_bulk_promo_step2_bonus_days": "📦 <b>Массовое создание промокодов</b>\n\n<b>Шаг 2 из 4:</b> Бонусные дни\n\nКоличество: <b>{quantity}</b>\n\nВведите количество бонусных дней (1-365):",
+  "admin_bulk_promo_step3_max_activations": "📦 <b>Массовое создание промокодов</b>\n\n<b>Шаг 3 из 4:</b> Максимальные активации\n\nКоличество: <b>{quantity}</b>\nБонусные дни: <b>{bonus_days}</b>\n\nВведите максимальное количество активаций для каждого промокода (1-10000):",
+  "admin_bulk_promo_step4_validity": "📦 <b>Массовое создание промокодов</b>\n\n<b>Шаг 4 из 4:</b> Срок действия\n\nКоличество: <b>{quantity}</b>\nБонусные дни: <b>{bonus_days}</b>\nМакс. активации: <b>{max_activations}</b>\n\nВыберите срок действия промокодов:",
+  
+  "admin_bulk_promo_invalid_quantity": "❌ Количество должно быть от 1 до 1000",
+  "admin_bulk_promo_invalid_bonus_days": "❌ Бонусные дни должны быть от 1 до 365",
+  "admin_bulk_promo_invalid_max_activations": "❌ Максимальные активации должны быть от 1 до 10000",
+  "admin_bulk_promo_invalid_validity_days": "❌ Дни действия должны быть от 1 до 365",
+  
+  "admin_bulk_promo_unlimited_validity": "♾️ Неограниченно",
+  "admin_bulk_promo_set_validity": "⏰ Установить срок",
+  "admin_bulk_promo_enter_validity_days": "⏰ Введите количество дней действия промокодов (1-365):",
+  
+  "admin_bulk_promo_creating": "⏳ Создаю {quantity} промокодов...",
+  
+  "admin_promo_step1_code": "🎟 <b>Создание промокода</b>\n\n<b>Шаг 1 из 5:</b> Код промокода\n\nВведите код промокода (3-30 символов, только буквы и цифры):",
+  "admin_promo_step2_bonus_days": "🎟 <b>Создание промокода</b>\n\n<b>Шаг 2 из 5:</b> Бонусные дни\n\nКод: <b>{code}</b>\n\nВведите количество бонусных дней (1-365):",
+  "admin_promo_step3_max_activations": "🎟 <b>Создание промокода</b>\n\n<b>Шаг 3 из 5:</b> Максимальные активации\n\nКод: <b>{code}</b>\nБонусные дни: <b>{bonus_days}</b>\n\nВведите максимальное количество активаций (1-10000):",
+  "admin_promo_step4_validity": "🎟 <b>Создание промокода</b>\n\n<b>Шаг 4 из 5:</b> Срок действия\n\nКод: <b>{code}</b>\nБонусные дни: <b>{bonus_days}</b>\nМакс. активации: <b>{max_activations}</b>\n\nВыберите срок действия промокода:",
+  "admin_promo_step5_description": "🎟 <b>Создание промокода</b>\n\n<b>Шаг 5 из 5:</b> Описание (опционально)\n\nКод: <b>{code}</b>\nБонусные дни: <b>{bonus_days}</b>\nМакс. активации: <b>{max_activations}</b>\nДействует: <b>{validity}</b>\n\nВведите описание промокода или нажмите \"Пропустить\":",
+  
+  "admin_promo_invalid_code_format": "❌ Код промокода должен содержать 3-30 символов (только буквы и цифры)",
+  "admin_promo_code_already_exists": "❌ Промокод с таким кодом уже существует",
+  "admin_promo_processing_error": "❌ Ошибка обработки промокода",
+  "admin_promo_unlimited_validity": "♾️ Неограниченно",
+  "admin_promo_set_validity": "⏰ Установить срок",
+  "admin_promo_enter_validity_days": "⏰ Введите количество дней действия промокода (1-365):",
+  "admin_promo_skip_description": "⏭️ Пропустить",
+  "admin_promo_description_too_long": "❌ Описание не должно превышать 200 символов",
+  "admin_promo_creating": "⏳ Создаю промокод...",
+  "admin_promo_created_success": "✅ Промокод создан!\n\n🎟 Код: <b>{code}</b>\n🎁 Бонусные дни: <b>{days}</b>\n🔢 Максимальные активации: <b>{max_act}</b>\n⏰ Действует до: <b>{validity}</b>\n📝 Описание: {description}",
+  "admin_promo_creation_failed": "❌ Ошибка создания промокода: {error}"
 }