Files
mtusi2026lab2/app.py
T

242 lines
6.9 KiB
Python

import uuid
import threading
from datetime import datetime, timezone
from fastapi import FastAPI, Header, HTTPException, Query, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from starlette.exceptions import HTTPException as StarletteHTTPException
from schemas import (
User, CreateUser,
Chat, CreateChat, ChatPage,
Message, CreateMessage, MessagePage,
)
app = FastAPI()
lock = threading.Lock()
users: dict[str, dict] = {}
usernames: set[str] = set()
chats: dict[str, Chat] = {}
messages: dict[str, list[Message]] = {}
def now_iso() -> str:
return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
def get_current_user(x_user_id: str | None):
if x_user_id is None:
raise HTTPException(
status_code=401,
detail="unauthorized",
headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'},
)
try:
uuid.UUID(x_user_id)
except ValueError:
raise HTTPException(status_code=400, detail="Invalid X-User-Id")
user = users.get(x_user_id)
if user is None:
raise HTTPException(
status_code=401,
detail="unauthorized",
headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'},
)
return user
@app.middleware("http")
async def xri(request: Request, call_next):
rid = request.headers.get("X-Request-Id") or str(uuid.uuid4())
request.state.request_id = rid
response = await call_next(request)
response.headers["X-Request-Id"] = rid
return response
@app.exception_handler(RequestValidationError)
async def validation_handler(request: Request, exc: RequestValidationError):
return JSONResponse(
status_code=400,
content={
"error": {
"code": "invalid_request",
"message": "Invalid request body",
"request_id": request.state.request_id,
}
},
)
@app.exception_handler(StarletteHTTPException)
async def http_exception_handler(request: Request, exc: StarletteHTTPException):
codes = {
400: "invalid_request",
401: "unauthorized",
404: "not_found",
409: "conflict",
}
code = codes.get(exc.status_code, "internal_error")
return JSONResponse(
status_code=exc.status_code,
content={
"error": {
"code": code,
"message": str(exc.detail),
"request_id": request.state.request_id,
}
},
headers=exc.headers or {},
)
@app.get("/health/live")
async def liveness():
return {"status": "ok"}
@app.get("/health/ready")
async def readiness():
return {"status": "ok"}
@app.post("/api/v1/users", status_code=201)
async def registerUser(payload: CreateUser):
uid = str(uuid.uuid4())
user = User(
id=uid,
username=payload.username,
display_name=payload.display_name,
created_at=now_iso(),
)
with lock:
if payload.username in usernames:
raise HTTPException(status_code=409, detail="Username already exists")
usernames.add(payload.username)
users[uid] = user
return user
@app.get("/api/v1/users/me")
async def currentUser(x_user_id: str | None = Header(default=None)):
return get_current_user(x_user_id)
@app.post("/api/v1/chats", status_code=201)
async def createChat(payload: CreateChat, x_user_id: str | None = Header(default=None)):
me = get_current_user(x_user_id)
if len(set(payload.member_ids)) != len(payload.member_ids):
raise HTTPException(status_code=400, detail="member_ids must be unique")
for i in payload.member_ids:
try:
uuid.UUID(i)
except ValueError:
raise HTTPException(status_code=400, detail="Invalid member id")
if i not in users:
raise HTTPException(status_code=400, detail="Unknown member")
if me.id not in payload.member_ids:
raise HTTPException(status_code=400, detail="Caller must be a member")
cid = str(uuid.uuid4())
chat = Chat(
id=cid,
title=payload.title,
member_ids=payload.member_ids,
created_at=now_iso(),
)
with lock:
chats[cid] = chat
messages[cid] = []
return chat
@app.get("/api/v1/chats")
async def listChats(
x_user_id: str | None = Header(default=None),
limit: int = Query(default=50, ge=1, le=100),
cursor: str | None = Query(default=None, min_length=1),
):
me = get_current_user(x_user_id)
with lock:
mine = [c for c in chats.values() if me.id in c.member_ids]
mine.sort(key=lambda c: (c.created_at, c.id))
if cursor is not None:
ids = [c.id for c in mine]
if cursor not in ids:
raise HTTPException(status_code=400, detail="Invalid cursor")
idx = ids.index(cursor)
mine = mine[idx + 1:]
page = mine[:limit]
next_cursor = page[-1].id if len(mine) > limit else None
return ChatPage(items=page, next_cursor=next_cursor)
@app.get("/api/v1/chats/{chat_id}")
async def getChat(chat_id: str, x_user_id: str | None = Header(default=None)):
me = get_current_user(x_user_id)
with lock:
chat = chats.get(chat_id)
if chat is None or me.id not in chat.member_ids:
raise HTTPException(status_code=404, detail="Chat not found")
return chat
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
async def createMessage(
chat_id: str,
payload: CreateMessage,
x_user_id: str | None = Header(default=None),
):
me = get_current_user(x_user_id)
with lock:
chat = chats.get(chat_id)
if chat is None or me.id not in chat.member_ids:
raise HTTPException(status_code=404, detail="Chat not found")
msg = Message(
id=str(uuid.uuid4()),
chat_id=chat_id,
sender_id=me.id,
text=payload.text,
created_at=now_iso(),
)
messages.setdefault(chat_id, []).append(msg)
return msg
@app.get("/api/v1/chats/{chat_id}/messages")
async def listMessages(
chat_id: str,
x_user_id: str | None = Header(default=None),
limit: int = Query(default=50, ge=1, le=100),
cursor: str | None = Query(default=None, min_length=1),
):
me = get_current_user(x_user_id)
with lock:
chat = chats.get(chat_id)
if chat is None or me.id not in chat.member_ids:
raise HTTPException(status_code=404, detail="Chat not found")
msgs = list(messages.get(chat_id, []))
msgs.sort(key=lambda m: (m.created_at, m.id))
if cursor is not None:
ids = [m.id for m in msgs]
if cursor not in ids:
raise HTTPException(status_code=400, detail="Invalid cursor")
idx = ids.index(cursor)
msgs = msgs[idx + 1:]
page = msgs[:limit]
next_cursor = page[-1].id if len(msgs) > limit else None
return MessagePage(items=page, next_cursor=next_cursor)