629 lines
30 KiB
Python
629 lines
30 KiB
Python
# ============================================================
|
||
# WMS 缺料事件消费管线（moduleId: domain-wms-events, 可重生 ✅）
|
||
# round-38 方向 N：缺料 → 重排端到端闭环 Mock
|
||
# ① 幂等去重：eventId 全局一次消费，乱序/重复不重复触发，落证据链；
|
||
# ② 库存版本随事件更新并写入证据链（evidenceRefs 带 inventory-version）；
|
||
# ③ 缺料 → 影响半径评估（复用 flex 沙盒路径，只读）→ Explore 方案卡（P2 确认）；
|
||
# ④ 确认后走 MES 下发（复用 mes.dispatch，P3 门禁）→ 回执镜像写回审计。
|
||
# 说明：方案卡动作复用既有 flex.reschedule（P2，L4 全量重排），
|
||
# 不改 workflow/harness 既有函数；WMS 侧证据由 wms.* 审计事件携带。
|
||
# ============================================================
|
||
from __future__ import annotations
|
||
|
||
import copy
|
||
import uuid
|
||
from datetime import datetime
|
||
from typing import Any
|
||
|
||
from server.agent_core.audit import write_audit
|
||
from server.engines import PoolEngine
|
||
from server.timeutil import fmt_dt
|
||
|
||
World = dict[str, Any]
|
||
|
||
_FLEX_ACTIVE_STATUSES = ("RELEASED", "CREATED")
|
||
|
||
|
||
def _now() -> str:
|
||
return fmt_dt(datetime.now())
|
||
|
||
|
||
def _ensure_tables(world: World) -> None:
|
||
world.setdefault("inventoryVersion", 0)
|
||
world.setdefault("wmsConsumed", {}) # eventId -> {seq, inventoryVersion, at}
|
||
world.setdefault("wmsPending", []) # 乱序缓冲：按 seq 连续性排空
|
||
world.setdefault("wmsLastSeq", 0)
|
||
world.setdefault("wmsInventoryLedger", []) # WMS 库存台账投影（world 侧）
|
||
world.setdefault("wmsTriggered", {}) # eventId -> {confirmId, inventoryVersion, materialCode, at}
|
||
world.setdefault("wmsReceipts", []) # MES 回执镜像（闭环末端）
|
||
|
||
|
||
def _normalize_event(event: dict[str, Any]) -> dict[str, Any]:
|
||
ev = dict(event or {})
|
||
if not str(ev.get("materialCode") or "").strip():
|
||
raise ValueError("WMS 事件缺少 materialCode")
|
||
ev["materialCode"] = str(ev["materialCode"]).strip()
|
||
ev["type"] = str(ev.get("type") or "SHORTAGE").upper()
|
||
if ev.get("newStock") is not None:
|
||
ev["newStock"] = float(ev["newStock"])
|
||
if ev.get("shortageQty") is not None:
|
||
ev["shortageQty"] = float(ev["shortageQty"])
|
||
if ev.get("seq") is not None:
|
||
ev["seq"] = int(ev["seq"])
|
||
return ev
|
||
|
||
|
||
def _is_shortage(ev: dict[str, Any]) -> bool:
|
||
return ev.get("type") == "SHORTAGE" or float(ev.get("shortageQty") or 0) > 0
|
||
|
||
|
||
# ============================================================
|
||
# ① 幂等去重 + ② 库存版本随事件更新（乱序按 seq 缓冲）
|
||
# ============================================================
|
||
def consume_event(store, event: dict[str, Any], actor: str = "wms") -> dict[str, Any]:
|
||
"""消费一条 WMS 事件：eventId 全局一次；乱序按 seq 缓冲排空；版本单调并落证据链。
|
||
|
||
返回 {duplicate, consumed, eventId, seq, materialCode, inventoryVersion, applied}。
|
||
applied 为本次排空批次的消费记录（含各自 inventoryVersion），乱序时可能 >1 条。
|
||
"""
|
||
world = store.data
|
||
_ensure_tables(world)
|
||
ev = _normalize_event(event)
|
||
event_id = str(ev.get("eventId") or "").strip()
|
||
if not event_id:
|
||
raise ValueError("WMS 事件缺少 eventId")
|
||
seq = int(ev.get("seq") or 0)
|
||
consumed = world["wmsConsumed"]
|
||
if event_id in consumed:
|
||
write_audit(world, store.next_id, actor=actor, category="INTEGRATION",
|
||
action="wms.event.duplicate", target={"type": "WMS_EVENT", "id": event_id},
|
||
power="P1", rationale={"seq": seq, "materialCode": ev["materialCode"],
|
||
"firstVersion": consumed[event_id].get("inventoryVersion")},
|
||
result="DUPLICATE", evidence_refs=[f"wms-event:{event_id}"])
|
||
store.save()
|
||
return {"duplicate": True, "consumed": False, "eventId": event_id, "seq": seq,
|
||
"materialCode": ev["materialCode"], "inventoryVersion": world["inventoryVersion"],
|
||
"applied": [], "reason": "already-consumed"}
|
||
# 乱序容忍：追加缓冲，仅排空 seq 连续的批次（不依赖到达顺序）
|
||
world["wmsPending"].append(ev)
|
||
applied = _drain_pending(store, actor)
|
||
store.save()
|
||
mine = next((a for a in applied if a["eventId"] == event_id), None)
|
||
return {"duplicate": False, "consumed": mine is not None, "eventId": event_id, "seq": seq,
|
||
"materialCode": ev["materialCode"], "inventoryVersion": world["inventoryVersion"],
|
||
"applied": applied}
|
||
|
||
|
||
def _drain_pending(store, actor: str) -> list[dict[str, Any]]:
|
||
"""按 seq 连续性排空缓冲：lastSeq+1 起逐条应用（乱序到达按逻辑顺序落版本）。"""
|
||
world = store.data
|
||
applied: list[dict[str, Any]] = []
|
||
while True:
|
||
nxt = int(world.get("wmsLastSeq") or 0) + 1
|
||
idx = next((i for i, e in enumerate(world["wmsPending"])
|
||
if int(e.get("seq") or 0) == nxt), None)
|
||
if idx is None:
|
||
break
|
||
ev = world["wmsPending"].pop(idx)
|
||
applied.append(_apply_event(store, ev, actor))
|
||
world["wmsLastSeq"] = nxt
|
||
return applied
|
||
|
||
|
||
def _apply_event(store, ev: dict[str, Any], actor: str) -> dict[str, Any]:
|
||
"""应用单条事件：库存版本 +1、台账/物料库存更新、冲突入 flexConflicts、证据链审计。"""
|
||
world = store.data
|
||
event_id = ev["eventId"]
|
||
mat_code = ev["materialCode"]
|
||
new_version = int(world.get("inventoryVersion") or 0) + 1
|
||
world["inventoryVersion"] = new_version
|
||
new_stock = ev.get("newStock")
|
||
|
||
# 库存台账（world 侧 WMS 投影）
|
||
ledger = world["wmsInventoryLedger"]
|
||
row = next((r for r in ledger if r["materialCode"] == mat_code), None)
|
||
if row is None:
|
||
row = {"materialCode": mat_code, "name": ev.get("name"), "unit": ev.get("unit"),
|
||
"stock": None, "inTransit": 0, "safetyStock": 0, "version": 0,
|
||
"source": "WMS", "updatedAt": _now()}
|
||
ledger.append(row)
|
||
if new_stock is not None:
|
||
row["stock"] = float(new_stock)
|
||
row["version"] = new_version
|
||
row["updatedAt"] = _now()
|
||
row["lastEventId"] = event_id
|
||
# 同步引擎读的物料库存（flexMaterials / materials 两轨）
|
||
if new_stock is not None:
|
||
for table in ("flexMaterials", "materials"):
|
||
for m in world.get(table, []):
|
||
if m.get("code") == mat_code:
|
||
m["stock"] = float(new_stock)
|
||
break
|
||
# 缺料冲突入冲突中心（WMS 来源，带 eventId/版本；有版本时挂最新 flex 版本）
|
||
if _is_shortage(ev):
|
||
latest_vid = None
|
||
versions = world.get("flexScheduleVersions") or []
|
||
if versions:
|
||
latest_vid = versions[-1].get("id")
|
||
world.setdefault("flexConflicts", []).append({
|
||
"id": store.next_id("flexConflict"),
|
||
"conflictType": "MATERIAL_SHORTAGE",
|
||
"severity": "MAJOR",
|
||
"resourceType": "MATERIAL",
|
||
"resourceName": row.get("name") or mat_code,
|
||
"orderNo": "",
|
||
"description": (f"WMS 缺料事件 {event_id}：{row.get('name') or mat_code} "
|
||
f"库存降至 {new_stock}" +
|
||
(f"，缺 {ev['shortageQty']} {row.get('unit') or ''}" if ev.get("shortageQty") else "")),
|
||
"suggestedSolution": "缺料重排：确认 Explore 方案卡后 L4 重排并 MES 下发",
|
||
"versionId": latest_vid,
|
||
"isResolved": False,
|
||
"source": "WMS-EVENT",
|
||
"eventId": event_id,
|
||
"inventoryVersion": new_version,
|
||
})
|
||
# 证据链：eventId + 库存版本
|
||
write_audit(world, store.next_id, actor=actor, category="INTEGRATION",
|
||
action="wms.event.consume", target={"type": "WMS_EVENT", "id": event_id},
|
||
power="P1", rationale={"seq": ev.get("seq"), "offset": ev.get("offset"),
|
||
"materialCode": mat_code, "newStock": new_stock,
|
||
"shortageQty": ev.get("shortageQty"),
|
||
"oldStock": ev.get("oldStock"), "type": ev.get("type")},
|
||
evidence_refs=[f"wms-event:{event_id}", f"inventory-version:{new_version}"])
|
||
world["wmsConsumed"][event_id] = {"seq": int(ev.get("seq") or 0),
|
||
"inventoryVersion": new_version, "at": _now()}
|
||
return {"eventId": event_id, "seq": int(ev.get("seq") or 0),
|
||
"inventoryVersion": new_version, "materialCode": mat_code,
|
||
"newStock": new_stock, "shortageQty": ev.get("shortageQty")}
|
||
|
||
|
||
# ============================================================
|
||
# ③ 影响半径评估（复用 flex 沙盒路径，只读主干）
|
||
# ============================================================
|
||
def _sandbox_counter():
|
||
counters: dict[str, int] = {}
|
||
|
||
def next_id(kind: str) -> int:
|
||
counters[kind] = counters.get(kind, 0) + 1000000
|
||
return counters[kind]
|
||
|
||
return next_id
|
||
|
||
|
||
def _material_row(world: World, code: str) -> dict[str, Any] | None:
|
||
for table in ("flexMaterials", "materials"):
|
||
for m in world.get(table, []):
|
||
if m.get("code") == code:
|
||
return m
|
||
return None
|
||
|
||
|
||
def _bom_products_for_material(world: World, code: str) -> list[str]:
|
||
products: list[str] = []
|
||
for b in world.get("flexBom", []):
|
||
if b.get("materialCode") == code and b.get("productCode") not in products:
|
||
products.append(str(b["productCode"]))
|
||
for bi in world.get("bomItems", []):
|
||
mat = next((m for m in world.get("materials", []) if m.get("id") == bi.get("materialId")), None)
|
||
if mat is not None and mat.get("code") == code:
|
||
prod = next((p for p in world.get("products", []) if p.get("id") == bi.get("productId")), None)
|
||
if prod is not None and prod.get("code") not in products:
|
||
products.append(str(prod["code"]))
|
||
return products
|
||
|
||
|
||
def evaluate_shortage_impact(world: World, event: dict[str, Any]) -> dict[str, Any]:
|
||
"""缺料影响半径（P1 只读）：深拷贝沙盒内 flex 试排对比（before 旧库存 vs after 新库存），主干零接触。
|
||
|
||
复用 rush/flex 的沙盒评估路径（深拷贝 + PoolEngine 试排 + 指标差分）。
|
||
"""
|
||
ev = _normalize_event(event)
|
||
mat_code = ev["materialCode"]
|
||
mat = _material_row(world, mat_code)
|
||
products = set(_bom_products_for_material(world, mat_code))
|
||
affected_orders = [
|
||
o for o in world.get("flexOrders", [])
|
||
if o.get("productCode") in products and o.get("status") in _FLEX_ACTIVE_STATUSES
|
||
]
|
||
need_qty = 0.0
|
||
for o in affected_orders:
|
||
for b in world.get("flexBom", []):
|
||
if b.get("productCode") == o.get("productCode") and b.get("materialCode") == mat_code:
|
||
need_qty += float(b.get("quantity") or 0) * float(o.get("quantity") or 0)
|
||
stock = ev.get("newStock")
|
||
if stock is None and mat is not None:
|
||
stock = float(mat.get("stock") or 0)
|
||
in_transit = float(mat.get("inTransit") or 0) if mat is not None else 0.0
|
||
shortage = max(0.0, round(need_qty - float(stock or 0) - in_transit, 3))
|
||
eval_id = uuid.uuid4().hex[:10]
|
||
|
||
if not affected_orders or not world.get("flexOrders"):
|
||
return {"evalId": eval_id, "materialCode": mat_code,
|
||
"materialName": (mat or {}).get("name") or ev.get("name") or mat_code,
|
||
"unit": (mat or {}).get("unit") or ev.get("unit"),
|
||
"oldStock": ev.get("oldStock"), "stock": stock,
|
||
"needQty": round(need_qty, 3), "shortageQty": shortage,
|
||
"affectedOrderCount": 0, "affectedOrders": [],
|
||
"baseline": None, "after": None, "delayDelta": 0.0, "conflictDelta": 0,
|
||
"strategy": "FLEX-BOTTLENECK", "readOnly": True,
|
||
"note": "无受影响柔性订单，无需重排"}
|
||
|
||
def _solve(stock_override):
|
||
sandbox = copy.deepcopy(world)
|
||
if stock_override is not None:
|
||
for m in sandbox.get("flexMaterials", []):
|
||
if m.get("code") == mat_code:
|
||
m["stock"] = float(stock_override)
|
||
break
|
||
sandbox["flexScheduleVersions"] = []
|
||
sandbox["flexVirtualLines"] = []
|
||
sandbox["flexWorkOrders"] = []
|
||
sandbox["flexConflicts"] = []
|
||
result = PoolEngine().solve(sandbox, _sandbox_counter(), sort_mode="BOTTLENECK")
|
||
promised = {
|
||
vl.get("orderNo"): vl.get("plannedEnd")
|
||
for vl in sandbox.get("flexVirtualLines", [])
|
||
if vl.get("orderNo") and vl.get("plannedEnd")
|
||
}
|
||
return result, promised
|
||
|
||
old_stock = ev.get("oldStock")
|
||
before_res, before_promised = _solve(old_stock if old_stock is not None else (stock or 0.0))
|
||
after_res, after_promised = _solve(stock)
|
||
|
||
# 影响半径：物料整体缺料（聚合需求 > 可用量）时，所有在排消费订单都受影响；
|
||
# 附加沙盒对比中完工时点后移的订单（delay 半径），便于方案卡展示严重度。
|
||
if shortage > 0:
|
||
affected = []
|
||
for o in affected_orders:
|
||
on = o.get("orderNo")
|
||
b_end, a_end = before_promised.get(on), after_promised.get(on)
|
||
row = {"orderNo": on, "productCode": o.get("productCode"),
|
||
"quantity": o.get("quantity"), "dueDate": o.get("dueDate"),
|
||
"beforeEnd": b_end, "afterEnd": a_end,
|
||
"endShifted": bool(b_end and a_end and a_end > b_end)}
|
||
affected.append(row)
|
||
affected.sort(key=lambda x: str(x.get("afterEnd") or ""), reverse=True)
|
||
else:
|
||
affected = []
|
||
|
||
return {
|
||
"evalId": eval_id, "materialCode": mat_code,
|
||
"materialName": (mat or {}).get("name") or ev.get("name") or mat_code,
|
||
"unit": (mat or {}).get("unit") or ev.get("unit"),
|
||
"oldStock": old_stock, "stock": stock,
|
||
"needQty": round(need_qty, 3), "shortageQty": shortage,
|
||
"affectedOrderCount": len(affected),
|
||
"affectedOrders": affected[:12],
|
||
"baseline": {"orderCount": before_res["orderCount"],
|
||
"conflictCount": before_res["conflictCount"],
|
||
"totalTardiness": round(before_res["totalTardiness"], 1)},
|
||
"after": {"orderCount": after_res["orderCount"],
|
||
"conflictCount": after_res["conflictCount"],
|
||
"totalTardiness": round(after_res["totalTardiness"], 1)},
|
||
"delayDelta": round(after_res["totalTardiness"] - before_res["totalTardiness"], 1),
|
||
"conflictDelta": after_res["conflictCount"] - before_res["conflictCount"],
|
||
"strategy": "FLEX-BOTTLENECK",
|
||
"readOnly": True,
|
||
}
|
||
|
||
|
||
# ============================================================
|
||
# ③ Explore 方案卡（DRAFT，P2 确认；动作复用 flex.reschedule）
|
||
# ============================================================
|
||
def stage_shortage_solution(store, event: dict[str, Any],
|
||
session_id: str = "wms", actor: str = "wms") -> dict[str, Any]:
|
||
"""缺料 → 影响半径（沙盒只读）→ 生成 Explore 方案卡（P2 确认，L4 重排）。
|
||
|
||
幂等触发：同一 eventId 只出一张卡；重复/乱序重放不会重复触发。
|
||
"""
|
||
from server.agent_core import harness
|
||
world = store.data
|
||
_ensure_tables(world)
|
||
ev = _normalize_event(event)
|
||
event_id = str(ev.get("eventId") or "").strip()
|
||
if not event_id:
|
||
raise ValueError("WMS 事件缺少 eventId")
|
||
if not _is_shortage(ev):
|
||
return {"staged": False, "reason": "not-a-shortage", "eventId": event_id}
|
||
triggered = world["wmsTriggered"].get(event_id)
|
||
if triggered:
|
||
return {"staged": False, "reason": "already-triggered", "eventId": event_id,
|
||
"confirmId": triggered.get("confirmId")}
|
||
consumed = world["wmsConsumed"].get(event_id)
|
||
if not consumed:
|
||
return {"staged": False, "reason": "event-not-consumed", "eventId": event_id}
|
||
inv_version = int(consumed["inventoryVersion"])
|
||
impact = evaluate_shortage_impact(world, ev)
|
||
if not impact.get("affectedOrders"):
|
||
return {"staged": False, "reason": "no-impact", "eventId": event_id, "impact": impact}
|
||
refs = [f"wms-event:{event_id}", f"inventory-version:{inv_version}"]
|
||
affected_nos = [o["orderNo"] for o in impact["affectedOrders"]]
|
||
params = {
|
||
"level": "L4", "sortMode": "BOTTLENECK", # 确认后 flex.reschedule → L4 全量重排
|
||
"eventId": event_id, "materialCode": ev["materialCode"],
|
||
"inventoryVersion": inv_version, "shortageQty": ev.get("shortageQty"),
|
||
"evalId": impact["evalId"], "affectedOrderNos": affected_nos,
|
||
"impact": impact,
|
||
}
|
||
base, aft = impact["baseline"], impact["after"]
|
||
block = harness.stage_confirmation(
|
||
session_id, "flex.reschedule", params,
|
||
title=f"缺料重排方案（{impact['materialName']} 缺 {impact['shortageQty']} {impact.get('unit') or ''}）",
|
||
summary_lines=[
|
||
f"WMS 事件 {event_id}：{impact['materialName']} 库存 {impact.get('oldStock')} → {impact.get('stock')}（影响半径 {impact['affectedOrderCount']} 单）",
|
||
"受影响订单：" + "、".join(affected_nos[:6]) + ("…" if len(affected_nos) > 6 else ""),
|
||
(f"沙盒对比（只读）：冲突 {base['conflictCount']} → {aft['conflictCount']}；"
|
||
f"延迟 {base['totalTardiness']}h → {aft['totalTardiness']}h"),
|
||
"确认后执行 L4 全量重排（DRAFT 版本），随后可走 MES 下发（P3 门禁）",
|
||
],
|
||
evidence_refs=refs,
|
||
)
|
||
confirm_id = str(block.props["confirmId"])
|
||
world["wmsTriggered"][event_id] = {"confirmId": confirm_id, "inventoryVersion": inv_version,
|
||
"materialCode": ev["materialCode"], "at": _now(),
|
||
"evalId": impact["evalId"]}
|
||
write_audit(world, store.next_id, actor=actor, category="GATE",
|
||
action="wms.event.stage", target={"type": "WMS_SHORTAGE", "id": event_id},
|
||
power="P1", rationale={"confirmId": confirm_id, "materialCode": ev["materialCode"],
|
||
"affectedOrderCount": impact["affectedOrderCount"],
|
||
"inventoryVersion": inv_version, "evalId": impact["evalId"]},
|
||
evidence_refs=refs)
|
||
store.save()
|
||
return {"staged": True, "duplicate": False, "eventId": event_id,
|
||
"confirmId": confirm_id, "block": block.model_dump(), "impact": impact,
|
||
"inventoryVersion": inv_version}
|
||
|
||
|
||
# ============================================================
|
||
# 上报入口（POST /api/wms/events）：消费 → 版本 → 影响 → 方案卡
|
||
# ============================================================
|
||
def consume_shortage_event(store, payload: dict[str, Any],
|
||
session_id: str = "wms", actor: str = "wms") -> dict[str, Any]:
|
||
"""WMS 缺料/库存事件上报入口（幂等）。
|
||
|
||
事件物化：外部 eventId 直接使用（并录入镜像流供重放）；缺省经 stub.emit_shortage 生成。
|
||
返回：消费结果 + （缺料事件）Explore 方案卡 staged/impact/card。
|
||
"""
|
||
event = _materialize_event(payload)
|
||
result = consume_event(store, event, actor=actor)
|
||
if result.get("duplicate"):
|
||
return result
|
||
if _is_shortage(event):
|
||
staged = stage_shortage_solution(store, event, session_id=session_id, actor=actor)
|
||
result["staged"] = bool(staged.get("staged"))
|
||
result["stageReason"] = staged.get("reason") if not staged.get("staged") else None
|
||
if staged.get("staged"):
|
||
result["card"] = staged["block"]
|
||
result["confirmId"] = staged["confirmId"]
|
||
result["impact"] = staged["impact"]
|
||
result["evalId"] = staged["impact"]["evalId"]
|
||
else:
|
||
result["staged"] = False
|
||
result["stageReason"] = "not-a-shortage"
|
||
return result
|
||
|
||
|
||
def _materialize_event(payload: dict[str, Any]) -> dict[str, Any]:
|
||
"""事件物化（尽量少依赖外部 eventId；同时让镜像流可重放）。"""
|
||
from server.integrations.wms_stub import get_wms_client
|
||
client = get_wms_client()
|
||
p = dict(payload or {})
|
||
if p.get("eventId"):
|
||
event = dict(p)
|
||
event.setdefault("type", "SHORTAGE")
|
||
client.record_external(event)
|
||
return event
|
||
mat = str(p.get("materialCode") or "").strip()
|
||
if not mat:
|
||
raise ValueError("WMS 事件缺少 materialCode")
|
||
new_stock = p.get("newStock")
|
||
if new_stock is None:
|
||
raise ValueError("WMS 缺料事件必须提供 newStock")
|
||
idem_key = p.get("idemKey") or f"api:{mat}:{p.get('occurredAt') or ''}"
|
||
return client.emit_shortage(
|
||
mat, new_stock=float(new_stock), shortage_qty=p.get("shortageQty"),
|
||
occurred_at=p.get("occurredAt"), idem_key=idem_key,
|
||
name=p.get("name"), unit=p.get("unit"))
|
||
|
||
|
||
# ============================================================
|
||
# ④ 确认后 MES 下发（复用 mes.dispatch P3 门禁）+ 回执镜像写回审计
|
||
# ============================================================
|
||
def stage_dispatch(store, event_id: str,
|
||
session_id: str = "wms", actor: str = "wms") -> dict[str, Any]:
|
||
"""缺料闭环 ④a：为最新重排版本暂存 MES 下发（复用 mes.stage_dispatch，P3 门禁）。"""
|
||
from server.aps_domain.mes import stage_dispatch as mes_stage_dispatch
|
||
world = store.data
|
||
_ensure_tables(world)
|
||
triggered = world["wmsTriggered"].get(event_id)
|
||
if not triggered:
|
||
return {"staged": False, "message": f"WMS 事件 {event_id} 未触发方案卡", "block": None}
|
||
r = mes_stage_dispatch(store, track="flex", session_id=session_id, actor=actor)
|
||
if r.get("staged") and r.get("block"):
|
||
write_audit(world, store.next_id, actor=actor, category="GATE",
|
||
action="wms.mes.dispatch.stage",
|
||
target={"type": "WMS_EVENT", "id": event_id}, power="P1",
|
||
rationale={"confirmId": r["block"].props["confirmId"],
|
||
"inventoryVersion": triggered["inventoryVersion"],
|
||
"materialCode": triggered["materialCode"]},
|
||
evidence_refs=[f"wms-event:{event_id}",
|
||
f"inventory-version:{triggered['inventoryVersion']}"])
|
||
store.save()
|
||
return r
|
||
|
||
|
||
def execute_dispatch_receipt(store, *, event_id: str, confirm_id: str, execution_grant: str,
|
||
version_id: int, before_snapshot: str, checkpoint_store,
|
||
evidence_refs: list[str] | None = None,
|
||
actor: str = "wms") -> dict[str, Any]:
|
||
"""Execute governed MES dispatch and mirror the WMS receipt/evidence chain."""
|
||
|
||
from server.aps_domain.mes import apply_dispatch as mes_apply_dispatch
|
||
from server.aps_domain.mes import validate_dispatchable_version
|
||
|
||
world = store.data
|
||
_ensure_tables(world)
|
||
triggered = world["wmsTriggered"].get(event_id)
|
||
dispatch_evidence = list(evidence_refs or [])
|
||
version_ref = f"schedule-version:{version_id}"
|
||
if version_ref not in dispatch_evidence:
|
||
dispatch_evidence.insert(0, version_ref)
|
||
validation = validate_dispatchable_version(world, "flex", version_id)
|
||
evidence_ref = validation.get("evidenceRef")
|
||
if evidence_ref and evidence_ref not in dispatch_evidence:
|
||
dispatch_evidence.append(str(evidence_ref))
|
||
result = mes_apply_dispatch(
|
||
store,
|
||
track="flex",
|
||
actor=actor,
|
||
confirm_id=confirm_id,
|
||
execution_grant=execution_grant,
|
||
version_id=version_id,
|
||
before_snapshot=before_snapshot,
|
||
evidence_refs=dispatch_evidence,
|
||
checkpoint_store=checkpoint_store,
|
||
)
|
||
inventory_version = (
|
||
int(triggered.get("inventoryVersion"))
|
||
if triggered and triggered.get("inventoryVersion") is not None
|
||
else int(world.get("inventoryVersion") or 0)
|
||
)
|
||
external_ids = list(result.get("created") or [])
|
||
receipt = {
|
||
"receiptId": f"WMS-RCPT-{event_id}",
|
||
"eventId": event_id,
|
||
"inventoryVersion": inventory_version,
|
||
"scheduleVersionId": version_id,
|
||
"mesExternalWoIds": external_ids,
|
||
"created": len(external_ids),
|
||
"duplicates": len(result.get("duplicates") or []),
|
||
"at": _now(),
|
||
"source": "WMS-MOCK",
|
||
}
|
||
world.setdefault("wmsReceipts", []).append(receipt)
|
||
write_audit(
|
||
world,
|
||
store.next_id,
|
||
actor=actor,
|
||
category="INTEGRATION",
|
||
action="wms.mes.receipt",
|
||
target={"type": "MES_RECEIPT", "id": receipt["receiptId"]},
|
||
power="P3",
|
||
rationale={
|
||
"eventId": event_id,
|
||
"inventoryVersion": inventory_version,
|
||
"scheduleVersionId": version_id,
|
||
"externalWoIds": external_ids,
|
||
"created": len(external_ids),
|
||
},
|
||
evidence_refs=[
|
||
f"wms-event:{event_id}",
|
||
f"inventory-version:{inventory_version}",
|
||
*dispatch_evidence,
|
||
],
|
||
)
|
||
store.save()
|
||
return {
|
||
**result,
|
||
"receipt": receipt,
|
||
"message": f"{result.get('message')} 回执已入审计（{receipt['receiptId']}）。",
|
||
}
|
||
|
||
|
||
# ============================================================
|
||
# 只读投影（P0）：库存版本/台账 / 事件流重放 / 连接状态
|
||
# ============================================================
|
||
def inventory_projection(world: World) -> dict[str, Any]:
|
||
"""WMS 库存版本/台账投影（P0 只读）。"""
|
||
_ensure_tables(world)
|
||
ledger = world.get("wmsInventoryLedger", [])
|
||
rows = []
|
||
for r in ledger:
|
||
mat = _material_row(world, r["materialCode"])
|
||
rows.append({**r, "apsStock": (float(mat.get("stock") or 0) if mat else r.get("stock"))})
|
||
return {
|
||
"connected": True, "mode": "stub",
|
||
"inventoryVersion": world.get("inventoryVersion", 0),
|
||
"consumedEvents": len(world.get("wmsConsumed", {})),
|
||
"triggeredCards": len(world.get("wmsTriggered", {})),
|
||
"receiptCount": len(world.get("wmsReceipts", [])),
|
||
"pendingEvents": len(world.get("wmsPending", [])),
|
||
"ledger": rows,
|
||
}
|
||
|
||
|
||
def wms_connection_status() -> dict[str, Any]:
|
||
from server.integrations.wms_stub import get_wms_client
|
||
return get_wms_client().status()
|
||
|
||
|
||
def replay_events(limit: int | None = None, order: str = "seq") -> dict[str, Any]:
|
||
"""WMS 事件流重放（P0）：seq=逻辑顺序 / arrival=到达顺序。"""
|
||
from server.integrations.wms_stub import get_wms_client
|
||
client = get_wms_client()
|
||
status = client.status()
|
||
events = client.replay(limit=limit, order=order)
|
||
return {"system": status.get("system"), "plant": status.get("plant"),
|
||
"inventoryVersion": client.inventory_version(),
|
||
"count": len(events), "events": events}
|
||
|
||
|
||
# ============================================================
|
||
# round-39 方向 P：Saga/补偿接入点
|
||
# ① run_shortage_saga：WMS 缺料→重排→MES 下发→回执 作为第一个 Saga 实例编排
|
||
# ② rollback_receipt：MES 回执补偿（幂等 VOIDED，留痕不删除）
|
||
# ============================================================
|
||
def rollback_receipt(store, *, event_id: str | None = None, receipt_id: str | None = None,
|
||
actor: str = "saga", reason: str = "saga-compensation") -> dict[str, Any]:
|
||
"""MES 回执补偿（幂等）：按 receiptId/eventId 将 wmsReceipts 条目标记 VOIDED（留痕不删除）。
|
||
|
||
- 幂等：同一 receiptId/eventId 已回滚过 → 直接返回记录（duplicate）；
|
||
- 无匹配回执（如已随世界快照回滚）→ 返回 voided=0（幂等成功语义）。
|
||
"""
|
||
world = store.data
|
||
_ensure_tables(world)
|
||
world.setdefault("wmsReceiptVoids", {})
|
||
key = receipt_id or event_id
|
||
if key and key in world["wmsReceiptVoids"]:
|
||
return {**world["wmsReceiptVoids"][key], "duplicate": True}
|
||
targets = [r for r in world.get("wmsReceipts", [])
|
||
if (receipt_id and r.get("receiptId") == receipt_id)
|
||
or (event_id and r.get("eventId") == event_id)]
|
||
for r in targets:
|
||
r["status"] = "VOIDED"
|
||
r["voidedAt"] = _now()
|
||
r["voidReason"] = reason
|
||
write_audit(world, store.next_id, actor=actor, category="INTEGRATION",
|
||
action="wms.mes.receipt.rollback",
|
||
target={"type": "MES_RECEIPT", "id": key or "ALL"},
|
||
power="P1", rationale={"eventId": event_id, "receiptId": receipt_id,
|
||
"voided": len(targets), "reason": reason},
|
||
result="SUCCESS",
|
||
evidence_refs=[f"wms-receipt-void:{key}"] if key else [])
|
||
result = {"voided": len(targets), "eventId": event_id, "receiptId": receipt_id,
|
||
"reason": reason, "message": f"回执补偿 ✅ VOIDED {len(targets)} 条（幂等）。"}
|
||
if key:
|
||
world["wmsReceiptVoids"][key] = result
|
||
store.save()
|
||
return result
|
||
|
||
|
||
def run_shortage_saga(store, payload: dict[str, Any], *,
|
||
session_id: str = "wms", actor: str = "saga",
|
||
auto_approve: bool = True, timeout_sec: float = 30.0,
|
||
max_retries: int = 2, coordinator=None) -> dict[str, Any]:
|
||
"""WMS 缺料闭环以 Saga 编排执行（round-39 方向 P，矩阵 78/119）。
|
||
|
||
事件物化 → consume → impact → 方案卡 → 确认重排 → MES 下发 → 回执；
|
||
任一失败 → 重试超限走补偿链（重排失败回滚前版本；MES 失败撤销下发）；
|
||
补偿也失败 → MANUAL_TAKEOVER（人工接管点，可经 retry 恢复）。
|
||
返回 saga 记录（含中间态 steps 明细 / 幂等键 / 审计引用）。
|
||
"""
|
||
from server.aps_domain import saga
|
||
event = _materialize_event(payload)
|
||
coord = coordinator or saga.get_coordinator(store, actor=actor)
|
||
record = saga.build_wms_shortage_saga(coord, event, session_id=session_id, actor=actor,
|
||
timeout_sec=timeout_sec, max_retries=max_retries)
|
||
return coord.run(record["id"], auto_approve=auto_approve)
|