forked from mtusi2026/mtusi2026lab2
295 lines
10 KiB
Python
295 lines
10 KiB
Python
import uuid
|
|
from datetime import datetime, timezone
|
|
from typing import Dict, List, Optional
|
|
from uuid import UUID
|
|
from fastapi import FastAPI, Header, HTTPException, Query, Response, Request
|
|
from fastapi.exceptions import RequestValidationError
|
|
from fastapi.responses import JSONResponse
|
|
from pydantic import BaseModel, Field, field_validator, ConfigDict
|
|
|
|
app = FastAPI(title="MTUSI Messenger — lab1", version="1.1.0")
|
|
|
|
USERS: Dict[str, dict] = {}
|
|
CHATS: Dict[str, dict] = {}
|
|
MESSAGES: Dict[str, List[dict]] = {}
|
|
|
|
def generate_request_id() -> str:
|
|
return uuid.uuid4().hex
|
|
|
|
def make_error_response(status_code: int, code: str, message: str, req_id: str) -> JSONResponse:
|
|
return JSONResponse(
|
|
status_code=status_code,
|
|
headers={"X-Request-Id": req_id},
|
|
content={
|
|
"error": {
|
|
"code": code,
|
|
"message": message,
|
|
"request_id": req_id
|
|
}
|
|
}
|
|
)
|
|
|
|
@app.exception_handler(RequestValidationError)
|
|
async def validation_exception_handler(request: Request, exc: RequestValidationError):
|
|
req_id = request.headers.get("X-Request-Id") or generate_request_id()
|
|
return make_error_response(400, "invalid_request", "Validation error in request body or parameters", req_id)
|
|
|
|
@app.exception_handler(HTTPException)
|
|
async def http_exception_handler(request: Request, exc: HTTPException):
|
|
req_id = request.headers.get("X-Request-Id") or generate_request_id()
|
|
detail = exc.detail
|
|
if isinstance(detail, dict) and "error" in detail:
|
|
detail["error"]["request_id"] = req_id
|
|
return JSONResponse(
|
|
status_code=exc.status_code,
|
|
headers={"X-Request-Id": req_id},
|
|
content=detail
|
|
)
|
|
|
|
code_map = {
|
|
400: "invalid_request",
|
|
401: "unauthorized",
|
|
404: "not_found",
|
|
409: "conflict",
|
|
429: "rate_limited",
|
|
503: "unavailable",
|
|
500: "internal_error"
|
|
}
|
|
code = code_map.get(exc.status_code, "internal_error")
|
|
return make_error_response(exc.status_code, code, str(detail), req_id)
|
|
|
|
class CreateUser(BaseModel):
|
|
model_config = ConfigDict(extra='forbid')
|
|
username: str = Field(..., pattern=r"^[a-z0-9_]{3,32}$")
|
|
display_name: str = Field(..., min_length=1, max_length=100)
|
|
|
|
@field_validator("display_name")
|
|
def not_blank(cls, v):
|
|
if not v.strip():
|
|
raise ValueError("Must not be blank")
|
|
return v
|
|
|
|
class CreateChat(BaseModel):
|
|
model_config = ConfigDict(extra='forbid')
|
|
title: str = Field(..., min_length=1, max_length=100)
|
|
member_ids: List[uuid.UUID] = Field(..., min_items=1, max_items=100)
|
|
|
|
@field_validator("title")
|
|
def not_blank(cls, v):
|
|
if not v.strip():
|
|
raise ValueError("Must not be blank")
|
|
return v
|
|
|
|
class CreateMessage(BaseModel):
|
|
model_config = ConfigDict(extra='forbid')
|
|
text: str = Field(..., min_length=1, max_length=4000)
|
|
|
|
@field_validator("text")
|
|
def not_blank(cls, v):
|
|
if not v.strip():
|
|
raise ValueError("Must not be blank")
|
|
return v
|
|
|
|
@app.get("/health/live")
|
|
def health_live(response: Response):
|
|
req_id = generate_request_id()
|
|
response.headers["X-Request-Id"] = req_id
|
|
return {"status": "ok"}
|
|
|
|
@app.get("/health/ready")
|
|
def health_ready(response: Response):
|
|
req_id = generate_request_id()
|
|
response.headers["X-Request-Id"] = req_id
|
|
return {"status": "ok"}
|
|
|
|
@app.post("/api/v1/users", status_code=201)
|
|
def register_user(body: CreateUser, response: Response):
|
|
req_id = generate_request_id()
|
|
response.headers["X-Request-Id"] = req_id
|
|
|
|
for u in USERS.values():
|
|
if u["username"] == body.username:
|
|
raise HTTPException(status_code=409, detail={"error": {"code": "conflict", "message": "Username already taken", "request_id": req_id}})
|
|
|
|
user_id = str(uuid.uuid4())
|
|
created_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
|
|
user_obj = {
|
|
"id": user_id,
|
|
"username": body.username,
|
|
"display_name": body.display_name,
|
|
"created_at": created_at
|
|
}
|
|
USERS[user_id] = user_obj
|
|
return user_obj
|
|
|
|
def get_current_user(x_user_id: Optional[str] = Header(None)) -> dict:
|
|
if not x_user_id or x_user_id not in USERS:
|
|
raise HTTPException(status_code=401, detail="Invalid or missing user identification")
|
|
return USERS[x_user_id]
|
|
|
|
@app.get("/api/v1/users/me")
|
|
def current_user(response: Response, x_user_id: Optional[str] = Header(None)):
|
|
req_id = generate_request_id()
|
|
response.headers["X-Request-Id"] = req_id
|
|
return get_current_user(x_user_id)
|
|
|
|
@app.post("/api/v1/chats", status_code=201)
|
|
def create_chat(body: CreateChat, response: Response, x_user_id: Optional[str] = Header(None)):
|
|
req_id = generate_request_id()
|
|
response.headers["X-Request-Id"] = req_id
|
|
user = get_current_user(x_user_id)
|
|
|
|
member_ids_str = [str(mid) for mid in body.member_ids]
|
|
|
|
if user["id"] not in member_ids_str:
|
|
raise HTTPException(status_code=400, detail="Caller must be in member_ids")
|
|
if len(member_ids_str) != len(set(member_ids_str)):
|
|
raise HTTPException(status_code=400, detail="Duplicate member IDs")
|
|
for mid_str in member_ids_str:
|
|
if mid_str not in USERS:
|
|
raise HTTPException(status_code=400, detail=f"User {mid_str} not found")
|
|
|
|
chat_id = str(uuid.uuid4())
|
|
created_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
|
|
chat_obj = {
|
|
"id": chat_id,
|
|
"title": body.title,
|
|
"member_ids": member_ids_str,
|
|
"created_at": created_at
|
|
}
|
|
CHATS[chat_id] = chat_obj
|
|
MESSAGES[chat_id] = []
|
|
return chat_obj
|
|
|
|
@app.get("/api/v1/chats")
|
|
def list_chats(limit: int = 50, cursor: Optional[str] = None, response: Response = None, x_user_id: Optional[str] = Header(None)):
|
|
req_id = generate_request_id()
|
|
response.headers["X-Request-Id"] = req_id
|
|
user = get_current_user(x_user_id)
|
|
|
|
if limit < 1 or limit > 100:
|
|
raise HTTPException(status_code=400, detail="Invalid limit")
|
|
|
|
user_chats = [c for c in CHATS.values() if user["id"] in c["member_ids"]]
|
|
user_chats.sort(key=lambda x: (x["created_at"], x["id"]))
|
|
|
|
start_idx = 0
|
|
if cursor:
|
|
try:
|
|
parts = cursor.split("_")
|
|
if len(parts) < 2:
|
|
raise ValueError("Malformed cursor")
|
|
c_time, c_id = parts[0], parts[1]
|
|
|
|
found = False
|
|
for idx, c in enumerate(user_chats):
|
|
if (c["created_at"], c["id"]) > (c_time, c_id):
|
|
start_idx = idx
|
|
found = True
|
|
break
|
|
if (c["created_at"], c["id"]) == (c_time, c_id):
|
|
start_idx = idx + 1
|
|
found = True
|
|
break
|
|
if not found:
|
|
raise HTTPException(status_code=400, detail="Invalid or foreign cursor")
|
|
except HTTPException:
|
|
raise
|
|
except Exception:
|
|
raise HTTPException(status_code=400, detail="Invalid cursor format")
|
|
|
|
page_items = user_chats[start_idx:start_idx + limit]
|
|
next_cursor = None
|
|
if start_idx + limit < len(user_chats):
|
|
last = page_items[-1]
|
|
next_cursor = f"{last['created_at']}_{last['id']}"
|
|
|
|
return {"items": page_items, "next_cursor": next_cursor}
|
|
|
|
@app.get("/api/v1/chats/{chat_id}")
|
|
def get_chat(chat_id: UUID, response: Response, x_user_id: Optional[str] = Header(None)):
|
|
req_id = generate_request_id()
|
|
response.headers["X-Request-Id"] = req_id
|
|
user = get_current_user(x_user_id)
|
|
|
|
chat = CHATS.get(str(chat_id))
|
|
if not chat or user["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)
|
|
def create_message(chat_id: UUID, body: CreateMessage, response: Response, x_user_id: Optional[str] = Header(None)):
|
|
req_id = generate_request_id()
|
|
response.headers["X-Request-Id"] = req_id
|
|
user = get_current_user(x_user_id)
|
|
|
|
chat_id_str = str(chat_id)
|
|
chat = CHATS.get(chat_id_str)
|
|
if not chat or user["id"] not in chat["member_ids"]:
|
|
raise HTTPException(status_code=404, detail="Chat not found")
|
|
|
|
msg_id = str(uuid.uuid4())
|
|
created_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
|
|
msg_obj = {
|
|
"id": msg_id,
|
|
"chat_id": chat_id_str,
|
|
"sender_id": user["id"],
|
|
"text": body.text,
|
|
"created_at": created_at
|
|
}
|
|
|
|
if chat_id_str not in MESSAGES:
|
|
MESSAGES[chat_id_str] = []
|
|
MESSAGES[chat_id_str].append(msg_obj)
|
|
|
|
return msg_obj
|
|
|
|
@app.get("/api/v1/chats/{chat_id}/messages")
|
|
def list_messages(chat_id: UUID, limit: int = 50, cursor: Optional[str] = None, response: Response = None, x_user_id: Optional[str] = Header(None)):
|
|
req_id = generate_request_id()
|
|
response.headers["X-Request-Id"] = req_id
|
|
user = get_current_user(x_user_id)
|
|
|
|
chat_id_str = str(chat_id)
|
|
chat = CHATS.get(chat_id_str)
|
|
if not chat or user["id"] not in chat["member_ids"]:
|
|
raise HTTPException(status_code=404, detail="Chat not found")
|
|
|
|
if limit < 1 or limit > 100:
|
|
raise HTTPException(status_code=400, detail="Invalid limit")
|
|
|
|
msgs = MESSAGES.get(chat_id_str, [])
|
|
msgs.sort(key=lambda x: (x["created_at"], x["id"]))
|
|
|
|
start_idx = 0
|
|
if cursor:
|
|
try:
|
|
parts = cursor.split("_")
|
|
if len(parts) < 2:
|
|
raise ValueError("Malformed cursor")
|
|
c_time, c_id = parts[0], parts[1]
|
|
|
|
found = False
|
|
for idx, m in enumerate(msgs):
|
|
if (m["created_at"], m["id"]) > (c_time, c_id):
|
|
start_idx = idx
|
|
found = True
|
|
break
|
|
if (m["created_at"], m["id"]) == (c_time, c_id):
|
|
start_idx = idx + 1
|
|
found = True
|
|
break
|
|
if not found:
|
|
raise HTTPException(status_code=400, detail="Invalid or foreign cursor")
|
|
except HTTPException:
|
|
raise
|
|
except Exception:
|
|
raise HTTPException(status_code=400, detail="Invalid cursor format")
|
|
|
|
page_items = msgs[start_idx:start_idx + limit]
|
|
next_cursor = None
|
|
if start_idx + limit < len(msgs):
|
|
last = page_items[-1]
|
|
next_cursor = f"{last['created_at']}_{last['id']}"
|
|
|
|
return {"items": page_items, "next_cursor": next_cursor} |