feat: routers client and version prefixes

routers/crm/v1/board.py

@@ -0,0 +1,56 @@
+from fastapi import APIRouter, Path
+
+from backend.dependecies import SessionDependency
+from schemas.board import *
+from services import BoardService
+
+router = APIRouter(tags=["board"])
+
+
+@router.get(
+    "/{projectId}",
+    response_model=GetBoardsResponse,
+    operation_id="get_boards",
+)
+async def get_boards(
+    session: SessionDependency,
+    project_id: int = Path(alias="projectId"),
+):
+    return await BoardService(session).get_all(project_id)
+
+
+@router.post(
+    "/",
+    response_model=CreateBoardResponse,
+    operation_id="create_board",
+)
+async def create_board(
+    session: SessionDependency,
+    request: CreateBoardRequest,
+):
+    return await BoardService(session).create(request)
+
+
+@router.patch(
+    "/{pk}",
+    response_model=UpdateBoardResponse,
+    operation_id="update_board",
+)
+async def update_board(
+    session: SessionDependency,
+    request: UpdateBoardRequest,
+    pk: int = Path(),
+):
+    return await BoardService(session).update(pk, request)
+
+
+@router.delete(
+    "/{pk}",
+    response_model=DeleteBoardResponse,
+    operation_id="delete_board",
+)
+async def delete_board(
+    session: SessionDependency,
+    pk: int = Path(),
+):
+    return await BoardService(session).delete(pk)

routers/crm/v1/deal.py

@@ -0,0 +1,74 @@
+from fastapi import APIRouter, Path, Query
+
+from backend.dependecies import (
+    SessionDependency,
+    PaginationDependency,
+    SortingDependency,
+)
+from schemas.deal import *
+from services import DealService
+
+router = APIRouter(tags=["deal"])
+
+
+@router.get(
+    "/",
+    response_model=GetDealsResponse,
+    operation_id="get_deals",
+)
+async def get_deals(
+    session: SessionDependency,
+    pagination: PaginationDependency,
+    sorting: SortingDependency,
+    project_id: Optional[int] = Query(alias="projectId", default=None),
+    board_id: Optional[int] = Query(alias="boardId", default=None),
+    status_id: Optional[int] = Query(alias="statusId", default=None),
+    id: Optional[int] = Query(default=None),
+    name: Optional[str] = Query(default=None),
+):
+    return await DealService(session).get_all(
+        pagination,
+        sorting,
+        project_id,
+        board_id,
+        status_id,
+        id,
+        name,
+    )
+
+
+@router.post(
+    "/",
+    response_model=CreateDealResponse,
+    operation_id="create_deal",
+)
+async def create_deal(
+    session: SessionDependency,
+    request: CreateDealRequest,
+):
+    return await DealService(session).create(request)
+
+
+@router.patch(
+    "/{pk}",
+    response_model=UpdateDealResponse,
+    operation_id="update_deal",
+)
+async def update_deal(
+    session: SessionDependency,
+    request: UpdateDealRequest,
+    pk: int = Path(),
+):
+    return await DealService(session).update(pk, request)
+
+
+@router.delete(
+    "/{pk}",
+    response_model=DeleteDealResponse,
+    operation_id="delete_deal",
+)
+async def delete_deal(
+    session: SessionDependency,
+    pk: int = Path(),
+):
+    return await DealService(session).delete(pk)

routers/crm/v1/deal_group.py

@@ -0,0 +1,59 @@
+from pathlib import Path
+
+from fastapi import APIRouter
+
+from backend.dependecies import SessionDependency
+from schemas.deal_group import *
+from services import DealGroupService
+
+router = APIRouter(tags=["deal-group"])
+
+
+@router.patch(
+    "/{pk}",
+    response_model=UpdateDealGroupResponse,
+    operation_id="update_deal_group",
+)
+async def update_group(
+    request: UpdateDealGroupRequest,
+    session: SessionDependency,
+    pk: int = Path(),
+):
+    return await DealGroupService(session).update(pk, request)
+
+
+@router.post(
+    "/",
+    response_model=CreateDealGroupResponse,
+    operation_id="create_deal_group",
+)
+async def create_group(
+    request: CreateDealGroupRequest,
+    session: SessionDependency,
+):
+    return await DealGroupService(session).create(request)
+
+
+@router.delete(
+    "/{pk}",
+    response_model=DeleteDealGroupResponse,
+    operation_id="delete_deal_group",
+)
+async def delete_group(
+    session: SessionDependency,
+    pk: int = Path(),
+):
+    return await DealGroupService(session).delete(pk)
+
+
+@router.post(
+    "/{pk}/deals",
+    response_model=UpdateDealsInGroupResponse,
+    operation_id="update_deals_in_group",
+)
+async def update_deals_in_group(
+    request: UpdateDealsInGroupRequest,
+    session: SessionDependency,
+    pk: int = Path(),
+):
+    return await DealGroupService(session).update_deals_in_group(pk, request)

routers/crm/v1/module.py

@@ -0,0 +1,18 @@
+from fastapi import APIRouter
+
+from backend.dependecies import SessionDependency
+from schemas.module import GetAllBuiltInModulesResponse
+from services.built_in_module import BuiltInModuleService
+
+router = APIRouter(tags=["modules"])
+
+
+@router.get(
+    "/built-in/",
+    response_model=GetAllBuiltInModulesResponse,
+    operation_id="get_built_in_modules",
+)
+async def get_built_in_modules(
+    session: SessionDependency,
+):
+    return await BuiltInModuleService(session).get_all()

routers/crm/v1/modules/clients/client.py

@@ -0,0 +1,56 @@
+from fastapi import APIRouter, Path, Query
+
+from backend.dependecies import SessionDependency
+from modules.clients.schemas.client import *
+from modules.clients.services import ClientService
+
+router = APIRouter(tags=["client"])
+
+
+@router.get(
+    "/",
+    response_model=GetClientsResponse,
+    operation_id="get_clients",
+)
+async def get_clients(
+    session: SessionDependency,
+    include_deleted: bool = Query(alias="includeDeleted", default=False),
+):
+    return await ClientService(session).get_all(include_deleted)
+
+
+@router.post(
+    "/",
+    response_model=CreateClientResponse,
+    operation_id="create_client",
+)
+async def create_client(
+    session: SessionDependency,
+    request: CreateClientRequest,
+):
+    return await ClientService(session).create(request)
+
+
+@router.patch(
+    "/{pk}",
+    response_model=UpdateClientResponse,
+    operation_id="update_client",
+)
+async def update_client(
+    session: SessionDependency,
+    request: UpdateClientRequest,
+    pk: int = Path(),
+):
+    return await ClientService(session).update(pk, request)
+
+
+@router.delete(
+    "/{pk}",
+    response_model=DeleteClientResponse,
+    operation_id="delete_client",
+)
+async def delete_product(
+    session: SessionDependency,
+    pk: int = Path(),
+):
+    return await ClientService(session).delete(pk)

routers/crm/v1/modules/fulfillment_base/barcode_template.py

@@ -0,0 +1,77 @@
+from fastapi import APIRouter, Path
+
+from backend.dependecies import SessionDependency
+from modules.fulfillment_base.schemas.barcode_template import *
+from modules.fulfillment_base.services import BarcodeTemplateService
+
+router = APIRouter(tags=["barcode_template"])
+
+
+@router.get(
+    "/",
+    response_model=GetBarcodeTemplatesResponse,
+    operation_id="get_barcode_templates",
+)
+async def get_barcode_templates(
+    session: SessionDependency,
+):
+    return await BarcodeTemplateService(session).get_all()
+
+
+@router.post(
+    "/",
+    response_model=CreateBarcodeTemplateResponse,
+    operation_id="create_barcode_template",
+)
+async def create_barcode_template(
+    session: SessionDependency,
+    request: CreateBarcodeTemplateRequest,
+):
+    return await BarcodeTemplateService(session).create(request)
+
+
+@router.patch(
+    "/{pk}",
+    response_model=UpdateBarcodeTemplateResponse,
+    operation_id="update_barcode_template",
+)
+async def update_barcode_template(
+    session: SessionDependency,
+    request: UpdateBarcodeTemplateRequest,
+    pk: int = Path(),
+):
+    return await BarcodeTemplateService(session).update(pk, request)
+
+
+@router.delete(
+    "/{pk}",
+    response_model=DeleteBarcodeTemplateResponse,
+    operation_id="delete_barcode_template",
+)
+async def delete_barcode_template(
+    session: SessionDependency,
+    pk: int = Path(),
+):
+    return await BarcodeTemplateService(session).delete(pk)
+
+
+@router.get(
+    "/attributes",
+    response_model=GetBarcodeAttributesResponse,
+    operation_id="get_barcode_template_attributes",
+)
+async def get_barcode_template_attributes(
+    session: SessionDependency,
+):
+    return await BarcodeTemplateService(session).get_attributes()
+
+
+@router.get(
+    "/sizes",
+    response_model=GetBarcodeTemplateSizesResponse,
+    operation_id="get_barcode_template_sizes",
+)
+async def get_barcode_template_sizes(
+    session: SessionDependency,
+):
+    return await BarcodeTemplateService(session).get_sizes()

routers/crm/v1/modules/fulfillment_base/deal_product.py

@@ -0,0 +1,137 @@
+from fastapi import APIRouter, Path
+
+from backend.dependecies import SessionDependency
+from modules.fulfillment_base.schemas.deal_product import *
+from modules.fulfillment_base.schemas.product_service import *
+from modules.fulfillment_base.services import DealProductService, ProductServiceService
+
+router = APIRouter(tags=["deal-product"])
+
+# region DealProduct
+
+
+@router.get(
+    "/{dealId}",
+    response_model=GetDealProductsResponse,
+    operation_id="get_deal_products",
+)
+async def get_deal_products(
+    session: SessionDependency,
+    deal_id: int = Path(alias="dealId"),
+):
+    return await DealProductService(session).get_all(deal_id)
+
+
+@router.post(
+    "/",
+    response_model=CreateDealProductResponse,
+    operation_id="create_deal_product",
+)
+async def create_deal_product(
+    session: SessionDependency,
+    request: CreateDealProductRequest,
+):
+    return await DealProductService(session).create(request)
+
+
+@router.patch(
+    "/{dealId}/product/{productId}",
+    response_model=UpdateDealProductResponse,
+    operation_id="update_deal_product",
+)
+async def update_deal_product(
+    session: SessionDependency,
+    request: UpdateDealProductRequest,
+    deal_id: int = Path(alias="dealId"),
+    product_id: int = Path(alias="productId"),
+):
+    return await DealProductService(session).update(deal_id, product_id, request)
+
+
+@router.delete(
+    "/{dealId}/product/{productId}",
+    response_model=DeleteDealProductResponse,
+    operation_id="delete_deal_product",
+)
+async def delete_deal_product(
+    session: SessionDependency,
+    deal_id: int = Path(alias="dealId"),
+    product_id: int = Path(alias="productId"),
+):
+    return await DealProductService(session).delete(deal_id, product_id)
+
+
+# endregion
+
+
+# region DealProductService
+
+
+@router.post(
+    "/service",
+    response_model=CreateProductServiceResponse,
+    operation_id="create_deal_product_service",
+)
+async def create_deal_product_service(
+    session: SessionDependency,
+    request: CreateProductServiceRequest,
+):
+    return await ProductServiceService(session).create(request)
+
+
+@router.patch(
+    "/{dealId}/product/{productId}/service/{serviceId}",
+    response_model=UpdateProductServiceResponse,
+    operation_id="update_deal_product_service",
+)
+async def update_deal_product_service(
+    session: SessionDependency,
+    request: UpdateProductServiceRequest,
+    deal_id: int = Path(alias="dealId"),
+    product_id: int = Path(alias="productId"),
+    service_id: int = Path(alias="serviceId"),
+):
+    return await ProductServiceService(session).update(
+        deal_id, product_id, service_id, request
+    )
+
+
+@router.delete(
+    "/{dealId}/product/{productId}/service/{serviceId}",
+    response_model=DeleteProductServiceResponse,
+    operation_id="delete_deal_product_service",
+)
+async def delete_deal_product_service(
+    session: SessionDependency,
+    deal_id: int = Path(alias="dealId"),
+    product_id: int = Path(alias="productId"),
+    service_id: int = Path(alias="serviceId"),
+):
+    return await ProductServiceService(session).delete(deal_id, product_id, service_id)
+
+
+@router.post(
+    "/services/duplicate",
+    response_model=ProductServicesDuplicateResponse,
+    operation_id="duplicate_product_services",
+)
+async def copy_product_services(
+    session: SessionDependency,
+    request: ProductServicesDuplicateRequest,
+):
+    return await ProductServiceService(session).duplicate_product_services(request)
+
+
+@router.post(
+    "/add-services-kit",
+    response_model=DealProductAddKitResponse,
+    operation_id="add_kit_to_deal_product",
+)
+async def add_kit_to_deal_product(
+    session: SessionDependency,
+    request: DealProductAddKitRequest,
+):
+    return await ProductServiceService(session).add_services_kit(request)
+
+
+# endregion

routers/crm/v1/modules/fulfillment_base/deal_service.py

@@ -0,0 +1,70 @@
+from fastapi import APIRouter, Path
+
+from backend.dependecies import SessionDependency
+from modules.fulfillment_base.schemas.deal_service import *
+from modules.fulfillment_base.services import DealServiceService
+
+router = APIRouter(tags=["deal-service"])
+
+
+@router.get(
+    "/{dealId}",
+    response_model=GetDealServicesResponse,
+    operation_id="get_deal_services",
+)
+async def get_deal_services(
+    session: SessionDependency,
+    deal_id: int = Path(alias="dealId"),
+):
+    return await DealServiceService(session).get_all(deal_id)
+
+
+@router.post(
+    "/",
+    response_model=CreateDealServiceResponse,
+    operation_id="create_deal_service",
+)
+async def create_deal_service(
+    session: SessionDependency,
+    request: CreateDealServiceRequest,
+):
+    return await DealServiceService(session).create(request)
+
+
+@router.patch(
+    "/{dealId}/service/{serviceId}",
+    response_model=UpdateDealServiceResponse,
+    operation_id="update_deal_service",
+)
+async def update_deal_service(
+    session: SessionDependency,
+    request: UpdateDealServiceRequest,
+    deal_id: int = Path(alias="dealId"),
+    service_id: int = Path(alias="serviceId"),
+):
+    return await DealServiceService(session).update(deal_id, service_id, request)
+
+
+@router.delete(
+    "/{dealId}/service/{serviceId}",
+    response_model=DeleteDealServiceResponse,
+    operation_id="delete_deal_service",
+)
+async def delete_deal_service(
+    session: SessionDependency,
+    deal_id: int = Path(alias="dealId"),
+    service_id: int = Path(alias="serviceId"),
+):
+    return await DealServiceService(session).delete(deal_id, service_id)
+
+
+@router.post(
+    "/add-services-kit",
+    response_model=DealAddKitResponse,
+    operation_id="add_kit_to_deal",
+)
+async def add_kit_to_deal(
+    session: SessionDependency,
+    request: DealAddKitRequest,
+):
+    return await DealServiceService(session).add_services_kit(request)

routers/crm/v1/modules/fulfillment_base/marketplace.py

@@ -0,0 +1,66 @@
+from fastapi import APIRouter, Path
+
+from backend.dependecies import SessionDependency
+from modules.fulfillment_base.schemas.marketplace import *
+from modules.fulfillment_base.services import MarketplaceService
+
+router = APIRouter(tags=["marketplace"])
+
+
+@router.get(
+    "/base",
+    response_model=GetBaseMarketplacesResponse,
+    operation_id="get_base_marketplaces",
+)
+async def get_base_marketplaces(
+    session: SessionDependency,
+):
+    return await MarketplaceService(session).get_base_marketplaces()
+
+
+@router.get(
+    "/{clientId}",
+    response_model=GetMarketplacesResponse,
+    operation_id="get_marketplaces",
+)
+async def get_marketplaces(
+    session: SessionDependency, client_id: int = Path(alias="clientId")
+):
+    return await MarketplaceService(session).get_all(client_id)
+
+
+@router.post(
+    "/",
+    response_model=CreateMarketplaceResponse,
+    operation_id="create_marketplace",
+)
+async def create_product(
+    session: SessionDependency,
+    request: CreateMarketplaceRequest,
+):
+    return await MarketplaceService(session).create(request)
+
+
+@router.patch(
+    "/{pk}",
+    response_model=UpdateMarketplaceResponse,
+    operation_id="update_marketplace",
+)
+async def update_marketplace(
+    session: SessionDependency,
+    request: UpdateMarketplaceRequest,
+    pk: int = Path(),
+):
+    return await MarketplaceService(session).update(pk, request)
+
+
+@router.delete(
+    "/{pk}",
+    response_model=DeleteMarketplaceResponse,
+    operation_id="delete_marketplace",
+)
+async def delete_marketplace(
+    session: SessionDependency,
+    pk: int = Path(),
+):
+    return await MarketplaceService(session).delete(pk)

routers/crm/v1/modules/fulfillment_base/product.py

@@ -0,0 +1,73 @@
+from fastapi import APIRouter, Path, Query
+
+from backend.dependecies import SessionDependency, PaginationDependency
+from modules.fulfillment_base.schemas.product import *
+from modules.fulfillment_base.services import ProductService, BarcodePrinterService
+
+router = APIRouter(tags=["product"])
+
+
+@router.get(
+    "/",
+    response_model=GetProductsResponse,
+    operation_id="get_products",
+)
+async def get_products(
+    session: SessionDependency,
+    pagination: PaginationDependency,
+    client_id: Optional[int] = Query(alias="clientId", default=None),
+    search_input: Optional[str] = Query(alias="searchInput", default=None),
+):
+    return await ProductService(session).get_all(pagination, client_id, search_input)
+
+
+@router.post(
+    "/",
+    response_model=CreateProductResponse,
+    operation_id="create_product",
+)
+async def create_product(
+    session: SessionDependency,
+    request: CreateProductRequest,
+):
+    return await ProductService(session).create(request)
+
+
+@router.patch(
+    "/{pk}",
+    response_model=UpdateProductResponse,
+    operation_id="update_product",
+)
+async def update_product(
+    session: SessionDependency,
+    request: UpdateProductRequest,
+    pk: int = Path(),
+):
+    return await ProductService(session).update(pk, request)
+
+
+@router.delete(
+    "/{pk}",
+    response_model=DeleteProductResponse,
+    operation_id="delete_product",
+)
+async def delete_product(
+    session: SessionDependency,
+    pk: int = Path(),
+):
+    return await ProductService(session).delete(pk)
+
+
+@router.post(
+    "/barcode/get-pdf",
+    operation_id="get_product_barcode_pdf",
+    response_model=GetProductBarcodePdfResponse,
+)
+async def get_product_barcode_pdf(
+    request: GetProductBarcodePdfRequest, session: SessionDependency
+):
+    service = BarcodePrinterService(session)
+    filename, base64_string = await service.generate_base64(request)
+    return GetProductBarcodePdfResponse(
+        base64_string=base64_string, filename=filename, mime_type="application/pdf"
+    )

routers/crm/v1/modules/fulfillment_base/service.py

@@ -0,0 +1,55 @@
+from fastapi import APIRouter, Path
+
+from backend.dependecies import SessionDependency
+from modules.fulfillment_base.schemas.service import *
+from modules.fulfillment_base.services import ServiceModelService
+
+router = APIRouter(tags=["service"])
+
+
+@router.get(
+    "/",
+    response_model=GetServicesResponse,
+    operation_id="get_services",
+)
+async def get_services(
+    session: SessionDependency,
+):
+    return await ServiceModelService(session).get_all()
+
+
+@router.post(
+    "/",
+    response_model=CreateServiceResponse,
+    operation_id="create_service",
+)
+async def create_service(
+    session: SessionDependency,
+    request: CreateServiceRequest,
+):
+    return await ServiceModelService(session).create(request)
+
+
+@router.patch(
+    "/{pk}",
+    response_model=UpdateServiceResponse,
+    operation_id="update_service",
+)
+async def update_service(
+    session: SessionDependency,
+    request: UpdateServiceRequest,
+    pk: int = Path(),
+):
+    return await ServiceModelService(session).update(pk, request)
+
+
+@router.delete(
+    "/{pk}",
+    response_model=DeleteServiceResponse,
+    operation_id="delete_service",
+)
+async def delete_service(
+    session: SessionDependency,
+    pk: int = Path(),
+):
+    return await ServiceModelService(session).delete(pk)

routers/crm/v1/modules/fulfillment_base/service_category.py

@@ -0,0 +1,55 @@
+from fastapi import APIRouter, Path
+
+from backend.dependecies import SessionDependency
+from modules.fulfillment_base.schemas.service_category import *
+from modules.fulfillment_base.services import ServiceCategoryService
+
+router = APIRouter(tags=["service-category"])
+
+
+@router.get(
+    "/",
+    response_model=GetServiceCategoriesResponse,
+    operation_id="get_service_categories",
+)
+async def get_services_categories(
+    session: SessionDependency,
+):
+    return await ServiceCategoryService(session).get_all()
+
+
+@router.post(
+    "/",
+    response_model=CreateServiceCategoryResponse,
+    operation_id="create_service_category",
+)
+async def create_service_category(
+    session: SessionDependency,
+    request: CreateServiceCategoryRequest,
+):
+    return await ServiceCategoryService(session).create(request)
+
+
+@router.patch(
+    "/{pk}",
+    response_model=UpdateServiceCategoryResponse,
+    operation_id="update_service_category",
+)
+async def update_service_category(
+    session: SessionDependency,
+    request: UpdateServiceCategoryRequest,
+    pk: int = Path(),
+):
+    return await ServiceCategoryService(session).update(pk, request)
+
+
+@router.delete(
+    "/{pk}",
+    response_model=DeleteServiceCategoryResponse,
+    operation_id="delete_service_category",
+)
+async def delete_service_category(
+    session: SessionDependency,
+    pk: int = Path(),
+):
+    return await ServiceCategoryService(session).delete(pk)

routers/crm/v1/modules/fulfillment_base/services_kit.py

@@ -0,0 +1,55 @@
+from fastapi import APIRouter, Path
+
+from backend.dependecies import SessionDependency
+from modules.fulfillment_base.schemas.services_kit import *
+from modules.fulfillment_base.services import ServicesKitService
+
+router = APIRouter(tags=["services-kit"])
+
+
+@router.get(
+    "/",
+    response_model=GetServicesKitResponse,
+    operation_id="get_services_kits",
+)
+async def get_services_kits(
+    session: SessionDependency,
+):
+    return await ServicesKitService(session).get_all()
+
+
+@router.post(
+    "/",
+    response_model=CreateServicesKitResponse,
+    operation_id="create_services_kit",
+)
+async def create_services_kit(
+    session: SessionDependency,
+    request: CreateServicesKitRequest,
+):
+    return await ServicesKitService(session).create(request)
+
+
+@router.patch(
+    "/{pk}",
+    response_model=UpdateServicesKitResponse,
+    operation_id="update_services_kit",
+)
+async def update_services_kit(
+    session: SessionDependency,
+    request: UpdateServicesKitRequest,
+    pk: int = Path(),
+):
+    return await ServicesKitService(session).update(pk, request)
+
+
+@router.delete(
+    "/{pk}",
+    response_model=DeleteServicesKitResponse,
+    operation_id="delete_services_kit",
+)
+async def delete_services_kit(
+    session: SessionDependency,
+    pk: int = Path(),
+):
+    return await ServicesKitService(session).delete(pk)

routers/crm/v1/project.py

@@ -0,0 +1,55 @@
+from fastapi import APIRouter, Path
+
+from backend.dependecies import SessionDependency
+from schemas.project import *
+from services import ProjectService
+
+router = APIRouter(tags=["project"])
+
+
+@router.get(
+    "/",
+    response_model=GetProjectsResponse,
+    operation_id="get_projects",
+)
+async def get_projects(
+    session: SessionDependency,
+):
+    return await ProjectService(session).get_all()
+
+
+@router.post(
+    "/",
+    response_model=CreateProjectResponse,
+    operation_id="create_project",
+)
+async def create_project(
+    session: SessionDependency,
+    request: CreateProjectRequest,
+):
+    return await ProjectService(session).create(request)
+
+
+@router.patch(
+    "/{pk}",
+    response_model=UpdateProjectResponse,
+    operation_id="update_project",
+)
+async def update_project(
+    session: SessionDependency,
+    request: UpdateProjectRequest,
+    pk: int = Path(),
+):
+    return await ProjectService(session).update(pk, request)
+
+
+@router.delete(
+    "/{pk}",
+    response_model=DeleteProjectResponse,
+    operation_id="delete_project",
+)
+async def delete_project(
+    session: SessionDependency,
+    pk: int = Path(),
+):
+    return await ProjectService(session).delete(pk)

routers/crm/v1/status.py

@@ -0,0 +1,68 @@
+from fastapi import APIRouter, Path
+
+from backend.dependecies import SessionDependency
+from schemas.status import *
+from services import StatusService
+
+router = APIRouter(tags=["status"])
+
+
+@router.get(
+    "/{boardId}",
+    response_model=GetStatusesResponse,
+    operation_id="get_statuses",
+)
+async def get_statuses(
+    session: SessionDependency,
+    board_id: int = Path(alias="boardId"),
+):
+    return await StatusService(session).get_all(board_id)
+
+
+@router.post(
+    "/",
+    response_model=CreateStatusResponse,
+    operation_id="create_status",
+)
+async def create_status(
+    session: SessionDependency,
+    request: CreateStatusRequest,
+):
+    return await StatusService(session).create(request)
+
+
+@router.patch(
+    "/{pk}",
+    response_model=UpdateStatusResponse,
+    operation_id="update_status",
+)
+async def update_status(
+    session: SessionDependency,
+    request: UpdateStatusRequest,
+    pk: int = Path(),
+):
+    return await StatusService(session).update(pk, request)
+
+
+@router.delete(
+    "/{pk}",
+    response_model=DeleteStatusResponse,
+    operation_id="delete_status",
+)
+async def delete_status(
+    session: SessionDependency,
+    pk: int = Path(),
+):
+    return await StatusService(session).delete(pk)
+
+
+@router.get(
+    "/history/{dealId}",
+    response_model=GetStatusHistoryResponse,
+    operation_id="get_status_history",
+)
+async def get_status_history(
+    session: SessionDependency,
+    deal_id: int = Path(alias="dealId"),
+):
+    return await StatusService(session).get_status_history(deal_id)