._.

.gitignore

@@ -1,3 +1,5 @@
 .idea
 .idea/
 .env
+__pycache__
+__pycache__/

app/core/usecases/federal_district_service.py

@@ -40,7 +40,7 @@ class FederalDistrictsService:
         return FederalDistrictEntity(
             id=created_federal_district.id,
             name=created_federal_district.name,
-            cities=[]  # Поскольку города еще не добавлены
+            cities=[]  
         )
 
     def update_federal_district(self, federal_district_id: int, entity: FederalDistrictEntity) -> Optional[FederalDistrictEntity]:

app/infrastructure/fastapi/accessory_routes.py

@@ -20,7 +20,6 @@ def read_accessory(accessory_id: int, db: Session = Depends(get_db)):
     accessory = service.get_accessory_by_id(accessory_id)
     if accessory is None:
         raise HTTPException(status_code=404, detail="Accessory not found")
-
     return accessory
 
 @router.post("/accessories", response_model=AccessoryEntity)
@@ -34,7 +33,6 @@ def update_accessory(accessory_id: int, accessory: AccessoryEntity, db: Session
     updated_accessory = service.update_accessory(accessory_id, accessory)
     if updated_accessory is None:
         raise HTTPException(status_code=404, detail="Accessory not found")
-
     return updated_accessory
 
 @router.delete("/accessories/{accessory_id}", response_model=bool)
@@ -43,5 +41,4 @@ def delete_accessory(accessory_id: int, db: Session = Depends(get_db)):
     success = service.delete_accessory(accessory_id)
     if not success:
         raise HTTPException(status_code=404, detail="Accessory not found")
-
     return success

app/infrastructure/fastapi/city_routes.py

@@ -0,0 +1,49 @@
+from typing import List
+
+from fastapi import APIRouter, HTTPException, Depends
+from sqlalchemy.orm import Session
+
+from app.infrastructure.database.dependencies import get_db
+from app.core.entities.city import CityEntity
+from app.core.usecases.city_service import CitiesService
+
+router = APIRouter()
+
+
+@router.get("/cities", response_model=List[CityEntity])
+def read_cities(db: Session = Depends(get_db)):
+    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)):
+    service = CitiesService(db)
+    city = service.get_city_by_id(city_id)
+    if city is None:
+        raise HTTPException(status_code=404, detail="City not found")
+    return city
+
+
+@router.post("/cities", response_model=CityEntity)
+def create_city(city: CityEntity, db: Session = Depends(get_db)):
+    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)):
+    service = CitiesService(db)
+    updated_city = service.update_city(city_id, city)
+    if updated_city is None:
+        raise HTTPException(status_code=404, detail="City not found")
+    return updated_city
+
+
+@router.delete("/cities/{city_id}", response_model=bool)
+def delete_city(city_id: int, db: Session = Depends(get_db)):
+    service = CitiesService(db)
+    success = service.delete_city(city_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="City not found")
+    return success

app/infrastructure/fastapi/delivery_accessory_routes.py

