✨ Add (module): User router to include its path operations

jpcadena · jpcadena · commit c46a5f3a284a · 2024-05-07T22:56:14.000-05:00
diff --git a/app/api/api_v1/router/user.py b/app/api/api_v1/router/user.py
@@ -4,6 +4,251 @@
  for users.
 """
 
-from fastapi import APIRouter
+import logging
+from typing import Annotated, Optional
 
+from fastapi import APIRouter, Body, Depends, HTTPException, Response, status
+from fastapi.params import Path, Query
+from pydantic import NonNegativeInt, PositiveInt
+
+from app.config.exceptions import (
+    DatabaseException,
+    NotFoundException,
+    ServiceException,
+)
+from app.config.init_settings import init_setting
+from app.crud.user import UserRepository, get_user_repository
+from app.schemas.user import User, UserCreate, UserUpdate, UsersResponse
+
+logger: logging.Logger = logging.getLogger(__name__)
 router: APIRouter = APIRouter(prefix="/user", tags=["user"])
+
+
+@router.get("", response_model=UsersResponse)
+def get_users(
+    user_repository: Annotated[UserRepository, Depends(get_user_repository)],
+    skip: Annotated[
+        NonNegativeInt,
+        Query(
+            annotation=Optional[NonNegativeInt],
+            title="Skip",
+            description="Skip users",
+            example=0,
+            openapi_examples=init_setting.SKIP_EXAMPLES,
+        ),
+    ] = 0,
+    limit: Annotated[
+        PositiveInt | None,
+        Query(
+            annotation=Optional[PositiveInt],
+            title="Limit",
+            description="Limit pagination",
+            ge=1,
+            le=100,
+            example=100,
+            openapi_examples=init_setting.LIMIT_EXAMPLES,
+        ),
+    ] = 100,
+) -> UsersResponse:
+    """
+    Retrieve all users' basic information from the system using
+     pagination.
+    ## Parameters:
+    - `:param skip:` **Offset from where to start returning users**
+    - `:type skip:` **NonNegativeInt**
+    - `:param limit:` **Limit the number of results from query**
+    - `:type limit:` **PositiveInt**
+    ## Response:
+    - `:return:` **List of Users retrieved from database**
+    - `:rtype:` **UsersResponse**
+    \f
+    :param user_repository: Dependency method for user service layer
+    :type user_repository: UserRepository
+    """
+    try:
+        found_users: list[User] = user_repository.read_users(skip, limit)
+    except ServiceException as exc:
+        logger.error(exc)
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)
+        ) from exc
+    users: UsersResponse = UsersResponse(users=found_users)
+    return users
+
+
+@router.post("", response_model=User, status_code=status.HTTP_201_CREATED)
+def create_user(
+    user: Annotated[
+        UserCreate,
+        Body(
+            ...,
+            title="User data",
+            description="User data to create",
+            openapi_examples=init_setting.USER_CREATE_EXAMPLES,
+        ),
+    ],
+    user_repository: Annotated[UserRepository, Depends(get_user_repository)],
+) -> User:
+    """
+    Register new user into the system.
+    ## Parameter:
+    - `:param user:` **Body Object for user creation.**
+    - `:type user:` **UserCreate**
+    ## Response:
+    - `:return:` **User created with its data**
+    - `:rtype:` **User**
+    \f
+    :param user_repository: Dependency method for user service layer
+    :type user_repository: UserRepository
+    """
+    try:
+        new_user: User | None = user_repository.create_user(user)
+    except ServiceException as exc:
+        detail: str = "Error at creating user."
+        logger.error(detail)
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail=detail
+        ) from exc
+    if not new_user:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="User could not be created",
+        )
+    return new_user
+
+
+@router.get("/{user_id}", response_model=User)
+def get_user_by_id(
+    user_repository: Annotated[UserRepository, Depends(get_user_repository)],
+    user_id: Annotated[
+        PositiveInt,
+        Path(
+            ...,
+            title="User ID",
+            annotation=PositiveInt,
+            description="ID of the User to be searched",
+            example=1,
+        ),
+    ],
+) -> User:
+    """
+    Retrieve an existing user's information given their user ID.
+    ## Parameter:
+    - `:param user_id:` **Unique identifier of the user to be retrieved**
+    - `:type user_id:` **PositiveInt**
+    ## Response:
+    - `:return:` **Found user with the given ID.**
+    - `:rtype:` **User**
+    \f
+    :param user_repository: Dependency method for user service layer
+    :type user_repository: UserRepository
+    """
+    try:
+        user: User = user_repository.read_by_id(user_id)
+    except ServiceException as exc:
+        detail: str = f"User with id {user_id} not found in the system."
+        logger.error(detail)
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail=detail
+        ) from exc
+    except NotFoundException as not_found_exc:
+        logger.error(not_found_exc)
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail=str(not_found_exc)
+        ) from not_found_exc
+    return user
+
+
+@router.put("/{user_id}", response_model=User)
+def update_user(
+    user_repository: Annotated[UserRepository, Depends(get_user_repository)],
+    user_id: Annotated[
+        PositiveInt,
+        Path(
+            ...,
+            title="User ID",
+            annotation=PositiveInt,
+            description="ID of the User to be searched",
+            example=1,
+        ),
+    ],
+    user_in: Annotated[
+        UserUpdate,
+        Body(
+            ...,
+            title="User data",
+            description="New user data to update",
+            openapi_examples=init_setting.USER_UPDATE_EXAMPLES,
+        ),
+    ],
+) -> User | None:
+    """
+    Update an existing user's information given their user ID and new
+     information.
+    ## Parameters:
+    - `:param user_id:` **Unique identifier of the user to be updated**
+    - `:type user_id:` **PositiveInt**
+    - `:param user_in:` **New user data to update that can include:
+     username, email, first_name, middle_name, last_name, password,
+      gender, birthdate, phone_number, city and country.**
+    - `:type user_in:` **UserUpdate**
+    ## Response:
+    - `:return:` **Updated user with the given ID and its data**
+    - `:rtype:` **User**
+    \f
+    :param user_repository: Dependency method for user service layer
+    :type user_repository: UserRepository
+    """
+    try:
+        user: User | None = user_repository.update_user(user_id, user_in)
+    except ServiceException as exc:
+        detail: str = f"User with id {user_id} not found in the system."
+        logger.error(detail)
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail=detail
+        ) from exc
+    return user
+
+
+@router.delete("/{user_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_user(
+    user_repository: Annotated[UserRepository, Depends(get_user_repository)],
+    user_id: Annotated[
+        PositiveInt,
+        Path(
+            ...,
+            title="User ID",
+            annotation=PositiveInt,
+            description="ID of the User to be searched",
+            example=1,
+        ),
+    ],
+) -> Response:
+    """
+    Delete an existing user given their user ID.
+    ## Parameter:
+    - `:param user_id:` **Unique identifier of the user to be deleted**
+    - `:type user_id:` **PositiveInt**
+    ## Response:
+    - `:return:` **Json Response object with the deleted information**
+    - `:rtype:` **Response**
+    \f
+    :param user_repository: Dependency method for user service layer
+    :type user_repository: UserRepository
+    """
+    try:
+        delete_result = user_repository.delete_user(user_id)
+    except DatabaseException as exc:
+        logger.error(f"Failed to delete user with ID {user_id}: {exc}")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"User with ID {user_id} not found.",
+        ) from exc
+    response: Response = Response(status_code=status.HTTP_204_NO_CONTENT)
+    response.headers["deleted"] = delete_result["deleted"].lower()
+    response.headers["deleted_at"] = (
+        delete_result["deleted_at"].isoformat()
+        if delete_result["deleted_at"]
+        else "null"
+    )
+    return response
diff --git a/app/config/exceptions.py b/app/config/exceptions.py
@@ -5,7 +5,7 @@
 from sqlalchemy.exc import SQLAlchemyError
 
 
-class DatabaseException(SQLAlchemyError):  # type: ignore
+class DatabaseException(SQLAlchemyError):
     """
     Database Exception class
     """
@@ -16,7 +16,7 @@ def __init__(self, message: str, note: str | None = None):
             self.add_note(note)
 
 
-class ServiceException(Exception):  # type: ignore
+class ServiceException(Exception):
     """
     Service Layer Exception class
     """
@@ -25,3 +25,14 @@ def __init__(self, message: str, note: str | None = None):
         super().__init__(message)
         if note:
             self.add_note(note)
+
+
+class NotFoundException(Exception):
+    """
+    Not Found Exception class
+    """
+
+    def __init__(self, message: str, note: str | None = None):
+        super().__init__(message)
+        if note:
+            self.add_note(note)
diff --git a/app/crud/user.py b/app/crud/user.py
@@ -10,13 +10,14 @@
 from pydantic import NonNegativeInt, PositiveInt
 from sqlalchemy import Row, RowMapping, select
 from sqlalchemy.engine import ScalarResult
-from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.exc import NoResultFound, SQLAlchemyError
 from sqlalchemy.orm import Session
 from sqlalchemy.sql import Select
 
 from app.config.exceptions import DatabaseException
 from app.db.session import get_session
 from app.models.user import User
+from app.schemas.user import User as UserSchema
 from app.schemas.user import UserCreate, UserUpdate
 
 logger: logging.Logger = logging.getLogger(__name__)
@@ -59,8 +60,8 @@ def read_by_id(self, _id: PositiveInt) -> User:
     def read_users(
         self,
         offset: NonNegativeInt,
-        limit: PositiveInt,
-    ) -> list[User]:
+        limit: PositiveInt | None,
+    ) -> list[UserSchema]:
         """
         Retrieve a list of users from the database, with pagination
         :param offset: The number of users to skip before starting to
