feat(promo): Добавлены промокоды на скидку в процентах

2026-01-19 03:50:33 +05:00
parent 0701af0f35
commit 3bf9acf4d4
14 changed files with 682 additions and 62 deletions
@@ -28,25 +28,82 @@ async def create_promo_prompt_handler(callback: types.CallbackQuery,
        return
    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs)

-    # Step 1: Ask for promo code
+    # Step 0: Ask for promo type (bonus_days or discount)
    prompt_text = _(
-        "admin_promo_step1_code"
+        "admin_promo_step0_type"
+    )
+
+    # Create keyboard for type selection
+    builder = InlineKeyboardBuilder()
+    builder.row(
+        InlineKeyboardButton(
+            text=_("admin_promo_type_bonus_days"),
+            callback_data="promo_type_select:bonus_days"
+        )
+    )
+    builder.row(
+        InlineKeyboardButton(
+            text=_("admin_promo_type_discount"),
+            callback_data="promo_type_select:discount"
+        )
+    )
+    builder.row(
+        InlineKeyboardButton(
+            text=_("admin_back_to_panel"),
+            callback_data="admin_action:main"
+        )
    )

    try:
        await callback.message.edit_text(
            prompt_text,
-            reply_markup=get_back_to_admin_panel_keyboard(current_lang, i18n),
+            reply_markup=builder.as_markup(),
            parse_mode="HTML")
    except Exception as e:
        logging.warning(
-            f"Could not edit message for promo prompt: {e}. Sending new.")
+            f"Could not edit message for promo type prompt: {e}. Sending new.")
        await callback.message.answer(
            prompt_text,
-            reply_markup=get_back_to_admin_panel_keyboard(current_lang, i18n),
+            reply_markup=builder.as_markup(),
            parse_mode="HTML")
    await callback.answer()
-    await state.set_state(AdminStates.waiting_for_promo_code)
+    await state.set_state(AdminStates.waiting_for_promo_type_selection)
+
+
+# Step 0: Process type selection
+@router.callback_query(F.data.startswith("promo_type_select:"), StateFilter(AdminStates.waiting_for_promo_type_selection))
+async def process_promo_type_selection(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 or not callback.message:
+        await callback.answer("Error processing type selection.", show_alert=True)
+        return
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs)
+
+    try:
+        promo_type = callback.data.split(":")[-1]  # "bonus_days" or "discount"
+        await state.update_data(promo_type=promo_type)
+
+        # Step 1: Ask for promo code
+        prompt_text = _(
+            "admin_promo_step1_code"
+        )
+
+        await callback.message.edit_text(
+            prompt_text,
+            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_code)
+
+    except Exception as e:
+        logging.error(f"Error processing promo type selection: {e}")
+        await callback.message.answer(_("error_occurred_try_again"))
+        await callback.answer()


 # Step 1: Process promo code
@@ -80,19 +137,31 @@ async def process_promo_code_handler(message: types.Message,
            return
        
        await state.update_data(promo_code=code_str)
-        
-        # Step 2: Ask for bonus days
-        prompt_text = _(
-            "admin_promo_step2_bonus_days",
-            code=code_str
-        )
-        
+
+        # Get promo type from state
+        data = await state.get_data()
+        promo_type = data.get("promo_type", "bonus_days")
+
+        # Step 2: Ask for bonus days OR discount percentage based on type
+        if promo_type == "discount":
+            prompt_text = _(
+                "admin_promo_step2_discount_percentage",
+                code=code_str
+            )
+            next_state = AdminStates.waiting_for_promo_discount_percentage
+        else:
+            prompt_text = _(
+                "admin_promo_step2_bonus_days",
+                code=code_str
+            )
+            next_state = AdminStates.waiting_for_promo_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_bonus_days)
+        await state.set_state(next_state)
        
    except Exception as e:
        logging.error(f"Error processing promo code: {e}")
@@ -119,9 +188,9 @@ async def process_promo_bonus_days_handler(message: types.Message,
                "admin_promo_invalid_bonus_days"
            ))
            return
-        
+
        await state.update_data(bonus_days=bonus_days)
