From 72d24ca27a4938ba7a52077ec4fef73ba7faf87d Mon Sep 17 00:00:00 2001 From: andrei Date: Fri, 4 Oct 2024 10:22:32 +0500 Subject: [PATCH] ._. --- ...ge_accessories.py => storage_accessory.py} | 2 +- app/core/usecases/accessory_service.py | 49 ++++++++++ app/core/usecases/delivery_service.py | 48 ++++++++++ app/core/usecases/order_service.py | 47 ++++++++++ app/core/usecases/role_service.py | 40 ++++++++ app/core/usecases/status_service.py | 40 ++++++++ app/core/usecases/step_service.py | 74 +++++++++++++++ .../usecases/storage_accessory_repository.py | 75 +++++++++++++++ app/core/usecases/storage_service.py | 74 +++++++++++++++ app/core/usecases/user_service.py | 94 +++++++++++++++++++ .../repository/delivery_repository.py | 2 +- ...ders_repository.py => order_repository.py} | 2 +- ...roles_repository.py => role_repository.py} | 2 +- ...ses_repository.py => status_repository.py} | 2 +- ...steps_repository.py => step_repository.py} | 2 +- ...ory.py => storage_accessory_repository.py} | 2 +- 16 files changed, 548 insertions(+), 7 deletions(-) rename app/core/entities/{storage_accessories.py => storage_accessory.py} (96%) create mode 100644 app/core/usecases/accessory_service.py create mode 100644 app/core/usecases/delivery_service.py create mode 100644 app/core/usecases/order_service.py create mode 100644 app/core/usecases/role_service.py create mode 100644 app/core/usecases/status_service.py create mode 100644 app/core/usecases/step_service.py create mode 100644 app/core/usecases/storage_accessory_repository.py create mode 100644 app/core/usecases/storage_service.py create mode 100644 app/core/usecases/user_service.py rename app/infrastructure/database/repository/{orders_repository.py => order_repository.py} (97%) rename app/infrastructure/database/repository/{roles_repository.py => role_repository.py} (97%) rename app/infrastructure/database/repository/{statuses_repository.py => status_repository.py} (96%) rename app/infrastructure/database/repository/{steps_repository.py => step_repository.py} (97%) rename app/infrastructure/database/repository/{storage_accessories_repository.py => storage_accessory_repository.py} (96%) diff --git a/app/core/entities/storage_accessories.py b/app/core/entities/storage_accessory.py similarity index 96% rename from app/core/entities/storage_accessories.py rename to app/core/entities/storage_accessory.py index 4e5cd59..b27f4a6 100644 --- a/app/core/entities/storage_accessories.py +++ b/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, diff --git a/app/core/usecases/accessory_service.py b/app/core/usecases/accessory_service.py new file mode 100644 index 0000000..5c6646f --- /dev/null +++ b/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 diff --git a/app/core/usecases/delivery_service.py b/app/core/usecases/delivery_service.py new file mode 100644 index 0000000..e5fafe1 --- /dev/null +++ b/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 diff --git a/app/core/usecases/order_service.py b/app/core/usecases/order_service.py new file mode 100644 index 0000000..257fb83 --- /dev/null +++ b/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 diff --git a/app/core/usecases/role_service.py b/app/core/usecases/role_service.py new file mode 100644 index 0000000..e94f93a --- /dev/null +++ b/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 diff --git a/app/core/usecases/status_service.py b/app/core/usecases/status_service.py new file mode 100644 index 0000000..080b34e --- /dev/null +++ b/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 diff --git a/app/core/usecases/step_service.py b/app/core/usecases/step_service.py new file mode 100644 index 0000000..988f0c9 --- /dev/null +++ b/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 diff --git a/app/core/usecases/storage_accessory_repository.py b/app/core/usecases/storage_accessory_repository.py new file mode 100644 index 0000000..936b258 --- /dev/null +++ b/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 diff --git a/app/core/usecases/storage_service.py b/app/core/usecases/storage_service.py new file mode 100644 index 0000000..3969881 --- /dev/null +++ b/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 diff --git a/app/core/usecases/user_service.py b/app/core/usecases/user_service.py new file mode 100644 index 0000000..25b4ce5 --- /dev/null +++ b/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 diff --git a/app/infrastructure/database/repository/delivery_repository.py b/app/infrastructure/database/repository/delivery_repository.py index cc847dc..cd39149 100644 --- a/app/infrastructure/database/repository/delivery_repository.py +++ b/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 diff --git a/app/infrastructure/database/repository/orders_repository.py b/app/infrastructure/database/repository/order_repository.py similarity index 97% rename from app/infrastructure/database/repository/orders_repository.py rename to app/infrastructure/database/repository/order_repository.py index 5da40a6..0d9cf43 100644 --- a/app/infrastructure/database/repository/orders_repository.py +++ b/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 diff --git a/app/infrastructure/database/repository/roles_repository.py b/app/infrastructure/database/repository/role_repository.py similarity index 97% rename from app/infrastructure/database/repository/roles_repository.py rename to app/infrastructure/database/repository/role_repository.py index e830323..4d7bb1d 100644 --- a/app/infrastructure/database/repository/roles_repository.py +++ b/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 diff --git a/app/infrastructure/database/repository/statuses_repository.py b/app/infrastructure/database/repository/status_repository.py similarity index 96% rename from app/infrastructure/database/repository/statuses_repository.py rename to app/infrastructure/database/repository/status_repository.py index 2698854..b6eaff5 100644 --- a/app/infrastructure/database/repository/statuses_repository.py +++ b/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 diff --git a/app/infrastructure/database/repository/steps_repository.py b/app/infrastructure/database/repository/step_repository.py similarity index 97% rename from app/infrastructure/database/repository/steps_repository.py rename to app/infrastructure/database/repository/step_repository.py index f413830..57e4e72 100644 --- a/app/infrastructure/database/repository/steps_repository.py +++ b/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 diff --git a/app/infrastructure/database/repository/storage_accessories_repository.py b/app/infrastructure/database/repository/storage_accessory_repository.py similarity index 96% rename from app/infrastructure/database/repository/storage_accessories_repository.py rename to app/infrastructure/database/repository/storage_accessory_repository.py index a4282ef..7619dde 100644 --- a/app/infrastructure/database/repository/storage_accessories_repository.py +++ b/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