._.

app/infrastructure/fastapi/city_routes.py

@@ -3,21 +3,25 @@ from typing import List
 from fastapi import APIRouter, HTTPException, Depends
 from sqlalchemy.orm import Session
 
+from app.core.usecases.auth_service import verify_token
 from app.infrastructure.database.dependencies import get_db
 from app.core.entities.city import CityEntity
 from app.core.usecases.city_service import CitiesService
+from app.infrastructure.database.models.users import User
 
 router = APIRouter()
 
 
 @router.get("/cities", response_model=List[CityEntity])
-def read_cities(db: Session = Depends(get_db)):
+def read_cities(db: Session = Depends(get_db),
+                current_user: User = Depends(verify_token)):
     service = CitiesService(db)
     return service.get_all_cities()
 
 
 @router.get("/cities/{city_id}", response_model=CityEntity)
-def read_city(city_id: int, db: Session = Depends(get_db)):
+def read_city(city_id: int, db: Session = Depends(get_db),
+              current_user: User = Depends(verify_token)):
     service = CitiesService(db)
     city = service.get_city_by_id(city_id)
     if city is None:
@@ -26,13 +30,15 @@ def read_city(city_id: int, db: Session = Depends(get_db)):
 
 
 @router.post("/cities", response_model=CityEntity)
-def create_city(city: CityEntity, db: Session = Depends(get_db)):
+def create_city(city: CityEntity, db: Session = Depends(get_db),
+                current_user: User = Depends(verify_token)):
     service = CitiesService(db)
     return service.create_city(city)
 
 
 @router.put("/cities/{city_id}", response_model=CityEntity)
-def update_city(city_id: int, city: CityEntity, db: Session = Depends(get_db)):
+def update_city(city_id: int, city: CityEntity, db: Session = Depends(get_db),
+                current_user: User = Depends(verify_token)):
     service = CitiesService(db)
     updated_city = service.update_city(city_id, city)
     if updated_city is None:
@@ -41,7 +47,8 @@ def update_city(city_id: int, city: CityEntity, db: Session = Depends(get_db)):
 
 
 @router.delete("/cities/{city_id}", response_model=bool)
-def delete_city(city_id: int, db: Session = Depends(get_db)):
+def delete_city(city_id: int, db: Session = Depends(get_db),
+                current_user: User = Depends(verify_token)):
     service = CitiesService(db)
     success = service.delete_city(city_id)
     if not success:

app/infrastructure/fastapi/delivery_accessory_routes.py

@@ -3,21 +3,25 @@ from typing import List
 from fastapi import APIRouter, HTTPException, Depends
 from sqlalchemy.orm import Session
 
+from app.core.usecases.auth_service import verify_token
 from app.infrastructure.database.dependencies import get_db
 from app.core.entities.delivery_accessory import DeliveryAccessoryEntity
 from app.core.usecases.delivery_accessory_service import DeliveryAccessoriesService
+from app.infrastructure.database.models.users import User
 
 router = APIRouter()
 
 
 @router.get("/delivery-accessories", response_model=List[DeliveryAccessoryEntity])
-def read_delivery_accessories(db: Session = Depends(get_db)):
+def read_delivery_accessories(db: Session = Depends(get_db),
+                              current_user: User = Depends(verify_token)):
     service = DeliveryAccessoriesService(db)
     return service.get_all_delivery_accessories()
 
 
 @router.get("/delivery-accessories/{delivery_accessory_id}", response_model=DeliveryAccessoryEntity)
-def read_delivery_accessory(delivery_accessory_id: int, db: Session = Depends(get_db)):
+def read_delivery_accessory(delivery_accessory_id: int, db: Session = Depends(get_db),
+                            current_user: User = Depends(verify_token)):
     service = DeliveryAccessoriesService(db)
     delivery_accessory = service.get_delivery_accessory_by_id(delivery_accessory_id)
     if delivery_accessory is None:
