Merge remote-tracking branch 'origin/cards'

services/attribute.py

@@ -0,0 +1,85 @@
+from sqlalchemy import select, and_
+
+from models import Attribute, AttributeType
+from schemas.attribute import *
+from services.base import BaseService
+
+
+class AttributeService(BaseService):
+    async def get_all(self) -> GetAttributesResponse:
+        stmt = (
+            select(Attribute)
+            .where(Attribute.is_deleted == False)
+            .order_by(Attribute.label)
+        )
+        attrs = (await self.session.scalars(stmt)).all()
+        return GetAttributesResponse(attributes=attrs)
+
+    async def get_types(self) -> GetAttributeTypesResponse:
+        stmt = (
+            select(AttributeType)
+            .where(AttributeType.is_deleted == False)
+        )
+        types = (await self.session.scalars(stmt)).all()
+        return GetAttributeTypesResponse(types=types)
+
+    async def get_attr_by_name(self, attr_name: str) -> Optional[Attribute]:
+        stmt = (
+            select(Attribute)
+            .where(
+                and_(
+                    Attribute.name == attr_name,
+                    Attribute.is_deleted == False,
+                )
+            )
+        )
+        attribute = (await self.session.scalars(stmt)).first()
+        return attribute
+
+    async def create(self, request: CreateAttributeRequest) -> CreateAttributeResponse:
+        existing_attr = await self.get_attr_by_name(request.attribute.name)
+        if existing_attr:
+            return CreateAttributeResponse(ok=False, message="Атрибут с данным уникальным ключом уже существует")
+
+        default_value = pickle.dumps(request.attribute.default_value)
+        values = request.attribute.model_dump()
+        del values["default_value"]
+
+        attribute = Attribute(
+            **values,
+            default_value=default_value,
+        )
+        self.session.add(attribute)
+        await self.session.commit()
+        return CreateAttributeResponse(ok=True, message="Атрибут успешно создан")
+
+    async def update(self, request: UpdateAttributeRequest) -> UpdateAttributeResponse:
+        attribute = await self.session.get(Attribute, request.attribute.id)
+        if not attribute:
+            return UpdateAttributeResponse(ok=False, message=f"Атрибут с ID {request.attribute.id} не найден")
+
+        if attribute.name != request.attribute.name:
+            attr_with_same_name = await self.get_attr_by_name(request.attribute.name)
+            if attr_with_same_name:
+                return CreateAttributeResponse(ok=False, message="Атрибут с данным уникальным ключом уже существует")
+
+        default_value = pickle.dumps(request.attribute.default_value) if request.attribute.default_value else None
+
+        attribute.name = request.attribute.name
+        attribute.label = request.attribute.label
+        attribute.default_value = default_value
+        attribute.is_applicable_to_group = request.attribute.is_applicable_to_group
+        attribute.is_nullable = request.attribute.is_nullable
+        attribute.description = request.attribute.description
+        await self.session.commit()
+
+        return UpdateAttributeResponse(ok=True, message="Атрибут успешно обновлен")
+
+    async def delete(self, attribute_id: int) -> DeleteAttributeResponse:
+        attribute: Optional[Attribute] = await self.session.get(Attribute, attribute_id)
+        if not attribute:
+            return DeleteAttributeResponse(ok=False, message=f"Атрибут с ID {attribute_id} не найден")
+
+        attribute.is_deleted = True
+        await self.session.commit()
+        return DeleteAttributeResponse(ok=True, message=f"Атрибут успешно удален")

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:
+            elif len(card_product.product.barcodes) > 0:
                 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/card_tag.py

