415 lines
17 KiB
Python
415 lines
17 KiB
Python
# ============================================================
|
||
# 订单分解 MRP（moduleId: domain-mrp, 可重生 ✅）
|
||
# 对标西门子 Opcenter：销售订单 → 沿工艺路线 + BOM 多层展开 →
|
||
# 自制（MAKE，进排产）/ 采购（BUY，原料毛坯）/ 委外（OUTSOURCE，WZ*/外协工序）。
|
||
# 权力：order.decompose = P1，只写 DRAFT 建议表；下达另走 P2。
|
||
# ============================================================
|
||
from __future__ import annotations
|
||
|
||
import math
|
||
from datetime import datetime
|
||
from typing import Any
|
||
|
||
from server.aps_domain.sourcing import (
|
||
annotate_world_sourcing,
|
||
infer_material_sourcing,
|
||
is_outsource_step,
|
||
)
|
||
from server.engines.queries import find_bom_items, find_routing_steps
|
||
from server.timeutil import add_minutes, fmt_date, fmt_dt, parse_dt
|
||
|
||
World = dict[str, Any]
|
||
|
||
_PURCHASE_BUFFER_DAYS = 1
|
||
_MAX_BOM_DEPTH = 10
|
||
|
||
|
||
def _now() -> str:
|
||
return fmt_dt(datetime.now())
|
||
|
||
|
||
def _ensure_tables(world: World) -> None:
|
||
world.setdefault("purchaseOrders", [])
|
||
world.setdefault("outsourceOrders", [])
|
||
|
||
|
||
def list_mrp(world: World) -> dict[str, Any]:
|
||
"""MRP 建议单投影（P0 只读）。"""
|
||
_ensure_tables(world)
|
||
try:
|
||
from server.aps_domain.orders import sync_flex_orders_to_sales
|
||
if world.get("flexOrders"):
|
||
sync_flex_orders_to_sales(world)
|
||
except Exception:
|
||
pass
|
||
annotate_world_sourcing(world)
|
||
purchases = list(world["purchaseOrders"])
|
||
outs = list(world["outsourceOrders"])
|
||
make = []
|
||
if not purchases and not outs and (world.get("flexBom") or world.get("flexOrders")):
|
||
make, purchases, outs = _flex_gap_preview(world)
|
||
return {
|
||
"purchaseOrders": purchases,
|
||
"outsourceOrders": outs,
|
||
"make": make,
|
||
"productionOrders": _list_flex_make(world),
|
||
}
|
||
|
||
|
||
def _list_flex_make(world: World) -> list[dict[str, Any]]:
|
||
try:
|
||
from server.aps_domain.orders import list_production_orders
|
||
return list_production_orders(world)
|
||
except Exception:
|
||
return []
|
||
|
||
|
||
def _flex_gap_preview(world: World) -> tuple[list, list, list]:
|
||
"""柔性 BOM/工艺只读预览（含委外推断）。"""
|
||
_ensure_tables(world)
|
||
annotate_world_sourcing(world)
|
||
make_rows: list[dict[str, Any]] = []
|
||
purchase_rows: list[dict[str, Any]] = []
|
||
outsource_rows: list[dict[str, Any]] = []
|
||
mats = {m.get("code"): m for m in (world.get("flexMaterials") or []) + (world.get("materials") or [])}
|
||
demand: dict[str, float] = {}
|
||
pcs_with_route = {str(r.get("productCode") or "") for r in (world.get("flexRoutings") or [])}
|
||
|
||
for fo in world.get("flexOrders") or []:
|
||
if (fo.get("status") or "") in ("DONE", "CANCELLED", "COMPLETED"):
|
||
continue
|
||
pc = fo.get("productCode")
|
||
qty = float(fo.get("quantity") or 0)
|
||
if not pc or qty <= 0:
|
||
continue
|
||
make_rows.append({
|
||
"salesOrderNo": fo.get("orderNo"), "productCode": pc,
|
||
"productName": fo.get("productName") or pc, "quantity": qty,
|
||
"note": "柔性/SQL 订单 · 自制进排产",
|
||
})
|
||
for r in world.get("flexRoutings") or []:
|
||
if r.get("productCode") != pc or not r.get("isExternal"):
|
||
continue
|
||
outsource_rows.append({
|
||
"id": -(len(outsource_rows) + 1),
|
||
"orderNo": f"OUT-PREV-{len(outsource_rows)+1:04d}",
|
||
"status": "DRAFT",
|
||
"salesOrderNo": fo.get("orderNo"),
|
||
"productName": fo.get("productName") or pc,
|
||
"operationName": r.get("operationName") or r.get("operationCode"),
|
||
"sequenceNo": r.get("seq"),
|
||
"quantity": qty, "unit": "件",
|
||
"requiredDate": fo.get("dueDate") or "",
|
||
"note": "WZ*/外协工序预览，点「重新分解」落正式建议",
|
||
})
|
||
stack = [(pc, qty, 0)]
|
||
seen_path: set[str] = set()
|
||
while stack:
|
||
cur, need, depth = stack.pop()
|
||
if depth > _MAX_BOM_DEPTH or cur in seen_path:
|
||
continue
|
||
seen_path.add(cur)
|
||
for b in world.get("flexBom") or []:
|
||
if b.get("productCode") != cur:
|
||
continue
|
||
mc = b.get("materialCode")
|
||
if not mc:
|
||
continue
|
||
child_need = float(b.get("quantity") or 0) * need
|
||
mat = mats.get(mc) or {}
|
||
has_rt = mc in pcs_with_route
|
||
if infer_material_sourcing(mat, has_routing=has_rt) == "MAKE" and has_rt:
|
||
stack.append((mc, child_need, depth + 1))
|
||
else:
|
||
demand[mc] = demand.get(mc, 0) + child_need
|
||
seen_path.discard(cur)
|
||
|
||
nid = -1
|
||
for mc, need in sorted(demand.items()):
|
||
mat = mats.get(mc) or {}
|
||
have = float(mat.get("stock") or 0) + float(mat.get("inTransit") or 0)
|
||
gap = need - have
|
||
if gap <= 0:
|
||
continue
|
||
lead = float(mat.get("procurementLeadTime") or 0)
|
||
purchase_rows.append({
|
||
"id": nid, "orderNo": f"PR-PREV-{abs(nid):04d}",
|
||
"status": "DRAFT", "materialCode": mc,
|
||
"materialName": mat.get("name") or mc,
|
||
"quantity": math.ceil(gap), "unit": mat.get("unit") or "件",
|
||
"salesOrderNo": "（多单汇总）",
|
||
"suggestedOrderDate": "", "requiredDate": "",
|
||
"leadTimeDays": lead,
|
||
"note": "多层 BOM 缺口预览，点「重新分解」可落正式建议",
|
||
"sourcingType": "BUY",
|
||
})
|
||
nid -= 1
|
||
return make_rows, purchase_rows, outsource_rows
|
||
|
||
|
||
def _target_orders(world: World, order_no: str | None) -> list[dict[str, Any]]:
|
||
from server.aps_domain.orders import SCHEDULABLE_STATUSES, sync_flex_orders_to_sales
|
||
if world.get("flexOrders"):
|
||
sync_flex_orders_to_sales(world)
|
||
orders = [so for so in world.get("salesOrders") or [] if so["status"] in SCHEDULABLE_STATUSES]
|
||
if order_no:
|
||
orders = [so for so in world.get("salesOrders") or []
|
||
if so["orderNo"].lower() == order_no.lower()
|
||
and so["status"] not in ("CANCELLED", "COMPLETED")]
|
||
if not orders:
|
||
raise ValueError(f"没找到可分解的订单：{order_no}")
|
||
return orders
|
||
|
||
|
||
def _mat_by_id(world: World) -> dict[int, dict]:
|
||
return {m["id"]: m for m in world.get("materials") or [] if isinstance(m.get("id"), int)}
|
||
|
||
|
||
def _ops_by_id(world: World) -> dict[int, dict]:
|
||
return {o["id"]: o for o in world.get("operations") or [] if isinstance(o.get("id"), int)}
|
||
|
||
|
||
def _product_has_routing(world: World, product_id: int) -> bool:
|
||
return any(r.get("productId") == product_id and r.get("isDefault")
|
||
for r in world.get("routings") or [])
|
||
|
||
|
||
def _append_outsource_for_product(
|
||
world: World,
|
||
next_id,
|
||
so: dict,
|
||
product_id: int,
|
||
product_name: str,
|
||
qty: float,
|
||
unit: str,
|
||
outsource_rows: list,
|
||
seen_keys: set[tuple],
|
||
) -> None:
|
||
ops = _ops_by_id(world)
|
||
for step in find_routing_steps(world, product_id):
|
||
op = ops.get(step.get("operationId")) or {}
|
||
if not is_outsource_step(step, op):
|
||
continue
|
||
key = (so["id"], product_id, step.get("operationId"), step.get("sequenceNo"))
|
||
if key in seen_keys:
|
||
continue
|
||
seen_keys.add(key)
|
||
oo_id = next_id("outsourceOrder")
|
||
row = {
|
||
"id": oo_id,
|
||
"orderNo": f"OUT{oo_id:05d}",
|
||
"salesOrderId": so["id"], "salesOrderNo": so["orderNo"],
|
||
"productId": product_id, "productName": product_name,
|
||
"operationId": step.get("operationId"),
|
||
"operationName": op.get("name") or f"OP#{step.get('operationId')}",
|
||
"operationCode": op.get("code") or "",
|
||
"sequenceNo": step.get("sequenceNo"),
|
||
"quantity": qty, "unit": unit,
|
||
"requiredDate": so.get("deliveryDate"),
|
||
"status": "DRAFT",
|
||
"sourcingType": "OUTSOURCE",
|
||
"createdAt": _now(),
|
||
}
|
||
world["outsourceOrders"].append(row)
|
||
outsource_rows.append(row)
|
||
|
||
|
||
def _append_purchase(
|
||
world: World,
|
||
next_id,
|
||
so: dict,
|
||
mat: dict,
|
||
shortage: float,
|
||
is_key: bool,
|
||
purchase_rows: list,
|
||
purchase_agg: dict[tuple, dict],
|
||
) -> None:
|
||
key = (so["id"], mat["id"])
|
||
if key in purchase_agg:
|
||
purchase_agg[key]["quantity"] = math.ceil(
|
||
purchase_agg[key]["quantity"] + shortage
|
||
)
|
||
return
|
||
lead = mat.get("procurementLeadTime", 0) or 0
|
||
due = parse_dt(str(so.get("deliveryDate") or today_fallback()) + " 08:00")
|
||
suggest_date = fmt_date(add_minutes(due, -(float(lead) + _PURCHASE_BUFFER_DAYS) * 24 * 60))
|
||
po_id = next_id("purchaseOrder")
|
||
row = {
|
||
"id": po_id,
|
||
"orderNo": f"PUR{po_id:05d}",
|
||
"salesOrderId": so["id"], "salesOrderNo": so["orderNo"],
|
||
"materialId": mat["id"], "materialCode": mat.get("code"), "materialName": mat.get("name"),
|
||
"quantity": math.ceil(shortage), "unit": mat.get("unit") or "件",
|
||
"leadTimeDays": lead,
|
||
"suggestedOrderDate": suggest_date,
|
||
"requiredDate": so.get("deliveryDate"),
|
||
"isKeyMaterial": is_key,
|
||
"status": "DRAFT",
|
||
"sourcingType": "BUY",
|
||
"createdAt": _now(),
|
||
}
|
||
world["purchaseOrders"].append(row)
|
||
purchase_rows.append(row)
|
||
purchase_agg[key] = row
|
||
|
||
|
||
def today_fallback() -> str:
|
||
return fmt_date(datetime.now())
|
||
|
||
|
||
def decompose_orders(world: World, next_id, order_no: str | None = None) -> dict[str, Any]:
|
||
"""按工艺路线类型 + 多层 BOM 分解订单（P1：DRAFT 建议）。"""
|
||
_ensure_tables(world)
|
||
annotate_world_sourcing(world)
|
||
targets = _target_orders(world, order_no)
|
||
target_ids = {so["id"] for so in targets}
|
||
|
||
world["purchaseOrders"] = [p for p in world["purchaseOrders"]
|
||
if not (p.get("salesOrderId") in target_ids and p.get("status") == "DRAFT")]
|
||
world["outsourceOrders"] = [o for o in world["outsourceOrders"]
|
||
if not (o.get("salesOrderId") in target_ids and o.get("status") == "DRAFT")]
|
||
|
||
make_rows: list[dict[str, Any]] = []
|
||
purchase_rows: list[dict[str, Any]] = []
|
||
outsource_rows: list[dict[str, Any]] = []
|
||
mats = _mat_by_id(world)
|
||
out_seen: set[tuple] = set()
|
||
purchase_agg: dict[tuple, dict] = {}
|
||
|
||
for so in targets:
|
||
for item in so.get("items", []):
|
||
if item.get("status") in ("CANCELLED", "COMPLETED"):
|
||
continue
|
||
qty = float(item.get("quantity") or 0)
|
||
if qty <= 0:
|
||
continue
|
||
pid = item.get("productId")
|
||
pname = item.get("productName") or ""
|
||
unit = item.get("unit") or "件"
|
||
if not isinstance(pid, int):
|
||
continue
|
||
|
||
# 根成品：自制 + 委外工序
|
||
make_rows.append({
|
||
"salesOrderNo": so["orderNo"], "productId": pid,
|
||
"productName": pname, "quantity": qty,
|
||
"sourcingType": "MAKE",
|
||
"note": "成品自制 · 由排产引擎生成生产订单与工单",
|
||
})
|
||
_append_outsource_for_product(
|
||
world, next_id, so, pid, pname, qty, unit, outsource_rows, out_seen,
|
||
)
|
||
|
||
# 多层 BOM：自制半成品继续下钻；采购件出采购建议
|
||
stack: list[tuple[int, float, int]] = [(pid, qty, 0)]
|
||
path: set[int] = set()
|
||
while stack:
|
||
cur_id, cur_qty, depth = stack.pop()
|
||
if depth >= _MAX_BOM_DEPTH or cur_id in path:
|
||
continue
|
||
path.add(cur_id)
|
||
for bi in find_bom_items(world, cur_id):
|
||
mid = bi.get("materialId")
|
||
mat = mats.get(mid) if isinstance(mid, int) else None
|
||
if not mat:
|
||
continue
|
||
child_qty = float(bi.get("quantity") or 0) * cur_qty
|
||
if child_qty <= 0:
|
||
continue
|
||
has_rt = _product_has_routing(world, mid)
|
||
sourcing = infer_material_sourcing(mat, has_routing=has_rt)
|
||
if sourcing == "MAKE" and has_rt:
|
||
make_rows.append({
|
||
"salesOrderNo": so["orderNo"], "productId": mid,
|
||
"productName": mat.get("name") or mat.get("code"),
|
||
"quantity": child_qty,
|
||
"sourcingType": "MAKE",
|
||
"note": f"半成品自制（来自 {pname or pid} BOM）",
|
||
})
|
||
_append_outsource_for_product(
|
||
world, next_id, so, mid,
|
||
mat.get("name") or mat.get("code") or "",
|
||
child_qty, mat.get("unit") or "件",
|
||
outsource_rows, out_seen,
|
||
)
|
||
stack.append((mid, child_qty, depth + 1))
|
||
continue
|
||
# 采购
|
||
shortage = child_qty - float(mat.get("stock") or 0) - float(mat.get("inTransit") or 0)
|
||
if shortage <= 0:
|
||
continue
|
||
_append_purchase(
|
||
world, next_id, so, mat, shortage,
|
||
bool(bi.get("isKeyMaterial")), purchase_rows, purchase_agg,
|
||
)
|
||
path.discard(cur_id)
|
||
|
||
return {
|
||
"orders": [so["orderNo"] for so in targets],
|
||
"make": make_rows,
|
||
"purchase": purchase_rows,
|
||
"outsource": outsource_rows,
|
||
}
|
||
|
||
|
||
def _release_targets(world: World, order_no: str | None, kind: str) -> tuple[list[dict], list[dict]]:
|
||
_ensure_tables(world)
|
||
so_ids = None
|
||
if order_no:
|
||
so = next((s for s in world["salesOrders"] if s["orderNo"].lower() == order_no.lower()), None)
|
||
if so is None:
|
||
raise ValueError(f"没找到订单：{order_no}")
|
||
so_ids = {so["id"]}
|
||
|
||
def _match(row: dict) -> bool:
|
||
return row["status"] == "DRAFT" and (so_ids is None or row["salesOrderId"] in so_ids)
|
||
|
||
pur = [p for p in world["purchaseOrders"] if _match(p)] if kind in ("all", "purchase") else []
|
||
out = [o for o in world["outsourceOrders"] if _match(o)] if kind in ("all", "outsource") else []
|
||
return pur, out
|
||
|
||
|
||
def confirmation_for_mrp_release(world: World, order_no: str | None, kind: str = "all") -> tuple[str, list[str]]:
|
||
pur, out = _release_targets(world, order_no, kind)
|
||
if not pur and not out:
|
||
raise ValueError("没有可下达的草稿建议单（请先执行订单分解）")
|
||
scope = f"订单 {order_no}" if order_no else "全部订单"
|
||
title = f"下达 MRP 建议单（{scope}）"
|
||
lines = []
|
||
if pur:
|
||
lines.append(f"采购建议 {len(pur)} 条 → 转为正式采购单（RELEASED）")
|
||
if out:
|
||
lines.append(f"委外建议 {len(out)} 条 → 转为正式委外单（RELEASED）")
|
||
lines.append("下达后建议单状态置为 RELEASED，进入采购/委外执行（P2 写主干，执行前自动建档）")
|
||
return title, lines
|
||
|
||
|
||
def apply_mrp_release(world: World, order_no: str | None = None, kind: str = "all") -> dict[str, Any]:
|
||
pur, out = _release_targets(world, order_no, kind)
|
||
released_at = _now()
|
||
for row in pur + out:
|
||
row["status"] = "RELEASED"
|
||
row["releasedAt"] = released_at
|
||
return {"purchase": pur, "outsource": out,
|
||
"purchaseCount": len(pur), "outsourceCount": len(out)}
|
||
|
||
|
||
def summarize_decomposition(result: dict[str, Any]) -> str:
|
||
lines = [f"已分解 {len(result['orders'])} 张订单（{ '、'.join(result['orders'][:5]) }"
|
||
+ ("…" if len(result["orders"]) > 5 else "") + "）："]
|
||
lines.append(f"· 自制：{len(result['make'])} 项（成品/半成品）→ 排产生成生产订单")
|
||
if result["purchase"]:
|
||
top = "、".join(f"{p['materialName']}×{p['quantity']}" for p in result["purchase"][:4])
|
||
lines.append(f"· 采购建议：{len(result['purchase'])} 条（{top}"
|
||
+ ("…" if len(result['purchase']) > 4 else "") + "），按前置期倒排")
|
||
else:
|
||
lines.append("· 采购建议：0 条（库存与在途可覆盖，或 BOM 未挂原料）")
|
||
if result["outsource"]:
|
||
top = "、".join(f"{o['productName']}·{o['operationName']}" for o in result["outsource"][:3])
|
||
lines.append(f"· 委外建议：{len(result['outsource'])} 条（{top}"
|
||
+ ("…" if len(result['outsource']) > 3 else "") + "），来自 WZ*/外协工序")
|
||
else:
|
||
lines.append("· 委外建议：0 条（工艺无 WZ*/外协步骤）")
|
||
lines.append("可在订单面板查看生产/采购/委外；「追溯」可看 BOM/库存/工单全链。")
|
||
return "\n".join(lines)
|