-        
+
        # Step 3: Ask for max activations
        data = await state.get_data()
        prompt_text = _(
@@ -129,14 +198,14 @@ async def process_promo_bonus_days_handler(message: types.Message,
            code=data.get("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_number"
@@ -146,6 +215,53 @@ async def process_promo_bonus_days_handler(message: types.Message,
        await message.answer(_("error_occurred_try_again"))


+# Step 2: Process discount percentage
+@router.message(AdminStates.waiting_for_promo_discount_percentage, F.text)
+async def process_promo_discount_percentage_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:
+        discount_percentage = int(message.text.strip())
+        if not (1 <= discount_percentage <= 100):
+            await message.answer(
+                "❌ Discount percentage must be between 1 and 100."
+            )
+            return
+
+        await state.update_data(discount_percentage=discount_percentage)
+
+        # Step 3: Ask for max activations
+        data = await state.get_data()
+        prompt_text = _(
+            "admin_promo_step3_max_activations",
+            code=data.get("promo_code"),
+            bonus_days=f"{discount_percentage}%"  # Display as percentage in place of 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_number"
+        ))
+    except Exception as e:
+        logging.error(f"Error processing discount percentage: {e}")
+        await message.answer(_("error_occurred_try_again"))
+
+
 # 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,
@@ -310,37 +426,53 @@ async def create_promo_code_final(callback_or_message,

    try:
        data = await state.get_data()
-        
+        promo_type = data.get("promo_type", "bonus_days")
+
        # Prepare promo code data
        promo_data = {
            "code": data["promo_code"],
-            "bonus_days": data["bonus_days"],
+            "promo_type": promo_type,
            "max_activations": data["max_activations"],
            "current_activations": 0,
            "is_active": True,
            "created_by_admin_id": callback_or_message.from_user.id,
            "created_at": datetime.now(timezone.utc)
        }
-        
+
+        # Set type-specific fields
+        if promo_type == "discount":
+            promo_data["discount_percentage"] = data["discount_percentage"]
+            promo_data["bonus_days"] = None
+        else:
+            promo_data["bonus_days"] = data["bonus_days"]
+            promo_data["discount_percentage"] = None
+
        # Set validity
        if data.get("validity_days"):
            promo_data["valid_until"] = datetime.now(timezone.utc) + timedelta(days=data["validity_days"])
        else:
            promo_data["valid_until"] = None
-        
+
        # Create promo code
        created_promo = await promo_code_dal.create_promo_code(session, promo_data)
        await session.commit()
-        
+
        # Log successful creation
-        logging.info(f"Promo code '{data['promo_code']}' created with ID {created_promo.promo_code_id}")
-        
+        logging.info(f"Promo code '{data['promo_code']}' ({promo_type}) created with ID {created_promo.promo_code_id}")
+
        # Success message
-        valid_until_str = _("admin_promo_unlimited") if not data.get("validity_days") else f"{data['validity_days']} дней"
+        valid_until_str = _("admin_promo_unlimited") if not data.get("validity_days") else f"{data['validity_days']} days"
+
+        # Format success message based on type
+        if promo_type == "discount":
+            value_display = f"{data['discount_percentage']}%"
+        else:
+            value_display = f"{data['bonus_days']} days"
+
        success_text = _(
            "admin_promo_created_success",
            code=data["promo_code"],
-            bonus_days=data["bonus_days"],
+            bonus_days=value_display,  # Reusing bonus_days placeholder for display
            max_activations=data["max_activations"],
            valid_until_str=valid_until_str
        )
@@ -385,8 +517,10 @@ async def create_promo_code_final(callback_or_message,
@router.callback_query(
    F.data == "admin_action:main",
    StateFilter(
+        AdminStates.waiting_for_promo_type_selection,
        AdminStates.waiting_for_promo_code,
        AdminStates.waiting_for_promo_bonus_days,
+        AdminStates.waiting_for_promo_discount_percentage,
        AdminStates.waiting_for_promo_max_activations,
        AdminStates.waiting_for_promo_validity_days,
    ),
@@ -47,9 +47,19 @@ async def get_promo_detail_text_and_keyboard(promo_id: int, session: AsyncSessio

    created = promo.created_at.strftime("%d.%m.%Y %H:%M") if promo.created_at else "N/A"

+    # Determine promo type and value to display
+    promo_type = getattr(promo, "promo_type", "bonus_days")
+    if promo_type == "discount":
+        type_name = _("admin_promo_type_discount")
+        value_line = _("admin_promo_card_discount_percentage", percentage=promo.discount_percentage)
+    else:
+        type_name = _("admin_promo_type_bonus_days")
+        value_line = _("admin_promo_card_bonus_days", days=promo.bonus_days)
+
    text = "\n".join([
        _("admin_promo_card_title", code=promo.code),
-        _("admin_promo_card_bonus_days", days=promo.bonus_days),
+        _("admin_promo_card_type", type=type_name),
+        value_line,
        _("admin_promo_card_activations", current=promo.current_activations, max=promo.max_activations),
        _("admin_promo_card_validity", validity=validity),
        _("admin_promo_card_status", status=status),
@@ -76,12 +86,22 @@ async def view_promo_codes_handler(callback: types.CallbackQuery, i18n_data: dic
    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs)

    promo_models = await promo_code_dal.get_all_active_promo_codes(session, limit=20, offset=0)
-    text = f"{_('admin_active_promos_list_header')}\n\n{_('admin_no_active_promos')}" if not promo_models else "\n".join(
-        [_("admin_active_promos_list_header"), ""] + [
-            f"{get_promo_status_emoji_and_text(p, i18n, current_lang)[0]} <code>{p.code}</code> | 🎁 {p.bonus_days}д | 📊 {p.current_activations}/{p.max_activations} | ⏰ {p.valid_until.strftime('%d.%m.%Y') if p.valid_until else _('admin_promo_valid_indefinitely')}"
-            for p in promo_models
-        ]
-    )
+    if not promo_models:
+        text = f"{_('admin_active_promos_list_header')}\n\n{_('admin_no_active_promos')}"
+    else:
+        promo_lines = [_("admin_active_promos_list_header"), ""]
+        for p in promo_models:
+            status_emoji = get_promo_status_emoji_and_text(p, i18n, current_lang)[0]
+            promo_type = getattr(p, "promo_type", "bonus_days")
+            if promo_type == "discount":
+                value_display = f"💰 {p.discount_percentage}%"
+            else:
+                value_display = f"🎁 {p.bonus_days}д"
+            validity_display = p.valid_until.strftime('%d.%m.%Y') if p.valid_until else _('admin_promo_valid_indefinitely')
+            promo_lines.append(
+                f"{status_emoji} <code>{p.code}</code> | {value_display} | 📊 {p.current_activations}/{p.max_activations} | ⏰ {validity_display}"
+            )
+        text = "\n".join(promo_lines)
    
    await callback.message.edit_text(text, reply_markup=get_back_to_admin_panel_keyboard(current_lang, i18n), parse_mode="HTML")
    await callback.answer()
@@ -300,7 +320,9 @@ async def promo_export_all_handler(callback: types.CallbackQuery, i18n_data: dic
        # CSV headers (forced to English)
        writer.writerow([
            i18n.gettext(export_lang, "admin_promo_csv_code"),
+            "Type",
            i18n.gettext(export_lang, "admin_promo_csv_bonus_days"),
+            "Discount %",
            i18n.gettext(export_lang, "admin_promo_csv_max_activations"),
            i18n.gettext(export_lang, "admin_promo_csv_current_activations"),
            i18n.gettext(export_lang, "admin_promo_csv_status"),
@@ -309,15 +331,22 @@ async def promo_export_all_handler(callback: types.CallbackQuery, i18n_data: dic
            i18n.gettext(export_lang, "admin_promo_csv_created_at"),
            i18n.gettext(export_lang, "admin_promo_csv_created_by_admin_id"),
        ])
-        
+
        for promo in all_promos:
            # Определяем статус
            status_emoji, status_text = get_promo_status_emoji_and_text(promo, i18n, export_lang)
-            
+
+            # Determine promo type and values
+            promo_type = getattr(promo, "promo_type", "bonus_days")
+            bonus_days_val = promo.bonus_days if promo_type == "bonus_days" else "N/A"
+            discount_val = promo.discount_percentage if promo_type == "discount" else "N/A"
+
            # Формируем данные для CSV
            row = [
                promo.code,
-                promo.bonus_days,
+                promo_type,
+                bonus_days_val,
+                discount_val,
                promo.max_activations,
                promo.current_activations,
                status_text,
@@ -374,13 +403,26 @@ async def promo_edit_select_handler(callback: types.CallbackQuery, i18n_data: di
        return
    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs)
    promo_id = int(callback.data.split(":")[1])
-    
+
+    # Get promo to check type
+    promo = await promo_code_dal.get_promo_code_by_id(session, promo_id)
+    if not promo:
+        await callback.answer(_("admin_promo_not_found"), show_alert=True)
+        return
+
+    promo_type = getattr(promo, "promo_type", "bonus_days")
+
    builder = InlineKeyboardBuilder()
-    builder.row(InlineKeyboardButton(text=_("admin_promo_edit_bonus_days"), callback_data=f"promo_edit_field:bonus_days:{promo_id}"))
+    # Show appropriate edit option based on type
+    if promo_type == "discount":
+        builder.row(InlineKeyboardButton(text="💰 Edit Discount %", callback_data=f"promo_edit_field:discount_percentage:{promo_id}"))
+    else:
+        builder.row(InlineKeyboardButton(text=_("admin_promo_edit_bonus_days"), callback_data=f"promo_edit_field:bonus_days:{promo_id}"))
+
    builder.row(InlineKeyboardButton(text=_("admin_promo_edit_max_activations"), callback_data=f"promo_edit_field:max_activations:{promo_id}"))
    builder.row(InlineKeyboardButton(text=_("admin_promo_edit_validity"), callback_data=f"promo_edit_field:valid_until:{promo_id}"))
    builder.row(InlineKeyboardButton(text=_("admin_promo_back_to_detail_button"), callback_data=f"promo_detail:{promo_id}"))
-    
+
    await callback.message.edit_text(_("admin_promo_edit_select_field"), reply_markup=builder.as_markup())
    await callback.answer()

@@ -394,14 +436,22 @@ async def promo_edit_field_handler(callback: types.CallbackQuery, state: FSMCont
    
    action, field, promo_id_str = callback.data.split(":")
    await state.update_data(promo_id=int(promo_id_str), field_to_edit=field)
-    
+
    prompts = {
        "bonus_days": "admin_promo_prompt_bonus_days",
+        "discount_percentage": "admin_promo_prompt_discount_percentage",
        "max_activations": "admin_promo_prompt_max_activations",
        "valid_until": "admin_promo_prompt_validity_days"
    }
+
+    prompt_key = prompts.get(field, "error_occurred_try_again")
+    if field == "discount_percentage":
+        prompt_text = "Enter the new discount percentage (1-100):"
+    else:
+        prompt_text = _(prompt_key)
+
    await state.set_state(AdminStates.waiting_for_promo_edit_details)
-    await callback.message.edit_text(_(prompts.get(field, "error_occurred_try_again")))
+    await callback.message.edit_text(prompt_text)
    await callback.answer()

@router.message(StateFilter(AdminStates.waiting_for_promo_edit_details))
@@ -418,9 +468,15 @@ async def process_promo_edit_details(message: types.Message, state: FSMContext,
    try:
        value = message.text
        update_data = {}
-        
+
        if field == "bonus_days":
            update_data["bonus_days"] = int(value)
+        elif field == "discount_percentage":
+            discount_pct = int(value)
+            if not (1 <= discount_pct <= 100):
+                await message.answer("❌ Discount percentage must be between 1 and 100.")
+                return
+            update_data["discount_percentage"] = discount_pct
        elif field == "max_activations":
            update_data["max_activations"] = int(value)
        elif field == "valid_until":
@@ -433,7 +489,7 @@ async def process_promo_edit_details(message: types.Message, state: FSMContext,
        if await promo_code_dal.update_promo_code(session, promo_id, update_data):
            await session.commit()
            await message.answer(_("admin_promo_edit_success"))
-            
+
            # Reset state and show updated details
            await state.clear()
            text, keyboard = await get_promo_detail_text_and_keyboard(promo_id, session, i18n, current_lang)