shanxia/bx/bx-backend/app/routers/advance.py

from typing import List, Optional
from fastapi import APIRouter, Depends, HTTPException, status
from sqlalchemy import or_, func
from sqlalchemy.orm import Session

from app.database import get_db
from app.core.deps import get_current_user
from app.models.user import User
from app.models.advance import AdvanceApply
from app.models.reimburse import ReimburseOffset
from app.schemas.common import ApiResponse, PagedData
from app.schemas.advance import (
    AdvanceApplyCreate,
    AdvanceApplyUpdate,
    AdvanceApplyOut,
    AdvanceApprovalCreate,
    AdvanceApprovalOut,
    AdvanceMyStatsOut,
    AdvanceApproverPendingStatsOut,
)
from app.services.advance import AdvanceService
from app.services.expense_item import ExpenseItemService
from app.models.workflow import WorkflowDef
from app.utils.codegen import generate_apply_code
from app.utils.date_range import parse_create_time_day_bounds

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


@router.get("/", response_model=ApiResponse[PagedData[AdvanceApplyOut]])
def list_advances(
    page: int = 1,
    pageSize: int = 10,
    status: str | None = None,
    keyword: str = "",
    applicantId: Optional[int] = None,
    applyDate: Optional[str] = None,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    filters = [AdvanceApply.del_flag == 0]
    if status:
        filters.append(AdvanceApply.status == status)
    if keyword:
        filters.append(or_(AdvanceApply.apply_code.contains(keyword), AdvanceApply.applicant_name.contains(keyword)))
    if applicantId is not None:
        filters.append(AdvanceApply.applicant_id == applicantId)
    bounds = parse_create_time_day_bounds(applyDate)
    if bounds:
        d0, d1 = bounds
        filters.append(AdvanceApply.create_time >= d0)
        filters.append(AdvanceApply.create_time < d1)
    rows, total = AdvanceService.get_paged(db, page=page, page_size=pageSize, filters=filters)
    out_rows = [AdvanceApplyOut.model_validate(r) for r in rows]
    if out_rows:
        offset_map = dict(
            db.query(ReimburseOffset.advance_id, func.coalesce(func.sum(ReimburseOffset.offset_amount), 0))
            .filter(ReimburseOffset.advance_id.in_([r.id for r in rows]))
            .group_by(ReimburseOffset.advance_id)
            .all()
        )
        for out_row in out_rows:
            out_row.offset_amount = float(offset_map.get(out_row.id, 0))
    paged_data = PagedData(rows=out_rows, total=total, page=page, page_size=pageSize)
    return ApiResponse(data=paged_data)


@router.get("/my", response_model=ApiResponse[PagedData[AdvanceApplyOut]])
def my_advances(
    page: int = 1,
    pageSize: int = 10,
    status: str | None = None,
    keyword: str = "",
    applyDate: Optional[str] = None,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    filters = [AdvanceApply.del_flag == 0, AdvanceApply.applicant_id == current_user.id]
    if status:
        filters.append(AdvanceApply.status == status)
    if keyword:
        filters.append(or_(AdvanceApply.apply_code.contains(keyword), AdvanceApply.applicant_name.contains(keyword)))
    bounds = parse_create_time_day_bounds(applyDate)
    if bounds:
        d0, d1 = bounds
        filters.append(AdvanceApply.create_time >= d0)
        filters.append(AdvanceApply.create_time < d1)
    rows, total = AdvanceService.get_paged(db, page=page, page_size=pageSize, filters=filters)
    out_rows = [AdvanceApplyOut.model_validate(r) for r in rows]
    if out_rows:
        offset_map = dict(
            db.query(ReimburseOffset.advance_id, func.coalesce(func.sum(ReimburseOffset.offset_amount), 0))
            .filter(ReimburseOffset.advance_id.in_([r.id for r in rows]))
            .group_by(ReimburseOffset.advance_id)
            .all()
        )
        for out_row in out_rows:
            out_row.offset_amount = float(offset_map.get(out_row.id, 0))
    paged_data = PagedData(rows=out_rows, total=total, page=page, page_size=pageSize)
    return ApiResponse(data=paged_data)


@router.get("/my/stats", response_model=ApiResponse[AdvanceMyStatsOut])
def my_advance_stats(
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    data = AdvanceService.my_apply_stats(db, current_user.id)
    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),
    current_user: User = Depends(get_current_user),
):
    return ApiResponse(data=AdvanceService.global_status_counts(db))


@router.get("/pending-approval", response_model=ApiResponse[PagedData[AdvanceApplyOut]])
def pending_approval(
    page: int = 1,
    pageSize: int = 10,
    keyword: str = "",
    applicantId: Optional[int] = None,
    applyDate: Optional[str] = None,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    rows, total = AdvanceService.pending_approval(
        db,
        current_user,
        page=page,
        page_size=pageSize,
        keyword=keyword,
        applicant_id=applicantId,
        apply_date=applyDate,
    )
    out_rows = [AdvanceApplyOut.model_validate(r) for r in rows]
    paged_data = PagedData(rows=out_rows, total=total, page=page, page_size=pageSize)
    return ApiResponse(data=paged_data)


@router.get("/pending-approval/stats", response_model=ApiResponse[AdvanceApproverPendingStatsOut])
def advance_pending_approval_stats(
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    data = AdvanceService.pending_approval_stats(db, current_user)
    return ApiResponse(data=AdvanceApproverPendingStatsOut.model_validate(data))


@router.get("/approved-by-me", response_model=ApiResponse[PagedData[AdvanceApplyOut]])
def approved_by_me(
    page: int = 1,
    pageSize: int = 10,
    keyword: str = "",
    applicantId: Optional[int] = None,
    applyDate: Optional[str] = None,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    rows, total = AdvanceService.approved_by_me(
        db,
        current_user,
        page=page,
        page_size=pageSize,
        keyword=keyword,
        applicant_id=applicantId,
        apply_date=applyDate,
    )
    out_rows = [AdvanceApplyOut.model_validate(r) for r in rows]
    paged_data = PagedData(rows=out_rows, total=total, page=page, page_size=pageSize)
    return ApiResponse(data=paged_data)


@router.get("/{advance_id}", response_model=ApiResponse[AdvanceApplyOut])
def get_advance(advance_id: int, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
    advance = AdvanceService.get_by_id(db, advance_id)
    if not advance:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="备用金申请不存在")
    out = AdvanceApplyOut.model_validate(advance)
    total_offset = (
        db.query(func.coalesce(func.sum(ReimburseOffset.offset_amount), 0))
        .filter(ReimburseOffset.advance_id == advance_id)
        .scalar()
    )
    out.offset_amount = float(total_offset or 0)
    return ApiResponse(data=out)


@router.get("/{advance_id}/approvals", response_model=ApiResponse[List[AdvanceApprovalOut]])
def get_approvals(advance_id: int, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
    approvals = AdvanceService.get_approvals(db, advance_id)
    return ApiResponse(data=[AdvanceApprovalOut.model_validate(a) for a in approvals])


@router.post("/", response_model=ApiResponse[AdvanceApplyOut])
def create_advance(body: AdvanceApplyCreate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
    data = body.model_dump(exclude_unset=True)
    eid = data.get("expense_item_id")
    if eid is not None:
        if not ExpenseItemService.get_by_id(db, int(eid)):
            raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=f"费用项目 {eid} 不存在")
    data["applicant_id"] = current_user.id
    data["applicant_name"] = current_user.real_name or current_user.username
    data["apply_code"] = generate_apply_code(db, "BYJ")
    data["status"] = "draft"
    wf = db.query(WorkflowDef).filter(WorkflowDef.biz_type == "advance", WorkflowDef.del_flag == 0).first()
    if wf:
        data["wf_id"] = wf.id
    advance = AdvanceService.create(db, data)
    return ApiResponse(data=AdvanceApplyOut.model_validate(advance))


@router.put("/{advance_id}", response_model=ApiResponse[AdvanceApplyOut])
def update_advance(advance_id: int, body: AdvanceApplyUpdate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
    data = body.model_dump(exclude_unset=True)
    if "expense_item_id" in data and data["expense_item_id"] is not None:
        eid = int(data["expense_item_id"])
        if not ExpenseItemService.get_by_id(db, eid):
            raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=f"费用项目 {eid} 不存在")
    advance = AdvanceService.update(db, advance_id, data)
    if not advance:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="备用金申请不存在")
    return ApiResponse(data=AdvanceApplyOut.model_validate(advance))


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


@router.post("/{advance_id}/approve", response_model=ApiResponse[AdvanceApplyOut])
def approve_advance(advance_id: int, body: AdvanceApprovalCreate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
    advance = AdvanceService.approve(db, advance_id, current_user, body.approval_opinion or "")
    if not advance:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="备用金申请不存在")
    return ApiResponse(data=AdvanceApplyOut.model_validate(advance))


@router.post("/{advance_id}/reject", response_model=ApiResponse[AdvanceApplyOut])
def reject_advance(advance_id: int, body: AdvanceApprovalCreate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
    advance = AdvanceService.reject(db, advance_id, current_user, body.approval_opinion or "")
    if not advance:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="备用金申请不存在")
    return ApiResponse(data=AdvanceApplyOut.model_validate(advance))


@router.delete("/{advance_id}", response_model=ApiResponse[None])
def delete_advance(advance_id: int, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
    AdvanceService.soft_delete(db, advance_id)
    return ApiResponse(data=None)