feat: modules, products, services, services kits

modules/fulfillment_base/services/__init__.py

@@ -0,0 +1,6 @@
+from .deal_product import DealProductService as DealProductService
+from .deal_service import DealServiceService as DealServiceService
+from .product import ProductService as ProductService
+from .product_service import ProductServiceService as ProductServiceService
+from .service import ServiceModelService as ServiceModelService
+from .services_kit import ServicesKitService as ServicesKitService

modules/fulfillment_base/services/deal_product.py

@@ -0,0 +1,72 @@
+from fastapi import HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from modules.fulfillment_base.models import DealProduct
+from modules.fulfillment_base.repositories import (
+    DealProductRepository,
+    ServicesKitRepository,
+    ProductServiceRepository,
+)
+from modules.fulfillment_base.schemas.deal_product import *
+from services.mixins import ServiceGetAllMixin
+
+
+class DealProductService(ServiceGetAllMixin[DealProduct, DealProductSchema]):
+    schema_class = DealProductSchema
+    entity_not_found_msg = "Связь товара со сделкой не найдена"
+
+    def __init__(self, session: AsyncSession):
+        self.repository = DealProductRepository(session)
+
+    async def create(
+        self, request: CreateDealProductRequest
+    ) -> CreateDealProductResponse:
+        await self.repository.create(request.entity)
+        deal_product = await self.repository.get_by_id(
+            request.entity.deal_id, request.entity.product_id
+        )
+        return CreateDealProductResponse(
+            entity=DealProductSchema.model_validate(deal_product),
+            message="Товар добавлен в сделку",
+        )
+
+    async def update(
+        self, deal_id: int, product_id: int, data: UpdateDealProductRequest
+    ) -> UpdateDealProductResponse:
+        entity = await self.repository.get_by_id(deal_id, product_id)
+        if not entity:
+            raise HTTPException(status_code=404, detail=self.entity_not_found_msg)
+
+        await self.repository.update(entity, data.entity)
+        return UpdateDealProductResponse(message="Товар сделки обновлен")
+
+    async def delete(self, deal_id: int, product_id: int) -> DeleteDealProductResponse:
+        entity = await self.repository.get_by_id(deal_id, product_id)
+        if not entity:
+            raise HTTPException(status_code=404, detail=self.entity_not_found_msg)
+
+        await self.repository.delete(entity)
+        return DeleteDealProductResponse(message="Товар удален из сделки")
+
+    async def add_services_kit(
+        self, request: DealProductAddKitRequest
+    ) -> DealProductAddKitResponse:
+        services_kit_repo = ServicesKitRepository(self.repository.session)
+        services_kit = await services_kit_repo.get_by_id(request.kit_id)
+        if not services_kit:
+            raise HTTPException(status_code=404, detail="Набор услуг не найден")
+
+        deal_product = await self.repository.get_by_id(
+            request.deal_id, request.product_id
+        )
+        if not deal_product:
+            raise HTTPException(status_code=404, detail=self.entity_not_found_msg)
+
+        product_service_repo = ProductServiceRepository(self.repository.session)
+        await product_service_repo.delete_product_services(
+            request.deal_id, [request.product_id]
+        )
+
+        await self.repository.add_services_kit(deal_product, services_kit)
+
+        return DealProductAddKitResponse(message="Комплект добавлен в товар")

modules/fulfillment_base/services/deal_service.py

@@ -0,0 +1,45 @@
+from fastapi import HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from modules.fulfillment_base.models import DealService
+from modules.fulfillment_base.repositories import DealServiceRepository
+from modules.fulfillment_base.schemas.deal_service import *
+from services.mixins import ServiceGetAllMixin
+
+
+class DealServiceService(ServiceGetAllMixin[DealService, DealServiceSchema]):
+    schema_class = DealServiceSchema
+    entity_not_found_msg = "Связь услуги со сделкой не найдена"
+
+    def __init__(self, session: AsyncSession):
+        self.repository = DealServiceRepository(session)
+
+    async def create(
+        self, request: CreateDealServiceRequest
+    ) -> CreateDealServiceResponse:
+        await self.repository.create(request.entity)
+        deal_service = await self.repository.get_by_id(
+            request.entity.deal_id, request.entity.service_id
+        )
+        return CreateDealServiceResponse(
+            entity=DealServiceSchema.model_validate(deal_service),
+            message="Услуга добавлена в сделку",
+        )
+
+    async def update(
+        self, deal_id: int, service_id: int, data: UpdateDealServiceRequest
+    ) -> UpdateDealServiceResponse:
+        entity = await self.repository.get_by_id(deal_id, service_id)
+        if not entity:
+            raise HTTPException(status_code=404, detail=self.entity_not_found_msg)
+
+        await self.repository.update(entity, data.entity)
+        return UpdateDealServiceResponse(message="Услуга сделки обновлена")
+
+    async def delete(self, deal_id: int, service_id: int) -> DeleteDealServiceResponse:
+        entity = await self.repository.get_by_id(deal_id, service_id)
+        if not entity:
+            raise HTTPException(status_code=404, detail=self.entity_not_found_msg)
+
+        await self.repository.delete(entity)
+        return DeleteDealServiceResponse(message="Услуга удалена из сделки")

modules/fulfillment_base/services/product.py

@@ -0,0 +1,27 @@
+from modules.fulfillment_base.models import Product
+from modules.fulfillment_base.repositories import ProductRepository
+from modules.fulfillment_base.schemas.product import (
+    CreateProductRequest,
+    ProductSchema,
+    UpdateProductRequest,
+)
+from services.mixins import *
+
+
+class ProductService(
+    ServiceGetAllMixin[Product, ProductSchema],
+    ServiceCreateMixin[Product, CreateProductRequest, ProductSchema],
+    ServiceUpdateMixin[Product, UpdateProductRequest],
+    ServiceDeleteMixin[Product],
+):
+    schema_class = ProductSchema
+    entity_not_found_msg = "Товар не найден"
+    entity_deleted_msg = "Товар успешно удален"
+    entity_updated_msg = "Товар успешно обновлен"
+    entity_created_msg = "Товар успешно создан"
+
+    def __init__(self, session: AsyncSession):
+        self.repository = ProductRepository(session)
+
+    async def is_soft_delete(self, product: ProductSchema) -> bool:
+        return True

modules/fulfillment_base/services/product_service.py

@@ -0,0 +1,66 @@
+from fastapi import HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from modules.fulfillment_base.models import DealProductService
+from modules.fulfillment_base.repositories import ProductServiceRepository
+from modules.fulfillment_base.schemas.product_service import *
+
+
+class ProductServiceService:
+    schema_class = ProductServiceSchema
+    entity_not_found_msg = "Связь услуги с товаром не найдена"
+
+    def __init__(self, session: AsyncSession):
+        self.repository = ProductServiceRepository(session)
+
+    async def create(
+        self, request: CreateProductServiceRequest
+    ) -> CreateProductServiceResponse:
+        await self.repository.create(request.entity)
+        deal_product = await self.repository.get_by_id(
+            request.entity.deal_id,
+            request.entity.product_id,
+            request.entity.service_id,
+        )
+        return CreateProductServiceResponse(
+            entity=ProductServiceSchema.model_validate(deal_product),
+            message="Услуга добавлена к товару",
+        )
+
+    async def update(
+        self,
+        deal_id: int,
+        product_id: int,
+        service_id: int,
+        data: UpdateProductServiceRequest,
+    ) -> UpdateProductServiceResponse:
+        entity = await self.repository.get_by_id(deal_id, product_id, service_id)
+        if not entity:
+            raise HTTPException(status_code=404, detail=self.entity_not_found_msg)
+
+        await self.repository.update(entity, data.entity)
+        return UpdateProductServiceResponse(message="Услуга обновлена")
+
+    async def delete(
+        self, deal_id: int, product_id: int, service_id: int
+    ) -> DeleteProductServiceResponse:
+        entity = await self.repository.get_by_id(deal_id, product_id, service_id)
+        if not entity:
+            raise HTTPException(status_code=404, detail=self.entity_not_found_msg)
+
+        await self.repository.delete(entity)
+        return DeleteProductServiceResponse(message="Товар удален из сделки")
+
+    async def duplicate_product_services(
+        self, request: ProductServicesDuplicateRequest
+    ) -> ProductServicesDuplicateResponse:
+        services_to_copy: list[
+            DealProductService
+        ] = await self.repository.get_product_services(
+            request.deal_id, request.source_deal_product_id
+        )
+
+        await self.repository.duplicate_services(
+            request.deal_id, request.target_deal_product_ids, services_to_copy
+        )
+        return ProductServicesDuplicateResponse(message="Услуги продублированы")

modules/fulfillment_base/services/service.py

@@ -0,0 +1,27 @@
+from modules.fulfillment_base.models import Service
+from modules.fulfillment_base.repositories import ServiceRepository
+from modules.fulfillment_base.schemas.service import (
+    ServiceSchema,
+    CreateServiceRequest,
+    UpdateServiceRequest,
+)
+from services.mixins import *
+
+
+class ServiceModelService(
+    ServiceGetAllMixin[Service, ServiceSchema],
+    ServiceCreateMixin[Service, CreateServiceRequest, ServiceSchema],
+    ServiceUpdateMixin[Service, UpdateServiceRequest],
+    ServiceDeleteMixin[Service],
+):
+    schema_class = ServiceSchema
+    entity_not_found_msg = "Услуга не найдена"
+    entity_deleted_msg = "Услуга успешно удалена"
+    entity_updated_msg = "Услуга успешно обновлена"
+    entity_created_msg = "Услуга успешно создана"
+
+    def __init__(self, session: AsyncSession):
+        self.repository = ServiceRepository(session)
+
+    async def is_soft_delete(self, service: ServiceSchema) -> bool:
+        return True

modules/fulfillment_base/services/services_kit.py

@@ -0,0 +1,24 @@
+from modules.fulfillment_base.models.service import ServicesKit
+from modules.fulfillment_base.repositories import ServicesKitRepository
+from modules.fulfillment_base.schemas.services_kit import (
+    ServicesKitSchema,
+    CreateServicesKitRequest,
+    UpdateServicesKitRequest,
+)
+from services.mixins import *
+
+
+class ServicesKitService(
+    ServiceCrudMixin[ServicesKit, ServicesKitSchema, CreateServicesKitRequest, UpdateServicesKitRequest]
+):
+    schema_class = ServicesKitSchema
+    entity_not_found_msg = "Набор услуг не найден"
+    entity_deleted_msg = "Набор услуг успешно удален"
+    entity_updated_msg = "Набор услуг успешно обновлен"
+    entity_created_msg = "Набор услуг успешно создан"
+
+    def __init__(self, session: AsyncSession):
+        self.repository = ServicesKitRepository(session)
+
+    async def is_soft_delete(self, service: ServicesKitSchema) -> bool:
+        return False