fakz9/Crm-Backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: routers client and version prefixes

Browse Source
This commit is contained in:
AlexSserb
2025-10-17 21:40:54 +04:00
parent 6b1b4109c6
commit d7c7d1775f
22 changed files with 4 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
modules/fulfillment_base/routers/__init__.py
View File

77
modules/fulfillment_base/routers/barcode_template.py
View File

@ -1,77 +0,0 @@
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()

137
modules/fulfillment_base/routers/deal_product.py
View File

@ -1,137 +0,0 @@
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

70
modules/fulfillment_base/routers/deal_service.py
View File

@ -1,70 +0,0 @@
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)

66
modules/fulfillment_base/routers/marketplace.py
View File

@ -1,66 +0,0 @@
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)

73
modules/fulfillment_base/routers/product.py
View File

@ -1,73 +0,0 @@
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"
)

55
modules/fulfillment_base/routers/service.py
View File

@ -1,55 +0,0 @@
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)

55
modules/fulfillment_base/routers/service_category.py
View File

@ -1,55 +0,0 @@
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)

55
modules/fulfillment_base/routers/services_kit.py
View File

@ -1,55 +0,0 @@
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)