add models and schemas

Author: RustamovAkrom

src/api/v1/user.py

@@ -1,24 +1,30 @@
 from fastapi import APIRouter, Depends
 
-from schemas.user import UserCreate, UserLogin, UserOut, UserResponse
+from schemas.auth import (
+    LoginOutScheme,
+    LoginScheme,
+    RegisterOutScheme,
+    RegistrationScheme,
+)
+from schemas.user import UserCreateScheme
 from services.user_service import UserService
 
 router = APIRouter()
 
 
-@router.post("/register", response_model=UserOut)
+@router.post("/register", response_model=UserCreateScheme)
 async def register_user(
-    data: UserCreate,
+    data: RegistrationScheme,
     user_service: UserService = Depends(),
-) -> UserOut:
+) -> RegisterOutScheme:
     return await user_service.register(data)
 
 
-@router.post("/login", response_model=UserResponse)
+@router.post("/login", response_model=LoginOutScheme)
 async def login_user(
-    data: UserLogin,
+    data: LoginScheme,
     user_service: UserService = Depends(),
-) -> UserResponse:
+) -> LoginOutScheme:
     return await user_service.login(data)
 
 

src/app.py

@@ -4,7 +4,7 @@
 
 from api.routers import api_router
 from core.config import settings
-from core.exceptions import register_exception_handlers
+from core.exceptions import register_error_handler
 from core.lifespan import lifespan
 from core.logger import configure_logger
 
@@ -26,7 +26,7 @@ def create_app() -> FastAPI:
     configure_logger()
 
     # Register exception handlers
-    register_exception_handlers(app)
+    register_error_handler(app)
 
     # Include API router
     app.include_router(api_router, prefix="/api/v1")

src/core/exceptions.py

@@ -1,45 +1,25 @@
-from typing import Any
-
-from fastapi import FastAPI, Request
+from fastapi import FastAPI, status
 from fastapi.responses import JSONResponse
 
 
 class APIException(Exception):
-    status_code: int = 500
-    default_code: str = "error"
-    default_detail: str = "Something went wrong."
-
     def __init__(
         self,
-        detail: str | None = None,
-        code: str | None = None,
-        values: dict[str, Any] | None = None,
-        status_code: int | None = None,
+        message: str,
+        *,
+        status_code: int = status.HTTP_400_BAD_REQUEST,
+        details: dict | None = None,
     ):
-        self.detail = detail or self.default_detail
-        self.code = code or self.default_code
-        self.values = values or {}
-        self.status_code = status_code or self.status_code
-
-        super().__init__(self.detail)
-
+        self.message = message
+        self.status_code = status_code
+        self.details = details or {}
 
-async def api_exception_handler(request: Request, exc: Exception) -> JSONResponse:
-    """
-    Обработчик для FastAPI, принимает Exception (требование Starlette),
-    проверяет на APIException и возвращает JSONResponse.
-    """
-    if isinstance(exc, APIException):
-        content = {
-            "code": exc.code,
-            "detail": exc.detail,
-            "values": exc.values,
-        }
-        return JSONResponse(status_code=exc.status_code, content=content)
+    def to_dict(self):
+        return {"message": self.message, "details": self.details}
 
-    # fallback для остальных исключений
-    return JSONResponse(status_code=500, content={"code": "error", "detail": str(exc)})
 
+def register_error_handler(app: FastAPI):
 
-def register_exception_handlers(app: FastAPI) -> None:
-    app.add_exception_handler(Exception, api_exception_handler)
+    @app.exception_handler(APIException)
+    async def api_exception_handler(_, exc: APIException):
+        return JSONResponse(status_code=exc.status_code, content=exc.to_dict())

src/db/crud/user.py

@@ -4,7 +4,7 @@
 
 from db.dependencies import get_db_session
 from db.models.users import User
-from schemas.user import UserCreate
+from schemas.auth import RegistrationScheme
 
 
 class UserCRUD:
@@ -21,10 +21,11 @@ async def get_by_username(self, username: str) -> User | None:
         result = await self.session.execute(stmt)
         return result.scalars().first()
 
-    async def create(self, data: UserCreate, hashed_password: str) -> User:
+    async def create(self, data: RegistrationScheme, hashed_password: str) -> User:
+        user_data = data.dict()
+        user_data.pop("password", None)
         user = User(
-            email=data.email,
-            username=data.username,
+            **user_data,
             hashed_password=hashed_password,
         )
         self.session.add(user)