shanxia2.0/backend/app/api/pl/vehicle_maintenance.py

"""车辆维保 API"""
from datetime import date
from datetime import datetime
from typing import List, Optional

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

from app.core.database import get_db
from app.core.db_auth import DbUserContext, get_db_current_user
from app.core.tenant_context import get_tenant_no
from app.utils.excel_export import (
    EXPORT_MAX_ROWS,
    ExportColumn,
    ExportValidationError,
    export_rows_to_xlsx_response,
    filter_export_columns,
)
from app.schemas.pl.vehicle_maintenance import (
    VehicleMaintenanceApplyCreate,
    VehicleMaintenanceApplyListResponse,
    VehicleMaintenanceApplyRead,
    VehicleMaintenanceApplyReminder,
    VehicleMaintenanceApplyUpdate,
    VehicleMaintenanceProcessBoardListResponse,
    VehicleMaintenanceProcessCreate,
    VehicleMaintenanceProcessRead,
    VehicleMaintenanceProcessUpdate,
)
from app.services import pl_vehicle_maintenance_service as svc

apply_router = APIRouter(prefix="/vehicle-maintenance-apply", tags=["运输计划-车辆维保申请"])
process_router = APIRouter(prefix="/vehicle-maintenance-process", tags=["运输计划-车辆维保处理"])


@apply_router.get("/", response_model=VehicleMaintenanceApplyListResponse)
def list_applies(
    q: Optional[str] = Query(default=None),
    maintenance_type: Optional[str] = Query(default=None, alias="maintenanceType"),
    status: Optional[str] = Query(default=None),
    apply_date_from: Optional[date] = Query(default=None, alias="applyDateFrom"),
    apply_date_to: Optional[date] = Query(default=None, alias="applyDateTo"),
    applicant_id: Optional[str] = Query(default=None, alias="applicantId"),
    page: int = Query(default=1, ge=1),
    page_size: int = Query(default=20, ge=1, le=500, alias="pageSize"),
    db: Session = Depends(get_db),
    user: DbUserContext = Depends(get_db_current_user),
) -> VehicleMaintenanceApplyListResponse:
    tenant_no = get_tenant_no(db, user.to_tenant_user_dict())
    items, total = svc.list_applies(
        db,
        tenant_no,
        user,
        q=q,
        maintenance_type=maintenance_type,
        status=status,
        apply_date_from=apply_date_from,
        apply_date_to=apply_date_to,
        applicant_id=applicant_id,
        page=page,
        page_size=page_size,
    )
    return VehicleMaintenanceApplyListResponse(
        items=items, total=total, page=page, pageSize=page_size
    )


@apply_router.get("/reminders", response_model=list[VehicleMaintenanceApplyReminder])
def list_reminders(
    license_plate: str = Query(..., alias="licensePlate"),
    exclude_apply_id: Optional[str] = Query(default=None, alias="excludeApplyId"),
    db: Session = Depends(get_db),
    user: DbUserContext = Depends(get_db_current_user),
) -> list[VehicleMaintenanceApplyReminder]:
    tenant_no = get_tenant_no(db, user.to_tenant_user_dict())
    return svc.list_reminders(
        db,
        tenant_no,
        user,
        license_plate,
        exclude_apply_id=exclude_apply_id,
    )



MAINT_APPLY_EXPORT_COLUMNS = [
    ExportColumn(title="申请单号", field="applyNo"),
    ExportColumn(title="车牌号", field="licensePlate"),
    ExportColumn(title="维保类型", field="maintenanceType"),
    ExportColumn(title="申请日期", field="applyDate"),
    ExportColumn(title="开始日期", field="startDate"),
    ExportColumn(title="预计取车", field="expectedPickupDate"),
    ExportColumn(title="申请人", field="applicantName"),
    ExportColumn(title="状态", field="status"),
    ExportColumn(title="创建时间", field="createTime"),
]


class MaintenanceApplyExportBody(BaseModel):
    q: Optional[str] = None
    maintenance_type: Optional[str] = Field(default=None, alias="maintenanceType")
    status: Optional[str] = None
    apply_date_from: Optional[date] = Field(default=None, alias="applyDateFrom")
    apply_date_to: Optional[date] = Field(default=None, alias="applyDateTo")
    ids: Optional[List[str]] = None
    columns: Optional[List[str]] = None

    model_config = {"populate_by_name": True}


@apply_router.post("/export")
def export_applies(
    body: MaintenanceApplyExportBody,
    db: Session = Depends(get_db),
    user: DbUserContext = Depends(get_db_current_user),
):
    """导出维保申请列表（当前筛选全量，或 ids 已选）。"""
    try:
        tenant_no = get_tenant_no(db, user.to_tenant_user_dict())
        items, _ = svc.list_applies(
            db,
            tenant_no,
            user,
            q=body.q,
            maintenance_type=body.maintenance_type,
            status=body.status,
            apply_date_from=body.apply_date_from,
            apply_date_to=body.apply_date_to,
            ids=body.ids,
            page=1,
            page_size=EXPORT_MAX_ROWS,
            max_page_size=EXPORT_MAX_ROWS,
        )
        rows = []
        for item in items:
            data = item.model_dump(by_alias=True)
            for k in ("applyDate", "startDate", "expectedPickupDate", "createTime"):
                if data.get(k) is not None:
                    data[k] = str(data[k])[:19]
            rows.append(data)
        cols = filter_export_columns(MAINT_APPLY_EXPORT_COLUMNS, body.columns)
        date_str = datetime.now().strftime("%Y%m%d")
        return export_rows_to_xlsx_response(
            db,
            tenant_no=tenant_no,
            sheet_title="维保申请",
            columns=cols,
            rows=rows,
            filename_stem=f"维保申请_{date_str}",
        )
    except ExportValidationError as e:
        raise HTTPException(status_code=400, detail=str(e)) from e


@apply_router.get("/{id}", response_model=VehicleMaintenanceApplyRead)
def get_apply(
    id: str,
    db: Session = Depends(get_db),
    user: DbUserContext = Depends(get_db_current_user),
) -> VehicleMaintenanceApplyRead:
    tenant_no = get_tenant_no(db, user.to_tenant_user_dict())
    return svc.get_apply(db, tenant_no, user, id)


@apply_router.post("/", response_model=VehicleMaintenanceApplyRead, status_code=status.HTTP_201_CREATED)
def create_apply(
    payload: VehicleMaintenanceApplyCreate,
    db: Session = Depends(get_db),
    user: DbUserContext = Depends(get_db_current_user),
) -> VehicleMaintenanceApplyRead:
    tenant_no = get_tenant_no(db, user.to_tenant_user_dict())
    return svc.create_apply(db, tenant_no, user, payload)


@apply_router.put("/{id}", response_model=VehicleMaintenanceApplyRead)
def update_apply(
    id: str,
    payload: VehicleMaintenanceApplyUpdate,
    db: Session = Depends(get_db),
    user: DbUserContext = Depends(get_db_current_user),
) -> VehicleMaintenanceApplyRead:
    tenant_no = get_tenant_no(db, user.to_tenant_user_dict())
    return svc.update_apply(db, tenant_no, user, id, payload)


@apply_router.post("/{id}/cancel", response_model=VehicleMaintenanceApplyRead)
def cancel_apply(
    id: str,
    db: Session = Depends(get_db),
    user: DbUserContext = Depends(get_db_current_user),
) -> VehicleMaintenanceApplyRead:
    tenant_no = get_tenant_no(db, user.to_tenant_user_dict())
    return svc.cancel_apply(db, tenant_no, user, id)


@apply_router.delete("/{ids}", status_code=status.HTTP_204_NO_CONTENT)
def delete_applies(
    ids: str,
    db: Session = Depends(get_db),
    user: DbUserContext = Depends(get_db_current_user),
) -> None:
    tenant_no = get_tenant_no(db, user.to_tenant_user_dict())
    apply_ids = [item for item in ids.split(",") if item]
    svc.delete_applies(db, tenant_no, user, apply_ids)


@process_router.get("/process-board", response_model=VehicleMaintenanceProcessBoardListResponse)
def list_process_board(
    q: Optional[str] = Query(default=None),
    maintenance_type: Optional[str] = Query(default=None, alias="maintenanceType"),
    apply_status: Optional[str] = Query(default=None, alias="applyStatus"),
    apply_date_from: Optional[date] = Query(default=None, alias="applyDateFrom"),
    apply_date_to: Optional[date] = Query(default=None, alias="applyDateTo"),
    process_date_from: Optional[date] = Query(default=None, alias="processDateFrom"),
    process_date_to: Optional[date] = Query(default=None, alias="processDateTo"),
    page: int = Query(default=1, ge=1),
    page_size: int = Query(default=20, ge=1, le=500, alias="pageSize"),
    db: Session = Depends(get_db),
    user: DbUserContext = Depends(get_db_current_user),
) -> VehicleMaintenanceProcessBoardListResponse:
    tenant_no = get_tenant_no(db, user.to_tenant_user_dict())
    items, total = svc.list_process_board(
        db,
        tenant_no,
        user,
        q=q,
        maintenance_type=maintenance_type,
        apply_status=apply_status,
        apply_date_from=apply_date_from,
        apply_date_to=apply_date_to,
        process_date_from=process_date_from,
        process_date_to=process_date_to,
        page=page,
        page_size=page_size,
    )
    return VehicleMaintenanceProcessBoardListResponse(
        items=items, total=total, page=page, pageSize=page_size
    )



