Merge pull request #8 from jsybf/dev

백엔드 정리

Author: jsybf

.gitignore

@@ -1 +1,8 @@
-/backend/.env
+# env file
+/backend/.env
+.env
+
+# editor and ide
+.idea
+__pycache__/
+=======

backend/Dockerfile

@@ -0,0 +1,33 @@
+# Use the official Python image from the Docker Hub
+FROM python:3.10.2-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    pkg-config \
+    default-libmysqlclient-dev \
+    && apt-get clean && rm -rf /var/lib/apt/lists/*
+
+# Install pipenv
+RUN pip install --no-cache-dir pipenv
+
+# Copy the Pipfile and Pipfile.lock into the container
+COPY Pipfile Pipfile.lock /app/
+
+# # Update Pipfile.lock
+# RUN pipenv lock
+
+# Install dependencies using pipenv
+RUN pipenv install --deploy --ignore-pipfile
+
+# Copy the rest of the application code into the container
+COPY ./app/ /app/
+
+# Expose port 8000 for the FastAPI app
+EXPOSE 8000
+
+# Run the FastAPI application using uvicorn
+CMD ["pipenv", "run", "python", "main.py"]

backend/Pipfile

@@ -4,6 +4,17 @@ verify_ssl = true
 name = "pypi"
 
 [packages]
+pyjwt = "==2.8.0"
+python-dotenv = "==1.0.1"
+httpx = "*"
+fastapi = {extras = ["standard"], version = "==0.115.1"}
+uvicorn = {extras = ["standard"], version = "*"}
+sqlalchemy = "==2.0.36"
+mysqlclient = "*"
+python-multipart = "*"
+boto3 = "*"
+boto3-stubs = {extras = ["s3"], version = "*"}
+pytest = "*"
 
 [dev-packages]
 

backend/Pipfile.lock

@@ -0,0 +1,75 @@
+from typing import Annotated
+
+from fastapi import APIRouter, HTTPException, Depends
+from fastapi.responses import RedirectResponse
+
+from auth import JwtAuth, request_access_token, request_user_info
+from core import utils, Config
+from entity import User
+from models import JwtResponse
+from repository import UserRepository, get_user_repository
+
+router = APIRouter()
+
+
+@router.get("/login")
+async def login() -> RedirectResponse:
+    """
+    login main entry point
+    책임
+        - kakao oauth server로 redirect
+    """
+    kakao_login_url = "https://kauth.kakao.com/oauth/authorize"
+    query_param = {
+        "client_id": Config.Kakako.ACCESS_KEY,
+        "redirect_uri": Config.Kakako.REDIRECT_URI,
+        "response_type": "code",
+    }
+    return RedirectResponse(
+        kakao_login_url + "?" + utils.build_query_param(query_param)
+    )
+
+
+@router.get("/authenticate")
+async def auhtenticate(
+    user_repo: Annotated[UserRepository, Depends(get_user_repository)],
+    code: str | None = None,
+    error: str | None = None,
+    error_description: str | None = None,
+) -> JwtResponse:
+    """
+    (참고) 인증 흐름
+    1. /login 에서 kauth.kakako.com/oauth/authroize로 redirect
+    2. 카카오톡 서버에서 이 api를 호출하며 query param으로 인증코드와 에러 코드들을 넘겨준다.
+
+    책임
+        - 카카오톡 서버로부터 전달받은 인증코드로 access_token 요청 보내기
+        - access_token으로 user info 요청 보내기
+    :param
+        code: 카카오톡 access_token 인증코드
+    """
+    if not code:
+        raise HTTPException(
+            status_code=400, detail={"error": error, "error_desc": error_description}
+        )
+
+    access_token: str = request_access_token(
+        redirect_uri=Config.Kakako.REDIRECT_URI,
+        auth_code=code,
+        client_id=Config.Kakako.ACCESS_KEY,
+    )["access_token"]
+    user_kakao_id: int = int(request_user_info(access_token)["id"])
+
+    # register new user
+    # user: User = User(kakao_id=user_id, username="foo", nickname="foo")
+    user: User | None = user_repo.find_by_kakao_id(user_kakao_id)
+    if user is None:
+        user = User(kakao_id=user_kakao_id, username="foo", nickname="foo")
+        user_repo.insert(user)
+
+    if user.id is None:
+        raise Exception("user id must not be None")
+
+    # TODO: expire and path
+    access_jwt = JwtAuth.create_token(user.id)
+    return JwtResponse(access_token=access_jwt)

backend/api/auth_router.py

@@ -0,0 +1,56 @@
+from typing import Annotated
+
+import jwt
+from fastapi import APIRouter, Depends, HTTPException
+from jwt.exceptions import InvalidTokenError
+
+from auth import JwtAuth
+from models import UserInvitationUrl
+from core import Config
+from repository import get_user_repository, UserRepository
+from entity import User
+
+router = APIRouter(dependencies=[Depends(JwtAuth())])
+
+
+def create_invitation_token(user_id: int) -> str:
+    return jwt.encode(
+        {"user_id": user_id, "type": "user_invitation"},
+        Config.JWT.SECRET_KEY,
+        Config.JWT.ALGORITHM,
+    )
+
+
+@router.get("/invitation/user")
+def get_user_id_by_invitation(
+    token: str, user_repo: Annotated[UserRepository, Depends(get_user_repository)]
+) -> int:
+    """
+    @param
+        token: invitation jwt token
+    """
+    try:
+        user_id: int = int(
+            jwt.decode(token, Config.JWT.SECRET_KEY, Config.JWT.ALGORITHM)["user_id"]
+        )
+    except InvalidTokenError as e:
+        raise HTTPException(401, detail=str(e))
+
+    user: User | None = user_repo.find_by_user_id(user_id)
+    if user is None:
+        raise HTTPException(status_code=404, detail="user not found")
+
+    return user_id
+
+
+@router.get("/user/invitation")
+def generate_invitation_url(
+    user_id: Annotated[int, Depends(JwtAuth())],
+) -> UserInvitationUrl:
+    """
+    invitation url format: ${server_host}/invitation?token=${jwt}
+    example: http://0.0.0.0:8000/invitation?token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoxLCJ0eXBlIjoidXNlcl9pbnZpdGF0aW9uIn0.LpR5N0xMXGr9Yn8UjsNVm6kcdkdH78HTvMId2f-47gY"
+    """
+    jwt: str = create_invitation_token(user_id)
+    invitation_url = f"{Config.ENV.SERVER_HOST}/invitation?token={jwt}"
+    return UserInvitationUrl(url=invitation_url)

backend/api/user_router.py

@@ -0,0 +1,118 @@
+from typing import Annotated
+from uuid import uuid4, UUID
+
+from fastapi import APIRouter, Depends, UploadFile, HTTPException, Response
+
+from auth import JwtAuth
+from entity import User, Voice
+from models import VoiceMetaData, VoiceIds
+from repository import (
+    get_voice_repository,
+    get_user_repository,
+    VoiceRepository,
+    UserRepository,
+)
+from s3_service import upload_audio, download_audio
+
+router = APIRouter(dependencies=[Depends(JwtAuth())])
+
+
+@router.post("/voice")
+async def upload_voice(
+    to_user_id: int,
+    audio_file: UploadFile,
+    from_user_id: Annotated[int, Depends(JwtAuth())],
+    voice_repo: Annotated[VoiceRepository, Depends(get_voice_repository)],
+    user_repo: Annotated[UserRepository, Depends(get_user_repository)],
+) -> VoiceMetaData:
+    # save voice data to db
+    from_user: User | None = user_repo.find_by_user_id(from_user_id)
+    if from_user is None:
+        raise HTTPException(status_code=404, detail="can't find user")
+
+    s3_id = uuid4()
+
+    voice = Voice(from_user=from_user.id, to_user=to_user_id, s3_id=s3_id.bytes)
+    voice_repo.insert(voice)
+
+    # upload to s3
+    upload_audio(f"{s3_id}.mp3", await audio_file.read())
+
+    # (tmp)
+    return VoiceMetaData(
+        id=voice.id,
+        s3_id=UUID(bytes=voice.s3_id),
+        from_user=voice.from_user,
+        to_user=voice.to_user,
+        annonymous=voice.annonymous,
+        is_read=voice.is_read,
+        is_correct=voice.is_correct,
+        created_at=voice.created_at,
+    )
+
+
+@router.get("/voice/{voice_id}/meta")
+async def get_voice_metadata(
+    voice_id: int,
+    user_id: Annotated[int, Depends(JwtAuth())],
+    voice_repo: Annotated[VoiceRepository, Depends(get_voice_repository)],
+) -> VoiceMetaData:
+    # find voice
+    voice = voice_repo.find_by_id(voice_id)
+    if voice is None:
+        raise HTTPException(status_code=404, detail="metadata not found")
+
+    # authorize: 보낸 쪽(from_user), 받는 쪽(to_user)모두 권한 있임
+
+    if user_id not in [voice.to_user, voice.from_user]:
+        raise HTTPException(status_code=401, detail="unauthorized")
+
+    print(f"voice_id: {voice_id} user_id: {user_id}")
+    return VoiceMetaData(
+        id=voice.id,
+        s3_id=UUID(bytes=voice.s3_id),
+        from_user=voice.from_user,
+        to_user=voice.to_user,
+        annonymous=voice.annonymous,
+        is_read=voice.is_read,
+        is_correct=voice.is_correct,
+        created_at=voice.created_at,
+    )
+
+
+@router.get("/voice/{voice_id}/audio")
+async def get_voice_audio(
+    voice_id: int,
+    user_id: Annotated[int, Depends(JwtAuth())],
+    voice_repo: Annotated[VoiceRepository, Depends(get_voice_repository)],
+) -> Response:
+    # find voice
+    voice = voice_repo.find_by_id(voice_id)
+    if voice is None:
+        raise HTTPException(status_code=404, detail="metadata not found")
+
+    # authorize
+    # authorize: 보낸 쪽(from_user), 받는 쪽(to_user)모두 권한 있임
+    if user_id not in [voice.to_user, voice.from_user]:
+        raise HTTPException(status_code=401, detail="unauthorized")
+
+    s3_id = str(UUID(bytes=voice.s3_id))
+
+    # TODO: if audio file doesn't exist in bucket
+    audio_binary: bytes = download_audio(f"{s3_id}.mp3")
+
+    return Response(content=audio_binary, media_type="audio/mpeg")
+
+
+@router.get("/user/voices")
+async def get_voice_id_list(
+    user_id: Annotated[int, Depends(JwtAuth())],
+    voice_repo: Annotated[VoiceRepository, Depends(get_voice_repository)],
+) -> VoiceIds:
+    received_voices: list[Voice] = voice_repo.find_by_to_user_id(user_id)
+    sent_voices: list[Voice] = voice_repo.find_by_from_user_id(user_id)
+
+    return VoiceIds(
+        received_voice_ids=list(map(lambda v: v.id, received_voices)),
+        sent_voice_ids=list(map(lambda v: v.id, sent_voices)),
+    )

backend/api/voice_router.py

@@ -0,0 +1,4 @@
+from .jwt_handler import JwtAuth
+from .kakao_oauth import request_access_token, request_user_info
+
+__all__ = ["request_access_token", "request_user_info", "JwtAuth"]

backend/__init__.py backend/app/__init__.py

@@ -0,0 +1,39 @@
+import jwt
+from fastapi import HTTPException, Request
+from fastapi.security import HTTPBearer
+from jwt.exceptions import InvalidTokenError
+
+from core import Config
+
+
+class JwtAuth(HTTPBearer):
+    def __init__(self, auto_error: bool = True):
+        super(JwtAuth, self).__init__(auto_error=auto_error)
+
+    async def __call__(self, request: Request) -> int:
+        auth_header: str = request.headers.get("Authorization")
+        if not auth_header:
+            raise HTTPException(401, detail=f"require Authorization header")
+        try:
+            scheme, token = auth_header.split(" ")
+            if scheme.lower() != "bearer":
+                raise Exception()
+        except Exception:
+            raise HTTPException(
+                401, detail=f"scheme should be bearer current:[{auth_header}] "
+            )
+
+        try:
+            request.state.token_info = jwt.decode(
+                token, Config.JWT.SECRET_KEY, Config.JWT.ALGORITHM
+            )["user_id"]
+        except InvalidTokenError as e:
+            raise HTTPException(401, detail=str(e))
+
+        return int(request.state.token_info)
+
+    @staticmethod
+    def create_token(user_id: int) -> str:
+        return jwt.encode(
+            {"user_id": user_id}, Config.JWT.SECRET_KEY, Config.JWT.ALGORITHM
+        )

backend/api/__init__.py backend/app/api/__init__.py

@@ -0,0 +1,25 @@
+import httpx
+
+
+def request_access_token(redirect_uri: str, auth_code: str, client_id: str) -> dict:
+    # TODO: http exception handling
+    resp = httpx.post(
+        "https://kauth.kakao.com/oauth/token",
+        data={
+            "client_id": client_id,
+            "redirect_uri": redirect_uri,
+            "code": auth_code,
+            "grant_type": "authorization_code",
+        },
+    )
+    return resp.json()
+
+
+def request_user_info(access_token: str) -> dict:
+    # TODO: http exception handling
+    resp = httpx.post(
+        url="https://kapi.kakao.com/v2/user/me",
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+
+    return resp.json()

backend/app/api/auth_router.py

@@ -0,0 +1,3 @@
+from .config import Config
+
+__all__ = ["Config"]