From 530fbf64a3da42488bc3acd39542864bd5accaf3 Mon Sep 17 00:00:00 2001 From: andrei Date: Fri, 4 Oct 2024 10:33:37 +0500 Subject: [PATCH] ._. --- ...sitory.py => storage_accessory_service.py} | 0 .../fastapi/accessory_routes.py | 47 ++++++++++++++++ app/infrastructure/fastapi/delivery_routes.py | 52 ++++++++++++++++++ app/infrastructure/fastapi/order_routes.py | 52 ++++++++++++++++++ app/infrastructure/fastapi/role_routes.py | 52 ++++++++++++++++++ app/infrastructure/fastapi/status_routes.py | 52 ++++++++++++++++++ app/infrastructure/fastapi/step_routes.py | 52 ++++++++++++++++++ .../fastapi/storage_accessory_routes.py | 53 +++++++++++++++++++ app/infrastructure/fastapi/storage_routes.py | 52 ++++++++++++++++++ app/infrastructure/fastapi/user_routes.py | 52 ++++++++++++++++++ app/main.py | 5 +- 11 files changed, 465 insertions(+), 4 deletions(-) rename app/core/usecases/{storage_accessory_repository.py => storage_accessory_service.py} (100%) create mode 100644 app/infrastructure/fastapi/accessory_routes.py create mode 100644 app/infrastructure/fastapi/delivery_routes.py create mode 100644 app/infrastructure/fastapi/order_routes.py create mode 100644 app/infrastructure/fastapi/role_routes.py create mode 100644 app/infrastructure/fastapi/status_routes.py create mode 100644 app/infrastructure/fastapi/step_routes.py create mode 100644 app/infrastructure/fastapi/storage_accessory_routes.py create mode 100644 app/infrastructure/fastapi/storage_routes.py create mode 100644 app/infrastructure/fastapi/user_routes.py diff --git a/app/core/usecases/storage_accessory_repository.py b/app/core/usecases/storage_accessory_service.py similarity index 100% rename from app/core/usecases/storage_accessory_repository.py rename to app/core/usecases/storage_accessory_service.py diff --git a/app/infrastructure/fastapi/accessory_routes.py b/app/infrastructure/fastapi/accessory_routes.py new file mode 100644 index 0000000..eaabdec --- /dev/null +++ b/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 diff --git a/app/infrastructure/fastapi/delivery_routes.py b/app/infrastructure/fastapi/delivery_routes.py new file mode 100644 index 0000000..ffa4519 --- /dev/null +++ b/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 diff --git a/app/infrastructure/fastapi/order_routes.py b/app/infrastructure/fastapi/order_routes.py new file mode 100644 index 0000000..ad13b70 --- /dev/null +++ b/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 diff --git a/app/infrastructure/fastapi/role_routes.py b/app/infrastructure/fastapi/role_routes.py new file mode 100644 index 0000000..e0203ea --- /dev/null +++ b/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 diff --git a/app/infrastructure/fastapi/status_routes.py b/app/infrastructure/fastapi/status_routes.py new file mode 100644 index 0000000..c51e8a2 --- /dev/null +++ b/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 diff --git a/app/infrastructure/fastapi/step_routes.py b/app/infrastructure/fastapi/step_routes.py new file mode 100644 index 0000000..54beeaa --- /dev/null +++ b/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 diff --git a/app/infrastructure/fastapi/storage_accessory_routes.py b/app/infrastructure/fastapi/storage_accessory_routes.py new file mode 100644 index 0000000..41f97a1 --- /dev/null +++ b/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 diff --git a/app/infrastructure/fastapi/storage_routes.py b/app/infrastructure/fastapi/storage_routes.py new file mode 100644 index 0000000..1606400 --- /dev/null +++ b/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 diff --git a/app/infrastructure/fastapi/user_routes.py b/app/infrastructure/fastapi/user_routes.py new file mode 100644 index 0000000..9cc609a --- /dev/null +++ b/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 diff --git a/app/main.py b/app/main.py index c6c6cd7..9055d9e 100644 --- a/app/main.py +++ b/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) \ No newline at end of file +init_db()