Files

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()