refactor: drive BOM import lifecycle with an explicit state machine

This commit is contained in:
阿白叔 committed 2026-10-16 09:46:02 +08:00
1 parent b30712b117
commit 2ddfd1a0b2
9 files changed
+400 -80

No files matched your search

+45
View File
@@ -0,0 +1,45 @@
# BOM 导入状态机
用户反馈:失败后重新导入时,旧失败报告在新结果出来前仍显示。导入生命周期由 `bom_import_state.py` 的 `BomImportMachine` 管理;`ProjectPlanPanel` 按批次(无批次则按任务)保存状态机。界面不再分别保存报告缓存和状态文字缓存。
```mermaid
stateDiagram-v2
[*] --> 空闲
空闲 --> 读取表格: 开始
读取表格 --> 校验表格
校验表格 --> 获取库存
获取库存 --> 匹配位号
匹配位号 --> 获取库存: 下一工程
匹配位号 --> 预览就绪: 全部通过
读取表格 --> 校验未通过: 文件错误
校验表格 --> 校验未通过: 格式或规则错误
匹配位号 --> 校验未通过: 匹配错误
读取表格 --> 取消中: 请求取消
校验表格 --> 取消中: 请求取消
获取库存 --> 取消中: 请求取消
匹配位号 --> 取消中: 请求取消
取消中 --> 已取消: 后台收尾完成
取消中 --> 异常: 收尾失败
```
图示突出主路径。读取、校验、库存与匹配阶段均可因运行异常转入 `FAILED`,也可返回含错误行的 `REJECTED` 报告;完整转换规则以 `_NEXT`、`receive`、`finish` 为准。
## 约束
- `phase` 表示业务阶段;`settled` 表示后台工作线程是否完成收尾。收到最终报告后仍可能暂时 `busy=True`,此时禁止启动新导入;取消按钮只在仍接收阶段事件时可用。
- `start()` 增加 `attempt`,同时清除本轮旧报告与提示。取消文件选择不会调用 `start()`。
- 阶段事件由后端 `on_phase(phase, message)` 明确发出,不解析中文提示来判断阶段。普通 `on_progress(message)` 只更新当前合法阶段内的进度。
- 所有转换在 GUI 线程处理。旧停止事件、被替换的状态机实例和旧 `attempt` 的回调都不能更新当前导入。
- 取消请求先进入 `CANCELLING`,阻止后续进度和结果;真实异常优先于取消,工作线程结束才进入 `CANCELLED` 或 `FAILED`。
- `report` 是状态的一部分,摘要和详情在显示时生成。保存、放弃预览只释放报告中的预览引用,保留 `PREVIEW_READY` 的成功含义并更新说明。
- 替换计划草稿独立于导入状态。失败、取消、重试不会自动删除已有草稿。保存与执行前的工程核验保持原流程。
此状态机只负责 BOM 导入,不替代数据库中的任务执行状态,也不管理原生 CAD 会话资源本身。
## 验证
`tests/v1_1/test_bom_import_state.py` 验证轮次隔离、非法倒退、多工程往返、取消与异常优先级、成功报告释放预览后的语义。UI 回归验证阶段事件驱动提示和按钮、等待状态不会被普通摘要刷新覆盖,以及取消后的迟到事件不会恢复旧结果。服务回归验证两工程发出明确的阶段序列。
新增用例先确认失败,再接入实现。首轮 BOM、任务 UI、预览及懒加载定向回归:70 项通过,22.97 秒。测试使用 offscreen Qt 和模拟库存,不重复启动真实 CAD。
最终加入库存取消、界面响应与保存安全回归,合计 90 项通过,34.78 秒。只读代码复核未发现新增问题;两轮测试有重叠,不累加计数。
@@ -8,6 +8,7 @@ from openpyxl import load_workbook
from .bom_batch import BomBatchPreview, BomProjectPreview, _assert_editable, _identity, _scope
from .bom_plan import BomMatcher, _normal_headers, _text, parse_bom_row
from .errors import TaskCenterError
from .bom_import_state import BomImportPhase
from .store_target_plan import merge_target_inventory
from .target_plan import ProjectIdentityResolver, compile_target_rules
@@ -110,7 +111,7 @@ def _check_record_conflicts(rows, records, indices):
rows[index] = replace(rows[index], status='failed', reason=reason)
def inspect_batch(service, task_id, path, *, stop_event=None, on_progress=None):
def inspect_batch(service, task_id, path, *, stop_event=None, on_progress=None, on_phase=None):
"""Validate all independent rows; never persist inventory or return partial plans.
Operational failures (including cancellation and native cleanup) propagate so
@@ -120,12 +121,14 @@ def inspect_batch(service, task_id, path, *, stop_event=None, on_progress=None):
if stop_event is not None and stop_event.is_set():
raise TaskCenterError('operation_cancelled', 'BOM 导入已取消')
def notify(message):
def notify(message, phase=None):
if phase is not None and on_phase is not None:
on_phase(phase, message)
if on_progress is not None:
on_progress(message)
check_cancelled()
notify('正在读取并校验 BOM Excel 表格…')
notify('正在读取并校验 BOM Excel 表格…', BomImportPhase.READING)
scope = _scope(service._store, task_id)
routing = ProjectIdentityResolver()
owners = {routing.project(project.path): (task, project) for task, project in scope}
@@ -138,6 +141,7 @@ def inspect_batch(service, task_id, path, *, stop_event=None, on_progress=None):
sheet = workbook.active
cells = iter(sheet.iter_rows())
header = next(cells, ())
notify('正在校验 BOM Excel 格式与工程归属…', BomImportPhase.VALIDATING)
header_error = ''
if len(workbook.worksheets) != 1:
header_error = 'BOM 工作簿只能包含一个工作表'
@@ -218,9 +222,9 @@ def inspect_batch(service, task_id, path, *, stop_event=None, on_progress=None):
for position, (key, indices) in enumerate(grouped.items(), 1):
check_cancelled()
task, project = owners[key]
def progress(message):
if on_progress is not None:
on_progress(f'工程 {position}/{len(grouped)} · {message}')
def progress(message, phase=None):
notify(f'工程 {position}/{len(grouped)} · {message}', phase)
progress(f'正在核验「{task.name}」的位号库存…', BomImportPhase.INVENTORY)
baseline = tuple(service._store.list_target_plan(task.task_id))
requested = tuple(dict.fromkeys(records[index].old for index in indices))
known = tuple(dict.fromkeys(row.target.old_part_number for row in baseline))
@@ -237,7 +241,7 @@ def inspect_batch(service, task_id, path, *, stop_event=None, on_progress=None):
inventory = tuple(service.for_project_task(task.task_id)._quick_run_preparer.collect_inventory(
project.path, tuple(dict.fromkeys((*known, *requested))), **controls))
check_cancelled()
progress(f'「{task.name}」正在匹配 {len(indices)} 行 BOM 与工程位号…')
progress(f'「{task.name}」正在匹配 {len(indices)} 行 BOM 与工程位号…', BomImportPhase.MATCHING)
merged = merge_target_inventory(baseline, inventory)
matched_rows, touched = {}, {}
matcher = BomMatcher(merged) if merged else None
@@ -0,0 +1,109 @@
"""BOM import transitions. Only the GUI thread owns and mutates this machine."""
from __future__ import annotations
from dataclasses import dataclass, replace
from enum import Enum
from typing import TYPE_CHECKING
from .errors import TaskCenterError
if TYPE_CHECKING:
from .bom_import_report import BomImportReport
class BomImportPhase(Enum):
IDLE = 'idle'
READING = 'reading'
VALIDATING = 'validating'
INVENTORY = 'inventory'
MATCHING = 'matching'
CANCELLING = 'cancelling'
PREVIEW_READY = 'preview_ready'
REJECTED = 'rejected'
CANCELLED = 'cancelled'
FAILED = 'failed'
_NEXT = {
BomImportPhase.READING: {BomImportPhase.READING, BomImportPhase.VALIDATING},
BomImportPhase.VALIDATING: {BomImportPhase.VALIDATING, BomImportPhase.INVENTORY},
BomImportPhase.INVENTORY: {BomImportPhase.INVENTORY, BomImportPhase.MATCHING},
BomImportPhase.MATCHING: {BomImportPhase.MATCHING, BomImportPhase.INVENTORY},
}
@dataclass(frozen=True)
class BomImportState:
attempt: int = 0
phase: BomImportPhase = BomImportPhase.IDLE
settled: bool = True
message: str = ''
report: BomImportReport | None = None
notice: str = ''
@property
def busy(self) -> bool:
# A received report does not mean the worker has released its resources.
return not self.settled
@property
def can_cancel(self) -> bool:
return self.busy and self.phase in _NEXT
class BomImportMachine:
def __init__(self):
self.state = BomImportState()
def start(self) -> int:
if self.state.busy:
raise RuntimeError('BOM import is still running')
self.state = BomImportState(self.state.attempt + 1, BomImportPhase.READING,
False, '正在读取并校验 BOM Excel 表格…')
return self.state.attempt
def _current(self, attempt: int) -> bool:
return attempt == self.state.attempt and self.state.busy
def progress(self, attempt: int, phase: BomImportPhase, message: str) -> bool:
if not self._current(attempt) or phase not in _NEXT.get(self.state.phase, ()):
return False
self.state = replace(self.state, phase=phase, message=message)
return True
def cancel(self, attempt: int) -> bool:
if not self._current(attempt) or not self.state.can_cancel:
return False
self.state = replace(self.state, phase=BomImportPhase.CANCELLING,
message='正在取消;等待自有 CAD 会话安全释放…')
return True
def receive(self, attempt: int, report: BomImportReport) -> bool:
if not self._current(attempt) or not self.state.can_cancel:
return False
phase = BomImportPhase.PREVIEW_READY if report.preview is not None else BomImportPhase.REJECTED
self.state = replace(self.state, phase=phase, message='', report=report)
return True
def finish(self, attempt: int, *, error: Exception | None = None) -> bool:
if not self._current(attempt):
return False
cancelled_error = isinstance(error, TaskCenterError) and error.code == 'operation_cancelled'
if error is not None and not cancelled_error:
reason = error.message if isinstance(error, TaskCenterError) else str(error)
self.state = replace(self.state, phase=BomImportPhase.FAILED, report=None,
message=f'本次 BOM 导入未完成:{reason[:240]};原有预览和编辑保留。')
elif cancelled_error or self.state.phase is BomImportPhase.CANCELLING:
self.state = replace(self.state, phase=BomImportPhase.CANCELLED, report=None,
message='本次 BOM 导入已取消,原有预览和编辑保留。')
elif self.state.phase not in (BomImportPhase.PREVIEW_READY, BomImportPhase.REJECTED):
self.state = replace(self.state, phase=BomImportPhase.FAILED,
message='本次 BOM 导入未返回校验结果,请重新导入。')
self.state = replace(self.state, settled=True)
return True
def release_preview(self, *, saved: bool) -> None:
report = self.state.report
if report is not None and report.preview is not None:
self.state = replace(self.state, report=replace(report, preview=None), notice=
'校验通过,位号计划已保存。' if saved else '本次导入预览已放弃,校验报告保留。')
@@ -753,10 +753,11 @@ class TaskCenterService:
return self._idle_quick_run_operation('start_new_round', task_id,
lambda: start_new_round(self, task_id))
def inspect_bom_batch(self, task_id: str, path: Path, *, stop_event=None, on_progress=None):
def inspect_bom_batch(self, task_id: str, path: Path, *, stop_event=None, on_progress=None, on_phase=None):
from .bom_import_report import inspect_batch
return self._idle_quick_run_operation('inspect_bom_batch', task_id,
lambda: inspect_batch(self, task_id, path, **control_options(stop_event, on_progress)))
lambda: inspect_batch(self, task_id, path, on_phase=on_phase,
**control_options(stop_event, on_progress)))
def _pause_quick_run_queue(self, task_id: str, message: str) -> None:
if self._store.get_task(task_id).status is TaskStatus.RUNNING:
@@ -664,7 +664,7 @@ class TrialTaskCenterWindow(QMainWindow):
self.run_panel.operator_band.style().unpolish(self.run_panel.operator_band)
self.run_panel.operator_band.style().polish(self.run_panel.operator_band)
def _run_async(self, operation, callback, button=None, *, expected_task_id=None, **_unused):
def _run_async(self, operation, callback, button=None, *, expected_task_id=None, retain_result=False, **_unused):
if self._workers or self._closed:
return
worker = ServiceWorker(operation)
@@ -675,7 +675,7 @@ class TrialTaskCenterWindow(QMainWindow):
owner = expected_task_id or self._active_quick_run_task_id
operation_error = None
def valid():
return not self._closed and generation == self._generation and (execution or expected_task_id is None or expected_task_id == self._task_id)
return not self._closed and generation == self._generation and (retain_result or execution or expected_task_id is None or expected_task_id == self._task_id)
def succeeded(result):
nonlocal operation_error
if valid():
@@ -13,11 +13,12 @@ from PySide6.QtWidgets import (QDialog, QDialogButtonBox, QFileDialog, QHBoxLayo
from .detail_windows import BomReportDialog
from .target_table import TargetTable
from .workers import ServiceWorker
from ..errors import TaskCenterError
from ..bom_import_state import BomImportMachine, BomImportPhase, BomImportState
class _OperationProgress(QObject):
changed = Signal(str)
phase_changed = Signal(object, str)
class _ScanProgress(QObject):
@@ -172,9 +173,8 @@ class ProjectPlanPanel(QWidget):
self._drafts = {}
self._bom_batches = {}
self._orphaned_bom_batches = {}
self._bom_reports = {}
self._bom_statuses = {}
self._operation_scope = None
self._bom_imports = {}
self._active_bom_import = None
self._editable = False
self._operation_stop = None
self._operation_progress = None
@@ -318,8 +318,7 @@ class ProjectPlanPanel(QWidget):
def forget_task(self, task_id):
"""A confirmed permanent deletion is the only removal that discards its draft."""
self._drafts.pop(task_id, None)
self._bom_reports.pop(self._report_scope(task_id), None)
self._bom_statuses.pop(self._report_scope(task_id), None)
self._bom_imports.pop(self._report_scope(task_id), None)
self._restore_bom_report(self._report_scope(self.task_id))
self._orphaned_bom_batches.pop(task_id, None)
for owner, batch in tuple(self._orphaned_bom_batches.items()):
@@ -346,44 +345,53 @@ class ProjectPlanPanel(QWidget):
self._release_bom_previews()
def _release_bom_previews(self, saved=None):
for scope, (report, text, title) in tuple(self._bom_reports.items()):
preview = report.preview
for machine in self._bom_imports.values():
report = machine.state.report
preview = report.preview if report is not None else None
if preview is not None and (saved is None or all(p.task_id in saved for p in preview.projects)):
text = '\n'.join(text.splitlines()[:-1]) + ('\n校验通过,位号计划已保存。' if saved is not None
else '\n本次导入预览已放弃,校验报告保留。')
self._bom_reports[scope] = (replace(report, preview=None), text, title)
machine.release_preview(saved=saved is not None)
self._restore_bom_report(self._report_scope(self.task_id))
@property
def bom_import_state(self):
machine = self._bom_imports.get(self._report_scope(self.task_id))
return machine.state if machine is not None else BomImportState()
def _clear_bom_notice(self):
scope = self._report_scope(self.task_id)
machine = self._bom_imports.get(scope)
if machine is not None and not machine.state.busy and machine.state.report is None:
del self._bom_imports[scope]
def cancel_operation(self):
if self._operation_stop is not None:
if self._active_bom_import is not None:
_, machine, attempt = self._active_bom_import
if not machine.cancel(attempt):
return
self._operation_stop.set()
self.stop_button.setEnabled(False)
message = '正在取消;等待自有 CAD 会话安全释放…'
if self._operation_scope is not None:
self._bom_statuses[self._operation_scope] = message
self.summary.setText(message)
if self._active_bom_import is not None:
self._summary()
else:
self.summary.setText('正在取消;等待自有 CAD 会话安全释放…')
def finish_operation(self, *, error=None):
scope = self._operation_scope
if scope is not None:
cancelled = ((error is None and self._operation_stop is not None and self._operation_stop.is_set()) or
(isinstance(error, TaskCenterError) and error.code == 'operation_cancelled'))
if cancelled:
self._bom_statuses[scope] = '本次 BOM 导入已取消,原有预览和编辑保留。'
if scope == self._report_scope(self.task_id):
self.window._set_operator_message(self._bom_statuses[scope])
elif error is not None:
reason = error.message if isinstance(error, TaskCenterError) else str(error)
self._bom_statuses[scope] = f'本次 BOM 导入未完成:{reason[:240]};原有预览和编辑保留。'
elif scope in self._bom_statuses:
self._bom_statuses[scope] = '本次 BOM 导入已结束,未应用新计划;请重新导入。'
self._operation_scope = None
active, self._active_bom_import = self._active_bom_import, None
if active is not None:
scope, machine, attempt = active
machine.finish(attempt, error=error)
if scope == self._report_scope(self.task_id):
self._restore_bom_report(scope)
if machine.state.message:
self.window._set_operator_message(machine.state.message,
'error' if machine.state.phase is BomImportPhase.FAILED else 'info')
self._operation_stop = None
if self._operation_progress is not None:
self._operation_progress.deleteLater()
self._operation_progress = None
self.stop_button.hide()
if scope is not None:
if active is not None:
self._summary()
def _dispatch_cancellable(self, operation, callback, button, *, bom_scope=None):
@@ -391,11 +399,12 @@ class ProjectPlanPanel(QWidget):
return
stop = Event()
self._operation_stop = stop
self._operation_scope = bom_scope
self._bom_statuses.pop(self._report_scope(self.task_id), None)
self._clear_bom_notice()
machine = None
if bom_scope is not None:
self._bom_reports.pop(bom_scope, None)
self._bom_statuses[bom_scope] = '正在读取并校验 BOM Excel 表格…'
machine = self._bom_imports.setdefault(bom_scope, BomImportMachine())
attempt = machine.start()
self._active_bom_import = (bom_scope, machine, attempt)
self._restore_bom_report(self._report_scope(self.task_id))
self._summary()
self.window._set_operator_message('正在导入 BOM,请查看位号计划中的进度。')
@@ -403,26 +412,42 @@ class ProjectPlanPanel(QWidget):
self._operation_progress = progress
progress.changed.connect(lambda message: self._operation_message(message)
if self._operation_stop is stop else None)
progress.phase_changed.connect(lambda phase, message: self._operation_phase(phase, message)
if self._operation_stop is stop else None)
self.stop_button.show()
self.stop_button.setEnabled(True)
self._dispatch(lambda: operation(stop, progress.changed.emit),
lambda result: callback(result) if not stop.is_set() else None, button)
def received(result):
if machine is not None:
if self._bom_imports.get(bom_scope) is not machine or not machine.receive(attempt, result):
return
elif stop.is_set():
return
callback(result)
action = (lambda: operation(stop, progress.changed.emit, progress.phase_changed.emit)) if machine else (
lambda: operation(stop, progress.changed.emit))
self._dispatch(action, received, button, retain_result=machine is not None)
def _operation_phase(self, phase, message):
if self._active_bom_import is not None:
scope, machine, attempt = self._active_bom_import
if machine.progress(attempt, phase, message) and scope == self._report_scope(self.task_id):
self._summary()
def _operation_message(self, message):
if self._operation_stop is not None and not self._operation_stop.is_set():
if self._operation_scope is not None:
self._bom_statuses[self._operation_scope] = message
if self._operation_scope != self._report_scope(self.task_id):
return
self.summary.setText(message)
if self._active_bom_import is not None:
_, machine, _ = self._active_bom_import
self._operation_phase(machine.state.phase, message)
else:
self.summary.setText(message)
def _summary(self):
count = self.table.plan_model.rowCount()
batch = self._active_bom_batch()
self.save_button.setText('保存本批位号计划' if batch else '保存位号计划')
status = self._bom_statuses.get(self._report_scope(self.task_id))
if status:
self.summary.setText(status)
state = self.bom_import_state
if state.message:
self.summary.setText(state.message)
return
if batch:
self.summary.setText(f'本批 BOM 已匹配 {len(batch.projects)} 个工程;表格显示当前工程,切换任务可编辑,'
@@ -440,7 +465,11 @@ class ProjectPlanPanel(QWidget):
self.window._update_gates()
def set_plan_editable(self, editable, *, busy=False):
self._editable = bool(editable)
self._editable = bool(editable) and not self.bom_import_state.busy
if self._active_bom_import is not None:
state = self._active_bom_import[1].state
self.stop_button.setVisible(state.busy)
self.stop_button.setEnabled(state.can_cancel)
self.table.set_plan_editable(self._editable)
for widget in (self.collect_button, self.save_button, self.import_button, self.import_bom_button,
self.select_all, self.select_none, self.bulk_part, self.bulk_apply):
@@ -451,8 +480,9 @@ class ProjectPlanPanel(QWidget):
and bool(self.table.plan_model.rowCount()) and not self.table.dirty)
self.export_bom_button.setEnabled(not busy)
def _dispatch(self, operation, callback, button):
self.window._run_async(operation, callback, button, expected_task_id=self.task_id)
def _dispatch(self, operation, callback, button, *, retain_result=False):
self.window._run_async(operation, callback, button, expected_task_id=self.task_id,
retain_result=retain_result)
self.window._update_gates()
def collect(self):
@@ -469,7 +499,7 @@ class ProjectPlanPanel(QWidget):
self._saved, self.collect_button)
def _saved(self, rows):
self._bom_statuses.pop(self._report_scope(self.task_id), None)
self._clear_bom_notice()
self._drafts.pop(self.task_id, None)
self.table.populate(rows)
self.window._load_task_data()
@@ -520,8 +550,8 @@ class ProjectPlanPanel(QWidget):
if path:
task_id = self.task_id
scope = self._report_scope(task_id)
self._dispatch_cancellable(lambda stop, progress: self.window.service.inspect_bom_batch(
task_id, Path(path), stop_event=stop, on_progress=progress),
self._dispatch_cancellable(lambda stop, progress, phase: self.window.service.inspect_bom_batch(
task_id, Path(path), stop_event=stop, on_progress=progress, on_phase=phase),
lambda report: self._received_bom_report(report, scope=scope), self.import_bom_button,
bom_scope=scope)
@@ -549,20 +579,23 @@ class ProjectPlanPanel(QWidget):
self.report_toggle.setChecked(False)
def _restore_bom_report(self, scope):
cached = self._bom_reports.get(scope)
self.last_bom_report = cached[0] if cached else None
self.report_text = cached[1] if cached else ''
self.report_toggle.setText(cached[2] if cached else '')
self.report_toggle.setVisible(bool(cached))
if not cached:
machine = self._bom_imports.get(scope)
state = machine.state if machine is not None else BomImportState()
self.last_bom_report = state.report
_, self.report_text, title = self._format_bom_report(state)
self.report_toggle.setText(title)
self.report_toggle.setVisible(state.report is not None)
if state.report is None:
self.report_toggle.setChecked(False)
if self.report_dialog is not None:
self.report_dialog.set_text(self.report_text)
def _received_bom_report(self, report, *, scope=None):
scope = scope or self._report_scope(self.task_id)
self._bom_statuses.pop(scope, None)
outcome = '校验未通过' if report.preview is None else '校验通过'
@staticmethod
def _format_bom_report(state):
report = state.report
if report is None:
return '', '', ''
outcome = '校验通过' if state.phase is BomImportPhase.PREVIEW_READY else '校验未通过'
summary = (f'BOM {outcome}:共 {report.total_rows} 行,通过 {report.passed_rows} 行、'
f'失败 {report.failed_rows} 行、未检查 {report.unchecked_rows} 行;'
f'共 {report.total_projects} 个工程,通过 {report.passed_projects} 个、'
@@ -572,21 +605,35 @@ class ProjectPlanPanel(QWidget):
f'({row.project_path or "无工程路径"})· '
f'{ {"passed": "通过", "failed": "失败", "unchecked": "未检查"}[row.status]}:{row.reason}'
for row in report.rows)
if report.preview is None:
if state.notice:
details.append(state.notice)
elif report.preview is None:
details.append('本次未暂存或保存新计划,原有预览和编辑保留;请修正后重新导入。')
else:
details.append('校验通过,已暂存预览;请确认后保存本批位号计划。')
title = f'本批 BOM {outcome} · 通过 {report.passed_rows} / 失败 {report.failed_rows} / 未检查 {report.unchecked_rows} 行 · 详情'
self._bom_reports[scope] = (report, '\n'.join(details), title)
if scope != self._report_scope(self.task_id):
return
if hasattr(self.window, '_set_operator_message'):
self.window._set_operator_message(summary, 'error' if report.preview is None else 'info')
self._restore_bom_report(scope)
return summary, '\n'.join(details), title
def _received_bom_report(self, report, *, scope=None):
scope = scope or self._report_scope(self.task_id)
machine = self._bom_imports.setdefault(scope, BomImportMachine())
# Direct report presentation (e.g. restoring a stored result) uses the same transitions.
if machine.state.report is not report:
if machine.state.busy:
return
attempt = machine.start()
machine.receive(attempt, report)
machine.finish(attempt)
if scope == self._report_scope(self.task_id):
if hasattr(self.window, '_set_operator_message'):
summary, _, _ = self._format_bom_report(machine.state)
self.window._set_operator_message(summary, 'error' if report.preview is None else 'info')
self._restore_bom_report(scope)
if report.preview is not None:
self._preview_bom(report.preview)
else:
elif scope == self._report_scope(self.task_id):
self._summary()
self.window._update_gates()
def _active_bom_batch(self):
return next((batch for batch in (*self._bom_batches.values(), *self._orphaned_bom_batches.values())
@@ -631,7 +678,7 @@ class ProjectPlanPanel(QWidget):
self._changed()
def _saved_bom_batch(self, saved):
self._bom_statuses.pop(self._report_scope(self.task_id), None)
self._clear_bom_notice()
self._release_bom_previews(saved)
for task_id in saved:
self._drafts.pop(task_id, None)
+12
View File
@@ -83,6 +83,18 @@ def test_distinct_sheet_selectors_and_multiple_new_parts_are_not_duplicates(batc
assert 'Excel' in messages[0]
def test_service_emits_explicit_import_phases_for_each_project(batch, tmp_path):
from dx_productivity.trial_task_center.bom_import_state import BomImportPhase as Phase
service, store, tasks, targets, calls = batch
phases = []
report = service.inspect_bom_batch(tasks[0].task_id,
write_bom_template(tmp_path / 'phases.xlsx', records_for(tasks, targets)),
on_phase=lambda phase, message: phases.append(phase))
assert report.preview
assert phases == [Phase.READING, Phase.VALIDATING, Phase.INVENTORY, Phase.MATCHING,
Phase.INVENTORY, Phase.MATCHING]
def test_cancel_and_native_cleanup_errors_propagate_without_next_project(batch, tmp_path):
service, store, tasks, targets, calls = batch
path = write_bom_template(tmp_path / 'bom.xlsx', records_for(tasks, targets))
+66
View File
@@ -0,0 +1,66 @@
"""Import lifecycle rules, independently of Qt and native CAD."""
import pytest
from dx_productivity.trial_task_center.bom_import_report import BomImportReport
from dx_productivity.trial_task_center.bom_import_state import BomImportMachine, BomImportPhase as Phase
from dx_productivity.trial_task_center.errors import TaskCenterError
def test_retry_rejects_late_progress_results_and_finish_from_previous_attempt():
machine = BomImportMachine()
old = machine.start()
report = BomImportReport((), (), errors=('bad file',))
assert machine.receive(old, report)
assert machine.state.phase is Phase.REJECTED
assert machine.state.busy # The worker still owns its resources.
with pytest.raises(RuntimeError):
machine.start()
machine.finish(old)
current = machine.start()
assert machine.state.report is None and machine.state.phase is Phase.READING
assert not machine.progress(old, Phase.MATCHING, 'late progress')
assert not machine.receive(old, report)
assert not machine.finish(old, error=RuntimeError('late error'))
assert machine.state.attempt == current and machine.state.busy
def test_transitions_prevent_regression_but_allow_the_next_project():
machine = BomImportMachine()
token = machine.start()
assert not machine.progress(token, Phase.MATCHING, 'skip validation')
assert machine.progress(token, Phase.VALIDATING, 'validate')
assert machine.progress(token, Phase.INVENTORY, 'first project')
assert machine.progress(token, Phase.MATCHING, 'match first')
assert not machine.progress(token, Phase.VALIDATING, 'late validation')
assert machine.progress(token, Phase.INVENTORY, 'second project')
assert machine.progress(token, Phase.MATCHING, 'match second')
assert machine.cancel(token)
assert machine.state.phase is Phase.CANCELLING and machine.state.busy
assert not machine.state.can_cancel
assert not machine.progress(token, Phase.INVENTORY, 'late progress')
assert not machine.receive(token, BomImportReport((), ()))
assert machine.finish(token)
assert machine.state.phase is Phase.CANCELLED and not machine.state.busy
def test_cleanup_failure_takes_priority_over_requested_cancellation():
machine = BomImportMachine()
token = machine.start()
machine.cancel(token)
machine.finish(token, error=TaskCenterError('native_cleanup', 'cleanup failed'))
assert machine.state.phase is Phase.FAILED
assert 'cleanup failed' in machine.state.message
assert not machine.state.busy
def test_ready_preview_is_separate_from_saved_or_discarded_plan():
machine = BomImportMachine()
token = machine.start()
report = BomImportReport((), (), preview=object())
assert machine.receive(token, report)
assert not machine.state.can_cancel
assert not machine.progress(token, Phase.READING, 'late message')
machine.finish(token)
machine.release_preview(saved=True)
assert machine.state.phase is Phase.PREVIEW_READY
assert machine.state.report.preview is None and '已保存' in machine.state.notice
+36
View File
@@ -150,3 +150,39 @@ def test_cancelling_bom_file_picker_keeps_previous_report(window, qtbot, monkeyp
assert panel.last_bom_report is report
assert '原有报告' in panel.report_text
assert not window._workers
def test_import_phases_drive_ui_and_cancelling_cannot_be_overwritten(window, qtbot, monkeypatch):
from dx_productivity.trial_task_center.bom_import_state import BomImportPhase
task = window.service.create_task('Phased import')
window.open_task(task.task_id)
qtbot.waitUntil(lambda: not window._loading and not window._context_query.busy)
panel = window.plan_panel
assert panel.bom_import_state.phase is BomImportPhase.IDLE
release = Event()
def inspect(*args, **kwargs):
phase = kwargs['on_phase']
phase(BomImportPhase.VALIDATING, 'validate rows')
phase(BomImportPhase.INVENTORY, 'read inventory')
phase(BomImportPhase.MATCHING, 'match rows')
assert release.wait(5)
phase(BomImportPhase.INVENTORY, 'late next project')
return BomImportReport((), (), errors=('late report',))
monkeypatch.setattr(window.service, 'inspect_bom_batch', inspect)
monkeypatch.setattr(QFileDialog, 'getOpenFileName', lambda *args: ('phased.xlsx', ''))
panel.import_bom()
try:
qtbot.waitUntil(lambda: panel.bom_import_state.phase is BomImportPhase.MATCHING)
panel._summary()
assert panel.summary.text() == 'match rows'
assert not panel.import_bom_button.isEnabled()
assert panel.stop_button.isEnabled()
panel.cancel_operation()
assert panel.bom_import_state.phase is BomImportPhase.CANCELLING
assert not panel.stop_button.isEnabled()
finally:
release.set()
qtbot.waitUntil(lambda: not window._workers)
assert panel.bom_import_state.phase is BomImportPhase.CANCELLED
assert not panel.bom_import_state.busy
assert panel.last_bom_report is None and '已取消' in panel.summary.text()