from typing import Any, List, Optional, Tuple from datetime import date, datetime from fastapi import APIRouter, Depends, HTTPException, Query, Request, status from fastapi.responses import JSONResponse from pydantic import BaseModel, Field from sqlalchemy import func, or_ 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.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.services.db_data_scope import apply_db_scope, assert_db_row_in_scope from app.models.db_models import DbInboundOutbound, DbPurchasePlan, DbWeighingSlip from app.schemas.db.inventory import InboundOutboundRead from app.schemas.db.plans import ( PurchasePlanCreate, PurchasePlanListResponse, PurchasePlanRead, PurchasePlanUpdate, PurchasePlanWithFillLink, ) from app.schemas.db.weighing import WeighingSlipRead from app.services.db.mappers import ( inventory_to_read, load_user_display_name_map, parse_date_str, parse_datetime_str, plan_to_read, plan_to_read_with_fill_link, weighing_to_read, ) from app.services.db.plan_list_filters import build_plan_column_filters from app.services.db.product_helpers import ( apply_product_snapshot_to_plan, resolve_crm_product, ) from app.utils.excel_export import ( EXPORT_MAX_ROWS, ExportColumn, ExportValidationError, export_rows_to_xlsx_response, filter_export_columns, ) router = APIRouter(prefix="/plans", tags=["plans"]) STATUS_THIRD_PARTY_FILL = "待三方填写" _PLAN_DATE_FIELDS = {"plan_date", "start_date", "end_date"} _PLAN_REMARK_FIELD = "remarks" def _base_query(db: Session, tenant_no: str): return db.query(DbPurchasePlan).filter( DbPurchasePlan.tenant_no == tenant_no, DbPurchasePlan.del_flag == 0, ) 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) -> list: return build_plan_column_filters( plan_no=_param_get(params, "planNo", "plan_no"), customer_name=_param_get(params, "customerName", "customer_name"), product=_param_get(params, "product"), specification=_param_get(params, "specification"), business_type=_param_get(params, "businessType", "business_type"), business_type_in=_param_get(params, "businessTypeIn", "business_type_in"), execution_status=_param_get(params, "executionStatus", "execution_status"), execution_status_in=_param_get(params, "executionStatusIn", "execution_status_in"), planned_quantity_op=_param_get(params, "plannedQuantityOp", "planned_quantity_op"), planned_quantity=_param_get(params, "plannedQuantity", "planned_quantity"), planned_quantity_min=_param_get(params, "plannedQuantityMin", "planned_quantity_min"), planned_quantity_max=_param_get(params, "plannedQuantityMax", "planned_quantity_max"), executed_quantity_op=_param_get(params, "executedQuantityOp", "executed_quantity_op"), executed_quantity=_param_get(params, "executedQuantity", "executed_quantity"), executed_quantity_min=_param_get(params, "executedQuantityMin", "executed_quantity_min"), executed_quantity_max=_param_get(params, "executedQuantityMax", "executed_quantity_max"), created_from=_param_get(params, "createdFrom", "created_from"), created_to=_param_get(params, "createdTo", "created_to"), start_date_from=_param_get(params, "startDateFrom", "start_date_from"), start_date_to=_param_get(params, "startDateTo", "start_date_to"), ) def _body_to_params(body: "PlanExportBody") -> dict: data = body.model_dump(by_alias=True, exclude_none=True) data.pop("ids", None) data.pop("columns", 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 _plans_query(db: Session, user: DbUserContext, params: dict): tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) query = _base_query(db, tenant_no).order_by(DbPurchasePlan.create_time.desc()) q = _param_get(params, "q") if q: keyword = str(q).lower() query = query.filter( or_( func.lower(DbPurchasePlan.customer_name).contains(keyword), func.lower(DbPurchasePlan.product).contains(keyword), func.lower(DbPurchasePlan.plan_no).contains(keyword), ) ) column_filters = _filters_from_params(params) if column_filters: query = query.filter(*column_filters) return apply_db_scope(query, DbPurchasePlan, user, db, tenant_no), tenant_no def _map_plans( db: Session, tenant_no: str, plans: list ) -> list[PurchasePlanWithFillLink]: if not plans: return [] plan_ids = [p.id for p in plans] fill_links = ( db.query(DbInboundOutbound) .filter( DbInboundOutbound.tenant_no == tenant_no, DbInboundOutbound.del_flag == 0, DbInboundOutbound.purchase_plan_id.in_(plan_ids), DbInboundOutbound.status == STATUS_THIRD_PARTY_FILL, ) .all() ) plan_id_to_inv_id = { inv.purchase_plan_id: inv.id for inv in fill_links if inv.purchase_plan_id } plan_nos = [p.plan_no for p in plans if p.plan_no] executed_sum_map: dict[tuple[Optional[str], Optional[str]], float] = {} if plan_ids or plan_nos: weighing_filters = [DbWeighingSlip.is_voided == 0, DbWeighingSlip.del_flag == 0] weighing_filters.append(DbWeighingSlip.tenant_no == tenant_no) id_filters = [] if plan_ids: id_filters.append(DbWeighingSlip.purchase_plan_id.in_(plan_ids)) if plan_nos: id_filters.append(DbWeighingSlip.plan_no.in_(plan_nos)) weighing_filters.append(or_(*id_filters)) weighing_rows = ( db.query( DbWeighingSlip.purchase_plan_id, DbWeighingSlip.plan_no, func.sum(DbWeighingSlip.net_weight).label("total_executed"), ) .filter(*weighing_filters) .group_by(DbWeighingSlip.purchase_plan_id, DbWeighingSlip.plan_no) .all() ) for row in weighing_rows: key = (row.purchase_plan_id, row.plan_no) executed_sum_map[key] = float(row.total_executed or 0) def calc_executed_for_plan(plan: DbPurchasePlan) -> float: if not executed_sum_map: return 0.0 total = 0.0 for (pid, pno), executed in executed_sum_map.items(): if pid is not None and pid == plan.id: total += executed elif pno and plan.plan_no and pno == plan.plan_no: total += executed return total user_name_map = load_user_display_name_map(db, [p.create_by for p in plans]) result_list: list[PurchasePlanWithFillLink] = [] for plan in plans: result_list.append( plan_to_read_with_fill_link( plan, executed_quantity=calc_executed_for_plan(plan), fill_link_inventory_id=plan_id_to_inv_id.get(plan.id), user_name_map=user_name_map, ) ) return result_list def _fetch_plans( db: Session, user: DbUserContext, params: dict, *, page: Optional[int] = None, page_size: Optional[int] = None, ) -> Tuple[list[PurchasePlanWithFillLink], int]: query, tenant_no = _plans_query(db, user, params) if page is not None and page_size is not None: total = query.order_by(None).count() plans = query.offset((page - 1) * page_size).limit(page_size).all() return _map_plans(db, tenant_no, plans), total plans = query.all() items = _map_plans(db, tenant_no, plans) return items, len(items) @router.get("/") def list_plans( request: Request, q: Optional[str] = Query(default=None, description="模糊搜索往来单位或产品"), plan_no: Optional[str] = Query(default=None, alias="planNo", description="计划号"), customer_name: Optional[str] = Query( default=None, alias="customerName", description="往来单位" ), product: Optional[str] = Query(default=None, description="产品"), business_type: Optional[str] = Query(default=None, alias="businessType", description="业务类型"), execution_status: Optional[str] = Query( default=None, alias="executionStatus", description="执行状态" ), created_from: Optional[str] = Query(default=None, alias="createdFrom", description="创建开始日期"), created_to: Optional[str] = Query(default=None, alias="createdTo", description="创建结束日期"), start_date_from: Optional[str] = Query( default=None, alias="startDateFrom", description="筛选区间开始：与计划有效期（起始～截止）有交集", ), start_date_to: Optional[str] = Query( default=None, alias="startDateTo", description="筛选区间结束：与计划有效期（起始～截止）有交集", ), page: Optional[int] = Query(default=None, ge=1, description="页码；传入则返回分页结构"), page_size: Optional[int] = Query( default=None, ge=1, le=500, alias="pageSize", description="每页条数" ), db: Session = Depends(get_db), user: DbUserContext = Depends(get_db_current_user), ): params = _merge_query( request, q=q, planNo=plan_no, customerName=customer_name, product=product, businessType=business_type, executionStatus=execution_status, createdFrom=created_from, createdTo=created_to, startDateFrom=start_date_from, startDateTo=start_date_to, ) paged = page is not None size = page_size if page_size is not None else 20 page_num = page if page is not None else 1 items, total = _fetch_plans( db, user, params, page=page_num if paged else None, page_size=size if paged else None, ) if paged: body = PurchasePlanListResponse( items=items, total=total, page=page_num, pageSize=size ) return JSONResponse(content=body.model_dump(by_alias=True)) return JSONResponse(content=[item.model_dump(by_alias=True) for item in items]) PLAN_EXPORT_COLUMNS = [ ExportColumn(title="计划号", field="planNo"), ExportColumn(title="业务类型", field="businessType"), ExportColumn(title="往来单位", field="customerName"), ExportColumn(title="计划日期", field="planDate"), ExportColumn(title="起始日期", field="startDate"), ExportColumn(title="截止日期", field="endDate"), ExportColumn(title="产品", field="product"), ExportColumn(title="规格", field="specification"), ExportColumn(title="车牌号", field="vehicleNo"), ExportColumn(title="计划量(吨)", field="plannedQuantity"), ExportColumn(title="已执行量(吨)", field="executedQuantity"), ExportColumn(title="执行状态", field="executionStatus"), ExportColumn(title="备注", field="remarks"), ExportColumn(title="自动生成", field="autoGenerate"), ExportColumn(title="创建人", field="createByName"), ] class PlanExportBody(BaseModel): q: Optional[str] = None plan_no: Optional[str] = Field(default=None, alias="planNo") customer_name: Optional[str] = Field(default=None, alias="customerName") product: Optional[str] = None business_type: Optional[str] = Field(default=None, alias="businessType") execution_status: Optional[str] = Field(default=None, alias="executionStatus") created_from: Optional[str] = Field(default=None, alias="createdFrom") created_to: Optional[str] = Field(default=None, alias="createdTo") start_date_from: Optional[str] = Field(default=None, alias="startDateFrom") start_date_to: Optional[str] = Field(default=None, alias="startDateTo") ids: Optional[List[str]] = None columns: Optional[List[str]] = None model_config = {"populate_by_name": True, "extra": "allow"} @router.post("/export") def export_plans( body: PlanExportBody, db: Session = Depends(get_db), user: DbUserContext = Depends(get_db_current_user), ): """导出计划列表（当前筛选全量，或 ids 已选）。""" try: items, _total = _fetch_plans(db, user, _body_to_params(body)) if body.ids: id_set = set(body.ids) items = [x for x in items if x.id in id_set] if len(items) > EXPORT_MAX_ROWS: raise ExportValidationError(f"导出超过 {EXPORT_MAX_ROWS} 条，请缩小筛选范围") rows = [] for item in items: data = item.model_dump(by_alias=True) data["autoGenerate"] = "是" if data.get("autoGenerateEnabled") else "否" eq = data.get("executedQuantity") or 0 try: data["executedQuantity"] = round(float(eq) / 1000, 2) except (TypeError, ValueError): data["executedQuantity"] = 0 if not data.get("createByName"): data["createByName"] = data.get("createBy") or "" rows.append(data) cols = filter_export_columns(PLAN_EXPORT_COLUMNS, body.columns) date_str = datetime.now().strftime("%Y%m%d") tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) 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 def _generate_plan_no() -> str: from app.services.db.plan_helpers import generate_plan_no return generate_plan_no() @router.post("/", response_model=PurchasePlanRead, status_code=status.HTTP_201_CREATED) def create_plan( payload: PurchasePlanCreate, db: Session = Depends(get_db), user: DbUserContext = Depends(get_db_current_user), ) -> PurchasePlanRead: tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) plan_no = payload.plan_no if payload.plan_no else _generate_plan_no() execution_status = payload.execution_status if not execution_status: execution_status = "待入库" if payload.business_type == "入库" else "待出库" snapshot = resolve_crm_product(db, tenant_no, payload.product_id) plan = DbPurchasePlan( id=generate_uuid(), tenant_no=tenant_no, plan_no=plan_no, plan_date=parse_date_str(payload.plan_date) or date.today(), start_date=parse_date_str(payload.start_date), end_date=parse_date_str(payload.end_date), business_type=payload.business_type, planned_quantity=payload.planned_quantity, vehicle_no=payload.vehicle_no or "", customer_name=payload.customer_name.strip() if payload.customer_name else None, remark=payload.remarks, execution_status=execution_status, executed_at=None, last_weighing_slip_id=None, executed_quantity=0, auto_generate_enabled=payload.auto_generate_enabled or 0, auto_generate_end_month=payload.auto_generate_end_month, auto_generate_last_month=None, create_by=user.id, create_dept_id=user.dept_id, ) apply_product_snapshot_to_plan(plan, snapshot) db.add(plan) db.commit() db.refresh(plan) return plan_to_read(plan, db=db) class AutoGenerateMonthlyResult(BaseModel): created_count: int skipped_reason: Optional[str] = None current_month: str @router.post("/run-auto-generate", response_model=AutoGenerateMonthlyResult) def run_auto_generate_monthly( force: bool = Query(default=False, description="true 时跳过「仅每月1日」限制，供验收手动触发"), db: Session = Depends(get_db), user: DbUserContext = Depends(get_db_current_user), ) -> AutoGenerateMonthlyResult: """手动触发计划按月自动生成（定时任务同款逻辑）。""" get_tenant_no(db, user.to_tenant_user_dict()) from app.services.db.auto_generate_plans import run_auto_generate_monthly_plans result = run_auto_generate_monthly_plans(db, force=force) return AutoGenerateMonthlyResult(**result) @router.get("/{id}", response_model=PurchasePlanRead) def get_plan( id: str, db: Session = Depends(get_db), user: DbUserContext = Depends(get_db_current_user), ) -> PurchasePlanRead: tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) plan = _get_plan(db, tenant_no, id, user) return plan_to_read(plan, db=db) @router.patch("/{id}", response_model=PurchasePlanRead) def update_plan( id: str, payload: PurchasePlanUpdate, db: Session = Depends(get_db), user: DbUserContext = Depends(get_db_current_user), ) -> PurchasePlanRead: tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) plan = _get_plan(db, tenant_no, id, user) payload_dict = payload.model_dump(exclude_unset=True) _apply_plan_product_update(db, tenant_no, plan, payload_dict) _apply_plan_update(plan, payload_dict) plan.update_by = user.id db.commit() db.refresh(plan) return plan_to_read(plan, db=db) @router.delete("/{id}", status_code=status.HTTP_204_NO_CONTENT) def delete_plan( 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()) plan = _get_plan(db, tenant_no, id, user) if plan.execution_status in ("已入库", "已出库"): raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="已完成的计划不能删除", ) assert_row_deletable_by_creator(plan, user_info_from_context(user)) plan.del_flag = 1 plan.update_by = user.id db.commit() def _get_plan( db: Session, tenant_no: str, plan_id: str, user: DbUserContext ) -> DbPurchasePlan: plan = ( _base_query(db, tenant_no) .filter(DbPurchasePlan.id == plan_id) .one_or_none() ) if plan is None: raise HTTPException( status_code=status.HTTP_404_NOT_FOUND, detail=f"Plan {plan_id} not found", ) assert_db_row_in_scope(db, plan, DbPurchasePlan, user, tenant_no) return plan def _get_plan_by_id_only(db: Session, plan_id: str) -> DbPurchasePlan: plan = ( db.query(DbPurchasePlan) .filter(DbPurchasePlan.id == plan_id, DbPurchasePlan.del_flag == 0) .one_or_none() ) if plan is None: raise HTTPException( status_code=status.HTTP_404_NOT_FOUND, detail=f"Plan {plan_id} not found", ) return plan def _apply_plan_product_update( db: Session, tenant_no: str, plan: DbPurchasePlan, payload_dict: dict ) -> None: if "product" in payload_dict and "product_id" not in payload_dict: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="请从 CRM 重新选择产品", ) product_id = payload_dict.pop("product_id", None) payload_dict.pop("product", None) payload_dict.pop("specification", None) if product_id is not None: snapshot = resolve_crm_product(db, tenant_no, product_id) apply_product_snapshot_to_plan(plan, snapshot) def _apply_plan_update(plan: DbPurchasePlan, payload_dict: dict) -> None: for key, value in payload_dict.items(): if key == _PLAN_REMARK_FIELD: if isinstance(value, str): value = value.strip() plan.remark = value continue if key in _PLAN_DATE_FIELDS: if value is None: setattr(plan, key, None) else: setattr(plan, key, parse_date_str(str(value))) continue if key == "executed_at": plan.executed_at = parse_datetime_str(str(value)) if value else None continue if isinstance(value, str): value = value.strip() setattr(plan, key, value) class PlanRelatedData(BaseModel): inventories: list[InboundOutboundRead] weighings: list[WeighingSlipRead] @router.get("/{id}/related", response_model=PlanRelatedData) def get_plan_related( id: str, db: Session = Depends(get_db), user: DbUserContext = Depends(get_db_current_user), ) -> PlanRelatedData: tenant_no = get_tenant_no(db, user.to_tenant_user_dict()) plan = _get_plan(db, tenant_no, id, user) inventories = ( db.query(DbInboundOutbound) .filter( DbInboundOutbound.tenant_no == tenant_no, DbInboundOutbound.del_flag == 0, DbInboundOutbound.purchase_plan_id == plan.id, ) .order_by(DbInboundOutbound.date.desc(), DbInboundOutbound.id.desc()) .all() ) weighing_query = db.query(DbWeighingSlip).filter( DbWeighingSlip.tenant_no == tenant_no, DbWeighingSlip.del_flag == 0, DbWeighingSlip.is_voided == 0, ) if plan.plan_no: weighing_query = weighing_query.filter( or_( DbWeighingSlip.plan_no == plan.plan_no, DbWeighingSlip.purchase_plan_id == plan.id, ) ) else: weighing_query = weighing_query.filter(DbWeighingSlip.purchase_plan_id == plan.id) weighings = weighing_query.order_by(DbWeighingSlip.create_time.desc()).all() user_name_map = load_user_display_name_map( db, [inv.create_by for inv in inventories] + [w.create_by for w in weighings], ) return PlanRelatedData( inventories=[inventory_to_read(inv, user_name_map=user_name_map) for inv in inventories], weighings=[weighing_to_read(w, user_name_map=user_name_map) for w in weighings], ) class ThirdPartyPlanPageData(BaseModel): plan: PurchasePlanRead today_inventories: list[InboundOutboundRead] month_inventories: list[InboundOutboundRead] @router.get("/{id}/third-party-page", response_model=ThirdPartyPlanPageData) def get_third_party_plan_page( id: str, db: Session = Depends(get_db), ) -> ThirdPartyPlanPageData: """三方 H5 填写页初始化数据（无需门户登录，与原系统一致）。""" plan = _get_plan_by_id_only(db, id) tenant_no = plan.tenant_no today = date.today() start = plan.start_date end = plan.end_date if start and today < start: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="计划尚未生效，当前日期不允许填写出入库单", ) if end and today > end: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="计划已过期，当前日期不允许填写出入库单", ) today_str = today.strftime("%Y-%m-%d") today_date = parse_date_str(today_str) inventories = ( db.query(DbInboundOutbound) .filter( DbInboundOutbound.tenant_no == tenant_no, DbInboundOutbound.del_flag == 0, DbInboundOutbound.purchase_plan_id == plan.id, DbInboundOutbound.date == today_date, ) .order_by(DbInboundOutbound.date.desc(), DbInboundOutbound.id.desc()) .all() ) month_start = today.replace(day=1) month_history = ( db.query(DbInboundOutbound) .filter( DbInboundOutbound.tenant_no == tenant_no, DbInboundOutbound.del_flag == 0, DbInboundOutbound.purchase_plan_id == plan.id, DbInboundOutbound.date >= month_start, DbInboundOutbound.date < today, ) .order_by(DbInboundOutbound.date.desc(), DbInboundOutbound.id.desc()) .all() ) user_name_map = load_user_display_name_map( db, [plan.create_by] + [inv.create_by for inv in inventories] + [inv.create_by for inv in month_history], ) return ThirdPartyPlanPageData( plan=plan_to_read(plan, user_name_map=user_name_map), today_inventories=[ inventory_to_read(inv, user_name_map=user_name_map) for inv in inventories ], month_inventories=[ inventory_to_read(inv, user_name_map=user_name_map) for inv in month_history ], )