963 lines
34 KiB
Python
963 lines
34 KiB
Python
"""运输计划归档导出：按段次×产品展开（装货行与各送货段各一行）。"""
|
||
from __future__ import annotations
|
||
|
||
from datetime import date, datetime
|
||
from decimal import Decimal
|
||
from typing import Optional, Union
|
||
|
||
from sqlalchemy.orm import Session
|
||
|
||
from app.models.pl_models import PlPlan, PlPlanContract, PlPlanProduct, PlTransport
|
||
from app.schemas.pl.plan import PlanDeliveryRead, PlanLoadRead, PlanStopProductRead
|
||
from app.services.pl.plan_list_export_segments import (
|
||
format_stop_segment_label,
|
||
iter_segment_product_slots,
|
||
)
|
||
from app.services.pl.plan_list_filters import customer_name_matches_keywords
|
||
from app.services.pl_brand_archive import (
|
||
expand_export_rows_for_plan_brand,
|
||
load_brand_qtys_by_plan_product_ids,
|
||
load_brand_qtys_by_stop_product_ids,
|
||
)
|
||
from app.services.pl_internal_customer import is_internal_customer_name
|
||
from app.services.pl_plan_stop_service import load_plan_stops_grouped
|
||
from app.services.pl_product_display import load_crm_product_alias_maps, resolve_product_display_names
|
||
|
||
StopKind = str # "load" | "delivery"
|
||
|
||
|
||
def _unique_contract_nos(*sources: Optional[str]) -> str:
|
||
"""按出现顺序去重拼接合同编号。"""
|
||
seen: list[str] = []
|
||
for raw in sources:
|
||
for part in str(raw or "").replace("，", ",").split(","):
|
||
no = part.strip()
|
||
if no and no not in seen:
|
||
seen.append(no)
|
||
return "、".join(seen)
|
||
|
||
|
||
def _contract_nos_from_stop_links(contracts: Optional[list]) -> list[str]:
|
||
"""段次合同关联 → 编号列表（去重保序）。"""
|
||
seen: list[str] = []
|
||
for item in contracts or []:
|
||
no = (
|
||
getattr(item, "contract_no", None)
|
||
or (item.get("contractNo") if isinstance(item, dict) else None)
|
||
or getattr(item, "contractNo", None)
|
||
or ""
|
||
)
|
||
no = str(no or "").strip()
|
||
if not no:
|
||
cid = (
|
||
getattr(item, "contract_id", None)
|
||
or (item.get("contractId") if isinstance(item, dict) else None)
|
||
or getattr(item, "contractId", None)
|
||
or ""
|
||
)
|
||
no = str(cid or "").strip()
|
||
if no and no not in seen:
|
||
seen.append(no)
|
||
return seen
|
||
|
||
|
||
def format_stop_contract_export_label(
|
||
kind: StopKind,
|
||
contracts: Optional[list],
|
||
customer_name: Optional[str],
|
||
) -> str:
|
||
"""与前端列表一致：有编号显示编号；山峡/云栋缺合同 → 装货出库 / 送货入库。"""
|
||
nos = _contract_nos_from_stop_links(contracts)
|
||
if nos:
|
||
return "、".join(nos)
|
||
if is_internal_customer_name(customer_name):
|
||
return "出库" if kind == "load" else "入库"
|
||
return ""
|
||
|
||
|
||
def _load_contract_nos_by_plan(
|
||
db: Session, tenant_no: str, plan_ids: list[str]
|
||
) -> dict[str, list[str]]:
|
||
if not plan_ids:
|
||
return {}
|
||
rows = (
|
||
db.query(PlPlanContract)
|
||
.filter(
|
||
PlPlanContract.tenant_no == tenant_no,
|
||
PlPlanContract.del_flag == 0,
|
||
PlPlanContract.plan_id.in_(plan_ids),
|
||
)
|
||
.order_by(PlPlanContract.order_num.asc(), PlPlanContract.create_time.asc())
|
||
.all()
|
||
)
|
||
out: dict[str, list[str]] = {pid: [] for pid in plan_ids}
|
||
for row in rows:
|
||
no = (row.contract_no or "").strip()
|
||
if not no:
|
||
continue
|
||
bucket = out.setdefault(row.plan_id, [])
|
||
if no not in bucket:
|
||
bucket.append(no)
|
||
return out
|
||
|
||
|
||
PLAN_TYPE_LABELS = {
|
||
"direct": "直销单",
|
||
"inbound": "入库单",
|
||
"outbound": "出库单",
|
||
}
|
||
|
||
ARCHIVE_STATUS_LABELS = {
|
||
"cancelled": "已取消",
|
||
"archived": "已归档",
|
||
"unarchived": "未归档",
|
||
"draft": "已暂存",
|
||
}
|
||
|
||
FOLLOW_STATUS_LABELS = {
|
||
"drafting": "草稿中",
|
||
"wait_notice": "等通知",
|
||
"pending_arrange": "待安排",
|
||
"arranged": "已安排",
|
||
"completed": "已完成",
|
||
"cancelled": "已取消",
|
||
"draft": "待安排",
|
||
"processing": "进行中",
|
||
}
|
||
|
||
FREIGHT_TYPE_LABELS = {
|
||
"by_weight": "按重量",
|
||
"by_trip": "按趟",
|
||
}
|
||
|
||
|
||
def resolve_archive_list_io_column(kind: StopKind, customer_name: Optional[str]) -> str:
|
||
"""装货/送货段入库出库列方向（与前端 resolveArchiveListIoColumn 一致）。"""
|
||
internal = is_internal_customer_name(customer_name)
|
||
if kind == "load":
|
||
return "outbound" if internal else "inbound"
|
||
return "inbound" if internal else "outbound"
|
||
|
||
|
||
def _format_date_value(value: Optional[Union[date, datetime, str]]) -> str:
|
||
if value is None:
|
||
return ""
|
||
return str(value)[:10]
|
||
|
||
|
||
def _format_plate_display(license_plate: Optional[str], trailer_no: Optional[str]) -> str:
|
||
plate = (license_plate or "").strip()
|
||
trailer = (trailer_no or "").strip()
|
||
if not plate and not trailer:
|
||
return ""
|
||
if plate and trailer:
|
||
return f"{plate}{trailer}"
|
||
return plate or trailer
|
||
|
||
|
||
def _get_stop_archive_actual_qty(product: PlanStopProductRead, kind: StopKind) -> Optional[Decimal]:
|
||
return product.inbound_qty if kind == "load" else product.outbound_qty
|
||
|
||
|
||
def _get_stop_archive_unit_price(product: PlanStopProductRead, kind: StopKind) -> Optional[Decimal]:
|
||
return product.inbound_price if kind == "load" else product.outbound_price
|
||
|
||
|
||
def _get_stop_archive_amount(product: PlanStopProductRead, kind: StopKind) -> Optional[Decimal]:
|
||
stored = product.inbound_amount if kind == "load" else product.outbound_amount
|
||
if stored is not None:
|
||
return stored
|
||
qty = _get_stop_archive_actual_qty(product, kind)
|
||
price = _get_stop_archive_unit_price(product, kind)
|
||
if qty is not None and price is not None:
|
||
return qty * price
|
||
return None
|
||
|
||
|
||
def _stop_time(kind: StopKind, stop: Union[PlanLoadRead, PlanDeliveryRead]) -> str:
|
||
if kind == "load":
|
||
return _format_date_value(getattr(stop, "load_time", None))
|
||
return _format_date_value(getattr(stop, "delivery_time", None))
|
||
|
||
|
||
def _load_legacy_products_by_plan(
|
||
db: Session, tenant_no: str, plan_ids: list[str]
|
||
) -> dict[str, list[PlPlanProduct]]:
|
||
if not plan_ids:
|
||
return {}
|
||
products = (
|
||
db.query(PlPlanProduct)
|
||
.filter(
|
||
PlPlanProduct.tenant_no == tenant_no,
|
||
PlPlanProduct.del_flag == 0,
|
||
PlPlanProduct.plan_id.in_(plan_ids),
|
||
)
|
||
.order_by(PlPlanProduct.order_num)
|
||
.all()
|
||
)
|
||
grouped: dict[str, list[PlPlanProduct]] = {}
|
||
for product in products:
|
||
grouped.setdefault(product.plan_id, []).append(product)
|
||
return grouped
|
||
|
||
|
||
def _plan_common_export_fields(
|
||
plan: PlPlan,
|
||
transport: Optional[PlTransport],
|
||
*,
|
||
contract_nos: Optional[list[str]] = None,
|
||
) -> dict:
|
||
freight_type_raw = transport.freight_type if transport else "by_weight"
|
||
freight_type_label = FREIGHT_TYPE_LABELS.get(freight_type_raw, freight_type_raw or "")
|
||
freight_price = transport.freight_price if transport else None
|
||
freight_amount = plan.freight_amount
|
||
if freight_amount is None and transport is not None:
|
||
freight_amount = transport.freight_amount
|
||
plan_date = _format_date_value(plan.plan_date)
|
||
link_nos = contract_nos or []
|
||
return {
|
||
"planId": plan.id or "",
|
||
"planNo": plan.plan_no or "",
|
||
"contractNo": _unique_contract_nos(plan.contract_no, *link_nos),
|
||
"planDate": plan_date,
|
||
"archiveStatus": ARCHIVE_STATUS_LABELS.get(plan.archive_status or "", plan.archive_status or ""),
|
||
"followStatus": FOLLOW_STATUS_LABELS.get(plan.follow_status or "", plan.follow_status or ""),
|
||
"planType": PLAN_TYPE_LABELS.get(plan.plan_type or "", plan.plan_type or ""),
|
||
"licensePlate": _format_plate_display(plan.license_plate, plan.trailer_no),
|
||
"erpEntered": "是" if int(plan.erp_entered or 0) == 1 else "否",
|
||
"freightType": freight_type_label,
|
||
"freightPrice": freight_price,
|
||
"freightAmount": freight_amount,
|
||
"remark": plan.remark or "",
|
||
}
|
||
|
||
|
||
def _empty_pair_side_fields(*, side: str) -> dict:
|
||
"""side: load | delivery"""
|
||
prefix = "load" if side == "load" else "delivery"
|
||
return {
|
||
f"{prefix}Customer": "",
|
||
f"{prefix}Address": "",
|
||
f"{prefix}Time": "",
|
||
f"{prefix}PlanQty": None,
|
||
f"{prefix}ActualQty": None,
|
||
f"{prefix}InboundQty": None,
|
||
f"{prefix}OutboundQty": None,
|
||
f"{prefix}UnitPrice": None,
|
||
f"{prefix}Amount": None,
|
||
}
|
||
|
||
|
||
def _empty_product_identity_fields() -> dict:
|
||
return {
|
||
"productName": "",
|
||
"brandName": "",
|
||
"aliasName": "",
|
||
"model": "",
|
||
"packageSpec": "",
|
||
"unit": "",
|
||
}
|
||
|
||
|
||
def _resolve_export_product_display(
|
||
plan_product: Optional[PlPlanProduct],
|
||
stop_product: Optional[PlanStopProductRead],
|
||
*,
|
||
standard_by_id: dict[str, str],
|
||
alias_options_by_id: dict[str, list[str]],
|
||
) -> tuple[str, str]:
|
||
"""返回 (展示用产品名称, 别名)。"""
|
||
saved_name = ""
|
||
product_id = ""
|
||
if plan_product is not None:
|
||
saved_name = plan_product.product_name or ""
|
||
product_id = plan_product.product_id or ""
|
||
elif stop_product is not None:
|
||
saved_name = stop_product.product_name or ""
|
||
product_id = stop_product.product_id or ""
|
||
display_name, alias = resolve_product_display_names(
|
||
saved_product_name=saved_name,
|
||
product_id=product_id,
|
||
standard_by_id=standard_by_id,
|
||
alias_options_by_id=alias_options_by_id,
|
||
)
|
||
return (display_name or saved_name or "").strip(), (alias or "").strip()
|
||
|
||
|
||
def _lookup_plan_product(
|
||
stop_product: PlanStopProductRead,
|
||
plan_products_by_id: dict[str, PlPlanProduct],
|
||
plan_products_by_product_id: dict[str, PlPlanProduct],
|
||
) -> Optional[PlPlanProduct]:
|
||
plan_product_id = str(getattr(stop_product, "plan_product_id", None) or "").strip()
|
||
if plan_product_id and plan_product_id in plan_products_by_id:
|
||
return plan_products_by_id[plan_product_id]
|
||
product_id = str(stop_product.product_id or "").strip()
|
||
if product_id and product_id in plan_products_by_product_id:
|
||
return plan_products_by_product_id[product_id]
|
||
return None
|
||
|
||
|
||
def _product_identity_from_stop(
|
||
product: PlanStopProductRead,
|
||
*,
|
||
plan_product: Optional[PlPlanProduct] = None,
|
||
standard_by_id: Optional[dict[str, str]] = None,
|
||
alias_options_by_id: Optional[dict[str, list[str]]] = None,
|
||
) -> dict:
|
||
display_name, alias_name = _resolve_export_product_display(
|
||
plan_product,
|
||
product,
|
||
standard_by_id=standard_by_id or {},
|
||
alias_options_by_id=alias_options_by_id or {},
|
||
)
|
||
return {
|
||
"productName": display_name or (product.product_name or ""),
|
||
"brandName": "",
|
||
"aliasName": alias_name,
|
||
"model": product.model or "",
|
||
"packageSpec": product.package_spec or "",
|
||
"unit": product.unit or "",
|
||
}
|
||
|
||
|
||
def _segment_slot_customer(
|
||
kind: str,
|
||
load: Optional[PlanLoadRead],
|
||
delivery: Optional[PlanDeliveryRead],
|
||
) -> str:
|
||
if kind == "load" and load is not None:
|
||
return load.customer_name or ""
|
||
if kind == "delivery" and delivery is not None:
|
||
return delivery.customer_name or ""
|
||
return ""
|
||
|
||
|
||
def _build_archive_segment_row(
|
||
row_no: int,
|
||
plan_common: dict,
|
||
kind: str,
|
||
load: Optional[PlanLoadRead],
|
||
delivery: Optional[PlanDeliveryRead],
|
||
delivery_seq: Optional[int],
|
||
product: Optional[PlanStopProductRead],
|
||
*,
|
||
plan_products_by_id: dict[str, PlPlanProduct],
|
||
plan_products_by_product_id: dict[str, PlPlanProduct],
|
||
standard_by_id: dict[str, str],
|
||
alias_options_by_id: dict[str, list[str]],
|
||
) -> dict:
|
||
"""一段次×一个产品一行：只填本侧客户/地址/时间/合同与本侧量价。"""
|
||
fallback_contract = str(plan_common.get("contractNo") or "")
|
||
row = {
|
||
**plan_common,
|
||
"rowNo": row_no,
|
||
"_stopKind": kind,
|
||
"_deliverySeq": delivery_seq,
|
||
"stopSegment": format_stop_segment_label(kind, delivery_seq),
|
||
"loadCustomer": "",
|
||
"loadAddress": "",
|
||
"loadTime": "",
|
||
"deliveryCustomer": "",
|
||
"deliveryAddress": "",
|
||
"deliveryTime": "",
|
||
"contractNo": fallback_contract,
|
||
**_empty_product_identity_fields(),
|
||
"planQty": None,
|
||
"actualQty": None,
|
||
"unitPrice": None,
|
||
"amount": None,
|
||
}
|
||
if kind == "load" and load is not None:
|
||
customer_name = load.customer_name or ""
|
||
row["loadCustomer"] = customer_name
|
||
row["loadAddress"] = load.address or ""
|
||
row["loadTime"] = _stop_time("load", load)
|
||
row["contractNo"] = format_stop_contract_export_label(
|
||
"load", load.contracts, customer_name
|
||
) or fallback_contract
|
||
elif kind == "delivery" and delivery is not None:
|
||
customer_name = delivery.customer_name or ""
|
||
row["deliveryCustomer"] = customer_name
|
||
row["deliveryAddress"] = delivery.address or ""
|
||
row["deliveryTime"] = _stop_time("delivery", delivery)
|
||
row["contractNo"] = format_stop_contract_export_label(
|
||
"delivery", delivery.contracts, customer_name
|
||
) or fallback_contract
|
||
if product is not None:
|
||
plan_product = _lookup_plan_product(
|
||
product, plan_products_by_id, plan_products_by_product_id
|
||
)
|
||
row.update(
|
||
_product_identity_from_stop(
|
||
product,
|
||
plan_product=plan_product,
|
||
standard_by_id=standard_by_id,
|
||
alias_options_by_id=alias_options_by_id,
|
||
)
|
||
)
|
||
row["planQty"] = product.plan_qty
|
||
row["actualQty"] = _get_stop_archive_actual_qty(product, kind)
|
||
row["unitPrice"] = _get_stop_archive_unit_price(product, kind)
|
||
row["amount"] = _get_stop_archive_amount(product, kind)
|
||
return row
|
||
|
||
|
||
def _append_legacy_plan_product_rows(
|
||
rows: list[dict],
|
||
row_no: int,
|
||
plan: PlPlan,
|
||
plan_common: dict,
|
||
products: list[PlPlanProduct],
|
||
*,
|
||
standard_by_id: Optional[dict[str, str]] = None,
|
||
alias_options_by_id: Optional[dict[str, list[str]]] = None,
|
||
brand_by_plan_product: Optional[dict[str, list]] = None,
|
||
) -> int:
|
||
"""无段表数据时回退计划产品级导出（兼容旧数据）；有品牌明细时按品牌拆行。"""
|
||
product_rows = products or [None]
|
||
fallback_no = str(plan_common.get("contractNo") or "")
|
||
if fallback_no:
|
||
legacy_contract_no = fallback_no
|
||
else:
|
||
legacy_contract_no = _unique_contract_nos(
|
||
format_stop_contract_export_label("load", None, plan.supplier_name),
|
||
format_stop_contract_export_label(
|
||
"delivery", None, plan.customer_name or plan.destination_name
|
||
),
|
||
)
|
||
brand_index = brand_by_plan_product or {}
|
||
for product in product_rows:
|
||
row = {
|
||
**plan_common,
|
||
"rowNo": 0,
|
||
"_stopKind": "",
|
||
"_deliverySeq": None,
|
||
"stopSegment": "",
|
||
"deliveryStopKind": "",
|
||
**_empty_pair_side_fields(side="load"),
|
||
**_empty_pair_side_fields(side="delivery"),
|
||
**_empty_product_identity_fields(),
|
||
"loadCustomer": plan.supplier_name or plan.customer_name or "",
|
||
"loadAddress": "",
|
||
"deliveryCustomer": plan.customer_name or "",
|
||
"deliveryAddress": plan.destination_name or "",
|
||
"deliveryTime": _format_date_value(plan.delivery_time),
|
||
"contractNo": legacy_contract_no,
|
||
# 兼容旧字段
|
||
"stopKind": "",
|
||
"stopCustomer": plan.customer_name or plan.supplier_name or "",
|
||
"stopAddress": plan.destination_name or "",
|
||
"stopTime": _format_date_value(plan.delivery_time),
|
||
"planQty": None,
|
||
"actualQty": None,
|
||
"inboundQty": None,
|
||
"outboundQty": None,
|
||
"unitPrice": None,
|
||
"amount": None,
|
||
}
|
||
if product is not None:
|
||
display_name, alias_name = _resolve_export_product_display(
|
||
product,
|
||
None,
|
||
standard_by_id=standard_by_id or {},
|
||
alias_options_by_id=alias_options_by_id or {},
|
||
)
|
||
row.update(
|
||
{
|
||
"productName": display_name or (product.product_name or ""),
|
||
"brandName": "",
|
||
"aliasName": alias_name,
|
||
"model": product.model or "",
|
||
"packageSpec": product.package_spec or "",
|
||
"unit": product.unit or "",
|
||
"loadPlanQty": product.quantity,
|
||
"loadActualQty": product.actual_qty,
|
||
"loadInboundQty": product.inbound_qty,
|
||
"loadOutboundQty": product.outbound_qty,
|
||
"loadUnitPrice": product.inbound_price or product.outbound_price,
|
||
"loadAmount": product.inbound_amount or product.outbound_amount,
|
||
"planQty": product.quantity,
|
||
"actualQty": product.actual_qty,
|
||
"inboundQty": product.inbound_qty,
|
||
"outboundQty": product.outbound_qty,
|
||
"unitPrice": product.inbound_price or product.outbound_price,
|
||
"amount": product.inbound_amount or product.outbound_amount,
|
||
}
|
||
)
|
||
for expanded in expand_export_rows_for_plan_brand(
|
||
row,
|
||
archive_status=getattr(plan, "archive_status", None),
|
||
plan_product=product,
|
||
stop_product_id=None,
|
||
plan_product_id=str(getattr(product, "id", None) or "")
|
||
if product is not None
|
||
else None,
|
||
by_stop_id={},
|
||
by_plan_product_id=brand_index,
|
||
apply_unit_price=True,
|
||
):
|
||
row_no += 1
|
||
expanded["rowNo"] = row_no
|
||
rows.append(expanded)
|
||
return row_no
|
||
|
||
|
||
def build_plan_archive_export_rows(
|
||
db: Session,
|
||
tenant_no: str,
|
||
plans: list[PlPlan],
|
||
transports_by_id: dict[str, PlTransport],
|
||
*,
|
||
stop_kind: Optional[str] = None,
|
||
stop_customer_keywords: Optional[list] = None,
|
||
) -> list[dict]:
|
||
"""构建归档导出数据行。
|
||
|
||
默认按段次×产品展开：先装货产品行，再各送货段产品行。
|
||
stop_kind 为 load / delivery 时只保留对应侧。
|
||
stop_customer_keywords 非空时按该行所属侧客户过滤。
|
||
无段表数据时回退计划产品级导出，stopSegment 为空。
|
||
"""
|
||
if not plans:
|
||
return []
|
||
|
||
include_load = stop_kind != "delivery"
|
||
include_delivery = stop_kind != "load"
|
||
keywords = [str(item).strip() for item in (stop_customer_keywords or []) if str(item).strip()]
|
||
|
||
def _keep_customer(name: Optional[str]) -> bool:
|
||
if not keywords:
|
||
return True
|
||
return customer_name_matches_keywords(name, keywords)
|
||
|
||
plan_ids = [plan.id for plan in plans]
|
||
stops_by_plan = load_plan_stops_grouped(db, tenant_no, plan_ids)
|
||
legacy_products_by_plan = _load_legacy_products_by_plan(db, tenant_no, plan_ids)
|
||
contract_nos_by_plan = _load_contract_nos_by_plan(db, tenant_no, plan_ids)
|
||
crm_product_ids: list[str] = []
|
||
for products in legacy_products_by_plan.values():
|
||
for product in products:
|
||
if product.product_id:
|
||
crm_product_ids.append(product.product_id)
|
||
for load_read, delivery_reads in stops_by_plan.values():
|
||
for stop in ([load_read] if load_read is not None else []) + list(delivery_reads or []):
|
||
for stop_product in stop.products or []:
|
||
if stop_product.product_id:
|
||
crm_product_ids.append(stop_product.product_id)
|
||
standard_by_id, alias_options_by_id = load_crm_product_alias_maps(
|
||
db,
|
||
tenant_no=tenant_no,
|
||
product_ids=crm_product_ids,
|
||
)
|
||
plan_product_ids: list[str] = []
|
||
stop_product_ids: list[str] = []
|
||
for products in legacy_products_by_plan.values():
|
||
for product in products:
|
||
if product.id:
|
||
plan_product_ids.append(str(product.id))
|
||
for load_read, delivery_reads in stops_by_plan.values():
|
||
for stop in ([load_read] if load_read is not None else []) + list(delivery_reads or []):
|
||
for stop_product in stop.products or []:
|
||
sid = str(getattr(stop_product, "id", None) or "").strip()
|
||
if sid:
|
||
stop_product_ids.append(sid)
|
||
brand_by_plan_product = load_brand_qtys_by_plan_product_ids(
|
||
db, tenant_no=tenant_no, plan_product_ids=plan_product_ids
|
||
)
|
||
brand_by_stop = load_brand_qtys_by_stop_product_ids(
|
||
db, tenant_no=tenant_no, stop_product_ids=stop_product_ids
|
||
)
|
||
|
||
rows: list[dict] = []
|
||
row_no = 0
|
||
for plan in plans:
|
||
transport = transports_by_id.get(plan.transport_id) if plan.transport_id else None
|
||
plan_common = _plan_common_export_fields(
|
||
plan,
|
||
transport,
|
||
contract_nos=contract_nos_by_plan.get(plan.id, []),
|
||
)
|
||
load_read, delivery_reads = stops_by_plan.get(plan.id, (None, []))
|
||
plan_products = legacy_products_by_plan.get(plan.id, [])
|
||
plan_products_by_id = {str(p.id): p for p in plan_products if p.id}
|
||
plan_products_by_product_id: dict[str, PlPlanProduct] = {}
|
||
for product in plan_products:
|
||
pid = str(product.product_id or "").strip()
|
||
if pid and pid not in plan_products_by_product_id:
|
||
plan_products_by_product_id[pid] = product
|
||
|
||
has_stops = load_read is not None or bool(delivery_reads)
|
||
if not has_stops:
|
||
if not include_load:
|
||
continue
|
||
legacy_customer = plan.customer_name or plan.supplier_name or ""
|
||
if not _keep_customer(legacy_customer):
|
||
continue
|
||
row_no = _append_legacy_plan_product_rows(
|
||
rows,
|
||
row_no,
|
||
plan,
|
||
plan_common,
|
||
plan_products,
|
||
standard_by_id=standard_by_id,
|
||
alias_options_by_id=alias_options_by_id,
|
||
brand_by_plan_product=brand_by_plan_product,
|
||
)
|
||
continue
|
||
|
||
for kind, slot_load, slot_delivery, seq, stop_product in iter_segment_product_slots(
|
||
load_read, delivery_reads
|
||
):
|
||
if kind == "load" and not include_load:
|
||
continue
|
||
if kind == "delivery" and not include_delivery:
|
||
continue
|
||
if not _keep_customer(_segment_slot_customer(kind, slot_load, slot_delivery)):
|
||
continue
|
||
base_row = _build_archive_segment_row(
|
||
0,
|
||
plan_common,
|
||
kind,
|
||
slot_load,
|
||
slot_delivery,
|
||
seq,
|
||
stop_product,
|
||
plan_products_by_id=plan_products_by_id,
|
||
plan_products_by_product_id=plan_products_by_product_id,
|
||
standard_by_id=standard_by_id,
|
||
alias_options_by_id=alias_options_by_id,
|
||
)
|
||
plan_product = None
|
||
if stop_product is not None:
|
||
plan_product = _lookup_plan_product(
|
||
stop_product, plan_products_by_id, plan_products_by_product_id
|
||
)
|
||
for expanded in expand_export_rows_for_plan_brand(
|
||
base_row,
|
||
archive_status=getattr(plan, "archive_status", None),
|
||
plan_product=plan_product,
|
||
stop_product_id=str(getattr(stop_product, "id", None) or "")
|
||
if stop_product is not None
|
||
else None,
|
||
plan_product_id=str(getattr(plan_product, "id", None) or "")
|
||
if plan_product is not None
|
||
else str(getattr(stop_product, "plan_product_id", None) or "")
|
||
if stop_product is not None
|
||
else None,
|
||
by_stop_id=brand_by_stop,
|
||
by_plan_product_id=brand_by_plan_product,
|
||
apply_unit_price=True,
|
||
):
|
||
row_no += 1
|
||
expanded["rowNo"] = row_no
|
||
rows.append(expanded)
|
||
|
||
return rows
|
||
|
||
|
||
ARCHIVE_MERGED_SHEET_TITLE = "计划归档（合并）"
|
||
|
||
# 与列表 PL_PLAN_SPAN_PROPS 对应：整张计划纵向合并（含装货侧）。
|
||
_PLAN_LEVEL_MERGE_FIELDS = frozenset(
|
||
{
|
||
"rowNo",
|
||
"planNo",
|
||
"planDate",
|
||
"archiveStatus",
|
||
"followStatus",
|
||
"planType",
|
||
"erpEntered",
|
||
"licensePlate",
|
||
"freightType",
|
||
"freightPrice",
|
||
"freightAmount",
|
||
"remark",
|
||
"loadCustomer",
|
||
"loadAddress",
|
||
"loadTime",
|
||
}
|
||
)
|
||
# 与列表 PL_DELIVERY_SPAN_PROPS 对应：同一送货段合并；仅一个送货段时连装货行一起合并。
|
||
_DELIVERY_LEVEL_MERGE_FIELDS = frozenset(
|
||
{
|
||
"deliveryCustomer",
|
||
"deliveryAddress",
|
||
"deliveryTime",
|
||
}
|
||
)
|
||
|
||
|
||
def _iter_equal_spans(rows: list[dict], key_fn) -> list[tuple[int, int]]:
|
||
"""返回需要合并的闭区间（数据行下标，不含表头）。单行不合并。"""
|
||
spans: list[tuple[int, int]] = []
|
||
index = 0
|
||
total = len(rows)
|
||
while index < total:
|
||
key = key_fn(rows[index])
|
||
end = index + 1
|
||
while end < total and key_fn(rows[end]) == key:
|
||
end += 1
|
||
if end - index > 1:
|
||
spans.append((index, end - 1))
|
||
index = end
|
||
return spans
|
||
|
||
|
||
_PLAN_LIST_PLAN_MERGE_FIELDS = frozenset(
|
||
{
|
||
"planNo",
|
||
"belongsCompany",
|
||
"followStatus",
|
||
"planDate",
|
||
"deliveryTimes",
|
||
"planType",
|
||
"licensePlate",
|
||
"personnelSummary",
|
||
"followUserName",
|
||
"archiveStatus",
|
||
"erpEntered",
|
||
"hazardCertReady",
|
||
"loadCustomer",
|
||
"loadAddressTime",
|
||
"loadDibang",
|
||
}
|
||
)
|
||
_PLAN_LIST_DELIVERY_MERGE_FIELDS = frozenset(
|
||
{
|
||
"deliveryCustomer",
|
||
"deliveryAddressTime",
|
||
"deliveryDibang",
|
||
}
|
||
)
|
||
_PLAN_LIST_LOAD_COPY_FIELDS = ("loadCustomer", "loadAddressTime", "loadDibang")
|
||
|
||
|
||
def _export_plan_group_key(row: dict) -> str:
|
||
return str(row.get("planId") or row.get("id") or "")
|
||
|
||
|
||
def prepare_archive_list_display_rows(
|
||
rows: list[dict],
|
||
*,
|
||
contract_field: str = "contractNo",
|
||
load_fields: tuple[str, ...] = ("loadCustomer", "loadAddress", "loadTime"),
|
||
delivery_fields: Optional[frozenset] = None,
|
||
number_plans: bool = True,
|
||
join_plan_fields: tuple[str, ...] = (),
|
||
) -> list[dict]:
|
||
"""按列表合并规则整理单元格取值。
|
||
|
||
序号按计划计，一张计划一个号（归档导出）。
|
||
只有一个送货段时，送货侧字段写到该计划首行，以便和装货行合并后仍能看见。
|
||
多个送货段时，装货行的送货客户为「—」。
|
||
"""
|
||
if delivery_fields is None:
|
||
delivery_fields = _DELIVERY_LEVEL_MERGE_FIELDS
|
||
prepared: list[dict] = []
|
||
plan_index = 0
|
||
cursor = 0
|
||
while cursor < len(rows):
|
||
plan_id = _export_plan_group_key(rows[cursor])
|
||
end = cursor + 1
|
||
while end < len(rows) and _export_plan_group_key(rows[end]) == plan_id:
|
||
end += 1
|
||
group = [dict(item) for item in rows[cursor:end]]
|
||
plan_index += 1
|
||
delivery_seqs: list[int] = []
|
||
for item in group:
|
||
if item.get("_stopKind") == "delivery" and item.get("_deliverySeq") is not None:
|
||
seq = int(item["_deliverySeq"])
|
||
if seq not in delivery_seqs:
|
||
delivery_seqs.append(seq)
|
||
sole_seq = delivery_seqs[0] if len(delivery_seqs) == 1 else None
|
||
for item in group:
|
||
kind = item.get("_stopKind") or ""
|
||
if kind == "load":
|
||
merge_seq = sole_seq if sole_seq is not None else 0
|
||
elif kind == "delivery":
|
||
merge_seq = int(item.get("_deliverySeq") or 1)
|
||
else:
|
||
merge_seq = 1
|
||
item["_mergeDeliverySeq"] = merge_seq
|
||
item["_contractMergeKey"] = (
|
||
f"{kind}|{merge_seq}|{item.get(contract_field) or ''}"
|
||
)
|
||
if number_plans:
|
||
item["rowNo"] = plan_index
|
||
if sole_seq is not None:
|
||
delivery_row = next((item for item in group if item.get("_stopKind") == "delivery"), None)
|
||
if delivery_row is not None:
|
||
for field in delivery_fields:
|
||
group[0][field] = delivery_row.get(field) or ""
|
||
else:
|
||
for item in group:
|
||
if item.get("_mergeDeliverySeq") != 0:
|
||
continue
|
||
if not item.get("deliveryCustomer"):
|
||
item["deliveryCustomer"] = "—"
|
||
load_row = next((item for item in group if item.get("_stopKind") == "load"), None)
|
||
if load_row is not None:
|
||
for field in load_fields:
|
||
if not group[0].get(field):
|
||
group[0][field] = load_row.get(field) or ""
|
||
for field in join_plan_fields:
|
||
seen: list[str] = []
|
||
for item in group:
|
||
text = str(item.get(field) or "").strip()
|
||
if text and text not in seen:
|
||
seen.append(text)
|
||
if seen:
|
||
group[0][field] = "\n".join(seen)
|
||
prepared.extend(group)
|
||
cursor = end
|
||
return prepared
|
||
|
||
|
||
def append_archive_list_merge_sheet(
|
||
wb,
|
||
columns,
|
||
rows: list[dict],
|
||
resolver,
|
||
*,
|
||
sheet_title: Optional[str] = None,
|
||
plan_fields: Optional[frozenset] = None,
|
||
delivery_fields: Optional[frozenset] = None,
|
||
contract_field: str = "contractNo",
|
||
load_fields: tuple[str, ...] = ("loadCustomer", "loadAddress", "loadTime"),
|
||
number_plans: bool = True,
|
||
join_plan_fields: tuple[str, ...] = (),
|
||
) -> None:
|
||
"""追加按列表合并的 sheet。默认标题为「计划归档（合并）」。"""
|
||
from openpyxl.styles import Alignment
|
||
|
||
if delivery_fields is None:
|
||
delivery_fields = _DELIVERY_LEVEL_MERGE_FIELDS
|
||
if plan_fields is None:
|
||
plan_fields = _PLAN_LEVEL_MERGE_FIELDS
|
||
display_rows = prepare_archive_list_display_rows(
|
||
list(rows),
|
||
contract_field=contract_field,
|
||
load_fields=load_fields,
|
||
delivery_fields=delivery_fields,
|
||
number_plans=number_plans,
|
||
join_plan_fields=join_plan_fields,
|
||
)
|
||
sheet = wb.create_sheet((sheet_title or ARCHIVE_MERGED_SHEET_TITLE)[:31])
|
||
sheet.append([column.title for column in columns])
|
||
for row in display_rows:
|
||
sheet.append(resolver.row_to_cells(row, columns))
|
||
|
||
field_column = {column.field: index + 1 for index, column in enumerate(columns)}
|
||
vertical = Alignment(vertical="center", wrap_text=True)
|
||
|
||
def merge_fields(fields, spans: list[tuple[int, int]]) -> None:
|
||
for field in fields:
|
||
column_index = field_column.get(field)
|
||
if not column_index:
|
||
continue
|
||
for start, end in spans:
|
||
sheet.merge_cells(
|
||
start_row=start + 2,
|
||
start_column=column_index,
|
||
end_row=end + 2,
|
||
end_column=column_index,
|
||
)
|
||
sheet.cell(start + 2, column_index).alignment = vertical
|
||
|
||
plan_key = _export_plan_group_key
|
||
plan_spans = _iter_equal_spans(display_rows, plan_key)
|
||
merged_plan_fields = set(plan_fields)
|
||
merged_plan_fields.update(field for field in field_column if str(field).startswith("attach"))
|
||
merge_fields(merged_plan_fields, plan_spans)
|
||
merge_fields(
|
||
delivery_fields,
|
||
_iter_equal_spans(
|
||
display_rows,
|
||
lambda row: (_export_plan_group_key(row), row.get("_mergeDeliverySeq")),
|
||
),
|
||
)
|
||
if contract_field in field_column:
|
||
merge_fields(
|
||
[contract_field],
|
||
_iter_equal_spans(
|
||
display_rows,
|
||
lambda row: (_export_plan_group_key(row), row.get("_contractMergeKey")),
|
||
),
|
||
)
|
||
|
||
|
||
def export_plan_list_xlsx_response(
|
||
db,
|
||
*,
|
||
tenant_no: str,
|
||
sheet_title: str,
|
||
columns,
|
||
rows: list[dict],
|
||
filename_stem: str,
|
||
):
|
||
"""运输计划 / 危化品证列表 Excel：明细页 + 按列表合并的第二页。"""
|
||
from app.utils.excel_export import (
|
||
DictLabelResolver,
|
||
ExportValidationError,
|
||
assert_export_row_count,
|
||
workbook_to_streaming_response,
|
||
)
|
||
from openpyxl import Workbook
|
||
|
||
assert_export_row_count(len(rows))
|
||
if not columns:
|
||
raise ExportValidationError("没有可导出的列")
|
||
resolver = DictLabelResolver(db, columns, tenant_no=tenant_no)
|
||
workbook = Workbook()
|
||
detail = workbook.active
|
||
detail.title = sheet_title[:31]
|
||
detail.append([column.title for column in columns])
|
||
for row in rows:
|
||
detail.append(resolver.row_to_cells(row, columns))
|
||
append_archive_list_merge_sheet(
|
||
workbook,
|
||
columns,
|
||
rows,
|
||
resolver,
|
||
sheet_title=f"{sheet_title}（合并）",
|
||
plan_fields=_PLAN_LIST_PLAN_MERGE_FIELDS,
|
||
delivery_fields=_PLAN_LIST_DELIVERY_MERGE_FIELDS,
|
||
contract_field="productContract",
|
||
load_fields=_PLAN_LIST_LOAD_COPY_FIELDS,
|
||
number_plans=False,
|
||
join_plan_fields=("deliveryTimes",),
|
||
)
|
||
return workbook_to_streaming_response(workbook, filename_stem=filename_stem)
|
||
|
||
|
||
def export_plan_archive_xlsx_response(
|
||
db,
|
||
*,
|
||
tenant_no: str,
|
||
columns,
|
||
rows: list[dict],
|
||
filename_stem: str,
|
||
):
|
||
"""归档 Excel：第一页为段次明细，第二页为列表合并样式。"""
|
||
from app.utils.excel_export import (
|
||
DictLabelResolver,
|
||
ExportValidationError,
|
||
assert_export_row_count,
|
||
workbook_to_streaming_response,
|
||
)
|
||
from openpyxl import Workbook
|
||
|
||
assert_export_row_count(len(rows))
|
||
if not columns:
|
||
raise ExportValidationError("没有可导出的列")
|
||
resolver = DictLabelResolver(db, columns, tenant_no=tenant_no)
|
||
workbook = Workbook()
|
||
detail = workbook.active
|
||
detail.title = "计划归档"
|
||
detail.append([column.title for column in columns])
|
||
for row in rows:
|
||
detail.append(resolver.row_to_cells(row, columns))
|
||
append_archive_list_merge_sheet(workbook, columns, rows, resolver)
|
||
return workbook_to_streaming_response(workbook, filename_stem=filename_stem)
|