From f3e1ccb7c418d3e8d2f198dd789e9f70f4fdfcab Mon Sep 17 00:00:00 2001 From: andrei Date: Fri, 4 Oct 2024 14:38:55 +0500 Subject: [PATCH] ._. --- ERD.drawio | 811 ++++++++++-------- app/core/entities/delivery.py | 12 - app/core/entities/step.py | 14 - app/core/entities/storage.py | 13 - app/core/entities/storage_accessory.py | 14 - app/core/usecases/delivery_service.py | 69 -- app/core/usecases/order_service.py | 4 +- app/core/usecases/step_service.py | 74 -- .../usecases/storage_accessory_service.py | 75 -- app/core/usecases/storage_service.py | 74 -- app/infrastructure/database/database.py | 15 +- .../database/models/accessory.py | 14 +- app/infrastructure/database/models/cities.py | 17 + .../database/models/deliveries.py | 17 - .../database/models/delivery_orders.py | 21 + .../database/models/dilevery_accessiories.py | 18 + .../database/models/federal_districts.py | 13 + app/infrastructure/database/models/steps.py | 20 - .../database/models/storage_accessories.py | 21 - .../models/{orders.py => total_orders.py} | 8 +- .../models/{storages.py => trucks.py} | 11 +- .../repository/delivery_repository.py | 31 - .../database/repository/order_repository.py | 12 +- .../database/repository/step_repository.py | 30 - .../storage_accessory_repository.py | 32 - .../database/repository/storage_repository.py | 31 - app/infrastructure/fastapi/delivery_routes.py | 52 -- app/infrastructure/fastapi/step_routes.py | 52 -- .../fastapi/storage_accessory_routes.py | 53 -- app/infrastructure/fastapi/storage_routes.py | 52 -- app/main.py | 22 +- 31 files changed, 562 insertions(+), 1140 deletions(-) delete mode 100644 app/core/entities/delivery.py delete mode 100644 app/core/entities/step.py delete mode 100644 app/core/entities/storage.py delete mode 100644 app/core/entities/storage_accessory.py delete mode 100644 app/core/usecases/delivery_service.py delete mode 100644 app/core/usecases/step_service.py delete mode 100644 app/core/usecases/storage_accessory_service.py delete mode 100644 app/core/usecases/storage_service.py create mode 100644 app/infrastructure/database/models/cities.py delete mode 100644 app/infrastructure/database/models/deliveries.py create mode 100644 app/infrastructure/database/models/delivery_orders.py create mode 100644 app/infrastructure/database/models/dilevery_accessiories.py create mode 100644 app/infrastructure/database/models/federal_districts.py delete mode 100644 app/infrastructure/database/models/steps.py delete mode 100644 app/infrastructure/database/models/storage_accessories.py rename app/infrastructure/database/models/{orders.py => total_orders.py} (69%) rename app/infrastructure/database/models/{storages.py => trucks.py} (52%) delete mode 100644 app/infrastructure/database/repository/delivery_repository.py delete mode 100644 app/infrastructure/database/repository/step_repository.py delete mode 100644 app/infrastructure/database/repository/storage_accessory_repository.py delete mode 100644 app/infrastructure/database/repository/storage_repository.py delete mode 100644 app/infrastructure/fastapi/delivery_routes.py delete mode 100644 app/infrastructure/fastapi/step_routes.py delete mode 100644 app/infrastructure/fastapi/storage_accessory_routes.py delete mode 100644 app/infrastructure/fastapi/storage_routes.py diff --git a/ERD.drawio b/ERD.drawio index eefd92c..bc2937f 100644 --- a/ERD.drawio +++ b/ERD.drawio @@ -1,532 +1,617 @@ - + - + - - + + - + - + - + - + - + - + - + - + - + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - + - + - + - + - + - + - + - - + + - + + + + - + - + - + - + - + - + - + - + - + - + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + - + - + - - + + - - + + + + - - + + + + - + + + + - + - + - + - + - + - + - + - + - + - + - + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/app/core/entities/delivery.py b/app/core/entities/delivery.py deleted file mode 100644 index dfd88ab..0000000 --- a/app/core/entities/delivery.py +++ /dev/null @@ -1,12 +0,0 @@ -from typing import Optional -from pydantic import BaseModel - - -class DeliveryEntity(BaseModel): - id: Optional[int] = None - count: int - storage_accessories_id: int - step_id: int - - class Config: - from_attributes = True diff --git a/app/core/entities/step.py b/app/core/entities/step.py deleted file mode 100644 index bac7cb0..0000000 --- a/app/core/entities/step.py +++ /dev/null @@ -1,14 +0,0 @@ -from typing import Optional -from datetime import datetime -from pydantic import BaseModel - - -class StepEntity(BaseModel): - id: Optional[int] = None - start_deadline: datetime - finish_deadline: datetime - order_id: Optional[int] = None - status_id: Optional[int] = None - - class Config: - from_attributes = True diff --git a/app/core/entities/storage.py b/app/core/entities/storage.py deleted file mode 100644 index 20f917b..0000000 --- a/app/core/entities/storage.py +++ /dev/null @@ -1,13 +0,0 @@ -from typing import Optional, List -from pydantic import BaseModel - - -class StorageEntity(BaseModel): - id: Optional[int] = None - name: str - x_coordinate: float - y_coordinate: float - storage_accessories: Optional[List[int]] = [] - - class Config: - from_attributes = True diff --git a/app/core/entities/storage_accessory.py b/app/core/entities/storage_accessory.py deleted file mode 100644 index 2946fe7..0000000 --- a/app/core/entities/storage_accessory.py +++ /dev/null @@ -1,14 +0,0 @@ -from typing import Optional -from datetime import datetime -from pydantic import BaseModel - - -class StorageAccessoryEntity(BaseModel): - id: Optional[int] = None - current_count: int - change_datetime: Optional[datetime] = None - storage_id: Optional[int] = None - accessory_id: Optional[int] = None - - class Config: - from_attributes = True diff --git a/app/core/usecases/delivery_service.py b/app/core/usecases/delivery_service.py deleted file mode 100644 index 8154f1f..0000000 --- a/app/core/usecases/delivery_service.py +++ /dev/null @@ -1,69 +0,0 @@ -from typing import List, Optional - -from sqlalchemy.orm import Session - -from app.core.entities.delivery import DeliveryEntity -from app.infrastructure.database.models.deliveries import Delivery -from app.infrastructure.database.repository.delivery_repository import DeliveryRepository - - -class DeliveryService: - def __init__(self, db: Session): - self.repository = DeliveryRepository(db) - - def get_all_deliveries(self) -> List[DeliveryEntity]: - deliveries = self.repository.get_all() - return [ - DeliveryEntity( - id=d.id, - count=d.count, - storage_accessories_id=d.storage_accessories_id, - step_id=d.step_id, - ) - for d in deliveries - ] - - def get_delivery_by_id(self, delivery_id: int) -> Optional[DeliveryEntity]: - delivery = self.repository.get_by_id(delivery_id) - if delivery: - return DeliveryEntity( - id=delivery.id, - count=delivery.count, - storage_accessories_id=delivery.storage_accessories_id, - step_id=delivery.step_id, - ) - - return None - - def create_delivery(self, entity: DeliveryEntity) -> DeliveryEntity: - delivery_model = Delivery( - count=entity.count, - storage_accessories_id=entity.storage_accessories_id, - step_id=entity.step_id, - ) - created_delivery = self.repository.create(delivery_model) - return DeliveryEntity( - id=created_delivery.id, - count=created_delivery.count, - storage_accessories_id=created_delivery.storage_accessories_id, - step_id=created_delivery.step_id, - ) - - def update_delivery(self, delivery_id: int, entity: DeliveryEntity) -> Optional[DeliveryEntity]: - delivery_model = self.repository.get_by_id(delivery_id) - if delivery_model: - delivery_model.count = entity.count - delivery_model.storage_accessories_id = entity.storage_accessories_id - delivery_model.step_id = entity.step_id - self.repository.update(delivery_model) - return DeliveryEntity( - id=delivery_model.id, - count=delivery_model.count, - storage_accessories_id=delivery_model.storage_accessories_id, - step_id=delivery_model.step_id, - ) - - return None - - def delete_delivery(self, delivery_id: int) -> bool: - return self.repository.delete(delivery_id) is not None diff --git a/app/core/usecases/order_service.py b/app/core/usecases/order_service.py index d4ff4e0..93a21df 100644 --- a/app/core/usecases/order_service.py +++ b/app/core/usecases/order_service.py @@ -3,7 +3,7 @@ from typing import List, Optional from sqlalchemy.orm import Session from app.core.entities.order import OrderEntity -from app.infrastructure.database.models.orders import Order +from app.infrastructure.database.models.total_orders import TotalOrder from app.infrastructure.database.repository.order_repository import OrderRepository @@ -36,7 +36,7 @@ class OrderService: return None def create_order(self, entity: OrderEntity) -> OrderEntity: - order_model = Order( + order_model = TotalOrder( order_datetime=entity.order_datetime, user_id=entity.user_id, status_id=entity.status_id, diff --git a/app/core/usecases/step_service.py b/app/core/usecases/step_service.py deleted file mode 100644 index 5be6920..0000000 --- a/app/core/usecases/step_service.py +++ /dev/null @@ -1,74 +0,0 @@ -from typing import List, Optional - -from sqlalchemy.orm import Session - -from app.core.entities.step import StepEntity -from app.infrastructure.database.models.steps import Step -from app.infrastructure.database.repository.step_repository import StepRepository - - -class StepService: - def __init__(self, db: Session): - self.repository = StepRepository(db) - - def get_all_steps(self) -> List[StepEntity]: - steps = self.repository.get_all() - return [ - StepEntity( - id=s.id, - start_deadline=s.start_deadline, - finish_deadline=s.finish_deadline, - order_id=s.order_id, - status_id=s.status_id, - ) for s in steps - ] - - def get_step_by_id(self, step_id: int) -> Optional[StepEntity]: - step = self.repository.get_by_id(step_id) - if step: - return StepEntity( - id=step.id, - start_deadline=step.start_deadline, - finish_deadline=step.finish_deadline, - order_id=step.order_id, - status_id=step.status_id, - ) - - return None - - def create_step(self, entity: StepEntity) -> StepEntity: - step_model = Step( - start_deadline=entity.start_deadline, - finish_deadline=entity.finish_deadline, - order_id=entity.order_id, - status_id=entity.status_id, - ) - created_step = self.repository.create(step_model) - return StepEntity( - id=created_step.id, - start_deadline=created_step.start_deadline, - finish_deadline=created_step.finish_deadline, - order_id=created_step.order_id, - status_id=created_step.status_id, - ) - - def update_step(self, step_id: int, entity: StepEntity) -> Optional[StepEntity]: - step_model = self.repository.get_by_id(step_id) - if step_model: - step_model.start_deadline = entity.start_deadline - step_model.finish_deadline = entity.finish_deadline - step_model.order_id = entity.order_id - step_model.status_id = entity.status_id - self.repository.update(step_model) - return StepEntity( - id=step_model.id, - start_deadline=step_model.start_deadline, - finish_deadline=step_model.finish_deadline, - order_id=step_model.order_id, - status_id=step_model.status_id, - ) - - return None - - def delete_step(self, step_id: int) -> bool: - return self.repository.delete(step_id) is not None diff --git a/app/core/usecases/storage_accessory_service.py b/app/core/usecases/storage_accessory_service.py deleted file mode 100644 index 13b704f..0000000 --- a/app/core/usecases/storage_accessory_service.py +++ /dev/null @@ -1,75 +0,0 @@ -from typing import List, Optional - -from sqlalchemy.orm import Session - -from app.core.entities.storage_accessory import StorageAccessoryEntity -from app.infrastructure.database.models.storage_accessories import StorageAccessories -from app.infrastructure.database.repository.storage_accessory_repository import StorageAccessoryRepository - - -class StorageAccessoryService: - def __init__(self, db: Session): - self.repository = StorageAccessoryRepository(db) - - def get_all_storage_accessories(self) -> List[StorageAccessoryEntity]: - storage_accessories = self.repository.get_all() - return [ - StorageAccessoryEntity( - id=sa.id, - current_count=sa.current_count, - change_datetime=sa.change_datetime, - storage_id=sa.storage_id, - accessory_id=sa.accessory_id, - ) for sa in storage_accessories - ] - - def get_storage_accessory_by_id(self, storage_accessories_id: int) -> Optional[StorageAccessoryEntity]: - storage_accessory = self.repository.get_by_id(storage_accessories_id) - if storage_accessory: - return StorageAccessoryEntity( - id=storage_accessory.id, - current_count=storage_accessory.current_count, - change_datetime=storage_accessory.change_datetime, - storage_id=storage_accessory.storage_id, - accessory_id=storage_accessory.accessory_id, - ) - - return None - - def create_storage_accessory(self, entity: StorageAccessoryEntity) -> StorageAccessoryEntity: - storage_accessory_model = StorageAccessories( - current_count=entity.current_count, - change_datetime=entity.change_datetime, - storage_id=entity.storage_id, - accessory_id=entity.accessory_id, - ) - created_storage_accessory = self.repository.create(storage_accessory_model) - return StorageAccessoryEntity( - id=created_storage_accessory.id, - current_count=created_storage_accessory.current_count, - change_datetime=created_storage_accessory.change_datetime, - storage_id=created_storage_accessory.storage_id, - accessory_id=created_storage_accessory.accessory_id, - ) - - def update_storage_accessory(self, storage_accessories_id: int, entity: StorageAccessoryEntity) -> Optional[ - StorageAccessoryEntity]: - storage_accessory_model = self.repository.get_by_id(storage_accessories_id) - if storage_accessory_model: - storage_accessory_model.current_count = entity.current_count - storage_accessory_model.change_datetime = entity.change_datetime - storage_accessory_model.storage_id = entity.storage_id - storage_accessory_model.accessory_id = entity.accessory_id - self.repository.update(storage_accessory_model) - return StorageAccessoryEntity( - id=storage_accessory_model.id, - current_count=storage_accessory_model.current_count, - change_datetime=storage_accessory_model.change_datetime, - storage_id=storage_accessory_model.storage_id, - accessory_id=storage_accessory_model.accessory_id, - ) - - return None - - def delete_storage_accessory(self, storage_accessories_id: int) -> bool: - return self.repository.delete(storage_accessories_id) is not None diff --git a/app/core/usecases/storage_service.py b/app/core/usecases/storage_service.py deleted file mode 100644 index f27c17b..0000000 --- a/app/core/usecases/storage_service.py +++ /dev/null @@ -1,74 +0,0 @@ -from typing import List, Optional - -from sqlalchemy.orm import Session - -from app.core.entities.storage import StorageEntity -from app.infrastructure.database.models.storages import Storage -from app.infrastructure.database.repository.storage_repository import StorageRepository - - -class StorageService: - def __init__(self, db: Session): - self.repository = StorageRepository(db) - - def get_all_storages(self) -> List[StorageEntity]: - storages = self.repository.get_all() - return [ - StorageEntity( - id=s.id, - name=s.name, - x_coordinate=s.x_coordinate, - y_coordinate=s.y_coordinate, - storage_accessories=s.storage_accessories, - ) for s in storages - ] - - def get_storage_by_id(self, storage_id: int) -> Optional[StorageEntity]: - storage = self.repository.get_by_id(storage_id) - if storage: - return StorageEntity( - id=storage.id, - name=storage.name, - x_coordinate=storage.x_coordinate, - y_coordinate=storage.y_coordinate, - storage_accessories=storage.storage_accessories, - ) - - return None - - def create_storage(self, entity: StorageEntity) -> StorageEntity: - storage_model = Storage( - name=entity.name, - x_coordinate=entity.x_coordinate, - y_coordinate=entity.y_coordinate, - storage_accessories=entity.storage_accessories - ) - created_storage = self.repository.create(storage_model) - return StorageEntity( - id=created_storage.id, - name=created_storage.name, - x_coordinate=created_storage.x_coordinate, - y_coordinate=created_storage.y_coordinate, - storage_accessories=created_storage.storage_accessories, - ) - - def update_storage(self, storage_id: int, entity: StorageEntity) -> Optional[StorageEntity]: - storage_model = self.repository.get_by_id(storage_id) - if storage_model: - storage_model.name = entity.name - storage_model.x_coordinate = entity.x_coordinate - storage_model.y_coordinate = entity.y_coordinate - storage_model.storage_accessories = entity.storage_accessories - self.repository.update(storage_model) - return StorageEntity( - id=storage_model.id, - name=storage_model.name, - x_coordinate=storage_model.x_coordinate, - y_coordinate=storage_model.y_coordinate, - storage_accessories=storage_model.storage_accessories, - ) - - return None - - def delete_storage(self, storage_id: int) -> bool: - return self.repository.delete(storage_id) is not None diff --git a/app/infrastructure/database/database.py b/app/infrastructure/database/database.py index be3034f..51df0b8 100644 --- a/app/infrastructure/database/database.py +++ b/app/infrastructure/database/database.py @@ -14,14 +14,15 @@ SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine) def init_db(): - import app.infrastructure.database.models.accessory - import app.infrastructure.database.models.deliveries - import app.infrastructure.database.models.orders import app.infrastructure.database.models.roles - import app.infrastructure.database.models.statuses - import app.infrastructure.database.models.steps - import app.infrastructure.database.models.storage_accessories - import app.infrastructure.database.models.storages import app.infrastructure.database.models.users + import app.infrastructure.database.models.statuses + import app.infrastructure.database.models.federal_districts + import app.infrastructure.database.models.trucks + import app.infrastructure.database.models.cities + import app.infrastructure.database.models.accessory + import app.infrastructure.database.models.total_orders + import app.infrastructure.database.models.delivery_orders + import app.infrastructure.database.models.dilevery_accessiories Base.metadata.create_all(bind=engine) diff --git a/app/infrastructure/database/models/accessory.py b/app/infrastructure/database/models/accessory.py index eb47be1..9028af0 100644 --- a/app/infrastructure/database/models/accessory.py +++ b/app/infrastructure/database/models/accessory.py @@ -1,4 +1,4 @@ -from sqlalchemy import Column, Integer, VARCHAR, Float +from sqlalchemy import Column, Integer, VARCHAR, Float, ForeignKey from sqlalchemy.orm import relationship from app.infrastructure.database.models import Base @@ -9,9 +9,13 @@ class Accessory(Base): id = Column(Integer, primary_key=True, autoincrement=True) name = Column(VARCHAR(100), nullable=False) - width = Column(Float) - height = Column(Float) - length = Column(Float) + volume = Column(Float) weight = Column(Float) + period = Column(Integer) + + city_id = Column(ForeignKey('cities.id')) + + city = relationship('City', back_populates='accessories') + + delivery_accessories = relationship('DeliveryAccessory', back_populates='accessory') - storage_accessories = relationship('StorageAccessories', back_populates='accessory') diff --git a/app/infrastructure/database/models/cities.py b/app/infrastructure/database/models/cities.py new file mode 100644 index 0000000..3be527b --- /dev/null +++ b/app/infrastructure/database/models/cities.py @@ -0,0 +1,17 @@ +from sqlalchemy import Column, Integer, VARCHAR, Float, ForeignKey +from sqlalchemy.orm import relationship + +from app.infrastructure.database.models import Base + + +class City(Base): + __tablename__ = 'cities' + + id = Column(Integer, primary_key=True, autoincrement=True) + name = Column(VARCHAR(100), nullable=False) + + federal_district_id = Column(Integer, ForeignKey('federal_districts.id')) + + federal_district = relationship('FederalDistrict', back_populates='cities') + + accessories = relationship('City', back_populates='Accessory') diff --git a/app/infrastructure/database/models/deliveries.py b/app/infrastructure/database/models/deliveries.py deleted file mode 100644 index 5e10c60..0000000 --- a/app/infrastructure/database/models/deliveries.py +++ /dev/null @@ -1,17 +0,0 @@ -from sqlalchemy import Column, Integer, ForeignKey -from sqlalchemy.orm import relationship - -from app.infrastructure.database.models import Base - - -class Delivery(Base): - __tablename__ = 'deliveries' - - id = Column(Integer, primary_key=True, autoincrement=True) - count = Column(Integer, nullable=False) - - storage_accessories_id = Column(Integer, ForeignKey('storage_accessories.id')) - step_id = Column(Integer, ForeignKey('steps.id')) - - storage_accessory = relationship('StorageAccessories', back_populates='deliveries') - step = relationship('Step', back_populates='deliveries') diff --git a/app/infrastructure/database/models/delivery_orders.py b/app/infrastructure/database/models/delivery_orders.py new file mode 100644 index 0000000..d084d8a --- /dev/null +++ b/app/infrastructure/database/models/delivery_orders.py @@ -0,0 +1,21 @@ +from sqlalchemy import Column, Integer, VARCHAR, Float, DateTime, ForeignKey +from sqlalchemy.orm import relationship + +from app.infrastructure.database.models import Base + + +class DeliveryOrder(Base): + __tablename__ = 'delivery_orders' + + id = Column(Integer, primary_key=True, autoincrement=True) + order_datetime = Column(DateTime, nullable=False) + count_robots = Column(Integer, nullable=False) + deadline = Column(DateTime, nullable=False) + + truck_id = Column(Integer, ForeignKey('trucks.id')) + total_order_id = Column(Integer, ForeignKey('total_orders.id')) + + truck = relationship('Truck', back_populates='delivery_orders') + total_order = relationship('TotalOrder', back_populates='delivery_orders') + + delivery_accessories = relationship('DeliveryAccessory', back_populates='delivery_order') diff --git a/app/infrastructure/database/models/dilevery_accessiories.py b/app/infrastructure/database/models/dilevery_accessiories.py new file mode 100644 index 0000000..2c2de33 --- /dev/null +++ b/app/infrastructure/database/models/dilevery_accessiories.py @@ -0,0 +1,18 @@ +from sqlalchemy import Column, Integer, VARCHAR, Float, DateTime, ForeignKey +from sqlalchemy.orm import relationship + +from app.infrastructure.database.models import Base + + +class DeliveryAccessory(Base): + __tablename__ = 'delivery_accessories' + + id = Column(Integer, primary_key=True, autoincrement=True) + queue = Column(Integer, nullable=False) + count = Column(Integer, nullable=False) + + accessory_id = Column(Integer, ForeignKey('accessories.id')) + delivery_order_id = Column(Integer, ForeignKey('delivery_orders.id')) + + accessory = relationship('Accessory', back_populates='delivery_accessories') + delivery_order = relationship('DeliveryOrder', back_populates='delivery_accessories') diff --git a/app/infrastructure/database/models/federal_districts.py b/app/infrastructure/database/models/federal_districts.py new file mode 100644 index 0000000..73de04e --- /dev/null +++ b/app/infrastructure/database/models/federal_districts.py @@ -0,0 +1,13 @@ +from sqlalchemy import Column, Integer, VARCHAR +from sqlalchemy.orm import relationship + +from app.infrastructure.database.models import Base + + +class FederalDistrict(Base): + __tablename__ = 'federal_districts' + + id = Column(Integer, primary_key=True, autoincrement=True) + name = Column(VARCHAR(100), nullable=False) + + cities = relationship('City', back_populates='federal_district') diff --git a/app/infrastructure/database/models/steps.py b/app/infrastructure/database/models/steps.py deleted file mode 100644 index 36843b0..0000000 --- a/app/infrastructure/database/models/steps.py +++ /dev/null @@ -1,20 +0,0 @@ -from sqlalchemy import Column, Integer, DateTime, ForeignKey -from sqlalchemy.orm import relationship - -from app.infrastructure.database.models import Base - - -class Step(Base): - __tablename__ = 'steps' - - id = Column(Integer, primary_key=True, autoincrement=True) - start_deadline = Column(DateTime, nullable=False) - finish_deadline = Column(DateTime, nullable=False) - - order_id = Column(Integer, ForeignKey('orders.id')) - status_id = Column(Integer, ForeignKey('statuses.id')) - - order = relationship('Order', back_populates='steps') - status = relationship('Status', back_populates='steps') - - deliveries = relationship('Delivery', back_populates='step') diff --git a/app/infrastructure/database/models/storage_accessories.py b/app/infrastructure/database/models/storage_accessories.py deleted file mode 100644 index a56c86c..0000000 --- a/app/infrastructure/database/models/storage_accessories.py +++ /dev/null @@ -1,21 +0,0 @@ -from sqlalchemy import Column, Integer, DateTime, ForeignKey -from sqlalchemy.orm import relationship - -from app.infrastructure.database.models import Base - - -class StorageAccessories(Base): - __tablename__ = 'storage_accessories' - - id = Column(Integer, primary_key=True, autoincrement=True) - current_count = Column(Integer, nullable=False) - change_datetime = Column(DateTime) - - storage_id = Column(Integer, ForeignKey('storages.id')) - accessory_id = Column(Integer, ForeignKey('accessories.id')) - - storage = relationship('Storage', back_populates='storage_accessories') - accessory = relationship('Accessory', back_populates='storage_accessories') - - deliveries = relationship('Delivery', back_populates='storage_accessory') - diff --git a/app/infrastructure/database/models/orders.py b/app/infrastructure/database/models/total_orders.py similarity index 69% rename from app/infrastructure/database/models/orders.py rename to app/infrastructure/database/models/total_orders.py index 6fd185d..2303e37 100644 --- a/app/infrastructure/database/models/orders.py +++ b/app/infrastructure/database/models/total_orders.py @@ -4,11 +4,13 @@ from sqlalchemy.orm import relationship from app.infrastructure.database.models import Base -class Order(Base): - __tablename__ = 'orders' +class TotalOrder(Base): + __tablename__ = 'total_orders' id = Column(Integer, primary_key=True, autoincrement=True) order_datetime = Column(DateTime, nullable=False) + count_robots = Column(Integer, nullable=False) + deadline = Column(DateTime) user_id = Column(Integer, ForeignKey('users.id')) status_id = Column(Integer, ForeignKey('statuses.id')) @@ -16,4 +18,4 @@ class Order(Base): user = relationship('User', back_populates='orders') status = relationship('Status', back_populates='orders') - steps = relationship('Step', back_populates='order') \ No newline at end of file + delivery_orders = relationship('DeliveryOrder', back_populates='total_orders') diff --git a/app/infrastructure/database/models/storages.py b/app/infrastructure/database/models/trucks.py similarity index 52% rename from app/infrastructure/database/models/storages.py rename to app/infrastructure/database/models/trucks.py index 09c3d7c..0b4e25c 100644 --- a/app/infrastructure/database/models/storages.py +++ b/app/infrastructure/database/models/trucks.py @@ -4,12 +4,13 @@ from sqlalchemy.orm import relationship from app.infrastructure.database.models import Base -class Storage(Base): - __tablename__ = 'storages' +class Truck(Base): + __tablename__ = 'trucks' id = Column(Integer, primary_key=True, autoincrement=True) name = Column(VARCHAR(100), nullable=False) - x_coordinate = Column(Float, nullable=False) - y_coordinate = Column(Float, nullable=False) + capacity = Column(Float, nullable=False) + volume = Column(Float, nullable=False) + + delivery_orders = relationship('DeliveryOrder', back_populates='truck') - storage_accessories = relationship('StorageAccessories', back_populates='storage') diff --git a/app/infrastructure/database/repository/delivery_repository.py b/app/infrastructure/database/repository/delivery_repository.py deleted file mode 100644 index cd39149..0000000 --- a/app/infrastructure/database/repository/delivery_repository.py +++ /dev/null @@ -1,31 +0,0 @@ -from sqlalchemy.orm import Session -from app.infrastructure.database.models.deliveries import Delivery - - -class DeliveryRepository: - def __init__(self, db: Session): - self.db = db - - def get_all(self): - return self.db.query(Delivery).all() - - def get_by_id(self, delivery_id: int): - return self.db.query(Delivery).filter(Delivery.id == delivery_id).first() - - def create(self, delivery: Delivery): - self.db.add(delivery) - self.db.commit() - self.db.refresh(delivery) - return delivery - - def update(self, delivery: Delivery): - self.db.commit() - return delivery - - def delete(self, delivery_id: int): - delivery = self.db.query(Delivery).filter(Delivery.id == delivery_id).first() - if delivery: - self.db.delete(delivery) - self.db.commit() - return delivery - return None diff --git a/app/infrastructure/database/repository/order_repository.py b/app/infrastructure/database/repository/order_repository.py index 0d9cf43..d55bcd5 100644 --- a/app/infrastructure/database/repository/order_repository.py +++ b/app/infrastructure/database/repository/order_repository.py @@ -1,28 +1,28 @@ from sqlalchemy.orm import Session -from app.infrastructure.database.models.orders import Order +from app.infrastructure.database.models.total_orders import TotalOrder class OrderRepository: def __init__(self, db: Session): self.db = db def get_all(self): - return self.db.query(Order).all() + return self.db.query(TotalOrder).all() def get_by_id(self, order_id: int): - return self.db.query(Order).filter(Order.id == order_id).first() + return self.db.query(TotalOrder).filter(TotalOrder.id == order_id).first() - def create(self, order: Order): + def create(self, order: TotalOrder): self.db.add(order) self.db.commit() self.db.refresh(order) return order - def update(self, order: Order): + def update(self, order: TotalOrder): self.db.commit() return order def delete(self, order_id: int): - order = self.db.query(Order).filter(Order.id == order_id).first() + order = self.db.query(TotalOrder).filter(TotalOrder.id == order_id).first() if order: self.db.delete(order) self.db.commit() diff --git a/app/infrastructure/database/repository/step_repository.py b/app/infrastructure/database/repository/step_repository.py deleted file mode 100644 index 57e4e72..0000000 --- a/app/infrastructure/database/repository/step_repository.py +++ /dev/null @@ -1,30 +0,0 @@ -from sqlalchemy.orm import Session -from app.infrastructure.database.models.steps import Step - -class StepRepository: - def __init__(self, db: Session): - self.db = db - - def get_all(self): - return self.db.query(Step).all() - - def get_by_id(self, step_id: int): - return self.db.query(Step).filter(Step.id == step_id).first() - - def create(self, step: Step): - self.db.add(step) - self.db.commit() - self.db.refresh(step) - return step - - def update(self, step: Step): - self.db.commit() - return step - - def delete(self, step_id: int): - step = self.db.query(Step).filter(Step.id == step_id).first() - if step: - self.db.delete(step) - self.db.commit() - return step - return None diff --git a/app/infrastructure/database/repository/storage_accessory_repository.py b/app/infrastructure/database/repository/storage_accessory_repository.py deleted file mode 100644 index 7619dde..0000000 --- a/app/infrastructure/database/repository/storage_accessory_repository.py +++ /dev/null @@ -1,32 +0,0 @@ -from sqlalchemy.orm import Session -from app.infrastructure.database.models.storage_accessories import StorageAccessories - - -class StorageAccessoryRepository: - def __init__(self, db: Session): - self.db = db - - def get_all(self): - return self.db.query(StorageAccessories).all() - - def get_by_id(self, storage_accessories_id: int): - return self.db.query(StorageAccessories).filter(StorageAccessories.id == storage_accessories_id).first() - - def create(self, storage_accessories: StorageAccessories): - self.db.add(storage_accessories) - self.db.commit() - self.db.refresh(storage_accessories) - return storage_accessories - - def update(self, storage_accessories: StorageAccessories): - self.db.commit() - return storage_accessories - - def delete(self, storage_accessories_id: int): - storage_accessories = self.db.query(StorageAccessories).filter( - StorageAccessories.id == storage_accessories_id).first() - if storage_accessories: - self.db.delete(storage_accessories) - self.db.commit() - return storage_accessories - return None diff --git a/app/infrastructure/database/repository/storage_repository.py b/app/infrastructure/database/repository/storage_repository.py deleted file mode 100644 index 0953fd3..0000000 --- a/app/infrastructure/database/repository/storage_repository.py +++ /dev/null @@ -1,31 +0,0 @@ -from sqlalchemy.orm import Session -from app.infrastructure.database.models.storages import Storage - - -class StorageRepository: - def __init__(self, db: Session): - self.db = db - - def get_all(self): - return self.db.query(Storage).all() - - def get_by_id(self, storage_id: int): - return self.db.query(Storage).filter(Storage.id == storage_id).first() - - def create(self, storage: Storage): - self.db.add(storage) - self.db.commit() - self.db.refresh(storage) - return storage - - def update(self, storage: Storage): - self.db.commit() - return storage - - def delete(self, storage_id: int): - storage = self.db.query(Storage).filter(Storage.id == storage_id).first() - if storage: - self.db.delete(storage) - self.db.commit() - return storage - return None diff --git a/app/infrastructure/fastapi/delivery_routes.py b/app/infrastructure/fastapi/delivery_routes.py deleted file mode 100644 index ffa4519..0000000 --- a/app/infrastructure/fastapi/delivery_routes.py +++ /dev/null @@ -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.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/step_routes.py b/app/infrastructure/fastapi/step_routes.py deleted file mode 100644 index 54beeaa..0000000 --- a/app/infrastructure/fastapi/step_routes.py +++ /dev/null @@ -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.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 deleted file mode 100644 index 41f97a1..0000000 --- a/app/infrastructure/fastapi/storage_accessory_routes.py +++ /dev/null @@ -1,53 +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.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 deleted file mode 100644 index 1606400..0000000 --- a/app/infrastructure/fastapi/storage_routes.py +++ /dev/null @@ -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.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/main.py b/app/main.py index 3c727cc..f6787e5 100644 --- a/app/main.py +++ b/app/main.py @@ -1,25 +1,21 @@ from fastapi import FastAPI from app.infrastructure.database.database import init_db from app.infrastructure.fastapi.user_routes import router as user_router -from app.infrastructure.fastapi.storage_routes import router as storage_router -from app.infrastructure.fastapi.storage_accessory_routes import router as storage_accessory_router -from app.infrastructure.fastapi.step_routes import router as step_router from app.infrastructure.fastapi.status_routes import router as status_router from app.infrastructure.fastapi.role_routes import router as role_router from app.infrastructure.fastapi.order_routes import router as order_router -from app.infrastructure.fastapi.delivery_routes import router as delivery_router from app.infrastructure.fastapi.accessory_routes import router as accessory_router app = FastAPI() init_db() -app.include_router(user_router, prefix="/api/users", tags=["users"]) -app.include_router(storage_router, prefix="/api/storages", tags=["storages"]) -app.include_router(storage_accessory_router, prefix="/api/storage_accessories", tags=["storage_accessories"]) -app.include_router(step_router, prefix="/api/steps", tags=["steps"]) -app.include_router(status_router, prefix="/api/statuses", tags=["statuses"]) -app.include_router(role_router, prefix="/api/roles", tags=["roles"]) -app.include_router(order_router, prefix="/api/orders", tags=["orders"]) -app.include_router(delivery_router, prefix="/api/deliveries", tags=["deliveries"]) -app.include_router(accessory_router, prefix="/api/accessories", tags=["accessories"]) +# app.include_router(user_router, prefix="/api/users", tags=["users"]) +# app.include_router(storage_router, prefix="/api/storages", tags=["storages"]) +# app.include_router(storage_accessory_router, prefix="/api/storage_accessories", tags=["storage_accessories"]) +# app.include_router(step_router, prefix="/api/steps", tags=["steps"]) +# app.include_router(status_router, prefix="/api/statuses", tags=["statuses"]) +# app.include_router(role_router, prefix="/api/roles", tags=["roles"]) +# app.include_router(order_router, prefix="/api/orders", tags=["orders"]) +# app.include_router(delivery_router, prefix="/api/deliveries", tags=["deliveries"]) +# app.include_router(accessory_router, prefix="/api/accessories", tags=["accessories"])