Backend: - POST /auth/device — анонимный вход по device_id (UUID) - GET /auth/me — текущий юзер - DELETE /me — удаление аккаунта (Apple требует) БД: - users.source TEXT DEFAULT 'telegram' - users.device_id UUID UNIQUE - users.apple_id TEXT UNIQUE - app_user_id_seq (START -1 INCREMENT -1) - auth_identities (provider, provider_uid, user_id) Auth: - JWT через PyJWT, APP_JWT_SECRET из .env - Authorization: Bearer <token> в require_auth - Rate limit /auth/device (5/60) Отрицательные telegram_id для Pleily-юзеров.
245 lines
8.9 KiB
Python
245 lines
8.9 KiB
Python
"""
|
|
App Auth Router — авторизация мобильного приложения Pleily.
|
|
|
|
Поддерживает:
|
|
- Анонимный вход по device_id (UUID) → выдаёт JWT на 365 дней.
|
|
- Привязка Apple ID (позже).
|
|
- Удаление аккаунта (требование Apple App Store).
|
|
|
|
Pleily-юзеры имеют ОТРИЦАТЕЛЬНЫЙ telegram_id (из sequence app_user_id_seq).
|
|
Telegram-юзеры сохраняют свои положительные telegram_id.
|
|
|
|
Все Pleily-юзеры изолированы в auth_identities: связка (provider, provider_uid)
|
|
указывает на users.telegram_id. Так один юзер может иметь несколько способов входа.
|
|
|
|
Эндпоинты:
|
|
- POST /auth/device — вход по device_id
|
|
- GET /auth/me — текущий юзер (для тестов)
|
|
- DELETE /me — удаление аккаунта (Apple требует)
|
|
|
|
🔧 НОВОЕ (07.10.2026): pleily_auth — первая версия.
|
|
"""
|
|
import logging
|
|
import uuid
|
|
from datetime import datetime, timezone, timedelta
|
|
from typing import Optional
|
|
|
|
import asyncpg
|
|
import jwt
|
|
from fastapi import APIRouter, Request, HTTPException, Depends
|
|
|
|
from auth import require_auth
|
|
from database import get_pool
|
|
from config import APP_JWT_SECRET
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
router = APIRouter(prefix="/auth", tags=["app-auth"])
|
|
|
|
# JWT настройки
|
|
JWT_ALGORITHM = "HS256"
|
|
JWT_TTL_DAYS = 365
|
|
JWT_TTL = timedelta(days=JWT_TTL_DAYS)
|
|
|
|
|
|
# ============ JWT HELPERS ============
|
|
|
|
def make_app_jwt(user_id: int) -> str:
|
|
"""Создаёт JWT для Pleily-юзера. Payload: {user_id, exp, iat}."""
|
|
if not APP_JWT_SECRET:
|
|
raise RuntimeError("APP_JWT_SECRET not configured")
|
|
|
|
now = datetime.now(timezone.utc)
|
|
payload = {
|
|
"user_id": int(user_id),
|
|
"iat": int(now.timestamp()),
|
|
"exp": int((now + JWT_TTL).timestamp()),
|
|
}
|
|
return jwt.encode(payload, APP_JWT_SECRET, algorithm=JWT_ALGORITHM)
|
|
|
|
|
|
def verify_app_jwt(token: str) -> dict:
|
|
"""Проверяет JWT, возвращает payload. Бросает ValueError если невалиден."""
|
|
if not APP_JWT_SECRET:
|
|
raise ValueError("APP_JWT_SECRET not configured")
|
|
|
|
try:
|
|
payload = jwt.decode(token, APP_JWT_SECRET, algorithms=[JWT_ALGORITHM])
|
|
except jwt.ExpiredSignatureError:
|
|
raise ValueError("Token expired")
|
|
except jwt.InvalidTokenError as e:
|
|
raise ValueError(f"Invalid token: {e}")
|
|
|
|
if "user_id" not in payload:
|
|
raise ValueError("user_id missing in token payload")
|
|
|
|
return payload
|
|
|
|
|
|
# ============ ВСПОМОГАТЕЛЬНЫЕ ============
|
|
|
|
async def _find_user_by_device(conn, device_id: str) -> Optional[int]:
|
|
"""Ищет user_id по (provider='device', provider_uid=device_id)."""
|
|
row = await conn.fetchrow("""
|
|
SELECT user_id FROM auth_identities
|
|
WHERE provider = 'device' AND provider_uid = $1
|
|
""", device_id)
|
|
return row["user_id"] if row else None
|
|
|
|
|
|
async def _create_app_user(conn, device_id: str) -> int:
|
|
"""
|
|
Создаёт нового Pleily-юзера с отрицательным telegram_id
|
|
(из sequence app_user_id_seq) и связкой auth_identities.
|
|
Возвращает telegram_id (отрицательный).
|
|
"""
|
|
# nextval из sequence app_user_id_seq даёт -1, -2, -3, ...
|
|
uid_row = await conn.fetchrow("SELECT nextval('app_user_id_seq') AS uid")
|
|
uid = uid_row["uid"]
|
|
|
|
# Создаём юзера в users
|
|
await conn.execute("""
|
|
INSERT INTO users (telegram_id, username, source)
|
|
VALUES ($1, $2, 'app')
|
|
""", uid, f"app_user_{abs(uid)}")
|
|
|
|
# Создаём identity
|
|
await conn.execute("""
|
|
INSERT INTO auth_identities (user_id, provider, provider_uid)
|
|
VALUES ($1, 'device', $2)
|
|
""", uid, device_id)
|
|
|
|
logger.info(f"[app_auth] created Pleily user: telegram_id={uid}, device={device_id}")
|
|
return uid
|
|
|
|
|
|
# ============ ЭНДПОИНТЫ ============
|
|
|
|
@router.post("/device")
|
|
async def auth_device(request: Request):
|
|
"""
|
|
Вход по device_id.
|
|
Body: {"device_id": "uuid-string"}
|
|
|
|
Если юзер с таким device_id уже есть — выдаёт новый JWT.
|
|
Если нет — создаёт нового Pleily-юзера и выдаёт JWT.
|
|
|
|
Returns: {"status": "ok", "token": "...", "user_id": -1}
|
|
"""
|
|
body = await request.json()
|
|
device_id_raw = (body.get("device_id") or "").strip()
|
|
|
|
if not device_id_raw:
|
|
raise HTTPException(400, "device_id is required")
|
|
|
|
# Валидация UUID
|
|
try:
|
|
device_uuid = uuid.UUID(device_id_raw)
|
|
except (ValueError, AttributeError, TypeError):
|
|
raise HTTPException(400, "device_id must be a valid UUID")
|
|
|
|
device_id_str = str(device_uuid)
|
|
|
|
pool = await get_pool()
|
|
async with pool.acquire() as conn:
|
|
# Пытаемся найти существующего юзера
|
|
user_id = await _find_user_by_device(conn, device_id_str)
|
|
|
|
if user_id is None:
|
|
# Создаём нового — в транзакции, чтобы nextval + INSERT были атомарны
|
|
try:
|
|
async with conn.transaction():
|
|
user_id = await _create_app_user(conn, device_id_str)
|
|
except asyncpg.UniqueViolationError:
|
|
# 🔧 Гонка: два параллельных запроса с одним device_id.
|
|
# Один вставил, второй словил UniqueViolation на (provider, provider_uid).
|
|
# Просто перечитываем — юзер уже есть.
|
|
logger.warning(
|
|
f"[app_auth] race on device_id={device_id_str}, retrying SELECT"
|
|
)
|
|
user_id = await _find_user_by_device(conn, device_id_str)
|
|
if user_id is None:
|
|
raise HTTPException(500, "Failed to create or find user")
|
|
|
|
token = make_app_jwt(user_id)
|
|
logger.info(f"[app_auth] login device={device_id_str} → user_id={user_id}")
|
|
|
|
return {
|
|
"status": "ok",
|
|
"token": token,
|
|
"user_id": user_id,
|
|
}
|
|
|
|
|
|
@router.get("/me")
|
|
async def auth_me(request: Request):
|
|
"""
|
|
Возвращает данные текущего Pleily-юзера. Для тестов и отладки.
|
|
|
|
Требует Authorization: Bearer <JWT>.
|
|
"""
|
|
user_id, _username = await require_auth(request)
|
|
|
|
pool = await get_pool()
|
|
async with pool.acquire() as conn:
|
|
row = await conn.fetchrow("""
|
|
SELECT telegram_id, username, source, app_language, current_level, created_at
|
|
FROM users WHERE telegram_id = $1
|
|
""", user_id)
|
|
|
|
if not row:
|
|
raise HTTPException(404, "User not found")
|
|
|
|
# Получаем identities юзера (для диагностики)
|
|
identities_rows = await conn.fetch("""
|
|
SELECT provider, provider_uid, created_at
|
|
FROM auth_identities WHERE user_id = $1
|
|
ORDER BY created_at
|
|
""", user_id)
|
|
|
|
return {
|
|
"user_id": row["telegram_id"],
|
|
"username": row["username"],
|
|
"source": row["source"],
|
|
"app_language": row["app_language"],
|
|
"current_level": row["current_level"],
|
|
"created_at": row["created_at"].isoformat() if row["created_at"] else None,
|
|
"identities": [
|
|
{
|
|
"provider": r["provider"],
|
|
"provider_uid": r["provider_uid"],
|
|
"created_at": r["created_at"].isoformat() if r["created_at"] else None,
|
|
}
|
|
for r in identities_rows
|
|
],
|
|
}
|
|
|
|
|
|
@router.delete("/me")
|
|
async def auth_delete_me(request: Request):
|
|
"""
|
|
Удаление аккаунта Pleily-юзера.
|
|
Требуется Apple App Store (право на удаление внутри приложения).
|
|
|
|
Требует Authorization: Bearer <JWT>.
|
|
Удаляем users по telegram_id — FK CASCADE подчистит все связанные
|
|
таблицы (auth_identities, learning_sessions, user_learning_answers и т.д.).
|
|
"""
|
|
user_id, _username = await require_auth(request)
|
|
|
|
pool = await get_pool()
|
|
async with pool.acquire() as conn:
|
|
# Проверяем существование
|
|
exists = await conn.fetchval(
|
|
"SELECT 1 FROM users WHERE telegram_id = $1", user_id
|
|
)
|
|
if not exists:
|
|
raise HTTPException(404, "User not found")
|
|
|
|
# Удаляем юзера — каскад подчистит auth_identities и остальное
|
|
await conn.execute(
|
|
"DELETE FROM users WHERE telegram_id = $1", user_id
|
|
)
|
|
|
|
logger.info(f"[app_auth] deleted Pleily user: telegram_id={user_id}")
|
|
return {"status": "ok", "user_id": user_id} |