MAINT_PROCESS_EXPORT_COLUMNS = [
    ExportColumn(title="申请单号", field="applyNo"),
    ExportColumn(title="申请日期", field="applyDate"),
    ExportColumn(title="申请人", field="applicantName"),
    ExportColumn(title="申请状态", field="applyStatus"),
    ExportColumn(title="车牌号", field="licensePlate"),
    ExportColumn(title="维保类型", field="maintenanceType"),
    ExportColumn(title="处理单号", field="processNo"),
    ExportColumn(title="处理日期", field="processDate"),
    ExportColumn(title="处理人", field="handlerName"),
    ExportColumn(title="金额(元)", field="amount"),
]


class MaintProcessExportBody(BaseModel):
    q: Optional[str] = None
    maintenance_type: Optional[str] = Field(default=None, alias="maintenanceType")
    apply_status: Optional[str] = Field(default=None, alias="applyStatus")
    apply_date_from: Optional[date] = Field(default=None, alias="applyDateFrom")
    apply_date_to: Optional[date] = Field(default=None, alias="applyDateTo")
    process_date_from: Optional[date] = Field(default=None, alias="processDateFrom")
    process_date_to: Optional[date] = Field(default=None, alias="processDateTo")
    ids: Optional[List[str]] = None
    columns: Optional[List[str]] = None
    model_config = {"populate_by_name": True}


@process_router.post("/process-board/export")
def export_process_board(
    body: MaintProcessExportBody,
    db: Session = Depends(get_db),
    user: DbUserContext = Depends(get_db_current_user),
):
    try:
        tenant_no = get_tenant_no(db, user.to_tenant_user_dict())
        items, _ = svc.list_process_board(
            db, tenant_no, user,
            q=body.q, maintenance_type=body.maintenance_type, apply_status=body.apply_status,
            apply_date_from=body.apply_date_from, apply_date_to=body.apply_date_to,
            process_date_from=body.process_date_from, process_date_to=body.process_date_to,
            ids=body.ids, page=1, page_size=EXPORT_MAX_ROWS, max_page_size=EXPORT_MAX_ROWS,
        )

        rows = []
        for item in items:
            data = item.model_dump(by_alias=True)
            for k, v in list(data.items()):
                if hasattr(v, 'isoformat'):
                    data[k] = str(v)[:19]
            rows.append(data)

        cols = filter_export_columns(MAINT_PROCESS_EXPORT_COLUMNS, body.columns)
        date_str = datetime.now().strftime("%Y%m%d")
        return export_rows_to_xlsx_response(
            db, tenant_no=tenant_no, sheet_title="维保过程", columns=cols, rows=rows,
            filename_stem=f"维保过程_{date_str}",
        )
    except ExportValidationError as e:
        raise HTTPException(status_code=400, detail=str(e)) from e


@process_router.get("/{id}", response_model=VehicleMaintenanceProcessRead)
def get_process(
    id: str,
    db: Session = Depends(get_db),
    user: DbUserContext = Depends(get_db_current_user),
) -> VehicleMaintenanceProcessRead:
    tenant_no = get_tenant_no(db, user.to_tenant_user_dict())
    return svc.get_process(db, tenant_no, user, id)


@process_router.post("/", response_model=VehicleMaintenanceProcessRead, status_code=status.HTTP_201_CREATED)
def create_process(
    payload: VehicleMaintenanceProcessCreate,
    db: Session = Depends(get_db),
    user: DbUserContext = Depends(get_db_current_user),
) -> VehicleMaintenanceProcessRead:
    tenant_no = get_tenant_no(db, user.to_tenant_user_dict())
    return svc.create_process(db, tenant_no, user, payload)


@process_router.put("/{id}", response_model=VehicleMaintenanceProcessRead)
def update_process(
    id: str,
    payload: VehicleMaintenanceProcessUpdate,
    db: Session = Depends(get_db),
    user: DbUserContext = Depends(get_db_current_user),
) -> VehicleMaintenanceProcessRead:
    tenant_no = get_tenant_no(db, user.to_tenant_user_dict())
    return svc.update_process(db, tenant_no, user, id, payload)


@process_router.delete("/{ids}", status_code=status.HTTP_204_NO_CONTENT)
def delete_processes(
    ids: str,
    db: Session = Depends(get_db),
    user: DbUserContext = Depends(get_db_current_user),
) -> None:
    tenant_no = get_tenant_no(db, user.to_tenant_user_dict())
    process_ids = [item for item in ids.split(",") if item]
    svc.delete_processes(db, tenant_no, user, process_ids)