659 lines
44 KiB
Python
659 lines
44 KiB
Python
# ============================================================
|
||
# RULE 规则排产引擎（moduleId: engines-rule, 可重生 ✅, 黄金测试 tests/golden）
|
||
# 从 legacy aps-frontend/js/common.js runScheduling/placeWorkOrder/findSlot 按行移植。
|
||
# 算法定位（plan.md §9.5.5）：构造启发式（EDD/优先级派工 + 顺排占槽），毫秒级，
|
||
# 作为 HYBRID 管线的初始解生成器；CP-SAT/GA 在 M5 接入。
|
||
# 与 legacy 的两处刻意偏差（修正其跨版本污染问题，已在黄金测试固化）：
|
||
# 1) 容量/维保冲突检测只扫"本次版本"新生成的工单（legacy 扫全表会误报历史版本）
|
||
# 2) 利用率统计只按本次版本工单计算
|
||
# ============================================================
|
||
from __future__ import annotations # 前向类型引用
|
||
|
||
from datetime import datetime # 时间类型
|
||
from typing import Any, Callable # 类型标注
|
||
|
||
from server.contracts import ScheduleResult # 输出契约
|
||
from server.engines.base import EngineParams, ISchedulingEngine # 接口与入参
|
||
from server.engines.queries import ( # 主数据查询辅助（P0 只读）
|
||
find_bom_items, find_product_lines, find_routing_steps,
|
||
find_workstation_for_operation, get_available_minutes, get_line_shifts,
|
||
)
|
||
from server.aps_domain.constraints import material_shortage_severity, profile_snapshot
|
||
from server.timeutil import add_minutes, fmt_date, fmt_dt, parse_dt, today0 # 日期工具
|
||
|
||
# 世界状态类型别名
|
||
World = dict[str, Any]
|
||
|
||
|
||
def _kit_ready(so: dict[str, Any]) -> int:
|
||
s = str(so.get("kitStatus") or "")
|
||
return 0 if ("已完成" in s or "齐套" in s or s.upper() == "READY") else 1
|
||
|
||
|
||
def _skill_rank(level: Any) -> int:
|
||
lvl = str(level or "L3").upper()
|
||
return {"L4": 0, "L3": 1, "L2": 2, "L1": 3}.get(lvl, 4)
|
||
|
||
|
||
def _processing_minutes(work_order: dict[str, Any]) -> float:
|
||
value = work_order.get("processingMinutes")
|
||
if isinstance(value, (int, float)) and not isinstance(value, bool) and float(value) > 0:
|
||
return float(value)
|
||
return (
|
||
parse_dt(work_order["plannedEndTime"]) - parse_dt(work_order["plannedStartTime"])
|
||
).total_seconds() / 60.0
|
||
|
||
|
||
def _processing_intervals(work_order: dict[str, Any]) -> list[tuple[datetime, datetime]]:
|
||
segments = work_order.get("plannedSegments")
|
||
if isinstance(segments, list) and segments:
|
||
intervals = []
|
||
for segment in segments:
|
||
if not isinstance(segment, dict):
|
||
break
|
||
try:
|
||
start = parse_dt(str(segment["startTime"]))
|
||
end = parse_dt(str(segment["endTime"]))
|
||
except (KeyError, TypeError, ValueError):
|
||
break
|
||
if start >= end:
|
||
break
|
||
intervals.append((start, end))
|
||
else:
|
||
return intervals
|
||
return [(
|
||
parse_dt(work_order["plannedStartTime"]),
|
||
parse_dt(work_order["plannedEndTime"]),
|
||
)]
|
||
|
||
|
||
def _preflight_direct_timing(world: World, all_items: list[dict]) -> bool:
|
||
for entry in all_items:
|
||
timing = entry.get("_cpOperationTiming")
|
||
if not isinstance(timing, list) or not timing:
|
||
raise ValueError("经验证的 CP timing 缺少工序槽位")
|
||
item = entry.get("item") or {}
|
||
steps = find_routing_steps(world, int(item.get("productId") or -1))
|
||
expected = [(int(step["sequenceNo"]), int(step["id"])) for step in steps]
|
||
actual = [
|
||
(int(slot.get("sequenceNo") or -1), int(slot.get("routingStepId") or -1))
|
||
for slot in timing
|
||
]
|
||
if actual != expected:
|
||
raise ValueError("经验证的 CP timing 与工艺路线不一致")
|
||
line_ids = {slot.get("lineId") for slot in timing}
|
||
if len(line_ids) != 1 or entry.get("forcedLineId") != next(iter(line_ids)):
|
||
raise ValueError("经验证的 CP timing 产线身份不一致")
|
||
for slot, step in zip(timing, steps):
|
||
workstation = find_workstation_for_operation(
|
||
world, int(slot["lineId"]), int(step["operationId"]),
|
||
)
|
||
if workstation is None or workstation.get("id") != slot.get("workstationId"):
|
||
raise ValueError("经验证的 CP timing 工位身份不一致")
|
||
segments = slot.get("plannedSegments")
|
||
if not isinstance(segments, list) or not segments:
|
||
raise ValueError("经验证的 CP timing 缺少 plannedSegments")
|
||
start = parse_dt(str(slot.get("plannedStartTime")))
|
||
end = parse_dt(str(slot.get("plannedEndTime")))
|
||
if start >= end:
|
||
raise ValueError("经验证的 CP timing 包络时间非法")
|
||
return True
|
||
|
||
|
||
class RuleEngine(ISchedulingEngine):
|
||
"""规则引擎：策略排序 → 选线 → 逐工序占槽 → 冲突检测 → KPI（P1：只改内存 world）。"""
|
||
|
||
# 引擎标识
|
||
name = "RULE"
|
||
# 规则引擎毫秒级完成，无需 anytime
|
||
supports_anytime = False
|
||
|
||
def __init__(self, requested_type: str = "RULE") -> None:
|
||
"""记录用户请求的引擎类型（CP/GA/HYBRID 由 RULE 代跑时留痕，M5 前的诚实标注）。"""
|
||
self.requested_type = requested_type if requested_type in ("RULE", "CP", "GA", "HYBRID") else "RULE" # 合法化
|
||
|
||
# ---------------- 主入口 ----------------
|
||
def solve(self, world: World, params: EngineParams, next_id: Callable[[str], int]) -> ScheduleResult:
|
||
"""执行一次排产（移植 runScheduling；写入 world 的版本/PO/WO/冲突/日志）。"""
|
||
all_items, campaign_meta, source_order_count = self.collect_and_order(world, params)
|
||
return self.materialize_schedule(
|
||
world, params, next_id, all_items, campaign_meta, source_order_count)
|
||
|
||
def collect_and_order(
|
||
self, world: World, params: EngineParams,
|
||
) -> tuple[list[dict], dict[str, Any], int]:
|
||
"""收集待排项并按策略排序（SC-03 CP 可在此后重排/强制选线）。"""
|
||
# ---- ① 收集待排订单项（OR-03：默认仅 APPROVED/CONFIRMED）----
|
||
from server.aps_domain.orders import is_schedulable
|
||
all_items: list[dict] = [] # 待排项集合 [{so, item}]
|
||
for so in world["salesOrders"]: # 遍历销售订单
|
||
if params.orderIds and so["id"] not in params.orderIds: # 指定订单集时跳过未选中
|
||
continue
|
||
if so["status"] in ("CANCELLED", "COMPLETED"): # 已取消/完成不排
|
||
continue
|
||
if not is_schedulable(so["status"], include_unapproved=params.includeUnapproved):
|
||
continue
|
||
for item in so["items"]: # 遍历订单项
|
||
if item["status"] == "COMPLETED": # 已完成项不排
|
||
continue
|
||
all_items.append({"so": so, "item": item}) # 加入待排集
|
||
|
||
# OR-05：可选纳入 ACTIVE 预测（伪销售订单，排在确定订单之后）
|
||
if params.includeForecast:
|
||
from server.aps_domain.forecast import forecasts_as_schedule_entries
|
||
all_items.extend(forecasts_as_schedule_entries(world))
|
||
|
||
# ---- ② 策略排序（调度规则的最优性依据见 plan.md §9.5.5；OR-02 掺入客户等级权重）----
|
||
strategy = params.strategyTemplate # 策略模板名
|
||
from server.aps_domain.params import level_weight as _level_w
|
||
source_order_count = len(all_items) # 合并前订单项数（SC-08 留痕）
|
||
campaign_meta: dict[str, Any] = {"enabled": False, "windowDays": 7, "poSaved": 0}
|
||
|
||
if strategy == "CAMPAIGN":
|
||
# SC-08：同产品交期窗口内战役合并，再按换型最小化排战役序
|
||
from server.aps_domain.campaign import DEFAULT_CAMPAIGN_WINDOW_DAYS, merge_entries_to_campaigns
|
||
from server.aps_domain.changeover import sort_entries_changeover_min
|
||
window = DEFAULT_CAMPAIGN_WINDOW_DAYS
|
||
all_items = merge_entries_to_campaigns(world, all_items, window_days=window)
|
||
all_items = sort_entries_changeover_min(world, all_items, level_weight_fn=_level_w)
|
||
campaign_meta = {
|
||
"enabled": True, "windowDays": window,
|
||
"poSaved": max(0, source_order_count - len(all_items)),
|
||
"campaignCount": len(all_items),
|
||
"mergedCount": sum(1 for e in all_items if e.get("isCampaign")),
|
||
}
|
||
elif strategy in ("CHANGEOVER_MIN", "COST_FIRST"):
|
||
# SC-07：换型最小化（贪心最近邻）；COST_FIRST 以换型耗时为成本代理
|
||
from server.aps_domain.changeover import sort_entries_changeover_min
|
||
all_items = sort_entries_changeover_min(world, all_items, level_weight_fn=_level_w)
|
||
else:
|
||
def sort_key(entry: dict): # 排序键工厂（Python 稳定排序；数值越小越先排）
|
||
so = entry["so"] # 所属订单
|
||
lw = -_level_w(world, so.get("customerLevel")) # 等级权重越高越靠前
|
||
rush = 0 if so.get("isRush") else 1 # 插单略优先
|
||
forecast = 1 if so.get("isForecast") else 0 # 预测垫后
|
||
if strategy == "DELIVERY_FIRST": # 交期优先 ≈ EDD（Jackson 定理）
|
||
return (forecast, so["deliveryDate"], lw, so["priority"], rush)
|
||
if strategy == "FIFO": # 先来先服务
|
||
return (forecast, so["orderDate"], lw, so["priority"])
|
||
if strategy == "CAPACITY_BALANCE": # 均衡：等级+优先级
|
||
return (forecast, lw, so["priority"], so["deliveryDate"], rush)
|
||
if strategy == "KITTING_FIRST": # 齐套优先：备料已完成先排
|
||
return (forecast, _kit_ready(so), so["deliveryDate"], lw, so["priority"], rush)
|
||
if strategy == "SKILL_FIRST": # 技能优先：高技能需求先排
|
||
return (forecast, _skill_rank(so.get("requiredSkillLevel")), so["deliveryDate"], lw, so["priority"], rush)
|
||
return (forecast, lw, so["priority"], so["deliveryDate"], rush) # 综合
|
||
all_items.sort(key=sort_key) # 应用排序
|
||
return all_items, campaign_meta, source_order_count
|
||
|
||
def materialize_schedule(
|
||
self,
|
||
world: World,
|
||
params: EngineParams,
|
||
next_id: Callable[[str], int],
|
||
all_items: list[dict],
|
||
campaign_meta: dict[str, Any],
|
||
source_order_count: int,
|
||
solver_meta: dict[str, Any] | None = None,
|
||
) -> ScheduleResult:
|
||
"""将已排序条目物化为版本/PO/WO（班次占槽）；entry.forcedLineId 可强制选线。"""
|
||
strategy = params.strategyTemplate
|
||
direct_cp_timing = bool(
|
||
solver_meta
|
||
and solver_meta.get("status") in {"OPTIMAL", "FEASIBLE"}
|
||
and solver_meta.get("directlyConsumedByMaterializer") is True
|
||
and solver_meta.get("operationTimingValidation", {}).get("passed") is True
|
||
)
|
||
if direct_cp_timing:
|
||
_preflight_direct_timing(world, all_items)
|
||
# ---- ③ 创建版本对象（版本链：parent 指向上一版本）----
|
||
now = datetime.now() # 当前时间（版本号与留痕）
|
||
version_id = next_id("scheduleVersion") # 发号
|
||
version: dict[str, Any] = {
|
||
"id": version_id,
|
||
"versionNo": "V" + fmt_date(now).replace("-", "") + f"-{len(world['scheduleVersions']) + 1:03d}", # V+日期+序号
|
||
"versionName": params.name or ("手动排产 " + fmt_dt(now)), # 版本名
|
||
"triggerType": params.triggerType, # 触发类型
|
||
"engineType": self.requested_type, # 如实记录请求引擎
|
||
"status": "DRAFT", # 新版本为草稿（发布走 P2 门禁）
|
||
"parentVersionId": world["scheduleVersions"][-1]["id"] if world["scheduleVersions"] else None, # 版本链
|
||
"orderCount": source_order_count, "poCount": 0, "woCount": 0,
|
||
"totalTardiness": 0.0, "totalCost": 0.0, "avgUtilization": 0.0,
|
||
"conflictCount": 0, "resolvedCount": 0,
|
||
"createdBy": "agent", "createdAt": fmt_dt(now), "publishedAt": None,
|
||
"note": f"strategy={strategy}", # 策略留痕
|
||
"constraintProfile": profile_snapshot(world),
|
||
"campaign": campaign_meta,
|
||
}
|
||
if solver_meta:
|
||
version["solverMeta"] = solver_meta
|
||
world["scheduleVersions"].append(version) # 入库（内存）
|
||
|
||
# ---- ④ 排产准备：基准开始时间与占用登记表 ----
|
||
horizon = params.planningHorizonDays or 14 # 展望期
|
||
base_start = (parse_dt(params.startDate + " 08:00") if params.startDate # 指定起始日 08:00
|
||
else add_minutes(today0(), 24 * 60)) # 默认明天零点
|
||
# SC-06：冻结窗口 → 起点后移（仅当 EngineParams 显式传入）
|
||
if params.freezeWindowHours is not None and float(params.freezeWindowHours) > 0:
|
||
base_start = add_minutes(base_start, int(float(params.freezeWindowHours) * 60))
|
||
used_workstations: dict[int, list[tuple[datetime, datetime]]] = {} # 工位占用区间表
|
||
used_line_minutes: dict[str, float] = {} # 产线-日期占用分钟（均衡策略选线用）
|
||
conflicts: list[dict] = [] # 本次冲突收集器
|
||
new_wo_ids: list[int] = [] # 本次生成的工单 ID（版本内冲突检测范围）
|
||
line_last_family: dict[int, str | None] = {} # MD-06：产线 → 上一订单产品族
|
||
total_changeover = 0.0
|
||
# SC-06：交期缓冲（None=1.0 即不提前）
|
||
due_buffer = 1.0 if params.deliveryBufferRatio is None else max(0.5, min(1.0, float(params.deliveryBufferRatio)))
|
||
|
||
# ---- ⑤ 逐订单项排产 ----
|
||
for entry in all_items: # 遍历待排项
|
||
so, item = entry["so"], entry["item"] # 解构
|
||
entry_timing = entry.get("_cpOperationTiming") if direct_cp_timing else None
|
||
product = next(m for m in world["materials"] if m["id"] == item["productId"]) # 产品主数据
|
||
from server.aps_domain.changeover import extra_setup_minutes, product_family
|
||
cur_family = product_family(product)
|
||
line_options = find_product_lines(world, item["productId"]) # 可选产线
|
||
if not line_options: # 无可用产线 → 致命冲突并跳过
|
||
conflicts.append({"conflictType": "NO_LINE", "severity": "CRITICAL", "productionOrderId": None,
|
||
"resourceType": "LINE", "description": f"产品 {product['name']} 无可用产线配置",
|
||
"suggestedSolution": "维护产线产品配置"})
|
||
continue
|
||
|
||
# 选线：CP 强制 → 均衡 → 换型亲和 → 默认最高优先
|
||
forced = entry.get("forcedLineId")
|
||
option_ids = {lp["lineId"] for lp in line_options}
|
||
if forced is not None and int(forced) in option_ids:
|
||
chosen_line_id = int(forced)
|
||
else:
|
||
chosen_line_id = line_options[0]["lineId"] # 默认最高优先
|
||
if strategy == "CAPACITY_BALANCE": # 产能均衡：按累计占用分钟升序
|
||
chosen_line_id = sorted(line_options, key=lambda lp: sum(
|
||
v for k, v in used_line_minutes.items() if k.startswith(f"{lp['lineId']}_")))[0]["lineId"]
|
||
elif strategy in ("CHANGEOVER_MIN", "COST_FIRST", "CAMPAIGN"):
|
||
def _line_score(lp: dict) -> tuple:
|
||
lid = lp["lineId"]
|
||
last = line_last_family.get(lid)
|
||
load = sum(v for k, v in used_line_minutes.items() if k.startswith(f"{lid}_"))
|
||
# 同族续排最优；空线次之；跨族最差
|
||
affinity = 0 if last == cur_family else (1 if last is None else 2)
|
||
return (affinity, lp.get("priority", 99), load)
|
||
chosen_line_id = sorted(line_options, key=_line_score)[0]["lineId"]
|
||
line = next(l for l in world["lines"] if l["id"] == chosen_line_id) # 产线对象
|
||
|
||
# MD-06 / C10：同线跨产品族时，首道工序叠加换型矩阵分钟
|
||
matrix_extra = 0.0
|
||
if params.constraints.get("changeover", True):
|
||
prev_fam = line_last_family.get(chosen_line_id)
|
||
matrix_extra = extra_setup_minutes(world, prev_fam, cur_family)
|
||
if direct_cp_timing:
|
||
assert isinstance(entry_timing, list)
|
||
matrix_extra = float(entry_timing[0].get("changeoverMin") or 0)
|
||
|
||
# 展开工艺步骤并绑定工位；缺工位 → 致命冲突并跳过
|
||
ws_list = [{"step": step, "ws": find_workstation_for_operation(world, chosen_line_id, step["operationId"])}
|
||
for step in find_routing_steps(world, item["productId"])] # 步骤×工位
|
||
if any(x["ws"] is None for x in ws_list): # 任一步骤无工位
|
||
conflicts.append({"conflictType": "NO_WORKSTATION", "severity": "CRITICAL", "productionOrderId": None,
|
||
"resourceType": "WORKSTATION",
|
||
"description": f"产品 {product['name']} 在产线 {line['name']} 缺少可用工位",
|
||
"suggestedSolution": "维护工位工序配置"})
|
||
continue
|
||
|
||
# 物料齐套：库存不足但在途可补 → 齐套时间推迟 3 天；全缺 → 缺料冲突（SC-04 可关/软硬）
|
||
material_ready = base_start # 默认立即齐套
|
||
kit_sev = material_shortage_severity(world)
|
||
if params.constraints.get("materialKit", True) and kit_sev: # 齐套约束开关
|
||
for bi in find_bom_items(world, item["productId"]): # 遍历 BOM 明细
|
||
mat = next(m for m in world["materials"] if m["id"] == bi["materialId"]) # 物料
|
||
need = bi["quantity"] * item["quantity"] # 总需求
|
||
if mat["stock"] < need and mat["stock"] + mat["inTransit"] >= need: # 在途可补
|
||
eta = add_minutes(today0(), 3 * 24 * 60) # 到货预计 +3 天
|
||
if eta > material_ready: # 取最晚齐套时刻
|
||
material_ready = eta
|
||
elif mat["stock"] + mat["inTransit"] < need: # 在途也不够 → 缺料
|
||
conflicts.append({"conflictType": "MATERIAL_SHORTAGE", "severity": kit_sev,
|
||
"resourceType": "MATERIAL", "resourceName": mat["name"],
|
||
"description": f"{so['orderNo']} {mat['name']} 缺料 "
|
||
f"{int(need - mat['stock'] - mat['inTransit'] + 0.999)} {mat['unit']}",
|
||
"suggestedSolution": "紧急采购或启用替代物料"})
|
||
|
||
# 生产订单壳（时间在工序排完后回填）
|
||
cursor = max(base_start, material_ready) # 排产游标：基准与齐套取晚者
|
||
if direct_cp_timing:
|
||
assert isinstance(entry_timing, list)
|
||
cursor = parse_dt(str(entry_timing[0]["plannedStartTime"]))
|
||
if cursor < material_ready:
|
||
conflicts.append({
|
||
"conflictType": "MATERIAL_SHORTAGE",
|
||
"severity": kit_sev or "CRITICAL",
|
||
"resourceType": "MATERIAL",
|
||
"description": (
|
||
f"{so['orderNo']} 的 CP 开工时间早于物料齐套时间 {fmt_dt(material_ready)}"
|
||
),
|
||
"suggestedSolution": "补齐物料后重新求解，禁止平移已验证的 CP 时间",
|
||
})
|
||
po_start, po_end = cursor, cursor # PO 起止（回填）
|
||
po_id = next_id("productionOrder") # 发号
|
||
camp = entry.get("campaign") or {}
|
||
camp_sources = camp.get("sourceOrderNos") or [so["orderNo"]]
|
||
is_camp = bool(entry.get("isCampaign"))
|
||
production_order: dict[str, Any] = {
|
||
"id": po_id, "orderNo": "PO" + so["orderNo"].replace("SO", "", 1), # PO 号继承 SO 号
|
||
"salesOrderId": so["id"], "salesOrderNo": so["orderNo"], "salesOrderItemId": item["id"],
|
||
"productId": item["productId"], "productName": product["name"], "productCode": product["code"],
|
||
"quantity": item["quantity"], "unit": item["unit"],
|
||
"plannedStartDate": None, "plannedEndDate": None,
|
||
"lineId": line["id"], "lineName": line["name"],
|
||
"status": "DRAFT", "priority": so["priority"],
|
||
"schedulingEngine": self.requested_type, "schedulingVersionId": version_id,
|
||
"materialKitStatus": "PASSED", "constraintCheckStatus": "PASSED",
|
||
"conflictCount": 0, "isRushOrder": so["isRush"], "rushStrategy": so.get("rushStrategy"),
|
||
"productFamily": cur_family, "changeoverMin": matrix_extra,
|
||
"isCampaign": is_camp,
|
||
"campaignMemberCount": camp.get("memberCount") or 1,
|
||
"campaignSourceOrderNos": camp_sources,
|
||
"campaignEarliestDue": camp.get("earliestDue") or so.get("deliveryDate"),
|
||
"campaignLatestDue": camp.get("latestDue") or so.get("deliveryDate"),
|
||
}
|
||
if is_camp:
|
||
production_order["orderNo"] = f"PO-CAMP-{po_id:04d}"
|
||
production_order["note"] = (
|
||
f"战役合并 {camp.get('memberCount')} 单（{'/'.join(str(x) for x in camp_sources)}）"
|
||
f" · 交期窗 {camp.get('earliestDue')}~{camp.get('latestDue')}"
|
||
)
|
||
world["productionOrders"].append(production_order) # 入库
|
||
version["poCount"] += 1 # 版本计数
|
||
if matrix_extra > 0:
|
||
total_changeover += matrix_extra
|
||
|
||
# ---- 逐工序占槽（核心：placeWorkOrder + findSlot 的移植）----
|
||
for idx, pair in enumerate(ws_list): # 按工艺顺序
|
||
step, ws = pair["step"], pair["ws"] # 步骤与工位
|
||
op = next(o for o in world["operations"] if o["id"] == step["operationId"]) # 工序
|
||
# 工时 = 准备时间 +（首道跨族换型）+ 数量×单件时间/产线效率
|
||
setup = step["setupTime"] + (matrix_extra if idx == 0 else 0)
|
||
duration_min = setup + (item["quantity"] * step["runTimePerUnit"]) / (line.get("efficiencyFactor") or 1)
|
||
cp_slot = entry_timing[idx] if direct_cp_timing else None
|
||
if cp_slot is not None:
|
||
placed = (
|
||
parse_dt(str(cp_slot["plannedStartTime"])),
|
||
parse_dt(str(cp_slot["plannedEndTime"])),
|
||
)
|
||
else:
|
||
placed = self._place_work_order(
|
||
world, cursor, chosen_line_id, ws, duration_min,
|
||
used_workstations, used_line_minutes,
|
||
)
|
||
wo_id = next_id("workOrder") # 工单发号
|
||
wo: dict[str, Any] = {
|
||
"id": wo_id, "orderNo": production_order["orderNo"] + f"-{idx + 1:02d}", # 工单号=PO号-序号
|
||
"productionOrderId": po_id, "productionOrderNo": production_order["orderNo"],
|
||
"operationId": op["id"], "operationName": op["name"], "sequenceNo": step["sequenceNo"],
|
||
"productId": item["productId"], "productName": product["name"],
|
||
"quantity": item["quantity"], "unit": item["unit"], "completedQuantity": 0,
|
||
"lineId": line["id"], "lineName": line["name"],
|
||
"workstationId": ws["id"], "workstationName": ws["name"],
|
||
"plannedStartTime": fmt_dt(placed[0]), "plannedEndTime": fmt_dt(placed[1]),
|
||
"status": "PENDING", "teamId": None, "teamName": None,
|
||
"requiredMaterials": [], "priority": so["priority"], "isFrozen": False,
|
||
"kitStatus": "PASSED", "progressPercent": 0, "conflictCount": 0, "note": "",
|
||
"changeoverMin": matrix_extra if idx == 0 else 0,
|
||
"schedulingVersionId": version_id,
|
||
}
|
||
if cp_slot is not None:
|
||
wo.update({
|
||
"teamId": cp_slot.get("teamId"),
|
||
"toolingId": cp_slot.get("toolingId"),
|
||
"routingStepId": cp_slot.get("routingStepId"),
|
||
"logicalOperationKey": cp_slot.get("logicalOperationKey"),
|
||
"cpOrderIndex": cp_slot.get("orderIndex"),
|
||
"plannedSegments": cp_slot["plannedSegments"],
|
||
"processingMinutes": cp_slot["processingMinutes"],
|
||
"elapsedSpanMinutes": cp_slot["elapsedSpanMinutes"],
|
||
"pauseMinutes": cp_slot["pauseMinutes"],
|
||
"segmentCount": cp_slot["segmentCount"],
|
||
"cpTimingSource": "operationSlots",
|
||
"changeoverMin": cp_slot.get("changeoverMin") or 0,
|
||
"setupMin": cp_slot.get("setupMin") or 0,
|
||
})
|
||
if idx == 0 and matrix_extra > 0:
|
||
wo["note"] = f"跨族换型 +{matrix_extra:.0f} 分（{line_last_family.get(chosen_line_id)}→{cur_family}）"
|
||
# IND-02 / C13：SOP 换型宵禁（默认 16:00 后不安排换线）
|
||
from server.aps_domain.constraints import is_enabled as _c_on
|
||
pol = world.get("changeoverPolicy") or {}
|
||
curfew = str(pol.get("noChangeoverAfter") or "")
|
||
if _c_on(world, "C13_sop") and curfew and ":" in curfew:
|
||
try:
|
||
ch, cm = map(int, curfew.split(":")[:2])
|
||
if placed[0].hour > ch or (placed[0].hour == ch and placed[0].minute >= cm):
|
||
conflicts.append({
|
||
"conflictType": "SOP_CHANGEOVER_CURFEW",
|
||
"severity": "MINOR",
|
||
"productionOrderId": po_id,
|
||
"workOrderId": wo_id,
|
||
"resourceType": "SOP",
|
||
"description": (
|
||
f"{production_order['orderNo']} 换型开始于 {fmt_dt(placed[0])}，"
|
||
f"晚于 SOP 宵禁 {curfew}"
|
||
),
|
||
"suggestedSolution": "提前换型或改同族连续排程",
|
||
})
|
||
except ValueError:
|
||
pass
|
||
# 该工序的物料需求与齐套状态（PASSED/PARTIAL/FAILED）
|
||
for bi in [b for b in find_bom_items(world, item["productId"]) if b["operationId"] == op["id"]]:
|
||
mat = next(m for m in world["materials"] if m["id"] == bi["materialId"]) # 物料
|
||
need = bi["quantity"] * item["quantity"] # 需求量
|
||
ks = "PASSED" # 默认齐套
|
||
if mat["stock"] < need: # 库存不足
|
||
ks = "PARTIAL" if mat["stock"] + mat["inTransit"] >= need else "FAILED" # 在途可补=部分
|
||
if ks != "PASSED" and wo["kitStatus"] == "PASSED": # 首个非齐套降级
|
||
wo["kitStatus"] = ks
|
||
elif ks == "FAILED": # 任一 FAILED 直接定级
|
||
wo["kitStatus"] = "FAILED"
|
||
wo["requiredMaterials"].append({"materialId": mat["id"], "name": mat["name"], "required": need,
|
||
"allocated": min(need, mat["stock"]), "available": mat["stock"], "status": ks})
|
||
if wo["kitStatus"] != "PASSED": # 工单齐套问题上卷到 PO
|
||
production_order["materialKitStatus"] = wo["kitStatus"]
|
||
|
||
world["workOrders"].append(wo) # 工单入库
|
||
new_wo_ids.append(wo_id) # 记入本版本工单集
|
||
version["woCount"] += 1 # 版本计数
|
||
cursor = add_minutes(placed[1], step["transferTime"] + step["waitTime"]) # 游标后移（转移+等待）
|
||
po_end = placed[1] # 更新 PO 结束
|
||
|
||
# 回填 PO 起止时间与交期延迟冲突
|
||
production_order["plannedStartDate"] = fmt_dt(po_start) # PO 开始
|
||
production_order["plannedEndDate"] = fmt_dt(po_end) # PO 结束
|
||
line_last_family[chosen_line_id] = cur_family # MD-06 记本线末族
|
||
due = parse_dt(so["deliveryDate"] + " 18:00") # 交期基准 18:00
|
||
# SC-06：缓冲比 <1 → 有效交期按「起点→交期」跨度比例提前
|
||
if due_buffer < 1.0 - 1e-9:
|
||
span_min = (due - base_start).total_seconds() / 60.0
|
||
if span_min > 0:
|
||
due = add_minutes(base_start, span_min * due_buffer)
|
||
if po_end > due: # 晚于交期 → 延迟冲突
|
||
hours_late = (po_end - due).total_seconds() / 3600 # 延迟小时
|
||
version["totalTardiness"] += hours_late # 累计延迟
|
||
if params.constraints.get("dueDate", True):
|
||
conflicts.append({"conflictType": "DELAY", "severity": "MAJOR", "productionOrderId": po_id,
|
||
"resourceType": "TIME",
|
||
"description": f"{production_order['orderNo']} 完成时间晚于交期 {hours_late:.1f} 小时",
|
||
"suggestedSolution": "启用加班/替代产线/压缩准备时间"})
|
||
|
||
# ---- ⑥ 容量冲突检测（仅扫本版本工单，修正 legacy 跨版本误报）----
|
||
if params.constraints.get("capacity", True):
|
||
new_wos = [w for w in world["workOrders"] if w["id"] in set(new_wo_ids)] # 本版本工单集
|
||
for line in world["lines"]: # 逐产线
|
||
loads: dict[str, float] = {} # 日期 → 占用分钟
|
||
for wo in new_wos: # 累计当日负荷
|
||
if wo["lineId"] != line["id"]: # 非本线跳过
|
||
continue
|
||
d = wo["plannedStartTime"][:10] # 开始日期
|
||
dur = _processing_minutes(wo) # C7：开工日归集 processing，不计暂停包络
|
||
loads[d] = loads.get(d, 0) + dur # 聚合
|
||
for d, minutes in loads.items(): # 逐日校验
|
||
avail = get_available_minutes(world, line["id"], d) # 当日可用
|
||
if minutes > avail * 1.05: # 超出 5% 容差 → 容量冲突
|
||
conflicts.append({"conflictType": "CAPACITY", "severity": "CRITICAL", "resourceType": "LINE",
|
||
"resourceName": line["name"], "conflictTimeStart": d + " 08:00",
|
||
"description": f"{line['name']} {d} 负荷 {round(minutes)} 分钟，超出可用 {round(avail)} 分钟",
|
||
"suggestedSolution": "分流至替代产线或启用加班"})
|
||
|
||
# ---- ⑦ 设备维保冲突检测（仅扫本版本工单；已取消维保不算窗口 MD-03）----
|
||
new_wos = [w for w in world["workOrders"] if w["id"] in set(new_wo_ids)] # 本版本工单集
|
||
if params.constraints.get("equipment", True):
|
||
for m in world["maintenance"]: # 逐条维保计划
|
||
if m.get("status", "PLANNED") not in ("PLANNED", "IN_PROGRESS"): # 取消/完成的维保不避让
|
||
continue
|
||
ms, me = parse_dt(m["plannedStart"]), parse_dt(m["plannedEnd"]) # 维保时段
|
||
for wo in new_wos: # 逐工单比对
|
||
eq = next((e for e in world["equipment"] if e["workstationId"] == wo["workstationId"]), None) # 工位设备
|
||
if not eq or eq["id"] != m["equipmentId"]: # 非该设备跳过
|
||
continue
|
||
if any(ws_t < me and we_t > ms for ws_t, we_t in _processing_intervals(wo)):
|
||
conflicts.append({"conflictType": "EQUIPMENT", "severity": "CRITICAL", "workOrderId": wo["id"],
|
||
"resourceType": "EQUIPMENT", "resourceName": eq["name"],
|
||
"description": f"{wo['orderNo']} 与设备 {eq['name']} 维保时间冲突",
|
||
"suggestedSolution": "调整工单时间或启用替代设备"})
|
||
|
||
# ---- ⑧ 冲突入库并回填计数 ----
|
||
for cf in conflicts: # 逐条补全元数据
|
||
cf["id"] = next_id("conflict") # 发号
|
||
cf["versionId"] = version_id # 归属版本
|
||
cf["isResolved"] = False # 初始未解决
|
||
cf["resolutionAction"] = "" # 解决动作留空
|
||
world["conflicts"].append(cf) # 入库
|
||
version["conflictCount"] = len(conflicts) # 版本冲突数
|
||
|
||
# PO 冲突计数与约束检查状态回填（legacy 逻辑保留）
|
||
wo_by_id = {w["id"]: w for w in new_wos} # 工单索引
|
||
for po in [p for p in world["productionOrders"] if p["schedulingVersionId"] == version_id]: # 本版本 PO
|
||
po["conflictCount"] = sum( # 关联冲突数 = 直接挂 PO + 经工单挂 PO
|
||
1 for c in conflicts
|
||
if c.get("productionOrderId") == po["id"]
|
||
or (c.get("workOrderId") in wo_by_id and wo_by_id[c["workOrderId"]]["productionOrderId"] == po["id"]))
|
||
if po["conflictCount"] > 0: # 有冲突 → 检查失败
|
||
po["constraintCheckStatus"] = "FAILED"
|
||
elif po["materialKitStatus"] != "PASSED": # 无冲突但缺料 → 告警
|
||
po["constraintCheckStatus"] = "WARNING"
|
||
|
||
# ---- ⑨ 利用率与成本统计（仅本版本工单，见模块头偏差说明 2）----
|
||
line_util: dict[int, dict[str, float]] = {} # 产线 → {used, avail}
|
||
for wo in new_wos: # 累计占用
|
||
dur = _processing_minutes(wo)
|
||
line_util.setdefault(wo["lineId"], {"used": 0.0, "avail": 0.0})["used"] += dur # 聚合占用
|
||
for line in world["lines"]: # 累计可用（展望期内逐日）
|
||
for i in range(horizon): # 展望期每一天
|
||
d = fmt_date(add_minutes(base_start, i * 24 * 60)) # 第 i 天
|
||
line_util.setdefault(line["id"], {"used": 0.0, "avail": 0.0})["avail"] += \
|
||
get_available_minutes(world, line["id"], d) # 累加可用分钟
|
||
utils = [(x["used"] / x["avail"]) if x["avail"] else 0.0 for x in line_util.values()] # 各线利用率
|
||
version["avgUtilization"] = sum(utils) / len(utils) if utils else 0.0 # 平均利用率
|
||
version["totalCost"] = version["woCount"] * 120 + version["totalTardiness"] * 50 # 成本（演示口径）
|
||
version["totalChangeoverMin"] = round(total_changeover, 1)
|
||
note_bits = [f"strategy={strategy}", f"changeoverMin={version['totalChangeoverMin']}"]
|
||
if campaign_meta.get("enabled"):
|
||
note_bits.append(f"campaignSaved={campaign_meta.get('poSaved', 0)}")
|
||
if solver_meta:
|
||
note_bits.append(f"solver={solver_meta.get('backend', 'CP')}")
|
||
note_bits.append(f"status={solver_meta.get('status')}")
|
||
if solver_meta.get("gap") is not None:
|
||
note_bits.append(f"gap={solver_meta.get('gap')}")
|
||
if solver_meta.get("wallTimeSec") is not None:
|
||
note_bits.append(f"t={solver_meta.get('wallTimeSec')}s")
|
||
version["note"] = ";".join(note_bits)
|
||
|
||
# ---- ⑩ 排产日志（审计的业务侧留痕）----
|
||
world["logs"].insert(0, {"id": next_id("log"), "type": "INFO", "category": "SCHEDULE",
|
||
"operationType": "SCHEDULE", "targetType": "SCHEDULE_VERSION", "targetId": version_id,
|
||
"action": "执行排产",
|
||
"description": f"版本 {version['versionNo']} 生成 {version['poCount']} 个生产订单 / "
|
||
f"{version['woCount']} 个工单，冲突 {version['conflictCount']}",
|
||
"operator": "agent", "createdAt": fmt_dt(now)})
|
||
|
||
# ---- ⑪ 输出结果摘要（契约校验后返回）----
|
||
gap = None
|
||
status = None
|
||
wall = None
|
||
if solver_meta:
|
||
status = solver_meta.get("status")
|
||
wall = solver_meta.get("wallTimeSec")
|
||
gap = solver_meta.get("gap")
|
||
refs = [f"run:{version['versionNo']}"]
|
||
if solver_meta and solver_meta.get("backend"):
|
||
refs.append(f"solver:{solver_meta['backend']}")
|
||
return ScheduleResult(
|
||
versionId=version_id, versionNo=version["versionNo"],
|
||
engineType=self.requested_type, strategy=strategy, status="DRAFT",
|
||
orderCount=version["orderCount"], poCount=version["poCount"], woCount=version["woCount"],
|
||
conflictCount=version["conflictCount"], totalTardiness=version["totalTardiness"],
|
||
avgUtilization=version["avgUtilization"], totalCost=version["totalCost"],
|
||
evidenceRefs=refs,
|
||
solveStatus=status, solveTimeSec=wall, optimalityGap=gap,
|
||
)
|
||
|
||
# ---------------- 占槽（placeWorkOrder 移植 + 长工序修正）----------------
|
||
def _place_work_order(self, world: World, cursor: datetime, line_id: int, ws: dict, duration_min: float,
|
||
used_ws: dict[int, list[tuple[datetime, datetime]]],
|
||
used_line_minutes: dict[str, float]) -> tuple[datetime, datetime]:
|
||
"""在班次日历内为工序找一个不与已占区间重叠的时段。
|
||
|
||
对 legacy 的修正（黄金测试 G2/G4 固化）：工时超过单班次长度的"长工序"，
|
||
legacy 会静默兜底硬排（导致周末开工与工位双占）；本实现改为"长工序模式"——
|
||
起点仍必须落在工作班次内，允许其跨班次/跨夜连续运行（M1 简化：视为连续生产，
|
||
正式拆分逻辑属 M5 工单拆分能力）。
|
||
"""
|
||
max_days = 30 # 最多向后找 30 天（legacy 同值；种子日历已覆盖 30 天）
|
||
for day_offset in range(max_days): # 逐日尝试
|
||
day = add_minutes(cursor, day_offset * 24 * 60) # 目标日
|
||
date_str = fmt_date(day) # 日期字符串
|
||
shifts = get_line_shifts(world, line_id, date_str) # 当日工作班次
|
||
if not shifts: # 无班次（周末）→ 下一天
|
||
continue
|
||
for shift in shifts: # 逐班次尝试
|
||
sh, sm = map(int, shift["startTime"].split(":")) # 班次开始时分
|
||
candidate = parse_dt(f"{date_str} {sh:02d}:{sm:02d}") # 候选开始=班次开始
|
||
if candidate < cursor and day_offset == 0: # 当天且早于游标 → 从游标起
|
||
candidate = cursor
|
||
eh, em = map(int, shift["endTime"].split(":")) # 班次结束时分
|
||
shift_end = parse_dt(f"{date_str} {eh:02d}:{em:02d}") # 班次结束时刻
|
||
if candidate >= shift_end: # 游标已越过本班次 → 下一班次
|
||
continue
|
||
# 判断是否"长工序"：从候选点起到班次结束都放不下完整工时
|
||
fits_in_shift = duration_min <= (shift_end - candidate).total_seconds() / 60
|
||
if fits_in_shift: # —— 普通模式：完整落在本班次内 ——
|
||
start = self._find_slot(candidate, shift_end, ws["id"], duration_min, used_ws) # 班次内找空槽
|
||
if start is not None: # 找到候选
|
||
end = add_minutes(start, duration_min) # 推算结束
|
||
if end > shift_end: # 越过班次结束 → 换下一班次
|
||
continue
|
||
used_ws.setdefault(ws["id"], []).append((start, end)) # 登记占用区间
|
||
key = f"{line_id}_{date_str}" # 产线-日期键
|
||
used_line_minutes[key] = used_line_minutes.get(key, 0) + duration_min # 登记产线占用
|
||
return (start, end) # 占槽成功
|
||
else: # —— 长工序模式：起点在班次内，允许跨班次连续运行 ——
|
||
start = self._find_slot(candidate, shift_end, ws["id"], duration_min, used_ws) # 起点扫描范围仍限本班次
|
||
if start is not None: # 找到不与任何已占区间重叠的起点
|
||
end = add_minutes(start, duration_min) # 结束可越过班次（连续生产）
|
||
used_ws.setdefault(ws["id"], []).append((start, end)) # 登记占用区间
|
||
key = f"{line_id}_{date_str}" # 占用记账仍按开工日归集
|
||
used_line_minutes[key] = used_line_minutes.get(key, 0) + duration_min
|
||
return (start, end) # 占槽成功
|
||
# 兜底：30 天内无槽（极端过载）→ 从游标硬排并留待容量冲突暴露（legacy 语义保留）
|
||
return (cursor, add_minutes(cursor, duration_min))
|
||
|
||
# ---------------- 找槽（findSlot 移植）----------------
|
||
def _find_slot(self, t_from: datetime, t_end: datetime, ws_id: int, duration_min: float,
|
||
used_ws: dict[int, list[tuple[datetime, datetime]]]) -> datetime | None:
|
||
"""从 t_from 起以 15 分钟步长扫描，返回首个与已占区间不重叠的开始时刻。"""
|
||
t = t_from # 扫描游标
|
||
intervals = used_ws.get(ws_id, []) # 该工位已占区间
|
||
while t <= t_end: # 未越界
|
||
end = add_minutes(t, duration_min) # 候选结束
|
||
overlap = any(t < iv_end and end > iv_start for iv_start, iv_end in intervals) # 区间重叠判定
|
||
if not overlap: # 无重叠 → 命中
|
||
return t
|
||
t = add_minutes(t, 15) # 后移 15 分钟（排产粒度）
|
||
return None # 本班次内无槽
|