Files
mtusi2026lab4/app.py
T
2026-11-09 23:42:13 +03:00

913 lines
33 KiB
Python

import os
import base64
import secrets
import uuid
import json
import re
import struct
import hashlib
import hmac
from datetime import datetime, timezone, timedelta
from typing import List, Optional
from uuid import UUID
import psycopg2
import psycopg2.extras
psycopg2.extras.register_uuid()
import bcrypt
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, model_validator, ConfigDict
import redis
import boto3
from botocore.client import Config
app = FastAPI(title="MTUSI Messenger — lab4", version="1.4.0")
DATABASE_URL = os.getenv("DATABASE_URL", "postgresql://postgres:postgres@postgres:5432/messenger")
SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
INSTANCE_ID = os.getenv("INSTANCE_ID", "instance-1")
REDIS_URL = os.getenv("REDIS_URL", "redis://redis:6379/0")
redis_client = redis.Redis.from_url(REDIS_URL, decode_responses=True)
SECRET_HMAC_KEY = os.environ["SECRET_HMAC_KEY"]
S3_ENDPOINT = os.getenv("S3_ENDPOINT", "http://s3:8333")
S3_BUCKET = os.getenv("S3_BUCKET", "messenger-attachments")
S3_ACCESS_KEY = os.getenv("S3_ACCESS_KEY_ID", "minioadmin")
S3_SECRET_KEY = os.getenv("S3_SECRET_ACCESS_KEY", "minioadminpassword")
s3_client = boto3.client(
"s3",
endpoint_url=S3_ENDPOINT,
aws_access_key_id=S3_ACCESS_KEY,
aws_secret_access_key=S3_SECRET_KEY,
config=Config(signature_version="s3v4"),
region_name="us-east-1"
)
def get_db_connection():
conn = psycopg2.connect(DATABASE_URL, cursor_factory=psycopg2.extras.RealDictCursor)
return conn
def generate_request_id() -> str:
return uuid.uuid4().hex
def make_error_response(
status_code: int,
code: str,
message: str,
req_id: str,
extra_headers: Optional[dict] = None,
) -> JSONResponse:
headers = {"X-Request-Id": req_id, "X-Instance-Id": INSTANCE_ID}
if extra_headers:
headers.update(extra_headers)
return JSONResponse(
status_code=status_code,
headers=headers,
content={
"error": {
"code": code,
"message": message,
"request_id": req_id,
}
},
)
def encode_cursor(chat_id: str, created_at: str, msg_id: str) -> str:
payload = f"{chat_id}|{created_at}|{msg_id}"
signature = hmac.new(SECRET_HMAC_KEY.encode(), payload.encode(), hashlib.sha256).hexdigest()[:16]
raw = f"{payload}|{signature}"
return base64.urlsafe_b64encode(raw.encode()).decode()
def decode_cursor(cursor: str, expected_chat_id: str) -> tuple:
try:
decoded = base64.urlsafe_b64decode(cursor.encode()).decode()
parts = decoded.split("|")
if len(parts) != 4:
raise ValueError()
chat_id, created_at, msg_id, signature = parts
if chat_id != expected_chat_id:
raise HTTPException(status_code=400, detail="Cursor belongs to another chat")
expected_sig = hmac.new(SECRET_HMAC_KEY.encode(), f"{chat_id}|{created_at}|{msg_id}".encode(), hashlib.sha256).hexdigest()[:16]
if not hmac.compare_digest(signature, expected_sig):
raise ValueError()
return created_at, msg_id
except HTTPException:
raise
except Exception:
raise HTTPException(status_code=400, detail="Invalid cursor format")
@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(
status_code=400,
code="invalid_request",
message="Validation error in request body or parameters",
req_id=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()
headers = {"X-Request-Id": req_id, "X-Instance-Id": INSTANCE_ID}
if exc.headers:
headers.update(exc.headers)
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=headers, content=detail)
code_map = {
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",
}
return JSONResponse(
status_code=exc.status_code,
headers=headers,
content={
"error": {
"code": code_map.get(exc.status_code, "internal_error"),
"message": str(detail),
"request_id": req_id,
}
},
)
@app.exception_handler(Exception)
async def unhandled_exception_handler(request: Request, exc: Exception):
req_id = request.headers.get("X-Request-Id") or generate_request_id()
return make_error_response(
status_code=500,
code="internal_error",
message="Internal server error",
req_id=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)
password: str = Field(..., min_length=12, max_length=128)
@field_validator("display_name", "password")
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(default="", max_length=4000)
attachment_ids: List[uuid.UUID] = Field(default=[], max_items=10)
@model_validator(mode="after")
def check_content(self) -> 'CreateMessage':
if not self.text.strip() and not self.attachment_ids:
raise ValueError("Message must contain either text or attachments")
return self
@app.get("/health/live")
def health_live(response: Response):
req_id = generate_request_id()
response.headers["X-Request-Id"] = req_id
response.headers["X-Instance-Id"] = INSTANCE_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
response.headers["X-Instance-Id"] = INSTANCE_ID
try:
conn = get_db_connection()
conn.close()
redis_client.ping()
s3_client.head_bucket(Bucket=S3_BUCKET)
except Exception:
raise HTTPException(status_code=503, detail="Database, Redis or S3 unavailable")
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
response.headers["X-Instance-Id"] = INSTANCE_ID
password_hash = bcrypt.hashpw(body.password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
user_id = str(uuid.uuid4())
created_at = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
conn = get_db_connection()
try:
with conn.cursor() as cur:
cur.execute(
"INSERT INTO users (id, username, display_name, password_hash, created_at) VALUES (%s, %s, %s, %s, %s)",
(user_id, body.username, body.display_name, password_hash, created_at)
)
conn.commit()
except psycopg2.errors.UniqueViolation:
conn.rollback()
raise HTTPException(status_code=409, detail={"error": {"code": "conflict", "message": "Username already taken", "request_id": req_id}})
finally:
conn.close()
return {
"id": user_id,
"username": body.username,
"display_name": body.display_name,
"created_at": created_at
}
@app.post("/api/v1/auth/sessions", status_code=201)
def create_session(authorization: Optional[str] = Header(None), response: Response = None):
req_id = generate_request_id()
response.headers["X-Request-Id"] = req_id
response.headers["X-Instance-Id"] = INSTANCE_ID
if not authorization or not authorization.startswith("Basic "):
raise HTTPException(
status_code=401,
detail="Missing or invalid basic auth",
headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}
)
try:
encoded = authorization.split(" ")[1]
decoded = base64.b64decode(encoded).decode("utf-8")
username, password = decoded.split(":", 1)
except Exception:
raise HTTPException(
status_code=401,
detail="Invalid credentials format",
headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}
)
conn = get_db_connection()
with conn.cursor() as cur:
cur.execute("SELECT * FROM users WHERE username = %s", (username,))
user = cur.fetchone()
if not user or not bcrypt.checkpw(password.encode('utf-8'), user['password_hash'].encode('utf-8')):
conn.close()
raise HTTPException(
status_code=401,
detail="Invalid credentials",
headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}
)
token = secrets.token_urlsafe(48)
redis_client.setex(f"session:{token}", SESSION_TTL_SECONDS, str(user['id']))
expires_at = datetime.now(timezone.utc) + timedelta(seconds=SESSION_TTL_SECONDS)
expires_at_str = expires_at.isoformat().replace("+00:00", "Z")
return {
"token": token,
"token_type": "Bearer",
"expires_at": expires_at_str,
"user": {
"id": user['id'],
"username": user['username'],
"display_name": user['display_name'],
"created_at": user['created_at'].isoformat().replace("+00:00", "Z") if isinstance(user['created_at'], datetime) else user['created_at']
}
}
def get_current_user_from_token(authorization: Optional[str] = Header(None)) -> dict:
if not authorization or not authorization.startswith("Bearer "):
raise HTTPException(
status_code=401,
detail="Missing or invalid bearer token",
headers={"WWW-Authenticate": 'Bearer realm="messenger"'}
)
token = authorization.split(" ")[1]
try:
user_id = redis_client.get(f"session:{token}")
except Exception:
raise HTTPException(status_code=503, detail="Session store unavailable")
if not user_id:
raise HTTPException(
status_code=401,
detail="Invalid or expired session token",
headers={"WWW-Authenticate": 'Bearer realm="messenger"'}
)
conn = get_db_connection()
with conn.cursor() as cur:
cur.execute("SELECT * FROM users WHERE id = %s", (user_id,))
row = cur.fetchone()
conn.close()
if not row:
raise HTTPException(
status_code=401,
detail="User not found",
headers={"WWW-Authenticate": 'Bearer realm="messenger"'}
)
return {
"id": str(row['id']),
"username": row['username'],
"display_name": row['display_name'],
"created_at": row['created_at'].isoformat().replace("+00:00", "Z") if isinstance(row['created_at'], datetime) else row['created_at']
}
@app.delete("/api/v1/auth/sessions/current", status_code=204)
def revoke_session(authorization: Optional[str] = Header(None)):
req_id = generate_request_id()
if not authorization or not authorization.startswith("Bearer "):
raise HTTPException(
status_code=401,
detail="Unauthorized",
headers={"WWW-Authenticate": 'Bearer realm="messenger"'}
)
token = authorization.split(" ")[1]
deleted = redis_client.delete(f"session:{token}")
if not deleted:
raise HTTPException(
status_code=401,
detail="Invalid session token",
headers={"WWW-Authenticate": 'Bearer realm="messenger"'}
)
return Response(
status_code=204,
headers={
"X-Request-Id": req_id,
"X-Instance-Id": INSTANCE_ID
},
)
@app.get("/api/v1/users/me")
def current_user(response: Response, authorization: Optional[str] = Header(None)):
req_id = generate_request_id()
response.headers["X-Request-Id"] = req_id
response.headers["X-Instance-Id"] = INSTANCE_ID
return get_current_user_from_token(authorization)
@app.post("/api/v1/chats", status_code=201)
def create_chat(body: CreateChat, response: Response, authorization: Optional[str] = Header(None)):
req_id = generate_request_id()
response.headers["X-Request-Id"] = req_id
response.headers["X-Instance-Id"] = INSTANCE_ID
user = get_current_user_from_token(authorization)
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")
conn = get_db_connection()
with conn.cursor() as cur:
for mid_str in member_ids_str:
cur.execute("SELECT id FROM users WHERE id = %s", (mid_str,))
if not cur.fetchone():
conn.close()
raise HTTPException(status_code=400, detail=f"User {mid_str} not found")
chat_id = str(uuid.uuid4())
created_at = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
try:
with conn.cursor() as cur:
cur.execute(
"INSERT INTO chats (id, title, created_at) VALUES (%s, %s, %s)",
(chat_id, body.title, created_at)
)
for mid_str in member_ids_str:
cur.execute(
"INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)",
(chat_id, mid_str)
)
conn.commit()
except Exception:
conn.rollback()
conn.close()
raise HTTPException(status_code=500, detail="Internal error creating chat")
conn.close()
return {
"id": chat_id,
"title": body.title,
"member_ids": member_ids_str,
"created_at": created_at
}
@app.get("/api/v1/chats")
def list_chats(limit: int = 50, cursor: Optional[str] = None, response: Response = None, authorization: Optional[str] = Header(None)):
req_id = generate_request_id()
response.headers["X-Request-Id"] = req_id
response.headers["X-Instance-Id"] = INSTANCE_ID
user = get_current_user_from_token(authorization)
if limit < 1 or limit > 100:
raise HTTPException(status_code=400, detail="Invalid limit")
conn = get_db_connection()
with conn.cursor() as cur:
cur.execute("""
SELECT c.id, c.title, c.created_at FROM chats c
JOIN chat_members cm ON c.id = cm.chat_id
WHERE cm.user_id = %s
ORDER BY c.created_at ASC, c.id ASC
""", (user["id"],))
rows = cur.fetchall()
conn.close()
user_chats = []
for r in rows:
conn = get_db_connection()
with conn.cursor() as cur:
cur.execute("SELECT user_id FROM chat_members WHERE chat_id = %s", (r['id'],))
m_rows = cur.fetchall()
conn.close()
user_chats.append({
"id": r['id'],
"title": r['title'],
"member_ids": [m['user_id'] for m in m_rows],
"created_at": r['created_at'].isoformat().replace("+00:00", "Z") if isinstance(r['created_at'], datetime) else r['created_at']
})
start_idx = 0
if cursor:
try:
parts = cursor.split("_")
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 if (c["created_at"], c["id"]) > (c_time, c_id) else idx + 1
found = True
break
if not found:
start_idx = len(user_chats)
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, authorization: Optional[str] = Header(None)):
req_id = generate_request_id()
response.headers["X-Request-Id"] = req_id
response.headers["X-Instance-Id"] = INSTANCE_ID
user = get_current_user_from_token(authorization)
chat_id_str = str(chat_id)
conn = get_db_connection()
with conn.cursor() as cur:
cur.execute("""
SELECT c.* FROM chats c
JOIN chat_members cm ON c.id = cm.chat_id
WHERE c.id = %s AND cm.user_id = %s
""", (chat_id_str, user["id"]))
chat = cur.fetchone()
if chat:
cur.execute("SELECT user_id FROM chat_members WHERE chat_id = %s", (chat_id_str,))
members = cur.fetchall()
conn.close()
if not chat:
raise HTTPException(status_code=404, detail="Chat not found")
return {
"id": chat['id'],
"title": chat['title'],
"member_ids": [m['user_id'] for m in members],
"created_at": chat['created_at'].isoformat().replace("+00:00", "Z") if isinstance(chat['created_at'], datetime) else chat['created_at']
}
def validate_image_and_get_dimensions(data: bytes, content_type: str):
if len(data) > 10 * 1024 * 1024:
raise HTTPException(status_code=413, detail="Payload too large (>10 MiB)")
width, height = 0, 0
if content_type == "image/png":
if not data.startswith(b'\x89PNG\r\n\x1a\n'):
raise HTTPException(status_code=415, detail="Invalid PNG signature")
if len(data) < 33:
raise HTTPException(status_code=415, detail="Truncated PNG")
if data[12:16] != b'IHDR':
raise HTTPException(status_code=415, detail="PNG missing IHDR chunk")
ihdr_len = struct.unpack('>I', data[8:12])[0]
if ihdr_len != 13:
raise HTTPException(status_code=415, detail="Invalid IHDR length")
width, height = struct.unpack('>II', data[16:24])
elif content_type == "image/jpeg":
if not data.startswith(b'\xff\xd8'):
raise HTTPException(status_code=415, detail="Invalid JPEG signature")
i = 2
while i < len(data) - 9:
marker = data[i]
if marker == 0xff:
marker_type = data[i+1]
if 0xc0 <= marker_type <= 0xc3:
height, width = struct.unpack('>HH', data[i+5:i+9])
break
i += 2 + struct.unpack('>H', data[i+2:i+4])[0]
else:
i += 1
else:
raise HTTPException(status_code=415, detail="Unsupported media type")
if width == 0 or height == 0:
raise HTTPException(status_code=415, detail="Could not read image dimensions")
if width * height > 40_000_000:
raise HTTPException(status_code=413, detail="Image exceeds 40 million pixels limit")
@app.post("/api/v1/chats/{chat_id}/attachments", status_code=201)
async def upload_attachment(
chat_id: UUID,
filename: str = Query(..., min_length=1, max_length=255),
request: Request = None,
response: Response = None,
authorization: Optional[str] = Header(None)
):
req_id = generate_request_id()
response.headers["X-Request-Id"] = req_id
response.headers["X-Instance-Id"] = INSTANCE_ID
user = get_current_user_from_token(authorization)
chat_id_str = str(chat_id)
conn = get_db_connection()
with conn.cursor() as cur:
cur.execute("SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", (chat_id_str, user["id"]))
if not cur.fetchone():
conn.close()
raise HTTPException(status_code=404, detail="Chat not found or inaccessible")
conn.close()
if any(ord(c) < 0x20 or ord(c) == 0x7f for c in filename) or '/' in filename or '\\' in filename:
raise HTTPException(400, "Invalid filename")
content_type = request.headers.get("content-type")
if content_type not in ["image/png", "image/jpeg"]:
raise HTTPException(status_code=415, detail="Unsupported media type")
MAX_UPLOAD = 10 * 1024 * 1024
cl = request.headers.get("content-length")
if cl is not None:
try:
if int(cl) > MAX_UPLOAD:
raise HTTPException(status_code=413, detail="Payload too large (>10 MiB)")
except ValueError:
raise HTTPException(status_code=400, detail="Invalid Content-Length")
chunks = []
total = 0
async for chunk in request.stream():
total += len(chunk)
if total > MAX_UPLOAD:
raise HTTPException(status_code=413, detail="Payload too large (>10 MiB)")
chunks.append(chunk)
body_bytes = b"".join(chunks)
validate_image_and_get_dimensions(body_bytes, content_type)
size_bytes = len(body_bytes)
sha256_hash = hashlib.sha256(body_bytes).hexdigest()
attachment_id = str(uuid.uuid4())
now = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
s3_key = f"attachments/{chat_id_str}/{attachment_id}/{filename}"
conn = get_db_connection()
try:
with conn.cursor() as cur:
cur.execute("""
INSERT INTO attachments (id, chat_id, owner_id, filename, content_type, size_bytes, sha256, status, variants, error_code, created_at, updated_at)
VALUES (%s, %s, %s, %s, %s, %s, %s, 'pending', '[]', NULL, %s, %s)
""", (attachment_id, chat_id_str, user["id"], filename, content_type, size_bytes, sha256_hash, now, now))
conn.commit()
except Exception:
conn.rollback()
conn.close()
raise HTTPException(status_code=500, detail="Internal error initializing attachment")
finally:
if not conn.closed:
conn.close()
try:
s3_client.put_object(
Bucket=S3_BUCKET,
Key=s3_key,
Body=body_bytes,
ContentType=content_type
)
except Exception:
raise HTTPException(status_code=503, detail="S3 storage unavailable")
conn = get_db_connection()
try:
with conn.cursor() as cur:
cur.execute("""
UPDATE attachments SET status = 'ready', updated_at = %s WHERE id = %s
""", (now, attachment_id))
conn.commit()
except Exception:
conn.rollback()
raise HTTPException(status_code=500, detail="Internal error finalizing attachment status")
finally:
if not conn.closed:
conn.close()
return {
"id": attachment_id,
"chat_id": chat_id_str,
"owner_id": user["id"],
"filename": filename,
"content_type": content_type,
"size_bytes": size_bytes,
"sha256": sha256_hash,
"status": "ready",
"variants": [],
"error_code": None,
"created_at": now,
"updated_at": now
}
@app.get("/api/v1/attachments/{attachment_id}")
def get_attachment(attachment_id: UUID, response: Response, authorization: Optional[str] = Header(None)):
req_id = generate_request_id()
response.headers["X-Request-Id"] = req_id
response.headers["X-Instance-Id"] = INSTANCE_ID
user = get_current_user_from_token(authorization)
att_id_str = str(attachment_id)
conn = get_db_connection()
with conn.cursor() as cur:
cur.execute("""
SELECT a.* FROM attachments a
JOIN chat_members cm ON a.chat_id = cm.chat_id
WHERE a.id = %s AND cm.user_id = %s
""", (att_id_str, user["id"]))
row = cur.fetchone()
conn.close()
if not row:
raise HTTPException(status_code=404, detail="Attachment not found or inaccessible")
return {
"id": str(row['id']),
"chat_id": str(row['chat_id']),
"owner_id": str(row['owner_id']),
"filename": row['filename'],
"content_type": row['content_type'],
"size_bytes": row['size_bytes'],
"sha256": row['sha256'],
"status": row['status'],
"variants": row['variants'],
"error_code": row['error_code'],
"created_at": row['created_at'].isoformat().replace("+00:00", "Z") if isinstance(row['created_at'], datetime) else row['created_at'],
"updated_at": row['updated_at'].isoformat().replace("+00:00", "Z") if isinstance(row['updated_at'], datetime) else row['updated_at']
}
@app.get("/api/v1/attachments/{attachment_id}/content")
def download_attachment(attachment_id: UUID, response: Response, authorization: Optional[str] = Header(None)):
req_id = generate_request_id()
response.headers["X-Request-Id"] = req_id
response.headers["X-Instance-Id"] = INSTANCE_ID
user = get_current_user_from_token(authorization)
att_id_str = str(attachment_id)
conn = get_db_connection()
with conn.cursor() as cur:
cur.execute("""
SELECT a.* FROM attachments a
JOIN chat_members cm ON a.chat_id = cm.chat_id
WHERE a.id = %s AND cm.user_id = %s
""", (att_id_str, user["id"]))
row = cur.fetchone()
conn.close()
if not row:
raise HTTPException(status_code=404, detail="Attachment not found or inaccessible")
if row['status'] != 'ready':
raise HTTPException(status_code=409, detail="Attachment not ready")
s3_key = f"attachments/{row['chat_id']}/{row['id']}/{row['filename']}"
try:
obj = s3_client.get_object(Bucket=S3_BUCKET, Key=s3_key)
data = obj['Body'].read()
except Exception:
raise HTTPException(status_code=503, detail="S3 storage unavailable or object missing")
return Response(
content=data,
media_type=row['content_type'],
headers={
"X-Request-Id": req_id,
"X-Instance-Id": INSTANCE_ID,
},
)
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
def create_message(
chat_id: UUID,
body: CreateMessage,
response: Response,
authorization: Optional[str] = Header(None),
idempotency_key: Optional[str] = Header(None, alias="Idempotency-Key")
):
req_id = generate_request_id()
response.headers["X-Request-Id"] = req_id
response.headers["X-Instance-Id"] = INSTANCE_ID
user = get_current_user_from_token(authorization)
if not idempotency_key or not re.match(r"^[A-Za-z0-9._:-]{1,128}$", idempotency_key):
raise HTTPException(status_code=400, detail="Missing or invalid Idempotency-Key")
chat_id_str = str(chat_id)
method = "POST"
path = f"/api/v1/chats/{chat_id_str}/messages"
body_json_str = json.dumps(body.model_dump(mode='json'), sort_keys=True)
request_hash = hashlib.sha256(body_json_str.encode("utf-8")).hexdigest()
conn = get_db_connection()
try:
with conn.cursor() as cur:
cur.execute(
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
(chat_id_str, user["id"])
)
if not cur.fetchone():
conn.close()
raise HTTPException(status_code=404, detail="Chat not found")
attachment_ids_str = [str(aid) for aid in body.attachment_ids]
if attachment_ids_str:
cur.execute("""
SELECT id, status FROM attachments
WHERE id = ANY(%s::uuid[]) AND chat_id = %s
""", (attachment_ids_str, chat_id_str))
found_atts = cur.fetchall()
if len(found_atts) != len(attachment_ids_str):
conn.close()
raise HTTPException(status_code=404, detail="One or more attachments not found or in another chat")
for att in found_atts:
if att['status'] == 'failed':
conn.close()
raise HTTPException(status_code=409, detail="Cannot attach failed attachment")
msg_id = str(uuid.uuid4())
created_at = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
msg_response = {
"id": msg_id,
"chat_id": chat_id_str,
"sender_id": user["id"],
"text": body.text,
"created_at": created_at,
"attachment_ids": attachment_ids_str
}
cur.execute("""
INSERT INTO idempotency_keys (user_id, method, path, key, request_hash, response_status, response_body)
VALUES (%s, %s, %s, %s, %s, %s, %s)
ON CONFLICT (user_id, method, path, key) DO NOTHING
""", (user["id"], method, path, idempotency_key, request_hash, 201, json.dumps(msg_response)))
if cur.rowcount == 0:
cur.execute("""
SELECT request_hash, response_status, response_body
FROM idempotency_keys
WHERE user_id = %s AND method = %s AND path = %s AND key = %s
""", (user["id"], method, path, idempotency_key))
row = cur.fetchone()
conn.commit()
conn.close()
if row["request_hash"] != request_hash:
raise HTTPException(status_code=409, detail="Idempotency key conflict with different payload")
return row["response_body"]
cur.execute(
"INSERT INTO messages (id, chat_id, sender_id, text, created_at, attachment_ids) VALUES (%s, %s, %s, %s, %s, %s::uuid[])",
(msg_id, chat_id_str, user["id"], body.text, created_at, attachment_ids_str)
)
conn.commit()
except HTTPException:
raise
except Exception as exc:
conn.rollback()
conn.close()
raise HTTPException(status_code=500, detail="Internal error processing message")
finally:
if not conn.closed:
conn.close()
return msg_response
@app.get("/api/v1/chats/{chat_id}/messages")
def list_messages(chat_id: UUID, limit: int = 50, cursor: Optional[str] = None, response: Response = None, authorization: Optional[str] = Header(None)):
req_id = generate_request_id()
response.headers["X-Request-Id"] = req_id
response.headers["X-Instance-Id"] = INSTANCE_ID
user = get_current_user_from_token(authorization)
chat_id_str = str(chat_id)
conn = get_db_connection()
with conn.cursor() as cur:
cur.execute(
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
(chat_id_str, user["id"])
)
if not cur.fetchone():
conn.close()
raise HTTPException(status_code=404, detail="Chat not found")
if limit < 1 or limit > 100:
conn.close()
raise HTTPException(status_code=400, detail="Invalid limit")
query = """
SELECT id, chat_id, sender_id, text, created_at, attachment_ids FROM messages
WHERE chat_id = %s
"""
params = [chat_id_str]
if cursor:
c_time, c_id = decode_cursor(cursor, chat_id_str)
query += " AND (created_at, id) > (%s, %s)"
params.extend([c_time, c_id])
query += " ORDER BY created_at ASC, id ASC LIMIT %s"
params.append(limit + 1)
with conn.cursor() as cur:
cur.execute(query, tuple(params))
rows = cur.fetchall()
conn.close()
has_next = len(rows) > limit
page_items = rows[:limit]
formatted_msgs = []
for m in page_items:
raw_atts = m.get('attachment_ids')
atts = []
if raw_atts:
for aid in raw_atts:
if aid:
atts.append(str(aid))
formatted_msgs.append({
"id": m['id'],
"chat_id": m['chat_id'],
"sender_id": m['sender_id'],
"text": m['text'],
"created_at": m['created_at'].isoformat().replace("+00:00", "Z") if isinstance(m['created_at'], datetime) else m['created_at'],
"attachment_ids": atts
})
next_cursor = None
if has_next and formatted_msgs:
last = formatted_msgs[-1]
next_cursor = encode_cursor(chat_id_str, last['created_at'], last['id'])
return {"items": formatted_msgs, "next_cursor": next_cursor}