Merge pull request #6 from Cinnamoon-dev/refactor/services

refactor: services

Author: Cinnamoon-dev

Makefile

@@ -1,5 +1,5 @@
 clean:
-	rm -rf $(shell find . | grep cache)
+	rm -rf $(shell find . | grep __pycache__)
 
 populate:
 	uv run python3 -m src.infra.database.populate

pyproject.toml

@@ -10,7 +10,7 @@ dependencies = [
     "passlib[bcrypt]>=1.7.4",
     "psycopg2-binary>=2.9.10",
     "pydantic[email]>=2.11.7",
-    "pyjwt==2.10.0",
+    "pyjwt>=2.10.1",
     "pytest>=8.4.1",
     "python-multipart>=0.0.20",
     "uvicorn>=0.35.0",

src/controllers/userController.py

@@ -1,3 +1,4 @@
+from fastapi.responses import JSONResponse
 from fastapi import APIRouter, Depends, Request
 
 from ._helpers import PermissionChecker
@@ -23,26 +24,34 @@ def user_view(
     user_id: int, 
     perms = Depends(PermissionChecker("usuario-view"))
 ):
-    return UserService().view(user_id)
+    user = UserService().view(user_id)
+
+    if user is None:
+        return JSONResponse(status_code=404, content={"error": True, "message": f"User with id {user_id} not found"})
+
+    return JSONResponse(status_code=200, content={"error": False, "data": user})
 
 @router.post("/")
 def user_add(
     user: UserAddSchema,
     perms = Depends(PermissionChecker("usuario-add"))
 ):
-    return UserService().add(user)
+    inserted_id = UserService().add(user)
+    return JSONResponse(status_code=200, content={"error": False, "message": f"User inserted successfully", "id": inserted_id})
 
 @router.put("/{user_id:int}")
 def user_edit(
     user_id: int, 
     user: UserEditSchema,
     perms = Depends(PermissionChecker("usuario-edit"))
 ):
-    return UserService().edit(user_id, user)
+    UserService().edit(user_id, user)
+    return JSONResponse(status_code=200, content={"error": False, "message": "User edited successfully"})
 
 @router.delete("/{user_id:int}")
 def user_delete(
     user_id: int,
     perms = Depends(PermissionChecker("usuario-delete"))
 ):
-    return UserService().delete(user_id)
+    UserService().delete(user_id)
+    return JSONResponse(status_code=200, content={"error": False, "message": "User deleted successfully"})

src/controllers/userTypeController.py

@@ -1,3 +1,4 @@
+from fastapi.responses import JSONResponse
 from fastapi import APIRouter, Depends, Request
 
 from ._helpers import PermissionChecker
@@ -21,30 +22,34 @@ def user_type_view(
     user_type_id: int,
     perms = Depends(PermissionChecker("tipo_usuario-view"))
 ):
-    response = UserTypeService().view(user_type_id)
-    return response
+    user_type = UserTypeService().view(user_type_id)
+
+    if user_type is None:
+        return JSONResponse(status_code=404, content={"error": True, "message": f"User type with id {user_type_id} not found"})
+
+    return JSONResponse(status_code=200, content={"error": False, "data": user_type})
 
 @router.post("/")
 def user_type_add(
     user_type: UserTypeSchema,
     perms = Depends(PermissionChecker("tipo_usuario-add"))
 ):
-    response = UserTypeService().add(user_type)
-    return response
+    inserted_id = UserTypeService().add(user_type)
+    return JSONResponse(status_code=200, content={"error": False, "message": f"User type inserted successfully", "id": inserted_id})
 
 @router.put("/{user_type_id:int}")
 def user_type_edit(
     user_type_id: int, 
     user_type: UserTypeSchema,
     perms = Depends(PermissionChecker("tipo_usuario-edit"))
 ):
-    response = UserTypeService().edit(user_type_id, user_type)
-    return response
+    UserTypeService().edit(user_type_id, user_type)
+    return JSONResponse(status_code=200, content={"error": False, "message": "User type edited successfully"})
 
 @router.delete("/{user_type_id:int}")
 def user_type_delete(
     user_type_id: int,
     perms = Depends(PermissionChecker("tipo_usuario-delete"))
 ):
-    response = UserTypeService().delete(user_type_id)
-    return response
+    UserTypeService().delete(user_type_id)
+    return JSONResponse(status_code=200, content={"error": False, "message": "User type deleted successfully"})

src/infra/database/scripts/rules.sql

@@ -1,9 +1,11 @@
 -- Tipo Usuário
 INSERT INTO tipo_usuario (id, nome) VALUES (1, 'admin');
+ALTER SEQUENCE tipo_usuario_id_seq RESTART WITH 2;
 
 -- Usuário
 -- senha: 1234
-INSERT INTO usuario (id, email, senha, tipo_usuario_id) VALUES (1, "admin@email.com", "$6$xvhoMyeu7TlurX6Z$.j4NQGAvbEzu3IKSJAWU8IzTqAGVW8RZ2sUWmJSzJY2QR0VJhm26rOC/0.7UXT3c8YrwoS3y4pUdbWJV7GEZG1", 1)
+INSERT INTO usuario (id, email, senha, tipo_usuario_id) VALUES (1, 'admin@email.com', '$6$xvhoMyeu7TlurX6Z$.j4NQGAvbEzu3IKSJAWU8IzTqAGVW8RZ2sUWmJSzJY2QR0VJhm26rOC/0.7UXT3c8YrwoS3y4pUdbWJV7GEZG1', 1);
+ALTER SEQUENCE usuario_id_seq RESTART WITH 2;
 
 -- Controllers
 INSERT INTO controllers (id, nome) VALUES (1, 'usuario');

src/services/userService.py

@@ -45,40 +45,37 @@ def all(self, query_params: QueryParams) -> dict[str, Any]:
         output = paginate(query, page, rows_per_page, sort) 
         return output
 
-    def view(self, user_id: int) -> dict[str, Any]:
+    def view(self, user_id: int) -> dict[str, Any] | None:
         user = None
 
         try:
             with PgDatabase() as db:
                 db.cursor.execute(f"SELECT {self.all_columns} FROM {self.table} WHERE id = %s", (user_id,))
                 row = db.cursor.fetchone()
-
-                if row is None:
-                    raise HTTPException(status_code=404, detail={"error": True, "message": "Usuário não encontrado"})
         except Exception:
             raise HTTPException(status_code=500, detail={"error": True, "message": "Database error"})
-        
-        user = line_to_dict(row, self.columns)
+ 
+        if row is not None:
+            user = line_to_dict(row, self.columns)
+
         return user
-    
 
-    def view_by_email(self, email: str) -> dict[str, Any]:
+    def view_by_email(self, email: str) -> dict[str, Any] | None:
         user = None
 
         try:
             with PgDatabase() as db:
                 db.cursor.execute(f"SELECT {self.all_columns} FROM {self.table} WHERE email = %s", (email,))
                 row = db.cursor.fetchone()
-
-                if row is None:
-                    raise HTTPException(status_code=404, detail={"error": True, "message": "Usuário não encontrado"})
         except Exception:
             raise HTTPException(status_code=500, detail={"error": True, "message": "Database error"})
 
-        user = line_to_dict(row, self.columns)
+        if row is not None:
+            user = line_to_dict(row, self.columns)
+
         return user
 
-    def add(self, user: UserAddSchema) -> dict[str, Any]:
+    def add(self, user: UserAddSchema) -> int:
         senha = bcrypt_context.hash(user.senha)
 
         try:
@@ -91,12 +88,14 @@ def add(self, user: UserAddSchema) -> dict[str, Any]:
 
                 inserted_id = raw_id[0]
                 db.connection.commit()
+        except HTTPException as e:
+            raise e
         except Exception as e:
             raise HTTPException(status_code=500, detail={"error": True, "message": str(e)})
 
-        return {"error": False, "message": f"Usuário {user.email} adicionado com sucesso.", "id": inserted_id}
+        return inserted_id
 
-    def edit(self, user_id: int, user: UserEditSchema) -> dict[str, Any]:
+    def edit(self, user_id: int, user: UserEditSchema) -> None:
         user_dict = user.model_dump(exclude_none=True)
         if not user_dict:
             raise HTTPException(status_code=200, detail={"error": False, "message": f"Usuário com id {user_id} editado com sucesso."})
@@ -109,14 +108,10 @@ def edit(self, user_id: int, user: UserEditSchema) -> dict[str, Any]:
         except Exception:
             raise HTTPException(status_code=500, detail={"error": True, "message": "Database error"})
 
-        return {"error": False, "message": f"Usuário com id {user_id} editado com sucesso."}
-
-    def delete(self, user_id: int) -> dict[str, Any]:
+    def delete(self, user_id: int) -> None:
         try:
             with PgDatabase() as db:
                 db.cursor.execute(f"DELETE FROM {self.table} WHERE id = %s", (user_id,))
                 db.connection.commit()
         except Exception:
             raise HTTPException(status_code=500, detail={"error": True, "message": "Database error"})
-
-        return {"error": False, "message": f"Usuário com id {user_id} deletado com sucesso."}

src/services/userTypeService.py

@@ -1,7 +1,6 @@
-from functools import reduce
 from typing import Any
+from functools import reduce
 from fastapi import HTTPException
-from fastapi.responses import JSONResponse
 from psycopg2.errors import UniqueViolation
 from fastapi.datastructures import QueryParams
 
@@ -39,26 +38,25 @@ def all(self, query_params: QueryParams) -> dict[str, Any]:
             if sort_order.lower() not in ["asc", "desc"]:
                 raise HTTPException(status_code=422, detail={"error": True, "message": f"Direção de ordenação {sort_order} inválida, deve ser 'asc' ou 'desc'"})
 
-        output = paginate(query, page, rows_per_page, sort) 
+        output = paginate(query, page, rows_per_page, sort)
         return output
 
-    def view(self, user_type_id: int) -> dict[str, Any]:
+    def view(self, user_type_id: int) -> dict[str, Any] | None:
         user_type = None
 
         try:
             with PgDatabase() as db:
                 db.cursor.execute(f"SELECT {self.all_columns} FROM {self.table} WHERE id = %s", (user_type_id,))
                 row = db.cursor.fetchone()
-
-                if row is None:
-                    raise HTTPException(status_code=404, detail={"error": True, "message": "Tipo de usuário não encontrado"})
         except Exception:
             raise HTTPException(status_code=500, detail={"error": True, "message": "Database error"})
 
-        user_type = line_to_dict(row, self.columns)
+        if row is not None:
+            user_type = line_to_dict(row, self.columns)
+
         return user_type
 
-    def add(self, user_type: UserTypeSchema) -> dict[str, Any]:
+    def add(self, user_type: UserTypeSchema) -> int:
         try:
             with PgDatabase() as db:
                 db.cursor.execute(f"INSERT INTO {self.table} (nome) VALUES (%s) RETURNING id", (user_type.nome,))
@@ -74,9 +72,9 @@ def add(self, user_type: UserTypeSchema) -> dict[str, Any]:
         except Exception:
             raise HTTPException(status_code=500, detail={"error": True, "message": "Database error"})
 
-        return {"error": False, "message": f"Tipo de usuário {user_type.nome} adicionado com sucesso.", "id": inserted_id}
+        return inserted_id
 
-    def edit(self, user_type_id: int, user_type: UserTypeSchema) -> dict[str, Any]:
+    def edit(self, user_type_id: int, user_type: UserTypeSchema) -> None:
         user_type_dict = user_type.model_dump(exclude_none=True)
         if not user_type_dict:
             raise HTTPException(status_code=200, detail={"error": False, "message": f"Tipo de usuário com id {user_type_id} editado com sucesso."})
@@ -91,14 +89,10 @@ def edit(self, user_type_id: int, user_type: UserTypeSchema) -> dict[str, Any]:
         except Exception as e:
             raise HTTPException(status_code=500, detail={"error": True, "message": str(e)})
 
-        return {"error": False, "message": f"Tipo de usuário com id {user_type_id} editado com sucesso."}
-    
-    def delete(self, user_type_id: int) -> dict[str, Any]:
+    def delete(self, user_type_id: int) -> None:
         try:
             with PgDatabase() as db:
                 db.cursor.execute(f"DELETE FROM {self.table} WHERE id = %s", (user_type_id,))
                 db.connection.commit()
         except Exception:
             raise HTTPException(status_code=500, detail={"error": True, "message": "Database error"})
-
-        return {"error": False, "message": f"Tipo de usuário com id {user_type_id} deletado com sucesso."}

src/tests/test_userType.py

@@ -41,8 +41,13 @@ def create_user_type(name: str) -> dict[str, str]:
     return user_type
 
 @pytest.fixture(scope="session")
-def headers():
-    return {"Content-Type": "application/json", "accept": "application/json"}
+def headers(client):
+    base_headers = {"Content-Type": "application/x-www-form-urlencoded", "accept": "application/json"}
+    admin_user = {"username": "admin@email.com", "password": "1234"}
+
+    response = client.post("/auth/login", data=admin_user, headers=base_headers).json()
+    headers = {"Content-Type": "application/json", "accept": "application/json", "Authorization": f"{response["token_type"]} {response["access_token"]}"}
+    return headers
 
 @pytest.fixture(scope="session")
 def client():
@@ -115,12 +120,12 @@ def test_delete_unused_user_type(client, headers):
     mocked_type = create_user_type("type_to_delete")
     mocked_id = client.post("/user/type", json=mocked_type, headers=headers).json()["id"]
 
-    response = client.delete(f"/user/type/{mocked_id}")
+    response = client.delete(f"/user/type/{mocked_id}", headers=headers)
     assert response.status_code == 200
 
 def test_delete_nonexistent_user_type(client, headers):
     mocked_type = create_user_type("nonexistent_user_type")
     mocked_id = client.post("/user/type", json=mocked_type, headers=headers).json()["id"]
 
-    response = client.delete(f"/user/type/{mocked_id + 1999}")
+    response = client.delete(f"/user/type/{mocked_id + 1999}", headers=headers)
     assert response.status_code == 200