172 lines
5.3 KiB
Python
172 lines
5.3 KiB
Python
import base64
|
|
import hashlib
|
|
import re
|
|
import secrets
|
|
from datetime import timedelta
|
|
from uuid import UUID, uuid4
|
|
|
|
from src.cursor import decode_cursor, encode_cursor
|
|
from src.domain import Chat, Message, Record, User, order_key, utcnow
|
|
from src.errors import DomainError, invalid, not_found
|
|
from src.password import Passwords
|
|
from src.repository import PostgresRepository
|
|
|
|
|
|
def page(*, rows: list[Record], limit: int, scope: str) -> dict:
|
|
items = rows[:limit]
|
|
cursor = (
|
|
encode_cursor(scope=scope, key=order_key(items[-1]))
|
|
if len(rows) > limit
|
|
else None
|
|
)
|
|
return {"items": items, "next_cursor": cursor}
|
|
|
|
|
|
def unauthorized(*, basic=False):
|
|
challenge = (
|
|
'Basic realm="messenger", charset="UTF-8"'
|
|
if basic
|
|
else 'Bearer realm="messenger"'
|
|
)
|
|
return DomainError(
|
|
401,
|
|
"unauthorized",
|
|
"Authentication required",
|
|
{"WWW-Authenticate": challenge},
|
|
)
|
|
|
|
|
|
def bearer(value):
|
|
if not value:
|
|
raise unauthorized()
|
|
scheme, _, token = value.partition(" ")
|
|
if scheme.lower() != "bearer" or not re.fullmatch(
|
|
r"[A-Za-z0-9_-]{32,256}", token
|
|
):
|
|
raise unauthorized()
|
|
return token
|
|
|
|
|
|
def token_digest(value):
|
|
return hashlib.sha256(value.encode()).digest()
|
|
|
|
|
|
class MessengerService:
|
|
def __init__(
|
|
self,
|
|
*,
|
|
repository: PostgresRepository,
|
|
passwords: Passwords,
|
|
session_ttl: int,
|
|
) -> None:
|
|
self.repository = repository
|
|
self.passwords = passwords
|
|
self.session_ttl = session_ttl
|
|
|
|
def identify(self, *, value: str | None) -> User:
|
|
token = bearer(value)
|
|
user_id = self.repository.session_user(digest=token_digest(token))
|
|
user = self.repository.get_user(user_id=user_id) if user_id else None
|
|
if user is None:
|
|
raise unauthorized()
|
|
return user
|
|
|
|
def register(
|
|
self, *, username: str, display_name: str, password: str
|
|
) -> User:
|
|
encoded = self.passwords.hash(password=password)
|
|
return self.repository.add_user(
|
|
user=User(uuid4(), username, display_name, utcnow()),
|
|
password_hash=encoded,
|
|
)
|
|
|
|
def login(self, *, authorization: str | None):
|
|
try:
|
|
scheme, _, encoded = (authorization or "").partition(" ")
|
|
if scheme.lower() != "basic":
|
|
raise ValueError
|
|
plain = base64.b64decode(encoded, validate=True).decode("utf-8")
|
|
username, separator, password = plain.partition(":")
|
|
if (
|
|
not separator
|
|
or not re.fullmatch(r"[a-z0-9_]{3,32}", username)
|
|
or not 12 <= len(password) <= 128
|
|
or not password.strip()
|
|
):
|
|
raise ValueError
|
|
except ValueError, UnicodeError:
|
|
raise unauthorized(basic=True) from None
|
|
user, password_hash = self.repository.credentials(username=username)
|
|
if not self.passwords.verify(password=password, encoded=password_hash):
|
|
raise unauthorized(basic=True)
|
|
now = utcnow()
|
|
expires = now + timedelta(seconds=self.session_ttl)
|
|
token = secrets.token_urlsafe(32)
|
|
self.repository.add_session(
|
|
digest=token_digest(token),
|
|
user_id=user.id,
|
|
created_at=now,
|
|
expires_at=expires,
|
|
)
|
|
return {
|
|
"token": token,
|
|
"token_type": "Bearer",
|
|
"expires_at": expires,
|
|
"user": user,
|
|
}
|
|
|
|
def logout(self, *, authorization: str | None):
|
|
self.identify(value=authorization)
|
|
self.repository.delete_session(
|
|
digest=token_digest(bearer(authorization))
|
|
)
|
|
|
|
def create_chat(
|
|
self, *, actor_id: UUID, title: str, member_ids: list[UUID]
|
|
) -> Chat:
|
|
return self.repository.add_chat(
|
|
chat=Chat(uuid4(), title, tuple(member_ids), utcnow()),
|
|
actor_id=actor_id,
|
|
)
|
|
|
|
def get_chat(self, *, actor_id: UUID, chat_id: UUID) -> Chat:
|
|
return self.repository.get_chat(actor_id=actor_id, chat_id=chat_id)
|
|
|
|
def send(
|
|
self,
|
|
*,
|
|
actor_id: UUID,
|
|
chat_id: UUID,
|
|
text: str,
|
|
idempotency_key: str | None,
|
|
) -> Message:
|
|
if not idempotency_key or not re.fullmatch(
|
|
r"[A-Za-z0-9._:-]{1,128}", idempotency_key
|
|
):
|
|
raise invalid()
|
|
return self.repository.add_message(
|
|
message=Message(uuid4(), chat_id, actor_id, text, utcnow()),
|
|
idempotency_key=idempotency_key,
|
|
)
|
|
|
|
def chats(self, *, actor_id: UUID, limit: int, cursor: str | None) -> dict:
|
|
scope = f"chats:{actor_id}"
|
|
after = decode_cursor(value=cursor, scope=scope)
|
|
rows = self.repository.list_chats(
|
|
actor_id=actor_id, after=after, limit=limit
|
|
)
|
|
return page(rows=rows, limit=limit, scope=scope)
|
|
|
|
def history(
|
|
self, *, actor_id: UUID, chat: Chat, limit: int, cursor: str | None
|
|
) -> dict:
|
|
if actor_id not in chat.member_ids:
|
|
raise not_found()
|
|
chat_id = chat.id
|
|
scope = f"messages:{chat_id}"
|
|
after = decode_cursor(value=cursor, scope=scope)
|
|
rows = self.repository.list_messages(
|
|
actor_id=actor_id, chat_id=chat_id, after=after, limit=limit
|
|
)
|
|
return page(rows=rows, limit=limit, scope=scope)
|