add user, and authentication middleware

Author: sumaro2101

.env.sample

@@ -1,5 +1,6 @@
 # ==================APP_SETTINGS==================
 DEBUG=1
+SECRET=SOMESECRET
 # ==================DATA_BASE==================
 POSTGRES_DB=analizer
 POSTGRES_PASSWORD=

api_v1/users/exceptions.py

@@ -0,0 +1,17 @@
+from fastapi_users.exceptions import FastAPIUsersException
+
+
+class PasswordNotValidError(FastAPIUsersException):
+    """
+    Исключение не валидного пароля
+    """
+
+    pass
+
+
+class UserNotVerified(FastAPIUsersException):
+    """
+    Исключение не вурифицинованного пользователя
+    """
+
+    pass

api_v1/users/middlewares.py

@@ -0,0 +1,31 @@
+from typing import Any
+from fastapi import Request, Depends
+from fastapi_users.db import SQLAlchemyUserDatabase
+from starlette.middleware.base import BaseHTTPMiddleware
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from .user_manager import UserManager
+from config.models import User
+from config import db_connection
+
+
+class AuthenticationMiddleware(BaseHTTPMiddleware):
+    """
+    Прослойка которая добавляет User в Request
+    """
+    def __init__(self, app):
+        super().__init__(app)
+
+    async def dispatch(
+        self,
+        request: Request,
+        call_next: Any,
+        session: AsyncSession = Depends(db_connection.session_geter),
+    ):
+        token = request.headers.get('Authorization')
+        user_db = SQLAlchemyUserDatabase(session, User)
+        manager = UserManager(user_db=user_db)
+        user = await manager.authenticate_user(token)
+        request.scope['user'] = user
+        response = await call_next(request)
+        return response

api_v1/users/user_manager.py

@@ -0,0 +1,56 @@
+import jwt
+from fastapi_users import BaseUserManager, IntegerIDMixin
+from fastapi_users.jwt import decode_jwt
+from fastapi_users import exceptions
+
+from .exceptions import PasswordNotValidError, UserNotVerified
+from config.models import User
+from config import settings
+
+
+class UserManager(IntegerIDMixin, BaseUserManager[User, int]):
+    """
+    UserManager для работы с пользователем
+    """
+
+    verification_token_secret = settings.SECRET
+
+    async def validate_password(self, password, user):
+        if not len(password) > 7:
+            raise PasswordNotValidError('Password is not valid')
+
+    async def authenticate_user(self, token: str | None):
+        if not token:
+            return
+        try:
+            data = decode_jwt(
+                token,
+                self.verification_token_secret,
+                [self.verification_token_audience],
+            )
+        except jwt.PyJWTError:
+            raise exceptions.InvalidVerifyToken()
+
+        try:
+            user_id = data["sub"]
+            email = data["email"]
+        except KeyError:
+            raise exceptions.InvalidVerifyToken()
+
+        try:
+            user = await self.get_by_email(email)
+        except exceptions.UserNotExists:
+            return
+
+        try:
+            parsed_id = self.parse_id(user_id)
+        except exceptions.InvalidID:
+            raise exceptions.InvalidVerifyToken()
+
+        if parsed_id != user.id:
+            raise exceptions.InvalidVerifyToken()
+
+        if not user.is_verified:
+            raise UserNotVerified()
+
+        return user

api_v1/users/views.py

@@ -1,5 +1,4 @@
-from fastapi import APIRouter, Depends, status
-
+from fastapi import APIRouter, Depends, status, Request
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from config import db_connection
@@ -14,9 +13,5 @@
 @router.get(path='/get',
             description='Test end point',
             )
-async def get_user(
-    session: AsyncSession = Depends(db_connection.session_geter),
-):
-    session = session
-    raise ValidationError(status_code=status.HTTP_400_BAD_REQUEST,
-                          detail=dict(some='Some is wrong'))
+async def get_user(request: Request):
+    return request.user

app_includes/logs_errors.py

@@ -2,11 +2,22 @@
 from fastapi.responses import JSONResponse
 from fastapi.exceptions import HTTPException
 from starlette.exceptions import HTTPException as StarletteHTTPException
+from fastapi_users.exceptions import (
+    InvalidID,
+    UserAlreadyExists,
+    UserNotExists,
+    UserInactive,
+    UserAlreadyVerified,
+    InvalidVerifyToken,
+    InvalidResetPasswordToken,
+    InvalidPasswordException,
+)
 
 from http import HTTPStatus
 
 from config.setup_logs.logging import logger
 from api_v1.exeptions import ValidationError
+from api_v1.users.exceptions import PasswordNotValidError, UserNotVerified
 
 
 def register_errors(app: FastAPI) -> None:
