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

"""中试服务体检管理 API（体检信息、预约项目、实际项目）"""
from typing import List, Optional

from fastapi import APIRouter, Depends, Query
from pydantic import BaseModel
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_checkup
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


# ---------------------------------------------------------------------------
# Pydantic Schemas
# ---------------------------------------------------------------------------


class IdBody(BaseModel):
    id: str


class CheckupSaveBody(BaseModel):
    application_id: str
    checkup_institution_id: Optional[str] = None
    reserve_time: Optional[str] = None
    reserve_fee: Optional[float] = None
    actual_checkup_time: Optional[str] = None
    actual_checkup_fee: Optional[float] = None
    checkup_remark: Optional[str] = None
    report_attachments: Optional[str] = None


class CheckupItemBody(BaseModel):
    project_name: str
    project_fee: Optional[float] = None


class CheckupItemsSaveBody(BaseModel):
    pilot_checkup_id: str
    items: List[CheckupItemBody]


# ---------------------------------------------------------------------------
# 1. 体检信息 CRUD + 状态变更
# ---------------------------------------------------------------------------


@router.get("/pilot-checkup/detail")
async def api_get_checkup_detail(
    application_id: str = Query(...),
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    result = pilot_checkup.get_checkup_by_application(
        db, application_id=application_id, tenant_no=tenant_no
    )
    if result is None:
        return success_response(None)
    return success_response(result)


@router.post("/pilot-checkup/save")
async def api_save_checkup(
    body: CheckupSaveBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        data = {
            "checkupInstitutionId": body.checkup_institution_id,
            "reserveTime": body.reserve_time,
            "reserveFee": body.reserve_fee,
            "actualCheckupTime": body.actual_checkup_time,
            "actualCheckupFee": body.actual_checkup_fee,
            "checkupRemark": body.checkup_remark,
            "reportAttachments": body.report_attachments,
        }
        existing = pilot_checkup.get_checkup_by_application(
            db, application_id=body.application_id, tenant_no=tenant_no
        )
        if existing:
            result = pilot_checkup.update_checkup(
                db, checkup_id=existing["id"], data=data, tenant_no=tenant_no
            )
            return success_response(result, message="更新成功")
        else:
            result = pilot_checkup.create_checkup(
                db,
                application_id=body.application_id,
                data=data,
                tenant_no=tenant_no,
                user_id=user.get("user_id"),
            )
            return success_response(result, message="创建成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.delete("/pilot-checkup/delete")
async def api_delete_checkup(
    body: IdBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        pilot_checkup.soft_delete_checkup(db, checkup_id=body.id, tenant_no=tenant_no)
        return success_response(None, message="删除成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.post("/pilot-checkup/mark-checked")
async def api_mark_checked(
    body: IdBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        result = pilot_checkup.mark_checkup_checked(
            db, checkup_id=body.id, tenant_no=tenant_no, user_id=user.get("user_id")
        )
        return success_response(result, message="操作成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.post("/pilot-checkup/settle-fee")
async def api_settle_fee(
    body: IdBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        result = pilot_checkup.settle_checkup_fee(
            db, checkup_id=body.id, tenant_no=tenant_no, user_id=user.get("user_id")
        )
        return success_response(result, message="结算成功")
    except ValueError as e:
        return error_response(400, str(e))


# ---------------------------------------------------------------------------
# 2. 预约项目
# ---------------------------------------------------------------------------


@router.get("/pilot-checkup/reserve-items")
async def api_list_reserve_items(
    pilot_checkup_id: str = Query(...),
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    result = pilot_checkup.list_reserve_items(
        db, checkup_id=pilot_checkup_id, tenant_no=tenant_no
    )
    return success_response(result)


@router.post("/pilot-checkup/reserve-items/save")
async def api_save_reserve_items(
    body: CheckupItemsSaveBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        items_json = [item.dict() for item in body.items]
        result = pilot_checkup.save_reserve_items(
            db,
            checkup_id=body.pilot_checkup_id,
            items_json=items_json,
            tenant_no=tenant_no,
            user_id=user.get("user_id"),
        )
        return success_response(result, message="保存成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.delete("/pilot-checkup/reserve-item/delete")
async def api_delete_reserve_item(
    body: IdBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        pilot_checkup.delete_reserve_item(db, item_id=body.id, tenant_no=tenant_no)
        return success_response(None, message="删除成功")
    except ValueError as e:
        return error_response(400, str(e))


# ---------------------------------------------------------------------------
# 3. 实际项目
# ---------------------------------------------------------------------------


@router.get("/pilot-checkup/actual-items")
async def api_list_actual_items(
    pilot_checkup_id: str = Query(...),
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    result = pilot_checkup.list_actual_items(
        db, checkup_id=pilot_checkup_id, tenant_no=tenant_no
    )
    return success_response(result)


@router.post("/pilot-checkup/actual-items/save")
async def api_save_actual_items(
    body: CheckupItemsSaveBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        items_json = [item.dict() for item in body.items]
        result = pilot_checkup.save_actual_items(
            db,
            checkup_id=body.pilot_checkup_id,
            items_json=items_json,
            tenant_no=tenant_no,
            user_id=user.get("user_id"),
        )
        return success_response(result, message="保存成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.delete("/pilot-checkup/actual-item/delete")
async def api_delete_actual_item(
    body: IdBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        pilot_checkup.delete_actual_item(db, item_id=body.id, tenant_no=tenant_no)
        return success_response(None, message="删除成功")
    except ValueError as e:
        return error_response(400, str(e))