@@ -69,7 +70,7 @@ def read_users(
         :param limit: The maximum number of users to return
         :type limit: PositiveInt
         :return: A list of users
-        :rtype: list[User]
+        :rtype: list[UserSchema]
         """
         stmt: Select[tuple[User]] = select(User).offset(offset).limit(limit)
         with self.session as session:
@@ -82,7 +83,7 @@ def read_users(
             except SQLAlchemyError as sa_exc:
                 logger.error(sa_exc)
                 raise DatabaseException(str(sa_exc)) from sa_exc
-            return users
+            return [UserSchema.model_validate(user) for user in users]
 
     def create_user(
         self,
@@ -146,31 +147,40 @@ def update_user(self, _id: PositiveInt, user: UserUpdate) -> User | None:
                 raise DatabaseException(str(db_exc)) from db_exc
             return updated_user
 
-    def delete_user(self, _id: PositiveInt) -> bool:
+    def delete_user(self, _id: PositiveInt) -> dict[str, Any]:
         """
         Delete a user from the database
         :param _id: The id of the user to delete
         :type _id: PositiveInt
-        :return: True if the user is deleted; otherwise False
-        :rtype: bool
+        :return: Data to confirmation info about the delete process
+        :rtype: dict[str, Any]
         """
         with self.session as session:
             try:
-                found_user: User | None = self.read_by_id(_id)
-            except DatabaseException as db_exc:
-                raise DatabaseException(str(db_exc)) from db_exc
-            if not found_user:
-                raise DatabaseException(
-                    f"User with ID: {_id} could not be deleted"
+                exists_query = (
+                    session.query(User).filter(User.id == _id).exists()
+                )
+                if not session.query(exists_query).scalar():
+                    raise NoResultFound(f"No user found with ID: {_id}")
+                delete_query = (
+                    session.query(User).filter(User.id == _id).delete()
                 )
-            try:
-                session.delete(found_user)
                 session.commit()
-            except SQLAlchemyError as sa_exc:
-                logger.error(sa_exc)
+                if delete_query == 0:
+                    raise NoResultFound(
+                        f"No user found with ID: {_id} to delete"
+                    )
+                deleted: bool = True
+                deleted_at: datetime = datetime.now()
+            except (SQLAlchemyError, NoResultFound) as e:
                 session.rollback()
-                return False
-            return True
+                logger.error(
+                    f"Failed to delete user with ID: {_id}, Error: {str(e)}"
+                )
+                raise DatabaseException(
+                    f"Could not delete user with ID: {_id}. Error: {str(e)}"
+                ) from e
+        return {"ok": deleted, "deleted_at": deleted_at}
 
 
 def get_user_repository() -> UserRepository:
