deps.py перенес в core, добил anotations в api, изменил зависимость get_jwt_manager на get_security, изменил API

ProFastCode · ProFastCode · commit 21ac5c4b0eba · 2024-07-08T01:18:14.000+03:00
diff --git a/app/__init__.py b/app/__init__.py
@@ -5,7 +5,7 @@
 from fastapi import FastAPI
 
 from app import api
-from app.core import settings
+from app.core.settings import settings
 
 app = FastAPI(
     title=settings.APP_TITLE,
diff --git a/app/api/anotations.py b/app/api/anotations.py
@@ -0,0 +1,14 @@
+"""
+Anotations
+"""
+
+from fastapi import Depends
+from typing_extensions import Annotated
+
+from app.core import deps
+
+Database = Annotated[deps.db.Database, Depends(deps.get_db)]
+
+Security = Annotated[deps.Security, Depends(deps.get_security)]
+
+CurrentUser = Annotated[deps.User, Depends(deps.get_current_user)]
diff --git a/app/api/deps.py b/app/api/deps.py
diff --git a/app/api/endpoints/__init__.py b/app/api/endpoints/__init__.py
@@ -4,10 +4,9 @@
 
 from fastapi import APIRouter
 
-from . import auth, users
+from . import users
 
 router = APIRouter()
-router.include_router(auth.router)
 router.include_router(users.router)
 
 __all__ = ['router']
diff --git a/app/api/endpoints/auth/__init__.py b/app/api/endpoints/auth/__init__.py
diff --git a/app/api/endpoints/auth/email/__init__.py b/app/api/endpoints/auth/email/__init__.py
diff --git a/app/api/endpoints/auth/email/endpoints.py b/app/api/endpoints/auth/email/endpoints.py
diff --git a/app/api/endpoints/users/__init__.py b/app/api/endpoints/users/__init__.py
@@ -4,9 +4,11 @@
 
 from fastapi import APIRouter
 
-from . import retrieve
+from . import auth, create, retrieve
 
 router = APIRouter(prefix='/users', tags=['users'])
+router.include_router(auth.router)
+router.include_router(create.router)
 router.include_router(retrieve.router)
 
 __all__ = ['router']
diff --git a/app/api/endpoints/users/auth.py b/app/api/endpoints/users/auth.py
@@ -0,0 +1,24 @@
+from fastapi import APIRouter
+
+from app.api import anotations
+from app.core import deps, exps
+from app.models.token import AccessToken
+from app.models.user import UserCreate
+
+router = APIRouter(prefix="/auth")
+
+
+@router.post("/token/", response_model=AccessToken)
+async def token(
+    data: UserCreate, db: anotations.Database, security: anotations.Security
+):
+    """
+    Retrieve new access token
+    """
+    if user := await db.user.retrieve_by_email(data.email):
+        if not deps.pwd_context.verify(data.password, user.password):
+            raise exps.USER_IS_CORRECT
+        access_token = security.jwt.encode_token({"id": user.id}, 1440)
+        return AccessToken(token=access_token)
+
+    raise exps.USER_NOT_FOUND
diff --git a/app/api/endpoints/users/create.py b/app/api/endpoints/users/create.py
@@ -0,0 +1,24 @@
+from fastapi import APIRouter
+
+from app.api import anotations
+from app.core import deps, exps
+from app.models.user import User, UserCreate, UserRead
+
+router = APIRouter(prefix="/create")
+
+
+@router.post("/", response_model=UserRead)
+async def registration(
+    data: UserCreate,
+    db: anotations.Database,
+):
+    """
+    Create user
+    """
+    if await db.user.retrieve_by_email(data.email):
+        raise exps.USER_EXISTS
+
+    password_hash = deps.pwd_context.hash(data.password)
+    model = User(email=data.email, password=password_hash)
+    user = await db.user.create(model)
+    return user
diff --git a/app/api/endpoints/users/retrieve.py b/app/api/endpoints/users/retrieve.py
@@ -2,17 +2,16 @@
 User Endpoints Module
 """
 
-from fastapi import APIRouter, Depends
-from typing_extensions import Annotated
+from fastapi import APIRouter
 
-from app.api import deps
-from app.models.user import User, UserRead
+from app.api import anotations
+from app.models.user import UserRead
 
 router = APIRouter()
 
 
 @router.get('/', response_model=UserRead)
-async def retrieve(user: Annotated[User, Depends(deps.get_current_user)]):
+async def retrieve(user: anotations.CurrentUser):
     """
     Retrieve user
     """
diff --git a/app/core/__init__.py b/app/core/__init__.py
@@ -2,6 +2,6 @@
 Core App Module
 """
 
-from .settings import settings
+from .security import Security
 
-__all__ = ['settings']
+__all__ = ["Security"]
diff --git a/app/core/db.py b/app/core/db.py
@@ -2,12 +2,11 @@
 Database
 """
 
-from sqlalchemy.ext.asyncio import (AsyncEngine, async_sessionmaker,
-                                    create_async_engine)
+from sqlalchemy.ext.asyncio import AsyncEngine, async_sessionmaker, create_async_engine
 from sqlmodel.ext.asyncio.session import AsyncSession
 
 from app import repositories as repos
-from app.core import settings
+from app.core.settings import settings
 
 
 def get_async_engine() -> AsyncEngine:
diff --git a/app/core/deps.py b/app/core/deps.py
@@ -0,0 +1,35 @@
+"""
+Dependencies
+"""
+
+from fastapi import Depends
+from fastapi.security import APIKeyHeader
+from passlib.context import CryptContext
+from typing_extensions import Annotated, AsyncGenerator
+
+from app.models.user import User
+
+from . import Security, db, exps
+
+pwd_context = CryptContext(schemes=['bcrypt'], deprecated='auto')
+
+
+async def get_db() -> AsyncGenerator[db.Database]:
+    async with db.SessionLocal() as session:
+        yield db.Database(session)
+
+
+async def get_security() -> Security:
+    return Security()
+
+
+async def get_current_user(
+    token: Annotated[str, Depends(APIKeyHeader(name='access-token'))],
+    security: Annotated[Security, Depends(get_security)],
+    db: Annotated[db.Database, Depends(get_db)],
+) -> User | None:
+    if payload := security.jwt.decode_token(token):
+        if not (user := await db.user.retrieve_one(ident=payload.get('id'))):
+            raise exps.USER_NOT_FOUND
+        else:
+            return user
diff --git a/app/core/security/__init__.py b/app/core/security/__init__.py
@@ -1,3 +1,11 @@
-from .jwt_manager import JWTManager
+from app.core.settings import settings
 
-__all__ = ['JWTManager']
+from .jwt import JWT
+
+
+class Security:
+    def __init__(self):
+        self.jwt = JWT(settings.APP_SECRET_KEY)
+
+
+__all__ = ["Security"]
diff --git a/app/core/security/jwt.py b/app/core/security/jwt.py
@@ -6,24 +6,26 @@
 from app.core import exps
 
 
-class JWTManager:
+class JWT:
     def __init__(self, secret_key: str):
         self.secret_key: str = secret_key
 
     def decode_token(self, token: str) -> dict | None:
         try:
-            payload = jwt.decode(token, self.secret_key, algorithms=[ALGORITHMS.HS256])
+            payload = jwt.decode(
+                token, self.secret_key, algorithms=[ALGORITHMS.HS256]
+            )
         except JWTError:
             raise exps.TOKEN_INVALID
 
-        exp = payload.get("exp")
+        exp = payload.get('exp')
         if exp and dt.datetime.now(dt.UTC).timestamp() > exp:
             raise exps.TOKEN_EXPIRED
-        return payload.get("payload")
+        return payload.get('payload')
 
     def encode_token(self, payload: dict, minutes: int) -> str:
         claims = {
-            "payload": payload,
-            "exp": dt.datetime.now(dt.UTC) + dt.timedelta(minutes=minutes),
+            'payload': payload,
+            'exp': dt.datetime.now(dt.UTC) + dt.timedelta(minutes=minutes),
         }
         return jwt.encode(claims, self.secret_key, algorithm=ALGORITHMS.HS256)
diff --git a/app/core/settings.py b/app/core/settings.py
@@ -8,26 +8,26 @@
 
 class Settings(BaseSettings):
     model_config = SettingsConfigDict(
-        env_file=".env", env_file_encoding="utf-8", case_sensitive=True
+        env_file='.env', env_file_encoding='utf-8', case_sensitive=True
     )
 
     # APP
-    APP_PATH: str = "/api"
-    APP_TITLE: str = "FastAPI Template"
-    APP_VERSION: str = "beta"
-    APP_SECRET_KEY: str = "abc"
+    APP_PATH: str = '/api'
+    APP_TITLE: str = 'FastAPI Template'
+    APP_VERSION: str = 'beta'
+    APP_SECRET_KEY: str = 'abc'
 
     # DATABASE
-    POSTGRES_DB: str = "postgres"
-    POSTGRES_HOST: str = "127.0.0.1"
+    POSTGRES_DB: str = 'postgres'
+    POSTGRES_HOST: str = '127.0.0.1'
     POSTGRES_PORT: int = 5432
-    POSTGRES_USER: str = "postgres"
-    POSTGRES_PASSWORD: str = "postgres"
+    POSTGRES_USER: str = 'postgres'
+    POSTGRES_PASSWORD: str = 'postgres'
 
     @property
     def pg_dsn(self) -> PostgresDsn:
         dsn = PostgresDsn.build(
-            scheme="postgresql+asyncpg",
+            scheme='postgresql+asyncpg',
             username=self.POSTGRES_USER,
             password=self.POSTGRES_PASSWORD,
             host=self.POSTGRES_HOST,
diff --git a/app/models/base.py b/app/models/base.py
@@ -5,7 +5,6 @@
 from sqlalchemy.types import BigInteger, TypeDecorator
 from sqlmodel import Field, SQLModel
 
-
 datetime_utc_now = partial(dt.datetime.now, tz=dt.UTC)
 
 
@@ -26,7 +25,9 @@ def process_bind_param(
         elif isinstance(value, str):
             return int(dt.datetime.fromisoformat(value).timestamp())
 
-    def process_result_value(self, value: int | None, dialect) -> dt.datetime | None:
+    def process_result_value(
+        self, value: int | None, dialect
+    ) -> dt.datetime | None:
         if isinstance(value, int):
             return dt.datetime.fromtimestamp(value, dt.UTC)
 
@@ -56,7 +57,7 @@ class TimestampModel(SQLModel):
         default_factory=datetime_utc_now,
         sa_type=UnixType,
         nullable=True,
-        sa_column_kwargs={"onupdate": datetime_utc_now},
+        sa_column_kwargs={'onupdate': datetime_utc_now},
     )
 
     class Config:
diff --git a/app/repositories/abstract.py b/app/repositories/abstract.py
