o2o-site-AEO/solution/backend/services/auth_service.py

import re
import uuid

from fastapi import Depends

from common.database.db_session_manager import DB_SESSION_MNG
from common.database.model.models import users
from common.enums import AuthProvider, DBWRType, ErrorType, UserRole, UserStatus
from common.logger import LOG
from common.models.gmodel import UserInfo
from crud.user_crud import IUserCRUD, UserCRUD
from router.v1.auth.protocol import (
    Req_GoogleLogin,
    Req_Signup,
    Req_UpdateMe,
    Res_Login,
    Res_Me,
    Res_RefreshToken,
)
from router.v1.validator.dependencies import (
    CreateAccessToken,
    CreateRefreshToken,
    DecodeRefreshToken,
    GetHashedPW,
    VerifyPW,
)
from services.external.google_identity import (
    GoogleAccount,
    GoogleNotConfigured,
    GoogleTokenInvalid,
    verify_id_token,
)

# 로그인 아이디: 영문으로 시작하는 4~20자.
_LOGIN_ID_RE = re.compile(r"^[a-zA-Z][a-zA-Z0-9._-]{3,19}$")
# 형식만 본다 — 이메일 소유 증명은 여기 없다(Req_Signup 주석).
_EMAIL_RE = re.compile(r"^[^@\s]+@[^@\s]+\.[^@\s]+$")
_MIN_PASSWORD_LEN = 8

# 구글 계정의 로그인 아이디 접두어.
_SOCIAL_ID_PREFIX = "google_"


def _google_login_id(sub: str) -> str:
    """구글 계정의 로그인 아이디."""
    return f"{_SOCIAL_ID_PREFIX}{sub}"


def _fit(value: str | None, limit: int) -> str | None:
    """컬럼 길이에 맞춰 자른다."""
    if value is None:
        return None
    return value[:limit]


