# ============================================================ # 工程目录数据包分析（moduleId: domain-folder-pack, 可重生 ✅） # 读取项目 workDir 下 Excel/CSV：表头/行数/样例/角色 → 排产齐备度校验 # ============================================================ from __future__ import annotations import copy import hashlib import json import os import re import tempfile from pathlib import Path from typing import Any from server.aps_domain.importers import preview_file from server.aps_domain.readiness import check_readiness World = dict[str, Any] KIND_CN = { "orders": "订单", "materials": "物料", "bom": "BOM 用料", "routing": "工艺路线/工时", "equipment": "设备", "molds": "模具", "operations": "工序库", "zones": "区域", } _FIELD_CN = { "productCode": "产品/料号", "quantity": "数量", "deliveryDate": "交期", "customerName": "客户/项目", "orderNo": "订单号", "code": "编码", "name": "名称", "operationCode": "工序", "seq": "顺序", "stdTimePerUnit": "工时", "capabilities": "可执行工序", "materialCode": "子件", "unit": "单位", } _NAME_KIND = [ (r"订单|order", "orders"), (r"物料|材料|material", "materials"), (r"^bom|用料|物料清单", "bom"), (r"工艺|路线|routing|工时", "routing"), (r"设备|机器|equipment", "equipment"), (r"模具|mold", "molds"), (r"工序", "operations"), (r"区域|zone", "zones"), ] _REQUIRED = ("orders", "materials", "routing", "equipment") _HELPFUL = ("bom", "molds", "operations") _FOLDER_SOURCE_EXTS = frozenset({".xlsx", ".xlsm", ".csv", ".txt", ".sql"}) _KANGNI_WORKBOOKS = ( "订单.xlsx", "工艺路线.xlsx", "工时.xlsx", "BOM.xlsx", "设备.xlsx", "模具.xlsx", "物料.xlsx", "设备能力映射模板.xlsx", "模具适配映射模板.xlsx", ) # 锐扬 MOM 收集表等现场模板中的非排产块：不导入，其问题行不计为数据错误 _MOM_SKIP_BLOCKS = ( "生产模型", "质检方案", "仓储模型", "人力资源", "客户管理", "供应商管理", "数据说明", "工厂资源", "人员技能", "客户供应商", "在制任务", "排产参数", "插单场景", "数据校验", ) def _is_mom_skip_block(sheet: str | None) -> bool: s = str(sheet or "") return any(b in s for b in _MOM_SKIP_BLOCKS) def _guess_kind_by_name(name: str) -> str | None: stem = re.sub(r"\.(xlsx|xlsm|csv|txt)$", "", name, flags=re.I) for pat, kind in _NAME_KIND: if re.search(pat, stem, re.I): return kind return None def _project_work_dir(session_id: str | None) -> tuple[dict[str, Any] | None, str]: try: from server.state.projects import get_project_store snap = get_project_store().snapshot(include_messages=False) except Exception: return None, "" sessions = {s["id"]: s for s in (snap.get("sessions") or []) if isinstance(s, dict)} projects = {p["id"]: p for p in (snap.get("projects") or []) if isinstance(p, dict)} sess = sessions.get(session_id or "") or {} proj = projects.get(sess.get("projectId") or "") if sess.get("projectId") else None work = (proj.get("workDir") or "").strip() if proj else "" return proj, work def _sample_cells(row: dict[str, Any], limit: int = 5) -> str: parts = [] for k, v in list(row.items())[:limit]: if v is None or v == "": continue parts.append(f"{k}={v}") return "，".join(parts) def _fmt_size(n: int) -> str: if n < 1024: return f"{n} B" if n < 1024 * 1024: return f"{n / 1024:.1f} KB" return f"{n / (1024 * 1024):.1f} MB" def _fmt_field_map(fmap: list[dict[str, str]]) -> str: if not fmap: return "" return "；".join( f"{m.get('source')}→{_FIELD_CN.get(m.get('target') or '', m.get('target'))}" for m in fmap[:6] ) def read_folder_source_snapshots( work_dir: str, ) -> tuple[list[dict[str, Any]], dict[str, bytes]]: """Read each source once; parsing and manifests must share these immutable bytes.""" root = Path(work_dir).expanduser().resolve(strict=True) if not root.is_dir(): raise PermissionError("工程目录不可访问，请重新选择项目目录") manifest: list[dict[str, Any]] = [] snapshots: dict[str, bytes] = {} for child in sorted(root.iterdir(), key=lambda item: item.name.lower()): if child.name.startswith(("~$", ".")) or child.suffix.lower() not in _FOLDER_SOURCE_EXTS: continue resolved = child.resolve(strict=True) try: relative = resolved.relative_to(root) except ValueError as exc: raise PermissionError(f"工程目录源文件越界：{child.name}") from exc if not resolved.is_file(): continue before = resolved.stat() raw = resolved.read_bytes() after = resolved.stat() if (before.st_size, before.st_mtime_ns) != (after.st_size, after.st_mtime_ns): raise PermissionError(f"工程目录源文件正在变化：{child.name}") relative_name = relative.as_posix() snapshots[relative_name] = raw manifest.append({ "name": relative_name, "sizeBytes": len(raw), "sha256": hashlib.sha256(raw).hexdigest(), }) return manifest, snapshots def folder_source_manifest(work_dir: str) -> list[dict[str, Any]]: manifest, _snapshots = read_folder_source_snapshots(work_dir) return manifest def _source_bytes( path: str, name: str, source_snapshots: dict[str, bytes] | None, ) -> bytes: if source_snapshots is not None: if name not in source_snapshots: raise PermissionError(f"工程目录冻结源缺少文件：{name}") return source_snapshots[name] with open(path, "rb") as handle: return handle.read() def _preview_sql_bytes(raw: bytes) -> dict[str, Any]: from server.importers.sql_pack import preview_sql_file fd, temporary = tempfile.mkstemp(suffix=".sql") try: with os.fdopen(fd, "wb") as handle: handle.write(raw) return preview_sql_file(temporary) finally: if os.path.exists(temporary): os.unlink(temporary) def folder_source_manifest_digest(manifest: list[dict[str, Any]]) -> str: payload = json.dumps( manifest, ensure_ascii=True, sort_keys=True, separators=(",", ":"), ).encode("utf-8") return hashlib.sha256(payload).hexdigest() def folder_schedule_world_fingerprint(world: World) -> str: """Normalize one lazy empty context container without hiding real policy changes.""" from server.agent_core.harness import world_fingerprint normalized = copy.deepcopy(world) if normalized.get("contextPolicies") is None: normalized["contextPolicies"] = {} return world_fingerprint(normalized) def _contains_materialized_path(value: Any, root: Path) -> bool: if isinstance(value, dict): return any(_contains_materialized_path(item, root) for item in value.values()) if isinstance(value, list): return any(_contains_materialized_path(item, root) for item in value) if not isinstance(value, str): return False root_text = str(root.resolve()).casefold() return root_text in value.casefold() def _build_kangni_payload_from_snapshots( source_snapshots: dict[str, bytes], ) -> dict[str, Any] | None: """Build the site payload only from the nine immutable uploaded workbook bytes.""" by_name: dict[str, tuple[str, bytes]] = {} for relative_name, raw in source_snapshots.items(): filename = Path(relative_name).name folded = filename.casefold() if folded in by_name: raise PermissionError(f"康尼数据包存在重名工作簿：{filename}") by_name[folded] = (filename, raw) required = {name.casefold(): name for name in _KANGNI_WORKBOOKS} if not all(folded in by_name for folded in required): return None from server.aps_domain.kangni_intake import build_site_payload_from_data_dir with tempfile.TemporaryDirectory(prefix="aps-kangni-folder-") as temporary: materialized = Path(temporary) for folded, stable_name in required.items(): _source_name, raw = by_name[folded] (materialized / stable_name).write_bytes(raw) payload = build_site_payload_from_data_dir(materialized) try: canonical = json.dumps( payload, ensure_ascii=False, sort_keys=True, separators=(",", ":"), allow_nan=False, ) except (TypeError, ValueError) as exc: raise ValueError("康尼冻结载荷不是纯 JSON，拒绝创建确认卡") from exc normalized = json.loads(canonical) if _contains_materialized_path(normalized, materialized): raise ValueError("康尼冻结载荷包含临时目录路径，拒绝创建长期证据") if not isinstance(normalized, dict): raise ValueError("康尼冻结载荷格式无效") fixed = normalized.get("fixed") flex = normalized.get("flex") meta = normalized.get("meta") if not isinstance(fixed, dict) or not isinstance(flex, dict) or not isinstance(meta, dict): raise ValueError("康尼冻结载荷必须包含 fixed、flex、meta") if int(meta.get("payloadSchemaVersion") or 0) != 1: raise ValueError("康尼冻结载荷版本不受支持") if meta.get("sourceMode") != "data-dir-only": raise ValueError("康尼冻结载荷来源模式无效") if int(meta.get("sourceWorkbookCount") or 0) != len(_KANGNI_WORKBOOKS): raise ValueError("康尼冻结载荷未绑定完整 9 份工作簿") return normalized def folder_schedule_payload_digest(params: dict[str, Any]) -> str: projection = { key: value for key, value in params.items() if key != "folderPayloadDigest" } try: payload = json.dumps( projection, ensure_ascii=True, sort_keys=True, separators=(",", ":"), allow_nan=False, ).encode("utf-8") except (TypeError, ValueError) as exc: raise ValueError("工程目录冻结载荷不是纯 JSON") from exc return hashlib.sha256(payload).hexdigest() def _discover_drawing_files(world: World, work: str, project_id: str | None) -> list[dict[str, Any]]: """发现并解析工程目录中的 DXF；失败仅记录，不影响表格齐备度。""" names = sorted( n for n in os.listdir(work) if n.lower().endswith(".dxf") and not n.startswith("~$") and not n.startswith(".") ) reports: list[dict[str, Any]] = [] assets = world.setdefault("drawingAssets", []) candidates_store = world.setdefault("drawingCandidates", []) runs = world.setdefault("drawingParseRuns", []) for name in names: path = os.path.join(work, name) try: from server.aps_domain.drawing_dxf import inspect_dxf, build_drawing_master_candidates parsed = inspect_dxf(path) asset = dict(parsed.get("asset") or {}) asset["projectId"] = project_id asset["status"] = "PARSED" asset["parsedAt"] = parsed.get("parsedAt") asset["parsed"] = parsed change_set = build_drawing_master_candidates(parsed) change_set["drawingAssetId"] = asset.get("id") change_set["projectId"] = project_id assets[:] = [row for row in assets if row.get("id") != asset.get("id")] assets.append(asset) candidates_store[:] = [row for row in candidates_store if row.get("drawingAssetId") != asset.get("id")] candidates_store.append(change_set) runs.append({ "drawingAssetId": asset.get("id"), "projectId": project_id, "sourcePath": path, "status": "SUCCEEDED", "parsedAt": parsed.get("parsedAt"), "entityCount": (parsed.get("drawing") or {}).get("modelspaceEntityCount", 0), }) reports.append({ "id": asset.get("id"), "name": name, "path": path, "kind": "drawing", "kindCn": "DXF 图纸", "status": "ok", "okCount": 0, "errorCount": 0, "required": False, "drawing": parsed.get("drawing") or {}, "candidateCounts": { "materials": len(change_set.get("materials") or []), "bomReferences": len(change_set.get("bomReferences") or []), "routingOperations": len(change_set.get("routingOperations") or []), }, "issue": "图纸已解析为待工程审核候选；不计入排产必备覆盖。", }) except Exception as exc: # noqa: BLE001 - 图纸故障不能阻断表格解析 runs.append({"projectId": project_id, "sourcePath": path, "status": "FAILED", "error": str(exc)}) reports.append({ "name": name, "path": path, "kind": "drawing", "kindCn": "DXF 图纸", "status": "fail", "okCount": 0, "errorCount": 0, "required": False, "errors": [str(exc)], "issue": f"图纸解析失败（不影响表格排产）：{exc}", }) return reports def analyze_work_dir( world: World, session_id: str | None = None, *, force_sql_replace: bool = False, source_snapshots: dict[str, bytes] | None = None, ) -> dict[str, Any]: """深度解析工程目录：每张表读内容 + 动态字段映射 + 汇总能否开排。 force_sql_replace=True 时（「根据这个排产」）强制用 SQL 包整表覆盖项目世界， 避免旧世界残留错误工艺映射后永远不更新。 """ proj, work = _project_work_dir(session_id) if not proj: return { "ok": False, "error": "当前话题不在工程项目下，请先在左侧选一个项目。", "files": [], "drawings": [], "coverage": {}, "missing": list(_REQUIRED), "canSchedule": False, "batches": [], "markdown": "当前话题不在工程项目下。请先在左侧选一个项目，或建项目时指定工程目录。", } if not work: return { "ok": False, "error": "这个项目还没设定工程目录。", "projectName": proj.get("name"), "files": [], "drawings": [], "coverage": {}, "missing": list(_REQUIRED), "canSchedule": False, "batches": [], "markdown": "这个项目还没设定工程目录。建项目时选一个放 Excel 的文件夹。", } if not os.path.isdir(work): return { "ok": False, "error": f"工程目录访问不到：{work}", "projectName": proj.get("name"), "workDir": work, "files": [], "drawings": [], "coverage": {}, "missing": list(_REQUIRED), "canSchedule": False, "batches": [], "markdown": f"工程目录访问不到：`{work}`（路径变了或盘符未挂上）。", } names = sorted(os.listdir(work)) drawing_reports = _discover_drawing_files(world, work, str(proj.get("id") or "") or None) table_names = [n for n in names if re.search(r"\.(xlsx|xlsm|csv|txt)$", n, re.I) and not n.startswith("~$") and not n.startswith(".")] sql_names = [n for n in names if n.lower().endswith(".sql") and not n.startswith("~$")] file_reports: list[dict[str, Any]] = [] all_batches: list[dict[str, Any]] = [] all_diagnostics: list[dict[str, Any]] = [] kind_ok: dict[str, int] = {} kind_fields: dict[str, list[dict[str, str]]] = {} # SQL 完整库优先：映射进当前世界并计入覆盖度（只取最大的一份完整库） sql_applied = False sql_stats: dict[str, Any] = {} if sql_names: sql_names = sorted( sql_names, key=lambda n: os.path.getsize(os.path.join(work, n)) if os.path.isfile(os.path.join(work, n)) else 0, reverse=True, ) for name in sql_names[:1]: path = os.path.join(work, name) try: size = ( len(source_snapshots[name]) if source_snapshots is not None and name in source_snapshots else os.path.getsize(path) ) except OSError: size = 0 try: from server.importers.sql_pack import apply_sql_pack_to_world raw = _source_bytes(path, name, source_snapshots) prev = _preview_sql_bytes(raw) flex = prev.get("flex") or {} st = (flex.get("stats") or {}) sql_stats = st if st.get("orders") or st.get("materials") or st.get("routing"): # 工程目录里的 SQL = 项目真相源，整包覆盖（避免旧错误工艺残留） apply_sql_pack_to_world(world, flex, replace=True) sql_applied = True for k, key in (("orders", "orders"), ("materials", "materials"), ("routing", "routing"), ("equipment", "equipment"), ("bom", "bom")): n_ok = int(st.get(key) or 0) if n_ok: kind_ok[k] = kind_ok.get(k, 0) + n_ok file_reports.append({ "name": name, "size": size, "status": "ok" if prev.get("okCount") else "warn", "kind": "sql-pack", "kindCn": "SQL 数据包", "okCount": prev.get("okCount") or 0, "errorCount": 0, "errors": [], "warnings": [], "headers": [t.get("table") for t in (prev.get("tables") or [])[:8]], "samples": prev.get("samples") or [], "sheets": prev.get("tables") or [], "required": True, "fieldMap": [], "fieldMapText": prev.get("fieldMapText") or "", "issue": prev.get("fieldMapText") or ( f"SQL→订单{st.get('orders', 0)}/工艺{st.get('routing', 0)}" f"/已挂工艺产品{st.get('routedProducts', 0)}" ), }) except Exception as exc: # noqa: BLE001 file_reports.append({ "name": name, "size": size, "status": "fail", "kind": "sql-pack", "kindCn": "SQL 数据包", "okCount": 0, "errorCount": 1, "errors": [str(exc)], "headers": [], "samples": [], "sheets": [], "required": True, "fieldMap": [], "fieldMapText": "", "issue": str(exc), }) # 第一遍：先读订单，建立 订单号→料号 映射，供工艺/BOM 的 sheet 名反查 product_by_order: dict[str, str] = {} for name in table_names: if _guess_kind_by_name(name) != "orders": continue path = os.path.join(work, name) try: raw = _source_bytes(path, name, source_snapshots) preview = preview_file(name, raw, world, soft=True, kind_hint="orders") except Exception: continue for b in preview.get("batches") or []: for row in b.get("okRows") or []: ono = str(row.get("orderNo") or "").strip() pc = str(row.get("productCode") or "").strip() if ono and pc: product_by_order[ono] = pc for name in table_names: path = os.path.join(work, name) try: size = ( len(source_snapshots[name]) if source_snapshots is not None and name in source_snapshots else os.path.getsize(path) ) except OSError: size = 0 kind_hint = _guess_kind_by_name(name) try: raw = _source_bytes(path, name, source_snapshots) preview = preview_file( name, raw, world, soft=True, product_by_order=product_by_order, kind_hint=kind_hint, ) except Exception as exc: # noqa: BLE001 file_reports.append({ "name": name, "size": size, "status": "fail", "kind": kind_hint, "kindCn": KIND_CN.get(kind_hint or "", "读失败"), "okCount": 0, "errorCount": 1, "errors": [str(exc)], "headers": [], "samples": [], "sheets": [], "required": False, "fieldMap": [], "fieldMapText": "", }) continue sheets = [] headers: list[str] = [] samples: list[str] = [] errors: list[str] = [] warnings: list[str] = [] file_diagnostics: list[dict[str, Any]] = [] field_map: list[dict[str, str]] = [] ok_total = 0 err_total = 0 skip_total = 0 primary_kind = kind_hint for b in preview.get("batches") or []: kind = b.get("kind") or primary_kind or "materials" n_ok = int(b.get("okCount") or 0) is_skip = _is_mom_skip_block(b.get("sheet")) original_error_count = int(b.get("errorCount") or 0) if not is_skip: if not primary_kind: primary_kind = kind cover_kind = primary_kind or kind if n_ok: kind_ok[cover_kind] = kind_ok.get(cover_kind, 0) + n_ok if kind != cover_kind: kind_ok[kind] = kind_ok.get(kind, 0) + n_ok if not field_map and b.get("fieldMap"): field_map = list(b["fieldMap"]) if primary_kind and b.get("fieldMap"): kind_fields.setdefault(primary_kind, list(b["fieldMap"])) batch_diagnostics = [ dict(item) for item in (b.get("diagnostics") or []) if isinstance(item, dict) ] if is_skip: skip_total += n_ok + original_error_count if not batch_diagnostics: batch_diagnostics = [ { "sheet": b.get("physicalSheet") or b.get("sheet") or name, "excelRow": None, "parserIndex": index, "kind": kind, "code": "NON_SCHEDULING_BLOCK", "severity": "ignored", "message": str(message), "rawSummary": {}, } for index, message in enumerate(b.get("errors") or [], 1) ] else: batch_diagnostics = [ { **item, "code": "NON_SCHEDULING_BLOCK", "severity": "ignored", "message": "非排产数据块，已跳过且不计入问题行", } for item in batch_diagnostics ] real_err = 0 elif batch_diagnostics: real_err = sum( 1 for item in batch_diagnostics if item.get("severity") == "blocking" ) else: real_err = original_error_count batch_counts = { severity: sum( 1 for item in batch_diagnostics if item.get("severity") == severity ) for severity in ("ignored", "warning", "blocking") } file_diagnostics.extend(batch_diagnostics) all_diagnostics.extend(batch_diagnostics) sheets.append({ "sheet": b.get("sheet"), "kind": kind, "kindCn": KIND_CN.get(kind, kind), "okCount": n_ok, "errorCount": real_err, "skip": is_skip, "diagnosticCounts": batch_counts, }) if not is_skip: ok_total += n_ok err_total += real_err for row in (b.get("okRows") or [])[:2]: if isinstance(row, dict): samples.append(_sample_cells(row)) if not headers: headers = list(row.keys())[:8] if not is_skip: for e in (b.get("errors") or [])[:3]: errors.append(str(e)) for w in (b.get("warnings") or [])[:2]: warnings.append(str(w)) if not headers and b.get("headersRaw"): headers = [str(h) for h in b["headersRaw"] if h][:8] all_batches.append({ "kind": b["kind"], "sheet": b.get("sheet") or name, "physicalSheet": b.get("physicalSheet") or b.get("sheet") or name, "okRows": b.get("okRows") or [], "okCount": n_ok, "errorCount": real_err, "errors": (b.get("errors") or [])[:8], "warnings": (b.get("warnings") or [])[:5], "diagnostics": batch_diagnostics, "diagnosticCounts": batch_counts, "fieldMap": b.get("fieldMap") or [], "sourceFile": name, "skip": is_skip, }) status = "ok" if ok_total > 0 and err_total == 0 else ("warn" if ok_total > 0 else "fail") fmap_text = _fmt_field_map(field_map) issue = "" blocking_diagnostic = next(( item for item in file_diagnostics if item.get("severity") == "blocking" ), None) if blocking_diagnostic: excel_row = blocking_diagnostic.get("excelRow") row_prefix = f"Excel 第{excel_row}行：" if excel_row else "" issue = row_prefix + str(blocking_diagnostic.get("message") or "数据校验未通过") elif errors: issue = errors[0] elif warnings: issue = warnings[0] elif fmap_text: issue = f"字段：{fmap_text}" elif samples: issue = f"样例：{samples[0]}" file_counts = { severity: sum( 1 for item in file_diagnostics if item.get("severity") == severity ) for severity in ("ignored", "warning", "blocking") } file_reports.append({ "name": name, "size": size, "status": status, "kind": primary_kind, "kindCn": KIND_CN.get(primary_kind or "", primary_kind or "未识别"), "okCount": ok_total, "errorCount": err_total, "skipRows": skip_total, "errors": errors, "warnings": warnings, "diagnostics": file_diagnostics, "diagnosticCounts": file_counts, "headers": headers, "samples": samples[:3], "sheets": sheets, "required": (primary_kind in _REQUIRED) if primary_kind else False, "fieldMap": field_map, "fieldMapText": fmap_text, "issue": issue, }) coverage = {k: kind_ok.get(k, 0) > 0 for k in (*_REQUIRED, *_HELPFUL)} for f in file_reports: k = f.get("kind") if k and int(f.get("okCount") or 0) > 0: coverage[k] = True kind_ok[k] = max(kind_ok.get(k, 0), int(f.get("okCount") or 0)) missing = [KIND_CN[k] for k in _REQUIRED if not coverage.get(k)] soft_missing: list[str] = [] if not (world.get("flexCalendar") or []): soft_missing.append("班次日历（没有可用系统默认班次）") for k in _HELPFUL: if not coverage.get(k): soft_missing.append(f"{KIND_CN[k]}（有更好，没有也能先试）") # 齐备度明细：每项带上识别到的关键字段 coverage_detail: list[dict[str, Any]] = [] for k in _REQUIRED: hit = bool(coverage.get(k)) fmap = kind_fields.get(k) or [] for f in file_reports: if f.get("kind") == k and f.get("fieldMap"): fmap = f["fieldMap"] break note = _fmt_field_map(fmap) if fmap else "" if hit: detail = f"读到 {kind_ok.get(k, 0)} 行" if sql_applied and int(sql_stats.get(k) or 0) > 0: detail = f"来自 SQL {sql_stats.get(k, 0)} 行" if note: detail += f"；识别 {note}" else: detail = "还没有有效数据" if note: detail += f"（已见表头 {note}，但行校验未过）" elif any(f.get("kind") == k for f in file_reports): detail = "有文件但关键字段对不上，请看文件清单里的问题列" coverage_detail.append({ "key": k, "label": KIND_CN[k], "ok": hit, "count": kind_ok.get(k, 0), "fieldMap": fmap, "note": detail, }) can_schedule = len(missing) == 0 # SQL 已挂订单工艺时，即使 Excel 缺表也可开排 if sql_applied and all(coverage.get(k) for k in ("orders", "routing", "equipment")): can_schedule = True missing = [] world_ready = check_readiness(world) md = _to_markdown( proj_name=proj.get("name") or "未命名", work=work, files=file_reports, coverage=coverage, coverage_detail=coverage_detail, missing=missing, soft_missing=soft_missing, can_schedule=can_schedule, kind_ok=kind_ok, world_ready=world_ready, ) excel_ok = sum( int(b.get("okCount") or 0) for b in all_batches if not b.get("skip") ) sql_ok_n = int((file_reports[0].get("okCount") or 0) if sql_applied and file_reports else 0) diagnostic_counts = { severity: sum( 1 for item in all_diagnostics if item.get("severity") == severity ) for severity in ("ignored", "warning", "blocking") } return { "ok": True, "projectName": proj.get("name"), "workDir": work, "files": [*file_reports, *drawing_reports], "drawings": drawing_reports, "coverage": coverage, "coverageDetail": coverage_detail, "kindCounts": kind_ok, "missing": missing, "softMissing": soft_missing, "canSchedule": can_schedule, "batches": [b for b in all_batches if b.get("okRows") and not b.get("skip")], "totalOk": excel_ok + sql_ok_n, "totalErrors": sum(int(b.get("errorCount") or 0) for b in all_batches), "skippedRows": sum(int(f.get("skipRows") or 0) for f in file_reports), "diagnostics": all_diagnostics, "diagnosticCounts": diagnostic_counts, "diagnosticsVersion": 1, "sqlApplied": sql_applied, "sqlStats": sql_stats, "worldReadySummary": world_ready.get("summary"), "productByOrder": product_by_order, "markdown": md, "forceSqlReplace": force_sql_replace, } def prepare_folder_schedule(world: World, session_id: str | None) -> dict[str, Any]: """Build a frozen P2 payload while keeping analysis writes off the main world.""" project, work_dir = _project_work_dir(session_id) if work_dir: before_manifest, source_snapshots = read_folder_source_snapshots(work_dir) else: before_manifest, source_snapshots = [], {} shadow = copy.deepcopy(world) report = analyze_work_dir( shadow, session_id, force_sql_replace=True, source_snapshots=source_snapshots, ) if not report.get("ok") or not work_dir: return report after_manifest = folder_source_manifest(work_dir) if after_manifest != before_manifest: raise PermissionError("工程目录在分析期间发生变化，请重新发起排产") sql_payload: dict[str, Any] | None = None if report.get("sqlApplied"): sql_entries = [ row for row in after_manifest if Path(str(row.get("name") or "")).suffix.lower() == ".sql" ] if not sql_entries: raise PermissionError("SQL 数据包已失效，请重新发起排产") selected = min( sql_entries, key=lambda row: (-int(row.get("sizeBytes") or 0), str(row.get("name") or "")), ) selected_name = str(selected["name"]) if selected_name not in source_snapshots: raise PermissionError("SQL 数据包冻结源已失效，请重新发起排产") preview = _preview_sql_bytes(source_snapshots[selected_name]) sql_payload = copy.deepcopy(preview.get("flex") or {}) if not isinstance(sql_payload, dict) or not (sql_payload.get("stats") or {}): raise PermissionError("SQL 数据包冻结失败，请重新发起排产") kangni_payload = _build_kangni_payload_from_snapshots(source_snapshots) kangni_meta = copy.deepcopy((kangni_payload or {}).get("meta") or {}) resource_quality = kangni_meta.get("resourceQuality") or {} trial_ready = bool( kangni_payload and int(kangni_meta.get("orderCount") or 0) > 0 and int(kangni_meta.get("routingRecordCount") or 0) > 0 and (kangni_payload.get("flex") or {}).get("flexEquipment") ) production_ready = ( bool(resource_quality.get("productionReady")) if kangni_payload else None ) final_manifest = folder_source_manifest(work_dir) if final_manifest != before_manifest: raise PermissionError("工程目录在冻结期间发生变化，请重新发起排产") report.update({ "projectId": (project or {}).get("id"), "sourceManifestVersion": 1, "sourceManifest": final_manifest, "sourceManifestDigest": folder_source_manifest_digest(final_manifest), "folderWorldFingerprint": folder_schedule_world_fingerprint(world), "sqlPayload": sql_payload, "kangniDetected": kangni_payload is not None, "trialReady": trial_ready, "productionReady": production_ready, "kangniPayload": kangni_payload, "kangniMeta": kangni_meta, }) return report def verify_folder_schedule_binding( params: dict[str, Any], current_world: World, ) -> dict[str, Any]: """Fail closed when approved files, frozen payload, or target world drifted.""" if int(params.get("sourceManifestVersion") or 0) != 1: raise PermissionError("工程目录确认缺少源文件清单，请重新发起") expected_manifest = params.get("sourceManifest") if not isinstance(expected_manifest, list) or not expected_manifest: raise PermissionError("工程目录确认缺少源文件证据，请重新发起") expected_digest = folder_source_manifest_digest(expected_manifest) if expected_digest != str(params.get("sourceManifestDigest") or ""): raise PermissionError("工程目录源文件证据已损坏，请重新发起") work_dir = str(params.get("workDir") or "").strip() if not work_dir: raise PermissionError("工程目录确认缺少项目目录，请重新发起") current_manifest = folder_source_manifest(work_dir) if current_manifest != expected_manifest: raise PermissionError("工程目录源文件已变化，请重新分析并确认") expected_payload_digest = str(params.get("folderPayloadDigest") or "") if not expected_payload_digest or folder_schedule_payload_digest(params) != expected_payload_digest: raise PermissionError("工程目录冻结载荷已损坏，请重新发起") if not str(params.get("projectId") or "").strip() or not str(params.get("sessionId") or "").strip(): raise PermissionError("工程目录确认缺少项目或会话绑定，请重新发起") if params.get("boundAction") != "folder.schedule": raise PermissionError("工程目录确认的动作绑定已损坏，请重新发起") if str(params.get("targetWorldKey") or "") != str(params.get("projectId") or ""): raise PermissionError("工程目录确认的目标世界绑定已损坏，请重新发起") if not str(params.get("beforeSnapshot") or "").strip(): raise PermissionError("工程目录确认缺少审批前快照，请重新发起") expected_world = str(params.get("folderWorldFingerprint") or "") if not expected_world or folder_schedule_world_fingerprint(current_world) != expected_world: raise PermissionError("工程目录确认的目标世界已变化，请重新发起") sql_payload = params.get("sqlPayload") batches = params.get("batches") or [] if params.get("sqlApplied") and not isinstance(sql_payload, dict): raise PermissionError("工程目录确认缺少冻结 SQL 载荷，请重新发起") kangni_detected = params.get("kangniDetected") is True kangni_payload = params.get("kangniPayload") if kangni_detected: if params.get("trialReady") is not True: raise PermissionError("康尼冻结载荷未达到本地试排条件，请重新发起") if not isinstance(kangni_payload, dict): raise PermissionError("工程目录确认缺少康尼冻结载荷，请重新发起") fixed = kangni_payload.get("fixed") flex = kangni_payload.get("flex") meta = kangni_payload.get("meta") if not isinstance(fixed, dict) or not isinstance(flex, dict) or not isinstance(meta, dict): raise PermissionError("康尼冻结载荷结构已损坏，请重新发起") if int(meta.get("payloadSchemaVersion") or 0) != 1 or meta.get("sourceMode") != "data-dir-only": raise PermissionError("康尼冻结载荷版本或来源已损坏，请重新发起") if params.get("kangniMeta") != meta: raise PermissionError("康尼冻结载荷对账证据不一致，请重新发起") resource_quality = meta.get("resourceQuality") or {} if not isinstance(params.get("productionReady"), bool): raise PermissionError("康尼冻结载荷缺少生产可用性结论，请重新发起") if params["productionReady"] != bool(resource_quality.get("productionReady")): raise PermissionError("康尼冻结载荷生产可用性证据不一致，请重新发起") try: json.dumps(kangni_payload, ensure_ascii=False, sort_keys=True, allow_nan=False) except (TypeError, ValueError) as exc: raise PermissionError("康尼冻结载荷不是纯 JSON，请重新发起") from exc elif kangni_payload is not None or params.get("trialReady"): raise PermissionError("康尼冻结载荷检测标记已损坏，请重新发起") if not batches and not sql_payload and not kangni_detected: raise PermissionError("工程目录确认没有可执行的冻结数据") return { "sourceManifestDigest": expected_digest, "folderWorldFingerprint": expected_world, "folderPayloadDigest": expected_payload_digest, "beforeSnapshot": str(params["beforeSnapshot"]), "fileCount": len(expected_manifest), "kangniDetected": kangni_detected, } def _to_markdown( *, proj_name: str, work: str, files: list[dict], coverage: dict, coverage_detail: list[dict], missing: list[str], soft_missing: list[str], can_schedule: bool, kind_ok: dict[str, int], world_ready: dict, ) -> str: lines = [ f"**工程目录数据包 · {proj_name}**", "", f"目录：`{work}`", "", "### 我读到的表格", "", ] if not files: lines.append("目录里还没有 Excel/CSV。把订单、物料、工艺、设备表放进来再叫我。") else: lines += [ "| 文件 | 类型 | 大小 | 有效行 | 问题行 | 识别字段 / 问题 |", "| --- | --- | ---: | ---: | ---: | --- |", ] for f in files: err = (f.get("issue") or "；".join((f.get("errors") or [])[:2]) or f.get("fieldMapText") or "—") err = str(err).replace("|", "/") if len(err) > 48: err = err[:48] + "…" lines.append( f"| {f.get('name')} | {f.get('kindCn') or '—'} | {_fmt_size(int(f.get('size') or 0))} " f"| {f.get('okCount', 0)} | {f.get('errorCount', 0)} | {err} |" ) skip_total = sum(int(f.get("skipRows") or 0) for f in files) if skip_total: lines.append( f"\n> 另有 {skip_total} 行来自非排产块（工厂/质检/仓储/人力/客户/供应商等表），" "已跳过，不计入问题行。" ) diagnostics = [ item for file_report in files for item in (file_report.get("diagnostics") or []) if isinstance(item, dict) ] structural_ignored = sum( item.get("code") in {"SECONDARY_SEQUENCE_HEADER", "EMBEDDED_SECTION_ROW"} for item in diagnostics ) general_defaults = sum( item.get("code") == "EQUIPMENT_CAPABILITIES_DEFAULTED" for item in diagnostics ) alias_recoveries = sum( item.get("code") == "DUPLICATE_ALIAS_EMPTY_IGNORED" for item in diagnostics ) diagnostic_notes: list[str] = [] if structural_ignored: diagnostic_notes.append(f"忽略 {structural_ignored} 行内嵌表头/字典结构") if general_defaults: diagnostic_notes.append(f"{general_defaults} 台设备暂按 GENERAL 工序能力导入") if alias_recoveries: diagnostic_notes.append(f"恢复 {alias_recoveries} 行重复编码列") if diagnostic_notes: lines.append("\n> 诊断说明：" + "；".join(diagnostic_notes) + "。") sample_rows = [(f.get("name"), (f.get("samples") or [None])[0]) for f in files if f.get("samples")] if sample_rows: lines += ["", "### 样例数据（每表一行）", "", "| 文件 | 样例 |", "| --- | --- |"] for name, sample in sample_rows[:8]: s = str(sample).replace("|", "/") if len(s) > 64: s = s[:64] + "…" lines.append(f"| {name} | {s} |") lines += [ "", "### 排产必备齐不齐", "", "| 必备项 | 状态 | 说明 |", "| --- | --- | --- |", ] for d in coverage_detail: st = "✓ 已有" if d.get("ok") else "× 缺少" note = str(d.get("note") or "").replace("|", "/") if len(note) > 56: note = note[:56] + "…" lines.append(f"| {d.get('label')} | {st} | {note} |") for s in soft_missing[:4]: lines.append(f"| （可选） | · | {s} |") lines.append("") if can_schedule: lines.append("**结论：按文件内容看，已基本满足排产条件。**") lines.append("下一步：确认导入这些数据，系统将继续校验并生成试排方案。") else: lines.append("**结论：当前不满足直接排产条件。**") lines.append("缺失项：" + ("、".join(missing) if missing else "有效数据行")) lines.append("请补充缺失数据或修正错误记录后重新执行目录分析。") ws = (world_ready or {}).get("summary") or {} if ws: lines += [ "", f"（系统当前已有待排订单 {ws.get('total', 0)} 张，" f"可排 {ws.get('ready', 0)} 张，存在阻断 {ws.get('blocked', 0)} 张。" f"导入目录后将基于新数据重新校验。）", ] return "\n".join(lines) def confirmation_for_folder_schedule(report: dict[str, Any]) -> tuple[str, list[str]]: title = f"导入工程目录并试排 · {report.get('projectName') or ''}" lines = [ f"目录：{report.get('workDir') or ''}", f"有效行合计：{report.get('totalOk') or 0}", ] for k in _REQUIRED: n = (report.get("kindCounts") or {}).get(k, 0) if n: lines.append(f"· {KIND_CN.get(k, k)} {n} 行") lines.append("确认后写入柔性主数据并生成试排方案（支持回滚）") return title, lines