@@ -0,0 +1,129 @@
+from sqlalchemy import select
+from sqlalchemy.orm import selectinload
+
+from models import CardTag, Card, CardGroup
+from schemas.card_tag import *
+from services.base import BaseService
+
+
+class CardTagService(BaseService):
+    async def _get_by_name_and_project_id(self, name: str, project_id: int) -> Optional[CardTag]:
+        stmt = (
+            select(CardTag)
+            .where(
+                CardTag.name == name,
+                CardTag.project_id == project_id,
+                CardTag.is_deleted == False,
+            )
+        )
+        card_tag = await self.session.scalars(stmt)
+        return card_tag.first()
+
+    async def create(self, request: CreateTagRequest) -> CreateTagResponse:
+        existing_tag = await self._get_by_name_and_project_id(request.tag.name, request.tag.project_id)
+        if existing_tag:
+            return UpdateTagResponse(ok=False, message='Тег с таким названием уже существует')
+
+        tag = CardTag(name=request.tag.name, project_id=request.tag.project_id)
+        self.session.add(tag)
+        await self.session.commit()
+        return CreateTagResponse(ok=True, message='Тег успешно создан')
+
+    async def update(self, request: UpdateTagRequest) -> UpdateTagResponse:
+        card_tag = await self.session.get(CardTag, request.tag.id)
+        if not card_tag:
+            return UpdateTagResponse(ok=False, message=f'Тег с ID {request.tag.id} не найден')
+
+        if card_tag.name != request.tag.name:
+            existing_tag = await self._get_by_name_and_project_id(request.tag.name, request.tag.project_id)
+            if existing_tag:
+                return UpdateTagResponse(ok=False, message='Тег с таким названием уже существует')
+
+            card_tag.name = request.tag.name
+
+        await self.session.commit()
+        return UpdateTagResponse(ok=True, message='Тег успешно обновлен')
+
+    async def delete(self, card_tag_id: int) -> DeleteTagResponse:
+        card_tag = await self.session.get(CardTag, card_tag_id)
+        if not card_tag:
+            return DeleteTagResponse(ok=False, message=f'Тег с ID {card_tag_id} не найден')
+
+        card_tag.is_deleted = True
+        await self.session.commit()
+        return DeleteTagResponse(ok=True, message='Тег успешно удален')
+
+    async def _switch_tag_in_card(self, card_tag: CardTag, card_id: int) -> tuple[bool, str]:
+        stmt = (
+            select(Card)
+            .options(selectinload(Card.tags))
+            .where(Card.id == card_id)
+        )
+        card: Optional[Card] = (await self.session.scalars(stmt)).first()
+        if not card:
+            return False, f'Карточка с ID {card_id} не найдена'
+
+        if card_tag in card.tags:
+            card.tags.remove(card_tag)
+            return True, 'Тег откреплен от карточки'
+
+        card.tags.append(card_tag)
+        return True, 'Тег прикреплен к карточке'
+
+    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).noload(Card.products),
+                selectinload(CardGroup.cards).noload(Card.services),
+                selectinload(CardGroup.cards).noload(Card.shipping_warehouse),
+                selectinload(CardGroup.cards).noload(Card.client),
+                selectinload(CardGroup.cards).noload(Card.group),
+            )
+        )
+        return group.cards if group else []
+
+    async def _switch_tag_in_group(self, card_tag: CardTag, group_id: int):
+        cards = await self._get_cards_by_group_id(group_id)
+
+        for card in cards:
+            if card_tag in card.tags:
+                card.tags.remove(card_tag)
+            else:
+                card.tags.append(card_tag)
+
+        return True, 'Теги группы изменены'
+
+    async def switch_tag(self, request: SwitchTagRequest) -> SwitchTagResponse:
+        card_tag: Optional[CardTag] = await self.session.get(CardTag, request.tag_id)
+        if not card_tag:
+            return SwitchTagResponse(ok=False, message=f'Тег с ID {request.tag_id} не найден')
+
+        if request.card_id:
+            ok, message = await self._switch_tag_in_card(card_tag, request.card_id)
+        else:
+            ok, message = await self._switch_tag_in_group(card_tag, request.group_id)
+
+        await self.session.commit()
+        return SwitchTagResponse(ok=True, message=message)
+
+    async def apply_tags(self, card: Card, tag_names: list[str]):
+        stmt = (
+            select(CardTag)
+            .where(
+                CardTag.name.in_(tag_names),
+                CardTag.is_deleted == False,
+                CardTag.project_id == card.board.project_id
+            )
+        )
+        tags = (await self.session.scalars(stmt)).all()
+
+        cards = [card]
+        if card.group:
+            cards = await self._get_cards_by_group_id(card.group.id)
+
+        for card in cards:
+            card.tags = tags
+
+        await self.session.flush()

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,36 +1,50 @@
 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 card_attributes import CardAttributesCommandHandler
+from models import Project, Board, Module
 from schemas.project import *
 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)
+            .order_by(Project.id)
         )
         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,
+                tags=project.tags,
+            )
+            projects.append(project_schema)
 
         return GetProjectsResponse(projects=projects)
 
@@ -71,3 +85,37 @@ class ProjectService(BaseService):
         await self.session.execute(stmt)
         await self.session.commit()
         return DeleteProjectResponse(ok=True, message="Проект успешно удален")
+
+    async def get_all_modules(self) -> GetAllModulesResponse:
+        stmt = (
+            select(Module)
+            .where(Module.is_deleted == False)
+        )
+        modules = await self.session.scalars(stmt)
+        return GetAllModulesResponse(modules=modules.all())
+
+    async def update_project_modules(self, request: UpdateModulesRequest) -> UpdateModulesResponse:
+        project: Optional[Project] = await self.session.get(Project, request.project_id)
+        if not project:
+            return UpdateModulesResponse(ok=False, message=f"Проект с ID {request.project_id} не найден")
+
+        modules_stmt = (
+            select(Module)
+            .where(Module.id.in_(request.module_ids))
+        )
+        modules = (await self.session.scalars(modules_stmt)).all()
+
+        project.modules = modules
+        await self.session.commit()
+
+        return UpdateModulesResponse(ok=True, message="Модули успешно обновлены")
+
+    async def update_project_attributes(self, request: UpdateAttributesRequest) -> UpdateAttributesResponse:
+        project: Optional[Project] = await self.session.get(Project, request.project_id)
+        if not project:
+            return UpdateAttributesResponse(ok=False, message=f"Проект с ID {request.project_id} не найден")
+
+        card_attrs_handler = CardAttributesCommandHandler(self.session)
+        await card_attrs_handler.set_project_attributes(project, request.attribute_ids)
+
+        return UpdateAttributesResponse(ok=True, message="Атрибуты успешно обновлены")

services/residues.py

@@ -178,7 +178,7 @@ class ResiduesService(BaseService):
             pallet = ResidualPallet(client_id=client_id, created_at=datetime.now())
             self.session.add(pallet)
             await self.session.flush()
-            await self._load_receipt_boxes(receipt_pallet.boxes, pallet.id)
+            await self._load_receipt_boxes(receipt_pallet.boxes, None, pallet.id)
             await self._load_receipt_products(receipt_pallet.products, pallet_id=pallet.id)
 
     async def _load_receipt_products(

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="Паллет успешно создан")
@@ -26,29 +26,19 @@ class ShippingService(BaseService):
         await self.session.commit()
         return DeletePalletResponse(ok=True, message="Паллет успешно удален")
 
-    async def _update_box(self, data: UpdateBoxSchema) -> tuple[bool, str]:
-        box = await self.session.get(Box, data.box_id)
-        if not box:
-            return False, f"Короб с ID:{data.box_id} не найден"
-
-        box.quantity = data.quantity
-        box.product_id = data.product_id
-        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)
@@ -59,16 +49,14 @@ class ShippingService(BaseService):
 
         return True, f"Короб добавлен в паллет"
 
-    async def update_box(self, request: UpdateBoxRequest) -> UpdateBoxResponse:
+    async def create_box(self, request: CreateBoxRequest) -> CreateBoxResponse:
         data_keys = request.data.model_dump().keys()
-        if "box_id" in data_keys:
-            ok, message = await self._update_box(request.data)
-        elif "pallet_id" in data_keys:
+        if "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)
+        return CreateBoxResponse(ok=ok, message=message)
 
     async def delete_box(self, deal_id: int) -> DeleteBoxResponse:
         box = await self.session.get(Box, deal_id)
@@ -94,13 +82,13 @@ class ShippingService(BaseService):
         shipping_product.product_id = data.product_id
         shipping_product.quantity = data.quantity
         await self.session.commit()
-        return True, "Запись о товаре на паллете успешно изменена"
+        return True, "Запись о товаре успешно изменена"
 
     async def _create_shipping_product(self, data: CreateShippingProductSchema) -> tuple[bool, str]:
         shipping_product = ShippingProduct(**data.model_dump())
         self.session.add(shipping_product)
         await self.session.commit()
-        return True, "Запись о товаре на паллете успешно добавлена"
+        return True, "Запись о товаре успешно добавлена"
 
     async def update_shipping_product(self, request: UpdateShippingProductRequest) -> UpdateShippingProductResponse:
         data_keys = request.data.model_dump().keys()

services/statistics/expenses_statistics.py

@@ -41,23 +41,23 @@ class PaymentStatisticsService(BaseService):
         return expenses_with_filled_gaps
 
     @staticmethod
-    def _apply_payments(deals_by_dates: Subquery, expenses_subquery: Subquery):
+    def _apply_payments(cards_by_dates: Subquery, expenses_subquery: Subquery):
         return (
             select(
-                deals_by_dates.c.date,
-                deals_by_dates.c.deals_count,
-                deals_by_dates.c.revenue,
-                (func.coalesce(deals_by_dates.c.profit, 0) - func.coalesce(expenses_subquery.c.expenses, 0))
+                cards_by_dates.c.date,
+                cards_by_dates.c.cards_count,
+                cards_by_dates.c.revenue,
+                (func.coalesce(cards_by_dates.c.profit, 0) - func.coalesce(expenses_subquery.c.expenses, 0))
                 .label("profit"),
-                (deals_by_dates.c.expenses + expenses_subquery.c.expenses).label("expenses"),
+                (cards_by_dates.c.expenses + expenses_subquery.c.expenses).label("expenses"),
             )
-            .join(expenses_subquery, expenses_subquery.c.date == deals_by_dates.c.date)
+            .join(expenses_subquery, expenses_subquery.c.date == cards_by_dates.c.date)
         )
 
-    def apply_payments(self, filters: CommonProfitFilters, deals_by_dates: Subquery):
+    def apply_payments(self, filters: CommonProfitFilters, cards_by_dates: Subquery):
         self.date_from, self.date_to = filters.date_range
 
         salary_expenses = self._get_payment_records_sub()
-        deals_by_dates = self._apply_payments(deals_by_dates, salary_expenses)
+        cards_by_dates = self._apply_payments(cards_by_dates, salary_expenses)
 
-        return deals_by_dates
+        return cards_by_dates

services/statistics/profit_statistics.py

@@ -4,8 +4,8 @@ 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, \
-    ShippingWarehouse, BaseMarketplace, User, Project, Board
+from models import CardService, Card, CardStatusHistory, CardProductService, CardProduct, Service, Client, \
+    ShippingWarehouse, BaseMarketplace, User, Project, Board, CardTag, cards_card_tags, user_position
 from schemas.statistics import GetProfitChartDataResponse, GetProfitChartDataRequest, ProfitChartDataItem, \
     GetProfitTableDataResponse, GetProfitTableDataRequest, ProfitTableDataItem, CommonProfitFilters
 from services.base import BaseService
@@ -16,21 +16,21 @@ from services.statistics.transactions_statistics import TransactionsStatisticsSe
 
 class ProfitStatisticsService(BaseService):
     @staticmethod
-    def _get_sub_deals_created_at(date_from: datetime.date, date_to: datetime.date):
-        deals_created_at = (
+    def _get_sub_cards_created_at(date_from: datetime.date, date_to: datetime.date):
+        cards_created_at = (
             select(
-                Deal.id.label('deal_id'),
+                Card.id.label('card_id'),
                 func.date_trunc(
                     'day',
-                    Deal.created_at,
+                    Card.created_at,
                 ).label('date'),
-                Deal.current_status_id,
+                Card.current_status_id,
             )
             .subquery()
         )
         return (
-            select(deals_created_at)
-            .where(deals_created_at.c.date.between(date_from, date_to))
+            select(cards_created_at)
+            .where(cards_created_at.c.date.between(date_from, date_to))
             .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('card_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.card_id == Card.id)
             .subquery()
         )
 
@@ -66,9 +66,9 @@ class ProfitStatisticsService(BaseService):
             .subquery()
         )
 
-    def _get_deals_dates(self, deal_status_id: int):
-        if deal_status_id == -1:
-            return ProfitStatisticsService._get_sub_deals_created_at(self.date_from, self.date_to)
+    def _get_cards_dates(self, card_status_id: int):
+        if card_status_id == -1:
+            return ProfitStatisticsService._get_sub_cards_created_at(self.date_from, self.date_to)
         return ProfitStatisticsService._get_filtered_sub_status_history(self.date_from, self.date_to)
 
     @staticmethod
@@ -80,7 +80,7 @@ class ProfitStatisticsService(BaseService):
             if is_chart:
                 data_item = ProfitChartDataItem(
                     date=row.date.date(),
-                    deals_count=row.deals_count,
+                    cards_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,
+                    cards_count=row.cards_count,
                     profit=row.profit,
                     revenue=row.revenue,
                     expenses=row.expenses,
@@ -97,28 +97,26 @@ class ProfitStatisticsService(BaseService):
 
         return data
 
-    def _get_stmt_deal_services(self, sub_filtered_status_history: Subquery):
+    def _get_stmt_card_services(self, sub_filtered_status_history: Subquery):
         return (
             select(
-                Deal.id.label("deal_id"),
+                Card.id.label("card_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.card_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_services_profit_accounted == True,
+                Card.is_completed == True if self.is_completed_only else True,
             )
-            .group_by(Deal.id, "date")
+            .group_by(Card.id, sub_filtered_status_history.c.date)
         )
 
     @staticmethod
@@ -127,117 +125,132 @@ 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):
+    def _apply_tag_filter(tag_id: int, stmt):
+        sub_card_ids = (
+            select(cards_card_tags.c.card_id)
+            .where(cards_card_tags.c.card_tag_id == tag_id)
+        )
+        return stmt.where(Card.id.in_(sub_card_ids))
+
+    @staticmethod
+    def _apply_filters(request: CommonProfitFilters, stmt_card_services, stmt_card_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_card_services = stmt_card_services.where(Card.client_id == request.client_id)
+            stmt_card_product_services = stmt_card_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_product_services = stmt_deal_product_services.where(
-                Deal.base_marketplace_key == request.base_marketplace_key)
+            stmt_card_services = stmt_card_services.where(Card.base_marketplace_key == request.base_marketplace_key)
+            stmt_card_product_services = stmt_card_product_services.where(
+                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)
-            stmt_deal_product_services = ProfitStatisticsService._board_ids_for_project(
+            stmt_card_services = ProfitStatisticsService._board_ids_for_project(request.project_id, stmt_card_services)
+            stmt_card_product_services = ProfitStatisticsService._board_ids_for_project(
                 request.project_id,
-                stmt_deal_product_services,
+                stmt_card_product_services,
             )
 
             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_card_services = stmt_card_services.where(Card.board_id == request.board_id)
+                stmt_card_product_services = stmt_card_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)
-                    stmt_deal_product_services = stmt_deal_product_services.where(
-                        Deal.current_status_id == request.deal_status_id)
+                if request.card_status_id != -1:
+                    stmt_card_services = stmt_card_services.where(Card.current_status_id == request.card_status_id)
+                    stmt_card_product_services = stmt_card_product_services.where(
+                        Card.current_status_id == request.card_status_id)
+
+            if request.card_tag_id != -1:
+                stmt_card_services = ProfitStatisticsService._apply_tag_filter(request.card_tag_id, stmt_card_services)
+                stmt_card_product_services = ProfitStatisticsService._apply_tag_filter(
+                    request.card_tag_id,
+                    stmt_card_product_services
+                )
 
         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_card_services = stmt_card_services.where(Card.manager_id == request.manager_id)
+            stmt_card_product_services = stmt_card_product_services.where(Card.manager_id == request.manager_id)
 
-        return stmt_deal_services, stmt_deal_product_services
+        return stmt_card_services, stmt_card_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("card_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_services_profit_accounted == True,
+                    Card.is_completed == True if self.is_completed_only else True,
                 )
             )
-            .group_by(Deal.id)
+            .group_by(Card.id)
         )
 
     @staticmethod
-    def _get_joined_deals_and_statuses(sub_deal_product_services: Subquery, sub_deals_dates: Subquery):
+    def _get_joined_cards_and_statuses(sub_card_product_services: Subquery, sub_cards_dates: Subquery):
         return (
             select(
-                sub_deal_product_services.c.deal_id,
+                sub_card_product_services.c.card_id,
                 func.date_trunc(
                     "day",
-                    sub_deals_dates.c.date
+                    sub_cards_dates.c.date
                 ).label("date"),
-                sub_deal_product_services.c.revenue.label("revenue"),
-                sub_deal_product_services.c.profit.label("profit"),
+                sub_card_product_services.c.revenue.label("revenue"),
+                sub_card_product_services.c.profit.label("profit"),
             )
-            .join(sub_deals_dates, sub_deal_product_services.c.deal_id == sub_deals_dates.c.deal_id)
+            .join(sub_cards_dates, sub_card_product_services.c.card_id == sub_cards_dates.c.card_id)
         )
 
     def _group_by_date(self, stmt):
-        all_dates = generate_date_range(self.date_from, self.date_to, ["deals_count", "revenue", "profit", "expenses"])
-        deals = (
+        all_dates = generate_date_range(self.date_from, self.date_to, ["cards_count", "revenue", "profit", "expenses"])
+        cards = (
             select(
                 stmt.c.date,
-                func.count(stmt.c.deal_id).label("deals_count"),
+                func.count(stmt.c.card_id).label("cards_count"),
                 func.sum(stmt.c.revenue).label("revenue"),
                 func.sum(stmt.c.profit).label("profit"),
             )
             .group_by(stmt.c.date)
             .subquery()
         )
-        deals_with_filled_gaps = (
+        cards_with_filled_gaps = (
             select(
                 all_dates.c.date,
-                (all_dates.c.deals_count + func.coalesce(deals.c.deals_count, 0)).label("deals_count"),
-                (all_dates.c.revenue + func.coalesce(deals.c.revenue, 0)).label("revenue"),
-                (all_dates.c.profit + func.coalesce(deals.c.profit, 0)).label("profit"),
+                (all_dates.c.cards_count + func.coalesce(cards.c.cards_count, 0)).label("cards_count"),
+                (all_dates.c.revenue + func.coalesce(cards.c.revenue, 0)).label("revenue"),
+                (all_dates.c.profit + func.coalesce(cards.c.profit, 0)).label("profit"),
                 literal(0).label("expenses"),
             )
-            .join(deals, all_dates.c.date == deals.c.date, isouter=True)
+            .join(cards, all_dates.c.date == cards.c.date, isouter=True)
             .order_by(all_dates.c.date.asc())
         )
-        return deals_with_filled_gaps
+        return cards_with_filled_gaps
 
     @staticmethod
-    def _group_by_deals(stmt_union: Subquery):
+    def _group_by_cards(stmt_union: Subquery):
         return (
             select(
-                stmt_union.c.deal_id,
+                stmt_union.c.card_id,
                 stmt_union.c.date,
                 func.sum(stmt_union.c.profit).label("profit"),
                 func.sum(stmt_union.c.revenue).label("revenue"),
             )
-            .group_by(stmt_union.c.deal_id, stmt_union.c.date)
+            .group_by(stmt_union.c.card_id, stmt_union.c.date)
         )
 
     @staticmethod
@@ -246,12 +259,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("cards_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 +274,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("cards_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 +290,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("cards_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 +303,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("cards_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 +319,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("cards_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 +334,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("cards_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)
         )
 
@@ -334,48 +347,66 @@ class ProfitStatisticsService(BaseService):
     def _join_and_group_by_managers(stmt):
         managers = (
             select(User)
-            .where(User.role_key == "employee")
+            .join(user_position)
+            .where(and_(User.is_deleted == False, user_position.c.position_key == "sales_manager"))
             .subquery()
         )
         return (
             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("cards_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")
         )
 
+    @staticmethod
+    def _join_and_group_by_tags(stmt):
+        return (
+            select(
+                CardTag.id,
+                CardTag.name.label("grouped_value"),
+                CardTag.is_deleted,
+                func.count(stmt.c.card_id).label("cards_count"),
+                func.sum(stmt.c.revenue).label("revenue"),
+                func.sum(stmt.c.profit).label("profit"),
+            )
+            .join(cards_card_tags, cards_card_tags.c.card_id == stmt.c.card_id)
+            .join(CardTag, cards_card_tags.c.card_tag_id == CardTag.id)
+            .where(CardTag.is_deleted == False)
+            .group_by(CardTag.is_deleted, CardTag.id, CardTag.name)
+        )
+
     async def _get_data_rows_grouped_by_date(
             self,
-            stmt_deal_services,
-            stmt_deal_product_services,
-            sub_deals_dates: Subquery,
+            stmt_card_services,
+            stmt_card_product_services,
+            sub_cards_dates: Subquery,
     ):
-        sub_deal_product_services = stmt_deal_product_services.subquery()
-        stmt_join_deals_statuses = self._get_joined_deals_and_statuses(sub_deal_product_services, sub_deals_dates)
+        sub_card_product_services = stmt_card_product_services.subquery()
+        stmt_join_cards_statuses = self._get_joined_cards_and_statuses(sub_card_product_services, sub_cards_dates)
 
-        sub_union = union_all(stmt_deal_services, stmt_join_deals_statuses).subquery()
+        sub_union = union_all(stmt_card_services, stmt_join_cards_statuses).subquery()
 
-        sub_grouped_by_deals = self._group_by_deals(sub_union)
-        sub_deals_grouped_by_date = self._group_by_date(sub_grouped_by_deals).subquery()
+        sub_grouped_by_cards = self._group_by_cards(sub_union)
+        sub_cards_grouped_by_date = self._group_by_date(sub_grouped_by_cards).subquery()
 
         expenses_statistics_service = PaymentStatisticsService(self.session)
-        stmt_deals_applied_expenses = expenses_statistics_service.apply_payments(
+        stmt_cards_applied_expenses = expenses_statistics_service.apply_payments(
             self.filters,
-            sub_deals_grouped_by_date
+            sub_cards_grouped_by_date
         )
         transactions_statistics_service = TransactionsStatisticsService(self.session)
-        stmt_deals_applied_transactions = transactions_statistics_service.apply_transactions(
+        stmt_cards_applied_transactions = transactions_statistics_service.apply_transactions(
             self.filters,
-            stmt_deals_applied_expenses.subquery()
+            stmt_cards_applied_expenses.subquery()
         )
 
-        result = await self.session.execute(stmt_deals_applied_transactions)
+        result = await self.session.execute(stmt_cards_applied_transactions)
         rows = result.all()
         return rows
 
@@ -384,18 +415,18 @@ 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_cards_dates = self._get_cards_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()
-        stmt_deal_services, stmt_deal_product_services = self._apply_filters(
+        stmt_card_services = self._get_stmt_card_services(sub_cards_dates)
+        stmt_card_product_services = self._get_stmt_product_services()
+        stmt_card_services, stmt_card_product_services = self._apply_filters(
             request,
-            stmt_deal_services,
-            stmt_deal_product_services
+            stmt_card_services,
+            stmt_card_product_services
         )
 
         rows = await self._get_data_rows_grouped_by_date(
-            stmt_deal_services, stmt_deal_product_services, sub_deals_dates
+            stmt_card_services, stmt_card_product_services, sub_cards_dates
         )
         return self._to_schema(rows, is_chart)
 
@@ -417,106 +448,114 @@ class ProfitStatisticsService(BaseService):
                 grouped_value=row.grouped_value,
                 revenue=row.revenue,
                 profit=row.profit,
-                deals_count=row.deals_count,
+                cards_count=row.cards_count,
             ))
         return GetProfitTableDataResponse(data=data)
 
     def _get_common_table_grouped(self, request: GetProfitTableDataRequest):
         self.date_from, self.date_to = request.date_range
+        self.is_completed_only = request.is_completed_only
         self.filters = request
 
-        sub_deals_dates = self._get_deals_dates(request.deal_status_id)
+        sub_cards_dates = self._get_cards_dates(request.card_status_id)
 
-        stmt_deal_services = self._get_stmt_deal_services(sub_deals_dates)
+        stmt_card_services = self._get_stmt_card_services(sub_cards_dates)
 
-        stmt_deal_product_services = self._get_stmt_product_services()
+        stmt_card_product_services = self._get_stmt_product_services()
 
-        stmt_deal_product_services = (
+        stmt_card_product_services = (
             select(
-                stmt_deal_product_services.c.deal_id,
+                stmt_card_product_services.c.card_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"),
+                stmt_card_product_services.c.revenue.label("revenue"),
+                stmt_card_product_services.c.profit.label("profit"),
             )
-            .join(Deal, Deal.id == stmt_deal_product_services.c.deal_id)
+            .join(Card, Card.id == stmt_card_product_services.c.card_id)
         )
 
-        stmt_deal_services, stmt_deal_product_services = self._apply_filters(
+        stmt_card_services, stmt_card_product_services = self._apply_filters(
             request,
-            stmt_deal_services,
-            stmt_deal_product_services
+            stmt_card_services,
+            stmt_card_product_services
         )
 
-        sub_union = union_all(stmt_deal_services, stmt_deal_product_services).subquery()
+        sub_union = union_all(stmt_card_services, stmt_card_product_services).subquery()
 
-        sub_grouped_by_deals = self._group_by_deals(sub_union)
-        return sub_grouped_by_deals
+        sub_grouped_by_cards = self._group_by_cards(sub_union)
+        return sub_grouped_by_cards
 
     async def _get_table_grouped_by_clients(self, request: GetProfitTableDataRequest) -> GetProfitTableDataResponse:
-        sub_grouped_by_deals = self._get_common_table_grouped(request)
-        stmt_grouped_by_clients = self._join_and_group_by_clients(sub_grouped_by_deals)
+        sub_grouped_by_cards = self._get_common_table_grouped(request)
+        stmt_grouped_by_clients = self._join_and_group_by_clients(sub_grouped_by_cards)
 
         return await self._table_data_from_stmt(stmt_grouped_by_clients)
 
     async def _get_table_grouped_by_projects(self, request: GetProfitTableDataRequest) -> GetProfitTableDataResponse:
-        sub_grouped_by_deals = self._get_common_table_grouped(request)
-        stmt_grouped_by_projects = self._join_and_group_by_projects(sub_grouped_by_deals)
+        sub_grouped_by_cards = self._get_common_table_grouped(request)
+        stmt_grouped_by_projects = self._join_and_group_by_projects(sub_grouped_by_cards)
 
         return await self._table_data_from_stmt(stmt_grouped_by_projects)
 
     async def _get_table_grouped_by_boards(self, request: GetProfitTableDataRequest) -> GetProfitTableDataResponse:
-        sub_grouped_by_deals = self._get_common_table_grouped(request)
-        stmt_grouped_by_boards = self._join_and_group_by_boards(sub_grouped_by_deals)
+        sub_grouped_by_cards = self._get_common_table_grouped(request)
+        stmt_grouped_by_boards = self._join_and_group_by_boards(sub_grouped_by_cards)
 
         return await self._table_data_from_stmt(stmt_grouped_by_boards)
 
     async def _get_table_grouped_by_statuses(self, request: GetProfitTableDataRequest) -> GetProfitTableDataResponse:
         date_from, date_to = request.date_range
+        self.is_completed_only = request.is_completed_only
 
-        sub_deals_dates = self._get_filtered_sub_status_history(date_from, date_to)
+        sub_cards_dates = self._get_filtered_sub_status_history(date_from, date_to)
 
-        stmt_deal_services = self._get_stmt_deal_services(sub_deals_dates)
-        stmt_deal_product_services = self._get_stmt_product_services()
+        stmt_card_services = self._get_stmt_card_services(sub_cards_dates)
+        stmt_card_product_services = self._get_stmt_product_services()
 
-        stmt_deal_services, stmt_deal_product_services = self._apply_filters(
+        stmt_card_services, stmt_card_product_services = self._apply_filters(
             request,
-            stmt_deal_services,
-            stmt_deal_product_services
+            stmt_card_services,
+            stmt_card_product_services
         )
 
-        stmt_join_deals_statuses = self._get_joined_deals_and_statuses(
-            stmt_deal_product_services.subquery(),
-            sub_deals_dates
+        stmt_join_cards_statuses = self._get_joined_cards_and_statuses(
+            stmt_card_product_services.subquery(),
+            sub_cards_dates
         )
 
-        sub_union = union_all(stmt_deal_services, stmt_join_deals_statuses).subquery()
+        sub_union = union_all(stmt_card_services, stmt_join_cards_statuses).subquery()
 
-        sub_grouped_by_deals = self._group_by_deals(sub_union)
-        stmt_grouped_by_date = self._join_and_group_by_statuses(sub_grouped_by_deals)
+        sub_grouped_by_cards = self._group_by_cards(sub_union)
+        stmt_grouped_by_date = self._join_and_group_by_statuses(sub_grouped_by_cards)
 
         return await self._table_data_from_stmt(stmt_grouped_by_date)
 
     async def _get_table_grouped_by_warehouses(self, request: GetProfitTableDataRequest) -> GetProfitTableDataResponse:
-        sub_grouped_by_deals = self._get_common_table_grouped(request)
-        stmt_grouped_by_warehouses = self._join_and_group_by_warehouses(sub_grouped_by_deals)
+        sub_grouped_by_cards = self._get_common_table_grouped(request)
+        stmt_grouped_by_warehouses = self._join_and_group_by_warehouses(sub_grouped_by_cards)
 
         return await self._table_data_from_stmt(stmt_grouped_by_warehouses)
 
     async def _get_table_grouped_by_marketplace(self, request: GetProfitTableDataRequest) -> GetProfitTableDataResponse:
-        sub_grouped_by_deals = self._get_common_table_grouped(request)
-        stmt_grouped_by_marketplaces = self._join_and_group_by_marketplaces(sub_grouped_by_deals)
+        sub_grouped_by_cards = self._get_common_table_grouped(request)
+        stmt_grouped_by_marketplaces = self._join_and_group_by_marketplaces(sub_grouped_by_cards)
 
         return await self._table_data_from_stmt(stmt_grouped_by_marketplaces)
 
     async def _get_table_grouped_by_managers(self, request: GetProfitTableDataRequest) -> GetProfitTableDataResponse:
-        sub_grouped_by_deals = self._get_common_table_grouped(request)
-        stmt_grouped_by_managers = self._join_and_group_by_managers(sub_grouped_by_deals)
+        sub_grouped_by_cards = self._get_common_table_grouped(request)
+        stmt_grouped_by_managers = self._join_and_group_by_managers(sub_grouped_by_cards)
 
         return await self._table_data_from_stmt(stmt_grouped_by_managers)
 
+    async def _get_table_grouped_by_tags(self, request: GetProfitTableDataRequest) -> GetProfitTableDataResponse:
+        sub_grouped_by_cards = self._get_common_table_grouped(request)
+        stmt_grouped_by_tags = self._join_and_group_by_tags(sub_grouped_by_cards)
+
+        return await self._table_data_from_stmt(stmt_grouped_by_tags)
+
     async def get_profit_table_data(self, request: GetProfitTableDataRequest) -> GetProfitTableDataResponse:
         match request.group_table_by:
             case ProfitTableGroupBy.BY_DATES:
@@ -535,5 +574,7 @@ class ProfitStatisticsService(BaseService):
                 return await self._get_table_grouped_by_marketplace(request)
             case ProfitTableGroupBy.BY_MANAGERS:
                 return await self._get_table_grouped_by_managers(request)
+            case ProfitTableGroupBy.BY_TAGS:
+                return await self._get_table_grouped_by_tags(request)
 
         raise HTTPException(status_code=400, detail='Указана некорректная группировка')

services/statistics/transactions_statistics.py

@@ -70,24 +70,24 @@ class TransactionsStatisticsService(BaseService):
         return expenses_with_filled_gaps
 
     @staticmethod
-    def _apply_transactions(deals_by_dates: Subquery, transactions: Subquery):
+    def _apply_transactions(cards_by_dates: Subquery, transactions: Subquery):
         return (
             select(
-                deals_by_dates.c.date,
-                deals_by_dates.c.deals_count,
-                (deals_by_dates.c.revenue + transactions.c.revenue).label("revenue"),
-                (func.coalesce(deals_by_dates.c.profit, 0) - func.coalesce(transactions.c.expenses, 0) + func.coalesce(
+                cards_by_dates.c.date,
+                cards_by_dates.c.cards_count,
+                (cards_by_dates.c.revenue + transactions.c.revenue).label("revenue"),
+                (func.coalesce(cards_by_dates.c.profit, 0) - func.coalesce(transactions.c.expenses, 0) + func.coalesce(
                     transactions.c.revenue, 0))
                 .label("profit"),
-                (deals_by_dates.c.expenses + transactions.c.expenses).label("expenses"),
+                (cards_by_dates.c.expenses + transactions.c.expenses).label("expenses"),
             )
-            .join(transactions, transactions.c.date == deals_by_dates.c.date)
+            .join(transactions, transactions.c.date == cards_by_dates.c.date)
         )
 
-    def apply_transactions(self, filters: CommonProfitFilters, deals_by_dates: Subquery):
+    def apply_transactions(self, filters: CommonProfitFilters, cards_by_dates: Subquery):
         self.date_from, self.date_to = filters.date_range
 
         additional_expenses = self._get_additional_transactions_sub(filters.income_tag_id, filters.expense_tag_id)
-        deals_by_dates = self._apply_transactions(deals_by_dates, additional_expenses)
+        cards_by_dates = self._apply_transactions(cards_by_dates, additional_expenses)
 
-        return deals_by_dates
+        return cards_by_dates

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