from __future__ import annotations
import hashlib
import secrets
from dataclasses import dataclass, replace
from datetime import datetime, timedelta
from typing import Any
from uuid import UUID
from sqlalchemy import select, update
from ..storage.db import Database
from ..storage.models import User, UserSession, utcnow
SUPPORTED_LOCALES = {"en", "uk", "ru"}
@dataclass(frozen=True)
class CurrentUser:
id: UUID
sub: str
email: str | None
display_name: str | None
profile: dict[str, Any]
locale: str | None
system_role: str | None
status: str | None
client_roles: tuple[str, ...]
permissions: tuple[str, ...]
blocked_at: datetime | None
@property
def is_blocked(self) -> bool:
return self.blocked_at is not None
@property
def effective_locale(self) -> str:
candidate = self.locale or self.profile.get("locale") or "en"
normalized = str(candidate).split("-", 1)[0].lower()
return normalized if normalized in SUPPORTED_LOCALES else "en"
def token_hash(token: str) -> str:
return hashlib.sha256(token.encode("utf-8")).hexdigest()
def _to_current(user: User) -> CurrentUser:
return CurrentUser(
id=user.id,
sub=user.sub,
email=user.email,
display_name=user.display_name,
profile=dict(user.profile or {}),
locale=user.locale,
system_role=user.system_role,
status=user.status,
client_roles=tuple(user.client_roles or []),
permissions=tuple(user.permissions or []),
blocked_at=user.blocked_at,
)
def create_session(
database: Database,
user_id: UUID,
ttl_seconds: int,
user_agent: str | None = None,
ip_address: str | None = None,
) -> tuple[str, datetime]:
token = secrets.token_urlsafe(32)
now = utcnow()
expires_at = now + timedelta(seconds=ttl_seconds)
with database.session() as session:
with session.begin():
session.add(
UserSession(
user_id=user_id,
token_hash=token_hash(token),
created_at=now,
expires_at=expires_at,
user_agent=user_agent,
ip_address=ip_address,
)
)
return token, expires_at
def resolve_session(database: Database, token: str) -> CurrentUser | None:
now = utcnow()
with database.session() as session:
row = session.scalars(
select(UserSession).where(UserSession.token_hash == token_hash(token))
).first()
if row is None or row.revoked_at is not None or row.expires_at <= now:
return None
user = session.get(User, row.user_id)
if user is None or user.blocked_at is not None:
return None
row.last_used_at = now
session.commit()
return _to_current(user)
def revoke_session(database: Database, token: str) -> None:
with database.session() as session:
with session.begin():
session.execute(
update(UserSession)
.where(
UserSession.token_hash == token_hash(token),
UserSession.revoked_at.is_(None),
)
.values(revoked_at=utcnow())
)
def revoke_user_sessions(database: Database, user_id: UUID) -> None:
with database.session() as session:
with session.begin():
session.execute(
update(UserSession)
.where(
UserSession.user_id == user_id,
UserSession.revoked_at.is_(None),
)
.values(revoked_at=utcnow())
)
def set_user_locale(database: Database, user_id: UUID, locale: str | None) -> CurrentUser:
normalized = locale or None
if normalized is not None and normalized not in SUPPORTED_LOCALES:
raise ValueError("locale must be en, uk, ru, or empty")
with database.session() as session:
with session.begin():
user = session.get(User, user_id)
if user is None:
raise ValueError("User not found")
user.locale = normalized
session.flush()
return _to_current(user)
def with_locale(user: CurrentUser, locale: str | None) -> CurrentUser:
return replace(user, locale=locale or None)