class AuthService:
    """비즈니스 로직 계층 (MVC 의 컨트롤러-서비스 분리에서 서비스)."""

    def __init__(self, user_crud: IUserCRUD = Depends(UserCRUD)):
        self.user_crud = user_crud

    @staticmethod
    def _user_info(user: users) -> UserInfo:
        # uuid → str (JWT json 직렬화 위해).
        return UserInfo(
            user_id=str(user.user_id),
            id=user.id,
            role=user.role,
            token_version=user.token_version,
        )

    async def _finish_login(self, user: users) -> Res_Login:
        """신원이 확인된 뒤의 마지막 단계 — id/pw 와 구글이 공유한다."""
        res = Res_Login()

        if user.status != UserStatus.ACTIVE.value:
            res.result.SetResult(ErrorType.ACCOUNT_BLOCKED_USER)
            return res

        user_info = self._user_info(user)
        res.access_token = CreateAccessToken(user_info)
        res.refresh_token = CreateRefreshToken(user_info)

        err_type = await DB_SESSION_MNG.execute_lambda_run(
            [users.DBType()],
            [lambda s: self.user_crud.update_last_accessed(s, user.user_id)],
        )
        if err_type != ErrorType.SUCCESS:
            res.result.SetResult(err_type)
        return res

    async def attempt_login(self, login_id: str, password: str, connect_ip: str) -> Res_Login:
        LOG.i(f"LOGIN : id={login_id}")
        res = Res_Login()

        # 1) 계정 조회 (Read DB)
        err_type, user = await DB_SESSION_MNG.execute_lambda(
            users.DBType(),
            DBWRType.DB_READ.value,
            lambda s: self.user_crud.get_user_by_login_id(s, login_id),
        )
        if err_type != ErrorType.SUCCESS:
            # 계정 없음/조회 실패 모두 로그인 실패로 일반화
            res.result.SetResult(ErrorType.ACCOUNT_INVALID_INFO)
            return res
        user: users

        # 2) 소셜 계정에는 대조할 비밀번호가 없다.
        if user.provider != AuthProvider.LOCAL.value or not user.password:
            res.result.SetResult(ErrorType.ACCOUNT_PROVIDER_CONFLICT)
            return res

        # 3) 비밀번호 검증
        if not await VerifyPW(password, user.password):
            res.result.SetResult(ErrorType.ACCOUNT_INVALID_INFO)
            return res

        return await self._finish_login(user)

    # 가입
    async def _create_account(
        self,
        *,
        login_id: str,
        password_hash: str | None,
        name: str | None,
        email: str | None,
        provider: AuthProvider,
        provider_uid: str | None,
    ) -> tuple[ErrorType, users]:
        """계정 1개를 만든다."""
        user = users(
            user_id=uuid.uuid4(),
            id=login_id,
            password=password_hash,
            name=_fit(name, 50),
            email=_fit(email, 255),
            status=UserStatus.ACTIVE.value,
            role=UserRole.USER.value,
            provider=provider.value,
            provider_uid=provider_uid,
        )
        err_type = await DB_SESSION_MNG.execute_lambda_run(
            [users.DBType()],
            [lambda s: self.user_crud.add_user(s, user)],
        )
        if err_type != ErrorType.SUCCESS:
            return err_type, None
        return ErrorType.SUCCESS, user

    async def _email_taken(self, email: str) -> bool:
        err_type, existing = await DB_SESSION_MNG.execute_lambda(
            users.DBType(),
            DBWRType.DB_READ.value,
            lambda s: self.user_crud.get_user_by_email(s, email),
        )
        return err_type == ErrorType.SUCCESS and existing is not None

    async def signup(self, req: Req_Signup) -> Res_Login:
        """id/pw 가입."""
        res = Res_Login()
        login_id = req.id.strip()
        email = (req.email or "").strip().lower()
        name = (req.name or "").strip() or None

        if not _LOGIN_ID_RE.match(login_id) or login_id.lower().startswith(_SOCIAL_ID_PREFIX):
            res.result.SetResult(ErrorType.INVALID_REQUEST_DATA)
            return res
        if len(req.password) < _MIN_PASSWORD_LEN:
            res.result.SetResult(ErrorType.INVALID_REQUEST_DATA)
            return res
        if not _EMAIL_RE.match(email):
            res.result.SetResult(ErrorType.INVALID_REQUEST_DATA)
            return res

        # 아이디 중복.
        dup = await DB_SESSION_MNG.execute_lambda(
            users.DBType(),
            DBWRType.DB_READ.value,
            lambda s: self.user_crud.is_user(s, login_id),
        )
        if dup != ErrorType.SUCCESS:
            res.result.SetResult(ErrorType.ACCOUNT_ALREADY_EXIST)
            return res

        # 이메일 중복 — 구글로 이미 가입한 사람이 같은 이메일로 계정을 하나 더 만드는 걸 막는다.
        if await self._email_taken(email):
            res.result.SetResult(ErrorType.ACCOUNT_ALREADY_EXIST)
            return res

        err_type, user = await self._create_account(
            login_id=login_id,
            password_hash=await GetHashedPW(req.password),
            name=name,
            email=email,
            provider=AuthProvider.LOCAL,
            provider_uid=None,
        )
        if err_type != ErrorType.SUCCESS:
            res.result.SetResult(err_type)
            return res

        LOG.i(f"SIGNUP : id={login_id}")
        return await self._finish_login(user)

    # 구글 로그인
    async def google_login(self, req: Req_GoogleLogin) -> Res_Login:
        """구글 ID 토큰 → 우리 세션."""
        res = Res_Login()

        try:
            account: GoogleAccount = await verify_id_token(req.credential)
        except GoogleNotConfigured:
            res.result.SetResult(ErrorType.OAUTH_NOT_CONFIGURED)
            return res
        except GoogleTokenInvalid:
            res.result.SetResult(ErrorType.OAUTH_INVALID_TOKEN)
            return res

        # 1) 이미 있는 구글 계정인가 — 판정 키는 sub 다(이메일이 바뀌어도 같은 사람).
        err_type, user = await DB_SESSION_MNG.execute_lambda(
            users.DBType(),
            DBWRType.DB_READ.value,
            lambda s: self.user_crud.get_user_by_provider_uid(s, AuthProvider.GOOGLE.value, account.sub),
        )
        if err_type == ErrorType.SUCCESS and user is not None:
            LOG.i(f"LOGIN(google) : sub={account.sub}")
            return await self._finish_login(user)

        # 2) 같은 이메일이 다른 수단으로 이미 가입돼 있으면 **잇지 않는다.** 자동으로 이으면, 남의 이메일로 먼저 만들어 둔 id/pw 계정에 그 사람의 구글 로그인이 그대로 들어간다(계정 선점).
        if account.email and await self._email_taken(account.email):
            res.result.SetResult(ErrorType.ACCOUNT_PROVIDER_CONFLICT)
            return res

        # 3) 첫 방문 — 계정을 만든다.
        err_type, user = await self._create_account(
            login_id=_google_login_id(account.sub),
            password_hash=None,
            name=account.name or None,
            email=account.email or None,
            provider=AuthProvider.GOOGLE,
            provider_uid=account.sub,
        )
        if err_type != ErrorType.SUCCESS:
            res.result.SetResult(err_type)
            return res

        LOG.i(f"SIGNUP(google) : sub={account.sub}")
        return await self._finish_login(user)

    async def get_me(self, user_info: UserInfo) -> Res_Me:
        res = Res_Me()

        # 1) 유저 조회
        err_type, user = await DB_SESSION_MNG.execute_lambda(
            users.DBType(),
            DBWRType.DB_READ.value,
            lambda s: self.user_crud.get_user_by_login_id(s, user_info.id),
        )
        if err_type != ErrorType.SUCCESS:
            res.result.SetResult(ErrorType.ACCOUNT_INVALID_INFO)
            return res
        user: users

        res.user_id = str(user.user_id)
        res.id = user.id
        res.name = user.name
        res.email = user.email
        res.contact_number = user.contact_number
        res.role = UserRole(user.role)
        res.provider = AuthProvider(user.provider)
        return res

    async def update_me(self, user_info: UserInfo, req: Req_UpdateMe) -> Res_Me:
        res = Res_Me()
        data = req.model_dump(exclude_unset=True)

        # 비밀번호: 값 있으면 해시 교체, 비었으면 변경 안 함.
        if data.get("password"):
            # 구글 계정에 비밀번호를 심으면 id/pw 로도 열리는 반쪽 계정이 된다 — 로그인 수단이 둘인데 어느 쪽도 상대를 모르는 상태다.
            if len(data["password"]) < _MIN_PASSWORD_LEN:
                res.result.SetResult(ErrorType.INVALID_REQUEST_DATA)
                return res
            err_type, me = await DB_SESSION_MNG.execute_lambda(
                users.DBType(),
                DBWRType.DB_READ.value,
                lambda s: self.user_crud.get_user_by_login_id(s, user_info.id),
            )
            if err_type != ErrorType.SUCCESS:
                res.result.SetResult(ErrorType.ACCOUNT_NOT_FOUND)
                return res
            if me.provider != AuthProvider.LOCAL.value:
                res.result.SetResult(ErrorType.ACCOUNT_PROVIDER_CONFLICT)
                return res
            data["password"] = await GetHashedPW(data["password"])
            # 비밀번호를 바꾸면 그 전에 나간 refresh 토큰을 전부 무효화한다 — 안 그러면 누군가 비번을 훔쳐 넣어 둔 refresh 토큰이 이 사람이 비번을 바꾼 뒤로도 계속 살아 있다(auth_service.refresh_token 이 이 값을 대조한다).
            data["token_version"] = (me.token_version or 1) + 1
        else:
            data.pop("password", None)
        # 빈 문자열은 NULL 로 저장(미입력 = 값 비움).
        for k in ("name", "email", "contact_number"):
            if k in data and data[k] == "":
                data[k] = None

        if data:
            err_type = await DB_SESSION_MNG.execute_lambda_run(
                [users.DBType()],
                [lambda s: self.user_crud.update_user(s, uuid.UUID(user_info.user_id), data)],
            )
            if err_type != ErrorType.SUCCESS:
                res.result.SetResult(err_type)
                return res

        # 갱신 후 최신 정보로 응답(프론트가 스토어 갱신에 사용).
        return await self.get_me(user_info)

    async def refresh_token(self, refresh_token: str) -> Res_RefreshToken:
        """refresh 토큰 → 새 access 토큰."""
        res = Res_RefreshToken()
        # refresh 토큰 검증은 라우터 Depends(IsValidRefreshToken) 에서 1차 수행됨(서명·만료).
        user_info = DecodeRefreshToken(refresh_token)

        err_type, user = await DB_SESSION_MNG.execute_lambda(
            users.DBType(),
            DBWRType.DB_READ.value,
            lambda s: self.user_crud.get_user_by_login_id(s, user_info.id),
        )
        if err_type != ErrorType.SUCCESS or user is None:
            res.result.SetResult(ErrorType.ACCOUNT_NOT_FOUND)
            return res
        user: users

        if user.status != UserStatus.ACTIVE.value:
            res.result.SetResult(ErrorType.ACCOUNT_BLOCKED_USER)
            return res
        # 구버전 토큰(token_version 없이 발급됨)은 UserInfo 기본값 1 로 읽힌다 — DB 컬럼 기본값도 1 이라 배포 직후에는 전부 통과한다.
        if user_info.token_version != user.token_version:
            res.result.SetResult(ErrorType.ACCOUNT_SESSION_REVOKED)
            return res

        # 최신 DB 값으로 다시 만든다 — role 이 바뀌었으면 그것도 여기서 따라온다.
        res.access_token = CreateAccessToken(self._user_info(user))
        return res