feat: cards, attributes and modules

services/barcode.py

@@ -8,7 +8,7 @@ from barcodes.attributes import AttributeWriterFactory
 from barcodes.generator.default_generator import DefaultBarcodeGenerator
 from barcodes.images_uploader import BarcodeImagesUploader
 from models import BarcodeTemplate, BarcodeTemplateAttribute, barcode_template_attribute_link, Product, \
-    BarcodeTemplateAdditionalField, BarcodeTemplateSize, Deal, DealProduct
+    BarcodeTemplateAdditionalField, BarcodeTemplateSize, Card, CardProduct
 from schemas.barcode import *
 from services.base import BaseService
 
@@ -113,44 +113,44 @@ class BarcodeService(BaseService):
             )
         return filename, pdf_buffer
 
-    async def get_deal_barcodes_pdf(self, request: GetDealProductsBarcodesPdfRequest) -> Tuple[str, BytesIO]:
+    async def get_card_barcodes_pdf(self, request: GetCardProductsBarcodesPdfRequest) -> Tuple[str, BytesIO]:
         stmt = (
-            select(Deal)
+            select(Card)
             .options(
-                selectinload(Deal.products).joinedload(DealProduct.product).selectinload(Product.client),
-                selectinload(Deal.products).joinedload(DealProduct.product).joinedload(Product.barcodes),
+                selectinload(Card.products).joinedload(CardProduct.product).selectinload(Product.client),
+                selectinload(Card.products).joinedload(CardProduct.product).joinedload(Product.barcodes),
             )
-            .filter(Deal.id == request.deal_id)
+            .filter(Card.id == request.card_id)
         )
         query = await self.session.execute(stmt)
-        deal: Deal = query.scalar()
-        if not deal:
+        card: Card = query.scalar()
+        if not card:
             raise ValueError('Сделка не найдена')
 
         uploader = BarcodeImagesUploader()
         barcodes_data: List[Dict[str, str | Product | BarcodeTemplate | int]] = []
-        for deal_product in deal.products:
-            if deal_product.product.barcode_image:
+        for card_product in card.products:
+            if card_product.product.barcode_image:
                 barcodes_data.append({
-                    "barcode_image_url": uploader.get_abs_path(deal_product.product.barcode_image.filename),
-                    "num_duplicates": deal_product.quantity
+                    "barcode_image_url": uploader.get_abs_path(card_product.product.barcode_image.filename),
+                    "num_duplicates": card_product.quantity
                 })
             else:
                 product_request = GetProductBarcodeRequest(
-                    product_id=deal_product.product_id,
+                    product_id=card_product.product_id,
                     barcode="",
-                    barcode_template_id=deal_product.product.barcode_template_id,
+                    barcode_template_id=card_product.product.barcode_template_id,
                 )
-                barcode_template = await self._get_barcode_template(product_request, deal_product.product)
+                barcode_template = await self._get_barcode_template(product_request, card_product.product)
                 barcodes_data.append({
-                    "barcode": deal_product.product.barcodes[0].barcode,
-                    "product": deal_product.product,
+                    "barcode": card_product.product.barcodes[0].barcode,
+                    "product": card_product.product,
                     "template": barcode_template,
-                    "num_duplicates": deal_product.quantity
+                    "num_duplicates": card_product.quantity
                 })
 
         default_generator = DefaultBarcodeGenerator()
-        filename = f'{deal.id}_deal_barcodes.pdf'
+        filename = f'{card.id}_deal_barcodes.pdf'
         pdf_buffer = default_generator.generate(barcodes_data)
 
         return filename, pdf_buffer

services/billing.py

@@ -1,4 +1,3 @@
-import logging
 from io import BytesIO
 from typing import List
 from uuid import uuid4
@@ -16,24 +15,24 @@ from constants import MONTHS, ENV
 from external.billing import BillingClient, CreateBillingRequestValue, CreateBillRequestSchema, CreateBillRequestItems, \
     BillStatusUpdateRequest, NotificationChannel, NotifyReceivedBillRequestSchema, DeleteBillRequestSchema, \
     ProductBillingDocumentPdf, ServiceBillingDocumentPdf
-from models import DealBillRequest, Deal, DealProduct, DealService as DealServiceModel, DealProductService, DealGroup, \
+from models import CardBillRequest, Card, CardProduct, CardService as CardServiceModel, CardGroup, \
     GroupBillRequest
 from schemas.billing import *
 from services.base import BaseService
-from services.deal import DealService
+from services.card import CardsService
 from utils.list_utils import to_locale_number
 
 
 class BillingService(BaseService):
