2393 lines
87 KiB
Python
2393 lines
87 KiB
Python
"""中试服务管理 API（细胞产品类型/规格/价格体系/项目价格、渠道信息、体检机构）"""
|
|
from typing import Any, List, Optional
|
|
|
|
from fastapi import APIRouter, Depends, Query
|
|
from pydantic import BaseModel, ConfigDict, Field
|
|
from sqlalchemy.orm import Session
|
|
|
|
from app.core.database import get_db
|
|
from app.core.menu_guard import require_admin_or_super_admin
|
|
from app.core.response import error_response, success_response
|
|
from app.crud import pilot_service as ps_svc
|
|
from app.models.models import SysUser
|
|
|
|
router = APIRouter(prefix="/web/admin", tags=["中试服务管理"])
|
|
|
|
|
|
def _get_tenant_no(db: Session, user: dict) -> str:
|
|
user_id = user.get("user_id")
|
|
if not user_id:
|
|
raise PermissionError("用户身份信息缺失，无法确定租户")
|
|
sys_user = db.query(SysUser).filter(SysUser.id == user_id).first()
|
|
if not sys_user or not sys_user.tenant_no:
|
|
raise PermissionError("用户租户信息缺失")
|
|
return sys_user.tenant_no
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# 1. 细胞产品类型
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class CellProductTypeCreateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
product_type_code: str = Field(..., alias="productTypeCode")
|
|
product_type_name: str = Field(..., alias="productTypeName")
|
|
order_num: Optional[int] = Field(0, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
class CellProductTypeUpdateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
product_type_code: Optional[str] = Field(None, alias="productTypeCode")
|
|
product_type_name: Optional[str] = Field(None, alias="productTypeName")
|
|
order_num: Optional[int] = Field(None, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
@router.get("/cell-product-types")
|
|
async def list_cell_product_types(
|
|
page: int = Query(1, ge=1),
|
|
pageSize: int = Query(10, ge=1, le=100, alias="pageSize"),
|
|
keyword: Optional[str] = None,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
tenant_no = _get_tenant_no(db, user)
|
|
items, total = ps_svc.list_cell_product_types(
|
|
db, page=page, page_size=pageSize, keyword=keyword, tenant_no=tenant_no, user_info=user
|
|
)
|
|
tp = ps_svc.total_pages(total, pageSize)
|
|
return success_response(
|
|
{"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp}
|
|
)
|
|
|
|
|
|
@router.post("/cell-product-types")
|
|
async def create_cell_product_type(
|
|
body: CellProductTypeCreateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
obj = ps_svc.create_cell_product_type(
|
|
db,
|
|
product_type_code=body.product_type_code,
|
|
product_type_name=body.product_type_name,
|
|
tenant_no=tenant_no,
|
|
order_num=body.order_num,
|
|
remark=body.remark,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(ps_svc._row_to_dict_cell_product_type(obj), message="创建成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.put("/cell-product-types/{row_id}")
|
|
async def update_cell_product_type(
|
|
row_id: str,
|
|
body: CellProductTypeUpdateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
|
|
obj = ps_svc.update_cell_product_type(
|
|
db,
|
|
row_id,
|
|
product_type_code=payload.get("product_type_code"),
|
|
product_type_name=payload.get("product_type_name"),
|
|
order_num=payload.get("order_num"),
|
|
remark=payload.get("remark"),
|
|
user_id=user.get("user_id"),
|
|
tenant_no=tenant_no,
|
|
)
|
|
return success_response(ps_svc._row_to_dict_cell_product_type(obj), message="更新成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.delete("/cell-product-types/{row_id}")
|
|
async def delete_cell_product_type(
|
|
row_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
ps_svc.soft_delete_cell_product_type(db, row_id, tenant_no=tenant_no)
|
|
return success_response(None, message="删除成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# 2. 细胞产品规格
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class CellProductSpecCreateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
spec_code: str = Field(..., alias="specCode")
|
|
spec_name: str = Field(..., alias="specName")
|
|
order_num: Optional[int] = Field(0, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
class CellProductSpecUpdateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
spec_code: Optional[str] = Field(None, alias="specCode")
|
|
spec_name: Optional[str] = Field(None, alias="specName")
|
|
order_num: Optional[int] = Field(None, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
@router.get("/cell-product-specs")
|
|
async def list_cell_product_specs(
|
|
page: int = Query(1, ge=1),
|
|
pageSize: int = Query(10, ge=1, le=100, alias="pageSize"),
|
|
keyword: Optional[str] = None,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
tenant_no = _get_tenant_no(db, user)
|
|
items, total = ps_svc.list_cell_product_specs(
|
|
db, page=page, page_size=pageSize, keyword=keyword, tenant_no=tenant_no, user_info=user
|
|
)
|
|
tp = ps_svc.total_pages(total, pageSize)
|
|
return success_response(
|
|
{"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp}
|
|
)
|
|
|
|
|
|
@router.post("/cell-product-specs")
|
|
async def create_cell_product_spec(
|
|
body: CellProductSpecCreateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
obj = ps_svc.create_cell_product_spec(
|
|
db,
|
|
spec_code=body.spec_code,
|
|
spec_name=body.spec_name,
|
|
tenant_no=tenant_no,
|
|
order_num=body.order_num,
|
|
remark=body.remark,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(ps_svc._row_to_dict_cell_product_spec(obj), message="创建成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.put("/cell-product-specs/{row_id}")
|
|
async def update_cell_product_spec(
|
|
row_id: str,
|
|
body: CellProductSpecUpdateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
|
|
obj = ps_svc.update_cell_product_spec(
|
|
db,
|
|
row_id,
|
|
spec_code=payload.get("spec_code"),
|
|
spec_name=payload.get("spec_name"),
|
|
order_num=payload.get("order_num"),
|
|
remark=payload.get("remark"),
|
|
user_id=user.get("user_id"),
|
|
tenant_no=tenant_no,
|
|
)
|
|
return success_response(ps_svc._row_to_dict_cell_product_spec(obj), message="更新成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.delete("/cell-product-specs/{row_id}")
|
|
async def delete_cell_product_spec(
|
|
row_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
ps_svc.soft_delete_cell_product_spec(db, row_id, tenant_no=tenant_no)
|
|
return success_response(None, message="删除成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# 3. 细胞产品价格
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class CellProductPriceCreateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
project_name: str = Field(..., alias="projectName")
|
|
project_code: str = Field(..., alias="projectCode")
|
|
cell_type_code: Optional[str] = Field(None, alias="cellTypeCode")
|
|
cell_type_name: Optional[str] = Field(None, alias="cellTypeName")
|
|
spec_text: Optional[str] = Field(None, alias="specText")
|
|
spec_id: Optional[str] = Field(None, alias="specId")
|
|
cell_product_type_id: Optional[str] = Field(None, alias="cellProductTypeId")
|
|
unit_price: Optional[float] = Field(None, alias="unitPrice")
|
|
order_num: Optional[int] = Field(0, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
class CellProductPriceUpdateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
project_name: Optional[str] = Field(None, alias="projectName")
|
|
project_code: Optional[str] = Field(None, alias="projectCode")
|
|
cell_type_code: Optional[str] = Field(None, alias="cellTypeCode")
|
|
cell_type_name: Optional[str] = Field(None, alias="cellTypeName")
|
|
spec_text: Optional[str] = Field(None, alias="specText")
|
|
spec_id: Optional[str] = Field(None, alias="specId")
|
|
cell_product_type_id: Optional[str] = Field(None, alias="cellProductTypeId")
|
|
unit_price: Optional[float] = Field(None, alias="unitPrice")
|
|
order_num: Optional[int] = Field(None, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
@router.get("/cell-product-prices")
|
|
async def list_cell_product_prices(
|
|
page: int = Query(1, ge=1),
|
|
pageSize: int = Query(10, ge=1, le=100, alias="pageSize"),
|
|
keyword: Optional[str] = None,
|
|
cell_product_type_id: Optional[str] = Query(None, alias="cellProductTypeId"),
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
tenant_no = _get_tenant_no(db, user)
|
|
items, total = ps_svc.list_cell_product_prices(
|
|
db,
|
|
page=page,
|
|
page_size=pageSize,
|
|
keyword=keyword,
|
|
tenant_no=tenant_no,
|
|
cell_product_type_id=cell_product_type_id,
|
|
user_info=user,
|
|
)
|
|
tp = ps_svc.total_pages(total, pageSize)
|
|
return success_response(
|
|
{"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp}
|
|
)
|
|
|
|
|
|
@router.post("/cell-product-prices")
|
|
async def create_cell_product_price(
|
|
body: CellProductPriceCreateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
obj = ps_svc.create_cell_product_price(
|
|
db,
|
|
project_name=body.project_name,
|
|
project_code=body.project_code,
|
|
cell_type_code=body.cell_type_code or "",
|
|
cell_type_name=body.cell_type_name or "",
|
|
spec_text=body.spec_text or "",
|
|
spec_id=body.spec_id or "",
|
|
cell_product_type_id=body.cell_product_type_id or "",
|
|
unit_price=body.unit_price,
|
|
tenant_no=tenant_no,
|
|
order_num=body.order_num,
|
|
remark=body.remark,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(ps_svc._row_to_dict_cell_product_price(obj), message="创建成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.put("/cell-product-prices/{row_id}")
|
|
async def update_cell_product_price(
|
|
row_id: str,
|
|
body: CellProductPriceUpdateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
|
|
obj = ps_svc.update_cell_product_price(
|
|
db,
|
|
row_id,
|
|
project_name=payload.get("project_name"),
|
|
project_code=payload.get("project_code"),
|
|
cell_type_code=payload.get("cell_type_code"),
|
|
cell_type_name=payload.get("cell_type_name"),
|
|
spec_text=payload.get("spec_text"),
|
|
spec_id=payload.get("spec_id"),
|
|
cell_product_type_id=payload.get("cell_product_type_id"),
|
|
unit_price=payload.get("unit_price"),
|
|
order_num=payload.get("order_num"),
|
|
remark=payload.get("remark"),
|
|
user_id=user.get("user_id"),
|
|
tenant_no=tenant_no,
|
|
)
|
|
return success_response(ps_svc._row_to_dict_cell_product_price(obj), message="更新成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.delete("/cell-product-prices/{row_id}")
|
|
async def delete_cell_product_price(
|
|
row_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
ps_svc.soft_delete_cell_product_price(db, row_id, tenant_no=tenant_no)
|
|
return success_response(None, message="删除成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# 4. 项目价格体系（主表 + 明细子表）
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class ProjectSystemCreateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
system_name: str = Field(..., alias="systemName")
|
|
system_code: str = Field(..., alias="systemCode")
|
|
status: Optional[str] = Field("1", alias="status")
|
|
order_num: Optional[int] = Field(0, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
class ProjectSystemUpdateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
system_name: Optional[str] = Field(None, alias="systemName")
|
|
system_code: Optional[str] = Field(None, alias="systemCode")
|
|
status: Optional[str] = Field(None, alias="status")
|
|
order_num: Optional[int] = Field(None, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
@router.get("/project-price-systems")
|
|
async def list_project_systems(
|
|
page: int = Query(1, ge=1),
|
|
pageSize: int = Query(10, ge=1, le=100, alias="pageSize"),
|
|
keyword: Optional[str] = None,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
tenant_no = _get_tenant_no(db, user)
|
|
items, total = ps_svc.list_project_systems(
|
|
db, page=page, page_size=pageSize, keyword=keyword, tenant_no=tenant_no, user_info=user
|
|
)
|
|
tp = ps_svc.total_pages(total, pageSize)
|
|
return success_response(
|
|
{"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp}
|
|
)
|
|
|
|
|
|
@router.post("/project-price-systems")
|
|
async def create_project_system(
|
|
body: ProjectSystemCreateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
obj = ps_svc.create_project_system(
|
|
db,
|
|
system_name=body.system_name,
|
|
system_code=body.system_code,
|
|
status=body.status,
|
|
tenant_no=tenant_no,
|
|
order_num=body.order_num,
|
|
remark=body.remark,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(ps_svc._row_to_dict_project_system(obj), message="创建成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.put("/project-price-systems/{row_id}")
|
|
async def update_project_system(
|
|
row_id: str,
|
|
body: ProjectSystemUpdateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
|
|
obj = ps_svc.update_project_system(
|
|
db,
|
|
row_id,
|
|
system_name=payload.get("system_name"),
|
|
system_code=payload.get("system_code"),
|
|
status=payload.get("status"),
|
|
order_num=payload.get("order_num"),
|
|
remark=payload.get("remark"),
|
|
user_id=user.get("user_id"),
|
|
tenant_no=tenant_no,
|
|
)
|
|
return success_response(ps_svc._row_to_dict_project_system(obj), message="更新成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.delete("/project-price-systems/{row_id}")
|
|
async def delete_project_system(
|
|
row_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
ps_svc.soft_delete_project_system(db, row_id, tenant_no=tenant_no)
|
|
return success_response(None, message="删除成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
# --- 项目价格体系明细 ---
|
|
|
|
|
|
class ProjectSystemItemCreateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
source_price_id: Optional[str] = Field(None, alias="sourcePriceId")
|
|
project_name: str = Field(..., alias="projectName")
|
|
project_code: str = Field(..., alias="projectCode")
|
|
cell_type_code: Optional[str] = Field(None, alias="cellTypeCode")
|
|
cell_type_name: Optional[str] = Field(None, alias="cellTypeName")
|
|
spec_text: Optional[str] = Field(None, alias="specText")
|
|
spec_id: Optional[str] = Field(None, alias="specId")
|
|
cell_product_type_id: Optional[str] = Field(None, alias="cellProductTypeId")
|
|
unit_price: Optional[float] = Field(None, alias="unitPrice")
|
|
order_num: Optional[int] = Field(0, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
class ProjectSystemItemUpdateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
source_price_id: Optional[str] = Field(None, alias="sourcePriceId")
|
|
project_name: Optional[str] = Field(None, alias="projectName")
|
|
project_code: Optional[str] = Field(None, alias="projectCode")
|
|
cell_type_code: Optional[str] = Field(None, alias="cellTypeCode")
|
|
cell_type_name: Optional[str] = Field(None, alias="cellTypeName")
|
|
spec_text: Optional[str] = Field(None, alias="specText")
|
|
spec_id: Optional[str] = Field(None, alias="specId")
|
|
cell_product_type_id: Optional[str] = Field(None, alias="cellProductTypeId")
|
|
unit_price: Optional[float] = Field(None, alias="unitPrice")
|
|
order_num: Optional[int] = Field(None, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
@router.get("/project-price-systems/{system_id}/items")
|
|
async def list_project_system_items(
|
|
system_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
items = ps_svc.list_project_system_items(db, system_id, tenant_no=tenant_no, user_info=user)
|
|
return success_response(items)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.post("/project-price-systems/{system_id}/items")
|
|
async def create_project_system_item(
|
|
system_id: str,
|
|
body: ProjectSystemItemCreateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
obj = ps_svc.create_project_system_item(
|
|
db,
|
|
project_system_id=system_id,
|
|
source_price_id=body.source_price_id or "",
|
|
project_name=body.project_name,
|
|
project_code=body.project_code,
|
|
cell_type_code=body.cell_type_code or "",
|
|
cell_type_name=body.cell_type_name or "",
|
|
spec_text=body.spec_text or "",
|
|
spec_id=body.spec_id or "",
|
|
cell_product_type_id=body.cell_product_type_id or "",
|
|
unit_price=body.unit_price,
|
|
tenant_no=tenant_no,
|
|
order_num=body.order_num,
|
|
remark=body.remark,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(ps_svc._row_to_dict_project_system_item(obj), message="创建成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.put("/project-system-items/{item_id}")
|
|
async def update_project_system_item(
|
|
item_id: str,
|
|
body: ProjectSystemItemUpdateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
|
|
obj = ps_svc.update_project_system_item(
|
|
db,
|
|
item_id,
|
|
source_price_id=payload.get("source_price_id"),
|
|
project_name=payload.get("project_name"),
|
|
project_code=payload.get("project_code"),
|
|
cell_type_code=payload.get("cell_type_code"),
|
|
cell_type_name=payload.get("cell_type_name"),
|
|
spec_text=payload.get("spec_text"),
|
|
spec_id=payload.get("spec_id"),
|
|
cell_product_type_id=payload.get("cell_product_type_id"),
|
|
unit_price=payload.get("unit_price"),
|
|
order_num=payload.get("order_num"),
|
|
remark=payload.get("remark"),
|
|
user_id=user.get("user_id"),
|
|
tenant_no=tenant_no,
|
|
)
|
|
return success_response(ps_svc._row_to_dict_project_system_item(obj), message="更新成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.delete("/project-system-items/{item_id}")
|
|
async def delete_project_system_item(
|
|
item_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
ps_svc.soft_delete_project_system_item(db, item_id, tenant_no=tenant_no)
|
|
return success_response(None, message="删除成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# 5. 渠道信息（主表 + 开票/邮寄地址/协议/协议产品价格子表）
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class ChannelCreateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
channel_name: str = Field(..., alias="channelName")
|
|
credit_code: Optional[str] = Field(None, alias="creditCode")
|
|
channel_type: Optional[str] = Field(None, alias="channelType")
|
|
contact_name: Optional[str] = Field(None, alias="contactName")
|
|
contact_phone: Optional[str] = Field(None, alias="contactPhone")
|
|
contact_email: Optional[str] = Field(None, alias="contactEmail")
|
|
protocol_attachments: Optional[str] = Field(None, alias="protocolAttachments")
|
|
order_num: Optional[int] = Field(0, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
class ChannelUpdateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
channel_name: Optional[str] = Field(None, alias="channelName")
|
|
credit_code: Optional[str] = Field(None, alias="creditCode")
|
|
channel_type: Optional[str] = Field(None, alias="channelType")
|
|
contact_name: Optional[str] = Field(None, alias="contactName")
|
|
contact_phone: Optional[str] = Field(None, alias="contactPhone")
|
|
contact_email: Optional[str] = Field(None, alias="contactEmail")
|
|
protocol_attachments: Optional[str] = Field(None, alias="protocolAttachments")
|
|
order_num: Optional[int] = Field(None, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
@router.get("/channels")
|
|
async def list_channels(
|
|
page: int = Query(1, ge=1),
|
|
pageSize: int = Query(10, ge=1, le=100, alias="pageSize"),
|
|
keyword: Optional[str] = None,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
tenant_no = _get_tenant_no(db, user)
|
|
items, total = ps_svc.list_channels(
|
|
db, page=page, page_size=pageSize, keyword=keyword, tenant_no=tenant_no, user_info=user
|
|
)
|
|
tp = ps_svc.total_pages(total, pageSize)
|
|
return success_response(
|
|
{"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp}
|
|
)
|
|
|
|
|
|
@router.post("/channels")
|
|
async def create_channel(
|
|
body: ChannelCreateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
obj = ps_svc.create_channel(
|
|
db,
|
|
channel_name=body.channel_name,
|
|
credit_code=body.credit_code,
|
|
channel_type=body.channel_type,
|
|
contact_name=body.contact_name,
|
|
contact_phone=body.contact_phone,
|
|
contact_email=body.contact_email,
|
|
protocol_attachments=body.protocol_attachments,
|
|
tenant_no=tenant_no,
|
|
order_num=body.order_num,
|
|
remark=body.remark,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(
|
|
ps_svc._row_to_dict_channel(obj, db, tenant_no),
|
|
message="创建成功",
|
|
)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.put("/channels/{row_id}")
|
|
async def update_channel(
|
|
row_id: str,
|
|
body: ChannelUpdateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
|
|
obj = ps_svc.update_channel(
|
|
db,
|
|
row_id,
|
|
channel_name=payload.get("channel_name"),
|
|
credit_code=payload.get("credit_code"),
|
|
channel_type=payload.get("channel_type"),
|
|
contact_name=payload.get("contact_name"),
|
|
contact_phone=payload.get("contact_phone"),
|
|
contact_email=payload.get("contact_email"),
|
|
protocol_attachments=payload.get("protocol_attachments"),
|
|
order_num=payload.get("order_num"),
|
|
remark=payload.get("remark"),
|
|
user_id=user.get("user_id"),
|
|
tenant_no=tenant_no,
|
|
)
|
|
return success_response(
|
|
ps_svc._row_to_dict_channel(obj, db, tenant_no),
|
|
message="更新成功",
|
|
)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.delete("/channels/{row_id}")
|
|
async def delete_channel(
|
|
row_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
ps_svc.soft_delete_channel(db, row_id, tenant_no=tenant_no)
|
|
return success_response(None, message="删除成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
# --- 渠道开票信息 ---
|
|
|
|
|
|
class ChannelInvoiceCreateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
company_name: str = Field(..., alias="companyName")
|
|
tax_no: Optional[str] = Field(None, alias="taxNo")
|
|
company_address: Optional[str] = Field(None, alias="companyAddress")
|
|
company_phone: Optional[str] = Field(None, alias="companyPhone")
|
|
bank_name: Optional[str] = Field(None, alias="bankName")
|
|
bank_account: Optional[str] = Field(None, alias="bankAccount")
|
|
order_num: Optional[int] = Field(0, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
class ChannelInvoiceUpdateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
company_name: Optional[str] = Field(None, alias="companyName")
|
|
tax_no: Optional[str] = Field(None, alias="taxNo")
|
|
company_address: Optional[str] = Field(None, alias="companyAddress")
|
|
company_phone: Optional[str] = Field(None, alias="companyPhone")
|
|
bank_name: Optional[str] = Field(None, alias="bankName")
|
|
bank_account: Optional[str] = Field(None, alias="bankAccount")
|
|
order_num: Optional[int] = Field(None, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
@router.get("/channels/{channel_id}/invoices")
|
|
async def list_channel_invoices(
|
|
channel_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
items = ps_svc.list_channel_invoices(db, channel_id, tenant_no=tenant_no, user_info=user)
|
|
return success_response(items)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.post("/channels/{channel_id}/invoices")
|
|
async def create_channel_invoice(
|
|
channel_id: str,
|
|
body: ChannelInvoiceCreateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
obj = ps_svc.create_channel_invoice(
|
|
db,
|
|
channel_id=channel_id,
|
|
company_name=body.company_name,
|
|
tax_no=body.tax_no,
|
|
company_address=body.company_address,
|
|
company_phone=body.company_phone,
|
|
bank_name=body.bank_name,
|
|
bank_account=body.bank_account,
|
|
tenant_no=tenant_no,
|
|
order_num=body.order_num,
|
|
remark=body.remark,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(ps_svc._row_to_dict_channel_invoice(obj), message="创建成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.put("/channel-invoices/{invoice_id}")
|
|
async def update_channel_invoice(
|
|
invoice_id: str,
|
|
body: ChannelInvoiceUpdateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
|
|
obj = ps_svc.update_channel_invoice(
|
|
db,
|
|
invoice_id,
|
|
company_name=payload.get("company_name"),
|
|
tax_no=payload.get("tax_no"),
|
|
company_address=payload.get("company_address"),
|
|
company_phone=payload.get("company_phone"),
|
|
bank_name=payload.get("bank_name"),
|
|
bank_account=payload.get("bank_account"),
|
|
order_num=payload.get("order_num"),
|
|
remark=payload.get("remark"),
|
|
user_id=user.get("user_id"),
|
|
tenant_no=tenant_no,
|
|
)
|
|
return success_response(ps_svc._row_to_dict_channel_invoice(obj), message="更新成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.delete("/channel-invoices/{invoice_id}")
|
|
async def delete_channel_invoice(
|
|
invoice_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
ps_svc.soft_delete_channel_invoice(db, invoice_id, tenant_no=tenant_no)
|
|
return success_response(None, message="删除成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
# --- 渠道邮寄地址 ---
|
|
|
|
|
|
class ChannelMailAddressCreateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
mail_address: str = Field(..., alias="mailAddress")
|
|
mail_contact: Optional[str] = Field(None, alias="mailContact")
|
|
mail_phone: Optional[str] = Field(None, alias="mailPhone")
|
|
order_num: Optional[int] = Field(0, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
class ChannelMailAddressUpdateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
mail_address: Optional[str] = Field(None, alias="mailAddress")
|
|
mail_contact: Optional[str] = Field(None, alias="mailContact")
|
|
mail_phone: Optional[str] = Field(None, alias="mailPhone")
|
|
order_num: Optional[int] = Field(None, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
@router.get("/channels/{channel_id}/mail-addresses")
|
|
async def list_channel_mail_addresses(
|
|
channel_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
items = ps_svc.list_channel_mail_addresses(db, channel_id, tenant_no=tenant_no, user_info=user)
|
|
return success_response(items)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.post("/channels/{channel_id}/mail-addresses")
|
|
async def create_channel_mail_address(
|
|
channel_id: str,
|
|
body: ChannelMailAddressCreateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
obj = ps_svc.create_channel_mail_address(
|
|
db,
|
|
channel_id=channel_id,
|
|
mail_address=body.mail_address,
|
|
mail_contact=body.mail_contact,
|
|
mail_phone=body.mail_phone,
|
|
tenant_no=tenant_no,
|
|
order_num=body.order_num,
|
|
remark=body.remark,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(ps_svc._row_to_dict_channel_mail_address(obj), message="创建成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.put("/channel-mail-addresses/{address_id}")
|
|
async def update_channel_mail_address(
|
|
address_id: str,
|
|
body: ChannelMailAddressUpdateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
|
|
obj = ps_svc.update_channel_mail_address(
|
|
db,
|
|
address_id,
|
|
mail_address=payload.get("mail_address"),
|
|
mail_contact=payload.get("mail_contact"),
|
|
mail_phone=payload.get("mail_phone"),
|
|
order_num=payload.get("order_num"),
|
|
remark=payload.get("remark"),
|
|
user_id=user.get("user_id"),
|
|
tenant_no=tenant_no,
|
|
)
|
|
return success_response(ps_svc._row_to_dict_channel_mail_address(obj), message="更新成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.delete("/channel-mail-addresses/{address_id}")
|
|
async def delete_channel_mail_address(
|
|
address_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
ps_svc.soft_delete_channel_mail_address(db, address_id, tenant_no=tenant_no)
|
|
return success_response(None, message="删除成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
# --- 渠道协议 ---
|
|
|
|
|
|
class ChannelAgreementCreateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
agreement_type: str = Field(..., alias="agreementType")
|
|
business_type: Optional[str] = Field(None, alias="businessType")
|
|
settle_mode: Optional[str] = Field(None, alias="settleMode")
|
|
credit_limit_amount: Optional[float] = Field(None, alias="creditLimitAmount")
|
|
effective_date: Optional[str] = Field(None, alias="effectiveDate")
|
|
expire_date: Optional[str] = Field(None, alias="expireDate")
|
|
order_num: Optional[int] = Field(0, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
class ChannelAgreementUpdateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
agreement_type: Optional[str] = Field(None, alias="agreementType")
|
|
business_type: Optional[str] = Field(None, alias="businessType")
|
|
settle_mode: Optional[str] = Field(None, alias="settleMode")
|
|
credit_limit_amount: Optional[float] = Field(None, alias="creditLimitAmount")
|
|
effective_date: Optional[str] = Field(None, alias="effectiveDate")
|
|
expire_date: Optional[str] = Field(None, alias="expireDate")
|
|
order_num: Optional[int] = Field(None, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
@router.get("/channels/{channel_id}/agreements")
|
|
async def list_channel_agreements(
|
|
channel_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
items = ps_svc.list_channel_agreements(db, channel_id, tenant_no=tenant_no, user_info=user)
|
|
return success_response(items)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.post("/channels/{channel_id}/agreements")
|
|
async def create_channel_agreement(
|
|
channel_id: str,
|
|
body: ChannelAgreementCreateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
obj = ps_svc.create_channel_agreement(
|
|
db,
|
|
channel_id=channel_id,
|
|
agreement_type=body.agreement_type,
|
|
business_type=body.business_type,
|
|
settle_mode=body.settle_mode,
|
|
credit_limit_amount=body.credit_limit_amount,
|
|
effective_date=body.effective_date,
|
|
expire_date=body.expire_date,
|
|
tenant_no=tenant_no,
|
|
order_num=body.order_num,
|
|
remark=body.remark,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(ps_svc._row_to_dict_channel_agreement(obj), message="创建成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.put("/channel-agreements/{agreement_id}")
|
|
async def update_channel_agreement(
|
|
agreement_id: str,
|
|
body: ChannelAgreementUpdateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
|
|
obj = ps_svc.update_channel_agreement(
|
|
db,
|
|
agreement_id,
|
|
agreement_type=payload.get("agreement_type"),
|
|
business_type=payload.get("business_type"),
|
|
settle_mode=payload.get("settle_mode"),
|
|
credit_limit_amount=payload.get("credit_limit_amount"),
|
|
effective_date=payload.get("effective_date"),
|
|
expire_date=payload.get("expire_date"),
|
|
order_num=payload.get("order_num"),
|
|
remark=payload.get("remark"),
|
|
user_id=user.get("user_id"),
|
|
tenant_no=tenant_no,
|
|
)
|
|
return success_response(ps_svc._row_to_dict_channel_agreement(obj), message="更新成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.delete("/channel-agreements/{agreement_id}")
|
|
async def delete_channel_agreement(
|
|
agreement_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
ps_svc.soft_delete_channel_agreement(db, agreement_id, tenant_no=tenant_no)
|
|
return success_response(None, message="删除成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.put("/channel-agreements/{agreement_id}/activate")
|
|
async def activate_channel_agreement(
|
|
agreement_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
obj = ps_svc.activate_channel_agreement(
|
|
db,
|
|
agreement_id,
|
|
tenant_no=tenant_no,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(ps_svc._row_to_dict_channel_agreement(obj), message="生效成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.put("/channel-agreements/{agreement_id}/void")
|
|
async def void_channel_agreement(
|
|
agreement_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
obj = ps_svc.void_channel_agreement(
|
|
db,
|
|
agreement_id,
|
|
tenant_no=tenant_no,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(ps_svc._row_to_dict_channel_agreement(obj), message="作废成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
# --- 渠道协议产品价格 ---
|
|
|
|
|
|
class ChannelAgreementPriceCreateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
project_name: Optional[str] = Field(None, alias="projectName")
|
|
project_code: Optional[str] = Field(None, alias="projectCode")
|
|
cell_type_code: Optional[str] = Field(None, alias="cellTypeCode")
|
|
cell_type_name: Optional[str] = Field(None, alias="cellTypeName")
|
|
spec_text: Optional[str] = Field(None, alias="specText")
|
|
original_price: Optional[float] = Field(None, alias="originalPrice")
|
|
agreement_price: Optional[float] = Field(None, alias="agreementPrice")
|
|
order_num: Optional[int] = Field(0, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
class ChannelAgreementPriceUpdateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
project_name: Optional[str] = Field(None, alias="projectName")
|
|
project_code: Optional[str] = Field(None, alias="projectCode")
|
|
cell_type_code: Optional[str] = Field(None, alias="cellTypeCode")
|
|
cell_type_name: Optional[str] = Field(None, alias="cellTypeName")
|
|
spec_text: Optional[str] = Field(None, alias="specText")
|
|
original_price: Optional[float] = Field(None, alias="originalPrice")
|
|
agreement_price: Optional[float] = Field(None, alias="agreementPrice")
|
|
order_num: Optional[int] = Field(None, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
@router.get("/channel-agreements/{agreement_id}/product-prices")
|
|
async def list_channel_agreement_prices(
|
|
agreement_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
items = ps_svc.list_channel_agreement_prices(db, agreement_id, tenant_no=tenant_no, user_info=user)
|
|
return success_response(items)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.post("/channel-agreements/{agreement_id}/product-prices")
|
|
async def create_channel_agreement_price(
|
|
agreement_id: str,
|
|
body: ChannelAgreementPriceCreateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
obj = ps_svc.create_channel_agreement_price(
|
|
db,
|
|
channel_agreement_id=agreement_id,
|
|
project_name=body.project_name,
|
|
project_code=body.project_code,
|
|
cell_type_code=body.cell_type_code,
|
|
cell_type_name=body.cell_type_name,
|
|
spec_text=body.spec_text,
|
|
original_price=body.original_price,
|
|
agreement_price=body.agreement_price,
|
|
tenant_no=tenant_no,
|
|
order_num=body.order_num,
|
|
remark=body.remark,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(ps_svc._row_to_dict_channel_agreement_price(obj), message="创建成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.put("/channel-agreement-product-prices/{price_id}")
|
|
async def update_channel_agreement_price(
|
|
price_id: str,
|
|
body: ChannelAgreementPriceUpdateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
|
|
obj = ps_svc.update_channel_agreement_price(
|
|
db,
|
|
price_id,
|
|
project_name=payload.get("project_name"),
|
|
project_code=payload.get("project_code"),
|
|
cell_type_code=payload.get("cell_type_code"),
|
|
cell_type_name=payload.get("cell_type_name"),
|
|
spec_text=payload.get("spec_text"),
|
|
original_price=payload.get("original_price"),
|
|
agreement_price=payload.get("agreement_price"),
|
|
order_num=payload.get("order_num"),
|
|
remark=payload.get("remark"),
|
|
user_id=user.get("user_id"),
|
|
tenant_no=tenant_no,
|
|
)
|
|
return success_response(ps_svc._row_to_dict_channel_agreement_price(obj), message="更新成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.delete("/channel-agreement-product-prices/{price_id}")
|
|
async def delete_channel_agreement_price(
|
|
price_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
ps_svc.soft_delete_channel_agreement_price(db, price_id, tenant_no=tenant_no)
|
|
return success_response(None, message="删除成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# 6. 体检机构（主表 + 开票信息/项目及价格子表）
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class CheckupInstitutionCreateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
institution_name: str = Field(..., alias="institutionName")
|
|
institution_address: Optional[str] = Field(None, alias="institutionAddress")
|
|
contact_name: Optional[str] = Field(None, alias="contactName")
|
|
contact_phone: Optional[str] = Field(None, alias="contactPhone")
|
|
institution_logo: Optional[str] = Field(None, alias="institutionLogo")
|
|
status: Optional[str] = Field("1", alias="status")
|
|
order_num: Optional[int] = Field(0, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
class CheckupInstitutionUpdateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
institution_name: Optional[str] = Field(None, alias="institutionName")
|
|
institution_address: Optional[str] = Field(None, alias="institutionAddress")
|
|
contact_name: Optional[str] = Field(None, alias="contactName")
|
|
contact_phone: Optional[str] = Field(None, alias="contactPhone")
|
|
institution_logo: Optional[str] = Field(None, alias="institutionLogo")
|
|
status: Optional[str] = Field(None, alias="status")
|
|
order_num: Optional[int] = Field(None, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
@router.get("/checkup-institutions")
|
|
async def list_checkup_institutions(
|
|
page: int = Query(1, ge=1),
|
|
pageSize: int = Query(10, ge=1, le=100, alias="pageSize"),
|
|
keyword: Optional[str] = None,
|
|
status: Optional[str] = None,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
tenant_no = _get_tenant_no(db, user)
|
|
items, total = ps_svc.list_checkup_institutions(
|
|
db,
|
|
page=page,
|
|
page_size=pageSize,
|
|
keyword=keyword,
|
|
status=status,
|
|
tenant_no=tenant_no,
|
|
user_info=user,
|
|
)
|
|
tp = ps_svc.total_pages(total, pageSize)
|
|
return success_response(
|
|
{"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp}
|
|
)
|
|
|
|
|
|
@router.post("/checkup-institutions")
|
|
async def create_checkup_institution(
|
|
body: CheckupInstitutionCreateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
obj = ps_svc.create_checkup_institution(
|
|
db,
|
|
institution_name=body.institution_name,
|
|
institution_address=body.institution_address,
|
|
contact_name=body.contact_name,
|
|
contact_phone=body.contact_phone,
|
|
institution_logo=body.institution_logo,
|
|
status=body.status,
|
|
tenant_no=tenant_no,
|
|
order_num=body.order_num,
|
|
remark=body.remark,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(ps_svc._row_to_dict_checkup_institution(obj), message="创建成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.put("/checkup-institutions/{row_id}")
|
|
async def update_checkup_institution(
|
|
row_id: str,
|
|
body: CheckupInstitutionUpdateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
|
|
obj = ps_svc.update_checkup_institution(
|
|
db,
|
|
row_id,
|
|
institution_name=payload.get("institution_name"),
|
|
institution_address=payload.get("institution_address"),
|
|
contact_name=payload.get("contact_name"),
|
|
contact_phone=payload.get("contact_phone"),
|
|
institution_logo=payload.get("institution_logo"),
|
|
status=payload.get("status"),
|
|
order_num=payload.get("order_num"),
|
|
remark=payload.get("remark"),
|
|
user_id=user.get("user_id"),
|
|
tenant_no=tenant_no,
|
|
)
|
|
return success_response(ps_svc._row_to_dict_checkup_institution(obj), message="更新成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.delete("/checkup-institutions/{row_id}")
|
|
async def delete_checkup_institution(
|
|
row_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
ps_svc.soft_delete_checkup_institution(db, row_id, tenant_no=tenant_no)
|
|
return success_response(None, message="删除成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
# --- 体检机构开票信息 ---
|
|
|
|
|
|
class CheckupInstitutionInvoiceCreateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
company_name: str = Field(..., alias="companyName")
|
|
tax_no: Optional[str] = Field(None, alias="taxNo")
|
|
company_address: Optional[str] = Field(None, alias="companyAddress")
|
|
company_phone: Optional[str] = Field(None, alias="companyPhone")
|
|
bank_name: Optional[str] = Field(None, alias="bankName")
|
|
bank_account: Optional[str] = Field(None, alias="bankAccount")
|
|
order_num: Optional[int] = Field(0, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
class CheckupInstitutionInvoiceUpdateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
company_name: Optional[str] = Field(None, alias="companyName")
|
|
tax_no: Optional[str] = Field(None, alias="taxNo")
|
|
company_address: Optional[str] = Field(None, alias="companyAddress")
|
|
company_phone: Optional[str] = Field(None, alias="companyPhone")
|
|
bank_name: Optional[str] = Field(None, alias="bankName")
|
|
bank_account: Optional[str] = Field(None, alias="bankAccount")
|
|
order_num: Optional[int] = Field(None, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
@router.get("/checkup-institutions/{institution_id}/invoices")
|
|
async def list_checkup_institution_invoices(
|
|
institution_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
items = ps_svc.list_checkup_institution_invoices(db, institution_id, tenant_no=tenant_no, user_info=user)
|
|
return success_response(items)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.post("/checkup-institutions/{institution_id}/invoices")
|
|
async def create_checkup_institution_invoice(
|
|
institution_id: str,
|
|
body: CheckupInstitutionInvoiceCreateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
obj = ps_svc.create_checkup_institution_invoice(
|
|
db,
|
|
checkup_institution_id=institution_id,
|
|
company_name=body.company_name,
|
|
tax_no=body.tax_no,
|
|
company_address=body.company_address,
|
|
company_phone=body.company_phone,
|
|
bank_name=body.bank_name,
|
|
bank_account=body.bank_account,
|
|
tenant_no=tenant_no,
|
|
order_num=body.order_num,
|
|
remark=body.remark,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(ps_svc._row_to_dict_checkup_institution_invoice(obj), message="创建成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.put("/checkup-institution-invoices/{invoice_id}")
|
|
async def update_checkup_institution_invoice(
|
|
invoice_id: str,
|
|
body: CheckupInstitutionInvoiceUpdateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
|
|
obj = ps_svc.update_checkup_institution_invoice(
|
|
db,
|
|
invoice_id,
|
|
company_name=payload.get("company_name"),
|
|
tax_no=payload.get("tax_no"),
|
|
company_address=payload.get("company_address"),
|
|
company_phone=payload.get("company_phone"),
|
|
bank_name=payload.get("bank_name"),
|
|
bank_account=payload.get("bank_account"),
|
|
order_num=payload.get("order_num"),
|
|
remark=payload.get("remark"),
|
|
user_id=user.get("user_id"),
|
|
tenant_no=tenant_no,
|
|
)
|
|
return success_response(ps_svc._row_to_dict_checkup_institution_invoice(obj), message="更新成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.delete("/checkup-institution-invoices/{invoice_id}")
|
|
async def delete_checkup_institution_invoice(
|
|
invoice_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
ps_svc.soft_delete_checkup_institution_invoice(db, invoice_id, tenant_no=tenant_no)
|
|
return success_response(None, message="删除成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
# --- 体检机构项目及价格 ---
|
|
|
|
|
|
class CheckupInstitutionProjectCreateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
project_name: str = Field(..., alias="projectName")
|
|
project_fee: Optional[float] = Field(None, alias="projectFee")
|
|
status: Optional[str] = Field("1", alias="status")
|
|
order_num: Optional[int] = Field(0, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
class CheckupInstitutionProjectUpdateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
project_name: Optional[str] = Field(None, alias="projectName")
|
|
project_fee: Optional[float] = Field(None, alias="projectFee")
|
|
status: Optional[str] = Field(None, alias="status")
|
|
order_num: Optional[int] = Field(None, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
@router.get("/checkup-institutions/{institution_id}/projects")
|
|
async def list_checkup_institution_projects(
|
|
institution_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
items = ps_svc.list_checkup_institution_projects(db, institution_id, tenant_no=tenant_no, user_info=user)
|
|
return success_response(items)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.post("/checkup-institutions/{institution_id}/projects")
|
|
async def create_checkup_institution_project(
|
|
institution_id: str,
|
|
body: CheckupInstitutionProjectCreateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
obj = ps_svc.create_checkup_institution_project(
|
|
db,
|
|
checkup_institution_id=institution_id,
|
|
project_name=body.project_name,
|
|
project_fee=body.project_fee,
|
|
status=body.status,
|
|
tenant_no=tenant_no,
|
|
order_num=body.order_num,
|
|
remark=body.remark,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(ps_svc._row_to_dict_checkup_institution_project(obj), message="创建成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.put("/checkup-institution-projects/{project_id}")
|
|
async def update_checkup_institution_project(
|
|
project_id: str,
|
|
body: CheckupInstitutionProjectUpdateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
|
|
obj = ps_svc.update_checkup_institution_project(
|
|
db,
|
|
project_id,
|
|
project_name=payload.get("project_name"),
|
|
project_fee=payload.get("project_fee"),
|
|
status=payload.get("status"),
|
|
order_num=payload.get("order_num"),
|
|
remark=payload.get("remark"),
|
|
user_id=user.get("user_id"),
|
|
tenant_no=tenant_no,
|
|
)
|
|
return success_response(ps_svc._row_to_dict_checkup_institution_project(obj), message="更新成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.delete("/checkup-institution-projects/{project_id}")
|
|
async def delete_checkup_institution_project(
|
|
project_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
ps_svc.soft_delete_checkup_institution_project(db, project_id, tenant_no=tenant_no)
|
|
return success_response(None, message="删除成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# 7. 渠道服务购买订单
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class ServiceOrderProductItem(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
project_code: Optional[str] = Field(None, alias="projectCode")
|
|
project_name: Optional[str] = Field(None, alias="projectName")
|
|
cell_type: Optional[str] = Field(None, alias="cellType")
|
|
spec_text: Optional[str] = Field(None, alias="specText")
|
|
agreement_unit_price: Optional[float] = Field(None, alias="agreementUnitPrice")
|
|
buy_qty: Optional[float] = Field(None, alias="buyQty")
|
|
buy_amount: Optional[float] = Field(None, alias="buyAmount")
|
|
|
|
|
|
class ServiceOrderCreateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
channel_id: str = Field(..., alias="channelId")
|
|
order_type: str = Field(..., alias="orderType") # yfk / gmcp
|
|
order_name: Optional[str] = Field(None, alias="orderName")
|
|
dept_name: Optional[str] = Field(None, alias="deptName")
|
|
prepay_amount: Optional[float] = Field(None, alias="prepayAmount")
|
|
channel_agreement_id: Optional[str] = Field(None, alias="channelAgreementId")
|
|
products: Optional[List[ServiceOrderProductItem]] = None
|
|
remark: Optional[str] = None
|
|
|
|
|
|
class ServiceOrderUpdateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
dept_name: Optional[str] = Field(None, alias="deptName")
|
|
order_name: Optional[str] = Field(None, alias="orderName")
|
|
remark: Optional[str] = None
|
|
prepay_amount: Optional[float] = Field(None, alias="prepayAmount")
|
|
channel_agreement_id: Optional[str] = Field(None, alias="channelAgreementId")
|
|
products: Optional[List[ServiceOrderProductItem]] = None
|
|
|
|
|
|
class FinanceSubmitBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
finance_submit_remark: Optional[str] = Field(None, alias="financeSubmitRemark")
|
|
finance_submit_attachments: Optional[str] = Field(None, alias="financeSubmitAttachments")
|
|
|
|
|
|
class FinanceConfirmBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
finance_remark: Optional[str] = Field(None, alias="financeRemark")
|
|
finance_confirm_attachments: Optional[str] = Field(None, alias="financeConfirmAttachments")
|
|
|
|
|
|
class RefundSubmitBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
refund_amount: Optional[float] = Field(None, alias="refundAmount")
|
|
refund_remark: Optional[str] = Field(None, alias="refundRemark")
|
|
refund_attachments: Optional[str] = Field(None, alias="refundAttachments")
|
|
|
|
|
|
class RefundConfirmBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
refund_finance_remark: Optional[str] = Field(None, alias="refundFinanceRemark")
|
|
refund_finance_confirm_attachments: Optional[str] = Field(
|
|
None, alias="refundFinanceConfirmAttachments"
|
|
)
|
|
|
|
|
|
class TxnRechargeBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
amount: float = Field(..., gt=0, alias="amount")
|
|
remark: Optional[str] = Field(None, alias="remark")
|
|
finance_submit_attachments: Optional[str] = Field(None, alias="financeSubmitAttachments")
|
|
|
|
|
|
class TxnRefundBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
amount: float = Field(..., gt=0, alias="amount")
|
|
remark: Optional[str] = Field(None, alias="remark")
|
|
attachments: Optional[str] = Field(None, alias="attachments")
|
|
|
|
|
|
class TxnProductItem(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
project_code: Optional[str] = Field(None, alias="projectCode")
|
|
project_name: Optional[str] = Field(None, alias="projectName")
|
|
cell_type: Optional[str] = Field(None, alias="cellType")
|
|
spec_text: Optional[str] = Field(None, alias="specText")
|
|
agreement_unit_price: Optional[float] = Field(None, alias="agreementUnitPrice")
|
|
qty: Optional[float] = Field(None, alias="qty")
|
|
amount: Optional[float] = Field(None, alias="amount")
|
|
|
|
|
|
class TxnPurchaseBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
products: List[TxnProductItem] = Field(..., alias="products")
|
|
remark: Optional[str] = Field(None, alias="remark")
|
|
|
|
|
|
class TxnUnsubscribeBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
products: List[TxnProductItem] = Field(..., alias="products")
|
|
remark: Optional[str] = Field(None, alias="remark")
|
|
|
|
|
|
class TxnUpdateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
amount: Optional[float] = Field(None, gt=0, alias="amount")
|
|
remark: Optional[str] = Field(None, alias="remark")
|
|
finance_submit_attachments: Optional[str] = Field(None, alias="financeSubmitAttachments")
|
|
refund_attachments: Optional[str] = Field(None, alias="refundAttachments")
|
|
products: Optional[List[TxnProductItem]] = Field(None, alias="products")
|
|
|
|
|
|
class TxnFinanceSubmitBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
finance_submit_remark: Optional[str] = Field(None, alias="financeSubmitRemark")
|
|
finance_submit_attachments: Optional[str] = Field(None, alias="financeSubmitAttachments")
|
|
|
|
|
|
class TxnFinanceConfirmBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
finance_remark: Optional[str] = Field(None, alias="financeRemark")
|
|
finance_confirm_attachments: Optional[str] = Field(None, alias="financeConfirmAttachments")
|
|
|
|
|
|
@router.get("/channel-service-orders")
|
|
async def list_channel_service_orders(
|
|
page: int = Query(1, ge=1),
|
|
pageSize: int = Query(10, ge=1, le=100, alias="pageSize"),
|
|
orderType: Optional[str] = Query(None, alias="orderType"),
|
|
orderStatus: Optional[str] = Query(None, alias="orderStatus"),
|
|
channelId: Optional[str] = Query(None, alias="channelId"),
|
|
keyword: Optional[str] = None,
|
|
createTimeStart: Optional[str] = Query(None, alias="createTimeStart"),
|
|
createTimeEnd: Optional[str] = Query(None, alias="createTimeEnd"),
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
tenant_no = _get_tenant_no(db, user)
|
|
items, total = ps_svc.list_channel_service_orders(
|
|
db,
|
|
page=page,
|
|
page_size=pageSize,
|
|
order_type=orderType,
|
|
order_status=orderStatus,
|
|
channel_id=channelId,
|
|
keyword=keyword,
|
|
create_time_start=createTimeStart,
|
|
create_time_end=createTimeEnd,
|
|
tenant_no=tenant_no,
|
|
user_info=user,
|
|
)
|
|
tp = ps_svc.total_pages(total, pageSize)
|
|
return success_response(
|
|
{"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp}
|
|
)
|
|
|
|
|
|
@router.get("/channel-service-orders/{order_id}")
|
|
async def get_channel_service_order_detail(
|
|
order_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
order = ps_svc.get_service_order(db, order_id, tenant_no=tenant_no)
|
|
if not order:
|
|
return error_response(404, "订单不存在")
|
|
order_dict = ps_svc._row_to_dict_service_order(order, db, tenant_no)
|
|
user_ids = [x for x in (order.create_by, order.finance_submit_by) if x]
|
|
name_map = ps_svc._user_nick_name_map(db, user_ids)
|
|
order_dict["createByName"] = name_map.get(order.create_by or "", "") or (order.create_by or "")
|
|
order_dict["financeSubmitByName"] = name_map.get(order.finance_submit_by or "", "") or (
|
|
order.finance_submit_by or ""
|
|
)
|
|
products = ps_svc.get_service_order_products(db, order_id, tenant_no=tenant_no)
|
|
order_dict["products"] = products
|
|
txns, _ = ps_svc.list_service_order_txns(db, service_order_id=order_id, tenant_no=tenant_no, page_size=200)
|
|
order_dict["transactions"] = txns
|
|
if order.order_type == "gmcp":
|
|
has_lock = ps_svc._gmcp_has_purchase_lock(db, order_id, tenant_no)
|
|
order_dict["hasPurchaseTxn"] = has_lock
|
|
order_dict["agreementEditable"] = ps_svc.gmcp_agreement_editable(db, order, tenant_no)
|
|
else:
|
|
order_dict["hasPurchaseTxn"] = False
|
|
order_dict["agreementEditable"] = order.order_status == "dsx"
|
|
return success_response(order_dict)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.post("/channel-service-orders")
|
|
async def create_channel_service_order(
|
|
body: ServiceOrderCreateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
products_data = None
|
|
if body.products:
|
|
products_data = [p.model_dump(by_alias=False) for p in body.products]
|
|
order = ps_svc.create_channel_service_order(
|
|
db,
|
|
channel_id=body.channel_id,
|
|
order_type=body.order_type,
|
|
order_name=body.order_name,
|
|
dept_name=body.dept_name,
|
|
prepay_amount=body.prepay_amount,
|
|
channel_agreement_id=body.channel_agreement_id,
|
|
products=products_data,
|
|
tenant_no=tenant_no,
|
|
remark=body.remark,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
order_dict = ps_svc._row_to_dict_service_order(order, db, tenant_no)
|
|
order_dict["products"] = ps_svc.get_service_order_products(db, order.id, tenant_no=tenant_no)
|
|
return success_response(order_dict, message="创建成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.put("/channel-service-orders/{order_id}")
|
|
async def update_channel_service_order(
|
|
order_id: str,
|
|
body: ServiceOrderUpdateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
|
|
products_data = None
|
|
if "products" in payload:
|
|
products_data = payload.pop("products")
|
|
if products_data is not None:
|
|
products_data = [
|
|
p.model_dump(by_alias=False) if hasattr(p, "model_dump") else p
|
|
for p in (body.products or [])
|
|
]
|
|
obj = ps_svc.update_channel_service_order(
|
|
db,
|
|
order_id,
|
|
tenant_no=tenant_no,
|
|
user_id=user.get("user_id"),
|
|
products=products_data,
|
|
**payload,
|
|
)
|
|
return success_response(
|
|
ps_svc._row_to_dict_service_order(obj, db, tenant_no), message="更新成功"
|
|
)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.delete("/channel-service-orders/{order_id}")
|
|
async def delete_channel_service_order(
|
|
order_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
ps_svc.soft_delete_service_order(db, order_id, tenant_no=tenant_no)
|
|
return success_response(None, message="删除成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.post("/channel-service-orders/{order_id}/submit-finance-confirm")
|
|
async def submit_service_order_finance_confirm(
|
|
order_id: str,
|
|
body: FinanceSubmitBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
obj = ps_svc.submit_finance_confirm(
|
|
db,
|
|
order_id,
|
|
finance_submit_remark=body.finance_submit_remark,
|
|
finance_submit_attachments=body.finance_submit_attachments,
|
|
tenant_no=tenant_no,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(
|
|
ps_svc._row_to_dict_service_order(obj, db, tenant_no), message="已发起财务确认"
|
|
)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.post("/channel-service-orders/{order_id}/confirm-receipt")
|
|
async def confirm_service_order_receipt(
|
|
order_id: str,
|
|
body: FinanceConfirmBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
obj = ps_svc.confirm_receipt(
|
|
db,
|
|
order_id,
|
|
finance_remark=body.finance_remark,
|
|
finance_confirm_attachments=body.finance_confirm_attachments,
|
|
tenant_no=tenant_no,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(
|
|
ps_svc._row_to_dict_service_order(obj, db, tenant_no), message="确认收款成功"
|
|
)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.post("/channel-service-orders/{order_id}/submit-refund")
|
|
async def submit_service_order_refund(
|
|
order_id: str,
|
|
body: RefundSubmitBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
obj = ps_svc.submit_refund(
|
|
db,
|
|
order_id,
|
|
refund_amount=body.refund_amount,
|
|
refund_remark=body.refund_remark,
|
|
refund_attachments=body.refund_attachments,
|
|
tenant_no=tenant_no,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(
|
|
ps_svc._row_to_dict_service_order(obj, db, tenant_no), message="提交退款成功"
|
|
)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.post("/channel-service-orders/{order_id}/confirm-refund")
|
|
async def confirm_service_order_refund(
|
|
order_id: str,
|
|
body: RefundConfirmBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
obj = ps_svc.confirm_refund(
|
|
db,
|
|
order_id,
|
|
refund_finance_remark=body.refund_finance_remark,
|
|
refund_finance_confirm_attachments=body.refund_finance_confirm_attachments,
|
|
tenant_no=tenant_no,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(
|
|
ps_svc._row_to_dict_service_order(obj, db, tenant_no), message="确认退款成功"
|
|
)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.put("/channel-service-orders/{order_id}/void")
|
|
async def void_channel_service_order(
|
|
order_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
obj = ps_svc.void_service_order(
|
|
db,
|
|
order_id,
|
|
tenant_no=tenant_no,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(
|
|
ps_svc._row_to_dict_service_order(obj, db, tenant_no), message="作废成功"
|
|
)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.get("/channel-service-order-txns")
|
|
async def list_service_order_txns(
|
|
page: int = Query(1, ge=1),
|
|
pageSize: int = Query(20, ge=1, le=100, alias="pageSize"),
|
|
serviceOrderId: Optional[str] = Query(None, alias="serviceOrderId"),
|
|
txnStatus: Optional[str] = Query(None, alias="txnStatus"),
|
|
txnType: Optional[str] = Query(None, alias="txnType"),
|
|
keyword: Optional[str] = None,
|
|
createTimeStart: Optional[str] = Query(None, alias="createTimeStart"),
|
|
createTimeEnd: Optional[str] = Query(None, alias="createTimeEnd"),
|
|
financeDoneOnly: Optional[bool] = Query(False, alias="financeDoneOnly"),
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
tenant_no = _get_tenant_no(db, user)
|
|
items, total = ps_svc.list_service_order_txns(
|
|
db,
|
|
service_order_id=serviceOrderId,
|
|
txn_status=txnStatus,
|
|
txn_type=txnType,
|
|
keyword=keyword,
|
|
create_time_start=createTimeStart,
|
|
create_time_end=createTimeEnd,
|
|
finance_done_only=bool(financeDoneOnly),
|
|
page=page,
|
|
page_size=pageSize,
|
|
tenant_no=tenant_no,
|
|
)
|
|
tp = ps_svc.total_pages(total, pageSize)
|
|
return success_response(
|
|
{"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp}
|
|
)
|
|
|
|
|
|
@router.get("/channel-service-order-txns/{txn_id}")
|
|
async def get_service_order_txn_detail(
|
|
txn_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
txn = ps_svc.get_service_order_txn(db, txn_id, tenant_no=tenant_no)
|
|
if not txn:
|
|
return error_response(404, "流水不存在")
|
|
txn_dict = ps_svc._service_order_txn_to_response_dict(db, txn, tenant_no)
|
|
return success_response(txn_dict)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.post("/channel-service-orders/{order_id}/recharge")
|
|
async def create_recharge_txn(
|
|
order_id: str,
|
|
body: TxnRechargeBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
txn = ps_svc.create_recharge_txn(
|
|
db,
|
|
order_id,
|
|
amount=body.amount,
|
|
remark=body.remark,
|
|
finance_submit_attachments=body.finance_submit_attachments,
|
|
tenant_no=tenant_no,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(
|
|
ps_svc._row_to_dict_service_order_txn(txn, db, tenant_no), message="充值流水创建成功"
|
|
)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.post("/channel-service-orders/{order_id}/refund")
|
|
async def create_refund_txn(
|
|
order_id: str,
|
|
body: TxnRefundBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
txn = ps_svc.create_refund_txn(
|
|
db,
|
|
order_id,
|
|
amount=body.amount,
|
|
remark=body.remark,
|
|
attachments=body.attachments,
|
|
tenant_no=tenant_no,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(
|
|
ps_svc._row_to_dict_service_order_txn(txn, db, tenant_no), message="退款流水创建成功"
|
|
)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.post("/channel-service-orders/{order_id}/purchase")
|
|
async def create_purchase_txn(
|
|
order_id: str,
|
|
body: TxnPurchaseBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
products_data = [p.model_dump(by_alias=False) for p in body.products]
|
|
txn = ps_svc.create_purchase_txn(
|
|
db,
|
|
order_id,
|
|
products=products_data,
|
|
remark=body.remark,
|
|
tenant_no=tenant_no,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(
|
|
ps_svc._row_to_dict_service_order_txn(txn, db, tenant_no), message="购买产品流水创建成功"
|
|
)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.post("/channel-service-orders/{order_id}/unsubscribe")
|
|
async def create_unsubscribe_txn(
|
|
order_id: str,
|
|
body: TxnUnsubscribeBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
products_data = [p.model_dump(by_alias=False) for p in body.products]
|
|
txn = ps_svc.create_unsubscribe_txn(
|
|
db,
|
|
order_id,
|
|
products=products_data,
|
|
remark=body.remark,
|
|
tenant_no=tenant_no,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(
|
|
ps_svc._row_to_dict_service_order_txn(txn, db, tenant_no), message="退订产品流水创建成功"
|
|
)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.put("/channel-service-order-txns/{txn_id}")
|
|
async def update_service_order_txn(
|
|
txn_id: str,
|
|
body: TxnUpdateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
products_data = None
|
|
if body.products is not None:
|
|
products_data = [p.model_dump(by_alias=False) for p in body.products]
|
|
txn = ps_svc.update_service_order_txn(
|
|
db,
|
|
txn_id,
|
|
amount=body.amount,
|
|
remark=body.remark,
|
|
finance_submit_attachments=body.finance_submit_attachments,
|
|
refund_attachments=body.refund_attachments,
|
|
products=products_data,
|
|
tenant_no=tenant_no,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(
|
|
ps_svc._row_to_dict_service_order_txn(txn, db, tenant_no), message="更新成功"
|
|
)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.post("/channel-service-order-txns/{txn_id}/submit-finance")
|
|
async def submit_txn_finance(
|
|
txn_id: str,
|
|
body: TxnFinanceSubmitBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
txn = ps_svc.submit_txn_finance(
|
|
db,
|
|
txn_id,
|
|
finance_submit_remark=body.finance_submit_remark,
|
|
finance_submit_attachments=body.finance_submit_attachments,
|
|
tenant_no=tenant_no,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(
|
|
ps_svc._row_to_dict_service_order_txn(txn, db, tenant_no), message="已发起财务确认"
|
|
)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.post("/channel-service-order-txns/{txn_id}/confirm")
|
|
async def confirm_txn(
|
|
txn_id: str,
|
|
body: TxnFinanceConfirmBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
txn = ps_svc.confirm_txn(
|
|
db,
|
|
txn_id,
|
|
finance_remark=body.finance_remark,
|
|
finance_confirm_attachments=body.finance_confirm_attachments,
|
|
tenant_no=tenant_no,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(
|
|
ps_svc._service_order_txn_to_response_dict(db, txn, tenant_no),
|
|
message="财务确认成功",
|
|
)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.put("/channel-service-order-txns/{txn_id}/void")
|
|
async def void_txn(
|
|
txn_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
txn = ps_svc.void_txn(
|
|
db,
|
|
txn_id,
|
|
tenant_no=tenant_no,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(
|
|
ps_svc._service_order_txn_to_response_dict(db, txn, tenant_no),
|
|
message="作废成功",
|
|
)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.get("/channels/{channel_id}/account")
|
|
async def get_channel_account_info(
|
|
channel_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
account = ps_svc.get_channel_account(db, channel_id, tenant_no=tenant_no)
|
|
if not account:
|
|
return success_response({"channelId": channel_id, "balanceAmount": 0.0})
|
|
return success_response(ps_svc._row_to_dict_channel_account(account))
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.get("/channels/{channel_id}/product-quotas")
|
|
async def list_channel_product_quotas(
|
|
channel_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
items = ps_svc.list_channel_product_quotas(db, channel_id, tenant_no=tenant_no)
|
|
return success_response(items)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
# --- 体检机构项目套餐 ---
|
|
|
|
|
|
class CheckupPackageItemBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
checkup_institution_project_id: str = Field(..., alias="checkupInstitutionProjectId")
|
|
project_name: Optional[str] = Field(None, alias="projectName")
|
|
project_fee: Optional[float] = Field(None, alias="projectFee")
|
|
order_num: Optional[int] = Field(None, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
|
|
|
|
class CheckupInstitutionPackageCreateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
package_name: str = Field(..., alias="packageName")
|
|
package_code: str = Field(..., alias="packageCode")
|
|
status: Optional[str] = Field("1", alias="status")
|
|
order_num: Optional[int] = Field(0, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
items: List[CheckupPackageItemBody] = Field(default_factory=list)
|
|
|
|
|
|
class CheckupInstitutionPackageUpdateBody(BaseModel):
|
|
model_config = ConfigDict(populate_by_name=True)
|
|
|
|
package_name: Optional[str] = Field(None, alias="packageName")
|
|
package_code: Optional[str] = Field(None, alias="packageCode")
|
|
status: Optional[str] = Field(None, alias="status")
|
|
order_num: Optional[int] = Field(None, alias="orderNum")
|
|
remark: Optional[str] = None
|
|
items: Optional[List[CheckupPackageItemBody]] = None
|
|
|
|
|
|
def _package_items_to_crud(items) -> List[dict]:
|
|
out = []
|
|
for x in items:
|
|
if isinstance(x, dict):
|
|
out.append(
|
|
{
|
|
"checkup_institution_project_id": x.get("checkup_institution_project_id")
|
|
or x.get("checkupInstitutionProjectId"),
|
|
"project_name": x.get("project_name") or x.get("projectName"),
|
|
"project_fee": x.get("project_fee") if x.get("project_fee") is not None else x.get("projectFee"),
|
|
"order_num": x.get("order_num") if x.get("order_num") is not None else x.get("orderNum"),
|
|
"remark": x.get("remark"),
|
|
}
|
|
)
|
|
else:
|
|
out.append(
|
|
{
|
|
"checkup_institution_project_id": x.checkup_institution_project_id,
|
|
"project_name": x.project_name,
|
|
"project_fee": x.project_fee,
|
|
"order_num": x.order_num,
|
|
"remark": x.remark,
|
|
}
|
|
)
|
|
return out
|
|
|
|
|
|
@router.get("/checkup-institutions/{institution_id}/packages")
|
|
async def list_checkup_institution_packages(
|
|
institution_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
items = ps_svc.list_checkup_institution_packages(db, institution_id, tenant_no=tenant_no, user_info=user)
|
|
return success_response(items)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.post("/checkup-institutions/{institution_id}/packages")
|
|
async def create_checkup_institution_package(
|
|
institution_id: str,
|
|
body: CheckupInstitutionPackageCreateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
detail = ps_svc.create_checkup_institution_package(
|
|
db,
|
|
checkup_institution_id=institution_id,
|
|
package_name=body.package_name,
|
|
package_code=body.package_code,
|
|
status=body.status,
|
|
items=_package_items_to_crud(body.items),
|
|
tenant_no=tenant_no,
|
|
order_num=body.order_num,
|
|
remark=body.remark,
|
|
user_id=user.get("user_id"),
|
|
)
|
|
return success_response(detail, message="创建成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.get("/checkup-institution-packages/{package_id}")
|
|
async def get_checkup_institution_package_detail(
|
|
package_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
detail = ps_svc.get_checkup_institution_package_detail(db, package_id, tenant_no=tenant_no)
|
|
if not detail:
|
|
return error_response(404, "记录不存在")
|
|
return success_response(detail)
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.put("/checkup-institution-packages/{package_id}")
|
|
async def update_checkup_institution_package(
|
|
package_id: str,
|
|
body: CheckupInstitutionPackageUpdateBody,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
payload = body.model_dump(exclude_unset=True, by_alias=False)
|
|
items_raw = payload.pop("items", None)
|
|
items = _package_items_to_crud(items_raw) if items_raw is not None else None
|
|
detail = ps_svc.update_checkup_institution_package(
|
|
db,
|
|
package_id,
|
|
package_name=payload.get("package_name"),
|
|
package_code=payload.get("package_code"),
|
|
status=payload.get("status"),
|
|
items=items,
|
|
order_num=payload.get("order_num"),
|
|
remark=payload.get("remark"),
|
|
user_id=user.get("user_id"),
|
|
tenant_no=tenant_no,
|
|
)
|
|
return success_response(detail, message="更新成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|
|
|
|
|
|
@router.delete("/checkup-institution-packages/{package_id}")
|
|
async def delete_checkup_institution_package(
|
|
package_id: str,
|
|
user: dict = Depends(require_admin_or_super_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
tenant_no = _get_tenant_no(db, user)
|
|
ps_svc.soft_delete_checkup_institution_package(db, package_id, tenant_no=tenant_no)
|
|
return success_response(None, message="删除成功")
|
|
except ValueError as e:
|
|
return error_response(400, str(e))
|