shanxia2.0/backend/app/api/pilot_service.py

"""中试服务管理 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
    )
    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
    )
    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,
    )
    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
    )
    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)
        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
    )
    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)
        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)
        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)
        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)
        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")
    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")
    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,
    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, 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.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,
            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"),
            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)
        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)
        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))


# --- 体检机构项目套餐 ---


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)
        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))