-    async def _process_deal_update_details(
+    async def _process_card_update_details(
             self,
             request: BillStatusUpdateRequest,
     ):
-        deal_bill_request = await self._get_deal_bill_by_id(request.listener_transaction_id)
-        if not deal_bill_request:
+        bill_request = await self._get_card_bill_by_id(request.listener_transaction_id)
+        if not bill_request:
             return
-        deal_bill_request.pdf_url = request.info.pdf_url
-        deal_bill_request.invoice_number = request.info.invoice_number
+        bill_request.pdf_url = request.info.pdf_url
+        bill_request.invoice_number = request.info.invoice_number
 
     async def _process_group_update_details(
             self,
@@ -63,19 +62,19 @@ class BillingService(BaseService):
         if not response.ok:
             return
         if type(request.listener_transaction_id) is int:
-            await self._process_deal_update_details(request)
+            await self._process_card_update_details(request)
         else:
             await self._process_group_update_details(request)
         await self.session.commit()
 
-    async def _process_deal_update_verification(
+    async def _process_card_update_verification(
             self,
             request: BillStatusUpdateRequest
     ):
-        deal_bill_request = await self._get_deal_bill_by_id(request.listener_transaction_id)
-        if not deal_bill_request:
+        card_bill_request = await self._get_card_bill_by_id(request.listener_transaction_id)
+        if not card_bill_request:
             return
-        deal_bill_request.paid = request.info.payed
+        card_bill_request.paid = request.info.payed
 
     async def _process_group_update_verification(
             self,
@@ -104,7 +103,7 @@ class BillingService(BaseService):
         if not response.ok:
             return
         if type(request.listener_transaction_id) is int:
-            await self._process_deal_update_verification(request)
+            await self._process_card_update_verification(request)
         else:
             await self._process_group_update_verification(request)
         await self.session.commit()
@@ -118,37 +117,37 @@ class BillingService(BaseService):
         elif request.channel == NotificationChannel.PAYMENT_VERIFICATION:
             await self._process_update_verification(request)
 
-    async def create_deal_bill_request(self, deal: Deal):
-        deal_bill_request = DealBillRequest(
-            deal_id=deal.id,
+    async def create_card_bill_request(self, card: Card):
+        card_bill_request = CardBillRequest(
+            card_id=card.id,
             created_at=datetime.datetime.now()
         )
-        self.session.add(deal_bill_request)
-        deal.is_locked = True
+        self.session.add(card_bill_request)
+        card.is_locked = True
         await self.session.commit()
 
-    async def create_group_bill_request(self, group: DealGroup):
+    async def create_group_bill_request(self, group: CardGroup):
         group_bill_request = GroupBillRequest(
             group_id=group.id,
             created_at=datetime.datetime.now()
         )
         self.session.add(group_bill_request)
-        for deal in group.deals:
-            deal.is_locked = True
+        for card in group.cards:
+            card.is_locked = True
         await self.session.commit()
 
-    async def create_deal_billing(self, user, request: CreateDealBillRequest) -> CreateDealBillResponse:
+    async def create_card_billing(self, user, request: CreateCardBillRequest) -> CreateCardBillResponse:
         try:
-            deal_service = DealService(self.session)
+            card_service = CardsService(self.session)
             billing_client = BillingClient(backend.config.BILLING_API_KEY)
 
-            basic_deal: Deal = await deal_service.get_by_id(user, request.deal_id, return_raw=True)
-            if basic_deal.group:
-                deals = await self._get_deals_by_group_id(basic_deal.group.id)
+            basic_card: Card = await card_service.get_by_id(user, request.card_id, return_raw=True)
+            if basic_card.group:
+                cards = await self._get_cards_by_group_id(basic_card.group.id)
             else:
-                deals = [basic_deal]
+                cards = [basic_card]
 
-            (services, products, is_size_needed) = await self._get_products_for_deal(deals)
+            (services, products, is_size_needed) = await self._get_products_for_card(cards)
             services: dict[str, ServiceBillingDocumentPdf]
             products: dict[str, ProductBillingDocumentPdf]
             is_size_needed: bool
@@ -163,72 +162,72 @@ class BillingService(BaseService):
                     )
                 )
 
-            deal = basic_deal
-            listener_transaction_id = deal.id
-            if deal.group:
-                listener_transaction_id = f"group-{basic_deal.group.id}"
-            inn: str = deal.client.details.inn
+            card = basic_card
+            listener_transaction_id = card.id
+            if card.group:
+                listener_transaction_id = f"group-{basic_card.group.id}"
+            inn: str = card.client.details.inn
             create_bill_request = CreateBillRequestSchema(
                 listener_transaction_id=listener_transaction_id,
-                payer_name=deal.client.name,
+                payer_name=card.client.name,
                 payer_inn=inn.strip(),
-                payer_phone=deal.client.details.phone_number,
+                payer_phone=card.client.details.phone_number,
                 items=CreateBillRequestItems(
                     values=billing_request_values
                 )
             )
             create_bill_response = await billing_client.create(create_bill_request)
             if not create_bill_response.ok:
-                return CreateDealBillResponse(ok=create_bill_response.ok, message='Ошибка!')
+                return CreateCardBillResponse(ok=create_bill_response.ok, message='Ошибка!')
 
-            if basic_deal.group:
-                await self.create_group_bill_request(basic_deal.group)
+            if basic_card.group:
+                await self.create_group_bill_request(basic_card.group)
             else:
-                await self.create_deal_bill_request(basic_deal)
+                await self.create_card_bill_request(basic_card)
 
-            return CreateDealBillResponse(ok=create_bill_response.ok, message='Заявка успешно создана!')
+            return CreateCardBillResponse(ok=create_bill_response.ok, message='Заявка успешно создана!')
         except Exception as e:
-            return CreateDealBillResponse(ok=False, message=str(e))
+            return CreateCardBillResponse(ok=False, message=str(e))
 
-    async def _get_deal_bill_by_id(self, deal_id: int) -> Optional[DealBillRequest]:
-        return await self.session.scalar(select(DealBillRequest).where(DealBillRequest.deal_id == deal_id))
+    async def _get_card_bill_by_id(self, card_id: int) -> Optional[CardBillRequest]:
+        return await self.session.scalar(select(CardBillRequest).where(CardBillRequest.card_id == card_id))
 
     async def _get_group_bill_by_id(self, group_id: int) -> Optional[GroupBillRequest]:
         return await self.session.scalar(select(GroupBillRequest).where(GroupBillRequest.group_id == group_id))
 
-    async def get_deal_bill_by_id(self, deal_id: int) -> GetDealBillById:
-        deal_bill = await self._get_deal_bill_by_id(deal_id)
-        if not deal_bill:
-            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail='Deal bill was not found')
-        return GetDealBillById(deal_bill=DealBillRequestSchema.model_validate(deal_bill))
+    async def get_card_bill_by_id(self, card_id: int) -> GetCardBillById:
+        bill = await self._get_card_bill_by_id(card_id)
+        if not bill:
+            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail='Card bill was not found')
+        return GetCardBillById(card_bill=CardBillRequestSchema.model_validate(bill))
 
-    async def cancel_deal_billing(self, user, request: CancelDealBillRequest) -> CancelDealBillResponse:
+    async def cancel_card_billing(self, user, request: CancelCardBillRequest) -> CancelCardBillResponse:
         try:
-            deal = await self._get_deal_by_id(request.deal_id)
-            if not deal:
-                return CancelDealBillResponse(ok=False, message='Сделка не найдена')
+            card = await self._get_card_by_id(request.card_id)
+            if not card:
+                return CancelCardBillResponse(ok=False, message='Сделка не найдена')
 
-            if deal.group:
-                bill = await self._get_group_bill_by_id(deal.group.id)
+            if card.group:
+                bill = await self._get_group_bill_by_id(card.group.id)
                 if not bill:
-                    return CancelDealBillResponse(ok=False, message='Заявка не найдена')
+                    return CancelCardBillResponse(ok=False, message='Заявка не найдена')
                 billing_client = BillingClient(backend.config.BILLING_API_KEY)
-                response = await billing_client.delete(DeleteBillRequestSchema(listener_transaction_id=deal.group.id))
+                response = await billing_client.delete(DeleteBillRequestSchema(listener_transaction_id=card.group.id))
             else:
-                bill = await self._get_deal_bill_by_id(request.deal_id)
+                bill = await self._get_card_bill_by_id(request.card_id)
                 if not bill:
-                    return CancelDealBillResponse(ok=False, message='Заявка не найдена')
+                    return CancelCardBillResponse(ok=False, message='Заявка не найдена')
                 billing_client = BillingClient(backend.config.BILLING_API_KEY)
-                response = await billing_client.delete(DeleteBillRequestSchema(listener_transaction_id=request.deal_id))
+                response = await billing_client.delete(DeleteBillRequestSchema(listener_transaction_id=request.card_id))
 
             if not response.ok:
-                return CancelDealBillResponse(ok=False, message='Ошибка')
+                return CancelCardBillResponse(ok=False, message='Ошибка')
 
             await self.session.delete(bill)
             await self.session.commit()
-            return CancelDealBillResponse(ok=True, message='Заявка успешно отозвана')
+            return CancelCardBillResponse(ok=True, message='Заявка успешно отозвана')
         except Exception as e:
-            return CancelDealBillResponse(ok=False, message=str(e))
+            return CancelCardBillResponse(ok=False, message=str(e))
 
     def _gen_key_for_service(self, service: ServiceBillingDocumentPdf) -> str:
         return f"{service.name}-{service.price}"
@@ -237,13 +236,13 @@ class BillingService(BaseService):
         article = product.article if product.article else uuid4()
         return f"{article}-{product.size}-{product.price}"
 
-    async def _get_products_for_deal(self, deals: list[Deal]) -> tuple[dict, dict, bool]:
+    async def _get_products_for_card(self, cards: list[Card]) -> tuple[dict, dict, bool]:
         services: dict[str, ServiceBillingDocumentPdf] = {}
         products: dict[str, ProductBillingDocumentPdf] = {}
         is_size_needed: bool = False
 
-        for deal in deals:
-            for product in deal.products:
+        for card in cards:
+            for product in card.products:
                 product_price = 0
                 for service in product.services:
                     service_data = ServiceBillingDocumentPdf(
@@ -269,7 +268,7 @@ class BillingService(BaseService):
                     products[product_key].quantity += product_data.quantity
                 else:
                     products[product_key] = product_data
-            for service in deal.services:
+            for service in card.services:
                 service_data = ServiceBillingDocumentPdf(
                     name=service.service.name,
                     price=service.price,
@@ -283,49 +282,49 @@ class BillingService(BaseService):
 
         return services, products, is_size_needed
 
-    async def _get_deal_by_id(self, deal_id: int) -> Optional[Deal]:
-        deal: Deal | None = await self.session.scalar(
-            select(Deal)
-            .where(Deal.id == deal_id)
+    async def _get_card_by_id(self, card_id: int) -> Optional[Card]:
+        card: Card | None = await self.session.scalar(
+            select(Card)
+            .where(Card.id == card_id)
             .options(
-                selectinload(Deal.products).selectinload(DealProduct.services),
-                selectinload(Deal.services).selectinload(DealServiceModel.service),
-                joinedload(Deal.shipping_warehouse),
-                joinedload(Deal.client),
-                selectinload(Deal.group).selectinload(DealGroup.deals),
+                selectinload(Card.products).selectinload(CardProduct.services),
+                selectinload(Card.services).selectinload(CardServiceModel.service),
+                joinedload(Card.shipping_warehouse),
+                joinedload(Card.client),
+                selectinload(Card.group).selectinload(CardGroup.cards),
             )
         )
-        return deal
+        return card
 
-    async def _get_deals_by_group_id(self, group_id: int) -> List[Deal]:
-        group: DealGroup | None = await self.session.scalar(
-            select(DealGroup)
-            .where(DealGroup.id == group_id)
+    async def _get_cards_by_group_id(self, group_id: int) -> List[Card]:
+        group: CardGroup | None = await self.session.scalar(
+            select(CardGroup)
+            .where(CardGroup.id == group_id)
             .options(
-                selectinload(DealGroup.deals).selectinload(Deal.products).selectinload(DealProduct.services),
-                selectinload(DealGroup.deals).selectinload(Deal.services).selectinload(DealServiceModel.service),
-                selectinload(DealGroup.deals).joinedload(Deal.shipping_warehouse),
-                selectinload(DealGroup.deals).joinedload(Deal.client),
-                selectinload(DealGroup.deals).selectinload(Deal.group).selectinload(DealGroup.deals),
+                selectinload(CardGroup.cards).selectinload(Card.products).selectinload(CardProduct.services),
+                selectinload(CardGroup.cards).selectinload(Card.services).selectinload(CardServiceModel.service),
+                selectinload(CardGroup.cards).joinedload(Card.shipping_warehouse),
+                selectinload(CardGroup.cards).joinedload(Card.client),
+                selectinload(CardGroup.cards).selectinload(Card.group).selectinload(CardGroup.cards),
             )
         )
-        return group.deals if group else []
+        return group.cards if group else []
 
-    async def _create_billing_document_html(self, deal_id: int):
-        deal = await self._get_deal_by_id(deal_id)
-        if not deal:
+    async def _create_billing_document_html(self, card_id: int):
+        card = await self._get_card_by_id(card_id)
+        if not card:
             return ""
 
-        if deal.group:
-            deals = await self._get_deals_by_group_id(deal.group.id)
+        if card.group:
+            cards = await self._get_cards_by_group_id(card.group.id)
         else:
-            deals = [deal]
+            cards = [card]
 
-        (services, products, is_size_needed) = await self._get_products_for_deal(deals)
+        (services, products, is_size_needed) = await self._get_products_for_card(cards)
 
-        deal_price = sum((service.price * service.quantity for service in services.values()))
-        deal_price_words = get_string_by_number(deal_price)[0:-10]
-        deal_price = to_locale_number(deal_price)
+        price = sum((service.price * service.quantity for service in services.values()))
+        price_words = get_string_by_number(price)[0:-10]
+        price = to_locale_number(price)
         template = ENV.get_template("bill-of-payment.html")
 
         now = datetime.datetime.now()
@@ -334,14 +333,14 @@ class BillingService(BaseService):
             "products": products,
             "services": services,
             "is_size_needed": is_size_needed,
-            "deal_price": deal_price,
-            "deal_price_words": deal_price_words,
-            "deal": deal,
+            "deal_price": price,
+            "deal_price_words": price_words,
+            "deal": card,
             "curr_date": curr_date
         })
 
-    async def create_billing_document_pdf(self, deal_id) -> BytesIO:
-        doc = await self._create_billing_document_html(deal_id)
+    async def create_billing_document_pdf(self, card_id) -> BytesIO:
+        doc = await self._create_billing_document_html(card_id)
         pdf_file = BytesIO()
         HTML(string=doc).write_pdf(pdf_file, stylesheets=[CSS(constants.APP_PATH + '/static/css/bill-of-payment.css')])
 

services/board.py

@@ -3,7 +3,7 @@ from typing import Optional
 
 from sqlalchemy import select, and_, func
 
-from models import Board, Deal
+from models import Board, Card
 from schemas.board import *
 from services.base import BaseService
 
@@ -76,12 +76,12 @@ class BoardService(BaseService):
 
     async def _count_deals_in_progress(self, board_id: int) -> int:
         stmt = (
-            select(func.count(Deal.id))
+            select(func.count(Card.id))
             .where(
                 and_(
-                    Deal.board_id == board_id,
-                    Deal.is_deleted == False,
-                    Deal.is_completed == False,
+                    Card.board_id == board_id,
+                    Card.is_deleted == False,
+                    Card.is_completed == False,
                 )
             )
         )
@@ -89,8 +89,8 @@ class BoardService(BaseService):
 
     async def _count_deals(self, board_id: int) -> int:
         stmt = (
-            select(func.count(Deal.id))
-            .where(Deal.board_id == board_id)
+            select(func.count(Card.id))
+            .where(Card.board_id == board_id)
         )
         return (await self.session.scalars(stmt)).first()
 
@@ -111,7 +111,7 @@ class BoardService(BaseService):
             await self.session.delete(board)
         else:
             board.is_deleted = True
-            for status in board.deal_statuses:
+            for status in board.statuses:
                 status.is_deleted = True
 
         await self.session.commit()

services/card_group.py

@@ -0,0 +1,168 @@
+from lexorank import lexorank
+from sqlalchemy import select, insert, update, delete
+from sqlalchemy.orm import selectinload
+
+from models import CardService as DealServiceModel, User, Card, CardProduct, Product, GroupBillRequest
+from models.card_group import CardGroup, card_relations
+from schemas.group import *
+from services.base import BaseService
+from services.card import CardsService
+
+
+class CardGroupService(BaseService):
+    async def get_cards_by_group_id(self, group_id) -> list[Card]:
+        group: CardGroup | None = await self.session.scalar(
+            select(CardGroup)
+            .where(CardGroup.id == group_id)
+            .options(
+                selectinload(CardGroup.cards).selectinload(Card.products).selectinload(CardProduct.services),
+                selectinload(CardGroup.cards).selectinload(Card.products)
+                .selectinload(CardProduct.product).selectinload(Product.barcodes),
+                selectinload(CardGroup.cards).selectinload(Card.services).selectinload(DealServiceModel.service),
+                selectinload(CardGroup.cards).selectinload(Card.status_history),
+                selectinload(CardGroup.cards).selectinload(Card.group).selectinload(CardGroup.cards),
+                selectinload(CardGroup.cards).joinedload(Card.client),
+                selectinload(CardGroup.cards).joinedload(Card.shipping_warehouse),
+            )
+        )
+        return group.cards if group else []
+
+    async def create_group_model(self) -> CardGroup:
+        group = CardGroup(
+            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: CreateCardGroupRequest) -> CardCreateGroupResponse:
+        try:
+            group = await self.create_group_model()
+
+            for card_id in [request.dragging_card_id, request.hovered_card_id]:
+                insert_stmt = insert(card_relations).values({
+                    'card_id': card_id,
+                    'group_id': group.id
+                })
+                await self.session.execute(insert_stmt)
+            # changing status if needed on draggable card
+            dragging_card = await self.session.scalar(
+                select(Card).where(Card.id == request.dragging_card_id)
+            )
+            dropped_card = await self.session.scalar(
+                select(Card).where(Card.id == request.hovered_card_id)
+            )
+            if dragging_card.current_status_id != dropped_card.current_status_id:
+                card_service = CardsService(self.session)
+                await card_service.change_status(dragging_card, dropped_card.current_status_id, user)
+            await self.session.commit()
+            return CardCreateGroupResponse(ok=True, message="Группа успешно создана")
+        except Exception as e:
+            return CardCreateGroupResponse(ok=False, message=str(e))
+
+    async def update_group(self, request: CardGroupUpdateRequest) -> CardGroupUpdateResponse:
+        try:
+            group = await self.session.scalar(
+                select(CardGroup).where(CardGroup.id == request.data.id)
+            )
+            if not group:
+                return CardGroupUpdateResponse(ok=False, message="Группа не найдена")
+            # update by dictionary
+            request_dict = request.data.model_dump()
+            request_dict.pop("bill_request", None)
+
+            update_stmt = (
+                update(CardGroup)
+                .where(CardGroup.id == request.data.id)
+                .values(**request_dict)
+            )
+            await self.session.execute(update_stmt)
+            await self.session.commit()
+            return CardGroupUpdateResponse(ok=True, message="Группа успешно обновлена")
+        except Exception as e:
+            await self.session.rollback()
+            return CardGroupUpdateResponse(ok=False, message=str(e))
+
+    async def complete_group(self, group_id: int) -> list[Card]:
+        cards = await self.get_cards_by_group_id(group_id)
+        for card in cards:
+            card.is_completed = True
+        return cards
+
+    async def delete_group(self, group_id: int) -> None:
+        cards = await self.get_cards_by_group_id(group_id)
+        for card in cards:
+            card.is_deleted = True
+        await self.session.commit()
+
+    async def change_group_status(
+            self,
+            user: User,
+            request: CardGroupChangeStatusRequest,
+    ) -> CardGroupChangeStatusResponse:
+        try:
+            # getting all cards in group
+            cards = await self.session.scalars(
+                select(card_relations.c.card_id)
+                .where(card_relations.c.group_id == request.group_id)
+            )
+
+            card_service = CardsService(self.session)
+            for card_id in cards:
+                card = await self.session.scalar(
+                    select(Card).where(Card.id == card_id)
+                )
+                await card_service.change_status(card, request.new_status, user)
+            await self.session.commit()
+            return CardGroupChangeStatusResponse(ok=True, message="Статус группы успешно изменен")
+        except Exception as e:
+            await self.session.rollback()
+            return CardGroupChangeStatusResponse(ok=False, message=str(e))
+
+    async def add_card(self, user: User, request: CardAddToGroupRequest) -> CardAddToGroupResponse:
+        try:
+            group_bill_request = await self.session.get(GroupBillRequest, request.group_id)
+            if group_bill_request:
+                raise Exception("Нельзя добавить сделку, так как на группу выставлен счёт.")
+
+            # changing status if needed
+            card_id = await self.session.scalar(
+                select(card_relations.c.card_id)
+                .where(card_relations.c.group_id == request.group_id)
+            )
+            group_card_status = await self.session.scalar(
+                select(Card.current_status_id)
+                .where(Card.id == card_id)
+            )
+            request_card = await self.session.scalar(
+                select(Card).where(Card.id == request.card_id)
+            )
+            if group_card_status != request_card.current_status_id:
+                await CardsService(self.session).change_status(request_card, group_card_status, user)
+            insert_stmt = insert(card_relations).values({
+                'card_id': request.card_id,
+                'group_id': request.group_id
+            })
+            await self.session.execute(insert_stmt)
+            await self.session.commit()
+
+            return CardAddToGroupResponse(ok=True, message="Сделка успешно добавлена в группу")
+        except Exception as e:
+            await self.session.rollback()
+            return CardAddToGroupResponse(ok=False, message=str(e))
+
+    async def remove_card(self, request: CardRemoveFromGroupRequest) -> CardRemoveFromGroupResponse:
+        try:
+            delete_stmt = (
+                delete(card_relations)
+                .where(
+                    card_relations.c.card_id == request.card_id,
+                )
+            )
+            await self.session.execute(delete_stmt)
+            await self.session.commit()
+            return CardRemoveFromGroupResponse(ok=True, message="Сделка успешно удалена из группы")
+        except Exception as e:
+            await self.session.rollback()
+            return CardRemoveFromGroupResponse(ok=False, message=str(e))

services/deal_group.py

@@ -1,168 +0,0 @@
-from lexorank import lexorank
-from sqlalchemy import select, insert, update, delete
-from sqlalchemy.orm import selectinload
-
-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):
-    async def get_deals_by_group_id(self, group_id) -> list[Deal]:
-        group: DealGroup | None = await self.session.scalar(
-            select(DealGroup)
-            .where(DealGroup.id == group_id)
-            .options(
-                selectinload(DealGroup.deals).selectinload(Deal.products).selectinload(DealProduct.services),
-                selectinload(DealGroup.deals).selectinload(Deal.products)
-                .selectinload(DealProduct.product).selectinload(Product.barcodes),
-                selectinload(DealGroup.deals).selectinload(Deal.services).selectinload(DealServiceModel.service),
-                selectinload(DealGroup.deals).selectinload(Deal.status_history),
-                selectinload(DealGroup.deals).selectinload(Deal.group).selectinload(DealGroup.deals),
-                selectinload(DealGroup.deals).joinedload(Deal.client),
-                selectinload(DealGroup.deals).joinedload(Deal.shipping_warehouse),
-            )
-        )
-        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:
-            deal.is_completed = True
-        return deals
-
-    async def delete_group(self, group_id: int) -> None:
-        deals = await self.get_deals_by_group_id(group_id)
-        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))

services/project.py

@@ -1,6 +1,7 @@
 from datetime import datetime
 
-from sqlalchemy import select, update, func, delete, and_
+from sqlalchemy import select, update, func, delete
+from sqlalchemy.orm import selectinload
 
 from models import Project, Board
 from schemas.project import *
@@ -9,28 +10,37 @@ from services.base import BaseService
 
 class ProjectService(BaseService):
     async def get_projects(self) -> GetProjectsResponse:
-        boards_sub = (
-            select(Board)
-            .where(Board.is_deleted == False)
+        board_count_sub = (
+            select(
+                Board.project_id,
+                func.count(Board.id).label('boards_count'),
+            )
+            .group_by(Board.project_id)
             .subquery()
         )
         stmt = (
             select(
-                Project.id,
-                Project.name,
-                func.count(boards_sub.c.id)
+                Project,
+                func.coalesce(board_count_sub.c.boards_count, 0),
+            )
+            .outerjoin(board_count_sub, Project.id == board_count_sub.c.project_id)
+            .options(
+                selectinload(Project.attributes),
+                selectinload(Project.modules),
             )
-            .join(boards_sub, Project.id == boards_sub.c.project_id, isouter=True)
-            .where(Project.is_deleted == False)
-            .group_by(Project.id, Project.name)
-            .order_by(Project.name)
         )
         project_data = (await self.session.execute(stmt)).all()
 
         projects = []
-        for project_id, name, boards_count in project_data:
-            project = ProjectSchemaWithCount(id=project_id, name=name, boards_count=boards_count)
-            projects.append(project)
+        for project, boards_count in project_data:
+            project_schema = FullProjectSchema(
+                id=project.id,
+                name=project.name,
+                boards_count=boards_count,
+                attributes=project.attributes,
+                modules=project.modules,
+            )
+            projects.append(project_schema)
 
         return GetProjectsResponse(projects=projects)
 

services/service.py

@@ -192,8 +192,8 @@ class ServiceService(BaseService):
             category_dict = raw_category.model_dump()
             del category_dict['id']
             last_deal_service_rank = await self.session.scalar(
-                select(ServiceCategory.deal_service_rank)
-                .order_by(ServiceCategory.deal_service_rank.desc())
+                select(ServiceCategory.card_service_rank)
+                .order_by(ServiceCategory.card_service_rank.desc())
                 .limit(1)
             )
             last_product_service_rank = await self.session.scalar(
@@ -338,7 +338,7 @@ class ServiceService(BaseService):
             if not request.move_down and not request.move_up:
                 return ServiceCategoryReorderResponse(ok=False, message="Не указано действие")
             if request.service_type == ServiceType.DEAL_SERVICE:
-                order_by = ServiceCategory.deal_service_rank
+                order_by = ServiceCategory.card_service_rank
                 rank_field = 'deal_service_rank'
             else:
                 order_by = ServiceCategory.product_service_rank

services/shipping.py

@@ -1,18 +1,18 @@
 from sqlalchemy import select, and_
 
-from models import Deal, Pallet, Box
+from models import Card, Pallet, Box
 from models.shipping import ShippingProduct
 from schemas.shipping import *
 from services.base import BaseService
 
 
 class ShippingService(BaseService):
-    async def create_pallet(self, deal_id: int) -> CreatePalletResponse:
-        deal = await self.session.get(Deal, deal_id)
+    async def create_pallet(self, card_id: int) -> CreatePalletResponse:
+        deal = await self.session.get(Card, card_id)
         if not deal:
             return CreatePalletResponse(ok=False, message="Сделка не найдена")
 
-        pallet = Pallet(deal_id=deal_id)
+        pallet = Pallet(card_id=card_id)
         self.session.add(pallet)
         await self.session.commit()
         return CreatePalletResponse(ok=True, message="Паллет успешно создан")
@@ -36,19 +36,19 @@ class ShippingService(BaseService):
         await self.session.commit()
         return True, "Короб обновлен"
 
-    async def _create_box(self, data: CreateBoxInDealSchema | CreateBoxInPalletSchema):
+    async def _create_box(self, data: CreateBoxInCardSchema | CreateBoxInPalletSchema):
         box = Box(**data.model_dump())
         self.session.add(box)
         await self.session.commit()
 
-    async def _create_box_in_deal(self, data: CreateBoxInDealSchema) -> tuple[bool, str]:
-        deal = await self.session.get(Deal, data.deal_id)
-        if not deal:
-            return False, f"Сделка с ID:{data.deal_id} не найдена"
+    async def _create_box_in_card(self, data: CreateBoxInCardSchema) -> tuple[bool, str]:
+        card = await self.session.get(Card, data.card_id)
+        if not card:
+            return False, f"Сделка с ID:{data.card_id} не найдена"
 
         await self._create_box(data)
 
-        return True, f"Короб для сделки ID:{data.deal_id} добавлен"
+        return True, f"Короб для сделки ID:{data.card_id} добавлен"
 
     async def _create_box_in_pallet(self, data: CreateBoxInPalletSchema) -> tuple[bool, str]:
         pallet = await self.session.get(Pallet, data.pallet_id)
@@ -66,7 +66,7 @@ class ShippingService(BaseService):
         elif "pallet_id" in data_keys:
             ok, message = await self._create_box_in_pallet(CreateBoxInPalletSchema.model_validate(request.data))
         else:
-            ok, message = await self._create_box_in_deal(CreateBoxInDealSchema.model_validate(request.data))
+            ok, message = await self._create_box_in_card(CreateBoxInCardSchema.model_validate(request.data))
 
         return UpdateBoxResponse(ok=ok, message=message)
 

services/statistics/profit_statistics.py

@@ -4,7 +4,7 @@ from fastapi import HTTPException
 from sqlalchemy import select, and_, union_all, func, Subquery, literal
 
 from enums.profit_table_group_by import ProfitTableGroupBy
-from models import DealService, Deal, DealStatusHistory, DealProductService, DealProduct, Service, Client, \
+from models import CardService, Card, CardStatusHistory, CardProductService, CardProduct, Service, Client, \
     ShippingWarehouse, BaseMarketplace, User, Project, Board
 from schemas.statistics import GetProfitChartDataResponse, GetProfitChartDataRequest, ProfitChartDataItem, \
     GetProfitTableDataResponse, GetProfitTableDataRequest, ProfitTableDataItem, CommonProfitFilters
@@ -19,12 +19,12 @@ class ProfitStatisticsService(BaseService):
     def _get_sub_deals_created_at(date_from: datetime.date, date_to: datetime.date):
         deals_created_at = (
             select(
-                Deal.id.label('deal_id'),
+                Card.id.label('deal_id'),
                 func.date_trunc(
                     'day',
-                    Deal.created_at,
+                    Card.created_at,
                 ).label('date'),
-                Deal.current_status_id,
+                Card.current_status_id,
             )
             .subquery()
         )
@@ -38,22 +38,22 @@ class ProfitStatisticsService(BaseService):
     def _get_sub_status_history():
         last_statuses = (
             select(
-                DealStatusHistory.deal_id,
-                func.max(DealStatusHistory.changed_at).label('changed_at')
+                CardStatusHistory.card_id,
+                func.max(CardStatusHistory.changed_at).label('changed_at')
             )
-            .group_by(DealStatusHistory.deal_id)
+            .group_by(CardStatusHistory.card_id)
             .subquery()
         )
         return (
             select(
-                Deal.id.label('deal_id'),
+                Card.id.label('deal_id'),
                 func.date_trunc(
                     'day',
                     last_statuses.c.changed_at,
                 ).label('date'),
-                Deal.current_status_id,
+                Card.current_status_id,
             )
-            .join(last_statuses, last_statuses.c.deal_id == Deal.id)
+            .join(last_statuses, last_statuses.c.deal_id == Card.id)
             .subquery()
         )
 
@@ -80,7 +80,7 @@ class ProfitStatisticsService(BaseService):
             if is_chart:
                 data_item = ProfitChartDataItem(
                     date=row.date.date(),
-                    deals_count=row.deals_count,
+                    deals_count=row.cards_count,
                     profit=row.profit,
                     revenue=row.revenue,
                     expenses=row.expenses,
@@ -88,7 +88,7 @@ class ProfitStatisticsService(BaseService):
             else:
                 data_item = ProfitTableDataItem(
                     grouped_value=row.date.date(),
-                    deals_count=row.deals_count,
+                    deals_count=row.cards_count,
                     profit=row.profit,
                     revenue=row.revenue,
                     expenses=row.expenses,
@@ -100,25 +100,25 @@ class ProfitStatisticsService(BaseService):
     def _get_stmt_deal_services(self, sub_filtered_status_history: Subquery):
         return (
             select(
-                Deal.id.label("deal_id"),
+                Card.id.label("deal_id"),
                 func.date_trunc(
                     "day",
                     sub_filtered_status_history.c.date,
                 ).label("date"),
-                func.sum(DealService.price * DealService.quantity).label("revenue"),
-                func.sum(DealService.price * DealService.quantity).label("profit"),
+                func.sum(CardService.price * CardService.quantity).label("revenue"),
+                func.sum(CardService.price * CardService.quantity).label("profit"),
             )
-            .join(DealService, Deal.id == DealService.deal_id)
-            .join(Service, DealService.service_id == Service.id)
-            .join(sub_filtered_status_history, Deal.id == sub_filtered_status_history.c.deal_id)
+            .join(CardService, Card.id == CardService.card_id)
+            .join(Service, CardService.service_id == Service.id)
+            .join(sub_filtered_status_history, Card.id == sub_filtered_status_history.c.deal_id)
             .where(
                 and_(
-                    Deal.is_deleted == False,
-                    Deal.is_accounted == True,
-                    Deal.is_completed == True if self.is_completed_only else True
+                    Card.is_deleted == False,
+                    Card.is_accounted == True,
+                    Card.is_completed == True if self.is_completed_only else True
                 )
             )
-            .group_by(Deal.id, "date")
+            .group_by(Card.id, "date")
         )
 
     @staticmethod
@@ -127,18 +127,18 @@ class ProfitStatisticsService(BaseService):
             select(Board.id)
             .where(Board.project_id == project_id)
         )
-        return stmt.where(Deal.board_id.in_(board_ids_stmt))
+        return stmt.where(Card.board_id.in_(board_ids_stmt))
 
     @staticmethod
     def _apply_filters(request: CommonProfitFilters, stmt_deal_services, stmt_deal_product_services):
         if request.client_id != -1:
-            stmt_deal_services = stmt_deal_services.where(Deal.client_id == request.client_id)
-            stmt_deal_product_services = stmt_deal_product_services.where(Deal.client_id == request.client_id)
+            stmt_deal_services = stmt_deal_services.where(Card.client_id == request.client_id)
+            stmt_deal_product_services = stmt_deal_product_services.where(Card.client_id == request.client_id)
 
         if request.base_marketplace_key != "all":
-            stmt_deal_services = stmt_deal_services.where(Deal.base_marketplace_key == request.base_marketplace_key)
+            stmt_deal_services = stmt_deal_services.where(Card.base_marketplace_key == request.base_marketplace_key)
             stmt_deal_product_services = stmt_deal_product_services.where(
-                Deal.base_marketplace_key == request.base_marketplace_key)
+                Card.base_marketplace_key == request.base_marketplace_key)
 
         if request.project_id != -1:
             stmt_deal_services = ProfitStatisticsService._board_ids_for_project(request.project_id, stmt_deal_services)
@@ -148,44 +148,44 @@ class ProfitStatisticsService(BaseService):
             )
 
             if request.board_id != -1:
-                stmt_deal_services = stmt_deal_services.where(Deal.board_id == request.board_id)
-                stmt_deal_product_services = stmt_deal_product_services.where(Deal.board_id == request.board_id)
+                stmt_deal_services = stmt_deal_services.where(Card.board_id == request.board_id)
+                stmt_deal_product_services = stmt_deal_product_services.where(Card.board_id == request.board_id)
 
-                if request.deal_status_id != -1:
-                    stmt_deal_services = stmt_deal_services.where(Deal.current_status_id == request.deal_status_id)
+                if request.card_status_id != -1:
+                    stmt_deal_services = stmt_deal_services.where(Card.current_status_id == request.card_status_id)
                     stmt_deal_product_services = stmt_deal_product_services.where(
-                        Deal.current_status_id == request.deal_status_id)
+                        Card.current_status_id == request.card_status_id)
 
         if request.manager_id != -1:
-            stmt_deal_services = stmt_deal_services.where(Deal.manager_id == request.manager_id)
-            stmt_deal_product_services = stmt_deal_product_services.where(Deal.manager_id == request.manager_id)
+            stmt_deal_services = stmt_deal_services.where(Card.manager_id == request.manager_id)
+            stmt_deal_product_services = stmt_deal_product_services.where(Card.manager_id == request.manager_id)
 
         return stmt_deal_services, stmt_deal_product_services
 
     def _get_stmt_product_services(self):
         return (
             select(
-                Deal.id.label("deal_id"),
-                func.sum(DealProductService.price * DealProduct.quantity).label("revenue"),
-                func.sum(DealProductService.price * DealProduct.quantity).label("profit"),
+                Card.id.label("deal_id"),
+                func.sum(CardProductService.price * CardProduct.quantity).label("revenue"),
+                func.sum(CardProductService.price * CardProduct.quantity).label("profit"),
             )
-            .join(DealProduct, Deal.id == DealProduct.deal_id)
+            .join(CardProduct, Card.id == CardProduct.card_id)
             .join(
-                DealProductService,
+                CardProductService,
                 and_(
-                    DealProductService.deal_id == Deal.id,
-                    DealProductService.product_id == DealProduct.product_id,
+                    CardProductService.card_id == Card.id,
+                    CardProductService.product_id == CardProduct.product_id,
                 )
             )
-            .join(Service, DealProductService.service_id == Service.id)
+            .join(Service, CardProductService.service_id == Service.id)
             .where(
                 and_(
-                    Deal.is_deleted == False,
-                    Deal.is_accounted == True,
-                    Deal.is_completed == True if self.is_completed_only else True,
+                    Card.is_deleted == False,
+                    Card.is_accounted == True,
+                    Card.is_completed == True if self.is_completed_only else True,
                 )
             )
-            .group_by(Deal.id)
+            .group_by(Card.id)
         )
 
     @staticmethod
@@ -208,7 +208,7 @@ class ProfitStatisticsService(BaseService):
         deals = (
             select(
                 stmt.c.date,
-                func.count(stmt.c.deal_id).label("deals_count"),
+                func.count(stmt.c.card_id).label("deals_count"),
                 func.sum(stmt.c.revenue).label("revenue"),
                 func.sum(stmt.c.profit).label("profit"),
             )
@@ -246,12 +246,12 @@ class ProfitStatisticsService(BaseService):
             select(
                 Client.id,
                 Client.name.label("grouped_value"),
-                func.count(stmt.c.deal_id).label("deals_count"),
+                func.count(stmt.c.card_id).label("deals_count"),
                 func.sum(stmt.c.revenue).label("revenue"),
                 func.sum(stmt.c.profit).label("profit"),
             )
-            .join(Deal, Deal.id == stmt.c.deal_id)
-            .join(Client, Client.id == Deal.client_id)
+            .join(Card, Card.id == stmt.c.card_id)
+            .join(Client, Client.id == Card.client_id)
             .group_by(Client.id, Client.name)
         )
 
@@ -261,12 +261,12 @@ class ProfitStatisticsService(BaseService):
             select(
                 Project.id,
                 Project.name.label("grouped_value"),
-                func.count(stmt.c.deal_id).label("deals_count"),
+                func.count(stmt.c.card_id).label("deals_count"),
                 func.sum(stmt.c.revenue).label("revenue"),
                 func.sum(stmt.c.profit).label("profit"),
             )
-            .join(Deal, Deal.id == stmt.c.deal_id)
-            .join(Board, Board.id == Deal.board_id)
+            .join(Card, Card.id == stmt.c.card_id)
+            .join(Board, Board.id == Card.board_id)
             .join(Project, Project.id == Board.project_id)
             .group_by(Project.id, Project.name)
         )
@@ -277,12 +277,12 @@ class ProfitStatisticsService(BaseService):
             select(
                 Board.id,
                 Board.name.label("grouped_value"),
-                func.count(stmt.c.deal_id).label("deals_count"),
+                func.count(stmt.c.card_id).label("deals_count"),
                 func.sum(stmt.c.revenue).label("revenue"),
                 func.sum(stmt.c.profit).label("profit"),
             )
-            .join(Deal, Deal.id == stmt.c.deal_id)
-            .join(Board, Board.id == Deal.board_id)
+            .join(Card, Card.id == stmt.c.card_id)
+            .join(Board, Board.id == Card.board_id)
             .group_by(Board.id, Board.name)
         )
 
@@ -290,13 +290,13 @@ class ProfitStatisticsService(BaseService):
     def _join_and_group_by_statuses(stmt):
         return (
             select(
-                Deal.current_status_id.label("grouped_value"),
-                func.count(stmt.c.deal_id).label("deals_count"),
+                Card.current_status_id.label("grouped_value"),
+                func.count(stmt.c.card_id).label("deals_count"),
                 func.sum(stmt.c.revenue).label("revenue"),
                 func.sum(stmt.c.profit).label("profit"),
             )
-            .join(Deal, Deal.id == stmt.c.deal_id)
-            .group_by(Deal.current_status_id)
+            .join(Card, Card.id == stmt.c.card_id)
+            .group_by(Card.current_status_id)
         )
 
     @staticmethod
@@ -306,12 +306,12 @@ class ProfitStatisticsService(BaseService):
                 ShippingWarehouse.id,
                 ShippingWarehouse.name.label("grouped_value"),
                 ShippingWarehouse.is_deleted,
-                func.count(stmt.c.deal_id).label("deals_count"),
+                func.count(stmt.c.card_id).label("deals_count"),
                 func.sum(stmt.c.revenue).label("revenue"),
                 func.sum(stmt.c.profit).label("profit"),
             )
-            .join(Deal, Deal.id == stmt.c.deal_id)
-            .join(ShippingWarehouse, Deal.shipping_warehouse_id == ShippingWarehouse.id)
+            .join(Card, Card.id == stmt.c.card_id)
+            .join(ShippingWarehouse, Card.shipping_warehouse_id == ShippingWarehouse.id)
             .where(ShippingWarehouse.is_deleted == False)
             .group_by(ShippingWarehouse.is_deleted, ShippingWarehouse.id, ShippingWarehouse.name)
         )
@@ -321,12 +321,12 @@ class ProfitStatisticsService(BaseService):
         return (
             select(
                 BaseMarketplace.name.label("grouped_value"),
-                func.count(stmt.c.deal_id).label("deals_count"),
+                func.count(stmt.c.card_id).label("deals_count"),
                 func.sum(stmt.c.revenue).label("revenue"),
                 func.sum(stmt.c.profit).label("profit"),
             )
-            .join(Deal, Deal.id == stmt.c.deal_id)
-            .join(BaseMarketplace, Deal.base_marketplace_key == BaseMarketplace.key)
+            .join(Card, Card.id == stmt.c.card_id)
+            .join(BaseMarketplace, Card.base_marketplace_key == BaseMarketplace.key)
             .group_by(BaseMarketplace.name)
         )
 
