forked from mtusi2026/mtusi2026lab3
179 lines
5.5 KiB
Python
179 lines
5.5 KiB
Python
import re
|
|
import uuid
|
|
|
|
from fastapi import APIRouter, Header, HTTPException, Query, Request
|
|
from fastapi.responses import JSONResponse
|
|
|
|
from app.models import (
|
|
Chat, CreateChat, Message, CreateMessage, ChatPage, MessagePage,
|
|
)
|
|
from app.security import get_current_user
|
|
|
|
router = APIRouter(tags=["chats"])
|
|
|
|
BEARER_CHALLENGE = 'Bearer realm="messenger"'
|
|
IDEMPOTENCY_RE = re.compile(r"^[A-Za-z0-9._:-]{1,128}$")
|
|
|
|
|
|
def error_response(
|
|
status: int, code: str, message: str, request_id: str, headers=None,
|
|
) -> JSONResponse:
|
|
return JSONResponse(
|
|
status_code=status,
|
|
content={
|
|
"error": {
|
|
"code": code,
|
|
"message": message,
|
|
"request_id": request_id,
|
|
}
|
|
},
|
|
headers=headers or {},
|
|
)
|
|
|
|
|
|
def validate_uuid(value: str) -> None:
|
|
try:
|
|
uuid.UUID(value)
|
|
except (ValueError, TypeError):
|
|
raise HTTPException(status_code=400, detail="invalid uuid")
|
|
|
|
|
|
def validate_idempotency_key(value: str | None) -> str:
|
|
if value is None or not IDEMPOTENCY_RE.match(value):
|
|
raise HTTPException(status_code=400, detail="invalid idempotency key")
|
|
return value
|
|
|
|
|
|
async def resolve_actor(request: Request, authorization: str | None):
|
|
rid = request.state.request_id
|
|
try:
|
|
user, _ = await get_current_user(request, authorization)
|
|
except HTTPException as exc:
|
|
if exc.status_code == 503:
|
|
return None, error_response(
|
|
503,
|
|
"unavailable",
|
|
"auth store unavailable",
|
|
rid,
|
|
)
|
|
return None, error_response(
|
|
401,
|
|
"unauthorized",
|
|
"unauthorized",
|
|
rid,
|
|
headers={"WWW-Authenticate": BEARER_CHALLENGE},
|
|
)
|
|
return user, None
|
|
|
|
|
|
@router.post("/chats", response_model=Chat, status_code=201)
|
|
async def create_chat(
|
|
data: CreateChat,
|
|
request: Request,
|
|
authorization: str | None = Header(default=None),
|
|
):
|
|
rid = request.state.request_id
|
|
actor, err = await resolve_actor(request, authorization)
|
|
if err is not None:
|
|
return err
|
|
storage = request.app.state.storage
|
|
try:
|
|
chat = await storage.create_chat(
|
|
data.title, data.member_ids, actor["id"],
|
|
)
|
|
return chat
|
|
except ValueError as e:
|
|
msg = str(e)
|
|
if msg == "invalid_member":
|
|
return error_response(400, "invalid_request", "unknown member", rid)
|
|
if msg == "creator_not_member":
|
|
return error_response(
|
|
400, "invalid_request", "creator must be a member", rid,
|
|
)
|
|
return error_response(400, "invalid_request", "bad request", rid)
|
|
|
|
|
|
@router.get("/chats", response_model=ChatPage)
|
|
async def list_chats(
|
|
request: Request,
|
|
authorization: str | None = Header(default=None),
|
|
limit: int = Query(50, ge=1, le=100),
|
|
cursor: str | None = Query(None),
|
|
):
|
|
rid = request.state.request_id
|
|
actor, err = await resolve_actor(request, authorization)
|
|
if err is not None:
|
|
return err
|
|
try:
|
|
items, next_cursor = await request.app.state.storage.list_chats(
|
|
actor["id"], limit, cursor,
|
|
)
|
|
except ValueError:
|
|
return error_response(400, "invalid_request", "bad cursor", rid)
|
|
return {"items": items, "next_cursor": next_cursor}
|
|
|
|
|
|
@router.get("/chats/{chat_id}", response_model=Chat)
|
|
async def get_chat(
|
|
chat_id: str,
|
|
request: Request,
|
|
authorization: str | None = Header(default=None),
|
|
):
|
|
rid = request.state.request_id
|
|
validate_uuid(chat_id)
|
|
actor, err = await resolve_actor(request, authorization)
|
|
if err is not None:
|
|
return err
|
|
chat = await request.app.state.storage.get_chat(chat_id, actor["id"])
|
|
if chat is None:
|
|
return error_response(404, "not_found", "chat not found", rid)
|
|
return chat
|
|
|
|
|
|
@router.post("/chats/{chat_id}/messages", response_model=Message, status_code=201)
|
|
async def create_message(
|
|
chat_id: str,
|
|
data: CreateMessage,
|
|
request: Request,
|
|
authorization: str | None = Header(default=None),
|
|
idempotency_key: str | None = Header(default=None, alias="Idempotency-Key"),
|
|
):
|
|
rid = request.state.request_id
|
|
validate_uuid(chat_id)
|
|
validate_idempotency_key(idempotency_key)
|
|
actor, err = await resolve_actor(request, authorization)
|
|
if err is not None:
|
|
return err
|
|
try:
|
|
msg = await request.app.state.storage.add_message(
|
|
chat_id, actor["id"], data.text, idempotency_key,
|
|
)
|
|
return msg
|
|
except ValueError as e:
|
|
if str(e) == "idempotency_conflict":
|
|
return error_response(409, "conflict", "idempotency key conflict", rid)
|
|
return error_response(404, "not_found", "chat not found", rid)
|
|
|
|
|
|
@router.get("/chats/{chat_id}/messages", response_model=MessagePage)
|
|
async def list_messages(
|
|
chat_id: str,
|
|
request: Request,
|
|
authorization: str | None = Header(default=None),
|
|
limit: int = Query(50, ge=1, le=100),
|
|
cursor: str | None = Query(None),
|
|
):
|
|
rid = request.state.request_id
|
|
validate_uuid(chat_id)
|
|
actor, err = await resolve_actor(request, authorization)
|
|
if err is not None:
|
|
return err
|
|
try:
|
|
items, next_cursor = await request.app.state.storage.list_messages(
|
|
chat_id, actor["id"], limit, cursor,
|
|
)
|
|
except ValueError as e:
|
|
if str(e) == "bad_cursor":
|
|
return error_response(400, "invalid_request", "bad cursor", rid)
|
|
return error_response(404, "not_found", "chat not found", rid)
|
|
return {"items": items, "next_cursor": next_cursor} |