@@ -0,0 +1,50 @@
+from typing import List
+
+from fastapi import APIRouter, HTTPException, Depends
+from sqlalchemy.orm import Session
+
+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
+
+router = APIRouter()
+
+
+@router.get("/delivery-accessories", response_model=List[DeliveryAccessoryEntity])
+def read_delivery_accessories(db: Session = Depends(get_db)):
+    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)):
+    service = DeliveryAccessoriesService(db)
+    delivery_accessory = service.get_delivery_accessory_by_id(delivery_accessory_id)
+    if delivery_accessory is None:
+        raise HTTPException(status_code=404, detail="Delivery accessory not found")
+    return delivery_accessory
+
+
+@router.post("/delivery-accessories", response_model=DeliveryAccessoryEntity)
+def create_delivery_accessory(delivery_accessory: DeliveryAccessoryEntity, db: Session = Depends(get_db)):
+    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)):
+    service = DeliveryAccessoriesService(db)
+    updated_delivery_accessory = service.update_delivery_accessory(delivery_accessory_id, delivery_accessory)
+    if updated_delivery_accessory is None:
+        raise HTTPException(status_code=404, detail="Delivery accessory not found")
+    return updated_delivery_accessory
+
+
+@router.delete("/delivery-accessories/{delivery_accessory_id}", response_model=bool)
+def delete_delivery_accessory(delivery_accessory_id: int, db: Session = Depends(get_db)):
+    service = DeliveryAccessoriesService(db)
+    success = service.delete_delivery_accessory(delivery_accessory_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Delivery accessory not found")
+    return success

app/infrastructure/fastapi/delivery_order_routes.py

@@ -0,0 +1,49 @@
+from typing import List
+
+from fastapi import APIRouter, HTTPException, Depends
+from sqlalchemy.orm import Session
+
+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
+
+router = APIRouter()
+
+
+@router.get("/delivery-orders", response_model=List[DeliveryOrderEntity])
+def read_delivery_orders(db: Session = Depends(get_db)):
+    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)):
+    service = DeliveryOrdersService(db)
+    delivery_order = service.get_delivery_order_by_id(delivery_order_id)
+    if delivery_order is None:
+        raise HTTPException(status_code=404, detail="Delivery order not found")
+    return delivery_order
+
+
+@router.post("/delivery-orders", response_model=DeliveryOrderEntity)
+def create_delivery_order(delivery_order: DeliveryOrderEntity, db: Session = Depends(get_db)):
+    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)):
+    service = DeliveryOrdersService(db)
+    updated_delivery_order = service.update_delivery_order(delivery_order_id, delivery_order)
+    if updated_delivery_order is None:
+        raise HTTPException(status_code=404, detail="Delivery order not found")
+    return updated_delivery_order
+
+
+@router.delete("/delivery-orders/{delivery_order_id}", response_model=bool)
+def delete_delivery_order(delivery_order_id: int, db: Session = Depends(get_db)):
+    service = DeliveryOrdersService(db)
+    success = service.delete_delivery_order(delivery_order_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Delivery order not found")
+    return success

app/infrastructure/fastapi/federal_district_routes.py

@@ -0,0 +1,50 @@
+from typing import List
+
+from fastapi import APIRouter, HTTPException, Depends
+from sqlalchemy.orm import Session
+
+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
+
+router = APIRouter()
+
+
+@router.get("/federal-districts", response_model=List[FederalDistrictEntity])
+def read_federal_districts(db: Session = Depends(get_db)):
+    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)):
+    service = FederalDistrictsService(db)
+    federal_district = service.get_federal_district_by_id(federal_district_id)
+    if federal_district is None:
+        raise HTTPException(status_code=404, detail="Federal district not found")
+    return federal_district
+
+
+@router.post("/federal-districts", response_model=FederalDistrictEntity)
+def create_federal_district(federal_district: FederalDistrictEntity, db: Session = Depends(get_db)):
+    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)):
+    service = FederalDistrictsService(db)
+    updated_federal_district = service.update_federal_district(federal_district_id, federal_district)
+    if updated_federal_district is None:
+        raise HTTPException(status_code=404, detail="Federal district not found")
+    return updated_federal_district
+
+
+@router.delete("/federal-districts/{federal_district_id}", response_model=bool)
+def delete_federal_district(federal_district_id: int, db: Session = Depends(get_db)):
+    service = FederalDistrictsService(db)
+    success = service.delete_federal_district(federal_district_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Federal district not found")
+    return success

app/infrastructure/fastapi/order_routes.py

@@ -1,52 +0,0 @@
-from typing import List
-
-from fastapi import APIRouter, HTTPException, Depends
-from sqlalchemy.orm import Session
-
-from app.infrastructure.database.dependencies import get_db
-from app.core.entities.order import OrderEntity
-from app.core.usecases.order_service import OrderService
-
-router = APIRouter()
-
-
-@router.get("/orders", response_model=List[OrderEntity])
-def read_orders(db: Session = Depends(get_db)):
-    service = OrderService(db)
-    return service.get_all_orders()
-
-
-@router.get("/orders/{order_id}", response_model=OrderEntity)
-def read_order(order_id: int, db: Session = Depends(get_db)):
-    service = OrderService(db)
-    order = service.get_order_by_id(order_id)
-    if order is None:
-        raise HTTPException(status_code=404, detail="Order not found")
-
-    return order
-
-
-@router.post("/orders", response_model=OrderEntity)
-def create_order(order: OrderEntity, db: Session = Depends(get_db)):
-    service = OrderService(db)
-    return service.create_order(order)
-
-
-@router.put("/orders/{order_id}", response_model=OrderEntity)
-def update_order(order_id: int, order: OrderEntity, db: Session = Depends(get_db)):
-    service = OrderService(db)
-    updated_order = service.update_order(order_id, order)
-    if updated_order is None:
-        raise HTTPException(status_code=404, detail="Order not found")
-
-    return updated_order
-
-
-@router.delete("/orders/{order_id}", response_model=bool)
-def delete_order(order_id: int, db: Session = Depends(get_db)):
-    service = OrderService(db)
-    success = service.delete_order(order_id)
-    if not success:
-        raise HTTPException(status_code=404, detail="Order not found")
-
-    return success

app/infrastructure/fastapi/role_routes.py

@@ -5,48 +5,45 @@ from sqlalchemy.orm import Session
 
 from app.infrastructure.database.dependencies import get_db
 from app.core.entities.role import RoleEntity
-from app.core.usecases.role_service import RoleService
+from app.core.usecases.role_service import RolesService
 
 router = APIRouter()
 
 
 @router.get("/roles", response_model=List[RoleEntity])
 def read_roles(db: Session = Depends(get_db)):
-    service = RoleService(db)
+    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)):
-    service = RoleService(db)
+    service = RolesService(db)
     role = service.get_role_by_id(role_id)
     if role is None:
         raise HTTPException(status_code=404, detail="Role not found")