@@ -341,12 +341,12 @@ class ProfitStatisticsService(BaseService):
             select(
                 managers.c.id,
                 (managers.c.first_name + " " + managers.c.second_name).label("grouped_value"),
-                func.count(stmt.c.deal_id).label("deals_count"),
+                func.count(stmt.c.card_id).label("deals_count"),
                 func.sum(stmt.c.revenue).label("revenue"),
                 func.sum(stmt.c.profit).label("profit"),
             )
-            .join(Deal, Deal.id == stmt.c.deal_id)
-            .join(managers, managers.c.id == Deal.manager_id)
+            .join(Card, Card.id == stmt.c.card_id)
+            .join(managers, managers.c.id == Card.manager_id)
             .group_by(managers.c.id, "grouped_value")
         )
 
@@ -384,7 +384,7 @@ class ProfitStatisticsService(BaseService):
         self.is_completed_only = request.is_completed_only
         self.filters = request
 
-        sub_deals_dates = self._get_deals_dates(request.deal_status_id)
+        sub_deals_dates = self._get_deals_dates(request.card_status_id)
 
         stmt_deal_services = self._get_stmt_deal_services(sub_deals_dates)
         stmt_deal_product_services = self._get_stmt_product_services()
@@ -425,7 +425,7 @@ class ProfitStatisticsService(BaseService):
         self.date_from, self.date_to = request.date_range
         self.filters = request
 
-        sub_deals_dates = self._get_deals_dates(request.deal_status_id)
+        sub_deals_dates = self._get_deals_dates(request.card_status_id)
 
         stmt_deal_services = self._get_stmt_deal_services(sub_deals_dates)
 
@@ -436,12 +436,12 @@ class ProfitStatisticsService(BaseService):
                 stmt_deal_product_services.c.deal_id,
                 func.date_trunc(
                     "day",
-                    Deal.created_at
+                    Card.created_at
                 ).label("date"),
                 stmt_deal_product_services.c.revenue.label("revenue"),
                 stmt_deal_product_services.c.profit.label("profit"),
             )
-            .join(Deal, Deal.id == stmt_deal_product_services.c.deal_id)
+            .join(Card, Card.id == stmt_deal_product_services.c.deal_id)
         )
 
         stmt_deal_services, stmt_deal_product_services = self._apply_filters(

services/status.py

@@ -2,30 +2,30 @@ from typing import Optional
 
 from sqlalchemy import select, and_, func
 
-from models import DealStatus, Deal
+from models import CardStatus, Card
 from schemas.status import *
 from services.base import BaseService
 
 
 class StatusService(BaseService):
-    async def _get_statuses_for_board(self, board_id: int) -> list[DealStatus]:
+    async def _get_statuses_for_board(self, board_id: int) -> list[CardStatus]:
         stmt = (
-            select(DealStatus)
+            select(CardStatus)
             .where(
                 and_(
-                    DealStatus.board_id == board_id,
-                    DealStatus.is_deleted == False,
+                    CardStatus.board_id == board_id,
+                    CardStatus.is_deleted == False,
                 )
             )
-            .order_by(DealStatus.ordinal_number)
+            .order_by(CardStatus.ordinal_number)
         )
         statuses = (await self.session.scalars(stmt)).all()
         return list(statuses)
 
-    async def _get_status_by_id(self, status_id: int) -> Optional[DealStatus]:
+    async def _get_status_by_id(self, status_id: int) -> Optional[CardStatus]:
         stmt = (
-            select(DealStatus)
-            .where(DealStatus.id == status_id)
+            select(CardStatus)
+            .where(CardStatus.id == status_id)
         )
         status = await self.session.scalar(stmt)
         return status
@@ -38,7 +38,7 @@ class StatusService(BaseService):
             statuses[-1].is_finishing = False
             ordinal_number = statuses[-1].ordinal_number + 1
 
-        status = DealStatus(
+        status = CardStatus(
             **request.status.model_dump(),
             ordinal_number=ordinal_number,
             is_finishing=True,
@@ -81,12 +81,12 @@ class StatusService(BaseService):
 
     async def _count_deals_in_progress(self, status_id: int) -> int:
         stmt = (
-            select(func.count(Deal.id))
+            select(func.count(Card.id))
             .where(
                 and_(
-                    Deal.current_status_id == status_id,
-                    Deal.is_deleted == False,
-                    Deal.is_completed == False,
+                    Card.current_status_id == status_id,
+                    Card.is_deleted == False,
+                    Card.is_completed == False,
                 )
             )
         )
@@ -94,12 +94,12 @@ class StatusService(BaseService):
 
     async def _count_deals(self, status_id: int) -> int:
         stmt = (
-            select(func.count(Deal.id))
-            .where(Deal.current_status_id == status_id)
+            select(func.count(Card.id))
+            .where(Card.current_status_id == status_id)
         )
         return (await self.session.scalars(stmt)).first()
 
-    async def _set_finishing_flag_to_prev_status(self, status: DealStatus):
+    async def _set_finishing_flag_to_prev_status(self, status: CardStatus):
         statuses = await self._get_statuses_for_board(status.board_id)
         if len(statuses) < 2:
             return