# ============================================================ # 现场「完整生产路线」导入（moduleId: domain-kangni-intake, 可重生 ✅） # 将康尼现场 Excel 落到 flex* 键，替换演示种子，供 PoolEngine 排产。 # 口径：docs/product/demand-data-intake.md；缺口用显式推断并写入 flexParams.siteInferences。 # 客户差异（工厂命名/工时推断规则/默认路径）收敛在 server/importers/profiles/kangni.json， # 本模块仅保留解析逻辑 + 兜底默认值（profile 缺失时可独立运行）。 # ============================================================ from __future__ import annotations import re from copy import deepcopy from datetime import datetime from pathlib import Path from typing import Any World = dict[str, Any] class KangniDataMappingError(ValueError): """康尼源表无法唯一、安全映射到订单时抛出。""" def _profile() -> dict[str, Any]: """加载康尼导入 profile（配置文件缺失时返回空 dict → 走内置兜底）。""" try: from server.importers.excel_importer import load_profile return load_profile("kangni") except Exception: return {} _P = _profile() # 现场默认路径（profile 可覆盖；再可被环境变量 / API / 脚本覆盖） DEFAULT_ROUTE_XLSX = Path(_P.get("defaultRouteXlsx") or ( r"D:\ItemSpace\14.工业智核\康尼\数据\outputs" r"\019f8987-be3f-7261-a9d3-efc1ecf9c27d\订单102285668_完整生产路线.xlsx" )) DEFAULT_DATA_DIR = Path(_P.get("dataDir") or r"D:\ItemSpace\14.工业智核\康尼\数据") # 工时/产能缺口推断（源表「待维护」时启用；单位：分钟/件） _INFER_STD_MIN = {k: float(v) for k, v in (_P.get("inferStdMin") or {"部装": 45.0, "装配": 30.0, "_default": 30.0}).items()} _DEFAULT_STATION_COUNT = int(_P.get("stationCount") or 4) _FLEX_CLEAR_KEYS = ( "flexZones", "flexOperations", "flexEquipment", "flexMolds", "flexMaterials", "flexBom", "flexRoutings", "flexTeams", "flexCalendar", "flexOrders", "flexParams", "flexScheduleVersions", "flexVirtualLines", "flexWorkOrders", "flexConflicts", ) # 固定轨 + 排产产物：加载现场时整表清空（去掉演示垃圾） _FIXED_CLEAR_KEYS = ( "factories", "workshops", "lines", "workstations", "equipment", "operations", "routings", "routingSteps", "materials", "boms", "bomItems", "lineProducts", "workstationOperations", "teams", "shifts", "shiftCalendar", "maintenance", "salesOrders", "productionOrders", "workOrders", "purchaseOrders", "outsourceOrders", "forecastOrders", "changeoverMatrix", "scheduleVersions", "conflicts", "logs", ) def _clean(v: Any) -> str: if v is None: return "" return str(v).replace("\u200b", "").strip() def _num(v: Any, default: float = 0.0) -> float: if v is None or v == "": return default if isinstance(v, (int, float)): return float(v) s = _clean(v).replace(",", "") try: return float(s) except ValueError: return default def _sequence(v: Any, fallback: int) -> int: s = _clean(v) if not s: return fallback try: return int(float(s)) except ValueError: return fallback def _is_pending(v: Any) -> bool: s = _clean(v) return (not s) or ("待维护" in s) or s.lower() in ("n/a", "na", "-", "—") def _parse_dt_date(v: Any) -> str | None: """任意日期/时间 → YYYY-MM-DD。""" if v is None or v == "": return None if isinstance(v, datetime): return v.strftime("%Y-%m-%d") s = _clean(v) m = re.match(r"(\d{4}-\d{2}-\d{2})", s) if m: return m.group(1) try: return datetime.fromisoformat(s.replace("/", "-")).strftime("%Y-%m-%d") except ValueError: return None def _infer_std_min(op_type: str, raw_hours: Any, infer_map: dict[str, float] | None = None) -> tuple[float, bool]: """返回 (分钟/件, 是否推断)。源表工时单位为小时；推断规则可由 profile 覆盖。""" rules = infer_map or _INFER_STD_MIN if not _is_pending(raw_hours): h = _num(raw_hours, 0.0) if h > 0: return (h * 60.0, False) t = _clean(op_type) for key, mins in rules.items(): if key != "_default" and key in t: return (float(mins), True) return (float(rules.get("_default", 30.0)), True) def _find_file(data_dir: Path, kind: str) -> Path | None: """按语义找源表（文件名乱码时靠 sheet 特征）。kind: orders|routing|bom|equipment|molds|materials。""" if not data_dir.exists(): return None try: import openpyxl except ImportError: return None name_hints = { "orders": ("订单",), "routing": ("工艺路线", "路线"), "stdtime": ("工时",), "equipmap": ("设备能力",), "moldmap": ("模具适配",), "bom": ("BOM", "bom"), "equipment": ("设备", "Equipment"), "molds": ("模具", "Mould", "Mold"), "materials": ("物料",), } for f in sorted(data_dir.glob("*.xlsx")): if any(h.lower() in f.name.lower() for h in name_hints.get(kind, ())): return f for f in sorted(data_dir.glob("*.xlsx")): try: wb = openpyxl.load_workbook(f, read_only=True, data_only=True) names = wb.sheetnames # 读首行表头 ws = wb[names[0]] header = [] for i, row in enumerate(ws.iter_rows(values_only=True)): header = [_clean(c) for c in row] break wb.close() except Exception: continue hs = "".join(header) if kind == "orders" and ("生产订单" in hs or "WBS" in hs) and "计划" in hs: return f if kind == "routing" and "工序编号" in hs and "标准工时" in hs and "工序类型" in hs: return f if kind == "stdtime" and "工序编号" in hs and "标准工时" in hs and "工序名称" in hs: return f if kind == "equipmap" and "设备编号" in hs and "可执行工序" in hs: return f if kind == "moldmap" and "模具编号" in hs and "适用工序" in hs: return f if kind == "bom" and "MES工序编号" in hs and "物料编号" in hs: return f if kind == "equipment" and ("设备编号" in hs or names == ["Equipment"]): return f if kind == "molds" and ("工装模具" in hs or "模具编号" in hs or "ABC分类" in hs): return f if kind == "materials" and "物料代码" in hs: return f # 工艺/BOM 多 sheet 名为订单号 if kind in ("routing", "bom") and any(re.fullmatch(r"\d{6,}", n or "") for n in names): # 再看第一个订单 sheet 表头 try: wb = openpyxl.load_workbook(f, read_only=True, data_only=True) order_sheets = [n for n in wb.sheetnames if re.fullmatch(r"\d{6,}", n)] if not order_sheets: wb.close() continue ws = wb[order_sheets[0]] hdr = [] for row in ws.iter_rows(values_only=True): hdr = [_clean(c) for c in row] break wb.close() blob = "".join(hdr) if kind == "routing" and "工序编号" in blob: return f if kind == "bom" and "物料编号" in blob: return f except Exception: continue return None def parse_std_time_sheet(path: Path, order_no: str) -> dict[str, float]: """从「工时.xlsx」按订单 sheet 读标准工时（分钟/件）。""" import openpyxl wb = openpyxl.load_workbook(path, data_only=True) try: if order_no not in wb.sheetnames: return {} ws = wb[order_no] rows = list(ws.iter_rows(values_only=True)) finally: wb.close() if not rows: return {} headers = [_clean(c) for c in rows[0]] col = {h: i for i, h in enumerate(headers) if h} out: dict[str, float] = {} op_col = col.get("工序编号") std_cols = [i for n, i in col.items() if n in ("标准工时/分钟", "标准工时", "工时")] for row in rows[1:]: if op_col is None or op_col >= len(row): continue code = _clean(row[op_col]) if not code: continue v = 0.0 for idx in std_cols: if idx < len(row): v = _num(row[idx], 0.0) if v > 0: break if v > 0: out[code] = float(v) return out def load_std_time_map(data_dir: Path) -> dict[str, dict[str, float]]: """扫描「工时.xlsx」全部订单 sheet → {订单号: {工序编号: 分钟}}。""" if not data_dir.exists(): return {} std_xlsx = _find_file(data_dir, "stdtime") if not std_xlsx: return {} import openpyxl wb = openpyxl.load_workbook(std_xlsx, read_only=True, data_only=True) try: names = list(wb.sheetnames) finally: wb.close() result: dict[str, dict[str, float]] = {} for order_no in names: times = parse_std_time_sheet(std_xlsx, order_no) if times: result[order_no] = times return result def load_std_route_map(data_dir: Path) -> dict[str, list[dict[str, Any]]]: """从工时表订单命名 sheet 读取规范工序序列，供 generic routing 安全匹配。""" if not data_dir.exists(): return {} std_xlsx = _find_file(data_dir, "stdtime") if not std_xlsx: return {} import openpyxl wb = openpyxl.load_workbook(std_xlsx, read_only=True, data_only=True) try: result: dict[str, list[dict[str, Any]]] = {} for order_no in wb.sheetnames: rows = list(wb[order_no].iter_rows(values_only=True)) if not rows: continue headers = [_clean(c) for c in rows[0]] col = {h: i for i, h in enumerate(headers) if h} specs: list[dict[str, Any]] = [] for row in rows[1:]: code = _clean(_cell(row, col, "工序编号")) if not code: continue specs.append({ "seq": _sequence( _cell(row, col, "排序号", "序号"), (len(specs) + 1) * 10, ), "operationCode": code, "operationName": _clean(_cell(row, col, "工序名称")) or code, "opType": _clean(_cell(row, col, "工序类型", "类型")), }) if specs: result[_clean(order_no)] = specs return result finally: wb.close() def _apply_std_time_map( order: dict[str, Any], std_time_map: dict[str, dict[str, float]], *, override_existing: bool = False, ) -> None: """用工时表回填；真实主单入口可显式要求覆盖完整路线中的旧值。""" times = (std_time_map or {}).get(order.get("orderNo") or "") or {} if not times: return for op in order.get("operations") or []: code = op.get("operationCode") if code in times and (override_existing or op.get("stdTimeInferred")): op["stdTimePerUnit"] = float(times[code]) op["stdTimeInferred"] = False op["stdTimeSource"] = "工时表" def _split_multi(v: Any) -> list[str]: """逗号/顿号/分号分隔的多值列。""" return [x.strip() for x in re.split(r"[,，;；、]", _clean(v)) if x.strip()] def _bool_yn(v: Any) -> bool: s = _clean(v).lower() return s in ("1", "true", "yes", "y", "是", "启用") def _cell(row: tuple, col: dict[str, int], *names: str) -> Any: """按别名读单元格，避免循环内闭包。""" for n in names: idx = col.get(n) if idx is not None and idx < len(row): return row[idx] return None def parse_equipment_capability_map(path: Path) -> list[dict[str, Any]]: """读取「设备能力映射模板.xlsx」→ flexEquipment 行。""" import openpyxl wb = openpyxl.load_workbook(path, data_only=True) try: rows = list(wb.active.iter_rows(values_only=True)) finally: wb.close() if not rows: return [] headers = [_clean(c) for c in rows[0]] col = {h: i for i, h in enumerate(headers) if h} out: list[dict[str, Any]] = [] for row in rows[1:]: code = _clean(_cell(row, col, "设备编号", "设备编码")) if not code: continue caps = _split_multi(_cell(row, col, "可执行工序编号", "能力工序")) op_std: dict[str, float] = {} op_std_raw = _clean(_cell(row, col, "单件工时", "工序工时", "单件工时(分钟,工序:分钟;多值分号)")) for part in op_std_raw.split(";"): if ":" in part: k, v = part.split(":", 1) op_std[_clean(k)] = _num(v, 0.0) out.append({ "code": code, "name": _clean(_cell(row, col, "设备名称")) or code, "capabilities": caps, "opStdTime": op_std, "movable": _bool_yn(_cell(row, col, "是否可移动", "可移动")), "moveTimeMin": _num(_cell(row, col, "移动耗时", "移动耗时(分钟)"), 0.0), "zone": _clean(_cell(row, col, "区域编码", "区域")), "adaptableMolds": _split_multi(_cell(row, col, "适配模具编号", "适配模具", "适配模具编号(逗号分隔)")), "availabilityRate": _num(_cell(row, col, "可动率", "可用率"), 0.95) or 0.95, "status": _clean(_cell(row, col, "状态")) or "RUNNING", "note": _clean(_cell(row, col, "备注")), }) return out def parse_mold_adaptation_map(path: Path) -> list[dict[str, Any]]: """读取「模具适配映射模板.xlsx」→ flexMolds 行。""" import openpyxl wb = openpyxl.load_workbook(path, data_only=True) try: rows = list(wb.active.iter_rows(values_only=True)) finally: wb.close() if not rows: return [] headers = [_clean(c) for c in rows[0]] col = {h: i for i, h in enumerate(headers) if h} out: list[dict[str, Any]] = [] for row in rows[1:]: code = _clean(_cell(row, col, "模具编号", "模具编码")) if not code: continue out.append({ "code": code, "name": _clean(_cell(row, col, "模具名称")) or code, "operationCode": _clean(_cell(row, col, "适用工序编号", "适用工序")), "adaptableEquipment": _split_multi(_cell(row, col, "适配设备编号", "适配设备", "适配设备编号(逗号分隔)")), "lifeTotal": _num(_cell(row, col, "寿命上限"), 0.0), "lifeUsed": _num(_cell(row, col, "已用寿命"), 0.0), "zone": _clean(_cell(row, col, "区域编码", "区域")), "changeoverMin": _num(_cell(row, col, "换型耗时", "换型耗时(分钟)"), 10.0) or 10.0, "status": _clean(_cell(row, col, "状态")) or "AVAILABLE", "note": _clean(_cell(row, col, "备注")), }) return out def build_flex_equipment_and_molds( data_dir: Path, packages: list[dict[str, Any]], op_std: dict[str, float], all_op_codes: list[str], profile: dict[str, Any], ) -> tuple[list[dict[str, Any]], list[dict[str, Any]], set[str], list[str]]: """优先用设备能力/模具适配映射表；缺表时回退合成共享装配工位。""" inferences: list[str] = [] equip_map_path = _find_file(data_dir, "equipmap") if data_dir.exists() else None mold_map_path = _find_file(data_dir, "moldmap") if data_dir.exists() else None equipment: list[dict[str, Any]] = [] molds: list[dict[str, Any]] = [] mold_ops: set[str] = set() zone_cfg = profile.get("zone") or {} default_zone = zone_cfg.get("code") or "ZONE-CG" if equip_map_path: equipment = parse_equipment_capability_map(equip_map_path) for i, row in enumerate(equipment): row["id"] = i + 1 row["zone"] = row.get("zone") or default_zone row["availabilityRate"] = float(row.get("availabilityRate") or profile.get("availabilityRate") or 0.95) row["status"] = row.get("status") or "RUNNING" row["inferred"] = False times = dict(row.get("opStdTime") or {}) for cap in row.get("capabilities") or []: times.setdefault(cap, op_std.get(cap, 30.0)) row["opStdTime"] = times if equipment: inferences.append(f"设备能力映射表已读取（{len(equipment)} 台）") if mold_map_path: molds = parse_mold_adaptation_map(mold_map_path) for i, row in enumerate(molds): row["id"] = i + 1 row["zone"] = row.get("zone") or default_zone row["status"] = row.get("status") or "AVAILABLE" row["changeoverMin"] = float(row.get("changeoverMin") or 10.0) row["lifeTotal"] = float(row.get("lifeTotal") or 0.0) row["lifeUsed"] = float(row.get("lifeUsed") or 0.0) row["inferred"] = False if row.get("operationCode"): mold_ops.add(row["operationCode"]) if molds: inferences.append(f"模具适配映射表已读取（{len(molds)} 套）") if not equipment: station_count = int(profile.get("stationCount") or 4) ws_prefix = profile.get("stationCodePrefix") or "WS-CG-" ws_name = profile.get("stationNamePrefix") or "城轨机构装配工位" avail = float(profile.get("availabilityRate") or 0.95) for i in range(station_count): code = f"{ws_prefix}{i + 1:02d}" equipment.append({ "id": i + 1, "code": code, "name": f"{ws_name}#{i + 1}", "capabilities": list(all_op_codes), "opStdTime": dict(op_std), "movable": False, "moveTimeMin": 0, "zone": default_zone, "adaptableMolds": [], "availabilityRate": avail, "status": "RUNNING", "inferred": True, }) inferences.append( f"设备/工位源表待维护 → 合成 {station_count} 台共享装配工位 " f"（能力=全部 {len(all_op_codes)} 道工序）" ) if not molds: inferences.append("模具未匹配到本产品 → requireMold=false，不占模具槽") return equipment, molds, mold_ops, inferences def parse_complete_route_xlsx(path: str | Path, infer_map: dict[str, float] | None = None) -> dict[str, Any]: """解析「订单XXXX_完整生产路线.xlsx」→ 单订单包（infer_map=profile 工时推断规则）。""" import openpyxl path = Path(path) if not path.exists(): raise FileNotFoundError(f"找不到生产路线文件: {path}") wb = openpyxl.load_workbook(path, data_only=True) ws = wb.active rows = [[ws.cell(r, c).value for c in range(1, ws.max_column + 1)] for r in range(1, ws.max_row + 1)] wb.close() order: dict[str, Any] = { "orderNo": "", "productCode": "", "productName": "", "drawingNo": "", "quantity": 1.0, "planStart": None, "dueDate": None, "wbs": "", "project": "", "status": "RELEASED", "kitStatus": "", "operations": [], "bom": [], "source": str(path), } # ---- 头信息：扫前 15 行键值对 ---- for row in rows[:15]: cells = [_clean(c) for c in row] for i, cell in enumerate(cells): nxt = cells[i + 1] if i + 1 < len(cells) else "" if cell in ("订单代码", "订单号") and nxt: order["orderNo"] = nxt elif cell in ("产品料号", "料号") and nxt: order["productCode"] = nxt elif cell == "订单数量" and nxt: order["quantity"] = _num(nxt, 1.0) or 1.0 elif cell in ("计划开始",) and nxt: order["planStart"] = _parse_dt_date(nxt) elif cell in ("计划结束", "交期") and nxt: order["dueDate"] = _parse_dt_date(nxt) elif cell == "WBS" and nxt: order["wbs"] = nxt elif cell == "项目" and nxt: order["project"] = nxt elif cell == "订单状态" and nxt: order["status"] = "RELEASED" if "运行" in nxt or nxt in ("RELEASED", "已下达") else "CREATED" elif cell == "备料状态" and nxt: order["kitStatus"] = nxt # 标题行补充产品名 if rows: title = _clean(rows[1][0] if len(rows) > 1 else "") m = re.search(r"产品\s*(\S+)[｜|].+?(?:图号\s*(\S+))?", title) if m: if not order["productCode"]: order["productCode"] = m.group(1) order["drawingNo"] = m.group(2) or "" # 「产品 CODE｜NAME｜图号」 parts = re.split(r"[｜|]", title) if len(parts) >= 2: order["productName"] = parts[1].strip() # ---- 工艺明细表 ---- op_header_idx = None for i, row in enumerate(rows): cells = [_clean(c) for c in row] if "工序编号" in cells and ("标准工时" in "".join(cells) or "顺序" in cells): op_header_idx = i break if op_header_idx is not None: headers = [_clean(c) for c in rows[op_header_idx]] col = {h: i for i, h in enumerate(headers) if h} def _c(row, *names, default=""): for n in names: if n in col and col[n] < len(row): return row[col[n]] return default for row in rows[op_header_idx + 1:]: code = _clean(_c(row, "工序编号")) if not code or not re.match(r"^[\w\-]+$", code): # 遇到下一节标题则停 first = _clean(row[0]) if row else "" if first.startswith("三、") or first.startswith("关键说明") or first.startswith("BOM"): break continue name = _clean(_c(row, "工序名称")) op_type = _clean(_c(row, "类型", "工序类型")) raw_std = _c(row, "标准工时(h)", "标准工时") std_min, inferred = _infer_std_min(op_type, raw_std, infer_map) seq = int(_num(_c(row, "顺序", "序号", "排序号"), len(order["operations"]) + 1)) order["operations"].append({ "seq": seq * 10 if seq < 100 else seq, "operationCode": code, "operationName": name or code, "opType": op_type, "stdTimePerUnit": std_min, "stdTimeInferred": inferred, "resourceGroup": _clean(_c(row, "资源组")), "equipmentHint": _clean(_c(row, "具体设备/工位")), "moldHint": _clean(_c(row, "工装/模具")), "requireMold": False, # 源表未匹配专用模具 }) # ---- BOM ---- bom_header_idx = None for i, row in enumerate(rows): cells = [_clean(c) for c in row] if "物料编号" in cells or ("物料编码" in cells and "投料点" in cells): bom_header_idx = i break if bom_header_idx is not None: headers = [_clean(c) for c in rows[bom_header_idx]] col = {h: i for i, h in enumerate(headers) if h} def _b(row, *names, default=""): for n in names: if n in col and col[n] < len(row): return row[col[n]] return default for row in rows[bom_header_idx + 1:]: mat = _clean(_b(row, "物料编号", "物料编码")) if not mat or mat.startswith("关键") or mat.startswith("BOM"): first = _clean(row[0]) if row else "" if first.startswith("关键") or first.startswith("四、"): break continue # 过滤层级伪编码（M01 / 1.1.01 误入物料列） if re.match(r"^M\d{2}$", mat) or re.match(r"^\d+\.\d+", mat) or len(mat) < 4: continue op_code = _clean(_b(row, "工序编号", "MES工序编号")) qty = _num(_b(row, "单位用量", "用量", "数量"), 1.0) name = _clean(_b(row, "物料名称", "名称")) if not name and len(row) > 4: name = _clean(row[4]) order["bom"].append({ "materialCode": mat, "materialName": name or mat, "quantity": qty, "consumeOp": op_code or (order["operations"][0]["operationCode"] if order["operations"] else ""), "isKey": qty >= 1.0, }) if not order["orderNo"]: raise ValueError(f"未能从 {path.name} 解析出订单号") if not order["operations"]: raise ValueError(f"{path.name} 无工艺工序明细，无法排产") if not order["dueDate"]: order["dueDate"] = order["planStart"] or datetime.now().strftime("%Y-%m-%d") if not order["productName"]: order["productName"] = order["productCode"] or order["orderNo"] return order def parse_orders_workbook(path: Path) -> list[dict[str, Any]]: """解析源表「订单.xlsx」。""" import openpyxl wb = openpyxl.load_workbook(path, data_only=True) ws = wb[wb.sheetnames[0]] rows = list(ws.iter_rows(values_only=True)) wb.close() if not rows: return [] headers = [_clean(c) for c in rows[0]] col = {h: i for i, h in enumerate(headers) if h} out = [] for row in rows[1:]: def g(*names): for n in names: if n in col and col[n] < len(row): return row[col[n]] return None ono = _clean(g("生产订单", "订单号", "订单代码")) if not ono: continue out.append({ "orderNo": ono, "wbs": _clean(g("WBS号", "WBS")), "productCode": _clean(g("料号", "产品料号")), "productName": _clean(g("物料名称", "产品名称")), "drawingNo": _clean(g("图号")), "planStart": _parse_dt_date(g("计划开始时间", "计划开始")), "dueDate": _parse_dt_date(g("计划结束时间", "计划结束", "交期")), "quantity": _num(g("订单数量", "数量"), 1.0) or 1.0, "status": "RELEASED", }) return out def _routing_sheet_sort_key(name: str) -> tuple[int, int | str]: match = re.fullmatch(r"Sheet(\d+)", name, re.IGNORECASE) return (1, int(match.group(1))) if match else (0, name) def _read_routing_operations( worksheet: Any, infer_map: dict[str, float] | None, std_times: dict[str, float] | None, ) -> list[dict[str, Any]]: rows = list(worksheet.iter_rows(values_only=True)) if not rows: return [] headers = [_clean(c) for c in rows[0]] col = {h: i for i, h in enumerate(headers) if h} if "工序编号" not in col: return [] ops: list[dict[str, Any]] = [] std_times = std_times or {} for row in rows[1:]: code = _clean(_cell(row, col, "工序编号")) if not code: continue op_type = _clean(_cell(row, col, "工序类型", "类型")) raw_std = _cell(row, col, "标准工时") if code in std_times: std_min = float(std_times[code]) inferred = False std_source = "工时表" else: std_min, inferred = _infer_std_min(op_type, raw_std, infer_map) std_source = "推断" if inferred else "实测" ops.append({ "seq": _sequence( _cell(row, col, "排序号", "序号"), (len(ops) + 1) * 10, ), "operationCode": code, "operationName": _clean(_cell(row, col, "工序名称")) or code, "opType": op_type, "stdTimePerUnit": std_min, "stdTimeInferred": inferred, "stdTimeSource": std_source, "resourceGroup": "", "requireMold": False, }) return ops def _operation_signature( operations: list[dict[str, Any]], *, full: bool, ) -> tuple[tuple[Any, ...], ...]: ordered = sorted( operations, key=lambda op: (int(op.get("seq") or 0), _clean(op.get("operationCode"))), ) if full: return tuple(( _clean(op.get("operationCode")), int(op.get("seq") or 0), _clean(op.get("operationName")), _clean(op.get("opType")), ) for op in ordered) return tuple(( _clean(op.get("operationCode")), int(op.get("seq") or 0), ) for op in ordered) def parse_routing_sheet( path: Path, order_no: str, infer_map: dict[str, float] | None = None, std_times: dict[str, float] | None = None, *, canonical_operations: list[dict[str, Any]] | None = None, diagnostics: dict[str, Any] | None = None, ) -> list[dict[str, Any]]: """解析 exact sheet；generic sheet 必须由工时表规范工序序列唯一证明。""" import openpyxl path = Path(path) order_no = _clean(order_no) wb = openpyxl.load_workbook(path, read_only=True, data_only=True) try: if order_no in wb.sheetnames: selected = order_no candidates = [order_no] match_mode = "exact-sheet" ops = _read_routing_operations(wb[selected], infer_map, std_times) if not ops: raise KangniDataMappingError( f"工艺路线 {path.name}/{selected} 未读到工序，订单 {order_no} 拒绝导入" ) else: if not canonical_operations: raise KangniDataMappingError( f"工艺路线缺少订单 sheet {order_no}，且工时表无规范工序序列，拒绝猜测 generic sheet" ) expected = _operation_signature(canonical_operations, full=False) if not expected: raise KangniDataMappingError( f"工时表订单 {order_no} 的规范工序序列为空，拒绝匹配 generic sheet" ) matched: dict[str, list[dict[str, Any]]] = {} for sheet_name in wb.sheetnames: if not re.fullmatch(r"Sheet\d+", sheet_name, re.IGNORECASE): continue sheet_ops = _read_routing_operations(wb[sheet_name], infer_map, std_times) if _operation_signature(sheet_ops, full=False) == expected: matched[sheet_name] = sheet_ops if not matched: raise KangniDataMappingError( f"订单 {order_no} 没有与工时表 code+排序号一致的 generic routing sheet" ) candidates = sorted(matched, key=_routing_sheet_sort_key) contents = { _operation_signature(matched[name], full=True) for name in candidates } if len(contents) != 1: raise KangniDataMappingError( f"订单 {order_no} 匹配多个 generic routing sheet {candidates}，但规范工艺内容不一致" ) selected = candidates[0] match_mode = "generic-std-sequence" ops = matched[selected] if diagnostics is not None: diagnostics.update({ "orderNo": order_no, "status": "matched", "matchMode": match_mode, "matchedSheet": selected, "matchedSheetCandidates": candidates, "operationCount": len(ops), "canonicalSource": f"工时.xlsx/{order_no}", }) return ops finally: wb.close() def _bom_row_signature(row: dict[str, Any]) -> tuple[Any, ...]: return ( row["materialCode"], row["materialName"], float(row["quantity"]), row["consumeOp"], bool(row["isKey"]), ) def parse_bom_sheet( path: Path, order_no: str, *, diagnostics: dict[str, Any] | None = None, ) -> list[dict[str, Any]]: """独立扫描全部 BOM sheets，只按结构化工单编号归集，绝不绑定 routing 同名 sheet。""" import openpyxl path = Path(path) order_no = _clean(order_no) wb = openpyxl.load_workbook(path, read_only=True, data_only=True) try: per_sheet: list[tuple[str, list[dict[str, Any]]]] = [] for sheet_name in wb.sheetnames: rows = list(wb[sheet_name].iter_rows(values_only=True)) if not rows: continue headers = [_clean(c) for c in rows[0]] col = {h: i for i, h in enumerate(headers) if h} order_col = next(( col[name] for name in ("工单编号", "生产订单", "订单号", "订单代码") if name in col ), None) is_exact = sheet_name == order_no if order_col is None and not is_exact: continue if is_exact and order_col is not None: foreign_orders = { _clean(row[order_col]) for row in rows[1:] if order_col < len(row) and _clean(row[order_col]) and _clean(_cell(row, col, "物料编号", "物料编码")) and _clean(row[order_col]) != order_no } if foreign_orders: raise KangniDataMappingError( f"BOM exact sheet {sheet_name} 含其它工单 {sorted(foreign_orders)}，订单 {order_no} 拒绝导入" ) parsed: list[dict[str, Any]] = [] for row in rows[1:]: row_order = _clean(row[order_col]) if order_col is not None and order_col < len(row) else "" if order_col is not None and row_order != order_no: continue material = _clean(_cell(row, col, "物料编号", "物料编码")) if not material: continue quantity = _num(_cell(row, col, "单位用量", "用量"), 1.0) parsed.append({ "materialCode": material, "materialName": _clean(_cell(row, col, "物料名称")) or material, "quantity": quantity, "consumeOp": _clean(_cell(row, col, "MES工序编号", "工序编号")), "isKey": quantity >= 1.0, }) if parsed: per_sheet.append((sheet_name, parsed)) matched_sheets = [name for name, _ in per_sheet] if not per_sheet: if diagnostics is not None: diagnostics.update({ "orderNo": order_no, "status": "missing", "matchMode": "structured-order-field", "matchedSheetCandidates": [], "sourceRowCount": 0, "outputRowCount": 0, "deduplicatedRows": 0, }) return [] merged: list[dict[str, Any]] = [] merged_by_identity: dict[tuple[str, str], dict[str, Any]] = {} prior_signatures: set[tuple[Any, ...]] = set() prior_sheets_by_identity: dict[tuple[str, str], set[str]] = {} deduplicated = 0 aggregated = 0 aggregation_groups: dict[tuple[str, str], dict[str, Any]] = {} for sheet_name, sheet_rows in per_sheet: for row in sheet_rows: signature = _bom_row_signature(row) identity = (row["materialCode"], row["consumeOp"]) if signature in prior_signatures: deduplicated += 1 prior_sheets_by_identity.setdefault(identity, set()).add(sheet_name) continue prior_signatures.add(signature) prior = merged_by_identity.get(identity) if prior is not None and prior["materialName"] != row["materialName"]: raise KangniDataMappingError( f"订单 {order_no} 的 BOM 在 {identity} 上物料名称冲突；" f"已见 sheets={sorted(prior_sheets_by_identity.get(identity) or set())}，" f"当前 sheet={sheet_name}" ) if prior is None: projected = deepcopy(row) merged.append(projected) merged_by_identity[identity] = projected aggregation_groups[identity] = { "materialCode": identity[0], "consumeOp": identity[1], "sourceRows": 1, "quantity": float(projected["quantity"]), } else: prior["quantity"] = round( float(prior["quantity"]) + float(row["quantity"]), 9 ) prior["isKey"] = float(prior["quantity"]) >= 1.0 group = aggregation_groups[identity] group["sourceRows"] += 1 group["quantity"] = float(prior["quantity"]) aggregated += 1 prior_sheets_by_identity.setdefault(identity, set()).add(sheet_name) if diagnostics is not None: diagnostics.update({ "orderNo": order_no, "status": "matched", "matchMode": "exact-or-structured-order-field", "matchedSheet": matched_sheets[0], "matchedSheetCandidates": matched_sheets, "sourceRowCount": sum(len(rows) for _, rows in per_sheet), "outputRowCount": len(merged), "deduplicatedRows": deduplicated, "aggregatedRows": aggregated, "aggregationGroups": [ aggregation_groups[key] for key in sorted(aggregation_groups) if aggregation_groups[key]["sourceRows"] > 1 ], }) return merged finally: wb.close() def _collect_kangni_packages( primary: dict[str, Any], route_path: Path, data_dir: Path, infer_map: dict[str, float] | None, std_time_map: dict[str, dict[str, float]], std_route_map: dict[str, list[dict[str, Any]]], ) -> tuple[list[dict[str, Any]], dict[str, Any]]: """按订单表收集主单和兄弟单，并返回逐单 routing/BOM 映射证据。""" packages = [primary] routing_mappings: dict[str, dict[str, Any]] = { primary["orderNo"]: { "orderNo": primary["orderNo"], "status": "matched", "matchMode": "complete-route", "matchedSheet": route_path.name, "matchedSheetCandidates": [route_path.name], "operationCount": len(primary.get("operations") or []), "canonicalSource": f"工时.xlsx/{primary['orderNo']}", }, } bom_mappings: dict[str, dict[str, Any]] = {} orders_xlsx = _find_file(data_dir, "orders") routing_xlsx = _find_file(data_dir, "routing") bom_xlsx = _find_file(data_dir, "bom") if not orders_xlsx: return packages, { "routing": routing_mappings, "bom": bom_mappings, "sourceFiles": {}, } source_orders = parse_orders_workbook(orders_xlsx) order_numbers = [order["orderNo"] for order in source_orders] duplicates = sorted({order_no for order_no in order_numbers if order_numbers.count(order_no) > 1}) if duplicates: raise KangniDataMappingError(f"订单表存在重复工单编号 {duplicates}，拒绝导入") primary_seen = False for order in source_orders: order_no = order["orderNo"] bom_diag: dict[str, Any] = {} bom = parse_bom_sheet(bom_xlsx, order_no, diagnostics=bom_diag) if bom_xlsx else [] if not bom_xlsx: bom_diag = { "orderNo": order_no, "status": "missing", "matchedSheetCandidates": [], "sourceRowCount": 0, "outputRowCount": 0, "deduplicatedRows": 0, } bom_mappings[order_no] = bom_diag if order_no == primary["orderNo"]: primary_seen = True for key in ("wbs", "productCode", "productName", "drawingNo", "planStart", "dueDate", "quantity"): if order.get(key) and not primary.get(key): primary[key] = order[key] if bom: primary["bom"] = bom continue if not routing_xlsx: raise KangniDataMappingError( f"订单 {order_no} 需要兄弟单工艺，但数据目录缺少工艺路线.xlsx" ) route_diag: dict[str, Any] = {} operations = parse_routing_sheet( routing_xlsx, order_no, infer_map, std_times=std_time_map.get(order_no) or {}, canonical_operations=std_route_map.get(order_no), diagnostics=route_diag, ) routing_mappings[order_no] = route_diag packages.append({ **order, "kitStatus": "未知", "operations": operations, "bom": bom, "source": orders_xlsx.name, "routingSource": routing_xlsx.name, }) if not primary_seen: bom_diag = {} bom = parse_bom_sheet(bom_xlsx, primary["orderNo"], diagnostics=bom_diag) if bom_xlsx else [] if bom: primary["bom"] = bom bom_mappings[primary["orderNo"]] = bom_diag or { "orderNo": primary["orderNo"], "status": "missing", "matchedSheetCandidates": [], "sourceRowCount": 0, "outputRowCount": 0, "deduplicatedRows": 0, } return packages, { "routing": routing_mappings, "bom": bom_mappings, "sourceFiles": { "orders": str(orders_xlsx), "routing": str(routing_xlsx) if routing_xlsx else "", "bom": str(bom_xlsx) if bom_xlsx else "", }, } def _build_flex_bundle_from_packages( packages: list[dict[str, Any]], source_path: str | Path, data_dir: str | Path, *, station_count: int = _DEFAULT_STATION_COUNT, profile: dict[str, Any], mapping_evidence: dict[str, Any], source_mode: str, ) -> dict[str, Any]: """从已验证订单包构建 flex*，供完整路线和 data-dir-only 两种入口复用。""" if not packages: raise KangniDataMappingError("无订单包可构建 flex payload") prof = profile primary = packages[0] route_path = Path(source_path) data_dir = Path(data_dir) inferences: list[str] = [] routing_record_count = sum(len(pkg.get("operations") or []) for pkg in packages) bom_source_row_count = sum( int(mapping.get("sourceRowCount") or 0) for mapping in (mapping_evidence.get("bom") or {}).values() ) if not bom_source_row_count: bom_source_row_count = sum(len(pkg.get("bom") or []) for pkg in packages) std_time_source_counts: dict[str, int] = {} for package in packages: for operation in package.get("operations") or []: source = operation.get("stdTimeSource") or ( "推断" if operation.get("stdTimeInferred") else "实测" ) std_time_source_counts[source] = std_time_source_counts.get(source, 0) + 1 used_std_ops = sum( 1 for pkg in packages for op in pkg["operations"] if op.get("stdTimeSource") == "工时表" ) if used_std_ops: inferences.append(f"{used_std_ops} 个工序标准工时来自 工时.xlsx（分钟/件）") for order_no, bom_mapping in (mapping_evidence.get("bom") or {}).items(): if bom_mapping.get("status") == "missing": inferences.append(f"订单 {order_no} 未匹配 BOM 源行，已保留为空并等待现场确认") aggregated_bom_rows = sum( int(mapping.get("aggregatedRows") or 0) for mapping in (mapping_evidence.get("bom") or {}).values() ) deduplicated_bom_rows = sum( int(mapping.get("deduplicatedRows") or 0) for mapping in (mapping_evidence.get("bom") or {}).values() ) if aggregated_bom_rows or deduplicated_bom_rows: inferences.append( f"BOM 多行用量按订单+物料+消耗工序显式汇总：" f"求和 {aggregated_bom_rows} 行，完全重复去重 {deduplicated_bom_rows} 行" ) generic_mappings = [ mapping for mapping in (mapping_evidence.get("routing") or {}).values() if mapping.get("matchMode") == "generic-std-sequence" ] if generic_mappings: reused = sum( 1 for mapping in generic_mappings if len(mapping.get("matchedSheetCandidates") or []) > 1 ) inferences.append( f"{len(generic_mappings)} 个订单通过工时表规范序列匹配 generic routing sheet" f"（{reused} 个订单复用内容完全相同的多候选）" ) chg_map = prof.get("changeoverMin") or {"部装": 15, "_default": 10} ops_map: dict[str, dict] = {} for pkg in packages: for op in pkg["operations"]: code = op["operationCode"] if code not in ops_map: chg = chg_map.get("_default", 10) for key, mins in chg_map.items(): if key != "_default" and key in (op.get("opType") or ""): chg = mins break ops_map[code] = { "code": code, "name": op["operationName"], "isBottleneck": False, "changeoverMin": chg, } if op.get("stdTimeInferred"): inferences.append( f"工序 {code} 标准工时源表待维护 → 推断 {op['stdTimePerUnit']} 分钟/件" f"（类型={op.get('opType') or '默认'}）" ) # 部装标瓶颈（首道/部装类） for code, op in ops_map.items(): if "部装" in op["name"] or code.endswith("Z1M") and "部装" in op["name"]: op["isBottleneck"] = True if not any(o["isBottleneck"] for o in ops_map.values()) and packages: first = packages[0]["operations"][0]["operationCode"] ops_map[first]["isBottleneck"] = True inferences.append(f"未标注瓶颈 → 将首道工序 {first} 标为瓶颈") all_op_codes = list(ops_map.keys()) inferences.append( f"导入对账：{len(packages)} 个订单 / {routing_record_count} 条工序记录 / " f"{len(all_op_codes)} 个工序种 / {bom_source_row_count} 条 BOM 源行" ) zone_cfg = prof.get("zone") or {} zone = {"code": zone_cfg.get("code") or "ZONE-CG", "name": zone_cfg.get("name") or "城轨机构装配区"} op_std: dict[str, float] = {} for pkg in packages: for op in pkg["operations"]: op_std.setdefault(op["operationCode"], op["stdTimePerUnit"]) equipment, molds, mold_ops, res_inferences = build_flex_equipment_and_molds( data_dir, packages, op_std, all_op_codes, prof, ) inferences.extend(res_inferences) equipment_without_capability = sum(1 for row in equipment if not row.get("capabilities")) shared_placeholder = any(row.get("code") == "EQ-SHARED-CG-01" for row in equipment) molds_without_operation = sum(1 for row in molds if not row.get("operationCode")) molds_without_equipment = sum(1 for row in molds if not row.get("adaptableEquipment")) molds_without_life = sum(1 for row in molds if float(row.get("lifeTotal") or 0.0) <= 0) if equipment_without_capability: placeholder_note = "；EQ-SHARED-CG-01 仅为共享占位" if shared_placeholder else "" inferences.append( f"资源缺口：{len(equipment)} 台设备中 {equipment_without_capability} 台未维护可执行工序" f"{placeholder_note}，不代表生产能力已确认" ) if molds and (molds_without_operation or molds_without_equipment or molds_without_life): inferences.append( f"资源缺口：{len(molds)} 套模具中，缺适用工序 {molds_without_operation} 套、" f"缺适配设备 {molds_without_equipment} 套、缺寿命上限 {molds_without_life} 套；" "模具映射未达到生产就绪" ) resource_quality = { "equipmentCount": len(equipment), "equipmentWithoutCapability": equipment_without_capability, "sharedPlaceholder": shared_placeholder, "moldCount": len(molds), "moldsWithoutOperation": molds_without_operation, "moldsWithoutEquipment": molds_without_equipment, "moldsWithoutLifeTotal": molds_without_life, "productionReady": bool(equipment) and equipment_without_capability == 0 and molds_without_operation == 0 and molds_without_equipment == 0 and molds_without_life == 0, } materials: dict[str, dict] = {} material_source_orders: dict[str, set[str]] = {} bom_rows: list[dict] = [] routings: list[dict] = [] orders: list[dict] = [] for pkg in packages: pc = pkg["productCode"] or f"P-{pkg['orderNo']}" pn = pkg.get("productName") or pc existing_product = materials.get(pc) if existing_product and _clean(existing_product.get("name")) != _clean(pn): raise KangniDataMappingError( f"物料编码 {pc} 名称冲突；已有={existing_product.get('name')} " f"orders={sorted(material_source_orders.get(pc) or set())}，" f"当前={pn} order={pkg['orderNo']}" ) if not existing_product: materials[pc] = { "code": pc, "name": pn, "type": "FINISHED_PRODUCT", "unit": "套", "stock": 0, "inTransit": 0, "safetyStock": 0, "procurementLeadTime": 0, "drawingNo": pkg.get("drawingNo") or "", } material_source_orders.setdefault(pc, set()).add(pkg["orderNo"]) for op in sorted(pkg["operations"], key=lambda x: x["seq"]): routings.append({ "productCode": pc, "productName": pn, "seq": op["seq"], "operationCode": op["operationCode"], "requireMold": op["operationCode"] in mold_ops, "stdTimePerUnit": op["stdTimePerUnit"], "stdTimeSource": op.get("stdTimeSource") or ("推断" if op.get("stdTimeInferred") else "实测"), }) kit_ready = "已完成" in (pkg.get("kitStatus") or "") for b in pkg["bom"]: mc = b["materialCode"] need = float(b["quantity"]) * float(pkg["quantity"]) stock = max(need * 5.0, need + 10.0) if kit_ready else max(need * 2.0, 10.0) material_name = b["materialName"] existing_material = materials.get(mc) if existing_material and _clean(existing_material.get("name")) != _clean(material_name): raise KangniDataMappingError( f"物料编码 {mc} 名称冲突；已有={existing_material.get('name')} " f"orders={sorted(material_source_orders.get(mc) or set())}，" f"当前={material_name} order={pkg['orderNo']}" ) if mc not in materials: materials[mc] = { "code": mc, "name": material_name, "type": "RAW_MATERIAL", "unit": "件", "stock": stock, "inTransit": 0, "safetyStock": max(1.0, need * 0.1), "procurementLeadTime": 7, } else: materials[mc]["stock"] = max(float(materials[mc].get("stock") or 0), stock) material_source_orders.setdefault(mc, set()).add(pkg["orderNo"]) consume = b.get("consumeOp") or (pkg["operations"][0]["operationCode"] if pkg["operations"] else "") bom_rows.append({ "productCode": pc, "materialCode": mc, "quantity": float(b["quantity"]), "consumeOp": consume, "isKey": bool(b.get("isKey")), "_orderNo": pkg["orderNo"], }) if kit_ready: inferences.append(f"订单 {pkg['orderNo']} 备料状态=已完成 → 原料库存按齐套放大") orders.append({ "orderNo": pkg["orderNo"], "productCode": pc, "quantity": int(pkg["quantity"]) if float(pkg["quantity"]).is_integer() else float(pkg["quantity"]), "dueDate": pkg["dueDate"], "priority": 1 if pkg["orderNo"] == primary["orderNo"] else 2, "wbs": pkg.get("wbs") or "", "productionController": "现场导入", "status": pkg.get("status") or "RELEASED", "project": pkg.get("project") or "", "sourceFile": pkg.get("source") or "", "kitStatus": pkg.get("kitStatus") or "", "requiredSkillLevel": (prof.get("team") or {}).get("skillLevel") or "L3", }) # 产品 BOM 保留消耗工序维度；同一投影键跨订单不一致时失败关闭。 seen_bom: dict[tuple[str, str, str], dict[str, Any]] = {} uniq_bom: list[dict[str, Any]] = [] for b in bom_rows: key = (b["productCode"], b["materialCode"], b["consumeOp"]) signature = (float(b["quantity"]), bool(b["isKey"])) prior = seen_bom.get(key) if prior is not None: if signature != prior["signature"]: raise KangniDataMappingError( f"flex BOM 投影冲突 productCode={key[0]} materialCode={key[1]} " f"consumeOp={key[2]}；" f"已有={prior['signature']} orders={sorted(prior['orders'])}，" f"当前={signature} order={b['_orderNo']}" ) prior["orders"].add(b["_orderNo"]) continue seen_bom[key] = {"signature": signature, "orders": {b["_orderNo"]}} uniq_bom.append({key_name: value for key_name, value in b.items() if key_name != "_orderNo"}) team_cfg = prof.get("team") or {} teams = [{ "code": team_cfg.get("code") or "T-CG-ASSY", "name": team_cfg.get("name") or "城轨机构装配班组", "memberCount": max(station_count, 4), "supportOps": list(all_op_codes), "skillLevel": team_cfg.get("skillLevel") or "L3", }] cal_cfg = prof.get("calendar") or {} calendar = [{ "shiftCode": cal_cfg.get("shiftCode") or "D", "startTime": cal_cfg.get("startTime") or "08:00", "endTime": cal_cfg.get("endTime") or "17:00", "breaks": cal_cfg.get("breaks") or [{"start": "12:00", "end": "13:00"}], "workdays": cal_cfg.get("workdays") or [1, 2, 3, 4, 5], }] # 去重推断文案 uniq_inf = [] for line in inferences: if line not in uniq_inf: uniq_inf.append(line) params = { "sortMode": "BOTTLENECK", "beforeDays": 0, "afterDays": 30, "rollingWindows": {"realtime": "60m", "long": "7d", "mid": "2d", "short": "2h"}, "mrpControllerDays": 3, "weights": {"tardiness": 0.4, "cost": 0.3, "utilization": 0.2, "balance": 0.1}, "siteProfile": source_mode, "siteSource": str(route_path), "siteInferences": uniq_inf, "demoDataCleared": True, } return { "flexZones": [zone], "flexOperations": list(ops_map.values()), "flexEquipment": equipment, "flexMolds": molds, "flexMaterials": list(materials.values()), "flexBom": uniq_bom, "flexRoutings": routings, "flexTeams": teams, "flexCalendar": calendar, "flexOrders": orders, "flexParams": params, "flexScheduleVersions": [], "flexVirtualLines": [], "flexWorkOrders": [], "flexConflicts": [], "_meta": { "orderCount": len(orders), "operationCount": len(ops_map), "routingRecordCount": routing_record_count, "bomCount": len(uniq_bom), "bomSourceRowCount": bom_source_row_count, "stdTimeSourceCounts": std_time_source_counts, "routingMappings": mapping_evidence.get("routing") or {}, "bomMappings": mapping_evidence.get("bom") or {}, "missingBomOrders": [ order_no for order_no, mapping in (mapping_evidence.get("bom") or {}).items() if mapping.get("status") == "missing" ], "resourceQuality": resource_quality, "inferences": uniq_inf, "primaryOrder": primary["orderNo"], "source": str(route_path), }, } def build_flex_bundle( route_path: str | Path | None = None, data_dir: str | Path | None = None, *, include_sibling_orders: bool = True, station_count: int = _DEFAULT_STATION_COUNT, profile: dict[str, Any] | None = None, ) -> dict[str, Any]: """构建可写入 world 的 flex* 包 + 推断说明。""" prof = profile if profile is not None else _P infer_map = prof.get("inferStdMin") or None route_path = Path(route_path) if route_path else DEFAULT_ROUTE_XLSX data_dir = Path(data_dir) if data_dir else DEFAULT_DATA_DIR std_time_map = load_std_time_map(data_dir) std_route_map = load_std_route_map(data_dir) primary = parse_complete_route_xlsx(route_path, infer_map) _apply_std_time_map(primary, std_time_map, override_existing=True) packages = [primary] mapping_evidence: dict[str, Any] = { "routing": { primary["orderNo"]: { "orderNo": primary["orderNo"], "status": "matched", "matchMode": "complete-route", "matchedSheet": route_path.name, "matchedSheetCandidates": [route_path.name], "operationCount": len(primary.get("operations") or []), "canonicalSource": f"工时.xlsx/{primary['orderNo']}", }, }, "bom": { primary["orderNo"]: { "orderNo": primary["orderNo"], "status": "matched" if primary.get("bom") else "missing", "matchMode": "complete-route", "matchedSheet": route_path.name if primary.get("bom") else "", "matchedSheetCandidates": [route_path.name] if primary.get("bom") else [], "sourceRowCount": len(primary.get("bom") or []), "outputRowCount": len(primary.get("bom") or []), "deduplicatedRows": 0, }, }, "sourceFiles": {}, } if include_sibling_orders and data_dir.exists(): packages, mapping_evidence = _collect_kangni_packages( primary, route_path, data_dir, infer_map, std_time_map, std_route_map, ) return _build_flex_bundle_from_packages( packages, route_path, data_dir, station_count=station_count, profile=prof, mapping_evidence=mapping_evidence, source_mode="complete-route", ) def _collect_kangni_packages_from_data_dir( data_dir: Path, infer_map: dict[str, float] | None, std_time_map: dict[str, dict[str, float]], std_route_map: dict[str, list[dict[str, Any]]], ) -> tuple[list[dict[str, Any]], dict[str, Any]]: """仅从标准工作簿收集全部订单包；任何路线/BOM不确定性均失败关闭。""" orders_xlsx = _find_file(data_dir, "orders") routing_xlsx = _find_file(data_dir, "routing") stdtime_xlsx = _find_file(data_dir, "stdtime") bom_xlsx = _find_file(data_dir, "bom") missing = [ name for name, path in ( ("订单.xlsx", orders_xlsx), ("工艺路线.xlsx", routing_xlsx), ("工时.xlsx", stdtime_xlsx), ("BOM.xlsx", bom_xlsx), ) if not path ] if missing: raise KangniDataMappingError(f"data-dir-only 缺少核心工作簿：{missing}") source_orders = parse_orders_workbook(orders_xlsx) if not source_orders: raise KangniDataMappingError("订单.xlsx 未读到生产订单") order_numbers = [order["orderNo"] for order in source_orders] duplicates = sorted({order_no for order_no in order_numbers if order_numbers.count(order_no) > 1}) if duplicates: raise KangniDataMappingError(f"订单表存在重复工单编号 {duplicates}，拒绝导入") packages: list[dict[str, Any]] = [] routing_mappings: dict[str, dict[str, Any]] = {} bom_mappings: dict[str, dict[str, Any]] = {} for order in source_orders: order_no = order["orderNo"] canonical_operations = std_route_map.get(order_no) std_times = std_time_map.get(order_no) if not canonical_operations or not std_times: raise KangniDataMappingError( f"工时.xlsx 缺少订单 {order_no} 的规范工序序列或分钟值" ) route_diag: dict[str, Any] = {} operations = parse_routing_sheet( routing_xlsx, order_no, infer_map, std_times=std_times, canonical_operations=canonical_operations, diagnostics=route_diag, ) if _operation_signature(operations, full=False) != _operation_signature( canonical_operations, full=False, ): raise KangniDataMappingError( f"订单 {order_no} 的 routing 与工时表规范工序序列不一致" ) non_table_sources = [ operation["operationCode"] for operation in operations if operation.get("stdTimeSource") != "工时表" ] if non_table_sources: raise KangniDataMappingError( f"订单 {order_no} 存在未由工时表提供分钟值的工序 {non_table_sources}" ) bom_diag: dict[str, Any] = {} bom = parse_bom_sheet(bom_xlsx, order_no, diagnostics=bom_diag) if not bom or bom_diag.get("status") != "matched": raise KangniDataMappingError(f"订单 {order_no} 未唯一匹配结构化 BOM") routing_mappings[order_no] = route_diag bom_mappings[order_no] = bom_diag packages.append({ **order, "kitStatus": "未知", "operations": operations, "bom": bom, "source": str(orders_xlsx), "routingSource": str(routing_xlsx), }) return packages, { "routing": routing_mappings, "bom": bom_mappings, "sourceFiles": { "orders": orders_xlsx.name, "routing": routing_xlsx.name, "stdtime": stdtime_xlsx.name, "bom": bom_xlsx.name, "workbooks": [path.name for path in sorted(data_dir.glob("*.xlsx"))], }, } def _canonicalize_payload_source_refs(value: Any) -> Any: """移除 payload 中的机器/临时目录绝对路径，仅保留稳定逻辑文件名。""" if isinstance(value, dict): return {key: _canonicalize_payload_source_refs(item) for key, item in value.items()} if isinstance(value, list): return [_canonicalize_payload_source_refs(item) for item in value] if isinstance(value, tuple): return [_canonicalize_payload_source_refs(item) for item in value] if isinstance(value, Path): return value.name if isinstance(value, str): candidate = Path(value) if candidate.is_absolute(): return candidate.name return value def build_site_payload_from_data_dir( data_dir: str | Path, *, station_count: int = _DEFAULT_STATION_COUNT, profile: dict[str, Any] | None = None, ) -> dict[str, Any]: """仅凭标准工作簿构建 fixed+flex+meta 纯 JSON payload，不依赖完整路线文件。""" data_dir = Path(data_dir) if not data_dir.is_dir(): raise KangniDataMappingError(f"康尼数据目录不存在：{data_dir}") prof = profile if profile is not None else _P infer_map = prof.get("inferStdMin") or None std_time_map = load_std_time_map(data_dir) std_route_map = load_std_route_map(data_dir) packages, mapping_evidence = _collect_kangni_packages_from_data_dir( data_dir, infer_map, std_time_map, std_route_map, ) fixed = build_fixed_master(packages, station_count=station_count, profile=prof) source_path = mapping_evidence["sourceFiles"]["orders"] flex_bundle = _build_flex_bundle_from_packages( packages, source_path, data_dir, station_count=station_count, profile=prof, mapping_evidence=mapping_evidence, source_mode="data-dir-only", ) meta = flex_bundle.pop("_meta") meta.update({ "payloadSchemaVersion": 1, "sourceMode": "data-dir-only", "sourceWorkbookCount": len(mapping_evidence["sourceFiles"]["workbooks"]), "sourceFiles": deepcopy(mapping_evidence["sourceFiles"]), "fixedSalesOrderCount": len(fixed.get("salesOrders") or []), "fixedRoutingRecordCount": len(fixed.get("routingSteps") or []), "projectedBomCount": len(flex_bundle.get("flexBom") or []), }) return _canonicalize_payload_source_refs({"fixed": fixed, "flex": flex_bundle, "meta": meta}) def build_fixed_master( packages: list[dict[str, Any]], *, station_count: int = _DEFAULT_STATION_COUNT, profile: dict[str, Any] | None = None, ) -> dict[str, Any]: """把现场订单包映射到主数据页/订单池读取的固定轨表（materials/operations/salesOrders…）。""" from server.timeutil import add_minutes, fmt_date, today0 if not packages: raise ValueError("无订单包可写入主数据") primary = packages[0] prof = profile if profile is not None else _P f_cfg = prof.get("factory") or {} w_cfg = prof.get("workshop") or {} l_cfg = prof.get("line") or {} ws_prefix = prof.get("stationCodePrefix") or "WS-CG-" ws_name = prof.get("stationNamePrefix") or "城轨机构装配工位" eq_prefix = prof.get("equipmentCodePrefix") or "EQ-CG-" avail = float(prof.get("availabilityRate") or 0.95) setup_cfg = prof.get("setupMin") or {"first": 15.0, "rest": 10.0} lead_days = int(prof.get("rawMaterialLeadTimeDays") or 7) family = prof.get("productFamily") or "CG-ASSY" factories = [{ "id": 1, "code": f_cfg.get("code") or "CG-F01", "name": f_cfg.get("name") or "城轨机构装配工厂", "timezone": f_cfg.get("timezone") or "Asia/Shanghai", "address": "现场导入", "status": "ACTIVE", }] workshops = [{ "id": 1, "factoryId": 1, "code": w_cfg.get("code") or "CG-WS01", "name": w_cfg.get("name") or "城轨机构装配车间", "status": "ACTIVE", }] lines = [{ "id": 1, "workshopId": 1, "code": l_cfg.get("code") or "CG-L01", "name": l_cfg.get("name") or "城轨机构装配线", "capacityPerDay": max(4, station_count), "taktTime": float(l_cfg.get("taktTime") or 30.0), "efficiencyFactor": float(l_cfg.get("efficiencyFactor") or 0.95), "status": "ACTIVE", "alternativeLineIds": [], }] workstations = [] equipment = [] for i in range(station_count): wsid = i + 1 code = f"{ws_prefix}{i + 1:02d}" workstations.append({ "id": wsid, "lineId": 1, "code": code, "name": f"{ws_name}#{i + 1}", "sequenceNo": i + 1, "status": "ACTIVE", }) equipment.append({ "id": wsid, "code": f"{eq_prefix}{i + 1:02d}", "name": f"装配工位设备#{i + 1}", "model": "SITE-ASSY", "workstationId": wsid, "capacityPerHour": 2, "efficiencyFactor": 0.95, "availabilityRate": avail, "status": "RUNNING", }) # 工序库（全订单并集） ops_map: dict[str, dict] = {} for pkg in packages: for op in pkg["operations"]: code = op["operationCode"] if code not in ops_map: ops_map[code] = { "code": code, "name": op["operationName"], "type": "INTERNAL", "standardTime": float(op["stdTimePerUnit"]), "seq": op["seq"], } operations = [] for i, (_code, op) in enumerate(sorted(ops_map.items(), key=lambda x: x[1]["seq"])): operations.append({ "id": i + 1, "code": op["code"], "name": op["name"], "type": op["type"], "standardTime": op["standardTime"], }) op_id_by_code = {o["code"]: o["id"] for o in operations} materials: list[dict] = [] mat_id_by_code: dict[str, int] = {} boms: list[dict] = [] bom_items: list[dict] = [] routings: list[dict] = [] routing_steps: list[dict] = [] line_products: list[dict] = [] sales_orders: list[dict] = [] mid = 1 bom_id = 1 rid = 1 step_id = 1 item_id = 1 lp_id = 1 for pkg in packages: pc = pkg["productCode"] or f"P-{pkg['orderNo']}" pn = pkg.get("productName") or pc if pc not in mat_id_by_code: materials.append({ "id": mid, "code": pc, "name": pn, "spec": pkg.get("drawingNo") or "", "type": "FINISHED_PRODUCT", "unit": "套", "productFamily": family, "safetyStock": 0, "procurementLeadTime": 0, "stock": 0, "inTransit": 0, "status": "ACTIVE", }) mat_id_by_code[pc] = mid mid += 1 product_id = mat_id_by_code[pc] kit_ready = "已完成" in (pkg.get("kitStatus") or "") for b in pkg["bom"]: mc = b["materialCode"] need = float(b["quantity"]) * float(pkg["quantity"]) stock = max(need * 5.0, need + 10.0) if kit_ready else max(need * 2.0, 10.0) if mc not in mat_id_by_code: materials.append({ "id": mid, "code": mc, "name": b["materialName"], "spec": "", "type": "RAW_MATERIAL", "unit": "件", "productFamily": "", "safetyStock": max(1.0, need * 0.1), "procurementLeadTime": lead_days, "stock": stock, "inTransit": 0, "status": "ACTIVE", }) mat_id_by_code[mc] = mid mid += 1 else: # 同物料库存取较大 mrow = next(m for m in materials if m["id"] == mat_id_by_code[mc]) mrow["stock"] = max(float(mrow.get("stock") or 0), stock) # BOM 头 + 明细（每产品一版） boms.append({ "id": bom_id, "productId": product_id, "version": "V1.0", "versionName": f"{pn} BOM（现场）", "isDefault": True, "status": "ACTIVE", }) for b in pkg["bom"]: consume = b.get("consumeOp") or "" oid = op_id_by_code.get(consume) or (operations[0]["id"] if operations else None) bom_items.append({ "id": item_id, "bomId": bom_id, "materialId": mat_id_by_code[b["materialCode"]], "quantity": float(b["quantity"]), "operationId": oid, "isKeyMaterial": bool(b.get("isKey")), }) item_id += 1 bom_id += 1 # 工艺路线 routings.append({ "id": rid, "productId": product_id, "version": "V1.0", "versionName": f"{pn} 工艺（现场）", "isDefault": True, "status": "ACTIVE", }) prev_step = None for seq_i, op in enumerate(sorted(pkg["operations"], key=lambda x: x["seq"]), start=1): oid = op_id_by_code[op["operationCode"]] routing_steps.append({ "id": step_id, "routingId": rid, "operationId": oid, "sequenceNo": seq_i, "prevStepId": prev_step, "setupTime": float(setup_cfg.get("first", 15.0)) if seq_i == 1 else float(setup_cfg.get("rest", 10.0)), "runTimePerUnit": float(op["stdTimePerUnit"]), "waitTime": 0, "transferTime": 0, "isExternal": False, "stdTimeSource": op.get("stdTimeSource") or ( "推断" if op.get("stdTimeInferred") else "实测" ), }) prev_step = step_id step_id += 1 rid += 1 line_products.append({ "id": lp_id, "lineId": 1, "productId": product_id, "standardCapacity": max(4, station_count), "priority": 1, "setupTime": 30, }) lp_id += 1 due = pkg.get("dueDate") or fmt_date(add_minutes(today0(), 14 * 24 * 60)) order_date = pkg.get("planStart") or fmt_date(today0()) so_id = len(sales_orders) + 1 sales_orders.append({ "id": so_id, "orderNo": str(pkg["orderNo"]), "customerId": "SITE-001", "customerName": pkg.get("project") or "现场生产订单", "customerLevel": "A", "orderDate": order_date, "deliveryDate": due, "priority": 1 if pkg is primary or pkg.get("orderNo") == primary["orderNo"] else 2, "manualPriority": None, "status": "APPROVED", "source": "SITE_XLSX", "specialRequirements": f"WBS={pkg.get('wbs') or ''}", "totalAmount": 0, "isRush": False, "rushStrategy": None, "kitStatus": pkg.get("kitStatus") or "", "requiredSkillLevel": (prof.get("team") or {}).get("skillLevel") or "L3", "changes": [], "createdBy": "site-import", "createdAt": order_date + " 08:00", "updatedAt": order_date + " 08:00", "wbs": pkg.get("wbs") or "", "items": [{ "id": so_id * 10 + 1, "orderId": so_id, "lineNo": 1, "productId": product_id, "productName": pn, "productCode": pc, "quantity": int(pkg["quantity"]) if float(pkg["quantity"]).is_integer() else float(pkg["quantity"]), "unit": "套", "bomVersion": "V1.0", "routingVersion": "V1.0", "deliveryDate": due, "status": "OPEN", }], }) # 工位可执行全部工序 wso = [] wid = 1 for ws in workstations: for op in operations: wso.append({ "id": wid, "workstationId": ws["id"], "operationId": op["id"], "setupTime": 10, "runTimePerUnit": op["standardTime"], "isPrimary": True, }) wid += 1 team_cfg = prof.get("team") or {} teams = [{ "id": 1, "code": team_cfg.get("code") or "T-CG-ASSY", "name": team_cfg.get("name") or "城轨机构装配班组", "workshopId": 1, "memberCount": max(station_count, 4), "skillLevel": team_cfg.get("skillLevel") or "L3", "status": "ACTIVE", }] cal_cfg = prof.get("calendar") or {} shifts = [{ "id": 1, "code": cal_cfg.get("shiftCode") or "D", "name": "早班", "startTime": cal_cfg.get("startTime") or "08:00", "endTime": cal_cfg.get("endTime") or "17:00", "breakPeriods": cal_cfg.get("breaks") or [{"start": "12:00", "end": "13:00"}], "isOvertime": False, "status": "ACTIVE", }] base = today0() shift_calendar = [] for i in range(int(prof.get("calendarDays") or 45)): date = add_minutes(base, i * 24 * 60) date_str = fmt_date(date) is_weekend = date.weekday() >= 5 shift_calendar.append({ "id": i + 1, "lineId": 1, "date": date_str, "shiftId": 1, "isWorking": not is_weekend, "teamId": 1, "maxWorkers": max(station_count, 4), }) return { "factories": factories, "workshops": workshops, "lines": lines, "workstations": workstations, "equipment": equipment, "operations": operations, "routings": routings, "routingSteps": routing_steps, "materials": materials, "boms": boms, "bomItems": bom_items, "lineProducts": line_products, "workstationOperations": wso, "teams": teams, "shifts": shifts, "shiftCalendar": shift_calendar, "maintenance": [], "salesOrders": sales_orders, "productionOrders": [], "workOrders": [], "purchaseOrders": [], "outsourceOrders": [], "forecastOrders": [], "changeoverMatrix": [], "scheduleVersions": [], "conflicts": [], "logs": [], } def apply_flex_bundle(world: World, bundle: dict[str, Any], *, replace: bool = True) -> dict[str, Any]: """将 flex 包写入 world；replace=True 时清空演示 flex*。""" if replace: for k in _FLEX_CLEAR_KEYS: world[k] = [] if k != "flexParams" else {} meta = bundle.pop("_meta", {}) # 订单补 id orders = bundle.get("flexOrders") or [] for i, o in enumerate(orders): o["id"] = i + 1 o.setdefault("status", "RELEASED") for k, v in bundle.items(): if k.startswith("_"): continue world[k] = v world.setdefault("flexParams", {})["demoDataCleared"] = True return meta def clear_demo_world(world: World) -> None: """清空固定轨 + 柔性轨演示/残留数据。""" for k in _FIXED_CLEAR_KEYS: world[k] = [] for k in _FLEX_CLEAR_KEYS: world[k] = [] if k != "flexParams" else {} def apply_site_payload_to_world( world: World, payload: dict[str, Any], *, clear_all: bool = True, ) -> dict[str, Any]: """确定性写入 data-dir-only payload；始终深拷贝，绝不变异 payload 输入。""" if not isinstance(payload, dict): raise ValueError("site payload 必须是 dict") fixed = deepcopy(payload.get("fixed")) flex = deepcopy(payload.get("flex")) meta = deepcopy(payload.get("meta")) if not isinstance(fixed, dict) or not isinstance(flex, dict) or not isinstance(meta, dict): raise ValueError("site payload 必须包含 dict 类型的 fixed、flex、meta") if clear_all: clear_demo_world(world) for key, value in fixed.items(): world[key] = value flex_with_meta = {**flex, "_meta": meta} applied_meta = apply_flex_bundle(world, flex_with_meta, replace=False) world.setdefault("flexParams", {})["siteProfile"] = "data-dir-only" world["flexParams"]["fixedMasterSynced"] = True applied_meta["clearedDemo"] = clear_all return applied_meta def load_site_into_world( world: World, *, route_path: str | Path | None = None, data_dir: str | Path | None = None, include_sibling_orders: bool = False, station_count: int = _DEFAULT_STATION_COUNT, clear_all: bool = True, profile: dict[str, Any] | None = None, ) -> dict[str, Any]: """一键：清空演示 → 写入固定轨主数据+订单池 + flex* → 返回摘要。""" prof = profile if profile is not None else _P infer_map = prof.get("inferStdMin") or None route_path = Path(route_path) if route_path else DEFAULT_ROUTE_XLSX data_dir = Path(data_dir) if data_dir else DEFAULT_DATA_DIR std_time_map = load_std_time_map(data_dir) std_route_map = load_std_route_map(data_dir) primary = parse_complete_route_xlsx(route_path, infer_map) _apply_std_time_map(primary, std_time_map, override_existing=True) packages = [primary] if include_sibling_orders and data_dir.exists(): packages, _ = _collect_kangni_packages( primary, route_path, data_dir, infer_map, std_time_map, std_route_map, ) if clear_all: clear_demo_world(world) fixed = build_fixed_master(packages, station_count=station_count, profile=prof) for k, v in fixed.items(): world[k] = v # flex 包：用同一 packages，避免再扫 siblings bundle = build_flex_bundle( route_path, data_dir, include_sibling_orders=False, station_count=station_count, profile=prof, ) # 若带了 siblings，重建 flex 订单集以与 packages 对齐 if len(packages) > 1: bundle = build_flex_bundle( route_path, data_dir, include_sibling_orders=True, station_count=station_count, profile=prof, ) meta = apply_flex_bundle(world, bundle, replace=False) # 已 clear_all meta["fixedMaterials"] = len(world.get("materials") or []) meta["fixedOperations"] = len(world.get("operations") or []) meta["salesOrders"] = len(world.get("salesOrders") or []) meta["clearedDemo"] = clear_all # 工厂名写入审计友好字段 world.setdefault("flexParams", {})["siteProfile"] = "complete-route-full" world["flexParams"]["fixedMasterSynced"] = True return meta def confirmation_for_site_load(meta: dict[str, Any]) -> tuple[str, list[str]]: title = "加载现场完整生产路线（清空演示并写入主数据+订单）" lines = [ f"主订单：{meta.get('primaryOrder')}", f"订单数：{meta.get('orderCount')} · 工序：{meta.get('operationCount')} · BOM：{meta.get('bomCount')}", f"主数据物料：{meta.get('fixedMaterials')} · 工序库：{meta.get('fixedOperations')} · 销售订单：{meta.get('salesOrders')}", f"来源：{meta.get('source')}", "将清空演示工厂全部垃圾数据，写入现场订单/物料/BOM/工艺/产线/柔性资源。", ] for line in (meta.get("inferences") or [])[:6]: lines.append(f"推断：{line}") if len(meta.get("inferences") or []) > 6: lines.append(f"…另有 {len(meta['inferences']) - 6} 条推断说明") return title, lines