initial commit (backend)

routers/feed.py

@@ -0,0 +1,725 @@
+"""
+Feed Router — посты для карусели (новости / партнёры / контакты / приложения).
+
+Публичные эндпоинты:
+- GET  /feed/{section}?lang={lang}   — лента постов с локализацией
+- GET  /feed/post/{id}?lang={lang}   — один пост
+
+Админские эндпоинты:
+- POST   /admin/feed/post               — создать пост + автоперевод на 4 языка
+- PUT    /admin/feed/post/{id}          — редактировать (опционально перевести заново)
+- POST   /admin/feed/post/{id}/delete   — удалить (вложения удалит CASCADE)
+- POST   /admin/feed/upload-image       — загрузить картинку (multipart, до 3 на пост)
+- POST   /admin/feed/translate          — перевести title+body вручную (без сохранения)
+
+Логика локализации:
+- В БД хранятся 4 версии поста (title_pl/ru/uk/en, body_pl/ru/uk/en).
+- Юзер получает только свою версию.
+- Fallback: _{lang} → _en → _pl.
+"""
+import logging
+import json
+import re
+import uuid
+import os
+from pathlib import Path
+from typing import Optional, Any
+
+import httpx
+from fastapi import APIRouter, Request, HTTPException, UploadFile, File, Form
+from auth import require_auth
+from database import get_pool
+from config import (
+    TOGETHER_API_KEY,
+    ADMIN_IDS,
+    FEED_SECTIONS,
+    FEED_TARGET_LANGUAGES,
+    MAX_FEED_ATTACHMENTS,
+    MAX_FEED_IMAGE_SIZE_BYTES,
+    FEED_ALLOWED_IMAGE_TYPES,
+    UPLOADS_DIR,
+)
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(tags=["feed"])
+
+TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
+TRANSLATE_MODEL = "MiniMaxAI/MiniMax-M3"
+
+# 🔧 ФИКС: бэк отдаёт полный URL картинки, чтобы фронт не гадал,
+# куда склеивать относительный путь /uploads/feed/...
+API_PUBLIC_URL = "https://api.filwordspl.com"
+
+
+# ============ HELPERS ============
+
+def _require_admin(telegram_id: int) -> None:
+    """Проверка, что пользователь — админ. Бросает 403 если нет."""
+    if telegram_id not in ADMIN_IDS:
+        raise HTTPException(403, "Access denied")
+
+
+def _localized_field(row: dict, field: str, lang: str) -> str:
+    """
+    Достаёт локализованное поле из строки БД.
+    Fallback: _{lang} → _en → _pl → ''.
+    """
+    if not row:
+        return ""
+    return (
+        row.get(f"{field}_{lang}")
+        or row.get(f"{field}_en")
+        or row.get(f"{field}_pl")
+        or ""
+    )
+
+
+def _serialize_post(row: dict, attachments: list, lang: str) -> dict:
+    """
+    Собирает финальный объект поста для фронта:
+    локализованный title/body, ссылки, метаданные, картинки.
+    """
+    return {
+        "id": row["id"],
+        "section": row["section"],
+        "title": _localized_field(row, "title", lang),
+        "body": _localized_field(row, "body", lang),
+        "images": [
+            f"{API_PUBLIC_URL}{a['file_path']}" if a["file_path"].startswith("/") else a["file_path"]
+            for a in attachments
+        ],
+        "linkUrl": row.get("link_url"),
+        "telegramUrl": row.get("telegram_url"),
+        "createdAt": row["created_at"].isoformat() if row.get("created_at") else None,
+        "updatedAt": row["updated_at"].isoformat() if row.get("updated_at") else None,
+        "expiresAt": row["expires_at"].isoformat() if row.get("expires_at") else None,
+        "isPinned": bool(row.get("is_pinned")),
+    }
+
+
+# ============ ПУБЛИЧНЫЕ ЭНДПОИНТЫ ============
+
+@router.get("/feed/{section}")
+async def get_feed_section(request: Request, section: str, lang: Optional[str] = None):
+    """
+    Возвращает ленту постов для секции (news / partners / contacts / apps).
+
+    - Закреплённые посты — сверху.
+    - Остальные — по created_at DESC.
+    - Истёкшие (expires_at < NOW()) — НЕ отдаём.
+    - Опубликованные (is_published = TRUE) — только они.
+    """
+    telegram_id, _ = await require_auth(request)
+
+    if section not in FEED_SECTIONS:
+        raise HTTPException(400, f"Invalid section: {section}")
+
+    pool = await get_pool()
+    async with pool.acquire() as conn:
+        # Если lang не передан — берём из профиля юзера
+        if not lang or lang not in FEED_TARGET_LANGUAGES:
+            lang = await conn.fetchval(
+                "SELECT app_language FROM users WHERE telegram_id = $1",
+                telegram_id,
+            ) or "pl"
+            if lang not in FEED_TARGET_LANGUAGES:
+                lang = "pl"
+
+        # Тянем посты: закреплённые сверху, потом по дате
+        rows = await conn.fetch("""
+            SELECT *
+            FROM feed_posts
+            WHERE section = $1
+              AND is_published = TRUE
+              AND (expires_at IS NULL OR expires_at > NOW())
+            ORDER BY is_pinned DESC, created_at DESC
+        """, section)
+
+        if not rows:
+            return {"posts": [], "section": section, "lang": lang}
+
+        # Одним запросом тянем все вложения для всех постов (без N+1)
+        post_ids = [r["id"] for r in rows]
+        att_rows = await conn.fetch("""
+            SELECT post_id, file_path, order_number
+            FROM feed_attachments
+            WHERE post_id = ANY($1::bigint[])
+            ORDER BY post_id, order_number ASC
+        """, post_ids)
+
+        # Группируем вложения по post_id
+        att_by_post: dict[int, list] = {}
+        for a in att_rows:
+            att_by_post.setdefault(a["post_id"], []).append(dict(a))
+
+        posts = [
+            _serialize_post(dict(r), att_by_post.get(r["id"], []), lang)
+            for r in rows
+        ]
+
+        return {"posts": posts, "section": section, "lang": lang}
+
+
+@router.get("/feed/post/{post_id}")
+async def get_feed_post(request: Request, post_id: int, lang: Optional[str] = None):
+    """Возвращает один пост по ID (с локализацией)."""
+    telegram_id, _ = await require_auth(request)
+
+    pool = await get_pool()
+    async with pool.acquire() as conn:
+        if not lang or lang not in FEED_TARGET_LANGUAGES:
+            lang = await conn.fetchval(
+                "SELECT app_language FROM users WHERE telegram_id = $1",
+                telegram_id,
+            ) or "pl"
+            if lang not in FEED_TARGET_LANGUAGES:
+                lang = "pl"
+
+        row = await conn.fetchrow("""
+            SELECT * FROM feed_posts WHERE id = $1 AND is_published = TRUE
+        """, post_id)
+
+        if not row:
+            raise HTTPException(404, "Post not found")
+
+        att_rows = await conn.fetch("""
+            SELECT file_path, order_number
+            FROM feed_attachments
+            WHERE post_id = $1
+            ORDER BY order_number ASC
+        """, post_id)
+
+        return _serialize_post(dict(row), [dict(a) for a in att_rows], lang)
+
+
+# ============ AI-ПЕРЕВОД ============
+
+async def translate_to_all_languages(
+    title: str,
+    body: str,
+    source_lang: str,
+) -> dict:
+    """
+    Переводит title и body с source_lang на все 4 языка (PL/RU/UK/EN).
+
+    Возвращает dict с 8 полями:
+        title_pl, title_ru, title_uk, title_en,
+        body_pl, body_ru, body_uk, body_en.
+
+    Если AI упал или вернул невалидный JSON — возвращает пустой dict.
+    Caller должен решить, использовать ли fallback (source_lang для всех языков).
+    """
+    if not TOGETHER_API_KEY:
+        logger.error("TOGETHER_API_KEY not configured — cannot translate")
+        return {}
+
+    if source_lang not in FEED_TARGET_LANGUAGES:
+        logger.error(f"Invalid source_lang: {source_lang}")
+        return {}
+
+    system_prompt = f"""Ты — переводчик. Переведи title и body на 4 языка: PL, RU, UK, EN.
+Язык оригинала: {source_lang}.
+
+Верни СТРОГО JSON без markdown и без пояснений:
+{{
+  "title_pl": "...", "title_ru": "...", "title_uk": "...", "title_en": "...",
+  "body_pl": "...", "body_ru": "...", "body_uk": "...", "body_en": "..."
+}}
+
+ВАЖНО:
+- Если source_lang = ru, то title_ru и body_ru оставь БЕЗ изменений.
+- Если source_lang = pl, то title_pl и body_pl оставь БЕЗ изменений.
+- Если source_lang = uk, то title_uk и body_uk оставь БЕЗ изменений.
+- Если source_lang = en, то title_en и body_en оставь БЕЗ изменений.
+- Сохраняй переносы строк внутри body (используй \\n в JSON).
+- Не добавляй никаких полей кроме указанных 8.
+- Если title пустой — оставь все title_* пустыми строками."""
+
+    user_prompt = f"title: {title}\nbody: {body}"
+
+    try:
+        async with httpx.AsyncClient(timeout=90.0) as client:
+            response = await client.post(
+                TOGETHER_API_URL,
+                headers={
+                    "Authorization": f"Bearer {TOGETHER_API_KEY}",
+                    "Content-Type": "application/json",
+                },
+                json={
+                    "model": TRANSLATE_MODEL,
+                    "messages": [
+                        {"role": "system", "content": system_prompt},
+                        {"role": "user", "content": user_prompt},
+                    ],
+                    "max_tokens": 2000,
+                    "temperature": 0.3,
+                },
+            )
+
+        if response.status_code != 200:
+            logger.error(
+                f"Translate API error: {response.status_code}, body={response.text[:200]}"
+            )
+            return {}
+
+        data = response.json()
+        raw = data["choices"][0]["message"]["content"].strip()
+
+        # Если AI обернул в ```json ... ``` — снимаем обёртку
+        if raw.startswith("```"):
+            raw = re.sub(r'^```(?:json)?\s*', '', raw)
+            raw = re.sub(r'\s*```$', '', raw)
+
+        # Иногда AI добавляет текст до/после JSON — вырезаем первый {...}
+        json_match = re.search(r'\{.*\}', raw, re.DOTALL)
+        if not json_match:
+            logger.error(f"AI response has no JSON: {raw[:200]}")
+            return {}
+
+        parsed = json.loads(json_match.group(0))
+
+        # Валидация: все 8 полей должны быть строками
+        expected_keys = [
+            "title_pl", "title_ru", "title_uk", "title_en",
+            "body_pl", "body_ru", "body_uk", "body_en",
+        ]
+        result = {}
+        for key in expected_keys:
+            value = parsed.get(key, "")
+            result[key] = str(value) if value is not None else ""
+
+        # Гарантия: source_lang остаётся без изменений
+        result[f"title_{source_lang}"] = title
+        result[f"body_{source_lang}"] = body
+
+        return result
+
+    except json.JSONDecodeError as e:
+        logger.error(f"Failed to parse AI JSON: {e}")
+        return {}
+    except Exception as e:
+        logger.error(f"Translate error: {str(e)}")
+        return {}
+
+
+# ============ АДМИНСКИЕ ЭНДПОИНТЫ ============
+
+@router.post("/admin/feed/post")
+async def admin_create_feed_post(request: Request):
+    """
+    Создать feed-пост.
+
+    Тело запроса (JSON):
+    {
+      "section": "news" | "partners" | "contacts" | "apps",
+      "source_language": "ru" | "pl" | "uk" | "en",
+      "title": "Заголовок на source_language",
+      "body": "Текст поста на source_language",
+      "link_url": "https://..." (опционально),
+      "telegram_url": "https://t.me/..." (опционально),
+      "is_pinned": false (опционально),
+      "expires_at": "2026-10-15T23:59:59Z" (опционально, для partners)
+    }
+
+    Backend автоматически переведёт title/body на 4 языка через MiniMax-M3.
+    Если перевод упал — сохраняем source_language для всех языков (fallback).
+    """
+    telegram_id, _ = await require_auth(request)
+    _require_admin(telegram_id)
+
+    body = await request.json()
+
+    section = body.get("section", "").strip()
+    source_language = body.get("source_language", "ru").strip().lower()
+    title = (body.get("title") or "").strip()
+    post_body = (body.get("body") or "").strip()
+    link_url = (body.get("link_url") or "").strip() or None
+    telegram_url = (body.get("telegram_url") or "").strip() or None
+    is_pinned = bool(body.get("is_pinned", False))
+    expires_at_raw = body.get("expires_at")
+
+    # Валидация
+    if section not in FEED_SECTIONS:
+        raise HTTPException(400, f"Invalid section. Allowed: {sorted(FEED_SECTIONS)}")
+
+    if source_language not in FEED_TARGET_LANGUAGES:
+        raise HTTPException(400, f"Invalid source_language. Allowed: {FEED_TARGET_LANGUAGES}")
+
+    if not title and not post_body:
+        raise HTTPException(400, "Either title or body is required")
+
+    if len(title) > 200:
+        raise HTTPException(400, "Title too long (max 200 characters)")
+
+    if len(post_body) > 5000:
+        raise HTTPException(400, "Body too long (max 5000 characters)")
+
+    # Парсим expires_at если передан
+    expires_at = None
+    if expires_at_raw:
+        try:
+            from datetime import datetime, timezone
+            # Поддерживаем ISO 8601 с 'Z' или без
+            normalized = expires_at_raw.replace("Z", "+00:00")
+            expires_at = datetime.fromisoformat(normalized)
+            if expires_at.tzinfo is None:
+                expires_at = expires_at.replace(tzinfo=timezone.utc)
+        except (ValueError, AttributeError):
+            raise HTTPException(400, "Invalid expires_at format (use ISO 8601)")
+
+    # Переводим на 4 языка
+    logger.info(f"Translating feed post from {source_language} → PL/RU/UK/EN")
+    translations = await translate_to_all_languages(title, post_body, source_language)
+
+    # Fallback: если перевод не удался — копируем source для всех языков
+    if not translations:
+        logger.warning("Translation failed — falling back to source_language for all")
+        translations = {}
+        for lang in FEED_TARGET_LANGUAGES:
+            translations[f"title_{lang}"] = title
+            translations[f"body_{lang}"] = post_body
+
+    pool = await get_pool()
+    async with pool.acquire() as conn:
+        row = await conn.fetchrow("""
+            INSERT INTO feed_posts (
+                section, source_language,
+                title_pl, title_ru, title_uk, title_en,
+                body_pl, body_ru, body_uk, body_en,
+                link_url, telegram_url,
+                author_id, is_pinned, is_published, expires_at
+            ) VALUES (
+                $1, $2,
+                $3, $4, $5, $6,
+                $7, $8, $9, $10,
+                $11, $12,
+                $13, $14, TRUE, $15
+            )
+            RETURNING id
+        """,
+            section, source_language,
+            translations["title_pl"], translations["title_ru"],
+            translations["title_uk"], translations["title_en"],
+            translations["body_pl"], translations["body_ru"],
+            translations["body_uk"], translations["body_en"],
+            link_url, telegram_url,
+            telegram_id, is_pinned, expires_at,
+        )
+
+        return {"status": "ok", "post_id": row["id"]}
+
+
+@router.put("/admin/feed/post/{post_id}")
+async def admin_update_feed_post(request: Request, post_id: int):
+    """
+    Редактировать feed-пост.
+
+    Тело запроса (JSON) — все поля опциональны:
+    {
+      "title": "...",            (на source_language)
+      "body": "...",             (на source_language)
+      "link_url": "..." | null,
+      "telegram_url": "..." | null,
+      "is_pinned": true/false,
+      "is_published": true/false,
+      "expires_at": "..." | null,
+      "translate_again": true    — перевести заново через AI
+    }
+    """
+    telegram_id, _ = await require_auth(request)
+    _require_admin(telegram_id)
+
+    body = await request.json()
+
+    pool = await get_pool()
+    async with pool.acquire() as conn:
+        existing = await conn.fetchrow("""
+            SELECT * FROM feed_posts WHERE id = $1
+        """, post_id)
+
+        if not existing:
+            raise HTTPException(404, "Post not found")
+
+        source_language = existing["source_language"]
+
+        # Мерджим поля: если не передано — оставляем старое
+        title = body.get("title", existing.get(f"title_{source_language}") or "")
+        post_body = body.get("body", existing.get(f"body_{source_language}") or "")
+        link_url = body.get("link_url", existing["link_url"])
+        telegram_url = body.get("telegram_url", existing["telegram_url"])
+        is_pinned = body.get("is_pinned", existing["is_pinned"])
+        is_published = body.get("is_published", existing["is_published"])
+
+        # expires_at: явное None → очистить, отсутствие ключа → оставить
+        if "expires_at" in body:
+            expires_at_raw = body.get("expires_at")
+            if expires_at_raw is None:
+                expires_at = None
+            else:
+                try:
+                    from datetime import datetime, timezone
+                    normalized = str(expires_at_raw).replace("Z", "+00:00")
+                    expires_at = datetime.fromisoformat(normalized)
+                    if expires_at.tzinfo is None:
+                        expires_at = expires_at.replace(tzinfo=timezone.utc)
+                except (ValueError, AttributeError):
+                    raise HTTPException(400, "Invalid expires_at format (use ISO 8601)")
+        else:
+            expires_at = existing["expires_at"]
+
+        # Если translate_again = True — переводим заново
+        if body.get("translate_again"):
+            logger.info(f"Re-translating feed post #{post_id} from {source_language}")
+            translations = await translate_to_all_languages(title, post_body, source_language)
+
+            if not translations:
+                logger.warning("Translation failed — keeping old translations for other languages")
+                # Оставляем старые версии для не-source языков, обновляем только source
+                translations = {
+                    "title_pl": existing["title_pl"], "title_ru": existing["title_ru"],
+                    "title_uk": existing["title_uk"], "title_en": existing["title_en"],
+                    "body_pl": existing["body_pl"], "body_ru": existing["body_ru"],
+                    "body_uk": existing["body_uk"], "body_en": existing["body_en"],
+                }
+                translations[f"title_{source_language}"] = title
+                translations[f"body_{source_language}"] = post_body
+        else:
+            # Без translate_again — обновляем ТОЛЬКО source_language, остальные не трогаем
+            translations = {
+                "title_pl": existing["title_pl"], "title_ru": existing["title_ru"],
+                "title_uk": existing["title_uk"], "title_en": existing["title_en"],
+                "body_pl": existing["body_pl"], "body_ru": existing["body_ru"],
+                "body_uk": existing["body_uk"], "body_en": existing["body_en"],
+            }
+            translations[f"title_{source_language}"] = title
+            translations[f"body_{source_language}"] = post_body
+
+        await conn.execute("""
+            UPDATE feed_posts SET
+                title_pl = $1, title_ru = $2, title_uk = $3, title_en = $4,
+                body_pl = $5, body_ru = $6, body_uk = $7, body_en = $8,
+                link_url = $9, telegram_url = $10,
+                is_pinned = $11, is_published = $12,
+                expires_at = $13,
+                updated_at = NOW(),
+                edited_at = NOW()
+            WHERE id = $14
+        """,
+            translations["title_pl"], translations["title_ru"],
+            translations["title_uk"], translations["title_en"],
+            translations["body_pl"], translations["body_ru"],
+            translations["body_uk"], translations["body_en"],
+            link_url, telegram_url,
+            is_pinned, is_published,
+            expires_at,
+            post_id,
+        )
+
+        return {"status": "ok", "post_id": post_id}
+
+
+# 🔧 ФИКС (18.09.2026): POST вместо DELETE.
+# Причина: Telegram WebView (iOS / macOS) не пропускает DELETE из-за CORS preflight,
+# который Cloudflare кеширует на 20 дней. POST без Content-Type — simple request,
+# preflight не отправляется, Cloudflare не вмешивается.
+#
+# 🔧 ФИКС (19.09.2026): удаляем не только запись из БД, но и файлы с диска.
+# Раньше файлы копились мёртвым грузом (27 мёртвых файлов за день тестов).
+@router.post("/admin/feed/post/{post_id}/delete")
+async def admin_delete_feed_post(request: Request, post_id: int):
+    """
+    Удалить feed-пост (POST вместо DELETE — обход CORS preflight в WebView).
+
+    Что делаем:
+    1. Читаем пути всех файлов поста из feed_attachments ДО удаления из БД.
+    2. Удаляем пост из БД (ON DELETE CASCADE уберёт вложения).
+    3. Удаляем файлы с диска.
+
+    Если файл уже удалён вручную / нет прав — не роняем запрос, только логируем.
+    Пост из БД уже удалён — файл вторичен.
+    """
+    telegram_id, _ = await require_auth(request)
+    _require_admin(telegram_id)
+
+    pool = await get_pool()
+    async with pool.acquire() as conn:
+        # 1. Читаем пути файлов ДО удаления
+        attachment_rows = await conn.fetch("""
+            SELECT file_path FROM feed_attachments WHERE post_id = $1
+        """, post_id)
+
+        # 2. Удаляем пост (CASCADE уберёт feed_attachments)
+        result = await conn.execute("""
+            DELETE FROM feed_posts WHERE id = $1
+        """, post_id)
+
+        affected = int(result.split()[-1])
+        if affected == 0:
+            raise HTTPException(404, "Post not found")
+
+        logger.info(f"Feed post #{post_id} deleted by admin {telegram_id}")
+
+    # 3. Удаляем файлы с диска (вне pool.acquire — чтобы не держать коннект)
+    #    file_path в БД = "/uploads/feed/16_0_abc.jpg"
+    #    на диске     = "/root/filwordspl/backend/uploads/feed/16_0_abc.jpg"
+    #    UPLOADS_DIR  = "/root/filwordspl/backend/uploads" (Path)
+    removed_count = 0
+    failed_count = 0
+
+    for row in attachment_rows:
+        file_path = row["file_path"]  # "/uploads/feed/16_0_abc.jpg"
+        # Убираем префикс "/uploads/" → "feed/16_0_abc.jpg"
+        rel_path = file_path.replace("/uploads/", "", 1).lstrip("/")
+        abs_path = Path(UPLOADS_DIR) / rel_path
+
+        try:
+            if abs_path.exists():
+                abs_path.unlink()
+                removed_count += 1
+                logger.info(f"[delete_feed_post] removed file: {abs_path}")
+            else:
+                logger.warning(f"[delete_feed_post] file not found: {abs_path}")
+        except Exception as e:
+            failed_count += 1
+            # Не роняем запрос — пост уже удалён из БД, файл вторичен
+            logger.error(f"[delete_feed_post] failed to remove {abs_path}: {e}")
+
+    if removed_count or failed_count:
+        logger.info(
+            f"[delete_feed_post] post #{post_id}: "
+            f"files removed={removed_count}, failed={failed_count}"
+        )
+
+    return {"status": "ok", "files_removed": removed_count}
+
+
+@router.post("/admin/feed/upload-image")
+async def admin_upload_feed_image(
+    request: Request,
+    post_id: int = Form(...),
+    file: UploadFile = File(...),
+):
+    """
+    Загрузить картинку к посту.
+    - Максимум MAX_FEED_ATTACHMENTS (3) на пост.
+    - Максимум MAX_FEED_IMAGE_SIZE_MB (5 МБ) на файл.
+    - Только image/jpeg, image/png, image/webp, image/gif.
+
+    Возвращает путь к файлу (используется как URL на фронте).
+    """
+    telegram_id, _ = await require_auth(request)
+    _require_admin(telegram_id)
+
+    # Валидация MIME-типа
+    content_type = (file.content_type or "").lower()
+    if content_type not in FEED_ALLOWED_IMAGE_TYPES:
+        raise HTTPException(
+            400,
+            f"Invalid image type: {content_type}. Allowed: {sorted(FEED_ALLOWED_IMAGE_TYPES)}",
+        )
+
+    # Читаем файл, проверяем размер
+    content = await file.read()
+    if len(content) == 0:
+        raise HTTPException(400, "Empty file")
+
+    if len(content) > MAX_FEED_IMAGE_SIZE_BYTES:
+        raise HTTPException(
+            400,
+            f"File too large: {len(content)} bytes. Max: {MAX_FEED_IMAGE_SIZE_BYTES} bytes",
+        )
+
+    pool = await get_pool()
+    async with pool.acquire() as conn:
+        # Проверяем, что пост существует
+        post_exists = await conn.fetchval(
+            "SELECT 1 FROM feed_posts WHERE id = $1", post_id
+        )
+        if not post_exists:
+            raise HTTPException(404, "Post not found")
+
+        # Проверяем лимит вложений
+        current_count = await conn.fetchval("""
+            SELECT COUNT(*) FROM feed_attachments WHERE post_id = $1
+        """, post_id) or 0
+
+        if current_count >= MAX_FEED_ATTACHMENTS:
+            raise HTTPException(
+                400,
+                f"Max {MAX_FEED_ATTACHMENTS} attachments per post (already {current_count})",
+            )
+
+        # Готовим имя файла: {post_id}_{order}_{uuid8}.{ext}
+        ext_map = {
+            "image/jpeg": "jpg",
+            "image/jpg": "jpg",
+            "image/png": "png",
+            "image/webp": "webp",
+            "image/gif": "gif",
+        }
+        ext = ext_map.get(content_type, "jpg")
+        order_number = current_count  # 0, 1, 2
+        filename = f"{post_id}_{order_number}_{uuid.uuid4().hex[:8]}.{ext}"
+
+        # Сохраняем на диск
+        feed_uploads_dir = Path(UPLOADS_DIR) / "feed"
+        feed_uploads_dir.mkdir(parents=True, exist_ok=True)
+        file_path_disk = feed_uploads_dir / filename
+        file_path_disk.write_bytes(content)
+
+        # Публичный URL для фронта (относительный — фронт сам подставит API_BASE)
+        public_path = f"/uploads/feed/{filename}"
+
+        # Пишем в БД
+        await conn.execute("""
+            INSERT INTO feed_attachments (post_id, file_path, file_type, order_number)
+            VALUES ($1, $2, $3, $4)
+        """, post_id, public_path, "image", order_number)
+
+        return {
+            "status": "ok",
+            "file_path": public_path,
+            "order_number": order_number,
+        }
+
+
+@router.post("/admin/feed/translate")
+async def admin_translate_feed(request: Request):
+    """
+    Перевести title+body БЕЗ сохранения в БД.
+    Используется для превью перевода в админ-UI.
+
+    Тело запроса:
+    {
+      "title": "...",
+      "body": "...",
+      "source_language": "ru"
+    }
+
+    Возвращает:
+    {
+      "title_pl": "...", "title_ru": "...", "title_uk": "...", "title_en": "...",
+      "body_pl": "...", "body_ru": "...", "body_uk": "...", "body_en": "..."
+    }
+    """
+    telegram_id, _ = await require_auth(request)
+    _require_admin(telegram_id)
+
+    body = await request.json()
+    title = (body.get("title") or "").strip()
+    post_body = (body.get("body") or "").strip()
+    source_language = body.get("source_language", "ru").strip().lower()
+
+    if source_language not in FEED_TARGET_LANGUAGES:
+        raise HTTPException(400, f"Invalid source_language. Allowed: {FEED_TARGET_LANGUAGES}")
+
+    if not title and not post_body:
+        raise HTTPException(400, "Either title or body is required")
+
+    translations = await translate_to_all_languages(title, post_body, source_language)
+
+    if not translations:
+        raise HTTPException(500, "Translation failed (AI unavailable or invalid response)")
+
+    return translations