forked from mtusi2026/mtusi2026lab3
290 lines
8.9 KiB
Python
290 lines
8.9 KiB
Python
import os
|
|
import uuid
|
|
from contextvars import ContextVar
|
|
from datetime import datetime, timedelta, timezone
|
|
from typing import Optional
|
|
from uuid import UUID
|
|
|
|
from fastapi import Depends, FastAPI, Header, HTTPException, Query, Request
|
|
from fastapi.exceptions import RequestValidationError
|
|
from fastapi.responses import JSONResponse
|
|
from fastapi.security import HTTPBasic, HTTPBasicCredentials
|
|
from sqlalchemy import text
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
from starlette.middleware.base import BaseHTTPMiddleware
|
|
|
|
from .auth import (
|
|
SESSION_TTL,
|
|
create_session,
|
|
generate_token,
|
|
get_current_user,
|
|
hash_password,
|
|
hash_token,
|
|
revoke_current_session,
|
|
verify_password,
|
|
)
|
|
from .db.models import SessionRow, User
|
|
from .db.session import get_db
|
|
from .models import CreateChat, CreateMessage, CreateUser
|
|
from .repositories import chats as chats_repo
|
|
from .repositories import messages as messages_repo
|
|
from .repositories import users as users_repo
|
|
|
|
request_id_var: ContextVar[str] = ContextVar("request_id", default="")
|
|
|
|
_HTTP_CODES = {
|
|
400: "invalid_request",
|
|
401: "unauthorized",
|
|
404: "not_found",
|
|
409: "conflict",
|
|
413: "payload_too_large",
|
|
415: "unsupported_media_type",
|
|
429: "rate_limited",
|
|
503: "unavailable",
|
|
500: "internal_error",
|
|
}
|
|
|
|
|
|
def err_json(status: int, code: str, message: str) -> JSONResponse:
|
|
return JSONResponse(
|
|
status_code=status,
|
|
content={
|
|
"error": {
|
|
"code": code,
|
|
"message": message,
|
|
"request_id": request_id_var.get(),
|
|
}
|
|
},
|
|
)
|
|
|
|
|
|
class RequestIdMiddleware(BaseHTTPMiddleware):
|
|
async def dispatch(self, request: Request, call_next):
|
|
rid = request.headers.get("X-Request-Id") or uuid.uuid4().hex
|
|
request_id_var.set(rid)
|
|
response = await call_next(request)
|
|
response.headers["X-Request-Id"] = rid
|
|
return response
|
|
|
|
|
|
app = FastAPI(title="MTUSI Messenger — lab2")
|
|
app.add_middleware(RequestIdMiddleware)
|
|
security = HTTPBasic(auto_error=False)
|
|
|
|
|
|
@app.exception_handler(RequestValidationError)
|
|
async def _validation(request: Request, exc: RequestValidationError):
|
|
return err_json(400, "invalid_request", "Validation error")
|
|
|
|
|
|
@app.exception_handler(HTTPException)
|
|
async def _http(request: Request, exc: HTTPException):
|
|
code = _HTTP_CODES.get(exc.status_code, "internal_error")
|
|
detail = exc.detail if isinstance(exc.detail, str) else "Error"
|
|
resp = err_json(exc.status_code, code, detail)
|
|
if exc.headers:
|
|
for k, v in exc.headers.items():
|
|
resp.headers[k] = v
|
|
return resp
|
|
|
|
|
|
@app.exception_handler(Exception)
|
|
async def _generic(request: Request, exc: Exception):
|
|
return err_json(500, "internal_error", "Internal server error")
|
|
|
|
|
|
def _iso_z(dt: datetime) -> str:
|
|
return dt.isoformat().replace("+00:00", "Z")
|
|
|
|
|
|
def _user_json(u: User) -> dict:
|
|
return {
|
|
"id": str(u.id),
|
|
"username": u.username,
|
|
"display_name": u.display_name,
|
|
"created_at": _iso_z(u.created_at),
|
|
}
|
|
|
|
|
|
def _chat_json(chat, member_ids: list[str]) -> dict:
|
|
return {
|
|
"id": str(chat.id),
|
|
"title": chat.title,
|
|
"member_ids": member_ids,
|
|
"created_at": _iso_z(chat.created_at),
|
|
}
|
|
|
|
|
|
def _msg_json(m) -> dict:
|
|
return {
|
|
"id": str(m.id),
|
|
"chat_id": str(m.chat_id),
|
|
"sender_id": str(m.sender_id),
|
|
"text": m.text,
|
|
"created_at": _iso_z(m.created_at),
|
|
}
|
|
|
|
|
|
# ---------- health ----------
|
|
@app.get("/health/live")
|
|
def live():
|
|
return {"status": "ok"}
|
|
|
|
|
|
@app.get("/health/ready")
|
|
async def ready(db: AsyncSession = Depends(get_db)):
|
|
try:
|
|
await db.execute(text("SELECT 1"))
|
|
except Exception:
|
|
return err_json(503, "unavailable", "Database unavailable")
|
|
return {"status": "ok"}
|
|
|
|
|
|
# ---------- users ----------
|
|
@app.post("/api/v1/users", status_code=201)
|
|
async def register(body: CreateUser, db: AsyncSession = Depends(get_db)):
|
|
existing = await users_repo.get_by_username(db, body.username)
|
|
if existing is not None:
|
|
raise HTTPException(409, "Username already exists")
|
|
try:
|
|
user = await users_repo.create(
|
|
db, body.username, body.display_name, hash_password(body.password)
|
|
)
|
|
except Exception:
|
|
raise HTTPException(409, "Username already exists")
|
|
return _user_json(user)
|
|
|
|
|
|
# ---------- sessions ----------
|
|
@app.post("/api/v1/auth/sessions", status_code=201)
|
|
async def login(
|
|
creds: Optional[HTTPBasicCredentials] = Depends(security),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
basic_challenge = 'Basic realm="messenger", charset="UTF-8"'
|
|
if creds is None:
|
|
raise HTTPException(
|
|
status_code=401, detail="Unauthorized", headers={"WWW-Authenticate": basic_challenge}
|
|
)
|
|
user = await users_repo.get_by_username(db, creds.username)
|
|
if user is None or not verify_password(creds.password, user.password_hash):
|
|
raise HTTPException(
|
|
status_code=401, detail="Unauthorized", headers={"WWW-Authenticate": basic_challenge}
|
|
)
|
|
expires = datetime.now(timezone.utc) + timedelta(seconds=SESSION_TTL)
|
|
token = await create_session(str(user.id))
|
|
|
|
return {
|
|
"token": token,
|
|
"token_type": "Bearer",
|
|
"expires_at": _iso_z(expires),
|
|
"user": _user_json(user),
|
|
}
|
|
|
|
|
|
@app.delete("/api/v1/auth/sessions/current", status_code=204)
|
|
async def logout(authorization: str = Header(...), db: AsyncSession = Depends(get_db)):
|
|
await revoke_current_session(authorization, db)
|
|
|
|
|
|
@app.get("/api/v1/users/me")
|
|
async def me(user: User = Depends(get_current_user)):
|
|
return _user_json(user)
|
|
|
|
|
|
# ---------- chats ----------
|
|
@app.post("/api/v1/chats", status_code=201)
|
|
async def create_chat(
|
|
body: CreateChat,
|
|
user: User = Depends(get_current_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
if user.id not in body.member_ids:
|
|
raise HTTPException(400, "Caller must be in member_ids")
|
|
try:
|
|
chat = await chats_repo.create_atomic(db, body.title, body.member_ids)
|
|
except ValueError:
|
|
raise HTTPException(404, "Member not found")
|
|
return _chat_json(chat, [str(x) for x in body.member_ids])
|
|
|
|
|
|
@app.get("/api/v1/chats")
|
|
async def list_chats(
|
|
user: User = Depends(get_current_user),
|
|
limit: int = Query(50, ge=1, le=100),
|
|
cursor: Optional[str] = Query(None, min_length=1),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
parsed = None
|
|
if cursor is not None:
|
|
try:
|
|
c_created, c_id = cursor.split("|", 1)
|
|
parsed = (datetime.fromisoformat(c_created), UUID(c_id))
|
|
except Exception:
|
|
raise HTTPException(400, "Invalid cursor")
|
|
rows, next_cursor = await chats_repo.list_for_user(db, user.id, limit, parsed)
|
|
items = []
|
|
for chat in rows:
|
|
members = await chats_repo.list_member_ids(db, chat.id)
|
|
items.append(_chat_json(chat, [str(m) for m in members]))
|
|
nxt = f"{next_cursor[0].isoformat()}|{next_cursor[1]}" if next_cursor else None
|
|
return {"items": items, "next_cursor": nxt}
|
|
|
|
|
|
@app.get("/api/v1/chats/{chat_id}")
|
|
async def get_chat(
|
|
chat_id: UUID,
|
|
user: User = Depends(get_current_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
chat = await chats_repo.get_if_member(db, chat_id, user.id)
|
|
if chat is None:
|
|
raise HTTPException(404, "Chat not found")
|
|
members = await chats_repo.list_member_ids(db, chat.id)
|
|
return _chat_json(chat, [str(m) for m in members])
|
|
|
|
|
|
# ---------- messages ----------
|
|
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
|
|
async def post_message(
|
|
chat_id: UUID,
|
|
body: CreateMessage,
|
|
user: User = Depends(get_current_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
chat = await chats_repo.get_if_member(db, chat_id, user.id)
|
|
if chat is None:
|
|
raise HTTPException(404, "Chat not found")
|
|
msg = await messages_repo.create_and_invalidate(db, chat_id, user.id, body.text)
|
|
return _msg_json(msg)
|
|
|
|
|
|
@app.get("/api/v1/chats/{chat_id}/messages")
|
|
async def list_messages(
|
|
chat_id: UUID,
|
|
user: User = Depends(get_current_user),
|
|
limit: int = Query(50, ge=1, le=100),
|
|
cursor: Optional[str] = Query(None, min_length=1),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
chat = await chats_repo.get_if_member(db, chat_id, user.id)
|
|
if chat is None:
|
|
raise HTTPException(404, "Chat not found")
|
|
|
|
parsed = None
|
|
if cursor is not None:
|
|
try:
|
|
c_created, c_id = cursor.split("|", 1)
|
|
parsed = (datetime.fromisoformat(c_created), UUID(c_id))
|
|
except Exception:
|
|
raise HTTPException(400, "Invalid cursor")
|
|
|
|
rows, next_cursor, _cached = await messages_repo.list_page_cached(db, chat_id, limit, parsed)
|
|
|
|
nxt = f"{next_cursor[0].isoformat()}|{next_cursor[1]}" if next_cursor else None
|
|
return {"items": [_msg_json(m) for m in rows], "next_cursor": nxt}
|
|
|
|
if __name__ == "__main__":
|
|
import uvicorn
|
|
|
|
uvicorn.run(app, host="0.0.0.0", port=int(os.getenv("APP_PORT", "8080"))) |