# ============================================================ # LNS 插单局部修复与影响半径（moduleId: domain-lns, OR-04 扩展，可重生 ✅） # 规则：固定窗口内最小扰动（窗口外订单冻结不动）；超过影响阈值 # 自动升级全量重排（ESCALATE → rush.apply 走 P2 人工确认）。 # 依赖：RULE 引擎物化急单工时；经典"插入+右移级联"邻域搜索。 # ============================================================ from __future__ import annotations import copy import uuid from datetime import datetime from typing import Any from server.aps_domain.rush import inject_rush_trunk, resolve_rush_payload from server.contracts import ScheduleResult, UIBlock from server.engines import get_engine from server.engines.base import EngineParams from server.timeutil import add_minutes, fmt_date, fmt_dt, parse_dt, today0 World = dict[str, Any] # ---- 默认窗口参数（可被 window 覆盖）---- DEFAULT_WINDOW_HOURS = 72.0 # 时间窗宽度：急单锚点前后各半 DEFAULT_MAX_AFFECTED = 5 # 受影响订单数上限（超过 → 升级） DEFAULT_DISTURBANCE_TOLERANCE = 0.5 # 扰动容忍度阈值（移动数 / 窗口订单数） def _counter(world: World): tables = { "scheduleVersion": "scheduleVersions", "productionOrder": "productionOrders", "workOrder": "workOrders", "salesOrder": "salesOrders", "conflict": "conflicts", "audit": "auditEvents", "log": "logs", } counters: dict[str, int] = {} def next_id(kind: str) -> int: key = tables.get(kind, kind + "s") rows = world.get(key, []) if kind not in counters: counters[kind] = max((r.get("id", 0) for r in rows if isinstance(r, dict)), default=0) counters[kind] += 1 return counters[kind] return next_id def _hours(a: datetime, b: datetime) -> float: return (b - a).total_seconds() / 3600.0 def _engine_params(world: World, order_ids: list[int], start_date: str | None) -> EngineParams: """RULE 引擎入参：可限定订单集（LNS 局部求解用）。""" from server.aps_domain.constraints import engine_constraint_flags from server.aps_domain.params import get_schedule_params sp = get_schedule_params(world) return EngineParams( orderIds=order_ids, engineType="RULE", strategyTemplate="DELIVERY_FIRST", planningHorizonDays=int(sp.get("planningHorizonDays") or 14), startDate=start_date or fmt_date(add_minutes(today0(), 24 * 60)), constraints=engine_constraint_flags(world), ) def _due_map(world: World) -> dict[int, str]: return {so["id"]: so["deliveryDate"] for so in world.get("salesOrders", []) if so.get("deliveryDate")} def _po_tardiness(po: dict, due_map: dict[int, str]) -> float: due = due_map.get(po.get("salesOrderId")) if not due: return 0.0 return max(0.0, _hours(parse_dt(due), parse_dt(po["plannedEndDate"]))) def _latest_schedule(world: World) -> dict[str, Any]: """当前排产：最新版本的 PO/WO 集合（无版本时回退全部 PO）。""" versions = world.get("scheduleVersions") or [] if versions: vid = versions[-1]["id"] pos = [p for p in world.get("productionOrders", []) if p.get("schedulingVersionId") == vid] if pos: return {"versionId": vid, "productionOrders": pos} return {"versionId": None, "productionOrders": list(world.get("productionOrders", []))} def _rush_duration_mini_solve(world: World, rush: dict[str, Any]) -> tuple[float, int] | None: """沙盒内只排急单，取自然落点（产线 + 工时）。返回 (时长小时, 产线 id) 或 None。""" sb = copy.deepcopy(world) sb["productionOrders"] = [] sb["workOrders"] = [] sb["conflicts"] = [] from server.aps_domain.rush import inject_rush order = inject_rush(sb, rush) try: result = get_engine("RULE").solve(sb, _engine_params(sb, [order["id"]], None), _counter(sb)) except Exception: return None pos = [p for p in sb.get("productionOrders", []) if p.get("salesOrderId") == order["id"]] if not pos or result.poCount <= 0: return None po = pos[0] dur = _hours(parse_dt(po["plannedStartDate"]), parse_dt(po["plannedEndDate"])) return dur, po.get("lineId") def _build_window(world: World, rush: dict[str, Any], anchor: datetime, window_params: dict[str, Any] | None) -> dict[str, Any]: """构造固定时间窗（锚点 ± 半窗；可显式指定 windowStart/End 覆盖）。""" wp = dict(window_params or {}) hours = float(wp.get("timeWindowHours") or DEFAULT_WINDOW_HOURS) start_dt = parse_dt(wp["windowStart"]) if wp.get("windowStart") else add_minutes(anchor, -hours * 60 / 2) end_dt = parse_dt(wp["windowEnd"]) if wp.get("windowEnd") else add_minutes(anchor, hours * 60 / 2) if end_dt <= start_dt: raise ValueError("LNS 窗口参数非法：windowEnd 必须晚于 windowStart") return { "start": fmt_dt(start_dt), "end": fmt_dt(end_dt), "anchor": fmt_date(anchor), "timeWindowHours": hours, "maxAffectedOrders": int(wp.get("maxAffectedOrders") or DEFAULT_MAX_AFFECTED), "disturbanceTolerance": float(wp.get("disturbanceTolerance") or DEFAULT_DISTURBANCE_TOLERANCE), "windowStart": fmt_dt(start_dt), "windowEnd": fmt_dt(end_dt), } def _line_sequence(world: World, line_id: int) -> list[dict]: return sorted( [p for p in world.get("productionOrders", []) if p.get("lineId") == line_id and p.get("plannedStartDate") and p.get("plannedEndDate")], key=lambda p: (p["plannedStartDate"], p["id"]), ) def _cascade_insert(seq: list[dict], slot: datetime, rush_dur: float, window_end: datetime) -> tuple[list[tuple[dict, datetime, datetime, float]], datetime, datetime] | None: """经典"插入 + 右移级联"：把急单放入 slot，后续重叠订单依次右移。 返回 (moved, rush_start, rush_end)；moved 为 [(po, 原start, 新start, 位移小时)]。 若级联需要移动窗口外订单（原 start >= 窗口右沿）→ 返回 None（影响半径越界）。 """ idx = len(seq) for i, po in enumerate(seq): if parse_dt(po["plannedStartDate"]) >= slot: idx = i break cursor = slot if idx > 0: cursor = max(cursor, parse_dt(seq[idx - 1]["plannedEndDate"])) rush_start = cursor rush_end = add_minutes(cursor, rush_dur * 60) cursor = rush_end moved: list[tuple[dict, datetime, datetime, float]] = [] for po in seq[idx:]: s = parse_dt(po["plannedStartDate"]) e = parse_dt(po["plannedEndDate"]) if s < cursor: if s >= window_end: # 窗口外订单被波及 → 升级信号 return None delta = _hours(s, cursor) moved.append((po, s, cursor, delta)) e = add_minutes(e, delta * 60) s = cursor cursor = e return moved, rush_start, rush_end def _candidate_slots(seq: list[dict], window: dict[str, Any], rush_dur: float, due: datetime | None) -> list[datetime]: w_start = parse_dt(window["start"]) w_end = parse_dt(window["end"]) slots: set[datetime] = {w_start} for po in seq: s, e = parse_dt(po["plannedStartDate"]), parse_dt(po["plannedEndDate"]) if (w_start <= s <= w_end) or (w_start <= e <= w_end): slots.add(e) # 窗口内订单的完工点也是候选插入点 if due is not None: slots.add(add_minutes(due, -rush_dur * 60)) # 对准交期倒排 slots.add(add_minutes(w_end, -rush_dur * 60)) # 窗口右沿倒排 out = [] for s in slots: s = max(s, w_start) if add_minutes(s, rush_dur * 60) <= w_end: # 只保留窗口内能放下的候选 out.append(s) return sorted(set(out)) def lns_local_repair(world: World, payload: dict[str, Any], window: dict[str, Any] | None = None) -> dict[str, Any]: """LNS 插单局部修复评估（P1，沙盒）：窗口内最小扰动 vs 升级全量重排。 Args: world: 世界状态（含当前排产版本 productionOrders） payload: 与 evaluate_rush 相同的插单载荷（orderNo 或 productCode/quantity/...） window: 可选窗口参数覆盖：{timeWindowHours, maxAffectedOrders, disturbanceTolerance, windowStart, windowEnd} Returns: {status: "LOCAL"|"ESCALATE", window, disturbance, plan, escalateReasons, ...} 纯沙盒：不修改传入 world。 """ sandbox = copy.deepcopy(world) # P1：主干零接触 rush = resolve_rush_payload(sandbox, payload) strategy = str(payload.get("strategy") or "DELIVERY_FIRST").upper() due = parse_dt(rush.get("deliveryDate") or fmt_date(add_minutes(today0(), 5 * 24 * 60))) current = _latest_schedule(sandbox) due_map = _due_map(sandbox) # 急单自身信息：新建 → 迷你求解取工时；已有 → 用当前排产中的 PO rush_po: dict | None = None for po in current["productionOrders"]: if po.get("salesOrderId") == rush.get("id"): rush_po = po break if rush_po is not None: dur = _hours(parse_dt(rush_po["plannedStartDate"]), parse_dt(rush_po["plannedEndDate"])) line_id = rush_po.get("lineId") anchor = parse_dt(rush_po["plannedStartDate"]) else: solved = _rush_duration_mini_solve(sandbox, rush) if solved is None: return _escalate_result(rush, strategy, window, ["急单无可用产线/无法物化，需全量重排"]) dur, line_id = solved anchor = due win = _build_window(sandbox, rush, anchor, window) w_start = parse_dt(win["start"]) w_end = parse_dt(win["end"]) if rush_po is None: seq = [p for p in _line_sequence(sandbox, line_id) if p.get("salesOrderId") != rush.get("id")] else: seq = [p for p in _line_sequence(sandbox, line_id) if p.get("id") != rush_po["id"]] window_order_count = sum( 1 for p in sandbox.get("productionOrders", []) if (w_start <= parse_dt(p["plannedStartDate"]) <= w_end) or (w_start <= parse_dt(p["plannedEndDate"]) <= w_end) ) # 基准扰动指标（全量延迟） base_tardiness = sum(_po_tardiness(p, due_map) for p in sandbox.get("productionOrders", [])) if dur > _hours(w_start, w_end): return _escalate_result(rush, strategy, win, [f"急单工时 {dur:.1f}h 超过窗口宽度 {_hours(w_start, w_end):.1f}h"]) candidates: list[tuple[tuple, list, datetime, datetime]] = [] for slot in _candidate_slots(seq, win, dur, due): res = _cascade_insert(seq, slot, dur, w_end) if res is None: continue # 波及窗口外 → 该候选不可行 moved, rush_start, rush_end = res if rush_start < w_start or rush_end > w_end: continue # 急单必须落在窗口内（固定窗口语义） # 扰动度量 shifted = sum(m[3] for m in moved) after_tardiness = base_tardiness for po, s0, s1, delta in moved: after_tardiness += _po_tardiness({**po, "plannedEndDate": fmt_dt( add_minutes(parse_dt(po["plannedEndDate"]), delta * 60))}, due_map) - _po_tardiness(po, due_map) after_tardiness += max(0.0, _hours(due, rush_end)) t_delta = after_tardiness - base_tardiness score = (len(moved), round(shifted, 2), round(t_delta, 2), rush_start) candidates.append((score, moved, rush_start, rush_end)) if not candidates: return _escalate_result(rush, strategy, win, ["窗口内无可行插入点（急单放不下或所有方案均波及窗口外订单）"]) score, moved, rush_start, rush_end = min(candidates, key=lambda c: c[0]) chosen = next((c for c in candidates if c[0] == score), None) moved_order_count = len(moved) shifted_hours = round(sum(m[3] for m in moved), 2) ratio = moved_order_count / max(1, window_order_count) plan_moves = [] for po, s0, s1, delta in moved: plan_moves.append({ "salesOrderId": po.get("salesOrderId"), "orderNo": po.get("orderNo"), "beforeStart": fmt_dt(s0), "afterStart": fmt_dt(s1), "afterEnd": fmt_dt(add_minutes(parse_dt(po["plannedEndDate"]), delta * 60)), "deltaHours": round(delta, 2), "isRush": False, }) plan_moves.sort(key=lambda m: m["afterStart"]) rush_end_gap = round(_hours(due, rush_end), 2) # 负值 = 提前完工 reasons: list[str] = [] if moved_order_count > win["maxAffectedOrders"]: reasons.append(f"受影响订单 {moved_order_count} 条 > 上限 {win['maxAffectedOrders']} 条") if ratio > win["disturbanceTolerance"]: reasons.append(f"扰动率 {ratio:.0%} 超过容忍阈值 {win['disturbanceTolerance']:.0%}") # 影响半径：窗口尾部积压风险（信息性，不单独升级） chain_risk = False chain_reason = None last_end = rush_end for m in plan_moves: last_end = max(last_end, parse_dt(m["afterEnd"])) if last_end > w_end: chain_risk = True chain_reason = f"窗口尾部积压至 {fmt_dt(last_end)}，后续订单存在外溢风险" line_name = next((ln["name"] for ln in sandbox.get("lines", []) if ln["id"] == line_id), None) plan = { "rushStart": fmt_dt(rush_start), "rushEnd": fmt_dt(rush_end), "lineId": line_id, "lineName": line_name, "movedOrders": plan_moves, "rushOrder": { "salesOrderId": rush.get("id"), "orderNo": rush.get("orderNo"), "productCode": rush.get("productCode"), "productName": rush.get("productName"), "quantity": rush.get("quantity"), "isNew": rush_po is None, }, } disturbance = { "movedOrderCount": moved_order_count, "shiftedHours": shifted_hours, "tardinessDelta": round(chosen[0][2], 2) if chosen else 0.0, "windowOuterMovedCount": 0, # 级联已拒绝所有波及窗口外的候选 "disturbanceRatio": round(ratio, 4), "rushEndGapHours": rush_end_gap, } status = "LOCAL" if not reasons else "ESCALATE" return { "lnsId": uuid.uuid4().hex[:10], "status": status, "escalate": status == "ESCALATE", "escalateReasons": reasons, "escalation": {"mode": "FULL_RESCHEDULE"} if reasons else None, "strategy": strategy if strategy in ("DELIVERY_FIRST", "CAPACITY_BALANCE", "COMPREHENSIVE") else "DELIVERY_FIRST", "mode": rush["mode"], "window": {**win, "lineId": line_id, "lineName": line_name, "windowOrderCount": window_order_count}, "rushOrder": { "orderNo": rush.get("orderNo"), "id": rush.get("id"), "customerName": rush.get("customerName"), "productCode": rush.get("productCode"), "productName": rush.get("productName"), "quantity": rush.get("quantity"), "deliveryDate": rush.get("deliveryDate"), "isRush": True, }, "disturbance": disturbance, "plan": plan, "chainRisk": {"flag": chain_risk, "reason": chain_reason}, "baseline": {"orderCount": len(sandbox.get("salesOrders", [])), "poCount": len(current["productionOrders"]), "windowOrderCount": window_order_count}, "payload": rush, } def _escalate_result(rush: dict[str, Any], strategy: str, window: dict[str, Any] | None, reasons: list[str]) -> dict[str, Any]: return { "lnsId": uuid.uuid4().hex[:10], "status": "ESCALATE", "escalate": True, "escalateReasons": reasons, "escalation": {"mode": "FULL_RESCHEDULE"}, "strategy": strategy if strategy in ("DELIVERY_FIRST", "CAPACITY_BALANCE", "COMPREHENSIVE") else "DELIVERY_FIRST", "mode": rush["mode"], "window": window or {}, "rushOrder": { "orderNo": rush.get("orderNo"), "id": rush.get("id"), "customerName": rush.get("customerName"), "productCode": rush.get("productCode"), "productName": rush.get("productName"), "quantity": rush.get("quantity"), "deliveryDate": rush.get("deliveryDate"), "isRush": True, }, "disturbance": {"movedOrderCount": 0, "shiftedHours": 0.0, "tardinessDelta": 0.0, "windowOuterMovedCount": 0, "disturbanceRatio": 0.0, "rushEndGapHours": None}, "plan": None, "chainRisk": {"flag": False, "reason": None}, "baseline": {}, "payload": rush, } def apply_lns_local(world: World, next_id, params: dict[str, Any]) -> dict[str, Any]: """LNS 局部方案落主干（P2）：急单入池 + 局部移动 + 新 DRAFT 版本（delta 计划）。 调用方负责 checkpoint/审计（复用 rush.apply 的 P2 建档模式）。 仅接受 status == "LOCAL" 的方案；升级场景请走 apply_rush 全量重排。 """ lns = params.get("lns") or {} if lns.get("status") != "LOCAL": raise ValueError("apply_lns_local 仅接受 LOCAL 方案；升级场景应走全量重排 apply_rush") rush = resolve_rush_payload(world, params.get("payload") or lns.get("payload") or params) order = inject_rush_trunk(world, next_id, rush) versions = world["scheduleVersions"] old_vid = versions[-1]["id"] if versions else None new_vid = next_id("scheduleVersion") now = datetime.now() ver_no = "V" + fmt_date(now).replace("-", "") + f"-{len(versions) + 1:03d}" # ① 复制上一版本 PO/WO 到新版本（沿用 adjust.py 的调程建档模式） old_pos = [p for p in world.get("productionOrders", []) if old_vid is None or p.get("schedulingVersionId") == old_vid] po_map: dict[int, int] = {} for po in old_pos: nid = next_id("productionOrder") po_map[po["id"]] = nid np = copy.deepcopy(po) np["id"] = nid np["schedulingVersionId"] = new_vid world["productionOrders"].append(np) for wo in world.get("workOrders", []): if wo.get("productionOrderId") not in po_map: continue nw = copy.deepcopy(wo) nid = next_id("workOrder") nw["id"] = nid nw["productionOrderId"] = po_map[wo["productionOrderId"]] world["workOrders"].append(nw) # ② 应用局部移动（按 salesOrderId 定位新版本 PO；同步平移其工单） moves = (lns.get("plan") or {}).get("movedOrders") or [] applied_moves = 0 for mv in moves: sid = mv.get("salesOrderId") if sid is None or sid == rush.get("id"): continue # 急单自身由 ③ 物化 np = next((p for p in world["productionOrders"] if p.get("schedulingVersionId") == new_vid and p.get("salesOrderId") == sid), None) if np is None: continue before = parse_dt(np["plannedStartDate"]) after = parse_dt(mv["afterStart"]) delta = _hours(before, after) np["plannedStartDate"] = mv["afterStart"] np["plannedEndDate"] = mv["afterEnd"] for wo in world.get("workOrders", []): if wo.get("productionOrderId") == np["id"]: wo["plannedStartTime"] = fmt_dt(add_minutes(parse_dt(wo["plannedStartTime"]), delta * 60)) wo["plannedEndTime"] = fmt_dt(add_minutes(parse_dt(wo["plannedEndTime"]), delta * 60)) applied_moves += 1 # ③ 物化急单 PO/WO（沙盒迷你求解 → 平移到计划槽位） plan = lns.get("plan") or {} rush_start = parse_dt(plan["rushStart"]) if lns.get("mode") == "existing" and (lns.get("plan") or {}).get("rushOrder", {}).get("isNew") is False: # 已有订单：其 PO 已在 ① 复制，直接平移到计划槽位 existing = next((p for p in world["productionOrders"] if p.get("schedulingVersionId") == new_vid and p.get("salesOrderId") == rush.get("id")), None) if existing is not None: before = parse_dt(existing["plannedStartDate"]) delta = _hours(before, rush_start) existing["plannedStartDate"] = plan["rushStart"] existing["plannedEndDate"] = plan["rushEnd"] for wo in world.get("workOrders", []): if wo.get("productionOrderId") == existing["id"]: wo["plannedStartTime"] = fmt_dt(add_minutes(parse_dt(wo["plannedStartTime"]), delta * 60)) wo["plannedEndTime"] = fmt_dt(add_minutes(parse_dt(wo["plannedEndTime"]), delta * 60)) else: sb = copy.deepcopy(world) sb["productionOrders"] = [] sb["workOrders"] = [] sb["conflicts"] = [] get_engine("RULE").solve(sb, _engine_params(sb, [order["id"]], fmt_date(rush_start)), _counter(sb)) rp = next((p for p in sb.get("productionOrders", []) if p.get("salesOrderId") == order["id"]), None) if rp is None: raise ValueError("LNS 急单物化失败：迷你求解未生成生产订单") delta = _hours(parse_dt(rp["plannedStartDate"]), rush_start) new_po = copy.deepcopy(rp) new_po["id"] = next_id("productionOrder") new_po["schedulingVersionId"] = new_vid new_po["plannedStartDate"] = plan["rushStart"] new_po["plannedEndDate"] = plan["rushEnd"] world["productionOrders"].append(new_po) for wo in sb.get("workOrders", []): if wo.get("productionOrderId") != rp["id"]: continue nw = copy.deepcopy(wo) nw["id"] = next_id("workOrder") nw["productionOrderId"] = new_po["id"] nw["plannedStartTime"] = fmt_dt(add_minutes(parse_dt(wo["plannedStartTime"]), delta * 60)) nw["plannedEndTime"] = fmt_dt(add_minutes(parse_dt(wo["plannedEndTime"]), delta * 60)) world["workOrders"].append(nw) # ④ （无整体回填：PO 与工单统一平移，保持计划槽位与扰动度量一致） # ⑤ 指标统计（局部口径：受影响产线窗口内延迟/冲突近似） due_map = _due_map(world) new_pos = [p for p in world["productionOrders"] if p.get("schedulingVersionId") == new_vid] total_tardiness = round(sum(_po_tardiness(p, due_map) for p in new_pos), 2) line_id = plan.get("lineId") line_pos = sorted([p for p in new_pos if p.get("lineId") == line_id and p.get("plannedStartDate")], key=lambda p: p["plannedStartDate"]) overlap = 0 prev_end = None for p in line_pos: s = parse_dt(p["plannedStartDate"]) if prev_end is not None and s < prev_end: overlap += 1 prev_end = max(prev_end, parse_dt(p["plannedEndDate"])) if prev_end is not None else parse_dt(p["plannedEndDate"]) win = lns.get("window") or {} w_start, w_end = parse_dt(win.get("start") or "2000-01-01 00:00"), parse_dt(win.get("end") or "2999-12-31 00:00") busy_h = sum(max(0.0, (min(parse_dt(p["plannedEndDate"]), w_end) - max(parse_dt(p["plannedStartDate"]), w_start)).total_seconds() / 3600) for p in new_pos if p.get("lineId") == line_id and w_end > w_start) base_ver = versions[-1] if versions else {} new_ver = { **{k: v for k, v in base_ver.items() if k not in ("id", "versionNo", "versionName", "createdAt", "createdBy", "publishedAt", "parentVersionId")}, "id": new_vid, "versionNo": ver_no, "versionName": f"LNS 插单局部修复 · {rush.get('orderNo')}", "triggerType": "LNS_RUSH", "status": "DRAFT", "parentVersionId": old_vid, "orderCount": len(world.get("salesOrders", [])), "poCount": len(new_pos), "woCount": sum(1 for w in world.get("workOrders", []) if w.get("productionOrderId") in {p["id"] for p in new_pos}), "totalTardiness": total_tardiness, "conflictCount": overlap, "createdBy": "agent", "createdAt": fmt_dt(now), "publishedAt": None, "note": (f"LNS 局部修复：移动 {applied_moves} 单 · 位移 {lns.get('disturbance', {}).get('shiftedHours', 0)}h · " f"急单 {rush.get('orderNo')}（窗口 {win.get('start')}~{win.get('end')}）"), "lns": { "lnsId": lns.get("lnsId"), "status": lns.get("status"), "disturbance": lns.get("disturbance"), "window": {k: win.get(k) for k in ("start", "end", "timeWindowHours", "maxAffectedOrders", "disturbanceTolerance")}, }, } versions.append(new_ver) result = ScheduleResult( versionId=new_vid, versionNo=ver_no, engineType="RULE", strategy=lns.get("strategy") or "DELIVERY_FIRST", status="DRAFT", orderCount=new_ver["orderCount"], poCount=new_ver["poCount"], woCount=new_ver["woCount"], conflictCount=overlap, totalTardiness=total_tardiness, avgUtilization=round(busy_h / max(1.0, _hours(w_start, w_end)), 3), evidenceRefs=[f"lns:{lns.get('lnsId')}"], solveStatus="LOCAL_REPAIR", ) return {"order": order, "result": result, "mode": "LNS_LOCAL", "disturbance": lns.get("disturbance"), "lns": lns} def format_lns_text(lns: dict[str, Any]) -> str: """LNS 评估结果中文摘要（对话侧）。""" rush = lns.get("rushOrder") or {} win = lns.get("window") or {} lines = [ f"LNS 插单局部修复（沙盒，未改主干）· 策略 {lns.get('strategy')}", f"急单：{rush.get('customerName') or rush.get('orderNo')} · {rush.get('productName')} × {rush.get('quantity')} · 交期 {rush.get('deliveryDate')}", f"时间窗：{win.get('start')} ~ {win.get('end')}（产线 {win.get('lineName') or win.get('lineId')} · 上限 {win.get('maxAffectedOrders')} 单 · 容忍 {win.get('disturbanceTolerance'):.0%}）" if win else "时间窗：默认", ] if lns.get("status") == "LOCAL": d = lns.get("disturbance") or {} plan = lns.get("plan") or {} lines += [ (f"方案：{plan.get('rushStart')} → {plan.get('rushEnd')}（{'提前' if d.get('rushEndGapHours') is not None and d['rushEndGapHours'] <= 0 else '超期'} " f"{abs(d.get('rushEndGapHours') or 0):.1f}h）"), f"扰动：移动 {d.get('movedOrderCount')} 单 · 位移 {d.get('shiftedHours')}h · 延迟变化 {d.get('tardinessDelta'):+.1f}h · 窗口外 {d.get('windowOuterMovedCount')} 单", ] if lns.get("chainRisk", {}).get("flag"): lines.append(f"提示：{lns['chainRisk']['reason']}") lines.append("确认后说「采用插单」（LNS 局部方案入 DRAFT 试排草稿，P2 写前自动建档）。") else: reasons = lns.get("escalateReasons") or [] lines.append("升级全量重排 ⚠️ " + "；".join(reasons)) lines.append("确认后说「采用插单」将执行全量重排并生成 DRAFT 版本（P2 人工确认）。") return "\n".join(lines) def lns_to_block(lns: dict[str, Any]) -> UIBlock: """对话侧 LNS 结果块（复用 rush 卡片样式）。""" rush = lns.get("rushOrder") or {} d = lns.get("disturbance") or {} status = lns.get("status") if status == "LOCAL": plan = lns.get("plan") or {} title = "LNS 插单局部修复（窗口内最小扰动）" text = ( f"急单：{rush.get('orderNo') or '（新建）'} · {rush.get('productName')} × {rush.get('quantity')}\n" f"落点：{plan.get('rushStart')} → {plan.get('rushEnd')}（{plan.get('lineName') or plan.get('lineId')}）\n" f"扰动：移动 {d.get('movedOrderCount')} 单 · 位移 {d.get('shiftedHours')}h · 延迟 {d.get('tardinessDelta'):+.1f}h\n" f"窗口外受影响：{d.get('windowOuterMovedCount')} 单（冻结 ✅）" ) else: title = "LNS 升级全量重排" text = (f"急单：{rush.get('orderNo') or '（新建）'} · {rush.get('productName')} × {rush.get('quantity')}\n" f"升级原因：{'；'.join(lns.get('escalateReasons') or ['影响半径超过阈值'])}\n" "确认后将执行全量重排并生成 DRAFT 版本（P2）。") return UIBlock( blockId=f"lns-{lns.get('lnsId')}", type="text", props={"kind": "lns-repair", "lns": lns, "title": title, "text": text}, actions=[], )