@@ -26,14 +30,16 @@ def read_delivery_accessory(delivery_accessory_id: int, db: Session = Depends(ge
 
 
 @router.post("/delivery-accessories", response_model=DeliveryAccessoryEntity)
-def create_delivery_accessory(delivery_accessory: DeliveryAccessoryEntity, db: Session = Depends(get_db)):
+def create_delivery_accessory(delivery_accessory: DeliveryAccessoryEntity, db: Session = Depends(get_db),
+                              current_user: User = Depends(verify_token)):
     service = DeliveryAccessoriesService(db)
     return service.create_delivery_accessory(delivery_accessory)
 
 
 @router.put("/delivery-accessories/{delivery_accessory_id}", response_model=DeliveryAccessoryEntity)
 def update_delivery_accessory(delivery_accessory_id: int, delivery_accessory: DeliveryAccessoryEntity,
-                              db: Session = Depends(get_db)):
+                              db: Session = Depends(get_db),
+                              current_user: User = Depends(verify_token)):
     service = DeliveryAccessoriesService(db)
     updated_delivery_accessory = service.update_delivery_accessory(delivery_accessory_id, delivery_accessory)
     if updated_delivery_accessory is None:
@@ -42,7 +48,8 @@ def update_delivery_accessory(delivery_accessory_id: int, delivery_accessory: De
 
 
 @router.delete("/delivery-accessories/{delivery_accessory_id}", response_model=bool)
-def delete_delivery_accessory(delivery_accessory_id: int, db: Session = Depends(get_db)):
+def delete_delivery_accessory(delivery_accessory_id: int, db: Session = Depends(get_db),
+                              current_user: User = Depends(verify_token)):
     service = DeliveryAccessoriesService(db)
     success = service.delete_delivery_accessory(delivery_accessory_id)
     if not success:

app/infrastructure/fastapi/delivery_order_routes.py

@@ -3,21 +3,25 @@ from typing import List
 from fastapi import APIRouter, HTTPException, Depends
 from sqlalchemy.orm import Session
 
+from app.core.usecases.auth_service import verify_token
 from app.infrastructure.database.dependencies import get_db
 from app.core.entities.delivery_order import DeliveryOrderEntity
 from app.core.usecases.delivery_order_service import DeliveryOrdersService
+from app.infrastructure.database.models.users import User
 
 router = APIRouter()
 
 
 @router.get("/delivery-orders", response_model=List[DeliveryOrderEntity])
-def read_delivery_orders(db: Session = Depends(get_db)):
+def read_delivery_orders(db: Session = Depends(get_db),
+                         current_user: User = Depends(verify_token)):
     service = DeliveryOrdersService(db)
     return service.get_all_delivery_orders()
 
 
 @router.get("/delivery-orders/{delivery_order_id}", response_model=DeliveryOrderEntity)
-def read_delivery_order(delivery_order_id: int, db: Session = Depends(get_db)):
+def read_delivery_order(delivery_order_id: int, db: Session = Depends(get_db),
+                        current_user: User = Depends(verify_token)):
     service = DeliveryOrdersService(db)
     delivery_order = service.get_delivery_order_by_id(delivery_order_id)
     if delivery_order is None:
@@ -26,13 +30,15 @@ def read_delivery_order(delivery_order_id: int, db: Session = Depends(get_db)):
 
 
 @router.post("/delivery-orders", response_model=DeliveryOrderEntity)
-def create_delivery_order(delivery_order: DeliveryOrderEntity, db: Session = Depends(get_db)):
+def create_delivery_order(delivery_order: DeliveryOrderEntity, db: Session = Depends(get_db),
+                          current_user: User = Depends(verify_token)):
     service = DeliveryOrdersService(db)
     return service.create_delivery_order(delivery_order)
 
 
 @router.put("/delivery-orders/{delivery_order_id}", response_model=DeliveryOrderEntity)
-def update_delivery_order(delivery_order_id: int, delivery_order: DeliveryOrderEntity, db: Session = Depends(get_db)):
+def update_delivery_order(delivery_order_id: int, delivery_order: DeliveryOrderEntity, db: Session = Depends(get_db),
+                          current_user: User = Depends(verify_token)):
     service = DeliveryOrdersService(db)
     updated_delivery_order = service.update_delivery_order(delivery_order_id, delivery_order)
     if updated_delivery_order is None:
@@ -41,7 +47,8 @@ def update_delivery_order(delivery_order_id: int, delivery_order: DeliveryOrderE
 
 
 @router.delete("/delivery-orders/{delivery_order_id}", response_model=bool)
-def delete_delivery_order(delivery_order_id: int, db: Session = Depends(get_db)):
+def delete_delivery_order(delivery_order_id: int, db: Session = Depends(get_db),
+                          current_user: User = Depends(verify_token)):
     service = DeliveryOrdersService(db)
     success = service.delete_delivery_order(delivery_order_id)
     if not success:

app/infrastructure/fastapi/federal_district_routes.py

@@ -3,21 +3,25 @@ from typing import List
 from fastapi import APIRouter, HTTPException, Depends
 from sqlalchemy.orm import Session
 
+from app.core.usecases.auth_service import verify_token
 from app.infrastructure.database.dependencies import get_db
 from app.core.entities.federal_district import FederalDistrictEntity
 from app.core.usecases.federal_district_service import FederalDistrictsService
+from app.infrastructure.database.models.users import User
 
 router = APIRouter()
 
 
 @router.get("/federal-districts", response_model=List[FederalDistrictEntity])
-def read_federal_districts(db: Session = Depends(get_db)):
+def read_federal_districts(db: Session = Depends(get_db),
+                           current_user: User = Depends(verify_token)):
     service = FederalDistrictsService(db)
     return service.get_all_federal_districts()
 
 
 @router.get("/federal-districts/{federal_district_id}", response_model=FederalDistrictEntity)
-def read_federal_district(federal_district_id: int, db: Session = Depends(get_db)):
+def read_federal_district(federal_district_id: int, db: Session = Depends(get_db),
+                          current_user: User = Depends(verify_token)):
     service = FederalDistrictsService(db)
     federal_district = service.get_federal_district_by_id(federal_district_id)
     if federal_district is None:
@@ -26,14 +30,16 @@ def read_federal_district(federal_district_id: int, db: Session = Depends(get_db
 
 
 @router.post("/federal-districts", response_model=FederalDistrictEntity)
-def create_federal_district(federal_district: FederalDistrictEntity, db: Session = Depends(get_db)):
+def create_federal_district(federal_district: FederalDistrictEntity, db: Session = Depends(get_db),
+                            current_user: User = Depends(verify_token)):
     service = FederalDistrictsService(db)
     return service.create_federal_district(federal_district)
 
 
 @router.put("/federal-districts/{federal_district_id}", response_model=FederalDistrictEntity)
 def update_federal_district(federal_district_id: int, federal_district: FederalDistrictEntity,
-                            db: Session = Depends(get_db)):
+                            db: Session = Depends(get_db),
+                            current_user: User = Depends(verify_token)):
     service = FederalDistrictsService(db)
     updated_federal_district = service.update_federal_district(federal_district_id, federal_district)
     if updated_federal_district is None:
@@ -42,7 +48,8 @@ def update_federal_district(federal_district_id: int, federal_district: FederalD
 
 
 @router.delete("/federal-districts/{federal_district_id}", response_model=bool)
-def delete_federal_district(federal_district_id: int, db: Session = Depends(get_db)):
+def delete_federal_district(federal_district_id: int, db: Session = Depends(get_db),
+                            current_user: User = Depends(verify_token)):
     service = FederalDistrictsService(db)
     success = service.delete_federal_district(federal_district_id)
     if not success:

app/infrastructure/fastapi/role_routes.py

@@ -3,21 +3,25 @@ from typing import List
 from fastapi import APIRouter, HTTPException, Depends
 from sqlalchemy.orm import Session
 
+from app.core.usecases.auth_service import verify_token
 from app.infrastructure.database.dependencies import get_db
 from app.core.entities.role import RoleEntity
 from app.core.usecases.role_service import RolesService
+from app.infrastructure.database.models.users import User
 
 router = APIRouter()
 
 
 @router.get("/roles", response_model=List[RoleEntity])
-def read_roles(db: Session = Depends(get_db)):
+def read_roles(db: Session = Depends(get_db),
+               current_user: User = Depends(verify_token)):
     service = RolesService(db)
     return service.get_all_roles()
 
 
 @router.get("/roles/{role_id}", response_model=RoleEntity)
-def read_role(role_id: int, db: Session = Depends(get_db)):
+def read_role(role_id: int, db: Session = Depends(get_db),
+              current_user: User = Depends(verify_token)):
     service = RolesService(db)
     role = service.get_role_by_id(role_id)
     if role is None:
@@ -26,13 +30,15 @@ def read_role(role_id: int, db: Session = Depends(get_db)):
 
 
 @router.post("/roles", response_model=RoleEntity)
-def create_role(role: RoleEntity, db: Session = Depends(get_db)):
+def create_role(role: RoleEntity, db: Session = Depends(get_db),
+                current_user: User = Depends(verify_token)):
     service = RolesService(db)
     return service.create_role(role)
 
 
 @router.put("/roles/{role_id}", response_model=RoleEntity)
-def update_role(role_id: int, role: RoleEntity, db: Session = Depends(get_db)):
+def update_role(role_id: int, role: RoleEntity, db: Session = Depends(get_db),
+                current_user: User = Depends(verify_token)):
     service = RolesService(db)
     updated_role = service.update_role(role_id, role)
     if updated_role is None:
@@ -41,7 +47,8 @@ def update_role(role_id: int, role: RoleEntity, db: Session = Depends(get_db)):
 
 
 @router.delete("/roles/{role_id}", response_model=bool)
-def delete_role(role_id: int, db: Session = Depends(get_db)):
+def delete_role(role_id: int, db: Session = Depends(get_db),
+                current_user: User = Depends(verify_token)):
     service = RolesService(db)
     success = service.delete_role(role_id)
     if not success:

app/infrastructure/fastapi/status_routes.py

@@ -3,21 +3,25 @@ from typing import List
 from fastapi import APIRouter, HTTPException, Depends
 from sqlalchemy.orm import Session
 
+from app.core.usecases.auth_service import verify_token
 from app.infrastructure.database.dependencies import get_db
 from app.core.entities.status import StatusEntity
 from app.core.usecases.status_service import StatusesService
+from app.infrastructure.database.models.users import User
 
 router = APIRouter()
 
 
 @router.get("/statuses", response_model=List[StatusEntity])
-def read_statuses(db: Session = Depends(get_db)):
+def read_statuses(db: Session = Depends(get_db),
+                  current_user: User = Depends(verify_token)):
     service = StatusesService(db)
     return service.get_all_statuses()
 
 
 @router.get("/statuses/{status_id}", response_model=StatusEntity)
-def read_status(status_id: int, db: Session = Depends(get_db)):
+def read_status(status_id: int, db: Session = Depends(get_db),
+                current_user: User = Depends(verify_token)):
     service = StatusesService(db)
     status = service.get_status_by_id(status_id)
     if status is None:
@@ -26,13 +30,15 @@ def read_status(status_id: int, db: Session = Depends(get_db)):
 
 
 @router.post("/statuses", response_model=StatusEntity)
-def create_status(status: StatusEntity, db: Session = Depends(get_db)):
+def create_status(status: StatusEntity, db: Session = Depends(get_db),
+                  current_user: User = Depends(verify_token)):
     service = StatusesService(db)
     return service.create_status(status)
 
 
 @router.put("/statuses/{status_id}", response_model=StatusEntity)
-def update_status(status_id: int, status: StatusEntity, db: Session = Depends(get_db)):
+def update_status(status_id: int, status: StatusEntity, db: Session = Depends(get_db),
+                  current_user: User = Depends(verify_token)):
     service = StatusesService(db)
     updated_status = service.update_status(status_id, status)
     if updated_status is None:
@@ -41,7 +47,8 @@ def update_status(status_id: int, status: StatusEntity, db: Session = Depends(ge
 
 
 @router.delete("/statuses/{status_id}", response_model=bool)
-def delete_status(status_id: int, db: Session = Depends(get_db)):
+def delete_status(status_id: int, db: Session = Depends(get_db),
+                  current_user: User = Depends(verify_token)):
     service = StatusesService(db)
     success = service.delete_status(status_id)
     if not success:

app/infrastructure/fastapi/total_order_routes.py

@@ -3,21 +3,25 @@ from typing import List
 from fastapi import APIRouter, HTTPException, Depends
 from sqlalchemy.orm import Session
 
+from app.core.usecases.auth_service import verify_token
 from app.infrastructure.database.dependencies import get_db
 from app.core.entities.total_order import TotalOrderEntity
 from app.core.usecases.total_order_service import TotalOrdersService
+from app.infrastructure.database.models.users import User
 
 router = APIRouter()
 
 
 @router.get("/total-orders", response_model=List[TotalOrderEntity])
-def read_total_orders(db: Session = Depends(get_db)):
+def read_total_orders(db: Session = Depends(get_db),
+                      current_user: User = Depends(verify_token)):
     service = TotalOrdersService(db)
     return service.get_all_total_orders()
 
 
 @router.get("/total-orders/{total_order_id}", response_model=TotalOrderEntity)
-def read_total_order(total_order_id: int, db: Session = Depends(get_db)):
+def read_total_order(total_order_id: int, db: Session = Depends(get_db),
+                     current_user: User = Depends(verify_token)):
     service = TotalOrdersService(db)
     total_order = service.get_total_order_by_id(total_order_id)
     if total_order is None:
@@ -26,13 +30,15 @@ def read_total_order(total_order_id: int, db: Session = Depends(get_db)):
 
 
 @router.post("/total-orders", response_model=TotalOrderEntity)
-def create_total_order(total_order: TotalOrderEntity, db: Session = Depends(get_db)):
+def create_total_order(total_order: TotalOrderEntity, db: Session = Depends(get_db),
+                       current_user: User = Depends(verify_token)):
     service = TotalOrdersService(db)
     return service.create_total_order(total_order)
 
 
 @router.put("/total-orders/{total_order_id}", response_model=TotalOrderEntity)
-def update_total_order(total_order_id: int, total_order: TotalOrderEntity, db: Session = Depends(get_db)):
+def update_total_order(total_order_id: int, total_order: TotalOrderEntity, db: Session = Depends(get_db),
+                       current_user: User = Depends(verify_token)):
     service = TotalOrdersService(db)
     updated_total_order = service.update_total_order(total_order_id, total_order)
     if updated_total_order is None:
@@ -41,7 +47,8 @@ def update_total_order(total_order_id: int, total_order: TotalOrderEntity, db: S
 
 
 @router.delete("/total-orders/{total_order_id}", response_model=bool)
-def delete_total_order(total_order_id: int, db: Session = Depends(get_db)):
+def delete_total_order(total_order_id: int, db: Session = Depends(get_db),
+                       current_user: User = Depends(verify_token)):
     service = TotalOrdersService(db)
     success = service.delete_total_order(total_order_id)
     if not success:

app/infrastructure/fastapi/truck_routes.py

@@ -3,21 +3,25 @@ from typing import List
 from fastapi import APIRouter, HTTPException, Depends
 from sqlalchemy.orm import Session
 
+from app.core.usecases.auth_service import verify_token
 from app.infrastructure.database.dependencies import get_db
 from app.core.entities.truck import TruckEntity
 from app.core.usecases.truck_service import TrucksService
+from app.infrastructure.database.models.users import User
 
 router = APIRouter()
 
 
 @router.get("/trucks", response_model=List[TruckEntity])
-def read_trucks(db: Session = Depends(get_db)):
+def read_trucks(db: Session = Depends(get_db),
+                current_user: User = Depends(verify_token)):
     service = TrucksService(db)
     return service.get_all_trucks()
 
 
 @router.get("/trucks/{truck_id}", response_model=TruckEntity)
-def read_truck(truck_id: int, db: Session = Depends(get_db)):
+def read_truck(truck_id: int, db: Session = Depends(get_db),
+               current_user: User = Depends(verify_token)):
     service = TrucksService(db)
     truck = service.get_truck_by_id(truck_id)
     if truck is None:
@@ -26,13 +30,15 @@ def read_truck(truck_id: int, db: Session = Depends(get_db)):
 
 
 @router.post("/trucks", response_model=TruckEntity)
-def create_truck(truck: TruckEntity, db: Session = Depends(get_db)):
+def create_truck(truck: TruckEntity, db: Session = Depends(get_db),
+                 current_user: User = Depends(verify_token)):
     service = TrucksService(db)
     return service.create_truck(truck)
 
 
 @router.put("/trucks/{truck_id}", response_model=TruckEntity)
-def update_truck(truck_id: int, truck: TruckEntity, db: Session = Depends(get_db)):
+def update_truck(truck_id: int, truck: TruckEntity, db: Session = Depends(get_db),
+                 current_user: User = Depends(verify_token)):
     service = TrucksService(db)
     updated_truck = service.update_truck(truck_id, truck)
     if updated_truck is None:
@@ -41,7 +47,8 @@ def update_truck(truck_id: int, truck: TruckEntity, db: Session = Depends(get_db
 
 
 @router.delete("/trucks/{truck_id}", response_model=bool)
-def delete_truck(truck_id: int, db: Session = Depends(get_db)):
+def delete_truck(truck_id: int, db: Session = Depends(get_db),
+                 current_user: User = Depends(verify_token)):
     service = TrucksService(db)
     success = service.delete_truck(truck_id)
     if not success:

app/infrastructure/fastapi/user_routes.py

@@ -6,22 +6,25 @@ from fastapi.security import OAuth2PasswordRequestForm
 from sqlalchemy.orm import Session
 
 from app.core.entities.user import UserEntity
-from app.core.usecases.auth_service import create_access_token
+from app.core.usecases.auth_service import create_access_token, verify_token
 from app.core.usecases.user_service import UsersService
 from app.infrastructure.database.dependencies import get_db
+from app.infrastructure.database.models.users import User
 from app.infrastructure.database.repository.user_repository import UsersRepository
 
 router = APIRouter()
 
 
 @router.get("/users", response_model=List[UserEntity])
-def read_users(db: Session = Depends(get_db)):
+def read_users(db: Session = Depends(get_db),
+               current_user: User = Depends(verify_token)):
     service = UsersService(db)
     return service.get_all_users()
 
 
 @router.get("/users/{user_id}", response_model=UserEntity)
-def read_user(user_id: int, db: Session = Depends(get_db)):
+def read_user(user_id: int, db: Session = Depends(get_db),
+              current_user: User = Depends(verify_token)):
     service = UsersService(db)
     user = service.get_user_by_id(user_id)
     if user is None:
@@ -30,13 +33,15 @@ def read_user(user_id: int, db: Session = Depends(get_db)):
 
 
 @router.post("/users", response_model=UserEntity)
-def create_user(user: UserEntity, db: Session = Depends(get_db)):
+def create_user(user: UserEntity, db: Session = Depends(get_db),
+                current_user: User = Depends(verify_token)):
     service = UsersService(db)
     return service.create_user(user)
 
 
 @router.put("/users/{user_id}", response_model=UserEntity)
-def update_user(user_id: int, user: UserEntity, db: Session = Depends(get_db)):
+def update_user(user_id: int, user: UserEntity, db: Session = Depends(get_db),
+                current_user: User = Depends(verify_token)):
     service = UsersService(db)
     updated_user = service.update_user(user_id, user)
     if updated_user is None:
@@ -45,7 +50,8 @@ def update_user(user_id: int, user: UserEntity, db: Session = Depends(get_db)):
 
 
 @router.delete("/users/{user_id}", response_model=bool)
-def delete_user(user_id: int, db: Session = Depends(get_db)):
+def delete_user(user_id: int, db: Session = Depends(get_db),
+                current_user: User = Depends(verify_token)):
     service = UsersService(db)
     success = service.delete_user(user_id)
     if not success: