crappy

services/client.py

@@ -1,14 +1,12 @@
 import datetime
-from typing import Union, Annotated
+from typing import Union
 
-from fastapi import Depends
 from sqlalchemy import select, update
 from sqlalchemy.orm import joinedload
 
 from models import Client, ClientDetails, User
-from services.auth import get_current_user
-from services.base import BaseService
 from schemas.client import *
+from services.base import BaseService
 
 
 class ClientService(BaseService):

services/deal.py

@@ -1,6 +1,6 @@
 import models.secondary
 from typing import Union
-
+import models.deal
 from fastapi import HTTPException
 from sqlalchemy import select, func
 from sqlalchemy.orm import joinedload, selectinload
@@ -156,3 +156,101 @@ class DealService(BaseService):
             )
         await self.session.commit()
         return DealAddServicesResponse(ok=True, message='Услуги успешно добавлены')
+
+    async def get_all(self) -> DealGetAllResponse:
+        deals_query = await self.session.scalars(select(Deal).options(joinedload(Deal.client)))
+        deals = deals_query.all()
+        result = []
+        for deal in deals:
+            result.append(DealSchema.model_validate(deal))
+        return DealGetAllResponse(deals=result)
+
+    async def get_by_id(self, deal_id: int) -> DealSchema:
+        deal = await self.session.scalar(
+            select(Deal)
+            .options(
+                joinedload(Deal.client),
+                selectinload(Deal.services)
+                .joinedload(models.secondary.DealService.service)
+                .joinedload(Service.category))
+            .where(Deal.id == deal_id)
+        )
+        if not deal:
+            raise HTTPException(status_code=404, detail="Сделка не найдена")
+        return DealSchema.model_validate(deal)
+
+    async def update_service_quantity(self,
+                                      request: DealUpdateServiceQuantityRequest) -> DealUpdateServiceQuantityResponse:
+        try:
+            deal_service = await self.session.scalar(
+                select(models.secondary.DealService)
+                .where(models.secondary.DealService.deal_id == request.deal_id,
+                       models.secondary.DealService.service_id == request.service_id)
+            )
+            if not deal_service:
+                raise HTTPException(status_code=404, detail="Сделка не найдена")
+            deal_service.quantity = request.quantity
+            await self.session.commit()
+            return DealUpdateServiceQuantityResponse(ok=True, message='Количество успешно обновлено')
+        except Exception as e:
+            await self.session.rollback()
+            return DealUpdateServiceQuantityResponse(ok=False, message=str(e))
+
+    async def add_service(self, request: DealAddServiceRequest) -> DealAddServiceResponse:
+        try:
+            deal = await self.session.scalar(select(Deal).where(Deal.id == request.deal_id))
+            if not deal:
+                raise HTTPException(status_code=404, detail="Сделка не найдена")
+            service = await self.session.scalar(select(Service).where(Service.id == request.service_id))
+            if not service:
+                raise HTTPException(status_code=404, detail="Услуга не найдена")
+            # Preventing duplicates
+            deal_service = await self.session.scalar(
+                select(models.secondary.DealService)
+                .where(models.secondary.DealService.deal_id == request.deal_id,
+                       models.secondary.DealService.service_id == request.service_id)
+            )
+            if deal_service:
+                raise HTTPException(status_code=400, detail="Услуга уже добавлена")
+            deal_service = models.secondary.DealService(
+                deal_id=request.deal_id,
+                service_id=request.service_id,
+                quantity=request.quantity
+            )
+            self.session.add(deal_service)
+            await self.session.commit()
+            return DealAddServiceResponse(ok=True, message='Услуга успешно добавлена')
+        except Exception as e:
+            await self.session.rollback()
+            return DealAddServiceResponse(ok=False, message=str(e))
+
+    async def delete_service(self, request: DealDeleteServiceRequest) -> DealDeleteServiceResponse:
+        try:
+            deal_service = await self.session.scalar(
+                select(models.secondary.DealService)
+                .where(models.secondary.DealService.deal_id == request.deal_id,
+                       models.secondary.DealService.service_id == request.service_id)
+            )
+            if not deal_service:
+                raise HTTPException(status_code=404, detail="Сделка не найдена")
+            await self.session.delete(deal_service)
+            await self.session.commit()
+            return DealDeleteServiceResponse(ok=True, message='Услуга успешно удалена')
+        except Exception as e:
+            await self.session.rollback()
+            return DealDeleteServiceResponse(ok=False, message=str(e))
+
+    async def delete_services(self, request: DealDeleteServicesRequest) -> DealDeleteServicesResponse:
+        try:
+            deal_services = await self.session.scalars(
+                select(models.secondary.DealService)
+                .where(models.secondary.DealService.deal_id == request.deal_id,
+                       models.secondary.DealService.service_id.in_(request.service_ids))
+            )
+            for deal_service in deal_services:
+                await self.session.delete(deal_service)
+            await self.session.commit()
+            return DealDeleteServicesResponse(ok=True, message='Услуги успешно удалены')
+        except Exception as e:
+            await self.session.rollback()
+            return DealDeleteServicesResponse(ok=False, message=str(e))