"""HTTP-слой: тонкие обработчики (SRP: только транспорт).""" import logging from typing import Optional from urllib.parse import quote from fastapi import APIRouter, Depends, Header, Query, Request, Response from app.auth import require_actor from app.db import Database from app.errors import unavailable, unsupported_media from app.s3store import S3Store from app.schemas import CreateChatBody, CreateMessageBody, CreateUserBody from app.services import ( AttachmentService, AuthService, ChatService, MessageService, UserService, ) from app.sessions import SessionStore from app.upload import read_body_limited logger = logging.getLogger("messenger") router = APIRouter() def _state(request: Request): db: Database = request.app.state.db sessions: SessionStore = request.app.state.sessions s3: S3Store = request.app.state.s3 return db, sessions, s3 def require_json_content_type(request: Request) -> None: content_type = request.headers.get("content-type", "") media = content_type.split(";")[0].strip().lower() if media != "application/json": raise unsupported_media() def _require_accepting(db: Database) -> None: if not db.accepting: raise unavailable("Сервер завершает работу") @router.get("/health/live") def live(): return {"status": "ok"} @router.get("/health/ready") def ready(request: Request): db, sessions, s3 = _state(request) if not db.ready or not db.accepting: raise unavailable("Не готов принимать трафик") if not db.ping() or not sessions.ping() or not s3.ping(): raise unavailable("Зависимость недоступна") return {"status": "ok"} @router.post("/api/v1/users", status_code=201) def create_user( request: Request, body: CreateUserBody, _: None = Depends(require_json_content_type), ): db, _sessions, _s3 = _state(request) _require_accepting(db) return UserService(db).create(body.model_dump()) @router.post("/api/v1/auth/sessions", status_code=201) def create_session( request: Request, authorization: Optional[str] = Header(default=None), ): db, sessions, _s3 = _state(request) _require_accepting(db) return AuthService(db, sessions).create_session(authorization) @router.delete("/api/v1/auth/sessions/current", status_code=204) def revoke_session( request: Request, authorization: Optional[str] = Header(default=None), ): db, sessions, _s3 = _state(request) _require_accepting(db) _actor, token = require_actor(db, sessions, authorization) AuthService(db, sessions).logout(token) return Response(status_code=204) @router.get("/api/v1/users/me") def current_user( request: Request, authorization: Optional[str] = Header(default=None), ): db, sessions, _s3 = _state(request) _require_accepting(db) actor, _token = require_actor(db, sessions, authorization) return actor.to_dict() @router.post("/api/v1/chats", status_code=201) def create_chat( request: Request, body: CreateChatBody, authorization: Optional[str] = Header(default=None), _: None = Depends(require_json_content_type), ): db, sessions, _s3 = _state(request) _require_accepting(db) actor, _token = require_actor(db, sessions, authorization) return ChatService(db).create(actor, body.model_dump()) @router.get("/api/v1/chats") def list_chats( request: Request, authorization: Optional[str] = Header(default=None), limit: Optional[str] = Query(default=None), cursor: Optional[str] = Query(default=None), ): db, sessions, _s3 = _state(request) _require_accepting(db) actor, _token = require_actor(db, sessions, authorization) return ChatService(db).list_for_user(actor, limit, cursor) @router.get("/api/v1/chats/{chat_id}") def get_chat( chat_id: str, request: Request, authorization: Optional[str] = Header(default=None), ): db, sessions, _s3 = _state(request) _require_accepting(db) actor, _token = require_actor(db, sessions, authorization) return ChatService(db).get_for_member(actor, chat_id).to_dict() @router.post("/api/v1/chats/{chat_id}/messages", status_code=201) def create_message( chat_id: str, request: Request, body: CreateMessageBody, authorization: Optional[str] = Header(default=None), idempotency_key: Optional[str] = Header(default=None, alias="Idempotency-Key"), _: None = Depends(require_json_content_type), ): db, sessions, _s3 = _state(request) _require_accepting(db) actor, _token = require_actor(db, sessions, authorization) chats = ChatService(db) chat = chats.get_for_member(actor, chat_id) path = f"/api/v1/chats/{chat.id}/messages" result = MessageService(db).create( actor, chat, body.model_dump(), idempotency_key=idempotency_key, method="POST", path=path, ) logger.info( "message created chat_id=%s sender_id=%s message_id=%s", chat.id, actor.id, result["id"], ) return result @router.get("/api/v1/chats/{chat_id}/messages") def list_messages( chat_id: str, request: Request, authorization: Optional[str] = Header(default=None), limit: Optional[str] = Query(default=None), cursor: Optional[str] = Query(default=None), ): db, sessions, _s3 = _state(request) _require_accepting(db) actor, _token = require_actor(db, sessions, authorization) chat = ChatService(db).get_for_member(actor, chat_id) return MessageService(db).list_for_chat(chat, limit, cursor) @router.post("/api/v1/chats/{chat_id}/attachments", status_code=201) async def upload_attachment( chat_id: str, request: Request, filename: Optional[str] = Query(default=None), authorization: Optional[str] = Header(default=None), ): db, sessions, s3 = _state(request) _require_accepting(db) actor, _token = require_actor(db, sessions, authorization) chat = ChatService(db).get_for_member(actor, chat_id) content_type = request.headers.get("content-type", "") media = content_type.split(";")[0].strip().lower() if media not in ("image/png", "image/jpeg"): raise unsupported_media("Content-Type должен быть image/png или image/jpeg") data = await read_body_limited(request) result = AttachmentService(db, s3).upload( actor, chat, filename_raw=filename, content_type=media, data=data, ) logger.info( "attachment uploaded chat_id=%s attachment_id=%s size=%s", chat.id, result["id"], result["size_bytes"], ) return result @router.get("/api/v1/attachments/{attachment_id}") def get_attachment( attachment_id: str, request: Request, authorization: Optional[str] = Header(default=None), ): db, sessions, s3 = _state(request) _require_accepting(db) actor, _token = require_actor(db, sessions, authorization) return AttachmentService(db, s3).get_for_member(actor, attachment_id).to_dict() @router.get("/api/v1/attachments/{attachment_id}/content") def download_attachment( attachment_id: str, request: Request, authorization: Optional[str] = Header(default=None), variant: Optional[str] = Query(default=None), ): db, sessions, s3 = _state(request) _require_accepting(db) actor, _token = require_actor(db, sessions, authorization) if variant is not None and variant != "" and variant != "original": from app.errors import not_found raise not_found("Вариант не найден") att, data = AttachmentService(db, s3).download_for_member(actor, attachment_id) filename = quote(att.filename) return Response( content=data, media_type=att.content_type, headers={ "Content-Length": str(len(data)), "Content-Disposition": f"inline; filename*=UTF-8''{filename}", }, )