feat: implement authentication and session service

This commit is contained in:
sinveria
2026-11-04 17:46:51 +03:00
parent 85207f3203
commit 23d16a1cc3
+132
View File
@@ -0,0 +1,132 @@
import hashlib
import secrets
from datetime import datetime, timedelta, timezone
from redis import Redis
from redis.exceptions import RedisError
from sqlalchemy.orm import Session
from app.core.config import settings
from app.db.models import User
from app.repositories.session_repository import SessionRepository
from app.repositories.user_repository import UserRepository
from app.services.user_service import password_hasher
class InvalidCredentialsError(Exception):
pass
class InvalidSessionError(Exception):
pass
class AuthService:
def __init__(self, db: Session):
self.db = db
self.sessions = SessionRepository(db)
self.users = UserRepository(db)
self.redis = Redis.from_url(
settings.cache_url,
decode_responses=True,
socket_connect_timeout=2,
socket_timeout=2,
)
@staticmethod
def _hash_token(token: str) -> str:
return hashlib.sha256(token.encode("utf-8")).hexdigest()
def create_session(self, username: str, password: str) -> dict:
user = self.users.get_by_username(username)
if user is None or not password_hasher.verify(
password, user.password_hash
):
raise InvalidCredentialsError("Invalid username or password")
token = secrets.token_urlsafe(32)
token_hash = self._hash_token(token)
expires_at = datetime.now(timezone.utc) + timedelta(
seconds=settings.session_ttl_seconds
)
try:
self.sessions.create(
user_id=user.id,
token_hash=token_hash,
expires_at=expires_at,
)
self.db.commit()
except Exception:
self.db.rollback()
raise
self._cache_session(token_hash, user.id, expires_at)
return {
"token": token,
"token_type": "Bearer",
"expires_at": expires_at,
"user": user,
}
def _cache_session(self, token_hash: str, user_id, expires_at) -> None:
ttl = max(
1,
int((expires_at - datetime.now(timezone.utc)).total_seconds()),
)
try:
self.redis.setex(
f"session:{token_hash}",
ttl,
str(user_id),
)
except RedisError:
pass
def authenticate(self, token: str) -> User:
token_hash = self._hash_token(token)
try:
cached_user_id = self.redis.get(f"session:{token_hash}")
except RedisError:
cached_user_id = None
session = self.sessions.get_valid_session(token_hash)
if session is None:
try:
self.redis.delete(f"session:{token_hash}")
except RedisError:
pass
raise InvalidSessionError("Session is invalid or expired")
if cached_user_id is None:
self._cache_session(
token_hash,
session.user_id,
session.expires_at,
)
return session.user
def delete_session(self, token: str) -> None:
token_hash = self._hash_token(token)
try:
deleted = self.sessions.delete_by_token_hash(token_hash)
if not deleted:
raise InvalidSessionError("Session is invalid or expired")
self.db.commit()
except Exception:
self.db.rollback()
raise
try:
self.redis.delete(f"session:{token_hash}")
except RedisError:
pass