-
     return role
 
 
 @router.post("/roles", response_model=RoleEntity)
 def create_role(role: RoleEntity, db: Session = Depends(get_db)):
-    service = RoleService(db)
+    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)):
-    service = RoleService(db)
+    service = RolesService(db)
     updated_role = service.update_role(role_id, role)
     if updated_role is None:
         raise HTTPException(status_code=404, detail="Role not found")
-
     return updated_role
 
 
 @router.delete("/roles/{role_id}", response_model=bool)
 def delete_role(role_id: int, db: Session = Depends(get_db)):
-    service = RoleService(db)
+    service = RolesService(db)
     success = service.delete_role(role_id)
     if not success:
         raise HTTPException(status_code=404, detail="Role not found")
-
     return success

app/infrastructure/fastapi/status_routes.py

@@ -5,48 +5,45 @@ from sqlalchemy.orm import Session
 
 from app.infrastructure.database.dependencies import get_db
 from app.core.entities.status import StatusEntity
-from app.core.usecases.status_service import StatusService
+from app.core.usecases.status_service import StatusesService
 
 router = APIRouter()
 
 
 @router.get("/statuses", response_model=List[StatusEntity])
 def read_statuses(db: Session = Depends(get_db)):
-    service = StatusService(db)
+    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)):
-    service = StatusService(db)
+    service = StatusesService(db)
     status = service.get_status_by_id(status_id)
     if status is None:
         raise HTTPException(status_code=404, detail="Status not found")
-
     return status
 
 
 @router.post("/statuses", response_model=StatusEntity)
 def create_status(status: StatusEntity, db: Session = Depends(get_db)):
-    service = StatusService(db)
+    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)):
-    service = StatusService(db)
+    service = StatusesService(db)
     updated_status = service.update_status(status_id, status)
     if updated_status is None:
         raise HTTPException(status_code=404, detail="Status not found")
-
     return updated_status
 
 
 @router.delete("/statuses/{status_id}", response_model=bool)
 def delete_status(status_id: int, db: Session = Depends(get_db)):
-    service = StatusService(db)
+    service = StatusesService(db)
     success = service.delete_status(status_id)
     if not success:
         raise HTTPException(status_code=404, detail="Status not found")
-
     return success

app/infrastructure/fastapi/total_order_routes.py

@@ -0,0 +1,49 @@
+from typing import List
+
+from fastapi import APIRouter, HTTPException, Depends
+from sqlalchemy.orm import Session
+
+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
+
+router = APIRouter()
+
+
+@router.get("/total-orders", response_model=List[TotalOrderEntity])
+def read_total_orders(db: Session = Depends(get_db)):
+    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)):
+    service = TotalOrdersService(db)
+    total_order = service.get_total_order_by_id(total_order_id)
+    if total_order is None:
+        raise HTTPException(status_code=404, detail="Total order not found")
+    return total_order
+
+
+@router.post("/total-orders", response_model=TotalOrderEntity)
+def create_total_order(total_order: TotalOrderEntity, db: Session = Depends(get_db)):
+    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)):
+    service = TotalOrdersService(db)
+    updated_total_order = service.update_total_order(total_order_id, total_order)
+    if updated_total_order is None:
+        raise HTTPException(status_code=404, detail="Total order not found")
+    return updated_total_order
+
+
+@router.delete("/total-orders/{total_order_id}", response_model=bool)
+def delete_total_order(total_order_id: int, db: Session = Depends(get_db)):
+    service = TotalOrdersService(db)
+    success = service.delete_total_order(total_order_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Total order not found")
+    return success

app/infrastructure/fastapi/truck_routes.py

@@ -0,0 +1,49 @@
+from typing import List
+
+from fastapi import APIRouter, HTTPException, Depends
+from sqlalchemy.orm import Session
+
+from app.infrastructure.database.dependencies import get_db
+from app.core.entities.truck import TruckEntity
+from app.core.usecases.truck_service import TrucksService
+
+router = APIRouter()
+
+
+@router.get("/trucks", response_model=List[TruckEntity])
+def read_trucks(db: Session = Depends(get_db)):
+    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)):
+    service = TrucksService(db)
+    truck = service.get_truck_by_id(truck_id)
+    if truck is None:
+        raise HTTPException(status_code=404, detail="Truck not found")
+    return truck
+
+
+@router.post("/trucks", response_model=TruckEntity)
+def create_truck(truck: TruckEntity, db: Session = Depends(get_db)):
+    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)):
+    service = TrucksService(db)
+    updated_truck = service.update_truck(truck_id, truck)
+    if updated_truck is None:
+        raise HTTPException(status_code=404, detail="Truck not found")
+    return updated_truck
+
+
+@router.delete("/trucks/{truck_id}", response_model=bool)
+def delete_truck(truck_id: int, db: Session = Depends(get_db)):
+    service = TrucksService(db)
+    success = service.delete_truck(truck_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Truck not found")
+    return success

app/infrastructure/fastapi/user_routes.py

@@ -5,48 +5,45 @@ from sqlalchemy.orm import Session
 
 from app.infrastructure.database.dependencies import get_db
 from app.core.entities.user import UserEntity
-from app.core.usecases.user_service import UserService
+from app.core.usecases.user_service import UsersService
 
 router = APIRouter()
 
 
 @router.get("/users", response_model=List[UserEntity])
 def read_users(db: Session = Depends(get_db)):
-    service = UserService(db)
+    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)):
-    service = UserService(db)
+    service = UsersService(db)
     user = service.get_user_by_id(user_id)
     if user is None:
         raise HTTPException(status_code=404, detail="User not found")
-
     return user
 
 
 @router.post("/users", response_model=UserEntity)
 def create_user(user: UserEntity, db: Session = Depends(get_db)):
-    service = UserService(db)
+    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)):
-    service = UserService(db)
+    service = UsersService(db)
     updated_user = service.update_user(user_id, user)
     if updated_user is None:
         raise HTTPException(status_code=404, detail="User not found")
-
     return updated_user
 
 
 @router.delete("/users/{user_id}", response_model=bool)
 def delete_user(user_id: int, db: Session = Depends(get_db)):
-    service = UserService(db)
+    service = UsersService(db)
     success = service.delete_user(user_id)
     if not success:
         raise HTTPException(status_code=404, detail="User not found")
-
     return success