Numerum/API_logistics
Numerum/API_logistics
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

._.

Browse Source
This commit is contained in:
Андрей Дувакин 2024-10-05 10:08:53 +05:00
parent 9ddfe3b102
commit 73ab9a05c6
9 changed files with 108 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
app/infrastructure/fastapi/city_routes.py
View File

@ -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:

17
app/infrastructure/fastapi/delivery_accessory_routes.py
View File

@ -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:

17
app/infrastructure/fastapi/delivery_order_routes.py
View File

@ -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:

17
app/infrastructure/fastapi/federal_district_routes.py
View File

@ -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:

17
app/infrastructure/fastapi/role_routes.py
View File

@ -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:

17
app/infrastructure/fastapi/status_routes.py
View File

@ -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:

17
app/infrastructure/fastapi/total_order_routes.py
View File

@ -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:

17
app/infrastructure/fastapi/truck_routes.py
View File

@ -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:

18
app/infrastructure/fastapi/user_routes.py
View File

@ -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: