forked from mtusi2026/mtusi2026lab2
97 lines
4.7 KiB
Python
97 lines
4.7 KiB
Python
from dataclasses import dataclass, field
|
|
import os
|
|
import threading
|
|
|
|
|
|
SCHEMA = """
|
|
CREATE TABLE IF NOT EXISTS users (
|
|
id UUID PRIMARY KEY, username VARCHAR(32) UNIQUE NOT NULL,
|
|
display_name VARCHAR(100) NOT NULL, password_hash TEXT NOT NULL,
|
|
created_at TIMESTAMPTZ NOT NULL
|
|
);
|
|
CREATE TABLE IF NOT EXISTS chats (
|
|
id UUID PRIMARY KEY, title VARCHAR(100) NOT NULL,
|
|
created_at TIMESTAMPTZ NOT NULL
|
|
);
|
|
CREATE TABLE IF NOT EXISTS chat_members (
|
|
chat_id UUID REFERENCES chats(id) ON DELETE CASCADE,
|
|
user_id UUID REFERENCES users(id) ON DELETE CASCADE,
|
|
PRIMARY KEY (chat_id, user_id)
|
|
);
|
|
CREATE TABLE IF NOT EXISTS messages (
|
|
id UUID PRIMARY KEY, chat_id UUID REFERENCES chats(id) ON DELETE CASCADE,
|
|
sender_id UUID REFERENCES users(id), text TEXT NOT NULL,
|
|
created_at TIMESTAMPTZ NOT NULL
|
|
);
|
|
CREATE INDEX IF NOT EXISTS messages_chat_created_idx ON messages(chat_id, created_at, id);
|
|
CREATE TABLE IF NOT EXISTS sessions (
|
|
token TEXT PRIMARY KEY, user_id UUID REFERENCES users(id) ON DELETE CASCADE,
|
|
expires_at TIMESTAMPTZ NOT NULL, revoked BOOLEAN NOT NULL DEFAULT FALSE
|
|
);
|
|
"""
|
|
|
|
|
|
@dataclass
|
|
class State:
|
|
users: dict[str, dict] = field(default_factory=dict)
|
|
usernames: dict[str, str] = field(default_factory=dict)
|
|
chats: dict[str, dict] = field(default_factory=dict)
|
|
messages: dict[str, list[dict]] = field(default_factory=dict)
|
|
sessions: dict[str, dict] = field(default_factory=dict)
|
|
lock: threading.RLock = field(default_factory=threading.RLock)
|
|
database_url: str = field(default_factory=lambda: os.environ.get("DATABASE_URL", ""))
|
|
connection_factory: object = field(init=False, default=None)
|
|
|
|
def __post_init__(self):
|
|
if not self.database_url:
|
|
return
|
|
try:
|
|
import psycopg
|
|
self.connection_factory = psycopg.connect
|
|
with self.connection_factory(self.database_url, autocommit=True) as conn:
|
|
with conn.cursor() as cur:
|
|
cur.execute(SCHEMA)
|
|
cur.execute("SELECT id, username, display_name, created_at, password_hash FROM users")
|
|
for row in cur.fetchall():
|
|
user_id, username, display_name, created_at, password_hash = row
|
|
user = {"id": str(user_id), "username": username, "display_name": display_name,
|
|
"created_at": created_at.isoformat().replace("+00:00", "Z"),
|
|
"_password_hash": password_hash}
|
|
self.users[user["id"]] = user
|
|
self.usernames[username] = user["id"]
|
|
cur.execute("SELECT id, title, created_at FROM chats")
|
|
for chat_id, title, created_at in cur.fetchall():
|
|
cur.execute("SELECT user_id FROM chat_members WHERE chat_id=%s ORDER BY user_id", (chat_id,))
|
|
self.chats[str(chat_id)] = {"id": str(chat_id), "title": title,
|
|
"member_ids": [str(row[0]) for row in cur.fetchall()],
|
|
"created_at": created_at.isoformat().replace("+00:00", "Z")}
|
|
self.messages[str(chat_id)] = []
|
|
cur.execute("SELECT id, chat_id, sender_id, text, created_at FROM messages ORDER BY created_at, id")
|
|
for message_id, chat_id, sender_id, text, created_at in cur.fetchall():
|
|
self.messages.setdefault(str(chat_id), []).append({
|
|
"id": str(message_id), "chat_id": str(chat_id), "sender_id": str(sender_id),
|
|
"text": text, "created_at": created_at.isoformat().replace("+00:00", "Z")})
|
|
cur.execute("SELECT token, user_id, expires_at, revoked FROM sessions")
|
|
for token, user_id, expires_at, revoked in cur.fetchall():
|
|
self.sessions[token] = {"user_id": str(user_id), "expires_at": expires_at.timestamp(),
|
|
"revoked": revoked}
|
|
except ImportError as exc:
|
|
raise RuntimeError("DATABASE_URL задан, но пакет psycopg не установлен") from exc
|
|
|
|
def execute(self, query, params=()):
|
|
if not self.connection_factory:
|
|
return
|
|
with self.connection_factory(self.database_url) as conn:
|
|
with conn.cursor() as cur:
|
|
cur.execute(query, params)
|
|
conn.commit()
|
|
|
|
def transaction(self, statements):
|
|
if not self.connection_factory:
|
|
return
|
|
with self.connection_factory(self.database_url) as conn:
|
|
with conn.cursor() as cur:
|
|
for query, params in statements:
|
|
cur.execute(query, params)
|
|
conn.commit()
|