Files
celtic-life-science/app/auth/service.py
T
Shubhankar45 8fdd20b29f Production
2026-09-22 06:23:46 +00:00

101 lines
3.6 KiB
Python

import uuid
from datetime import timedelta
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from app.audit.service import AuditService
from app.auth.models import RefreshToken
from app.auth.schemas import TokenPair
from app.auth.security import (
create_access_token,
generate_refresh_token,
hash_refresh_token,
utcnow,
verify_password,
)
from app.common.enums import AuditAction, EntityType
from app.common.exceptions import UnauthorizedError
from app.config.settings import settings
from app.users.models import User
class AuthService:
def __init__(self, db: AsyncSession) -> None:
self.db = db
self.audit = AuditService(db)
async def login(self, email: str, password: str, ip: str | None = None) -> TokenPair:
stmt = select(User).where(User.email == email)
user = (await self.db.execute(stmt)).scalar_one_or_none()
# Same message for unknown user and wrong password — do not leak which.
if user is None or not verify_password(password, user.password_hash):
if user is not None:
user.failed_login_attempts += 1
await self.db.commit()
raise UnauthorizedError("Invalid email or password")
if not user.is_active:
raise UnauthorizedError("User account is deactivated")
# SEC-10 — lock out after repeated failures.
if user.failed_login_attempts >= settings.LOGIN_MAX_FAILED_ATTEMPTS:
raise UnauthorizedError("Account locked after too many failed attempts")
user.failed_login_attempts = 0
await self.audit.log(
actor_user_id=user.id,
entity_type=EntityType.USER,
entity_id=user.id,
action=AuditAction.LOGIN,
ip_address=ip,
)
pair = await self._issue_tokens(user)
await self.db.commit()
return pair
async def refresh(self, raw_token: str) -> TokenPair:
token_hash = hash_refresh_token(raw_token)
stmt = select(RefreshToken).where(RefreshToken.token_hash == token_hash)
stored = (await self.db.execute(stmt)).scalar_one_or_none()
if stored is None or stored.revoked or stored.expires_at < utcnow():
raise UnauthorizedError("Invalid or expired refresh token")
user = await self.db.get(User, stored.user_id)
if user is None or not user.is_active:
raise UnauthorizedError("User no longer active")
# Rotate: the presented token is burned as the new one is issued.
stored.revoked = True
pair = await self._issue_tokens(user)
await self.db.commit()
return pair
async def logout(self, user_id: uuid.UUID) -> None:
"""Revoke every refresh token for this user."""
stmt = select(RefreshToken).where(
RefreshToken.user_id == user_id, RefreshToken.revoked.is_(False)
)
for token in (await self.db.execute(stmt)).scalars().all():
token.revoked = True
await self.db.commit()
async def _issue_tokens(self, user: User) -> TokenPair:
access = create_access_token(user.id, user.role.value)
raw_refresh, refresh_hash = generate_refresh_token()
self.db.add(
RefreshToken(
user_id=user.id,
token_hash=refresh_hash,
expires_at=utcnow() + timedelta(days=settings.REFRESH_TOKEN_EXPIRE_DAYS),
)
)
await self.db.flush()
return TokenPair(
access_token=access,
refresh_token=raw_refresh,
expires_in=settings.ACCESS_TOKEN_EXPIRE_MINUTES * 60,
)