"""运输计划管理 - 基础数据 API（承运商、车辆、人员）""" from datetime import datetime from typing import Any, List, Optional from fastapi import APIRouter, Depends, HTTPException, Query, Request, status from pydantic import BaseModel, ConfigDict, Field from sqlalchemy import case, func, or_ from sqlalchemy.orm import Session from app.utils.excel_export import ( EXPORT_MAX_ROWS, ExportColumn, ExportValidationError, export_rows_to_xlsx_response, filter_export_columns, ) from app.core.database import get_db from app.core.db_auth import DbUserContext, get_db_current_user from app.core.delete_guard import assert_row_deletable_by_creator, user_info_from_context from app.core.tenant_context import get_tenant_no from app.core.utils import generate_uuid from app.models.pl_models import ( PlCarrier, PlPersonnel, PlVehicle, PlVehicleDriver, PlVehiclePersonnel, ) from app.schemas.pl import ( CarrierAuditReject, CarrierCreate, CarrierListResponse, CarrierRead, CarrierUpdate, carrier_to_read, CertRead, DriverCreate, DriverListResponse, DriverRead, DriverUpdate, PersonnelCreate, PersonnelDetailRead, PersonnelListResponse, PersonnelRead, PersonnelUpdate, VehicleCreate, VehicleDetailRead, VehicleDriverCreate, VehicleListResponse, VehicleRead, VehicleUpdate, ) from app.services.pl_cert_service import ( certs_to_read, list_owner_certs, list_owner_certs_batch, nearest_expire_date, save_owner_certs, ) from app.services.pl_cert_required_service import ( validate_personnel_required_certs, validate_vehicle_save_certs, ) from app.services.pl_carrier_service import carrier_eligible_for_transport, normalize_carrier_urls from app.services.pl_personnel_service import ( load_vehicle_personnel_rows, load_vehicle_personnel_summaries, save_vehicle_personnel, ) from app.services.pl_personnel_user_bind import assert_sys_user_bind_available from app.schemas.pl.paste_recognize import PasteCommitBody, PasteCommitResult from app.services.pl_paste_recognize_service import commit_paste_recognize router = APIRouter(prefix="", tags=["运输计划-基础数据"]) 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 _body_to_params(body: BaseModel) -> dict: data = body.model_dump(by_alias=True, exclude_none=True) for key in ("ids", "columns"): data.pop(key, None) 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 _carrier_column_filter_kwargs(params: dict) -> dict: return dict( carrier_name=_param_get(params, "carrierName", "carrier_name"), carrier_name_in=_param_get(params, "carrierNameIn", "carrier_name_in"), contact_name=_param_get(params, "contactName", "contact_name"), contact_name_in=_param_get(params, "contactNameIn", "contact_name_in"), contact_phone=_param_get(params, "contactPhone", "contact_phone"), contact_phone_in=_param_get(params, "contactPhoneIn", "contact_phone_in"), status=_param_get(params, "status"), status_in=_param_get(params, "statusIn", "status_in"), remark=_param_get(params, "remark"), transport_agreement_expire_date_from=_param_get( params, "transportAgreementExpireDateFrom", "transport_agreement_expire_date_from", ), transport_agreement_expire_date_to=_param_get( params, "transportAgreementExpireDateTo", "transport_agreement_expire_date_to", ), ) def _vehicle_column_filter_kwargs(params: dict) -> dict: return dict( license_plate=_param_get(params, "licensePlate", "license_plate"), license_plate_in=_param_get(params, "licensePlateIn", "license_plate_in"), vehicle_status=_param_get(params, "vehicleStatus", "vehicle_status"), vehicle_status_in=_param_get(params, "vehicleStatusIn", "vehicle_status_in"), carrier_name=_param_get(params, "carrierName", "carrier_name"), remark=_param_get(params, "remark"), load_capacity_op=_param_get(params, "loadCapacityOp", "load_capacity_op"), load_capacity=_param_get(params, "loadCapacity", "load_capacity"), load_capacity_min=_param_get(params, "loadCapacityMin", "load_capacity_min"), load_capacity_max=_param_get(params, "loadCapacityMax", "load_capacity_max"), ) def _personnel_column_filter_kwargs(params: dict) -> dict: return dict( personnel_name=_param_get(params, "personnelName", "personnel_name"), personnel_name_in=_param_get(params, "personnelNameIn", "personnel_name_in"), phone_no=_param_get(params, "phoneNo", "phone_no"), phone_no_in=_param_get(params, "phoneNoIn", "phone_no_in"), status=_param_get(params, "status"), status_in=_param_get(params, "statusIn", "status_in"), personnel_type=_param_get(params, "personnelType", "personnel_type"), personnel_type_in=_param_get(params, "personnelTypeIn", "personnel_type_in"), id_card_no=_param_get(params, "idCardNo", "id_card_no"), remark=_param_get(params, "remark"), sys_user_name=_param_get(params, "sysUserName", "sys_user_name"), age_op=_param_get(params, "ageOp", "age_op"), age=_param_get(params, "age"), age_min=_param_get(params, "ageMin", "age_min"), age_max=_param_get(params, "ageMax", "age_max"), ) # ============================================================================= # 承运商 API # ============================================================================= class CarrierColumnFacetBody(BaseModel): """承运商列头可选值（去重；可附带列表上下文）""" model_config = ConfigDict(extra="allow") field: str = Field(..., description="carrierName | contactName | contactPhone") keyword: Optional[str] = Field(default=None, description="可选值关键字") limit: Optional[int] = Field(default=500, ge=1, le=500, description="返回条数上限") _CARRIER_FACET_COLUMNS = { "carrierName": PlCarrier.carrier_name, "contactName": PlCarrier.contact_name, "contactPhone": PlCarrier.contact_phone, } @router.post("/carrier/column-facet-values") def carrier_column_facet_values( body: CarrierColumnFacetBody, db: Session = Depends(get_db), user: DbUserContext = Depends(get_db_current_user), ): """承运商列头可选值：在列表上下文（排除本列）下去重。""" from app.services.column_facet import list_column_facet_values from app.services.pl.carrier_list_filters import build_carrier_column_filters from app.services.pl.facet_context import strip_simple_facet_self_params column = _CARRIER_FACET_COLUMNS.get(body.field) if column is None: raise HTTPException(status_code=400, detail="不支持的列") tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) params = strip_simple_facet_self_params(_body_to_params(body), body.field) extra_filters = build_carrier_column_filters( **_carrier_column_filter_kwargs(params) ) audit = _param_get(params, "auditStatus", "audit_status") if audit: extra_filters.append(PlCarrier.audit_status == audit) qv = _param_get(params, "q") if qv: extra_filters.append( or_( func.lower(PlCarrier.carrier_name).contains(str(qv).lower()), func.lower(PlCarrier.contact_name).contains(str(qv).lower()), PlCarrier.contact_phone.contains(str(qv)), ) ) rows = list_column_facet_values( db, PlCarrier, column, tenant_no=tenant_no, keyword=body.keyword, limit=body.limit if body.limit is not None else 500, extra_filters=extra_filters or None, ) return {"list": rows} class VehicleColumnFacetBody(BaseModel): """车辆列头可选值（去重；可附带列表上下文）""" model_config = ConfigDict(extra="allow") field: str = Field(..., description="licensePlate") keyword: Optional[str] = Field(default=None, description="可选值关键字") limit: Optional[int] = Field(default=500, ge=1, le=500, description="返回条数上限") _VEHICLE_FACET_COLUMNS = { "licensePlate": PlVehicle.license_plate, } @router.post("/vehicle/column-facet-values") def vehicle_column_facet_values( body: VehicleColumnFacetBody, db: Session = Depends(get_db), user: DbUserContext = Depends(get_db_current_user), ): """车辆列头可选值：在列表上下文（排除本列）下去重（含 vehicleType）。""" from app.services.column_facet import list_column_facet_values from app.services.pl.facet_context import strip_simple_facet_self_params from app.services.pl.vehicle_list_filters import build_vehicle_column_filters column = _VEHICLE_FACET_COLUMNS.get(body.field) if column is None: raise HTTPException(status_code=400, detail="不支持的列") tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) params = strip_simple_facet_self_params(_body_to_params(body), body.field) extra_filters = build_vehicle_column_filters( **_vehicle_column_filter_kwargs(params) ) vt = _param_get(params, "vehicleType", "vehicle_type") if vt: extra_filters.append(PlVehicle.vehicle_type == vt) cid = _param_get(params, "carrierId", "carrier_id") if cid: extra_filters.append(PlVehicle.carrier_id == cid) qv = _param_get(params, "q") if qv: extra_filters.append(PlVehicle.license_plate.contains(str(qv))) mine_flag = _param_get(params, "mineVehicles", "mine_vehicles") if mine_flag is True or ( mine_flag is not None and str(mine_flag).strip().lower() in {"1", "true", "yes", "y"} ): from app.services.pl_vehicle_mine_vehicles import ( license_plates_for_user_personnel, should_restrict_mine_vehicles, ) if should_restrict_mine_vehicles( db, tenant_no, user.id, mine_vehicles=True ): plates = license_plates_for_user_personnel(db, tenant_no, user.id) if not plates: return {"list": []} extra_filters.append(PlVehicle.license_plate.in_(list(plates))) rows = list_column_facet_values( db, PlVehicle, column, tenant_no=tenant_no, keyword=body.keyword, limit=body.limit if body.limit is not None else 500, extra_filters=extra_filters or None, ) return {"list": rows} class PersonnelColumnFacetBody(BaseModel): """人员列头可选值（去重；可附带列表上下文）""" model_config = ConfigDict(extra="allow") field: str = Field(..., description="personnelName | phoneNo") keyword: Optional[str] = Field(default=None, description="可选值关键字") limit: Optional[int] = Field(default=500, ge=1, le=500, description="返回条数上限") _PERSONNEL_FACET_COLUMNS = { "personnelName": PlPersonnel.personnel_name, "phoneNo": PlPersonnel.phone_no, } @router.post("/personnel/column-facet-values") def personnel_column_facet_values( body: PersonnelColumnFacetBody, db: Session = Depends(get_db), user: DbUserContext = Depends(get_db_current_user), ): """人员列头可选值：在列表上下文（排除本列）下去重（含 personnelAffiliation）。""" from app.services.column_facet import list_column_facet_values from app.services.pl.facet_context import strip_simple_facet_self_params from app.services.pl.personnel_list_filters import build_personnel_column_filters column = _PERSONNEL_FACET_COLUMNS.get(body.field) if column is None: raise HTTPException(status_code=400, detail="不支持的列") tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) params = strip_simple_facet_self_params(_body_to_params(body), body.field) extra_filters = build_personnel_column_filters( **_personnel_column_filter_kwargs(params) ) affiliation = _param_get(params, "personnelAffiliation", "personnel_affiliation") if affiliation: extra_filters.append(PlPersonnel.personnel_affiliation == affiliation) qv = _param_get(params, "q") if qv: extra_filters.append( or_( func.lower(PlPersonnel.personnel_name).contains(str(qv).lower()), PlPersonnel.phone_no.contains(str(qv)), ) ) rows = list_column_facet_values( db, PlPersonnel, column, tenant_no=tenant_no, keyword=body.keyword, limit=body.limit if body.limit is not None else 500, extra_filters=extra_filters or None, ) return {"list": rows} @router.get("/carrier", response_model=CarrierListResponse) def list_carriers( request: Request, q: Optional[str] = Query(default=None, description="模糊搜索"), status: Optional[str] = Query(default=None, description="状态"), audit_status: Optional[str] = Query(default=None, alias="auditStatus", description="审核状态"), 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), ) -> CarrierListResponse: tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) params = _merge_query(request, q=q, status=status, auditStatus=audit_status) query = db.query(PlCarrier).filter( PlCarrier.tenant_no == tenant_no, PlCarrier.del_flag == 0, ) audit = _param_get(params, "auditStatus", "audit_status") if audit: query = query.filter(PlCarrier.audit_status == audit) qv = _param_get(params, "q") if qv: query = query.filter( or_( func.lower(PlCarrier.carrier_name).contains(str(qv).lower()), func.lower(PlCarrier.contact_name).contains(str(qv).lower()), PlCarrier.contact_phone.contains(str(qv)), ) ) from app.services.pl.carrier_list_filters import build_carrier_column_filters column_filters = build_carrier_column_filters( **_carrier_column_filter_kwargs(params) ) if column_filters: query = query.filter(*column_filters) # 承运商为物流主数据，列表不做 create_by 数据范围过滤 query = query.order_by( case((PlCarrier.order_num.is_(None), 1), else_=0).asc(), PlCarrier.create_time.desc(), ) total = query.count() offset = (page - 1) * page_size rows = query.offset(offset).limit(page_size).all() return CarrierListResponse( total=total, list=[carrier_to_read(row) for row in rows], ) CARRIER_EXPORT_COLUMNS = [ ExportColumn(title="承运商名称", field="carrierName"), ExportColumn(title="联系人", field="contactName"), ExportColumn(title="联系电话", field="contactPhone"), ExportColumn(title="合作状态", field="statusLabel"), ExportColumn(title="资质提示", field="qualificationHint"), ExportColumn(title="协议有效期", field="transportAgreementExpireDate"), ExportColumn(title="备注", field="remark"), ] class CarrierExportBody(BaseModel): q: Optional[str] = None status: Optional[str] = None audit_status: Optional[str] = Field(default=None, alias="auditStatus") ids: Optional[List[str]] = None columns: Optional[List[str]] = None model_config = {"populate_by_name": True, "extra": "allow"} @router.post("/carrier/export") def export_carriers( body: CarrierExportBody, 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()) params = _body_to_params(body) query = db.query(PlCarrier).filter( PlCarrier.tenant_no == tenant_no, PlCarrier.del_flag == 0, ) audit = _param_get(params, "auditStatus", "audit_status") if audit: query = query.filter(PlCarrier.audit_status == audit) qv = _param_get(params, "q") if qv: query = query.filter( or_( func.lower(PlCarrier.carrier_name).contains(str(qv).lower()), func.lower(PlCarrier.contact_name).contains(str(qv).lower()), PlCarrier.contact_phone.contains(str(qv)), ) ) from app.services.pl.carrier_list_filters import build_carrier_column_filters column_filters = build_carrier_column_filters( **_carrier_column_filter_kwargs(params) ) if column_filters: query = query.filter(*column_filters) if body.ids: query = query.filter(PlCarrier.id.in_(body.ids)) query = query.order_by( case((PlCarrier.order_num.is_(None), 1), else_=0).asc(), PlCarrier.create_time.desc(), ) rows = query.limit(EXPORT_MAX_ROWS + 1).all() items = [] for row in rows: data = carrier_to_read(row).model_dump(by_alias=True) data["statusLabel"] = "合作中" if str(data.get("status")) == "1" else "已终止" if data.get("transportAgreementExpired"): data["qualificationHint"] = "协议已过期" elif data.get("qualificationComplete") is False: data["qualificationHint"] = "资质不全" else: data["qualificationHint"] = "资质齐全" items.append(data) requested = None if body.columns: requested = [] for key in body.columns: if key in ( "qualificationAttachments", "qualificationAttachment", "photoUrls", ): continue if key == "status": requested.append("statusLabel") elif key == "qualificationHint": requested.append("qualificationHint") else: requested.append(key) cols = filter_export_columns(CARRIER_EXPORT_COLUMNS, requested) date_str = datetime.now().strftime("%Y%m%d") return export_rows_to_xlsx_response( db, tenant_no=tenant_no, sheet_title="承运商列表", columns=cols, rows=items, filename_stem=f"承运商列表_{date_str}", ) except ExportValidationError as e: raise HTTPException(status_code=400, detail=str(e)) from e @router.post("/carrier", response_model=CarrierRead, status_code=status.HTTP_201_CREATED) def create_carrier( payload: CarrierCreate, db: Session = Depends(get_db), user: DbUserContext = Depends(get_db_current_user), ) -> CarrierRead: tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) carrier = PlCarrier( id=generate_uuid(), tenant_no=tenant_no, carrier_name=payload.carrier_name, contact_name=payload.contact_name, contact_phone=payload.contact_phone, status=payload.status, business_license_urls=normalize_carrier_urls(payload.business_license_urls), road_transport_license_urls=normalize_carrier_urls(payload.road_transport_license_urls), transport_agreement_urls=normalize_carrier_urls(payload.transport_agreement_urls), transport_agreement_expire_date=payload.transport_agreement_expire_date, audit_status="pending", remark=payload.remark, create_by=user.id, create_dept_id=user.dept_id, ) db.add(carrier) db.commit() db.refresh(carrier) return carrier_to_read(carrier) @router.get("/carrier/{id}", response_model=CarrierRead) def get_carrier( id: str, db: Session = Depends(get_db), user: DbUserContext = Depends(get_db_current_user), ) -> CarrierRead: tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) carrier = _get_carrier(db, tenant_no, id, user) return carrier_to_read(carrier) @router.put("/carrier/{id}", response_model=CarrierRead) def update_carrier( id: str, payload: CarrierUpdate, db: Session = Depends(get_db), user: DbUserContext = Depends(get_db_current_user), ) -> CarrierRead: tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) carrier = _get_carrier(db, tenant_no, id, user) payload_data = payload.model_dump(exclude_unset=True) for key in ( "business_license_urls", "road_transport_license_urls", "transport_agreement_urls", ): if key in payload_data: payload_data[key] = normalize_carrier_urls(payload_data[key]) for key, value in payload_data.items(): setattr(carrier, key, value) carrier.update_by = user.id db.commit() db.refresh(carrier) return carrier_to_read(carrier) @router.delete("/carrier/{id}", status_code=status.HTTP_204_NO_CONTENT) def delete_carrier( id: 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()) carrier = _get_carrier(db, tenant_no, id, user) assert_row_deletable_by_creator(carrier, user_info_from_context(user)) carrier.del_flag = 1 carrier.update_by = user.id db.commit() @router.post("/carrier/{id}/approve", response_model=CarrierRead) def approve_carrier( id: str, db: Session = Depends(get_db), user: DbUserContext = Depends(get_db_current_user), ) -> CarrierRead: raise HTTPException(status_code=400, detail="承运商审核流程已停用") @router.post("/carrier/{id}/reject", response_model=CarrierRead) def reject_carrier( id: str, payload: CarrierAuditReject, db: Session = Depends(get_db), user: DbUserContext = Depends(get_db_current_user), ) -> CarrierRead: raise HTTPException(status_code=400, detail="承运商审核流程已停用") def _get_carrier(db: Session, tenant_no: str, carrier_id: str, user: DbUserContext) -> PlCarrier: carrier = ( db.query(PlCarrier) .filter( PlCarrier.id == carrier_id, PlCarrier.tenant_no == tenant_no, PlCarrier.del_flag == 0, ) .first() ) if not carrier: raise HTTPException(status_code=404, detail="承运商不存在") return carrier # ============================================================================= # 车辆 API # ============================================================================= def _vehicle_to_read( vehicle: PlVehicle, summary: Optional[str] = None, default_driver_name: Optional[str] = None, *, cert_list: Optional[list[CertRead]] = None, ) -> VehicleRead: data = VehicleRead.model_validate(vehicle) if summary is not None: data.personnel_summary = summary if default_driver_name is not None: data.default_driver_name = default_driver_name if cert_list is not None: data.cert_list = cert_list return data def _vehicle_to_detail( db: Session, tenant_no: str, vehicle: PlVehicle ) -> VehicleDetailRead: summaries = load_vehicle_personnel_summaries(db, tenant_no, [vehicle.id]) summary, default_name = summaries.get(vehicle.id, ("", None)) personnel_list = load_vehicle_personnel_rows(db, tenant_no, vehicle.id) cert_list = certs_to_read( list_owner_certs(db, tenant_no, "vehicle", vehicle.id) ) base = _vehicle_to_read(vehicle, summary, default_name) return VehicleDetailRead( **base.model_dump(by_alias=False, exclude={"cert_list"}), personnel_list=personnel_list, cert_list=cert_list, ) @router.get("/vehicle", response_model=VehicleListResponse) def list_vehicles( request: Request, q: Optional[str] = Query(default=None, description="模糊搜索车牌号"), vehicle_type: Optional[str] = Query(default=None, alias="vehicleType", description="车辆类型"), carrier_id: Optional[str] = Query(default=None, alias="carrierId", description="承运商ID"), vehicle_status: Optional[str] = Query(default=None, alias="vehicleStatus", description="车辆状态"), exclude_ineligible_carrier: Optional[bool] = Query( default=False, alias="excludeIneligibleCarrier", description="排除资质不全或协议过期的承运商车辆", ), mine_vehicles: Optional[bool] = Query( default=None, alias="mineVehicles", description="仅返回当前用户关联驾押人员所挂靠车辆", ), 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), ) -> VehicleListResponse: tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) params = _merge_query( request, q=q, vehicleType=vehicle_type, carrierId=carrier_id, vehicleStatus=vehicle_status, mineVehicles=mine_vehicles, ) query = db.query(PlVehicle).filter( PlVehicle.tenant_no == tenant_no, PlVehicle.del_flag == 0, ) vt = _param_get(params, "vehicleType", "vehicle_type") if vt: query = query.filter(PlVehicle.vehicle_type == vt) cid = _param_get(params, "carrierId", "carrier_id") if cid: query = query.filter(PlVehicle.carrier_id == cid) qv = _param_get(params, "q") if qv: query = query.filter(PlVehicle.license_plate.contains(str(qv))) from app.services.pl.vehicle_list_filters import build_vehicle_column_filters column_filters = build_vehicle_column_filters( **_vehicle_column_filter_kwargs(params) ) if column_filters: query = query.filter(*column_filters) mine_flag = _param_get(params, "mineVehicles", "mine_vehicles") if mine_flag is True or ( mine_flag is not None and str(mine_flag).strip().lower() in {"1", "true", "yes", "y"} ): from app.services.pl_vehicle_mine_vehicles import ( license_plates_for_user_personnel, should_restrict_mine_vehicles, ) if should_restrict_mine_vehicles( db, tenant_no, user.id, mine_vehicles=True ): plates = license_plates_for_user_personnel(db, tenant_no, user.id) if not plates: return VehicleListResponse(total=0, list=[]) query = query.filter(PlVehicle.license_plate.in_(list(plates))) # 车辆为主数据，列表不做 create_by 数据范围过滤 query = query.order_by( case((PlVehicle.order_num.is_(None), 1), else_=0).asc(), PlVehicle.create_time.desc(), ) if exclude_ineligible_carrier: vehicles = query.all() carrier_ids = { v.carrier_id for v in vehicles if v.vehicle_type == "carrier" and v.carrier_id } carrier_map: dict[str, PlCarrier] = {} if carrier_ids: carriers = ( db.query(PlCarrier) .filter( PlCarrier.id.in_(carrier_ids), PlCarrier.tenant_no == tenant_no, PlCarrier.del_flag == 0, ) .all() ) carrier_map = {c.id: c for c in carriers} vehicles = [ v for v in vehicles if v.vehicle_type != "carrier" or not v.carrier_id or ( v.carrier_id in carrier_map and carrier_eligible_for_transport(carrier_map[v.carrier_id]) ) ] summaries = load_vehicle_personnel_summaries( db, tenant_no, [v.id for v in vehicles] ) certs_by_owner = list_owner_certs_batch( db, tenant_no, "vehicle", [v.id for v in vehicles] ) items = [ _vehicle_to_read( v, *summaries.get(v.id, ("", None)), cert_list=certs_to_read(certs_by_owner.get(v.id, [])), ) for v in vehicles ] return VehicleListResponse(total=len(items), list=items) total = query.count() offset = (page - 1) * page_size vehicles = query.offset(offset).limit(page_size).all() summaries = load_vehicle_personnel_summaries( db, tenant_no, [v.id for v in vehicles] ) certs_by_owner = list_owner_certs_batch( db, tenant_no, "vehicle", [v.id for v in vehicles] ) return VehicleListResponse( total=total, list=[ _vehicle_to_read( v, *summaries.get(v.id, ("", None)), cert_list=certs_to_read(certs_by_owner.get(v.id, [])), ) for v in vehicles ], ) VEHICLE_EXPORT_COLUMNS = [ ExportColumn(title="车牌号", field="licensePlate"), ExportColumn(title="关联人员", field="personnelSummary"), ExportColumn(title="车辆类型", field="vehicleTypeLabel"), ExportColumn(title="车辆状态", field="vehicleStatusLabel"), ExportColumn(title="载重(吨)", field="loadCapacity"), ExportColumn(title="承运商", field="carrierName"), ExportColumn(title="备注", field="remark"), ] _VEHICLE_TYPE_LABEL = {"self": "自有车", "carrier": "承运商车"} _VEHICLE_STATUS_LABEL = {"1": "启用", "0": "停用", "idle": "空闲", "busy": "在途", "maintain": "维保"} class VehicleExportBody(BaseModel): q: Optional[str] = None vehicle_type: Optional[str] = Field(default=None, alias="vehicleType") carrier_id: Optional[str] = Field(default=None, alias="carrierId") vehicle_status: Optional[str] = Field(default=None, alias="vehicleStatus") ids: Optional[List[str]] = None columns: Optional[List[str]] = None model_config = {"populate_by_name": True, "extra": "allow"} @router.post("/vehicle/export") def export_vehicles( body: VehicleExportBody, 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()) params = _body_to_params(body) query = db.query(PlVehicle).filter( PlVehicle.tenant_no == tenant_no, PlVehicle.del_flag == 0, ) vt = _param_get(params, "vehicleType", "vehicle_type") if vt: query = query.filter(PlVehicle.vehicle_type == vt) cid = _param_get(params, "carrierId", "carrier_id") if cid: query = query.filter(PlVehicle.carrier_id == cid) qv = _param_get(params, "q") if qv: query = query.filter(PlVehicle.license_plate.contains(str(qv))) from app.services.pl.vehicle_list_filters import build_vehicle_column_filters column_filters = build_vehicle_column_filters( **_vehicle_column_filter_kwargs(params) ) if column_filters: query = query.filter(*column_filters) if body.ids: query = query.filter(PlVehicle.id.in_(body.ids)) query = query.order_by( case((PlVehicle.order_num.is_(None), 1), else_=0).asc(), PlVehicle.create_time.desc(), ) vehicles = query.limit(EXPORT_MAX_ROWS + 1).all() summaries = load_vehicle_personnel_summaries(db, tenant_no, [v.id for v in vehicles]) items = [] for v in vehicles: data = _vehicle_to_read(v, *summaries.get(v.id, ("", None))).model_dump(by_alias=True) vt = str(data.get("vehicleType") or "") data["vehicleTypeLabel"] = _VEHICLE_TYPE_LABEL.get(vt, vt) vs = str(data.get("vehicleStatus") or "") data["vehicleStatusLabel"] = _VEHICLE_STATUS_LABEL.get(vs, vs) items.append(data) requested = None if body.columns: requested = [] for key in body.columns: if key in ("photoUrls", "certAttachments", "certList"): continue if key == "vehicleType": requested.append("vehicleTypeLabel") elif key == "vehicleStatus": requested.append("vehicleStatusLabel") else: requested.append(key) cols = filter_export_columns(VEHICLE_EXPORT_COLUMNS, requested) date_str = datetime.now().strftime("%Y%m%d") return export_rows_to_xlsx_response( db, tenant_no=tenant_no, sheet_title="车辆列表", columns=cols, rows=items, filename_stem=f"车辆列表_{date_str}", ) except ExportValidationError as e: raise HTTPException(status_code=400, detail=str(e)) from e @router.post("/vehicle", response_model=VehicleDetailRead, status_code=status.HTTP_201_CREATED) def create_vehicle( payload: VehicleCreate, db: Session = Depends(get_db), user: DbUserContext = Depends(get_db_current_user), ) -> VehicleDetailRead: tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) existing = ( db.query(PlVehicle) .filter( PlVehicle.license_plate == payload.license_plate, PlVehicle.del_flag == 0, ) .first() ) if existing: raise HTTPException(status_code=400, detail="车牌号已存在") validate_vehicle_save_certs( db, tenant_no, vehicle_type=payload.vehicle_type, trailer_no=payload.trailer_no, cert_rows=payload.cert_list, personnel_rows=payload.personnel_list, ) vehicle = PlVehicle( id=generate_uuid(), tenant_no=tenant_no, vehicle_type=payload.vehicle_type, carrier_id=payload.carrier_id, carrier_name=payload.carrier_name, license_plate=payload.license_plate, trailer_no=payload.trailer_no, load_capacity=payload.load_capacity, vehicle_status=payload.vehicle_status, photo_urls=payload.photo_urls, remark=payload.remark, create_by=user.id, create_dept_id=user.dept_id, ) db.add(vehicle) db.flush() try: save_vehicle_personnel( db, vehicle.id, payload.personnel_list, tenant_no, user_id=user.id, dept_id=user.dept_id, vehicle_type=payload.vehicle_type, ) save_owner_certs( db, "vehicle", vehicle.id, payload.cert_list, tenant_no, user_id=user.id, dept_id=user.dept_id, ) db.commit() except HTTPException: db.rollback() raise except Exception: db.rollback() raise db.refresh(vehicle) return _vehicle_to_detail(db, tenant_no, vehicle) @router.get("/vehicle/{id}", response_model=VehicleDetailRead) def get_vehicle( id: str, db: Session = Depends(get_db), user: DbUserContext = Depends(get_db_current_user), ) -> VehicleDetailRead: tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) vehicle = _get_vehicle(db, tenant_no, id, user) return _vehicle_to_detail(db, tenant_no, vehicle) @router.put("/vehicle/{id}", response_model=VehicleDetailRead) def update_vehicle( id: str, payload: VehicleUpdate, db: Session = Depends(get_db), user: DbUserContext = Depends(get_db_current_user), ) -> VehicleDetailRead: tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) vehicle = _get_vehicle(db, tenant_no, id, user) personnel_list = payload.personnel_list cert_list = payload.cert_list data = payload.model_dump( exclude_unset=True, exclude={"personnel_list", "cert_list"} ) effective_vehicle_type = data.get("vehicle_type", vehicle.vehicle_type) effective_trailer_no = data.get("trailer_no", vehicle.trailer_no) effective_cert_rows = ( cert_list if cert_list is not None else list_owner_certs(db, tenant_no, "vehicle", vehicle.id) ) effective_personnel_rows = personnel_list if effective_personnel_rows is None: effective_personnel_rows = load_vehicle_personnel_rows(db, tenant_no, vehicle.id) validate_vehicle_save_certs( db, tenant_no, vehicle_type=effective_vehicle_type, trailer_no=effective_trailer_no, cert_rows=effective_cert_rows, personnel_rows=effective_personnel_rows, ) for key, value in data.items(): setattr(vehicle, key, value) vehicle.update_by = user.id try: if personnel_list is not None: save_vehicle_personnel( db, vehicle.id, personnel_list, tenant_no, user_id=user.id, dept_id=user.dept_id, vehicle_type=effective_vehicle_type, ) if cert_list is not None: save_owner_certs( db, "vehicle", vehicle.id, cert_list, tenant_no, user_id=user.id, dept_id=user.dept_id, ) db.commit() except HTTPException: db.rollback() raise except Exception: db.rollback() raise db.refresh(vehicle) return _vehicle_to_detail(db, tenant_no, vehicle) @router.delete("/vehicle/{id}", status_code=status.HTTP_204_NO_CONTENT) def delete_vehicle( id: 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()) vehicle = _get_vehicle(db, tenant_no, id, user) assert_row_deletable_by_creator(vehicle, user_info_from_context(user)) vehicle.del_flag = 1 vehicle.update_by = user.id db.commit() def _get_vehicle(db: Session, tenant_no: str, vehicle_id: str, user: DbUserContext) -> PlVehicle: vehicle = ( db.query(PlVehicle) .filter( PlVehicle.id == vehicle_id, PlVehicle.tenant_no == tenant_no, PlVehicle.del_flag == 0, ) .first() ) if not vehicle: raise HTTPException(status_code=404, detail="车辆不存在") return vehicle # ============================================================================= # 人员 API # ============================================================================= def _personnel_to_read( db: Session, tenant_no: str, personnel: PlPersonnel, *, cert_list: Optional[list[CertRead]] = None, ) -> PersonnelRead: nearest = nearest_expire_date(db, tenant_no, "personnel", personnel.id) data = PersonnelRead.model_validate(personnel) data.nearest_expire_date = nearest if cert_list is not None: data.cert_list = cert_list return data def _assert_personnel_sys_user_bind( db: Session, tenant_no: str, *, personnel_id: str, sys_user_id: Optional[str], ) -> None: uid = (sys_user_id or "").strip() if not uid: return existing = ( db.query(PlPersonnel) .filter( PlPersonnel.tenant_no == tenant_no, PlPersonnel.sys_user_id == uid, PlPersonnel.del_flag == 0, ) .all() ) try: assert_sys_user_bind_available( existing=existing, personnel_id=personnel_id, sys_user_id=uid, ) except ValueError as exc: raise HTTPException(status_code=400, detail=str(exc)) from exc def _personnel_to_detail( db: Session, tenant_no: str, personnel: PlPersonnel ) -> PersonnelDetailRead: base = _personnel_to_read(db, tenant_no, personnel) cert_list = certs_to_read( list_owner_certs(db, tenant_no, "personnel", personnel.id) ) return PersonnelDetailRead( **base.model_dump(by_alias=False, exclude={"cert_list"}), cert_list=cert_list, ) @router.get("/personnel", response_model=PersonnelListResponse) def list_personnel( request: Request, q: Optional[str] = Query(default=None, description="模糊搜索姓名/手机号"), status: Optional[str] = Query(default=None, description="状态"), personnel_affiliation: Optional[str] = Query( default=None, alias="personnelAffiliation", description="人员归属 self/carrier" ), personnel_type: Optional[str] = Query( default=None, alias="personnelType", description="人员类型 driver/escort" ), 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), ) -> PersonnelListResponse: tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) params = _merge_query( request, q=q, status=status, personnelAffiliation=personnel_affiliation, personnelType=personnel_type, ) query = db.query(PlPersonnel).filter( PlPersonnel.tenant_no == tenant_no, PlPersonnel.del_flag == 0, ) affiliation = _param_get(params, "personnelAffiliation", "personnel_affiliation") if affiliation: query = query.filter(PlPersonnel.personnel_affiliation == affiliation) qv = _param_get(params, "q") if qv: query = query.filter( or_( func.lower(PlPersonnel.personnel_name).contains(str(qv).lower()), PlPersonnel.phone_no.contains(str(qv)), ) ) from app.services.pl.personnel_list_filters import build_personnel_column_filters column_filters = build_personnel_column_filters( **_personnel_column_filter_kwargs(params) ) if column_filters: query = query.filter(*column_filters) # 人员为主数据，列表不做 create_by 数据范围过滤 query = query.order_by( case((PlPersonnel.order_num.is_(None), 1), else_=0).asc(), PlPersonnel.create_time.desc(), ) total = query.count() offset = (page - 1) * page_size rows = query.offset(offset).limit(page_size).all() personnel_ids = [p.id for p in rows] certs_by_owner = list_owner_certs_batch(db, tenant_no, "personnel", personnel_ids) return PersonnelListResponse( total=total, list=[ _personnel_to_read( db, tenant_no, p, cert_list=certs_to_read(certs_by_owner.get(p.id, [])), ) for p in rows ], ) PERSONNEL_EXPORT_COLUMNS = [ ExportColumn(title="姓名", field="personnelName"), ExportColumn(title="人员归属", field="personnelAffiliationLabel"), ExportColumn(title="人员类型", field="personnelTypeLabel"), ExportColumn(title="手机号", field="phoneNo"), ExportColumn(title="年龄", field="age"), ExportColumn(title="身份证号", field="idCardNo"), ExportColumn(title="状态", field="statusLabel"), ExportColumn(title="最近到期", field="nearestExpireDate"), ExportColumn(title="备注", field="remark"), ] _AFFILIATION_LABEL = {"self": "自有", "carrier": "承运商"} _PERSONNEL_TYPE_LABEL = {"driver": "司机", "escort": "押运员"} class PersonnelExportBody(BaseModel): q: Optional[str] = None status: Optional[str] = None personnel_affiliation: Optional[str] = Field(default=None, alias="personnelAffiliation") personnel_type: Optional[str] = Field(default=None, alias="personnelType") ids: Optional[List[str]] = None columns: Optional[List[str]] = None model_config = {"populate_by_name": True, "extra": "allow"} @router.post("/personnel/export") def export_personnel( body: PersonnelExportBody, 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()) params = _body_to_params(body) query = db.query(PlPersonnel).filter( PlPersonnel.tenant_no == tenant_no, PlPersonnel.del_flag == 0, ) affiliation = _param_get(params, "personnelAffiliation", "personnel_affiliation") if affiliation: query = query.filter(PlPersonnel.personnel_affiliation == affiliation) qv = _param_get(params, "q") if qv: query = query.filter( or_( func.lower(PlPersonnel.personnel_name).contains(str(qv).lower()), PlPersonnel.phone_no.contains(str(qv)), ) ) from app.services.pl.personnel_list_filters import build_personnel_column_filters column_filters = build_personnel_column_filters( **_personnel_column_filter_kwargs(params) ) if column_filters: query = query.filter(*column_filters) if body.ids: query = query.filter(PlPersonnel.id.in_(body.ids)) query = query.order_by( case((PlPersonnel.order_num.is_(None), 1), else_=0).asc(), PlPersonnel.create_time.desc(), ) rows = query.limit(EXPORT_MAX_ROWS + 1).all() items = [] for p in rows: data = _personnel_to_read(db, tenant_no, p).model_dump(by_alias=True) af = str(data.get("personnelAffiliation") or "") data["personnelAffiliationLabel"] = _AFFILIATION_LABEL.get(af, af) pt = str(data.get("personnelType") or "") data["personnelTypeLabel"] = _PERSONNEL_TYPE_LABEL.get(pt, pt) st = str(data.get("status") or "") data["statusLabel"] = "启用" if st == "1" else ("停用" if st == "0" else st) items.append(data) requested = None if body.columns: requested = [] for key in body.columns: if key in ("photoUrls", "certAttachments", "certList"): continue if key == "personnelAffiliation": requested.append("personnelAffiliationLabel") elif key == "personnelType": requested.append("personnelTypeLabel") elif key == "status": requested.append("statusLabel") else: requested.append(key) cols = filter_export_columns(PERSONNEL_EXPORT_COLUMNS, requested) date_str = datetime.now().strftime("%Y%m%d") return export_rows_to_xlsx_response( db, tenant_no=tenant_no, sheet_title="人员列表", columns=cols, rows=items, filename_stem=f"人员列表_{date_str}", ) except ExportValidationError as e: raise HTTPException(status_code=400, detail=str(e)) from e @router.post("/personnel", response_model=PersonnelDetailRead, status_code=status.HTTP_201_CREATED) def create_personnel( payload: PersonnelCreate, db: Session = Depends(get_db), user: DbUserContext = Depends(get_db_current_user), ) -> PersonnelDetailRead: tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) validate_personnel_required_certs( payload.cert_list, payload.personnel_type, personnel_affiliation=payload.personnel_affiliation, subject_label=f"「{payload.personnel_name}」", ) personnel_id = generate_uuid() _assert_personnel_sys_user_bind( db, tenant_no, personnel_id=personnel_id, sys_user_id=payload.sys_user_id, ) personnel = PlPersonnel( id=personnel_id, tenant_no=tenant_no, personnel_name=payload.personnel_name, phone_no=payload.phone_no, age=payload.age, id_card_no=payload.id_card_no, personnel_type=payload.personnel_type, personnel_affiliation=payload.personnel_affiliation, status=payload.status, photo_urls=payload.photo_urls, sys_user_id=(payload.sys_user_id or "").strip() or None, remark=payload.remark, create_by=user.id, create_dept_id=user.dept_id, ) db.add(personnel) db.flush() try: save_owner_certs( db, "personnel", personnel.id, payload.cert_list, tenant_no, user_id=user.id, dept_id=user.dept_id, ) db.commit() except Exception: db.rollback() raise db.refresh(personnel) return _personnel_to_detail(db, tenant_no, personnel) @router.get("/personnel/{id}", response_model=PersonnelDetailRead) def get_personnel( id: str, db: Session = Depends(get_db), user: DbUserContext = Depends(get_db_current_user), ) -> PersonnelDetailRead: tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) personnel = _get_personnel(db, tenant_no, id, user) return _personnel_to_detail(db, tenant_no, personnel) @router.put("/personnel/{id}", response_model=PersonnelDetailRead) def update_personnel( id: str, payload: PersonnelUpdate, db: Session = Depends(get_db), user: DbUserContext = Depends(get_db_current_user), ) -> PersonnelDetailRead: tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) personnel = _get_personnel(db, tenant_no, id, user) cert_list = payload.cert_list data = payload.model_dump(exclude_unset=True, exclude={"cert_list"}) effective_personnel_type = data.get("personnel_type", personnel.personnel_type) effective_personnel_affiliation = data.get( "personnel_affiliation", personnel.personnel_affiliation ) effective_cert_rows = ( cert_list if cert_list is not None else list_owner_certs(db, tenant_no, "personnel", personnel.id) ) subject_name = data.get("personnel_name", personnel.personnel_name) validate_personnel_required_certs( effective_cert_rows, effective_personnel_type, personnel_affiliation=effective_personnel_affiliation, subject_label=f"「{subject_name}」", ) if "sys_user_id" in data: raw_uid = data.get("sys_user_id") data["sys_user_id"] = (raw_uid or "").strip() or None _assert_personnel_sys_user_bind( db, tenant_no, personnel_id=personnel.id, sys_user_id=data["sys_user_id"], ) for key, value in data.items(): setattr(personnel, key, value) personnel.update_by = user.id try: if cert_list is not None: save_owner_certs( db, "personnel", personnel.id, cert_list, tenant_no, user_id=user.id, dept_id=user.dept_id, ) db.commit() except Exception: db.rollback() raise db.refresh(personnel) return _personnel_to_detail(db, tenant_no, personnel) @router.delete("/personnel/{id}", status_code=status.HTTP_204_NO_CONTENT) def delete_personnel( id: 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()) personnel = _get_personnel(db, tenant_no, id, user) assert_row_deletable_by_creator(personnel, user_info_from_context(user)) personnel.del_flag = 1 personnel.update_by = user.id db.commit() def _get_personnel(db: Session, tenant_no: str, personnel_id: str, user: DbUserContext) -> PlPersonnel: personnel = ( db.query(PlPersonnel) .filter( PlPersonnel.id == personnel_id, PlPersonnel.tenant_no == tenant_no, PlPersonnel.del_flag == 0, ) .first() ) if not personnel: raise HTTPException(status_code=404, detail="人员不存在") return personnel # ============================================================================= # 司机 API（兼容别名，内部使用 pl_personnel） # ============================================================================= def _personnel_to_driver_read(personnel: PlPersonnel) -> DriverRead: return DriverRead( id=personnel.id, driver_name=personnel.personnel_name, phone_no=personnel.phone_no, id_card_no=personnel.id_card_no, tenant_no=personnel.tenant_no, order_num=personnel.order_num, remark=personnel.remark, create_by=personnel.create_by, create_dept_id=personnel.create_dept_id, create_time=personnel.create_time, update_by=personnel.update_by, update_time=personnel.update_time, del_flag=personnel.del_flag, ) @router.get("/driver", response_model=DriverListResponse) def list_drivers( q: Optional[str] = Query(default=None, description="模糊搜索姓名/手机号"), 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), ) -> DriverListResponse: tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) query = db.query(PlPersonnel).filter( PlPersonnel.tenant_no == tenant_no, PlPersonnel.del_flag == 0, ) if q: query = query.filter( or_( func.lower(PlPersonnel.personnel_name).contains(q.lower()), PlPersonnel.phone_no.contains(q), ) ) # 司机列表为主数据选项，不做 create_by 数据范围过滤 query = query.order_by( case((PlPersonnel.order_num.is_(None), 1), else_=0).asc(), PlPersonnel.create_time.desc(), ) total = query.count() offset = (page - 1) * page_size rows = query.offset(offset).limit(page_size).all() return DriverListResponse( total=total, list=[_personnel_to_driver_read(p) for p in rows], ) DRIVER_EXPORT_COLUMNS = [ ExportColumn(title="司机姓名", field="driverName"), ExportColumn(title="手机号", field="phoneNo"), ExportColumn(title="身份证号", field="idCardNo"), ExportColumn(title="备注", field="remark"), ] class DriverExportBody(BaseModel): q: Optional[str] = None ids: Optional[List[str]] = None columns: Optional[List[str]] = None @router.post("/driver/export") def export_drivers( body: DriverExportBody, 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()) query = db.query(PlPersonnel).filter( PlPersonnel.tenant_no == tenant_no, PlPersonnel.del_flag == 0, ) if body.q: query = query.filter( or_( func.lower(PlPersonnel.personnel_name).contains(body.q.lower()), PlPersonnel.phone_no.contains(body.q), ) ) if body.ids: query = query.filter(PlPersonnel.id.in_(body.ids)) query = query.order_by( case((PlPersonnel.order_num.is_(None), 1), else_=0).asc(), PlPersonnel.create_time.desc(), ) rows = query.limit(EXPORT_MAX_ROWS + 1).all() items = [_personnel_to_driver_read(p).model_dump(by_alias=True) for p in rows] cols = filter_export_columns(DRIVER_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=items, filename_stem=f"司机列表_{date_str}", ) except ExportValidationError as e: raise HTTPException(status_code=400, detail=str(e)) from e @router.post("/driver", response_model=DriverRead, status_code=status.HTTP_201_CREATED) def create_driver( payload: DriverCreate, db: Session = Depends(get_db), user: DbUserContext = Depends(get_db_current_user), ) -> DriverRead: tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) personnel = PlPersonnel( id=generate_uuid(), tenant_no=tenant_no, personnel_name=payload.driver_name, phone_no=payload.phone_no, id_card_no=payload.id_card_no, status="1", remark=payload.remark, create_by=user.id, create_dept_id=user.dept_id, ) db.add(personnel) db.commit() db.refresh(personnel) return _personnel_to_driver_read(personnel) @router.get("/driver/{id}", response_model=DriverRead) def get_driver( id: str, db: Session = Depends(get_db), user: DbUserContext = Depends(get_db_current_user), ) -> DriverRead: tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) personnel = _get_personnel(db, tenant_no, id, user) return _personnel_to_driver_read(personnel) @router.put("/driver/{id}", response_model=DriverRead) def update_driver( id: str, payload: DriverUpdate, db: Session = Depends(get_db), user: DbUserContext = Depends(get_db_current_user), ) -> DriverRead: tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) personnel = _get_personnel(db, tenant_no, id, user) if payload.driver_name is not None: personnel.personnel_name = payload.driver_name if payload.phone_no is not None: personnel.phone_no = payload.phone_no if payload.id_card_no is not None: personnel.id_card_no = payload.id_card_no if payload.remark is not None: personnel.remark = payload.remark personnel.update_by = user.id db.commit() db.refresh(personnel) return _personnel_to_driver_read(personnel) @router.delete("/driver/{id}", status_code=status.HTTP_204_NO_CONTENT) def delete_driver( id: 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()) personnel = _get_personnel(db, tenant_no, id, user) assert_row_deletable_by_creator(personnel, user_info_from_context(user)) personnel.del_flag = 1 personnel.update_by = user.id db.commit() # ============================================================================= # 车辆-司机绑定 API（兼容，写入 pl_vehicle_personnel） # ============================================================================= @router.post("/vehicle-driver", status_code=status.HTTP_201_CREATED) def bind_vehicle_driver( payload: VehicleDriverCreate, db: Session = Depends(get_db), user: DbUserContext = Depends(get_db_current_user), ) -> dict: tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) _get_vehicle(db, tenant_no, payload.vehicle_id, user) _get_personnel(db, tenant_no, payload.driver_id, user) if payload.is_default == 1: db.query(PlVehiclePersonnel).filter( PlVehiclePersonnel.vehicle_id == payload.vehicle_id, PlVehiclePersonnel.role == "driver", PlVehiclePersonnel.del_flag == 0, ).update({"is_default": 0}) vd = PlVehiclePersonnel( id=generate_uuid(), tenant_no=tenant_no, vehicle_id=payload.vehicle_id, personnel_id=payload.driver_id, role="driver", is_default=payload.is_default, create_by=user.id, create_dept_id=user.dept_id, ) db.add(vd) db.commit() return {"id": vd.id} @router.delete("/vehicle-driver/{id}", status_code=status.HTTP_204_NO_CONTENT) def unbind_vehicle_driver( id: 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()) vd = ( db.query(PlVehiclePersonnel) .filter( PlVehiclePersonnel.id == id, PlVehiclePersonnel.tenant_no == tenant_no, PlVehiclePersonnel.del_flag == 0, ) .first() ) if not vd: vd = ( db.query(PlVehicleDriver) .filter( PlVehicleDriver.id == id, PlVehicleDriver.tenant_no == tenant_no, PlVehicleDriver.del_flag == 0, ) .first() ) if vd: assert_row_deletable_by_creator(vd, user_info_from_context(user)) vd.del_flag = 1 db.commit() @router.post("/paste-recognize/commit", response_model=PasteCommitResult) def paste_recognize_commit( payload: PasteCommitBody, db: Session = Depends(get_db), user: DbUserContext = Depends(get_db_current_user), ) -> PasteCommitResult: tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) try: result = commit_paste_recognize( db, tenant_no, payload, user_id=user.id, dept_id=user.dept_id, ) db.commit() return result except HTTPException: db.rollback() raise except Exception: db.rollback() raise