feat: cards, attributes and modules

routers/__init__.py

@@ -1,6 +1,6 @@
 from .auth import auth_router
-from .deal import deal_router
-from .group import deal_group_router
+from .card import card_router
+from .group import card_group_router
 from .client import client_router
 from .service import service_router
 from .product import product_router

routers/billing.py

@@ -29,34 +29,34 @@ async def webhook(
 @billing_router.post(
     '/create-deal-bill',
     operation_id='create_deal_bill',
-    response_model=CreateDealBillResponse
+    response_model=CreateCardBillResponse
 )
 async def create_deal_bill(
         session: SessionDependency,
-        request: CreateDealBillRequest,
+        request: CreateCardBillRequest,
         user: CurrentUserDependency
 ):
-    return await BillingService(session).create_deal_billing(user, request)
+    return await BillingService(session).create_card_billing(user, request)
 @billing_router.post(
     '/cancel-deal-bill',
     operation_id='cancel_deal_bill',
-    response_model=CancelDealBillResponse
+    response_model=CancelCardBillResponse
 )
 async def cancel_deal_billing(
         session: SessionDependency,
-        request: CancelDealBillRequest,
+        request: CancelCardBillRequest,
         user: CurrentUserDependency
 ):
-    return await BillingService(session).cancel_deal_billing(user, request)
+    return await BillingService(session).cancel_card_billing(user, request)
 
 
 @billing_router.get(
     '/deal-bill-request/{deal_id}',
-    response_model=GetDealBillById,
+    response_model=GetCardBillById,
     operation_id='get_deal_bill_by_id'
 )
 async def get_deal_bill_by_id(
         deal_id: int,
         session: SessionDependency
 ):
-    return await BillingService(session).get_deal_bill_by_id(deal_id)
+    return await BillingService(session).get_card_bill_by_id(deal_id)

routers/card.py

@@ -10,170 +10,169 @@ from backend.session import get_session
 from generators.deal_pdf_generator.generator import DealTechSpecPdfGenerator
 from models import User
 from parsers import DealParser
-from schemas.barcode import GetDealProductsBarcodesPdfRequest, GetDealProductsBarcodesPdfResponse
-from schemas.deal import *
+from schemas.barcode import GetCardProductsBarcodesPdfRequest, GetCardProductsBarcodesPdfResponse
+from schemas.card import *
 from services.auth import get_current_user, authorized_user, guest_user
 from services.barcode import BarcodeService
 from services.billing import BillingService
-from services.deal import DealService
+from services.card import CardsService
 
-deal_router = APIRouter(
-    prefix='/deal',
-    tags=['deal'],
+card_router = APIRouter(
+    prefix='/card',
+    tags=['card'],
 )
 
 
-# region Deal
+# region Card
 
-@deal_router.post(
+@card_router.post(
     '/delete',
-    response_model=DealDeleteResponse,
-    operation_id='deleteDeal',
+    response_model=CardDeleteResponse,
+    operation_id='deleteCard',
     dependencies=[Depends(authorized_user)]
 )
 async def delete(
-        request: DealDeleteRequest,
+        request: CardDeleteRequest,
         session: Annotated[AsyncSession, Depends(get_session)]
 ):
-    return await DealService(session).delete(request)
+    return await CardsService(session).delete(request)
 
 
-@deal_router.post(
+@card_router.post(
     '/complete',
-    response_model=DealCompleteResponse,
-    operation_id='completeDeal',
+    response_model=CardCompleteResponse,
+    operation_id='completeCard',
     dependencies=[Depends(authorized_user)]
 )
 async def complete(
-        request: DealCompleteRequest,
+        request: CardCompleteRequest,
         session: SessionDependency,
         user: CurrentUserDependency
 ):
-    return await DealService(session).complete(user, request)
+    return await CardsService(session).complete(user, request)
 
 
-@deal_router.post(
+@card_router.post(
     '/quickCreate',
-    response_model=DealQuickCreateResponse,
+    response_model=CardQuickCreateResponse,
     dependencies=[Depends(authorized_user)]
 )
 async def quick_create(
-        request: DealQuickCreateRequest,
+        request: CardQuickCreateRequest,
         session: Annotated[AsyncSession, Depends(get_session)],
         user: Annotated[User, Depends(get_current_user)]
 ):
-    return await DealService(session).quick_create(request, user)
+    return await CardsService(session).quick_create(request, user)
 
 
-@deal_router.post(
+@card_router.post(
     '/changeStatus',
-    response_model=DealChangeStatusResponse,
+    response_model=CardChangeStatusResponse,
     dependencies=[Depends(authorized_user)]
 )
 async def change_status(
-        request: DealChangeStatusRequest,
+        request: CardChangeStatusRequest,
         session: Annotated[AsyncSession, Depends(get_session)],
         user: Annotated[User, Depends(get_current_user)]
 ):
-    return await DealService(session).change_status_manual(request, user)
+    return await CardsService(session).change_status_manual(request, user)
 
 
-@deal_router.get(
+@card_router.get(
     '/summaries',
-    response_model=DealSummaryResponse,
-    operation_id='getDealSummaries',
+    response_model=CardSummaryResponse,
+    operation_id='getCardSummaries',
     dependencies=[Depends(authorized_user)]
 )
 async def get_summary(
         session: Annotated[AsyncSession, Depends(get_session)],
         full: Optional[bool]
 ):
-    return await DealService(session).get_summary(full)
+    return await CardsService(session).get_summary(full)
 
 
-@deal_router.post(
+@card_router.post(
     '/summaries/reorder',
-    response_model=DealSummaryResponse,
-    operation_id='reorderDealSummaries',
+    response_model=CardSummaryResponse,
+    operation_id='reorderCardSummaries',
     dependencies=[Depends(authorized_user)]
 )
 async def reorder(
         session: Annotated[AsyncSession, Depends(get_session)],
-        request: DealSummaryReorderRequest,
+        request: CardSummaryReorderRequest,
         user: Annotated[User, Depends(get_current_user)]
 ):
-    return await DealService(session).reorder(request, user)
+    return await CardsService(session).reorder(request, user)
 
 
-@deal_router.get(
+@card_router.get(
     '/get-all',
-    response_model=DealGetAllResponse,
-    operation_id='getAllDeals',
+    response_model=CardGetAllResponse,
+    operation_id='getAllCards',
     dependencies=[Depends(authorized_user)]
 )
 async def get_all(
         session: Annotated[AsyncSession, Depends(get_session)]
 ):
-    return await DealService(session).get_all()
+    return await CardsService(session).get_all()
 
 
-# endpoint to get deal by id
-@deal_router.get(
-    '/get/{deal_id}',
-    response_model=DealSchema,
-    operation_id='getDealById',
+# endpoint to get card by id
+@card_router.get(
+    '/get/{card_id}',
+    response_model=CardSchema,
+    operation_id='getCardById',
     dependencies=[Depends(guest_user)]
 )
-async def get_deal_by_id(
-        deal_id: int,
+async def get_card_by_id(
+        card_id: int,
         user: CurrentUserDependency,
         session: Annotated[AsyncSession, Depends(get_session)]
 ):
-    return await DealService(session).get_by_id(user, deal_id)
+    return await CardsService(session).get_by_id(user, card_id)
 
 
-@deal_router.post(
+@card_router.post(
     '/update-general-info',
-    response_model=DealUpdateGeneralInfoResponse,
-    operation_id='updateDealGeneralInfo',
+    response_model=CardUpdateGeneralInfoResponse,
+    operation_id='updateCardGeneralInfo',
     dependencies=[Depends(authorized_user)]
 )
 async def update_general_info(
-        request: DealUpdateGeneralInfoRequest,
+        request: CardUpdateGeneralInfoRequest,
         session: Annotated[AsyncSession, Depends(get_session)],
         user: CurrentUserDependency,
 ):
-    return await DealService(session).update_general_info(request, user)
+    return await CardsService(session).update_general_info(request, user)
 
 
-@deal_router.post(
+@card_router.post(
     '/add-kit',
-    response_model=DealAddKitResponse,
-    operation_id='add_kit_to_deal'
-
+    response_model=CardAddKitResponse,
+    operation_id='add_kit_to_card'
 )
-async def add_kit_to_deal(
+async def add_kit_to_card(
         session: SessionDependency,
-        request: DealAddKitRequest
+        request: CardAddKitRequest
 ):
-    return await DealService(session).add_kit_to_deal(request)
+    return await CardsService(session).add_kit_to_card(request)
 
 
-@deal_router.post(
+@card_router.post(
     '/create-guest-url',
-    response_model=DealCreateGuestUrlResponse,
+    response_model=CardCreateGuestUrlResponse,
     operation_id='create_deal_guest_url',
     dependencies=[Depends(authorized_user)]
 )
 async def create_guest_url(
         session: SessionDependency,
-        request: DealCreateGuestUrlRequest,
+        request: CardCreateGuestUrlRequest,
         user: CurrentUserDependency
 ):
-    return DealService(session).create_guest_url(user, request)
+    return CardsService(session).create_guest_url(user, request)
 
 
-@deal_router.get(
+@card_router.get(
     '/billing-document/{deal_id}',
     operation_id='get_billing_document',
     # dependencies=[Depends(authorized_user)],
@@ -186,7 +185,7 @@ async def get_billing_document(
     return Response(pdf_file.getvalue(), media_type='application/pdf')
 
 
-@deal_router.get(
+@card_router.get(
     '/tech-spec/{deal_id}',
     operation_id='get_deal_tech_spec',
     # dependencies=[Depends(authorized_user)],
@@ -199,33 +198,33 @@ async def get_deal_tech_spec(
     return Response(pdf_file.getvalue(), media_type='application/pdf')
 
 
-@deal_router.post(
+@card_router.post(
     '/prefill',
-    response_model=DealPrefillResponse,
-    operation_id='prefill_deal',
+    response_model=CardPrefillResponse,
+    operation_id='prefill_card',
     dependencies=[Depends(authorized_user)]
 )
-async def post_prefill_deal(
+async def post_prefill_card(
         session: SessionDependency,
-        request: DealPrefillRequest,
+        request: CardPrefillRequest,
         user: CurrentUserDependency
 ):
-    return await DealService(session).prefill_deal(user, request)
+    return await CardsService(session).prefill_card_products_and_services(user, request)
 
 
-@deal_router.post(
+@card_router.post(
     '/recalculate-price',
-    response_model=DealRecalculatePriceResponse,
-    operation_id='recalculate_deal_price',
+    response_model=CardRecalculatePriceResponse,
+    operation_id='recalculate_card_price',
 )
-async def recalculate_deal_price(
+async def recalculate_card_price(
         session: SessionDependency,
-        request: DealRecalculatePriceRequest,
+        request: CardRecalculatePriceRequest,
 ):
-    return await DealService(session).recalculate_price(request)
+    return await CardsService(session).recalculate_price(request)
 
 
-@deal_router.post(
+@card_router.post(
     '/employee',
     response_model=ManageEmployeeResponse,
     operation_id='manage_employee',
@@ -234,24 +233,24 @@ async def manage_employee(
         session: SessionDependency,
         request: ManageEmployeeRequest,
 ):
-    return await DealService(session).manage_employee(request)
+    return await CardsService(session).manage_employee(request)
 
 
-@deal_router.get(
-    '/employee/available/{deal_id}',
+@card_router.get(
+    '/employee/available/{card_id}',
     response_model=GetAvailableEmployeesToAssignResponse,
     operation_id='get_available_employees_to_assign',
 )
 async def get_available_employees_to_assign(
         session: Annotated[AsyncSession, Depends(get_session)],
-        deal_id: int,
+        card_id: int,
 ):
-    return await DealService(session).get_available_employees_to_assign(deal_id)
+    return await CardsService(session).get_available_employees_to_assign(card_id)
 
 
-@deal_router.post(
+@card_router.post(
     '/prefill/excel/parse',
-    response_model=ParseDealsExcelResponse,
+    response_model=ParseCardsExcelResponse,
     operation_id='parse_deals_excel',
 )
 async def parse_deals_excel(
@@ -262,221 +261,220 @@ async def parse_deals_excel(
     return await DealParser(session).parse(file_bytes)
 
 
-@deal_router.post(
+@card_router.post(
     '/prefill/excel/create',
-    response_model=CreateDealsFromExcelResponse,
+    response_model=CreateCardsFromExcelResponse,
     operation_id='create_deals_excel',
 )
 async def create_deals_from_excel(
         session: Annotated[AsyncSession, Depends(get_session)],
-        request: CreateDealsFromExcelRequest,
+        request: CreateCardsFromExcelRequest,
         user: CurrentUserDependency,
 ):
-    return await DealService(session).create_deals_from_excel(request, user)
+    return await CardsService(session).create_cards_from_excel(request, user)
 
 # endregion
 
-# region Deal services
+# region Card services
 
-@deal_router.post(
+@card_router.post(
     '/services/add/multiple',
-    response_model=DealAddServicesResponse,
-    operation_id='addMultipleDealServices',
+    response_model=CardAddServicesResponse,
+    operation_id='add_multiple_card_services',
     dependencies=[Depends(guest_user)]
 )
 async def services_add(
-        request: DealAddServicesRequest,
+        request: CardAddServicesRequest,
         session: Annotated[AsyncSession, Depends(get_session)],
 ):
-    return await DealService(session).add_services(request)
+    return await CardsService(session).add_services(request)
 
 
-@deal_router.post(
+@card_router.post(
     '/services/add',
-    response_model=DealAddServiceResponse,
-    operation_id='addDealService',
+    response_model=CardAddServiceResponse,
+    operation_id='add_card_service',
     dependencies=[Depends(guest_user)]
 )
 async def services_add(
-        request: DealAddServiceRequest,
+        request: CardAddServiceRequest,
         session: Annotated[AsyncSession, Depends(get_session)],
         user: CurrentUserDependency
 ):
-    return await DealService(session).add_service(user, request)
+    return await CardsService(session).add_service(user, request)
 
 
-@deal_router.post(
+@card_router.post(
     '/services/update-quantity',
-    response_model=DealUpdateServiceQuantityResponse,
-    operation_id='updateDealServiceQuantity',
+    response_model=CardUpdateServiceQuantityResponse,
+    operation_id='update_card_service_quantity',
     dependencies=[Depends(guest_user)]
 )
 async def services_update_quantity(
-        request: DealUpdateServiceQuantityRequest,
+        request: CardUpdateServiceQuantityRequest,
         session: Annotated[AsyncSession, Depends(get_session)],
         user: CurrentUserDependency
 
 ):
-    return await DealService(session).update_service_quantity(user, request)
+    return await CardsService(session).update_service_quantity(user, request)
 
 
-@deal_router.post(
+@card_router.post(
     '/services/update',
-    response_model=DealUpdateServiceResponse,
-    operation_id='updateDealService',
+    response_model=CardUpdateServiceResponse,
+    operation_id='update_card_service',
     dependencies=[Depends(guest_user)]
 )
 async def services_update(
-        request: DealUpdateServiceRequest,
+        request: CardUpdateServiceRequest,
         session: Annotated[AsyncSession, Depends(get_session)],
         user: CurrentUserDependency
 ):
-    return await DealService(session).update_service(user, request)
+    return await CardsService(session).update_service(user, request)
 
 
-@deal_router.post(
+@card_router.post(
     '/services/delete',
-    response_model=DealDeleteServiceResponse,
-    operation_id='deleteDealService',
+    response_model=CardDeleteServiceResponse,
+    operation_id='delete_card_service',
     dependencies=[Depends(guest_user)]
 )
 async def services_delete(
-        request: DealDeleteServiceRequest,
+        request: CardDeleteServiceRequest,
         session: Annotated[AsyncSession, Depends(get_session)],
         user: CurrentUserDependency
 ):
-    return await DealService(session).delete_service(user, request)
+    return await CardsService(session).delete_service(user, request)
 
 
-@deal_router.post(
+@card_router.post(
     '/services/delete/multiple',
-    response_model=DealDeleteServicesResponse,
-    operation_id='deleteMultipleDealServices',
+    response_model=CardDeleteServicesResponse,
+    operation_id='delete_multiple_card_services',
     dependencies=[Depends(guest_user)]
 )
 async def services_delete(
-        request: DealDeleteServicesRequest,
+        request: CardDeleteServicesRequest,
         session: Annotated[AsyncSession, Depends(get_session)],
         user: CurrentUserDependency
 ):
-    return await DealService(session).delete_services(user, request)
+    return await CardsService(session).delete_services(user, request)
 
 
-@deal_router.post(
+@card_router.post(
     '/services/copy',
-    response_model=DealServicesCopyResponse,
+    response_model=CardServicesCopyResponse,
     operation_id='copy_product_services',
     dependencies=[Depends(guest_user)]
 )
 async def services_copy(
         session: SessionDependency,
-        request: DealServicesCopyRequest,
+        request: CardServicesCopyRequest,
         user: CurrentUserDependency
 ):
-    return await DealService(session).copy_services(user, request)
+    return await CardsService(session).copy_services(user, request)
 
 
 # endregion
 
-# region Deal products
-@deal_router.post(
+# region Card products
+@card_router.post(
     '/products/update-quantity',
-    response_model=DealUpdateProductQuantityResponse,
-    operation_id='updateDealProductQuantity',
+    response_model=CardUpdateProductQuantityResponse,
+    operation_id='update_card_product_quantity',
     dependencies=[Depends(guest_user)]
 )
 async def products_update(
-        request: DealUpdateProductQuantityRequest,
+        request: CardUpdateProductQuantityRequest,
         session: Annotated[AsyncSession, Depends(get_session)],
         user: CurrentUserDependency
 ):
-    return await DealService(session).update_product_quantity(user, request)
+    return await CardsService(session).update_product_quantity(user, request)
 
 
-@deal_router.post(
+@card_router.post(
     '/products/add',
-    response_model=DealAddProductResponse,
-    operation_id='addDealProduct',
+    response_model=CardAddProductResponse,
+    operation_id='add_card_product',
     dependencies=[Depends(guest_user)]
 )
 async def products_add(
-        request: DealAddProductRequest,
+        request: CardAddProductRequest,
         session: Annotated[AsyncSession, Depends(get_session)],
         user: CurrentUserDependency
 ):
-    return await DealService(session).add_product(user, request)
+    return await CardsService(session).add_product(user, request)
 
 
-@deal_router.post(
+@card_router.post(
     '/products/delete',
-    response_model=DealDeleteProductResponse,
-    operation_id='deleteDealProduct',
+    response_model=CardDeleteProductResponse,
+    operation_id='delete_card_product',
     dependencies=[Depends(guest_user)]
 )
 async def products_delete(
-        request: DealDeleteProductRequest,
+        request: CardDeleteProductRequest,
         session: Annotated[AsyncSession, Depends(get_session)],
         user: CurrentUserDependency
-
 ):
-    return await DealService(session).delete_product(user, request)
+    return await CardsService(session).delete_product(user, request)
 
 
-@deal_router.post(
+@card_router.post(
     '/products/delete/multiple',
-    response_model=DealDeleteProductsResponse,
-    operation_id='deleteMultipleDealProducts',
+    response_model=CardDeleteProductsResponse,
+    operation_id='delete_multiple_card_products',
     dependencies=[Depends(guest_user)]
 )
 async def products_delete(
-        request: DealDeleteProductsRequest,
+        request: CardDeleteProductsRequest,
         session: Annotated[AsyncSession, Depends(get_session)],
         user: CurrentUserDependency
 ):
-    return await DealService(session).delete_products(user, request)
+    return await CardsService(session).delete_products(user, request)
 
 
-@deal_router.post(
+@card_router.post(
     '/product/update',
-    response_model=DealUpdateProductResponse,
-    operation_id='updateDealProduct',
+    response_model=CardUpdateProductResponse,
+    operation_id='update_card_product',
     dependencies=[Depends(guest_user)]
 )
 async def products_update(
-        request: DealUpdateProductRequest,
+        request: CardUpdateProductRequest,
         session: Annotated[AsyncSession, Depends(get_session)],
         user: CurrentUserDependency
 ):
-    return await DealService(session).update_product(user, request)
+    return await CardsService(session).update_product(user, request)
 
 
-@deal_router.post(
+@card_router.post(
     '/product/add-kit',
-    response_model=DealProductAddKitResponse,
-    operation_id='add_kit_to_deal_product',
+    response_model=CardProductAddKitResponse,
+    operation_id='add_kit_to_card_product',
     dependencies=[Depends(guest_user)]
 )
-async def add_kit_to_deal_product(
+async def add_kit_to_card_product(
         session: SessionDependency,
-        request: DealProductAddKitRequest,
+        request: CardProductAddKitRequest,
         user: CurrentUserDependency
 ):
-    return await DealService(session).add_kit_to_deal_product(user, request)
+    return await CardsService(session).add_kit_to_card_product(user, request)
 
 
-@deal_router.post(
+@card_router.post(
     '/barcodes/get-pdf',
-    operation_id='get_deal_products_barcodes_pdf',
-    response_model=GetDealProductsBarcodesPdfResponse
+    operation_id='get_card_products_barcodes_pdf',
+    response_model=GetCardProductsBarcodesPdfResponse
 )
-async def get_deal_products_barcodes_pdf(
-        request: GetDealProductsBarcodesPdfRequest,
+async def get_card_products_barcodes_pdf(
+        request: GetCardProductsBarcodesPdfRequest,
         session: Annotated[AsyncSession, Depends(get_session)]
 ):
-    filename, pdf_buffer = await BarcodeService(session).get_deal_barcodes_pdf(request)
+    filename, pdf_buffer = await BarcodeService(session).get_card_barcodes_pdf(request)
     pdf_buffer: BytesIO
     base64_string = base64.b64encode(pdf_buffer.read()).decode('utf-8')
-    return GetDealProductsBarcodesPdfResponse(
+    return GetCardProductsBarcodesPdfResponse(
         base64_string=base64_string,
         filename=filename,
         mime_type='application/pdf'

routers/group.py

@@ -3,77 +3,77 @@ from fastapi import APIRouter, Depends
 from backend.dependecies import SessionDependency, CurrentUserDependency
 from schemas.group import *
 from services.auth import authorized_user
-from services.deal_group import DealGroupService
+from services.card_group import CardGroupService
 
-deal_group_router = APIRouter(
-    prefix='/deal-group',
-    tags=['deal-group'],
+card_group_router = APIRouter(
+    prefix='/card-group',
+    tags=['card-group'],
 )
 
 
-@deal_group_router.patch(
+@card_group_router.patch(
     '/',
-    response_model=DealGroupUpdateResponse,
-    operation_id='update_deal_group',
+    response_model=CardGroupUpdateResponse,
+    operation_id='update_card_group',
     dependencies=[Depends(authorized_user)]
 )
 async def update_group(
-        request: DealGroupUpdateRequest,
+        request: CardGroupUpdateRequest,
         session: SessionDependency,
 ):
-    return await DealGroupService(session).update_group(request)
+    return await CardGroupService(session).update_group(request)
 
 
-@deal_group_router.post(
+@card_group_router.post(
     '/',
-    response_model=DealCreateGroupResponse,
-    operation_id='create_deal_group',
+    response_model=CardCreateGroupResponse,
+    operation_id='create_card_group',
     dependencies=[Depends(authorized_user)]
 )
 async def create_group(
-        request: DealCreateGroupRequest,
+        request: CreateCardGroupRequest,
         session: SessionDependency,
         user: CurrentUserDependency
 ):
-    return await DealGroupService(session).create_group(user, request)
+    return await CardGroupService(session).create_group(user, request)
 
 
-@deal_group_router.patch(
+@card_group_router.patch(
     '/change-status',
-    response_model=DealGroupChangeStatusResponse,
+    response_model=CardGroupChangeStatusResponse,
     operation_id='change_status',
     dependencies=[Depends(authorized_user)]
 )
 async def change_status(
-        request: DealGroupChangeStatusRequest,
+        request: CardGroupChangeStatusRequest,
         session: SessionDependency,
         user: CurrentUserDependency
 ):
-    return await DealGroupService(session).change_group_status(user,request)
+    return await CardGroupService(session).change_group_status(user,request)
 
 
-@deal_group_router.post(
-    '/deal',
-    response_model=DealAddToGroupResponse,
-    operation_id='add_deal',
+@card_group_router.post(
+    '/card',
+    response_model=CardAddToGroupResponse,
+    operation_id='add_card',
     dependencies=[Depends(authorized_user)]
 )
-async def add_deal(
-        request: DealAddToGroupRequest,
+async def add_card(
+        request: CardAddToGroupRequest,
         session: SessionDependency,
         user: CurrentUserDependency
 ):
-    return await DealGroupService(session).add_deal(user, request)
+    return await CardGroupService(session).add_card(user, request)
 
 
-@deal_group_router.delete(
-    '/deal',
-    response_model=DealRemoveFromGroupResponse,
-    operation_id='remove_deal',
+@card_group_router.delete(
+    '/card',
+    response_model=CardRemoveFromGroupResponse,
+    operation_id='remove_card',
     dependencies=[Depends(authorized_user)]
 )
-async def remove_deal(
-        request: DealRemoveFromGroupRequest,
+async def remove_card(
+        request: CardRemoveFromGroupRequest,
         session: SessionDependency,
 ):
-    return await DealGroupService(session).remove_deal(request)
+    return await CardGroupService(session).remove_card(request)

routers/shipping.py

@@ -15,16 +15,16 @@ shipping_router = APIRouter(
 
 
 @shipping_router.post(
-    '/pallet/{deal_id}',
+    '/pallet/{card_id}',
     response_model=CreatePalletResponse,
     operation_id='create_pallet',
     dependencies=[Depends(authorized_user)],
 )
 async def create_pallet(
         session: SessionDependency,
-        deal_id: int,
+        card_id: int,
 ):
-    return await ShippingService(session).create_pallet(deal_id)
+    return await ShippingService(session).create_pallet(card_id)
 
 
 @shipping_router.delete(