._.

app/core/entities/storage_accessory.py

@@ -2,7 +2,7 @@ from typing import Optional
 from datetime import datetime
 
 
-class StorageAccessoriesEntity:
+class StorageAccessoryEntity:
     def __init__(self,
                  storage_accessories_id: Optional[int],
                  current_count: int,

app/core/usecases/accessory_service.py

@@ -0,0 +1,49 @@
+from typing import List, Optional
+
+from sqlalchemy.orm import Session
+
+from app.core.entities.accessory import AccessoryEntity
+from app.infrastructure.database.models.accessory import Accessory
+from app.infrastructure.database.repository.accessory_repository import AccessoriesRepository
+
+class AccessoriesService:
+    def __init__(self, db: Session):
+        self.repository = AccessoriesRepository(db)
+
+    def get_all_accessories(self) -> List[AccessoryEntity]:
+        accessories = self.repository.get_all()
+        return [AccessoryEntity(a.id, a.name, a.width, a.height, a.length, a.weight) for a in accessories]
+
+    def get_accessory_by_id(self, accessory_id: int) -> Optional[AccessoryEntity]:
+        accessory = self.repository.get_by_id(accessory_id)
+        if accessory:
+            return AccessoryEntity(accessory.id, accessory.name, accessory.width, accessory.height, accessory.length, accessory.weight)
+
+        return None
+
+    def create_accessory(self, entity: AccessoryEntity) -> AccessoryEntity:
+        accessory_model = Accessory(
+            name=entity.name,
+            width=entity.width,
+            height=entity.height,
+            length=entity.length,
+            weight=entity.weight
+        )
+        created_accessory = self.repository.create(accessory_model)
+        return AccessoryEntity(created_accessory.id, created_accessory.name, created_accessory.width, created_accessory.height, created_accessory.length, created_accessory.weight)
+
+    def update_accessory(self, accessory_id: int, entity: AccessoryEntity) -> Optional[AccessoryEntity]:
+        accessory_model = self.repository.get_by_id(accessory_id)
+        if accessory_model:
+            accessory_model.name = entity.name
+            accessory_model.width = entity.width
+            accessory_model.height = entity.height
+            accessory_model.length = entity.length
+            accessory_model.weight = entity.weight
+            self.repository.update(accessory_model)
+            return AccessoryEntity(accessory_model.id, accessory_model.name, accessory_model.width, accessory_model.height, accessory_model.length, accessory_model.weight)
+
+        return None
+
+    def delete_accessory(self, accessory_id: int) -> bool:
+        return self.repository.delete(accessory_id) is not None

app/core/usecases/delivery_service.py

@@ -0,0 +1,48 @@
+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(d.id, d.count, d.storage_accessories_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(delivery.id, delivery.count, delivery.storage_accessories_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(created_delivery.id, created_delivery.count, created_delivery.storage_accessories_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(delivery_model.id, delivery_model.count, delivery_model.storage_accessories_id,
+                                  delivery_model.step_id)
+
+        return None
+
+    def delete_delivery(self, delivery_id: int) -> bool:
+        return self.repository.delete(delivery_id) is not None

app/core/usecases/order_service.py

@@ -0,0 +1,47 @@
+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.repository.order_repository import OrderRepository
+
+
+class OrderService:
+    def __init__(self, db: Session):
+        self.repository = OrderRepository(db)
+
+    def get_all_orders(self) -> List[OrderEntity]:
+        orders = self.repository.get_all()
+        return [OrderEntity(o.id, o.order_datetime, o.user_id, o.status_id) for o in orders]
+
+    def get_order_by_id(self, order_id: int) -> Optional[OrderEntity]:
+        order = self.repository.get_by_id(order_id)
+        if order:
+            return OrderEntity(order.id, order.order_datetime, order.user_id, order.status_id)
+
+        return None
+
+    def create_order(self, entity: OrderEntity) -> OrderEntity:
+        order_model = Order(
+            order_datetime=entity.order_datetime,
+            user_id=entity.user_id,
+            status_id=entity.status_id
+        )
+        created_order = self.repository.create(order_model)
+        return OrderEntity(created_order.id, created_order.order_datetime, created_order.user_id,
+                           created_order.status_id)
+
+    def update_order(self, order_id: int, entity: OrderEntity) -> Optional[OrderEntity]:
+        order_model = self.repository.get_by_id(order_id)
+        if order_model:
+            order_model.order_datetime = entity.order_datetime
+            order_model.user_id = entity.user_id
+            order_model.status_id = entity.status_id
+            self.repository.update(order_model)
+            return OrderEntity(order_model.id, order_model.order_datetime, order_model.user_id, order_model.status_id)
+
+        return None
+
+    def delete_order(self, order_id: int) -> bool:
+        return self.repository.delete(order_id) is not None

app/core/usecases/role_service.py

@@ -0,0 +1,40 @@
+from typing import List, Optional
+
+from sqlalchemy.orm import Session
+
+from app.core.entities.role import RoleEntity
+from app.infrastructure.database.models.roles import Role
+from app.infrastructure.database.repository.role_repository import RoleRepository
+
+
+class RoleService:
+    def __init__(self, db: Session):
+        self.repository = RoleRepository(db)
+
+    def get_all_roles(self) -> List[RoleEntity]:
+        roles = self.repository.get_all()
+        return [RoleEntity(r.id, r.name) for r in roles]
+
+    def get_role_by_id(self, role_id: int) -> Optional[RoleEntity]:
+        role = self.repository.get_by_id(role_id)
+        if role:
+            return RoleEntity(role.id, role.name)
+
+        return None
+
+    def create_role(self, entity: RoleEntity) -> RoleEntity:
+        role_model = Role(name=entity.name)
+        created_role = self.repository.create(role_model)
+        return RoleEntity(created_role.id, created_role.name)
+
+    def update_role(self, role_id: int, entity: RoleEntity) -> Optional[RoleEntity]:
+        role_model = self.repository.get_by_id(role_id)
+        if role_model:
+            role_model.name = entity.name
+            self.repository.update(role_model)
+            return RoleEntity(role_model.id, role_model.name)
+
+        return None
+
+    def delete_role(self, role_id: int) -> bool:
+        return self.repository.delete(role_id) is not None

app/core/usecases/status_service.py

@@ -0,0 +1,40 @@
+from typing import List, Optional
+
+from sqlalchemy.orm import Session
+
+from app.core.entities.status import StatusEntity
+from app.infrastructure.database.models.statuses import Status
+from app.infrastructure.database.repository.status_repository import StatusRepository
+
+
+class StatusService:
+    def __init__(self, db: Session):
+        self.repository = StatusRepository(db)
+
+    def get_all_statuses(self) -> List[StatusEntity]:
+        statuses = self.repository.get_all()
+        return [StatusEntity(s.id, s.name) for s in statuses]
+
+    def get_status_by_id(self, status_id: int) -> Optional[StatusEntity]:
+        status = self.repository.get_by_id(status_id)
+        if status:
+            return StatusEntity(status.id, status.name)
+
+        return None
+
+    def create_status(self, entity: StatusEntity) -> StatusEntity:
+        status_model = Status(name=entity.name)
+        created_status = self.repository.create(status_model)
+        return StatusEntity(created_status.id, created_status.name)
+
+    def update_status(self, status_id: int, entity: StatusEntity) -> Optional[StatusEntity]:
+        status_model = self.repository.get_by_id(status_id)
+        if status_model:
+            status_model.name = entity.name
+            self.repository.update(status_model)
+            return StatusEntity(status_model.id, status_model.name)
+
+        return None
+
+    def delete_status(self, status_id: int) -> bool:
+        return self.repository.delete(status_id) is not None

app/core/usecases/step_service.py

@@ -0,0 +1,74 @@
+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(
+                s.id,
+                s.start_deadline,
+                s.finish_deadline,
+                s.order_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(
+                step.id,
+                step.start_deadline,
+                step.finish_deadline,
+                step.order_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(
+            created_step.id,
+            created_step.start_deadline,
+            created_step.finish_deadline,
+            created_step.order_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(
+                step_model.id,
+                step_model.start_deadline,
+                step_model.finish_deadline,
+                step_model.order_id,
+                step_model.status_id
+            )
+
+        return None
+
+    def delete_step(self, step_id: int) -> bool:
+        return self.repository.delete(step_id) is not None

app/core/usecases/storage_accessory_repository.py

@@ -0,0 +1,75 @@
+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(
+                sa.id,
+                sa.current_count,
+                sa.change_datetime,
+                sa.storage_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(
+                storage_accessory.id,
+                storage_accessory.current_count,
+                storage_accessory.change_datetime,
+                storage_accessory.storage_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(
+            created_storage_accessory.id,
+            created_storage_accessory.current_count,
+            created_storage_accessory.change_datetime,
+            created_storage_accessory.storage_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(
+                storage_accessory_model.id,
+                storage_accessory_model.current_count,
+                storage_accessory_model.change_datetime,
+                storage_accessory_model.storage_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

app/core/usecases/storage_service.py

@@ -0,0 +1,74 @@
+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(
+                s.id,
+                s.name,
+                s.x_coordinate,
+                s.y_coordinate,
+                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(
+                storage.id,
+                storage.name,
+                storage.x_coordinate,
+                storage.y_coordinate,
+                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(
+            created_storage.id,
+            created_storage.name,
+            created_storage.x_coordinate,
+            created_storage.y_coordinate,
+            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(
+                storage_model.id,
+                storage_model.name,
+                storage_model.x_coordinate,
+                storage_model.y_coordinate,
+                storage_model.storage_accessories
+            )
+
+        return None
+
+    def delete_storage(self, storage_id: int) -> bool:
+        return self.repository.delete(storage_id) is not None

app/core/usecases/user_service.py

@@ -0,0 +1,94 @@
+from typing import List, Optional
+
+from sqlalchemy.orm import Session
+
+from app.core.entities.user import UserEntity
+from app.infrastructure.database.models.users import User
+from app.infrastructure.database.repository.user_repository import UserRepository
+
+
+class UserService:
+    def __init__(self, db: Session):
+        self.repository = UserRepository(db)
+
+    def get_all_users(self) -> List[UserEntity]:
+        users = self.repository.get_all()
+        return [
+            UserEntity(
+                user.id,
+                user.first_name,
+                user.last_name,
+                user.login,
+                user.password,
+                user.role_id
+            ) for user in users
+        ]
+
+    def get_user_by_id(self, user_id: int) -> Optional[UserEntity]:
+        user = self.repository.get_by_id(user_id)
+        if user:
+            return UserEntity(
+                user.id,
+                user.first_name,
+                user.last_name,
+                user.login,
+                user.password,
+                user.role_id
+            )
+
+        return None
+
+    def get_user_by_login(self, login: str) -> Optional[UserEntity]:
+        user = self.repository.get_by_login(login)
+        if user:
+            return UserEntity(
+                user.id,
+                user.first_name,
+                user.last_name,
+                user.login,
+                user.password,
+                user.role_id
+            )
+
+        return None
+
+    def create_user(self, entity: UserEntity) -> UserEntity:
+        user_model = User(
+            first_name=entity.first_name,
+            last_name=entity.last_name,
+            login=entity.login,
+            password=entity.password,
+            role_id=entity.role_id
+        )
+        created_user = self.repository.create(user_model)
+        return UserEntity(
+            created_user.id,
+            created_user.first_name,
+            created_user.last_name,
+            created_user.login,
+            created_user.password,
+            created_user.role_id
+        )
+
+    def update_user(self, user_id: int, entity: UserEntity) -> Optional[UserEntity]:
+        user_model = self.repository.get_by_id(user_id)
+        if user_model:
+            user_model.first_name = entity.first_name
+            user_model.last_name = entity.last_name
+            user_model.login = entity.login
+            user_model.password = entity.password
+            user_model.role_id = entity.role_id
+            self.repository.update(user_model)
+            return UserEntity(
+                user_model.id,
+                user_model.first_name,
+                user_model.last_name,
+                user_model.login,
+                user_model.password,
+                user_model.role_id
+            )
+
+        return None
+
+    def delete_user(self, user_id: int) -> bool:
+        return self.repository.delete(user_id) is not None

app/infrastructure/database/repository/delivery_repository.py

@@ -2,7 +2,7 @@ from sqlalchemy.orm import Session
 from app.infrastructure.database.models.deliveries import Delivery
 
 
-class DeliveriesRepository:
+class DeliveryRepository:
     def __init__(self, db: Session):
         self.db = db
 

app/infrastructure/database/repository/order_repository.py

@@ -1,7 +1,7 @@
 from sqlalchemy.orm import Session
 from app.infrastructure.database.models.orders import Order
 
-class OrdersRepository:
+class OrderRepository:
     def __init__(self, db: Session):
         self.db = db
 

app/infrastructure/database/repository/role_repository.py

@@ -1,7 +1,7 @@
 from sqlalchemy.orm import Session
 from app.infrastructure.database.models.roles import Role
 
-class RolesRepository:
+class RoleRepository:
     def __init__(self, db: Session):
         self.db = db
 

app/infrastructure/database/repository/status_repository.py

@@ -1,7 +1,7 @@
 from sqlalchemy.orm import Session
 from app.infrastructure.database.models.statuses import Status
 
-class StatusesRepository:
+class StatusRepository:
     def __init__(self, db: Session):
         self.db = db
 

app/infrastructure/database/repository/step_repository.py

@@ -1,7 +1,7 @@
 from sqlalchemy.orm import Session
 from app.infrastructure.database.models.steps import Step
 
-class StepsRepository:
+class StepRepository:
     def __init__(self, db: Session):
         self.db = db
 

app/infrastructure/database/repository/storage_accessory_repository.py

@@ -2,7 +2,7 @@ from sqlalchemy.orm import Session
 from app.infrastructure.database.models.storage_accessories import StorageAccessories
 
 
-class StorageAccessoriesRepository:
+class StorageAccessoryRepository:
     def __init__(self, db: Session):
         self.db = db