Реализовать лабораторную работу 2

This commit is contained in:
2026-10-18 15:53:16 +03:00
parent 65003b6119
commit be7a90132b
48 changed files with 1921 additions and 23 deletions
View File
+42
View File
@@ -0,0 +1,42 @@
from fastapi import Request
from app.core.errors import ApiError
from app.repositories.memory import SessionRow, UserRow
import uuid as _uuid
BEARER_CHALLENGE = {'WWW-Authenticate': 'Bearer realm="messenger"'}
def storage_of(request: Request):
return request.app.state.storage
async def current_session(request: Request) -> SessionRow:
header = request.headers.get('authorization', '')
token = header[7:].strip() if header[:7].lower() == 'bearer ' else ''
if not token:
raise ApiError(401, 'Bearer session required', headers=BEARER_CHALLENGE)
row = await storage_of(request).session(token)
if row is None:
raise ApiError(401, 'Session is missing, expired or revoked', headers=BEARER_CHALLENGE)
return row
async def current_user(request: Request) -> UserRow:
session = await current_session(request)
user = await storage_of(request).user(session.user_id)
if user is None:
raise ApiError(401, 'Session user no longer exists', headers=BEARER_CHALLENGE)
return user
async def require_chat_member(request: Request, chat_id: str, user: UserRow):
try:
_uuid.UUID(chat_id)
except ValueError:
raise ApiError(400, 'chat_id must be a UUID')
row = await storage_of(request).chat(chat_id)
if row is None or user.id not in row.member_ids:
raise ApiError(404, 'Chat is not available for this user')
return row
View File
+31
View File
@@ -0,0 +1,31 @@
from fastapi import APIRouter, Request
from fastapi.responses import Response
from app.api.deps import current_session
from app.api.serialize import user_out
from app.core.config import settings
from app.core.errors import ApiError
from app.core.security import parse_basic, verify_password
from app.repositories.memory import iso_z
router = APIRouter()
BASIC_CHALLENGE = {'WWW-Authenticate': 'Basic realm="messenger", charset="UTF-8"'}
@router.post('/api/v1/auth/sessions', status_code=201)
async def login(request: Request):
creds = parse_basic(request.headers.get('authorization', ''))
storage = request.app.state.storage
row = await storage.user_by_username(creds[0]) if creds else None
if creds is None or row is None or not verify_password(row.password_hash, creds[1]):
raise ApiError(401, 'Invalid credentials', headers=BASIC_CHALLENGE)
session = await storage.create_session(row.id, settings.session_ttl_seconds)
return {'token': session.token, 'token_type': 'Bearer',
'expires_at': iso_z(session.expires_at), 'user': user_out(row)}
@router.delete('/api/v1/auth/sessions/current', status_code=204)
async def logout(request: Request):
session = await current_session(request)
await request.app.state.storage.revoke(session.token)
return Response(status_code=204)
+33
View File
@@ -0,0 +1,33 @@
from fastapi import APIRouter, Query, Request
from app.api.deps import current_user, require_chat_member
from app.api.serialize import chat_out
from app.core.cursors import decode_cursor, paginate
from app.schemas import CreateChat
router = APIRouter()
@router.post('/api/v1/chats', status_code=201)
async def create_chat(body: CreateChat, request: Request):
user = await current_user(request)
member_ids = [str(mid) for mid in body.member_ids]
row = await request.app.state.storage.create_chat(body.title, member_ids, user.id)
return chat_out(row)
@router.get('/api/v1/chats')
async def list_chats(request: Request, limit: int = Query(50, ge=1, le=100),
cursor: str | None = Query(None, min_length=1)):
user = await current_user(request)
resource = 'chats:' + user.id
key = decode_cursor(cursor, resource) if cursor else None
rows = await request.app.state.storage.chats_of(user.id)
page, next_cursor = paginate(rows, key, limit, resource)
return {'items': [chat_out(r) for r in page], 'next_cursor': next_cursor}
@router.get('/api/v1/chats/{chat_id}')
async def get_chat(chat_id: str, request: Request):
user = await current_user(request)
return chat_out(await require_chat_member(request, chat_id, user))
+17
View File
@@ -0,0 +1,17 @@
from fastapi import APIRouter, Request
from app.core.errors import ApiError
router = APIRouter()
@router.get('/health/live')
async def live():
return {'status': 'ok'}
@router.get('/health/ready')
async def ready(request: Request):
if not await request.app.state.storage.ready():
raise ApiError(503, 'Storage is unavailable')
return {'status': 'ok'}
+11
View File
@@ -0,0 +1,11 @@
from fastapi import APIRouter, Request
from app.api.deps import current_user
from app.api.serialize import user_out
router = APIRouter()
@router.get('/api/v1/users/me')
async def me(request: Request):
return user_out(await current_user(request))
+32
View File
@@ -0,0 +1,32 @@
from fastapi import APIRouter, Query, Request
from app.api.deps import current_user, require_chat_member
from app.api.serialize import message_out
from app.core.cursors import decode_cursor, encode_cursor
from app.schemas import CreateMessage
router = APIRouter()
@router.post('/api/v1/chats/{chat_id}/messages', status_code=201)
async def create_message(body: CreateMessage, chat_id: str, request: Request):
user = await current_user(request)
chat = await require_chat_member(request, chat_id, user)
row = await request.app.state.storage.add_message(chat.id, user.id, body.text)
return message_out(row)
@router.get('/api/v1/chats/{chat_id}/messages')
async def list_messages(request: Request, chat_id: str,
limit: int = Query(50, ge=1, le=100),
cursor: str | None = Query(None, min_length=1)):
user = await current_user(request)
chat = await require_chat_member(request, chat_id, user)
resource = 'messages:' + chat.id
key = decode_cursor(cursor, resource) if cursor else None
rows, has_more = await request.app.state.storage.messages_page(chat.id, key, limit)
next_cursor = (
encode_cursor(resource, rows[-1].created_at, rows[-1].id)
if has_more else None
)
return {'items': [message_out(row) for row in rows], 'next_cursor': next_cursor}
+14
View File
@@ -0,0 +1,14 @@
from fastapi import APIRouter, Request
from app.api.serialize import user_out
from app.core.security import hash_password
from app.schemas import CreateUser
router = APIRouter()
@router.post('/api/v1/users', status_code=201)
async def register(body: CreateUser, request: Request):
row = await request.app.state.storage.create_user(
body.username, body.display_name, hash_password(body.password))
return user_out(row)
+15
View File
@@ -0,0 +1,15 @@
from app.repositories.memory import UserRow
def user_out(row: UserRow) -> dict:
return {'id': row.id, 'username': row.username,
'display_name': row.display_name, 'created_at': row.created_at}
def chat_out(row) -> dict:
return {'id': row.id, 'title': row.title,
'member_ids': list(row.member_ids), 'created_at': row.created_at}
def message_out(row) -> dict:
return {'id': row.id, 'chat_id': row.chat_id, 'sender_id': row.sender_id,
'text': row.text, 'created_at': row.created_at}