feat: projects and boards

services/deal_group.py

@@ -1,10 +1,12 @@
-from sqlalchemy import select
+from lexorank import lexorank
+from sqlalchemy import select, insert, update, delete
 from sqlalchemy.orm import selectinload
 
-from models import DealService as DealServiceModel
-from models.deal_group import DealGroup
-from schemas.deal import *
+from models import DealService as DealServiceModel, User, Deal, DealProduct, Product, GroupBillRequest
+from models.deal_group import DealGroup, deal_relations
+from schemas.group import *
 from services.base import BaseService
+from services.deal import DealService
 
 
 class DealGroupService(BaseService):
@@ -25,6 +27,63 @@ class DealGroupService(BaseService):
         )
         return group.deals if group else []
 
+    async def create_group_model(self) -> DealGroup:
+        group = DealGroup(
+            name='',
+            lexorank=lexorank.middle(lexorank.Bucket.BUCEKT_0).__str__(),
+        )
+        self.session.add(group)
+        await self.session.flush()
+        return group
+
+    async def create_group(self, user: User, request: DealCreateGroupRequest) -> DealCreateGroupResponse:
+        try:
+            group = await self.create_group_model()
+
+            for deal_id in [request.dragging_deal_id, request.hovered_deal_id]:
+                insert_stmt = insert(deal_relations).values({
+                    'deal_id': deal_id,
+                    'group_id': group.id
+                })
+                await self.session.execute(insert_stmt)
+            # changing status if needed on draggable deal
+            dragging_deal = await self.session.scalar(
+                select(Deal).where(Deal.id == request.dragging_deal_id)
+            )
+            dropped_deal = await self.session.scalar(
+                select(Deal).where(Deal.id == request.hovered_deal_id)
+            )
+            if dragging_deal.current_status_id != dropped_deal.current_status_id:
+                deal_service = DealService(self.session)
+                await deal_service.change_status(dragging_deal, dropped_deal.current_status_id, user)
+            await self.session.commit()
+            return DealCreateGroupResponse(ok=True, message="Группа успешно создана")
+        except Exception as e:
+            return DealCreateGroupResponse(ok=False, message=str(e))
+
+    async def update_group(self, request: DealGroupUpdateRequest) -> DealGroupUpdateResponse:
+        try:
+            group = await self.session.scalar(
+                select(DealGroup).where(DealGroup.id == request.data.id)
+            )
+            if not group:
+                return DealGroupUpdateResponse(ok=False, message="Группа не найдена")
+            # update by dictionary
+            request_dict = request.data.model_dump()
+            request_dict.pop("bill_request", None)
+
+            update_stmt = (
+                update(DealGroup)
+                .where(DealGroup.id == request.data.id)
+                .values(**request_dict)
+            )
+            await self.session.execute(update_stmt)
+            await self.session.commit()
+            return DealGroupUpdateResponse(ok=True, message="Группа успешно обновлена")
+        except Exception as e:
+            await self.session.rollback()
+            return DealGroupUpdateResponse(ok=False, message=str(e))
+
     async def complete_group(self, group_id: int) -> list[Deal]:
         deals = await self.get_deals_by_group_id(group_id)
         for deal in deals:
@@ -36,3 +95,74 @@ class DealGroupService(BaseService):
         for deal in deals:
             deal.is_deleted = True
         await self.session.commit()
+
+    async def change_group_status(
+            self,
+            user: User,
+            request: DealGroupChangeStatusRequest,
+    ) -> DealGroupChangeStatusResponse:
+        try:
+            # getting all deals in group
+            deals = await self.session.scalars(
+                select(deal_relations.c.deal_id)
+                .where(deal_relations.c.group_id == request.group_id)
+            )
+
+            deal_service = DealService(self.session)
+            for deal_id in deals:
+                deal = await self.session.scalar(
+                    select(Deal).where(Deal.id == deal_id)
+                )
+                await deal_service.change_status(deal, request.new_status, user)
+            await self.session.commit()
+            return DealGroupChangeStatusResponse(ok=True, message="Статус группы успешно изменен")
+        except Exception as e:
+            await self.session.rollback()
+            return DealGroupChangeStatusResponse(ok=False, message=str(e))
+
+    async def add_deal(self, user: User, request: DealAddToGroupRequest) -> DealAddToGroupResponse:
+        try:
+            group_bill_request = await self.session.get(GroupBillRequest, request.group_id)
+            if group_bill_request:
+                raise Exception("Нельзя добавить сделку, так как на группу выставлен счёт.")
+
+            # changing status if needed
+            deal_id = await self.session.scalar(
+                select(deal_relations.c.deal_id)
+                .where(deal_relations.c.group_id == request.group_id)
+            )
+            group_deal_status = await self.session.scalar(
+                select(Deal.current_status_id)
+                .where(Deal.id == deal_id)
+            )
+            request_deal = await self.session.scalar(
+                select(Deal).where(Deal.id == request.deal_id)
+            )
+            if group_deal_status != request_deal.current_status_id:
+                await DealService(self.session).change_status(request_deal, group_deal_status, user)
+            insert_stmt = insert(deal_relations).values({
+                'deal_id': request.deal_id,
+                'group_id': request.group_id
+            })
+            await self.session.execute(insert_stmt)
+            await self.session.commit()
+
+            return DealAddToGroupResponse(ok=True, message="Сделка успешно добавлена в группу")
+        except Exception as e:
+            await self.session.rollback()
+            return DealAddToGroupResponse(ok=False, message=str(e))
+
+    async def remove_deal(self, request: DealRemoveFromGroupRequest) -> DealRemoveFromGroupResponse:
+        try:
+            delete_stmt = (
+                delete(deal_relations)
+                .where(
+                    deal_relations.c.deal_id == request.deal_id,
+                )
+            )
+            await self.session.execute(delete_stmt)
+            await self.session.commit()
+            return DealRemoveFromGroupResponse(ok=True, message="Сделка успешно удалена из группы")
+        except Exception as e:
+            await self.session.rollback()
+            return DealRemoveFromGroupResponse(ok=False, message=str(e))