@@ -59,6 +70,165 @@ async def file_not_found_error_handler(
                 return JSONResponse(response)
     ```
     """
+    @app.exception_handler(UserNotVerified)
+    async def user_not_verify_error_handler(
+        request: Request,
+        exc: UserNotVerified,
+    ):
+        """
+        Логирование всех UserNotVerified
+        """
+        logger.opt(exception=True).warning(exc)
+        response = dict(
+            status=False,
+            error_code=exc.status_code,
+            message=exc.detail,
+        )
+        return JSONResponse(response)
+
+    @app.exception_handler(InvalidPasswordException)
+    async def password_invalid_error_handler(
+        request: Request,
+        exc: InvalidPasswordException,
+    ):
+        """
+        Логирование всех InvalidPasswordException
+        """
+        logger.opt(exception=True).warning(exc)
+        response = dict(
+            status=False,
+            error_code=exc.status_code,
+            message=exc.detail,
+        )
+        return JSONResponse(response)
+
+    @app.exception_handler(InvalidResetPasswordToken)
+    async def password_token_error_handler(
+        request: Request,
+        exc: InvalidResetPasswordToken,
+    ):
+        """
+        Логирование всех InvalidResetPasswordToken
+        """
+        logger.opt(exception=True).warning(exc)
+        response = dict(
+            status=False,
+            error_code=exc.status_code,
+            message=exc.detail,
+        )
+        return JSONResponse(response)
+
+    @app.exception_handler(InvalidVerifyToken)
+    async def verify_token_error_handler(
+        request: Request,
+        exc: InvalidVerifyToken,
+    ):
+        """
+        Логирование всех InvalidVerifyToken
+        """
+        logger.opt(exception=True).warning(exc)
+        response = dict(
+            status=False,
+            error_code=exc.status_code,
+            message=exc.detail,
+        )
+        return JSONResponse(response)
+
+    @app.exception_handler(UserAlreadyVerified)
+    async def user_exists_error_handler(
+        request: Request,
+        exc: UserAlreadyVerified,
+    ):
+        """
+        Логирование всех UserAlreadyVerified
+        """
+        logger.opt(exception=True).warning(exc)
+        response = dict(
+            status=False,
+            error_code=exc.status_code,
+            message=exc.detail,
+        )
+        return JSONResponse(response)
+
+    @app.exception_handler(UserInactive)
+    async def user_activity_error_handler(
+        request: Request,
+        exc: UserInactive,
+    ):
+        """
+        Логирование всех UserInactive
+        """
+        logger.opt(exception=True).warning(exc)
+        response = dict(
+            status=False,
+            error_code=exc.status_code,
+            message=exc.detail,
+        )
+        return JSONResponse(response)
+
+    @app.exception_handler(UserNotExists)
+    async def user_not_exists_error_handler(
+        request: Request,
+        exc: UserNotExists,
+    ):
+        """
+        Логирование всех UserNotExists
+        """
+        logger.opt(exception=True).warning(exc)
+        response = dict(
+            status=False,
+            error_code=exc.status_code,
+            message=exc.detail,
+        )
+        return JSONResponse(response)
+
+    @app.exception_handler(UserAlreadyExists)
+    async def user_already_exists_error_handler(
+        request: Request,
+        exc: UserAlreadyExists,
+    ):
+        """
+        Логирование всех UserAlreadyExists
+        """
+        logger.opt(exception=True).warning(exc)
+        response = dict(
+            status=False,
+            error_code=exc.status_code,
+            message=exc.detail,
+        )
+        return JSONResponse(response)
+
+    @app.exception_handler(InvalidID)
+    async def invalid_id_error_handler(
+        request: Request,
+        exc: InvalidID,
+    ):
+        """
+        Логирование всех InvalidID
+        """
+        logger.opt(exception=True).warning(exc)
+        response = dict(
+            status=False,
+            error_code=exc.status_code,
+            message=exc.detail,
+        )
+        return JSONResponse(response)
+
+    @app.exception_handler(PasswordNotValidError)
+    async def password_validator_error_handler(
+        request: Request,
+        exc: PasswordNotValidError,
+    ):
+        """
+        Логирование всех PasswordNotValidError
+        """
+        logger.opt(exception=True).warning(exc)
+        response = dict(
+            status=False,
+            error_code=exc.status_code,
+            message=exc.detail,
+        )
+        return JSONResponse(response)
 
     @app.exception_handler(ValidationError)
     async def validation_error_handler(
@@ -109,7 +279,7 @@ async def error_handler(
         return JSONResponse(response)
 
     @app.exception_handler(StarletteHTTPException)
-    async def validation_error_handler(
+    async def validation_starlette_error_handler(
         request: Request,
         exc: StarletteHTTPException,
     ):

app_includes/middlewares.py

@@ -2,6 +2,7 @@
 from fastapi import FastAPI
 
 from config import settings
+from api_v1.users.middlewares import AuthenticationMiddleware
 
 
 def register_middlewares(app: FastAPI) -> None:
@@ -50,3 +51,6 @@ def register_middlewares(app: FastAPI) -> None:
         allow_methods=['*'],
         allow_headers=['*'],
     )
+    app.add_middleware(
+        AuthenticationMiddleware,
+    )

async_alembic/env.py

@@ -8,7 +8,8 @@
 
 from alembic import context
 
-from config import BaseModel, settings
+from config import settings
+from config.models.base import Base
 
 
 # this is the Alembic Config object, which provides
@@ -22,7 +23,7 @@
 
 # add your model's MetaData object here
 # for 'autogenerate' support
-target_metadata = BaseModel.metadata
+target_metadata = Base.metadata
 
 # other values from the config, defined by the needs of env.py,
 # can be acquired:
@@ -91,7 +92,7 @@ def run_migrations_online() -> None:
                 poolclass=pool.NullPool,
                 future=True,
             )
-        ) 
+        )
     if isinstance(connectable, AsyncEngine):
         asyncio.run(run_async_migrations(connectable))
     else: