._.

app/infrastructure/fastapi/accessory_routes.py

@@ -0,0 +1,47 @@
+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.accessory import AccessoryEntity
+from app.core.usecases.accessory_service import AccessoriesService
+
+router = APIRouter()
+
+@router.get("/accessories", response_model=List[AccessoryEntity])
+def read_accessories(db: Session = Depends(get_db)):
+    service = AccessoriesService(db)
+    return service.get_all_accessories()
+
+@router.get("/accessories/{accessory_id}", response_model=AccessoryEntity)
+def read_accessory(accessory_id: int, db: Session = Depends(get_db)):
+    service = AccessoriesService(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)
+def create_accessory(accessory: AccessoryEntity, db: Session = Depends(get_db)):
+    service = AccessoriesService(db)
+    return service.create_accessory(accessory)
+
+@router.put("/accessories/{accessory_id}", response_model=AccessoryEntity)
+def update_accessory(accessory_id: int, accessory: AccessoryEntity, db: Session = Depends(get_db)):
+    service = AccessoriesService(db)
+    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)
+def delete_accessory(accessory_id: int, db: Session = Depends(get_db)):
+    service = AccessoriesService(db)
+    success = service.delete_accessory(accessory_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Accessory not found")
+
+    return success

app/infrastructure/fastapi/delivery_routes.py

@@ -0,0 +1,52 @@
+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 import DeliveryEntity
+from app.core.usecases.delivery_service import DeliveryService
+
+router = APIRouter()
+
+
+@router.get("/deliveries", response_model=List[DeliveryEntity])
+def read_deliveries(db: Session = Depends(get_db)):
+    service = DeliveryService(db)
+    return service.get_all_deliveries()
+
+
+@router.get("/deliveries/{delivery_id}", response_model=DeliveryEntity)
+def read_delivery(delivery_id: int, db: Session = Depends(get_db)):
+    service = DeliveryService(db)
+    delivery = service.get_delivery_by_id(delivery_id)
+    if delivery is None:
+        raise HTTPException(status_code=404, detail="Delivery not found")
+
+    return delivery
+
+
+@router.post("/deliveries", response_model=DeliveryEntity)
+def create_delivery(delivery: DeliveryEntity, db: Session = Depends(get_db)):
+    service = DeliveryService(db)
+    return service.create_delivery(delivery)
+
+
+@router.put("/deliveries/{delivery_id}", response_model=DeliveryEntity)
+def update_delivery(delivery_id: int, delivery: DeliveryEntity, db: Session = Depends(get_db)):
+    service = DeliveryService(db)
+    updated_delivery = service.update_delivery(delivery_id, delivery)
+    if updated_delivery is None:
+        raise HTTPException(status_code=404, detail="Delivery not found")
+
+    return updated_delivery
+
+
+@router.delete("/deliveries/{delivery_id}", response_model=bool)
+def delete_delivery(delivery_id: int, db: Session = Depends(get_db)):
+    service = DeliveryService(db)
+    success = service.delete_delivery(delivery_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Delivery not found")
+
+    return success

app/infrastructure/fastapi/order_routes.py

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,52 @@
+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.role import RoleEntity
+from app.core.usecases.role_service import RoleService
+
+router = APIRouter()
+
+
+@router.get("/roles", response_model=List[RoleEntity])
+def read_roles(db: Session = Depends(get_db)):
+    service = RoleService(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)
+    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)
+    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)
+    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)
+    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

@@ -0,0 +1,52 @@
+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.status import StatusEntity
+from app.core.usecases.status_service import StatusService
+
+router = APIRouter()
+
+
+@router.get("/statuses", response_model=List[StatusEntity])
+def read_statuses(db: Session = Depends(get_db)):
+    service = StatusService(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)
+    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)
+    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)
+    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)
+    success = service.delete_status(status_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Status not found")
+
+    return success

app/infrastructure/fastapi/step_routes.py

@@ -0,0 +1,52 @@
+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.step import StepEntity
+from app.core.usecases.step_service import StepService
+
+router = APIRouter()
+
+
+@router.get("/steps", response_model=List[StepEntity])
+def read_steps(db: Session = Depends(get_db)):
+    service = StepService(db)
+    return service.get_all_steps()
+
+
+@router.get("/steps/{step_id}", response_model=StepEntity)
+def read_step(step_id: int, db: Session = Depends(get_db)):
+    service = StepService(db)
+    step = service.get_step_by_id(step_id)
+    if step is None:
+        raise HTTPException(status_code=404, detail="Step not found")
+
+    return step
+
+
+@router.post("/steps", response_model=StepEntity)
+def create_step(step: StepEntity, db: Session = Depends(get_db)):
+    service = StepService(db)
+    return service.create_step(step)
+
+
+@router.put("/steps/{step_id}", response_model=StepEntity)
+def update_step(step_id: int, step: StepEntity, db: Session = Depends(get_db)):
+    service = StepService(db)
+    updated_step = service.update_step(step_id, step)
+    if updated_step is None:
+        raise HTTPException(status_code=404, detail="Step not found")
+
+    return updated_step
+
+
+@router.delete("/steps/{step_id}", response_model=bool)
+def delete_step(step_id: int, db: Session = Depends(get_db)):
+    service = StepService(db)
+    success = service.delete_step(step_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Step not found")
+
+    return success

app/infrastructure/fastapi/storage_accessory_routes.py

@@ -0,0 +1,53 @@
+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.storage_accessory import StorageAccessoryEntity
+from app.core.usecases.storage_accessory_service import StorageAccessoryService
+
+router = APIRouter()
+
+
+@router.get("/storage-accessories", response_model=List[StorageAccessoryEntity])
+def read_storage_accessories(db: Session = Depends(get_db)):
+    service = StorageAccessoryService(db)
+    return service.get_all_storage_accessories()
+
+
+@router.get("/storage-accessories/{storage_accessories_id}", response_model=StorageAccessoryEntity)
+def read_storage_accessory(storage_accessories_id: int, db: Session = Depends(get_db)):
+    service = StorageAccessoryService(db)
+    storage_accessory = service.get_storage_accessory_by_id(storage_accessories_id)
+    if storage_accessory is None:
+        raise HTTPException(status_code=404, detail="Storage Accessory not found")
+
+    return storage_accessory
+
+
+@router.post("/storage-accessories", response_model=StorageAccessoryEntity)
+def create_storage_accessory(storage_accessory: StorageAccessoryEntity, db: Session = Depends(get_db)):
+    service = StorageAccessoryService(db)
+    return service.create_storage_accessory(storage_accessory)
+
+
+@router.put("/storage-accessories/{storage_accessories_id}", response_model=StorageAccessoryEntity)
+def update_storage_accessory(storage_accessories_id: int, storage_accessory: StorageAccessoryEntity,
+                             db: Session = Depends(get_db)):
+    service = StorageAccessoryService(db)
+    updated_storage_accessory = service.update_storage_accessory(storage_accessories_id, storage_accessory)
+    if updated_storage_accessory is None:
+        raise HTTPException(status_code=404, detail="Storage Accessory not found")
+
+    return updated_storage_accessory
+
+
+@router.delete("/storage-accessories/{storage_accessories_id}", response_model=bool)
+def delete_storage_accessory(storage_accessories_id: int, db: Session = Depends(get_db)):
+    service = StorageAccessoryService(db)
+    success = service.delete_storage_accessory(storage_accessories_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Storage Accessory not found")
+
+    return success

app/infrastructure/fastapi/storage_routes.py

@@ -0,0 +1,52 @@
+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.storage import StorageEntity
+from app.core.usecases.storage_service import StorageService
+
+router = APIRouter()
+
+
+@router.get("/storages", response_model=List[StorageEntity])
+def read_storages(db: Session = Depends(get_db)):
+    service = StorageService(db)
+    return service.get_all_storages()
+
+
+@router.get("/storages/{storage_id}", response_model=StorageEntity)
+def read_storage(storage_id: int, db: Session = Depends(get_db)):
+    service = StorageService(db)
+    storage = service.get_storage_by_id(storage_id)
+    if storage is None:
+        raise HTTPException(status_code=404, detail="Storage not found")
+
+    return storage
+
+
+@router.post("/storages", response_model=StorageEntity)
+def create_storage(storage: StorageEntity, db: Session = Depends(get_db)):
+    service = StorageService(db)
+    return service.create_storage(storage)
+
+
+@router.put("/storages/{storage_id}", response_model=StorageEntity)
+def update_storage(storage_id: int, storage: StorageEntity, db: Session = Depends(get_db)):
+    service = StorageService(db)
+    updated_storage = service.update_storage(storage_id, storage)
+    if updated_storage is None:
+        raise HTTPException(status_code=404, detail="Storage not found")
+
+    return updated_storage
+
+
+@router.delete("/storages/{storage_id}", response_model=bool)
+def delete_storage(storage_id: int, db: Session = Depends(get_db)):
+    service = StorageService(db)
+    success = service.delete_storage(storage_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Storage not found")
+
+    return success

app/infrastructure/fastapi/user_routes.py

@@ -0,0 +1,52 @@
+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.user import UserEntity
+from app.core.usecases.user_service import UserService
+
+router = APIRouter()
+
+
+@router.get("/users", response_model=List[UserEntity])
+def read_users(db: Session = Depends(get_db)):
+    service = UserService(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)
+    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)
+    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)
+    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)
+    success = service.delete_user(user_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="User not found")
+
+    return success

app/main.py

@@ -1,9 +1,6 @@
 from fastapi import FastAPI
-# from app.infrastructure.fastapi import routes
 from app.infrastructure.database.database import init_db
 
 app = FastAPI()
 
-init_db()  # Инициализация базы данных
-
-# app.include_router(routes.router)
+init_db()