From 73ab9a05c636c501031111efb933b2ed9fb1b206 Mon Sep 17 00:00:00 2001 From: andrei Date: Sat, 5 Oct 2024 10:08:53 +0500 Subject: [PATCH] ._. --- app/infrastructure/fastapi/city_routes.py | 17 ++++++++++++----- .../fastapi/delivery_accessory_routes.py | 17 ++++++++++++----- .../fastapi/delivery_order_routes.py | 17 ++++++++++++----- .../fastapi/federal_district_routes.py | 17 ++++++++++++----- app/infrastructure/fastapi/role_routes.py | 17 ++++++++++++----- app/infrastructure/fastapi/status_routes.py | 17 ++++++++++++----- .../fastapi/total_order_routes.py | 17 ++++++++++++----- app/infrastructure/fastapi/truck_routes.py | 17 ++++++++++++----- app/infrastructure/fastapi/user_routes.py | 18 ++++++++++++------ 9 files changed, 108 insertions(+), 46 deletions(-) diff --git a/app/infrastructure/fastapi/city_routes.py b/app/infrastructure/fastapi/city_routes.py index 87cfa38..846a9bd 100644 --- a/app/infrastructure/fastapi/city_routes.py +++ b/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: diff --git a/app/infrastructure/fastapi/delivery_accessory_routes.py b/app/infrastructure/fastapi/delivery_accessory_routes.py index ddaadfa..1e35d75 100644 --- a/app/infrastructure/fastapi/delivery_accessory_routes.py +++ b/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: diff --git a/app/infrastructure/fastapi/delivery_order_routes.py b/app/infrastructure/fastapi/delivery_order_routes.py index af2b6bb..51a8546 100644 --- a/app/infrastructure/fastapi/delivery_order_routes.py +++ b/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: diff --git a/app/infrastructure/fastapi/federal_district_routes.py b/app/infrastructure/fastapi/federal_district_routes.py index 336f762..c9a0ce2 100644 --- a/app/infrastructure/fastapi/federal_district_routes.py +++ b/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: diff --git a/app/infrastructure/fastapi/role_routes.py b/app/infrastructure/fastapi/role_routes.py index a21e9b3..bbd4ea2 100644 --- a/app/infrastructure/fastapi/role_routes.py +++ b/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: diff --git a/app/infrastructure/fastapi/status_routes.py b/app/infrastructure/fastapi/status_routes.py index ceca07e..4874c55 100644 --- a/app/infrastructure/fastapi/status_routes.py +++ b/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: diff --git a/app/infrastructure/fastapi/total_order_routes.py b/app/infrastructure/fastapi/total_order_routes.py index 50a431a..d0ec5cf 100644 --- a/app/infrastructure/fastapi/total_order_routes.py +++ b/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: diff --git a/app/infrastructure/fastapi/truck_routes.py b/app/infrastructure/fastapi/truck_routes.py index 9d6cd7b..7d5402f 100644 --- a/app/infrastructure/fastapi/truck_routes.py +++ b/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: diff --git a/app/infrastructure/fastapi/user_routes.py b/app/infrastructure/fastapi/user_routes.py index 20f4b05..0901ae6 100644 --- a/app/infrastructure/fastapi/user_routes.py +++ b/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: