shanxia2.0/backend/app/api/bx/advance.py

from typing import Any, List, Optional

from fastapi import APIRouter, Depends, HTTPException, Request, status, Query
from pydantic import BaseModel, ConfigDict, Field
from sqlalchemy import or_
from sqlalchemy.orm import Session

from app.api.bx.export_common import (
    EXPORT_MAX_ROWS,
    ExportColumn,
    ExportValidationError,
    BxApplyListExportBody,
    dump_export_row,
    respond_xlsx,
)
from app.core.bx_auth import BxUserContext, get_bx_current_user
from app.core.database import get_db
from app.core.tenant_context import get_tenant_no
from app.models.bx_models import BxAdvanceApply, BxWorkflowDef
from app.schemas.bx.advance import (
    AdvanceApplyCreate,
    AdvanceApplyOut,
    AdvanceApplyUpdate,
    AdvanceApprovalCreate,
    AdvanceApprovalOut,
    AdvanceApproverPendingStatsOut,
    AdvanceMyStatsOut,
)
from app.schemas.bx.common import ApiResponse, PagedData
from app.services.bx.advance import AdvanceService
from app.services.bx.advance_list_filters import build_advance_column_filters
from app.services.bx.expense_item import ExpenseItemService
from app.services.bx.list_sort import order_advance, parse_sort_params
from app.services.bx_data_scope import apply_bx_scope

router = APIRouter(prefix="/advances", tags=["备用金管理"])


def _tenant(db: Session, user: BxUserContext) -> str:
    return get_tenant_no(db, user.to_tenant_user_dict())


def _advance_order(params: dict):
    sf, so = parse_sort_params(params)
    return order_advance(sf, so)

def _fill_offset_amounts(db: Session, tenant_no: str, rows, out_rows: List[AdvanceApplyOut]) -> None:
    if not out_rows:
        return
    offset_map = AdvanceService.offset_amount_map(db, tenant_no, [r.id for r in rows])
    for out_row in out_rows:
        out_row.offset_amount = offset_map.get(out_row.id, 0.0)


ADVANCE_EXPORT_COLUMNS = [
    ExportColumn(title="申请单号", field="applyCode"),
    ExportColumn(title="申请时间", field="applyTime"),
    ExportColumn(title="申请人", field="applicantName"),
    ExportColumn(title="申请原因", field="reason"),
    ExportColumn(title="申请金额（元）", field="amount"),
    ExportColumn(title="实际发放金额（元）", field="actualAmount"),
    ExportColumn(title="冲抵总金额（元）", field="offsetAmount"),
    ExportColumn(title="状态", field="status"),
    ExportColumn(title="当前节点", field="currentNode"),
]


def _merge_query(request: Request, **known) -> dict:
    out = {k: v for k, v in known.items() if v is not None and v != ""}
    for k, v in request.query_params.multi_items():
        if k in ("page", "pageSize"):
            continue
        if k not in out and v not in (None, ""):
            out[k] = v
    return out


def _param_get(params: dict, *keys: str) -> Any:
    for key in keys:
        if key in params and params[key] not in (None, ""):
            return params[key]
    return None


def _filters_from_params(params: dict, *, tenant_no: str = "") -> list:
    ids = _param_get(params, "ids")
    if isinstance(ids, str):
        ids = [s.strip() for s in ids.split(",") if s.strip()]
    return build_advance_column_filters(
        tenant_no=tenant_no,
        keyword=str(_param_get(params, "keyword") or ""),
        status=_param_get(params, "status"),
        status_in=_param_get(params, "statusIn", "status_in"),
        apply_code=_param_get(params, "applyCode", "apply_code"),
        apply_code_in=_param_get(params, "applyCodeIn", "apply_code_in"),
        reason=_param_get(params, "reason"),
        reason_in=_param_get(params, "reasonIn", "reason_in"),
        applicant_id=_param_get(params, "applicantId", "applicant_id"),
        applicant_name=_param_get(params, "applicantName", "applicant_name"),
        applicant_name_in=_param_get(params, "applicantNameIn", "applicant_name_in"),
        current_node=_param_get(params, "currentNode", "current_node"),
        current_node_in=_param_get(params, "currentNodeIn", "current_node_in"),
        issue_by=_param_get(params, "issueBy", "issue_by"),
        issue_user_id=_param_get(params, "issueUserId", "issue_user_id"),
        issue_user_name=_param_get(params, "issueUserName", "issue_user_name"),
        issue_user_name_in=_param_get(params, "issueUserNameIn", "issue_user_name_in"),
        amount_op=_param_get(params, "amountOp", "amount_op"),
        amount=_param_get(params, "amount"),
        amount_min=_param_get(params, "amountMin", "amount_min"),
        amount_max=_param_get(params, "amountMax", "amount_max"),
        actual_amount_op=_param_get(params, "actualAmountOp", "actual_amount_op"),
        actual_amount=_param_get(params, "actualAmount", "actual_amount"),
        actual_amount_min=_param_get(params, "actualAmountMin", "actual_amount_min"),
        actual_amount_max=_param_get(params, "actualAmountMax", "actual_amount_max"),
        offset_amount_op=_param_get(params, "offsetAmountOp", "offset_amount_op"),
        offset_amount=_param_get(params, "offsetAmount", "offset_amount"),
        offset_amount_min=_param_get(params, "offsetAmountMin", "offset_amount_min"),
        offset_amount_max=_param_get(params, "offsetAmountMax", "offset_amount_max"),
        apply_date=_param_get(params, "applyDate", "apply_date"),
        apply_date_from=_param_get(params, "applyDateFrom", "apply_date_from"),
        apply_date_to=_param_get(params, "applyDateTo", "apply_date_to"),
        issue_time_from=_param_get(params, "issueTimeFrom", "issue_time_from"),
        issue_time_to=_param_get(params, "issueTimeTo", "issue_time_to"),
        ids=ids if isinstance(ids, list) else None,
    )


def _body_to_params(body: BxApplyListExportBody) -> dict:
    data = body.model_dump(by_alias=True, exclude_none=True)
    extra = getattr(body, "model_extra", None) or {}
    for key, value in extra.items():
        if key not in data and value not in (None, ""):
            data[key] = value
    return data


def _advance_list_filters(body: BxApplyListExportBody, *, tenant_no: str = "") -> list:
    return _filters_from_params(_body_to_params(body), tenant_no=tenant_no)


def _export_advance_rows(
    db: Session,
    tenant_no: str,
    rows,
    *,
    with_offset: bool = True,
) -> List[dict]:
    out_rows = [AdvanceApplyOut.model_validate(r) for r in rows]
    if with_offset:
        _fill_offset_amounts(db, tenant_no, rows, out_rows)
    return [dump_export_row(r) for r in out_rows]


class AdvanceColumnFacetBody(BaseModel):
    """备用金申请列头可选值（去重；可附带列表上下文）"""

    model_config = ConfigDict(populate_by_name=True, extra="allow")

    field: str = Field(..., description="applyCode | applicantName | reason | currentNode | issueUserName")
    scope: Optional[str] = Field(
        default=None,
        description=(
            "列表视图：pending/approved=审批；mine=我的申请；"
            "issue_pending/issue_issued=发放；省略则按通用数据权限"
        ),
    )
    keyword: Optional[str] = Field(default=None, description="列表快速搜索关键字")
    limit: Optional[int] = Field(default=500, ge=1, le=500, description="返回条数上限")


_ADVANCE_FACET_SCOPES = frozenset(
    {"pending", "approved", "mine", "issue_pending", "issue_issued"}
)

_ADVANCE_FACET_COLUMNS = {
    "applyCode": BxAdvanceApply.apply_code,
    "applicantName": BxAdvanceApply.applicant_name,
    "reason": BxAdvanceApply.reason,
    "currentNode": BxAdvanceApply.current_node,
    "issueUserName": BxAdvanceApply.issue_user_name,
}


@router.post("/column-facet-values", response_model=ApiResponse[dict])
def advance_column_facet_values(
    body: AdvanceColumnFacetBody,
    db: Session = Depends(get_db),
    user: BxUserContext = Depends(get_bx_current_user),
):
    """备用金申请列头可选值：在列表上下文（排除本列）下去重；可按列表视图 scope 收窄。"""
    from app.services.column_facet import list_column_facet_values
    from app.services.pl.facet_context import strip_simple_facet_self_params

    column = _ADVANCE_FACET_COLUMNS.get(body.field)
    if column is None:
        raise HTTPException(status_code=400, detail="不支持的列")
    tenant_no = _tenant(db, user)
    scope = (body.scope or "").strip() or None
    if scope and scope not in _ADVANCE_FACET_SCOPES:
        raise HTTPException(status_code=400, detail="不支持的 scope")
    list_keyword = (body.keyword or "").strip() or None
    params = strip_simple_facet_self_params(_body_to_params(body), body.field)
    params.pop("scope", None)
    params.pop("field", None)
    params.pop("limit", None)
    if list_keyword:
        params["keyword"] = list_keyword
    if scope in ("pending", "issue_pending", "issue_issued"):
        params.pop("status", None)
        params.pop("statusIn", None)
        params.pop("status_in", None)
    extra_filters = _filters_from_params(params, tenant_no=tenant_no)
    if scope:
        try:
            extra_filters = list(extra_filters) + [
                AdvanceService.list_scope_filter(db, user, tenant_no, scope)
            ]
        except ValueError as e:
            raise HTTPException(status_code=400, detail=str(e)) from e
    rows = list_column_facet_values(
        db,
        BxAdvanceApply,
        column,
        tenant_no=tenant_no,
        keyword=None,
        limit=body.limit if body.limit is not None else 500,
        apply_scope=(
            None
            if scope == "pending"
            else lambda query: apply_bx_scope(query, BxAdvanceApply, user, db, tenant_no)
        ),
        extra_filters=extra_filters or None,
    )
    return ApiResponse(data={"list": rows})


@router.get("/", response_model=ApiResponse[PagedData[AdvanceApplyOut]])
def list_advances(
    request: Request,
    page: int = 1,
    pageSize: int = Query(10, ge=1, le=500),
    status: Optional[str] = None,
    keyword: str = "",
    applicantId: Optional[str] = None,
    applyDate: Optional[str] = None,
    applyDateFrom: Optional[str] = None,
    applyDateTo: Optional[str] = None,
    db: Session = Depends(get_db),
    user: BxUserContext = Depends(get_bx_current_user),
):
    tenant_no = _tenant(db, user)
    params = _merge_query(
        request,
        status=status,
        keyword=keyword or None,
        applicantId=applicantId,
        applyDate=applyDate,
        applyDateFrom=applyDateFrom,
        applyDateTo=applyDateTo,
    )
    filters = _filters_from_params(params, tenant_no=tenant_no)
    rows, total = AdvanceService.get_paged(
        db,
        tenant_no,
        page=page,
        page_size=pageSize,
        filters=filters,
        user=user,
        order_by=_advance_order(params),
    )
    out_rows = [AdvanceApplyOut.model_validate(r) for r in rows]
    _fill_offset_amounts(db, tenant_no, rows, out_rows)
    return ApiResponse(data=PagedData(rows=out_rows, total=total, page=page, page_size=pageSize))


@router.get("/my", response_model=ApiResponse[PagedData[AdvanceApplyOut]])
def my_advances(
    request: Request,
    page: int = 1,
    pageSize: int = Query(10, ge=1, le=500),
    status: Optional[str] = None,
    keyword: str = "",
    applyDate: Optional[str] = None,
    applyDateFrom: Optional[str] = None,
    applyDateTo: Optional[str] = None,
    db: Session = Depends(get_db),
    user: BxUserContext = Depends(get_bx_current_user),
):
    tenant_no = _tenant(db, user)
    params = _merge_query(
        request,
        status=status,
        keyword=keyword or None,
        applyDate=applyDate,
        applyDateFrom=applyDateFrom,
        applyDateTo=applyDateTo,
    )
    filters = [
        or_(
            BxAdvanceApply.applicant_id == user.id,
            BxAdvanceApply.create_by == user.id,
        )
    ]
    filters.extend(_filters_from_params(params, tenant_no=tenant_no))
    rows, total = AdvanceService.get_paged(
        db,
        tenant_no,
        page=page,
        page_size=pageSize,
        filters=filters,
        user=user,
        order_by=_advance_order(params),
    )
    out_rows = [AdvanceApplyOut.model_validate(r) for r in rows]
    _fill_offset_amounts(db, tenant_no, rows, out_rows)
    return ApiResponse(data=PagedData(rows=out_rows, total=total, page=page, page_size=pageSize))


@router.get("/my/stats", response_model=ApiResponse[AdvanceMyStatsOut])
def my_advance_stats(
    db: Session = Depends(get_db),
    user: BxUserContext = Depends(get_bx_current_user),
):
    tenant_no = _tenant(db, user)
    data = AdvanceService.my_apply_stats(db, user, tenant_no)
    return ApiResponse(data=AdvanceMyStatsOut.model_validate(data))


@router.get("/stats/status-counts", response_model=ApiResponse[dict])
def advance_status_counts(
    db: Session = Depends(get_db),
    user: BxUserContext = Depends(get_bx_current_user),
):
    tenant_no = _tenant(db, user)
    return ApiResponse(data=AdvanceService.global_status_counts(db, tenant_no, user=user))


@router.get("/pending-approval", response_model=ApiResponse[PagedData[AdvanceApplyOut]])
def pending_approval(
    request: Request,
    page: int = 1,
    pageSize: int = Query(10, ge=1, le=500),
    keyword: str = "",
    applicantId: Optional[str] = None,
    applyDate: Optional[str] = None,
    applyDateFrom: Optional[str] = None,
    applyDateTo: Optional[str] = None,
    db: Session = Depends(get_db),
    user: BxUserContext = Depends(get_bx_current_user),
):
    tenant_no = _tenant(db, user)
    params = _merge_query(
        request,
        keyword=keyword or None,
        applicantId=applicantId,
        applyDate=applyDate,
        applyDateFrom=applyDateFrom,
        applyDateTo=applyDateTo,
    )
    # Tab 语义固定 pending；不把 status 列参传入 builder
    params.pop("status", None)
    params.pop("statusIn", None)
    params.pop("status_in", None)
    extra_filters = _filters_from_params(params, tenant_no=tenant_no)
    rows, total = AdvanceService.pending_approval(
        db,
        user,
        tenant_no,
        page=page,
        page_size=pageSize,
        extra_filters=extra_filters,
        order_by=_advance_order(params),
    )
    out_rows = [AdvanceApplyOut.model_validate(r) for r in rows]
    return ApiResponse(data=PagedData(rows=out_rows, total=total, page=page, page_size=pageSize))


@router.get("/pending-approval/stats", response_model=ApiResponse[AdvanceApproverPendingStatsOut])
def advance_pending_approval_stats(
    db: Session = Depends(get_db),
    user: BxUserContext = Depends(get_bx_current_user),
):
    tenant_no = _tenant(db, user)
    data = AdvanceService.pending_approval_stats(db, user, tenant_no)
    return ApiResponse(data=AdvanceApproverPendingStatsOut.model_validate(data))


@router.get("/approved-by-me", response_model=ApiResponse[PagedData[AdvanceApplyOut]])
def approved_by_me(
    request: Request,
    page: int = 1,
    pageSize: int = Query(10, ge=1, le=500),
    keyword: str = "",
    applicantId: Optional[str] = None,
    applyDate: Optional[str] = None,
    applyDateFrom: Optional[str] = None,
    applyDateTo: Optional[str] = None,
    db: Session = Depends(get_db),
    user: BxUserContext = Depends(get_bx_current_user),
):
    tenant_no = _tenant(db, user)
    params = _merge_query(
        request,
        keyword=keyword or None,
        applicantId=applicantId,
        applyDate=applyDate,
        applyDateFrom=applyDateFrom,
        applyDateTo=applyDateTo,
    )
    extra_filters = _filters_from_params(params, tenant_no=tenant_no)
    rows, total = AdvanceService.approved_by_me(
        db,
        user,
        tenant_no,
        page=page,
        page_size=pageSize,
        extra_filters=extra_filters,
        order_by=_advance_order(params),
    )
    out_rows = [AdvanceApplyOut.model_validate(r) for r in rows]
    return ApiResponse(data=PagedData(rows=out_rows, total=total, page=page, page_size=pageSize))


@router.post("/export")
def export_advances(
    body: BxApplyListExportBody,
    db: Session = Depends(get_db),
    user: BxUserContext = Depends(get_bx_current_user),
):
    try:
        tenant_no = _tenant(db, user)
        params = _body_to_params(body)
        filters = _filters_from_params(params, tenant_no=tenant_no)
        rows, _ = AdvanceService.get_paged(
            db,
            tenant_no,
            page=1,
            page_size=EXPORT_MAX_ROWS,
            filters=filters,
            user=user,
            order_by=_advance_order(params),
        )
        export_rows = _export_advance_rows(db, tenant_no, rows)
        return respond_xlsx(
            db,
            tenant_no=tenant_no,
            sheet_title="备用金申请",
            columns=ADVANCE_EXPORT_COLUMNS,
            rows=export_rows,
            filename_stem="备用金申请",
            requested_columns=body.columns,
        )
    except ExportValidationError as e:
        raise HTTPException(status_code=400, detail=str(e)) from e


@router.post("/my/export")
def export_my_advances(
    body: BxApplyListExportBody,
    db: Session = Depends(get_db),
    user: BxUserContext = Depends(get_bx_current_user),
):
    try:
        tenant_no = _tenant(db, user)
        params = _body_to_params(body)
        filters = [
            or_(
                BxAdvanceApply.applicant_id == user.id,
                BxAdvanceApply.create_by == user.id,
            )
        ]
        filters.extend(_filters_from_params(params, tenant_no=tenant_no))
        rows, _ = AdvanceService.get_paged(
            db,
            tenant_no,
            page=1,
            page_size=EXPORT_MAX_ROWS,
            filters=filters,
            user=user,
            order_by=_advance_order(params),
        )
        export_rows = _export_advance_rows(db, tenant_no, rows)
        return respond_xlsx(
            db,
            tenant_no=tenant_no,
            sheet_title="我的备用金",
            columns=ADVANCE_EXPORT_COLUMNS,
            rows=export_rows,
            filename_stem="我的备用金申请",
            requested_columns=body.columns,
        )
    except ExportValidationError as e:
        raise HTTPException(status_code=400, detail=str(e)) from e


@router.post("/pending-approval/export")
def export_pending_approval_advances(
    body: BxApplyListExportBody,
    db: Session = Depends(get_db),
    user: BxUserContext = Depends(get_bx_current_user),
):
    try:
        tenant_no = _tenant(db, user)
        params = _body_to_params(body)
        params.pop("status", None)
        params.pop("statusIn", None)
        params.pop("status_in", None)
        extra_filters = _filters_from_params(params, tenant_no=tenant_no)
        rows, _ = AdvanceService.pending_approval(
            db,
            user,
            tenant_no,
            page=1,
            page_size=EXPORT_MAX_ROWS,
            extra_filters=extra_filters,
            order_by=_advance_order(params),
        )
        export_rows = _export_advance_rows(db, tenant_no, rows, with_offset=False)
        return respond_xlsx(
            db,
            tenant_no=tenant_no,
            sheet_title="备用金待审批",
            columns=ADVANCE_EXPORT_COLUMNS,
            rows=export_rows,
            filename_stem="备用金待审批",
            requested_columns=body.columns,
        )
    except ExportValidationError as e:
        raise HTTPException(status_code=400, detail=str(e)) from e


@router.post("/approved-by-me/export")
def export_approved_by_me_advances(
    body: BxApplyListExportBody,
    db: Session = Depends(get_db),
    user: BxUserContext = Depends(get_bx_current_user),
):
    try:
        tenant_no = _tenant(db, user)
        params = _body_to_params(body)
        extra_filters = _filters_from_params(params, tenant_no=tenant_no)
        rows, _ = AdvanceService.approved_by_me(
            db,
            user,
            tenant_no,
            page=1,
            page_size=EXPORT_MAX_ROWS,
            extra_filters=extra_filters,
            order_by=_advance_order(params),
        )
        export_rows = _export_advance_rows(db, tenant_no, rows, with_offset=False)
        return respond_xlsx(
            db,
            tenant_no=tenant_no,
            sheet_title="备用金已审批",
            columns=ADVANCE_EXPORT_COLUMNS,
            rows=export_rows,
            filename_stem="备用金已审批",
            requested_columns=body.columns,
        )
    except ExportValidationError as e:
        raise HTTPException(status_code=400, detail=str(e)) from e


@router.get("/{advance_id}", response_model=ApiResponse[AdvanceApplyOut])
def get_advance(
    advance_id: str,
    db: Session = Depends(get_db),
    user: BxUserContext = Depends(get_bx_current_user),
):
    tenant_no = _tenant(db, user)
    advance = AdvanceService.get_by_id(db, advance_id, tenant_no, user=user)
    if not advance:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="备用金申请不存在")
    out = AdvanceApplyOut.model_validate(advance)
    offset_map = AdvanceService.offset_amount_map(db, tenant_no, [advance_id])
    out.offset_amount = offset_map.get(advance_id, 0.0)
    return ApiResponse(data=out)


@router.get("/{advance_id}/approvals", response_model=ApiResponse[List[AdvanceApprovalOut]])
def get_approvals(
    advance_id: str,
    db: Session = Depends(get_db),
    user: BxUserContext = Depends(get_bx_current_user),
):
    tenant_no = _tenant(db, user)
    if not AdvanceService.get_by_id(db, advance_id, tenant_no, user=user):
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="备用金申请不存在")
    approvals = AdvanceService.get_approvals(db, advance_id, tenant_no, user=user)
    return ApiResponse(data=[AdvanceApprovalOut.model_validate(a) for a in approvals])


@router.get("/{advance_id}/approval-history", response_model=ApiResponse[List[AdvanceApprovalOut]])
def get_approval_history(
    advance_id: str,
    db: Session = Depends(get_db),
    user: BxUserContext = Depends(get_bx_current_user),
):
    tenant_no = _tenant(db, user)
    if not AdvanceService.get_by_id(db, advance_id, tenant_no, user=user):
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="备用金申请不存在")
    history = AdvanceService.get_approval_history(db, advance_id, tenant_no, user=user)
    return ApiResponse(data=[AdvanceApprovalOut.model_validate(a) for a in history])


@router.post("/", response_model=ApiResponse[AdvanceApplyOut])
def create_advance(
    body: AdvanceApplyCreate,
    db: Session = Depends(get_db),
    user: BxUserContext = Depends(get_bx_current_user),
):
    tenant_no = _tenant(db, user)
    data = body.model_dump(exclude_unset=True)
    eid = data.get("expense_item_id")
    if eid:
        if not ExpenseItemService.get_by_id(db, eid, tenant_no, user=user, skip_scope=True):
            raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=f"费用项目 {eid} 不存在")
    data["applicant_id"] = user.id
    data["applicant_name"] = user.name
    data["status"] = "draft"
    wf = (
        db.query(BxWorkflowDef)
        .filter(
            BxWorkflowDef.biz_type == "advance",
            BxWorkflowDef.tenant_no == tenant_no,
            BxWorkflowDef.del_flag == 0,
        )
        .first()
    )
    if wf:
        data["wf_id"] = wf.id
    advance = AdvanceService.create(db, data, user=user)
    db.commit()
    db.refresh(advance)
    return ApiResponse(data=AdvanceApplyOut.model_validate(advance))


@router.put("/{advance_id}", response_model=ApiResponse[AdvanceApplyOut])
def update_advance(
    advance_id: str,
    body: AdvanceApplyUpdate,
    db: Session = Depends(get_db),
    user: BxUserContext = Depends(get_bx_current_user),
):
    tenant_no = _tenant(db, user)
    data = body.model_dump(exclude_unset=True)
    if data.get("expense_item_id"):
        eid = data["expense_item_id"]
        if not ExpenseItemService.get_by_id(db, eid, tenant_no, user=user, skip_scope=True):
            raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=f"费用项目 {eid} 不存在")
    advance = AdvanceService.update(db, advance_id, data, user=user)
    if not advance:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="备用金申请不存在")
    db.commit()
    db.refresh(advance)
    return ApiResponse(data=AdvanceApplyOut.model_validate(advance))


@router.post("/{advance_id}/submit", response_model=ApiResponse[AdvanceApplyOut])
def submit_advance(
    advance_id: str,
    db: Session = Depends(get_db),
    user: BxUserContext = Depends(get_bx_current_user),
):
    advance = AdvanceService.submit(db, advance_id, user)
    if not advance:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="备用金申请不存在")
    db.commit()
    db.refresh(advance)
    return ApiResponse(data=AdvanceApplyOut.model_validate(advance))


@router.post("/{advance_id}/approve", response_model=ApiResponse[AdvanceApplyOut])
def approve_advance(
    advance_id: str,
    body: AdvanceApprovalCreate,
    db: Session = Depends(get_db),
    user: BxUserContext = Depends(get_bx_current_user),
):
    advance = AdvanceService.approve(db, advance_id, user, body.approval_opinion or "")
    if not advance:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="备用金申请不存在或无权审批")
    db.commit()
    db.refresh(advance)
    return ApiResponse(data=AdvanceApplyOut.model_validate(advance))


@router.post("/{advance_id}/reject", response_model=ApiResponse[AdvanceApplyOut])
def reject_advance(
    advance_id: str,
    body: AdvanceApprovalCreate,
    db: Session = Depends(get_db),
    user: BxUserContext = Depends(get_bx_current_user),
):
    advance = AdvanceService.reject(db, advance_id, user, body.approval_opinion or "")
    if not advance:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="备用金申请不存在或无权审批")
    db.commit()
    db.refresh(advance)
    return ApiResponse(data=AdvanceApplyOut.model_validate(advance))


@router.post("/{advance_id}/withdraw", response_model=ApiResponse[AdvanceApplyOut])
def withdraw_advance(
    advance_id: str,
    db: Session = Depends(get_db),
    user: BxUserContext = Depends(get_bx_current_user),
):
    advance = AdvanceService.withdraw(db, advance_id, user)
    if not advance:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="备用金申请不存在、非本人申请或当前状态不可撤回",
        )
    db.commit()
    db.refresh(advance)
    return ApiResponse(data=AdvanceApplyOut.model_validate(advance))


@router.delete("/{advance_id}", response_model=ApiResponse[None])
def delete_advance(
    advance_id: str,
    db: Session = Depends(get_db),
    user: BxUserContext = Depends(get_bx_current_user),
):
    tenant_no = _tenant(db, user)
    if not AdvanceService.get_by_id(db, advance_id, tenant_no, user=user):
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="备用金申请不存在")
    AdvanceService.soft_delete(db, advance_id, user=user)
    db.commit()
    return ApiResponse(data=None)