Vladless
690 lines
29 KiB
Python
690 lines
29 KiB
Python
import csv
|
|
from datetime import datetime
|
|
from io import StringIO
|
|
import re
|
|
|
|
from fastapi import APIRouter, Depends, Path, Query
|
|
from fastapi.responses import JSONResponse, StreamingResponse
|
|
from sqlalchemy import text
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from api.depends import get_session, verify_identity_admin
|
|
|
|
try:
|
|
from modules.partner_program.settings import PARTNER_BONUS_PERCENTAGES
|
|
except Exception:
|
|
PARTNER_BONUS_PERCENTAGES = {1: 0.0}
|
|
|
|
|
|
router = APIRouter()
|
|
|
|
|
|
def _parse_percent(value: float) -> float | None:
|
|
try:
|
|
val = float(value)
|
|
except (TypeError, ValueError):
|
|
return None
|
|
if 0.0 <= val <= 1.0:
|
|
val *= 100.0
|
|
if 0.0 <= val <= 100.0:
|
|
return val
|
|
return None
|
|
|
|
|
|
def _default_partner_percent() -> float:
|
|
try:
|
|
return float(PARTNER_BONUS_PERCENTAGES.get(1, 0.0)) * 100.0
|
|
except Exception:
|
|
return 0.0
|
|
|
|
|
|
def _row_dt_iso(value) -> str | None:
|
|
if isinstance(value, datetime):
|
|
return value.isoformat()
|
|
return None
|
|
|
|
|
|
@router.get("/all")
|
|
async def get_all_partners(
|
|
limit: int = Query(1000, ge=1, le=10000, description="Лимит результатов"),
|
|
offset: int = Query(0, ge=0, description="Смещение"),
|
|
identity=Depends(verify_identity_admin),
|
|
session: AsyncSession = Depends(get_session),
|
|
):
|
|
"""Список всех партнёров со статистикой. Требуется админ (X-Identity-Id + X-Token)."""
|
|
partners_sql = text(
|
|
"""
|
|
SELECT
|
|
p.partner_tg_id AS tg_id,
|
|
COALESCE(u.partner_balance, 0) AS partner_balance,
|
|
u.partner_percent,
|
|
COALESCE(u.partner_percent_custom, false) AS partner_percent_custom,
|
|
u.partner_code,
|
|
u.payout_method,
|
|
COUNT(p.joined_tg_id) as joined_count
|
|
FROM partners p
|
|
LEFT JOIN users u ON u.tg_id = p.partner_tg_id
|
|
WHERE p.partner_tg_id IS NOT NULL
|
|
GROUP BY p.partner_tg_id, u.partner_balance, u.partner_percent, u.partner_percent_custom, u.partner_code, u.payout_method
|
|
ORDER BY partner_balance DESC
|
|
LIMIT :limit OFFSET :offset
|
|
"""
|
|
)
|
|
count_sql = text(
|
|
"""
|
|
SELECT COUNT(DISTINCT partner_tg_id) FROM partners
|
|
WHERE partner_tg_id IS NOT NULL
|
|
"""
|
|
)
|
|
result = await session.execute(partners_sql, {"limit": limit, "offset": offset})
|
|
partners = result.fetchall()
|
|
count_result = await session.execute(count_sql)
|
|
total = count_result.scalar() or 0
|
|
default_percent = _default_partner_percent()
|
|
partners_list = []
|
|
for partner in partners:
|
|
percent_value = partner[2]
|
|
percent_custom = bool(partner[3])
|
|
percent = float(percent_value) if (percent_custom and percent_value is not None) else float(default_percent)
|
|
partners_list.append({
|
|
"tg_id": int(partner[0]),
|
|
"balance": float(partner[1] or 0),
|
|
"percent": percent,
|
|
"code": partner[4] or None,
|
|
"method": partner[5] or None,
|
|
"referred_count": int(partner[6] or 0),
|
|
})
|
|
return JSONResponse(content={"total": total, "items": partners_list})
|
|
|
|
|
|
@router.get("/stats/all")
|
|
async def get_partners_stats(
|
|
identity=Depends(verify_identity_admin),
|
|
session: AsyncSession = Depends(get_session),
|
|
):
|
|
"""Общая статистика партнёрской программы."""
|
|
stats_sql = text(
|
|
"""
|
|
WITH partner_refs AS (
|
|
SELECT partner_tg_id, COUNT(DISTINCT joined_tg_id) AS ref_count
|
|
FROM partners
|
|
WHERE partner_tg_id IS NOT NULL
|
|
GROUP BY partner_tg_id
|
|
)
|
|
SELECT
|
|
(SELECT COUNT(*) FROM partner_refs) AS total_partners,
|
|
(SELECT COUNT(DISTINCT partner_tg_id) FROM partners WHERE partner_tg_id IS NOT NULL AND DATE(created_at) = CURRENT_DATE) AS partners_today,
|
|
(SELECT COUNT(DISTINCT joined_tg_id) FROM partners WHERE partner_tg_id IS NOT NULL) AS total_referred,
|
|
(SELECT COALESCE(SUM(u.partner_balance), 0.0) FROM users u WHERE u.tg_id IN (SELECT partner_tg_id FROM partner_refs)) AS total_balance,
|
|
(SELECT partner_tg_id FROM partner_refs ORDER BY ref_count DESC LIMIT 1) AS top_partner_tg_id,
|
|
(SELECT ref_count FROM partner_refs ORDER BY ref_count DESC LIMIT 1) AS top_partner_refs
|
|
"""
|
|
)
|
|
stats_result = await session.execute(stats_sql)
|
|
stats_row = stats_result.fetchone()
|
|
if stats_row:
|
|
stats = {
|
|
"total_partners": int(stats_row[0] or 0),
|
|
"partners_today": int(stats_row[1] or 0),
|
|
"total_referred": int(stats_row[2] or 0),
|
|
"total_balance": float(stats_row[3] or 0.0),
|
|
"top_partner_tg_id": int(stats_row[4] or 0),
|
|
"top_partner_refs": int(stats_row[5] or 0),
|
|
}
|
|
else:
|
|
stats = {
|
|
"total_partners": 0,
|
|
"partners_today": 0,
|
|
"total_referred": 0,
|
|
"total_balance": 0.0,
|
|
"top_partner_tg_id": 0,
|
|
"top_partner_refs": 0,
|
|
}
|
|
return JSONResponse(content=stats)
|
|
|
|
|
|
@router.patch("/{tg_id}")
|
|
async def update_partner(
|
|
tg_id: int = Path(..., description="Telegram ID партнёра"),
|
|
balance: float = Query(..., description="Новый баланс партнёра"),
|
|
percent: float = Query(..., description="Новый процент партнёра"),
|
|
identity=Depends(verify_identity_admin),
|
|
session: AsyncSession = Depends(get_session),
|
|
):
|
|
"""Обновляет данные партнёра (баланс и процент)."""
|
|
try:
|
|
stmt = text(
|
|
"""
|
|
UPDATE users
|
|
SET partner_balance = :balance, partner_percent = :percent
|
|
WHERE tg_id = :tg_id
|
|
"""
|
|
)
|
|
result = await session.execute(stmt, {"tg_id": tg_id, "balance": balance, "percent": percent})
|
|
await session.commit()
|
|
if result.rowcount > 0:
|
|
return JSONResponse(
|
|
content={"success": True, "message": f"Партнёр {tg_id} успешно обновлён"}, status_code=200
|
|
)
|
|
return JSONResponse(content={"success": False, "message": "Партнёр не найден"}, status_code=404)
|
|
except Exception as e:
|
|
await session.rollback()
|
|
return JSONResponse(content={"success": False, "message": str(e)}, status_code=500)
|
|
|
|
|
|
@router.get("/{tg_id}")
|
|
async def get_partner_data(
|
|
tg_id: int = Path(..., description="Telegram ID партнёра"),
|
|
identity=Depends(verify_identity_admin),
|
|
session: AsyncSession = Depends(get_session),
|
|
):
|
|
"""Партнёрские данные по tg_id и список приглашённых."""
|
|
meta_sql = text(
|
|
"""
|
|
SELECT COALESCE(u.partner_balance, 0), u.partner_percent, COALESCE(u.partner_percent_custom, false), u.partner_code, u.payout_method
|
|
FROM users u WHERE u.tg_id = :tg_id
|
|
"""
|
|
)
|
|
invited_sql = text(
|
|
"""
|
|
SELECT pr.joined_tg_id, pr.created_at, COALESCE(u.balance, 0),
|
|
(SELECT COUNT(*) FROM keys k WHERE k.tg_id = pr.joined_tg_id),
|
|
(SELECT COUNT(*) FROM payments pay WHERE pay.tg_id = pr.joined_tg_id AND lower(pay.status) = 'success')
|
|
FROM partners pr
|
|
LEFT JOIN users u ON u.tg_id = pr.joined_tg_id
|
|
WHERE pr.partner_tg_id = :tg_id
|
|
ORDER BY pr.created_at DESC
|
|
"""
|
|
)
|
|
meta_res = await session.execute(meta_sql, {"tg_id": tg_id})
|
|
meta_row = meta_res.fetchone()
|
|
invited_res = await session.execute(invited_sql, {"tg_id": tg_id})
|
|
invited_rows = invited_res.fetchall()
|
|
default_percent = _default_partner_percent()
|
|
percent = default_percent
|
|
if meta_row:
|
|
percent_value, percent_custom = meta_row[1], bool(meta_row[2])
|
|
if percent_custom and percent_value is not None:
|
|
percent = float(percent_value)
|
|
response = {
|
|
"tg_id": tg_id,
|
|
"partner_balance": float(meta_row[0] or 0) if meta_row else 0.0,
|
|
"partner_percent": percent,
|
|
"partner_code": meta_row[3] if meta_row else None,
|
|
"payout_method": meta_row[4] if meta_row else None,
|
|
"invited": [
|
|
{
|
|
"tg_id": row[0],
|
|
"joined_at": row[1].isoformat() if isinstance(row[1], datetime) else None,
|
|
"balance": float(row[2] or 0),
|
|
"subs_count": int(row[3] or 0),
|
|
"payments_count": int(row[4] or 0),
|
|
}
|
|
for row in invited_rows
|
|
],
|
|
}
|
|
return JSONResponse(content=response)
|
|
|
|
|
|
@router.post("/{tg_id}/invited")
|
|
async def add_partner_invited(
|
|
tg_id: int = Path(..., description="Telegram ID партнёра"),
|
|
joined_tg_id: int = Query(..., description="Telegram ID приглашённого"),
|
|
identity=Depends(verify_identity_admin),
|
|
session: AsyncSession = Depends(get_session),
|
|
):
|
|
"""Добавляет приглашённого пользователя партнёру."""
|
|
if joined_tg_id == tg_id:
|
|
return JSONResponse(
|
|
content={"success": False, "message": "Нельзя привязать пользователя к самому себе"}, status_code=400
|
|
)
|
|
try:
|
|
partner_exists = await session.execute(text("SELECT 1 FROM users WHERE tg_id = :tg_id"), {"tg_id": tg_id})
|
|
if not partner_exists.scalar():
|
|
return JSONResponse(content={"success": False, "message": "Партнёр не найден"}, status_code=404)
|
|
invited_exists = await session.execute(
|
|
text("SELECT 1 FROM users WHERE tg_id = :joined_tg_id"), {"joined_tg_id": joined_tg_id}
|
|
)
|
|
if not invited_exists.scalar():
|
|
return JSONResponse(
|
|
content={"success": False, "message": "Приглашённый пользователь не найден"}, status_code=404
|
|
)
|
|
existing = await session.execute(
|
|
text("SELECT partner_tg_id FROM partners WHERE joined_tg_id = :joined_tg_id"),
|
|
{"joined_tg_id": joined_tg_id},
|
|
)
|
|
existing_partner = existing.scalar()
|
|
if existing_partner is not None:
|
|
return JSONResponse(
|
|
content={"success": False, "message": f"Пользователь уже привязан к партнёру {existing_partner}"},
|
|
status_code=409,
|
|
)
|
|
await session.execute(
|
|
text("INSERT INTO partners (partner_tg_id, joined_tg_id) VALUES (:partner_tg_id, :joined_tg_id)"),
|
|
{"partner_tg_id": tg_id, "joined_tg_id": joined_tg_id},
|
|
)
|
|
await session.commit()
|
|
return JSONResponse(
|
|
content={
|
|
"success": True,
|
|
"message": "Приглашённый добавлен",
|
|
"partner_tg_id": tg_id,
|
|
"joined_tg_id": joined_tg_id,
|
|
},
|
|
status_code=201,
|
|
)
|
|
except Exception as e:
|
|
await session.rollback()
|
|
return JSONResponse(content={"success": False, "message": str(e)}, status_code=500)
|
|
|
|
|
|
@router.delete("/{tg_id}/invited/{joined_tg_id}")
|
|
async def delete_partner_invited(
|
|
tg_id: int = Path(..., description="Telegram ID партнёра"),
|
|
joined_tg_id: int = Path(..., description="Telegram ID приглашённого"),
|
|
identity=Depends(verify_identity_admin),
|
|
session: AsyncSession = Depends(get_session),
|
|
):
|
|
"""Удаляет приглашённого у партнёра."""
|
|
try:
|
|
result = await session.execute(
|
|
text("DELETE FROM partners WHERE partner_tg_id = :partner_tg_id AND joined_tg_id = :joined_tg_id"),
|
|
{"partner_tg_id": tg_id, "joined_tg_id": joined_tg_id},
|
|
)
|
|
await session.commit()
|
|
if result.rowcount > 0:
|
|
return JSONResponse(
|
|
content={
|
|
"success": True,
|
|
"message": "Приглашённый удалён",
|
|
"partner_tg_id": tg_id,
|
|
"joined_tg_id": joined_tg_id,
|
|
},
|
|
status_code=200,
|
|
)
|
|
return JSONResponse(
|
|
content={"success": False, "message": "Связка партнёр-приглашённый не найдена"}, status_code=404
|
|
)
|
|
except Exception as e:
|
|
await session.rollback()
|
|
return JSONResponse(content={"success": False, "message": str(e)}, status_code=500)
|
|
|
|
|
|
@router.patch("/{tg_id}/percent")
|
|
async def update_partner_percent(
|
|
tg_id: int = Path(..., description="Telegram ID партнёра"),
|
|
percent: float = Query(..., description="Новый персональный процент (0-100 или 0.0-1.0)"),
|
|
identity=Depends(verify_identity_admin),
|
|
session: AsyncSession = Depends(get_session),
|
|
):
|
|
"""Обновляет персональный процент партнёра."""
|
|
normalized = _parse_percent(percent)
|
|
if normalized is None:
|
|
return JSONResponse(
|
|
content={"success": False, "message": "Неверный процент. Допустимо 0-100 или 0.0-1.0"}, status_code=400
|
|
)
|
|
try:
|
|
result = await session.execute(
|
|
text("UPDATE users SET partner_percent = :percent, partner_percent_custom = true WHERE tg_id = :tg_id"),
|
|
{"tg_id": tg_id, "percent": normalized},
|
|
)
|
|
await session.commit()
|
|
if result.rowcount > 0:
|
|
return JSONResponse(
|
|
content={"success": True, "message": "Процент обновлён", "percent": normalized}, status_code=200
|
|
)
|
|
return JSONResponse(content={"success": False, "message": "Партнёр не найден"}, status_code=404)
|
|
except Exception as e:
|
|
await session.rollback()
|
|
return JSONResponse(content={"success": False, "message": str(e)}, status_code=500)
|
|
|
|
|
|
@router.patch("/{tg_id}/balance")
|
|
async def update_partner_balance(
|
|
tg_id: int = Path(..., description="Telegram ID партнёра"),
|
|
amount: float = Query(..., description="Сумма операции"),
|
|
mode: str = Query("set", description="Режим: set, add, subtract"),
|
|
identity=Depends(verify_identity_admin),
|
|
session: AsyncSession = Depends(get_session),
|
|
):
|
|
"""Изменяет баланс партнёрской программы."""
|
|
mode_normalized = (mode or "set").strip().lower()
|
|
if mode_normalized not in {"set", "add", "subtract"}:
|
|
return JSONResponse(
|
|
content={"success": False, "message": "Неверный режим. Используйте set, add или subtract"}, status_code=400
|
|
)
|
|
try:
|
|
amount_val = float(amount)
|
|
except (TypeError, ValueError):
|
|
return JSONResponse(content={"success": False, "message": "Неверная сумма"}, status_code=400)
|
|
if amount_val < 0:
|
|
return JSONResponse(content={"success": False, "message": "Сумма не может быть отрицательной"}, status_code=400)
|
|
try:
|
|
current_res = await session.execute(
|
|
text("SELECT partner_balance FROM users WHERE tg_id = :tg_id"), {"tg_id": tg_id}
|
|
)
|
|
current_balance = current_res.scalar()
|
|
if current_balance is None:
|
|
return JSONResponse(content={"success": False, "message": "Партнёр не найден"}, status_code=404)
|
|
current_balance = float(current_balance or 0.0)
|
|
if mode_normalized == "set":
|
|
new_balance = amount_val
|
|
elif mode_normalized == "add":
|
|
new_balance = current_balance + amount_val
|
|
else:
|
|
if current_balance < amount_val:
|
|
return JSONResponse(content={"success": False, "message": "Недостаточно средств"}, status_code=400)
|
|
new_balance = current_balance - amount_val
|
|
await session.execute(
|
|
text("UPDATE users SET partner_balance = :balance WHERE tg_id = :tg_id"),
|
|
{"tg_id": tg_id, "balance": new_balance},
|
|
)
|
|
await session.commit()
|
|
return JSONResponse(
|
|
content={"success": True, "message": "Баланс обновлён", "balance": new_balance}, status_code=200
|
|
)
|
|
except Exception as e:
|
|
await session.rollback()
|
|
return JSONResponse(content={"success": False, "message": str(e)}, status_code=500)
|
|
|
|
|
|
@router.get("/{tg_id}/invited")
|
|
async def get_partner_invited(
|
|
tg_id: int = Path(..., description="Telegram ID партнёра"),
|
|
identity=Depends(verify_identity_admin),
|
|
session: AsyncSession = Depends(get_session),
|
|
):
|
|
"""Список приглашённых партнёра."""
|
|
invited_sql = text(
|
|
"""
|
|
SELECT pr.joined_tg_id, pr.created_at, COALESCE(u.balance, 0),
|
|
(SELECT COUNT(*) FROM keys k WHERE k.tg_id = pr.joined_tg_id),
|
|
(SELECT COUNT(*) FROM payments pay WHERE pay.tg_id = pr.joined_tg_id AND lower(pay.status) = 'success')
|
|
FROM partners pr
|
|
LEFT JOIN users u ON u.tg_id = pr.joined_tg_id
|
|
WHERE pr.partner_tg_id = :tg_id
|
|
ORDER BY pr.created_at DESC
|
|
"""
|
|
)
|
|
invited_res = await session.execute(invited_sql, {"tg_id": tg_id})
|
|
invited_rows = invited_res.fetchall()
|
|
invited_list = [
|
|
{
|
|
"tg_id": row[0],
|
|
"joined_at": row[1].isoformat() if isinstance(row[1], datetime) else None,
|
|
"balance": float(row[2] or 0),
|
|
"subs_count": int(row[3] or 0),
|
|
"payments_count": int(row[4] or 0),
|
|
}
|
|
for row in invited_rows
|
|
]
|
|
return JSONResponse(content=invited_list)
|
|
|
|
|
|
@router.get("/payouts/pending")
|
|
async def get_partner_payouts_pending(
|
|
limit: int = Query(50, ge=1, le=200),
|
|
offset: int = Query(0, ge=0),
|
|
partner_tg_id: int | None = Query(None),
|
|
identity=Depends(verify_identity_admin),
|
|
session: AsyncSession = Depends(get_session),
|
|
):
|
|
"""Ожидающие заявки на вывод."""
|
|
where_clause = "WHERE pr.status = 'pending'"
|
|
params = {"limit": limit, "offset": offset}
|
|
if partner_tg_id is not None:
|
|
where_clause += " AND pr.tg_id = :partner_tg_id"
|
|
params["partner_tg_id"] = partner_tg_id
|
|
count_sql = text(f"SELECT COUNT(*) FROM payout_requests pr {where_clause}")
|
|
rows_sql = text(
|
|
f"""
|
|
SELECT pr.id, pr.tg_id, pr.amount, pr.status, pr.created_at,
|
|
COALESCE(pr.method, u.payout_method) AS method, COALESCE(pr.destination, u.card_number) AS destination
|
|
FROM payout_requests pr
|
|
LEFT JOIN users u ON u.tg_id = pr.tg_id
|
|
{where_clause}
|
|
ORDER BY pr.created_at ASC, pr.id ASC
|
|
LIMIT :limit OFFSET :offset
|
|
"""
|
|
)
|
|
total = await session.scalar(count_sql) or 0
|
|
result = await session.execute(rows_sql, params)
|
|
items = [
|
|
{
|
|
"id": int(row[0]),
|
|
"tg_id": int(row[1]),
|
|
"amount": float(row[2] or 0.0),
|
|
"status": row[3] or "pending",
|
|
"created_at": _row_dt_iso(row[4]),
|
|
"method": row[5] or None,
|
|
"destination": row[6] or None,
|
|
}
|
|
for row in result.fetchall()
|
|
]
|
|
return JSONResponse(content={"total": int(total), "items": items})
|
|
|
|
|
|
@router.get("/payouts/history")
|
|
async def get_partner_payouts_history(
|
|
limit: int = Query(50, ge=1, le=200),
|
|
offset: int = Query(0, ge=0),
|
|
partner_tg_id: int | None = Query(None),
|
|
identity=Depends(verify_identity_admin),
|
|
session: AsyncSession = Depends(get_session),
|
|
):
|
|
"""История выплат (approved/rejected)."""
|
|
where_clause = "WHERE pr.status IN ('approved','rejected')"
|
|
params = {"limit": limit, "offset": offset}
|
|
if partner_tg_id is not None:
|
|
where_clause += " AND pr.tg_id = :partner_tg_id"
|
|
params["partner_tg_id"] = partner_tg_id
|
|
count_sql = text(f"SELECT COUNT(*) FROM payout_requests pr {where_clause}")
|
|
rows_sql = text(
|
|
f"""
|
|
SELECT pr.id, pr.tg_id, pr.amount, pr.status, pr.created_at,
|
|
COALESCE(pr.method, u.payout_method) AS method, COALESCE(pr.destination, u.card_number) AS destination
|
|
FROM payout_requests pr
|
|
LEFT JOIN users u ON u.tg_id = pr.tg_id
|
|
{where_clause}
|
|
ORDER BY pr.created_at DESC, pr.id DESC
|
|
LIMIT :limit OFFSET :offset
|
|
"""
|
|
)
|
|
total = await session.scalar(count_sql) or 0
|
|
result = await session.execute(rows_sql, params)
|
|
items = [
|
|
{
|
|
"id": int(row[0]),
|
|
"tg_id": int(row[1]),
|
|
"amount": float(row[2] or 0.0),
|
|
"status": row[3] or "—",
|
|
"created_at": _row_dt_iso(row[4]),
|
|
"method": row[5] or None,
|
|
"destination": row[6] or None,
|
|
}
|
|
for row in result.fetchall()
|
|
]
|
|
return JSONResponse(content={"total": int(total), "items": items})
|
|
|
|
|
|
@router.post("/payouts/{payout_id}/approve")
|
|
async def approve_partner_payout(
|
|
payout_id: int = Path(..., description="ID заявки"),
|
|
identity=Depends(verify_identity_admin),
|
|
session: AsyncSession = Depends(get_session),
|
|
):
|
|
"""Одобряет заявку на вывод."""
|
|
req_row = await session.execute(
|
|
text("SELECT id, tg_id, amount FROM payout_requests WHERE id = :id AND status = 'pending'"),
|
|
{"id": payout_id},
|
|
)
|
|
req = req_row.fetchone()
|
|
if not req:
|
|
return JSONResponse(
|
|
content={"success": False, "message": "Заявка не найдена или уже обработана"}, status_code=404
|
|
)
|
|
user_row = await session.execute(
|
|
text("SELECT payout_method, card_number FROM users WHERE tg_id = :tg_id"), {"tg_id": req[1]}
|
|
)
|
|
user = user_row.fetchone()
|
|
payout_method = (user[0] if user else None) or "card"
|
|
destination = (user[1] if user else None) or None
|
|
destination = (destination or "").strip() or None
|
|
await session.execute(
|
|
text(
|
|
"UPDATE payout_requests SET status = 'approved', method = :method, destination = :destination WHERE id = :id"
|
|
),
|
|
{"id": payout_id, "method": payout_method, "destination": destination},
|
|
)
|
|
await session.commit()
|
|
return JSONResponse(content={"success": True, "message": "Заявка одобрена"}, status_code=200)
|
|
|
|
|
|
@router.post("/payouts/{payout_id}/reject")
|
|
async def reject_partner_payout(
|
|
payout_id: int = Path(..., description="ID заявки"),
|
|
identity=Depends(verify_identity_admin),
|
|
session: AsyncSession = Depends(get_session),
|
|
):
|
|
"""Отклоняет заявку на вывод и возвращает сумму на баланс."""
|
|
req_row = await session.execute(
|
|
text("SELECT id, tg_id, amount FROM payout_requests WHERE id = :id AND status = 'pending'"),
|
|
{"id": payout_id},
|
|
)
|
|
req = req_row.fetchone()
|
|
if not req:
|
|
return JSONResponse(
|
|
content={"success": False, "message": "Заявка не найдена или уже обработана"}, status_code=404
|
|
)
|
|
user_row = await session.execute(
|
|
text("SELECT payout_method, card_number, partner_balance FROM users WHERE tg_id = :tg_id"), {"tg_id": req[1]}
|
|
)
|
|
user = user_row.fetchone()
|
|
payout_method = (user[0] if user else None) or "card"
|
|
destination = (user[1] if user else None) or None
|
|
destination = (destination or "").strip() or None
|
|
await session.execute(
|
|
text(
|
|
"UPDATE payout_requests SET status = 'rejected', method = :method, destination = :destination WHERE id = :id"
|
|
),
|
|
{"id": payout_id, "method": payout_method, "destination": destination},
|
|
)
|
|
if user is not None:
|
|
current_balance = float(user[2] or 0.0)
|
|
await session.execute(
|
|
text("UPDATE users SET partner_balance = :balance WHERE tg_id = :tg_id"),
|
|
{"balance": current_balance + float(req[2] or 0.0), "tg_id": req[1]},
|
|
)
|
|
await session.commit()
|
|
return JSONResponse(content={"success": True, "message": "Заявка отклонена"}, status_code=200)
|
|
|
|
|
|
@router.patch("/{tg_id}/percent/reset")
|
|
async def reset_partner_percent(
|
|
tg_id: int = Path(..., description="Telegram ID партнёра"),
|
|
identity=Depends(verify_identity_admin),
|
|
session: AsyncSession = Depends(get_session),
|
|
):
|
|
"""Сбрасывает персональный процент партнёра к дефолту."""
|
|
result = await session.execute(
|
|
text("UPDATE users SET partner_percent = NULL, partner_percent_custom = false WHERE tg_id = :tg_id"),
|
|
{"tg_id": tg_id},
|
|
)
|
|
await session.commit()
|
|
if result.rowcount > 0:
|
|
return JSONResponse(content={"success": True, "message": "Процент сброшен"}, status_code=200)
|
|
return JSONResponse(content={"success": False, "message": "Партнёр не найден"}, status_code=404)
|
|
|
|
|
|
@router.patch("/{tg_id}/code")
|
|
async def update_partner_code(
|
|
tg_id: int = Path(..., description="Telegram ID партнёра"),
|
|
code: str = Query(..., description="Новый код партнёра (латиница/цифры/_)"),
|
|
identity=Depends(verify_identity_admin),
|
|
session: AsyncSession = Depends(get_session),
|
|
):
|
|
"""Обновляет код партнёрской ссылки."""
|
|
raw = (code or "").strip().lower()
|
|
if not raw:
|
|
return JSONResponse(content={"success": False, "message": "Код не может быть пустым"}, status_code=400)
|
|
if not re.fullmatch(r"[a-z0-9_]{3,32}", raw):
|
|
return JSONResponse(
|
|
content={"success": False, "message": "Неверный код. Разрешены a-z, 0-9, _ (3-32 символа)"}, status_code=400
|
|
)
|
|
exists = await session.execute(
|
|
text("SELECT 1 FROM users WHERE partner_code = :code AND tg_id != :tg_id"), {"code": raw, "tg_id": tg_id}
|
|
)
|
|
if exists.first():
|
|
return JSONResponse(content={"success": False, "message": "Такой код уже занят"}, status_code=409)
|
|
result = await session.execute(
|
|
text("UPDATE users SET partner_code = :code WHERE tg_id = :tg_id"), {"code": raw, "tg_id": tg_id}
|
|
)
|
|
await session.commit()
|
|
if result.rowcount > 0:
|
|
return JSONResponse(content={"success": True, "message": "Код обновлён", "code": raw}, status_code=200)
|
|
return JSONResponse(content={"success": False, "message": "Партнёр не найден"}, status_code=404)
|
|
|
|
|
|
@router.post("/reset-disabled-methods")
|
|
async def reset_disabled_payout_methods(
|
|
identity=Depends(verify_identity_admin),
|
|
session: AsyncSession = Depends(get_session),
|
|
):
|
|
"""Сбрасывает реквизиты для отключённых способов вывода."""
|
|
try:
|
|
from modules.partner_program.settings import (
|
|
ENABLE_PAYOUT_CARD,
|
|
ENABLE_PAYOUT_SBP,
|
|
ENABLE_PAYOUT_TON,
|
|
ENABLE_PAYOUT_USDT,
|
|
)
|
|
from modules.partner_program import buttons as B
|
|
except Exception:
|
|
ENABLE_PAYOUT_CARD = True
|
|
ENABLE_PAYOUT_USDT = True
|
|
ENABLE_PAYOUT_TON = True
|
|
ENABLE_PAYOUT_SBP = True
|
|
B = None
|
|
disabled = []
|
|
if not ENABLE_PAYOUT_CARD and B:
|
|
disabled.append(B.METHOD_CARD)
|
|
if not ENABLE_PAYOUT_USDT and B:
|
|
disabled.append(B.METHOD_USDT)
|
|
if not ENABLE_PAYOUT_TON and B:
|
|
disabled.append(B.METHOD_TON)
|
|
if not ENABLE_PAYOUT_SBP and B:
|
|
disabled.append(B.METHOD_SBP)
|
|
if not disabled:
|
|
return JSONResponse(content={"success": True, "message": "Отключённых методов нет"}, status_code=200)
|
|
await session.execute(
|
|
text("UPDATE users SET card_number = NULL WHERE payout_method = ANY(:methods)"), {"methods": disabled}
|
|
)
|
|
await session.commit()
|
|
return JSONResponse(content={"success": True, "message": "Отключённые методы сброшены"}, status_code=200)
|
|
|
|
|
|
@router.get("/{tg_id}/export")
|
|
async def export_partner_invites_csv(
|
|
tg_id: int = Path(..., description="Telegram ID партнёра"),
|
|
identity=Depends(verify_identity_admin),
|
|
session: AsyncSession = Depends(get_session),
|
|
):
|
|
"""Экспорт приглашённых партнёром в CSV."""
|
|
rows = await session.execute(
|
|
text("SELECT joined_tg_id, created_at FROM partners WHERE partner_tg_id = :tg_id ORDER BY created_at ASC"),
|
|
{"tg_id": tg_id},
|
|
)
|
|
data = rows.fetchall()
|
|
if not data:
|
|
return JSONResponse(content={"success": False, "message": "Нет приглашённых"}, status_code=404)
|
|
buffer = StringIO()
|
|
writer = csv.writer(buffer, delimiter=";")
|
|
writer.writerow(["joined_tg_id", "created_at"])
|
|
for joined_tg_id, created_at in data:
|
|
writer.writerow([int(joined_tg_id), created_at.isoformat() if created_at else ""])
|
|
content = buffer.getvalue().encode("utf-8-sig")
|
|
filename = f"partner_invites_{tg_id}.csv"
|
|
return StreamingResponse(
|
|
iter([content]), media_type="text/csv", headers={"Content-Disposition": f"attachment; filename={filename}"}
|
|
)
|