fix: share batch defaults and protect BOM drafts across task lifecycle

This commit is contained in:
阿白叔 committed 2026-10-15 16:44:11 +08:00
1 parent a1f924295c
commit b47059587a
16 files changed
+961 -79

No files matched your search

@@ -0,0 +1,164 @@
"""Transactional batch defaults, kept separate from per-component choices."""
from dataclasses import replace
from .errors import TaskCenterError
from .models import TaskStatus
from .rule_validation import validate_mapping_pairs
def members(store, task_id):
task = store.get_task(task_id)
if not task.group_id:
return (task,)
return tuple(t for t in store.list_project_group(task.group_id) if t.status is not TaskStatus.DELETED)
def _signature(rule):
return (rule.old_part_number.casefold(), rule.new_part_number, rule.enabled,
rule.custom_value_enabled, rule.custom_value, rule.sync_nc)
def batch_rule_view(store, task_id, *, strict=False):
"""Read legacy groups too; expose conflicting rows so users can resolve them."""
with store.transaction():
tasks = members(store, task_id)
task = store.get_task(task_id)
if task.status is TaskStatus.DELETED or not task.group_id:
return store.list_rules(task_id)
seen, result = {}, []
local = {r.old_part_number.casefold(): r for r in store.list_rules(task_id)}
for item in tasks:
for rule in store.list_rules(item.task_id):
key = rule.old_part_number.casefold()
if key in seen and seen[key] != _signature(rule):
if strict:
raise TaskCenterError('batch_rules_conflict', f'同批料号规则不一致:{rule.old_part_number},请编辑该规则统一默认值')
result.append(rule)
elif key not in seen:
seen[key] = _signature(rule)
preferred = local.get(key)
result.append(preferred if preferred and _signature(preferred) == _signature(rule) else rule)
if strict:
validate_mapping_pairs((r.old_part_number, r.new_part_number) for r in result if r.enabled)
return tuple(result)
def _options(rule):
return dict(old_part_number=rule.old_part_number, new_part_number=rule.new_part_number,
enabled=rule.enabled, custom_value_enabled=rule.custom_value_enabled,
custom_value=rule.custom_value, sync_nc=rule.sync_nc)
def seed_defaults(rows, rules):
"""Fill new inventory rows only; callers retain every existing edited row."""
defaults = {r.old_part_number.casefold(): r for r in rules if r.enabled}
return tuple(replace(row, new_part_number=rule.new_part_number,
custom_value_enabled=rule.custom_value_enabled,
custom_value=rule.custom_value, sync_nc=rule.sync_nc)
if (rule := defaults.get(row.target.old_part_number.casefold())) else row for row in rows)
def _propagate(store, task_id, before, after):
if not store.get_task(task_id).target_plan_mode:
return
rows = store.list_target_plan(task_id)
defaults_before = {r.old_part_number.casefold(): r for r in before}
defaults_after = {r.old_part_number.casefold(): r for r in after}
updated = []
for row in rows:
key = row.target.old_part_number.casefold()
prior, rule = defaults_before.get(key), defaults_after.get(key)
changes = {}
if rule:
# A rule's enabled flag controls discovery, never the user's selection.
if prior:
for field in ('new_part_number', 'sync_nc'):
if getattr(row, field) == getattr(prior, field):
changes[field] = getattr(rule, field)
if (row.custom_value_enabled, row.custom_value) == (prior.custom_value_enabled, prior.custom_value):
changes.update(custom_value_enabled=rule.custom_value_enabled, custom_value=rule.custom_value)
elif not row.new_part_number:
changes['new_part_number'] = rule.new_part_number
if row.sync_nc:
changes['sync_nc'] = rule.sync_nc
if not row.custom_value_enabled and not row.custom_value:
changes.update(custom_value_enabled=rule.custom_value_enabled, custom_value=rule.custom_value)
updated.append(replace(row, **changes))
if tuple(updated) != rows:
store.replace_target_plan(task_id, updated)
def mutate_batch_rules(service, task_id, operation, *, rule_id=None, offset=0, **options):
store = service._store
with store.transaction():
task = store.get_task(task_id)
tasks = members(store, task_id)
if task.status is TaskStatus.DELETED or not tasks:
raise TaskCenterError('rules_locked', '已删除任务不能编辑料号规则')
for member in tasks:
if member.group_id and member.status not in {TaskStatus.DRAFT, TaskStatus.READY, TaskStatus.FAILED}:
raise TaskCenterError('rules_locked', f'同批任务「{member.name}」已冻结,不能修改本批料号规则')
service._editable_rules(member.task_id, lambda: None)
before = {t.task_id: store.list_rules(t.task_id) for t in tasks}
selected = store.get_rule(rule_id) if rule_id else None
selected_key = selected.old_part_number.casefold() if selected else None
if operation == 'update':
for field in ('custom_value_enabled', 'custom_value', 'sync_nc'):
if options.get(field) is None:
options[field] = getattr(selected, field)
union = {}
# Existing per-project rules are merged when unambiguous. An explicit
# edit/delete may resolve its own old-number conflict, never other keys.
for rules in before.values():
local_keys = set()
for rule in rules:
key = rule.old_part_number.casefold()
if key in local_keys:
raise TaskCenterError('batch_rules_conflict', f'同批旧料号重复:{rule.old_part_number},请先整理重复规则')
local_keys.add(key)
if key in union and _signature(union[key]) != _signature(rule):
if key != selected_key or operation not in {'update', 'delete'}:
raise TaskCenterError('batch_rules_conflict', f'同批料号规则不一致:{rule.old_part_number},请编辑该规则统一默认值')
else:
union.setdefault(key, rule)
for member in tasks:
local = {r.old_part_number.casefold(): r for r in before[member.task_id]}
if selected_key in local and operation in {'update', 'delete'}:
# Resolve a historical chain/conflict before copying other keys.
# Disabling is temporary and remains inside this batch transaction.
prior = local[selected_key]
if operation == 'delete':
store.delete_rule(prior.rule_id)
del local[selected_key]
else:
store.update_rule(prior.rule_id, **(_options(prior) | {'enabled': False}))
for key, rule in union.items():
if key == selected_key and operation == 'delete':
continue
if key not in local:
settings = _options(rule)
if key == selected_key and operation == 'update':
settings['enabled'] = False
local[key] = store.add_rule(member.task_id, **settings)
# Historical per-project additions may have different positions.
# Normalize to the same batch order before applying a relative move.
store._write_rule_positions([local[key] for key in union if key in local])
if operation == 'add':
if options['old_part_number'].strip().casefold() in local:
raise TaskCenterError('batch_rules_conflict', '该旧料号已有本批规则,请编辑已有规则')
result = store.add_rule(member.task_id, **options)
elif operation == 'update':
new_key = options['old_part_number'].strip().casefold()
if new_key != selected_key and new_key in local:
raise TaskCenterError('batch_rules_conflict', '该旧料号已有本批规则,请编辑已有规则')
result = store.update_rule(local[selected_key].rule_id, **options)
elif operation == 'delete':
result = None
elif operation == 'move':
result = store.move_rule(local[selected_key].rule_id, offset)
else:
raise ValueError(operation)
_propagate(store, member.task_id, before[member.task_id], store.list_rules(member.task_id))
if member.task_id == task_id:
chosen = result
return chosen
@@ -81,14 +81,16 @@ def preview_batch(service, task_id, path, *, stop_event=None, on_progress=None):
for key in grouped:
_assert_editable(service, owners[key][0].task_id)
projects = []
for task, project in scope:
selected = tuple((task, project) for task, project in scope
if str(project.path.resolve()).casefold() in grouped)
for index, (task, project) in enumerate(selected, 1):
check_cancelled()
key = str(project.path.resolve()).casefold()
if key not in grouped:
continue
baseline = tuple(store.list_target_plan(task.task_id))
if on_progress is not None:
on_progress(f'正在读取工程「{task.name}」({project.path})')
def progress(message):
if on_progress is not None:
on_progress(f'工程 {index}/{len(selected)} · {message}')
progress(f'正在读取工程「{task.name}」({project.path})')
check_cancelled()
try:
requested = tuple(dict.fromkeys(record.old for record in grouped[key]))
@@ -102,7 +104,7 @@ def preview_batch(service, task_id, path, *, stop_event=None, on_progress=None):
if stop_event is not None:
controls['stop_event'] = stop_event
if on_progress is not None:
controls['on_progress'] = on_progress
controls['on_progress'] = progress
inventory = tuple(preparer.collect_inventory(project.path, parts, **controls))
check_cancelled()
merged = merge_target_inventory(baseline, inventory)
@@ -120,6 +122,7 @@ def preview_batch(service, task_id, path, *, stop_event=None, on_progress=None):
raise TaskCenterError(error.code, f'工程「{task.name}」({project.path}):{error.message}',
error_id=error.error_id, traceback_detail=error.traceback_detail) from error
projects.append(BomProjectPreview(task.task_id, project.path, baseline, inventory, rows))
progress(f'「{task.name}」匹配完成:{sum(row.enabled for row in rows)}/{len(rows)} 个位号启用')
check_cancelled()
return BomBatchPreview(task_id, _identity(scope), tuple(projects))
@@ -0,0 +1,18 @@
"""Reuse the replacement engine's mapping constraints for persisted and batch rules."""
import csv
import io
from pathlib import Path
from dx_productivity.part_replace.inputs import InputError, parse_mapping_bytes
from .errors import TaskCenterError
def validate_mapping_pairs(pairs):
output = io.StringIO(newline='')
writer = csv.writer(output, lineterminator='\n')
writer.writerow(('old_part_number', 'new_part_number'))
writer.writerows(pairs)
try:
parse_mapping_bytes(output.getvalue().encode('utf-8'), Path('task-center-rules.csv'))
except InputError as error:
raise TaskCenterError(error.code, error.message) from error
@@ -25,6 +25,8 @@ from .bom_plan import read_bom_plan as _read_bom_plan
from .project_context import ProjectTaskContext
from .execution_metrics import measure_phase
from .read_control import QueryCancelled
from .batch_rules import batch_rule_view, mutate_batch_rules, seed_defaults
from .operation_control import check_cancelled, control_options, report_progress
_Result = TypeVar("_Result")
@@ -140,16 +142,31 @@ class TaskCenterService:
return self._operation("export_bom_template", task_id,
lambda: export_template(self._store, task_id, path))
def preview_bom_batch(self, task_id: str, path: Path):
def preview_bom_batch(self, task_id: str, path: Path, *, stop_event=None, on_progress=None):
from .bom_batch import preview_batch
return self._idle_quick_run_operation('preview_bom_batch', task_id,
lambda: preview_batch(self, task_id, path))
lambda: preview_batch(self, task_id, path, **control_options(stop_event, on_progress)))
def save_bom_batch(self, preview, rows_by_task):
from .bom_batch import save_batch
return self._idle_quick_run_operation('save_bom_batch', preview.anchor_task_id,
lambda: save_batch(self, preview, rows_by_task))
def save_plan_drafts(self, batches, standalone):
"""Confirm all window drafts atomically, including multiple BOM batches."""
from .bom_batch import save_batch, _assert_editable
batches = tuple(batches)
def save():
result = {}
with self._store.transaction():
for preview, rows in batches:
result.update(save_batch(self, preview, rows))
for task_id, rows in standalone.items():
_assert_editable(self, task_id)
result[task_id] = self._store.replace_target_plan(task_id, rows)
return result
return self._idle_quick_run_operation('save_plan_drafts', None, save)
def for_project_task(self, task_id: str) -> "TaskCenterService":
"""Return a facade whose evidence root is isolated to this task."""
return self._facade_for_task_record(self._store.get_task(task_id), force=True)
@@ -226,7 +243,7 @@ class TaskCenterService:
legacy = bound is None
if not allow_legacy and (task.primary_project_id is None or bound is None or len(projects) != 1):
raise TaskCenterError("project_binding", "bound task must own exactly one project")
rules, targets = bundle.rules, bundle.targets
rules, targets = (batch_rule_view(self._store, task_id) if task.group_id else bundle.rules), bundle.targets
facade = self._facade_for_task_record(task)
effective_rules = compile_target_rules(tuple(targets)) if task.target_plan_mode else rules
snapshot = facade._quick_run_preparer.read_snapshot(task_id, projects, effective_rules,
@@ -269,7 +286,7 @@ class TaskCenterService:
return self._idle_quick_run_operation("purge_task", task_id, purge)
def rules(self, task_id: str) -> tuple[RuleRecord, ...]:
return self._operation("list_rules", task_id, lambda: self._store.list_rules(task_id))
return self._operation("list_rules", task_id, lambda: batch_rule_view(self._store, task_id))
def _execution_rules(self, task_id: str):
task = self._store.get_task(task_id)
@@ -279,7 +296,7 @@ class TaskCenterService:
if not rules:
raise TaskCenterError("enabled_rule_required", "target plan has no enabled targets")
return rules
return self._store.list_rules(task_id)
return batch_rule_view(self._store, task_id, strict=True)
def add_rule(
self,
@@ -295,17 +312,14 @@ class TaskCenterService:
return self._idle_quick_run_operation(
"add_rule",
task_id,
lambda: self._editable_rules(
task_id,
lambda: self._store.add_rule(
task_id,
old_part_number,
new_part_number,
lambda: mutate_batch_rules(
self, task_id, 'add',
old_part_number=old_part_number,
new_part_number=new_part_number,
enabled=enabled,
custom_value_enabled=custom_value_enabled,
custom_value=custom_value,
sync_nc=sync_nc,
),
),
)
@@ -323,17 +337,14 @@ class TaskCenterService:
return self._idle_quick_run_operation(
"update_rule",
None,
lambda: self._editable_rules(
self._store.get_rule(rule_id).task_id,
lambda: self._store.update_rule(
rule_id,
lambda: mutate_batch_rules(
self, self._store.get_rule(rule_id).task_id, 'update', rule_id=rule_id,
old_part_number=old_part_number,
new_part_number=new_part_number,
enabled=enabled,
custom_value_enabled=custom_value_enabled,
custom_value=custom_value,
sync_nc=sync_nc,
),
),
)
@@ -341,26 +352,32 @@ class TaskCenterService:
self._idle_quick_run_operation(
"delete_rule",
None,
lambda: self._editable_rules(self._store.get_rule(rule_id).task_id, lambda: self._store.delete_rule(rule_id)),
lambda: mutate_batch_rules(self, self._store.get_rule(rule_id).task_id, 'delete', rule_id=rule_id),
)
def move_rule(self, rule_id: str, offset: int) -> tuple[RuleRecord, ...]:
return self._idle_quick_run_operation(
"move_rule",
None,
lambda: self._editable_rules(self._store.get_rule(rule_id).task_id, lambda: self._store.move_rule(rule_id, offset)),
lambda: mutate_batch_rules(self, self._store.get_rule(rule_id).task_id, 'move', rule_id=rule_id, offset=offset),
)
def projects(self, task_id: str) -> tuple[ProjectRecord, ...]:
return self._operation("list_projects", task_id, lambda: self._store.list_projects(task_id))
def collect_target_inventory(self, task_id: str, old_part_numbers: tuple[str, ...] | None = None):
def collect_target_inventory(self, task_id: str, old_part_numbers: tuple[str, ...] | None = None,
*, stop_event=None, on_progress=None):
delegated = self._project_task_service(task_id)
if delegated is not self:
return delegated.collect_target_inventory(task_id, old_part_numbers)
return delegated.collect_target_inventory(task_id, old_part_numbers, **control_options(stop_event, on_progress))
def collect():
rules = self._store.list_rules(task_id)
parts = old_part_numbers or tuple(rule.old_part_number for rule in rules if rule.enabled)
from .bom_batch import _assert_editable
_assert_editable(self, task_id)
check_cancelled(stop_event)
rules = batch_rule_view(self._store, task_id, strict=True)
prior = self._store.list_target_plan(task_id)
requested = old_part_numbers or tuple(rule.old_part_number for rule in rules if rule.enabled)
parts = tuple(dict.fromkeys((*requested, *(row.target.old_part_number for row in prior))))
if not parts:
raise TaskCenterError("target_inventory", "add an old Part Number before collecting inventory")
project = self._store.list_projects(task_id)
@@ -368,25 +385,20 @@ class TaskCenterService:
raise TaskCenterError("target_inventory", "target inventory requires one project task")
with measure_phase(self._logging, task_id, 'collect_inventory', unit='component',
project_path=str(project[0].path)) as metric:
rows = collect_target_inventory(self._quick_run_preparer, project[0].path, parts)
report_progress(on_progress, f'正在采集工程:{project[0].display_name}')
rows = collect_target_inventory(self._quick_run_preparer, project[0].path, parts,
**control_options(stop_event, on_progress))
check_cancelled(stop_event)
metric['completed_units'] = len(rows)
prior = self._store.list_target_plan(task_id)
current = self._store.record_target_inventory(task_id, rows)
if not current:
return ()
if prior:
return current
existing = {row.target.key: row for row in current}
from .target_plan import TargetPlanRow
return self._store.replace_target_plan(task_id, tuple(
TargetPlanRow(row, False, next((r.new_part_number for r in rules
if r.old_part_number.casefold() == row.old_part_number.casefold()), ""),
next((r.custom_value_enabled for r in rules
if r.old_part_number.casefold() == row.old_part_number.casefold()), False),
next((r.custom_value for r in rules
if r.old_part_number.casefold() == row.old_part_number.casefold()), ""),
next((r.sync_nc for r in rules
if r.old_part_number.casefold() == row.old_part_number.casefold()), True)) for row in rows))
with self._store.transaction():
if self._store.list_target_plan(task_id) != prior:
raise TaskCenterError('target_identity', '位号计划在采集时已改变,请重新采集')
current = self._store.record_target_inventory(task_id, rows)
known = {row.target.key: row for row in prior}
seeded = seed_defaults(current, rules)
result = tuple(known.get(row.target.key, row) for row in seeded)
check_cancelled(stop_event)
return self._store.replace_target_plan(task_id, result)
return self._idle_quick_run_operation("collect_target_inventory", task_id, collect)
def scan_projects(self, task_id: str, root: Path) -> tuple[ProjectRecord, ...]:
+2 -11
View File
@@ -6,16 +6,14 @@ from collections.abc import Iterator, Sequence
from contextlib import contextmanager
from dataclasses import dataclass
from datetime import datetime, timedelta, timezone
import csv
import hashlib
import io
import os
from pathlib import Path
import sqlite3
import threading
from uuid import uuid4
from dx_productivity.part_replace.inputs import InputError, parse_mapping_bytes
from .rule_validation import validate_mapping_pairs
from .store_schema import StoreSchema, _SCHEMA_VERSION
from .store_target_plan import TargetPlanRepository
@@ -973,14 +971,7 @@ class TaskStore:
"SELECT old_part_number, new_part_number FROM rules WHERE task_id = ? AND enabled = 1 ORDER BY position",
(task_id,),
).fetchall()
output = io.StringIO(newline="")
writer = csv.writer(output, lineterminator="\n")
writer.writerow(("old_part_number", "new_part_number"))
writer.writerows((row["old_part_number"], row["new_part_number"]) for row in rows)
try:
parse_mapping_bytes(output.getvalue().encode("utf-8"), Path("task-center-rules.csv"))
except InputError as error:
raise TaskCenterError(error.code, error.message) from error
validate_mapping_pairs((row['old_part_number'], row['new_part_number']) for row in rows)
def _rule_row(self, rule_id: str) -> sqlite3.Row:
row = self._connection.execute("SELECT * FROM rules WHERE rule_id = ?", (rule_id,)).fetchone()
@@ -4,7 +4,7 @@ from threading import Event
import time
from PySide6.QtCore import QElapsedTimer, QSettings, QSignalBlocker, QThreadPool, QTimer, Qt
from PySide6.QtWidgets import (QApplication, QDialog, QHBoxLayout, QMainWindow, QMessageBox,
QPushButton, QSplitter, QTabWidget, QVBoxLayout, QWidget)
QPushButton, QLabel, QSplitter, QTabWidget, QVBoxLayout, QWidget)
from ..errors import TaskCenterError
from ..models import TaskStatus
from ..version import VERSION
@@ -23,13 +23,17 @@ from .task_log import TaskLogPresenter
from .execution_feedback import format_feedback
class TrialTaskCenterWindow(QMainWindow):
def __init__(self, service, directory_picker=None, quick_run_confirmer=None):
def __init__(self, service, directory_picker=None, quick_run_confirmer=None, close_plan_confirmer=None):
super().__init__()
self.service = service
self._close_plan_confirmer = close_plan_confirmer or self._confirm_close_plans
self._close_pending = False
self._close_saving = False
self._quick_run_confirmer = quick_run_confirmer or self._confirm_quick_run
self._task_id = None
self._context = None
self._tasks = ()
self._known_task_groups = {}
self._workers = set()
self._closed = False
self._batch_stop = None
@@ -52,6 +56,7 @@ class TrialTaskCenterWindow(QMainWindow):
self.setStyleSheet(APP_STYLESHEET)
self.task_list = TaskList(self.open_task)
self.task_list.filter.currentTextChanged.connect(self._refresh_task_list)
self.task_list.recycle_button.toggled.connect(self._refresh_task_list)
self.task_list.new_button.clicked.connect(self._new_task)
self.task_list.edit_button.clicked.connect(self._edit_task)
self.task_list.delete_button.clicked.connect(self._delete_task)
@@ -100,6 +105,10 @@ class TrialTaskCenterWindow(QMainWindow):
rule_page = QWidget()
rules_layout = QVBoxLayout(rule_page)
rules_layout.setContentsMargins(0, 0, 0, 0)
rules_help = QLabel('规则提供采集条件和位号默认值;位号计划模式实际执行已保存的每行计划。'
'修改默认值仅更新仍等于旧默认值的字段,保留手动覆盖和替换勾选。')
rules_help.setWordWrap(True)
rules_layout.addWidget(rules_help)
rules_layout.addWidget(self.mapping_table, 1)
commands = QHBoxLayout()
for button in (self.add_mapping_button, self.edit_mapping_button, self.delete_mapping_button,
@@ -141,12 +150,46 @@ class TrialTaskCenterWindow(QMainWindow):
self.detail_splitter.setSizes((190,))
self.run_panel.toggle_log_button.setChecked(False)
def _confirm_close_plans(self):
box = QMessageBox(self)
box.setWindowTitle('未保存位号计划')
box.setText('当前或其他任务仍有未保存的位号计划 / BOM 预览。')
save = box.addButton('保存全部', QMessageBox.ButtonRole.AcceptRole)
discard = box.addButton('放弃', QMessageBox.ButtonRole.DestructiveRole)
cancel = box.addButton('取消', QMessageBox.ButtonRole.RejectRole)
box.setDefaultButton(cancel)
box.exec()
return 'save' if box.clickedButton() is save else 'discard' if box.clickedButton() is discard else 'cancel'
def closeEvent(self, event):
if self._close_saving:
event.ignore()
return
if self._workers:
self._close_pending = True
self.plan_panel.cancel_operation()
self._pause_queue()
self._set_operator_message('操作尚未结束,请等当前步骤安全收尾后关闭。', 'warning')
event.ignore()
return
self._close_pending = False
if self.plan_panel.has_unsaved_plans():
choice = self._close_plan_confirmer()
if choice == 'cancel':
event.ignore()
return
if choice == 'save':
event.ignore()
self._close_saving = True
def saved(_):
self.plan_panel.discard_all()
self._close_pending = True
self._run_async(self.plan_panel.prepare_save_all(), saved)
return
if choice != 'discard':
event.ignore()
return
self.plan_panel.discard_all()
for name, widget in self._layout_widgets().items():
self._layout_settings.setValue(f'single_project/{name}', widget.saveState())
self._layout_settings.setValue('tasks/sort', self.task_list.sort.currentData())
@@ -159,11 +202,14 @@ class TrialTaskCenterWindow(QMainWindow):
super().closeEvent(event)
def _refresh_task_list(self):
deleted = self.task_list.recycle_button.isChecked()
def received(tasks):
self._known_task_groups.update((task.task_id, task.group_id) for task in tasks)
self._tasks = tasks
self.task_list.populate(tasks, selected_task_id=self._task_id)
self._update_gates()
self._task_query.request(lambda control: self.service.tasks(read_control=control), received, self._show_error, cancellable=True)
self._task_query.request(lambda control: self.service.tasks(status=TaskStatus.DELETED, read_control=control)
if deleted else self.service.tasks(read_control=control), received, self._show_error, cancellable=True)
def open_task(self, task_id):
if not task_id or (self._workers and self._batch_stop is None):
@@ -232,17 +278,19 @@ class TrialTaskCenterWindow(QMainWindow):
self.run_panel.stop_queue_button.setVisible(self._batch_stop is not None)
self.run_panel.stop_queue_button.setEnabled(bool(self._batch_stop and not self._batch_stop.is_set()))
self.run_panel.copy_value_check.setEnabled(state.editable)
self.mapping_table.set_rules_editable(state.editable)
rule_editable = state.editable and not self._group_has_unsaved_plans()
self.mapping_table.set_rules_editable(rule_editable)
self.plan_panel.set_plan_editable(state.editable, busy=busy)
self.add_mapping_button.setEnabled(state.editable)
self.add_mapping_button.setEnabled(rule_editable)
selected = self.mapping_table.current_rule_id() is not None
for button in (self.edit_mapping_button, self.delete_mapping_button,
self.move_mapping_up_button, self.move_mapping_down_button):
button.setEnabled(state.editable and selected)
button.setEnabled(rule_editable and selected)
self.project_summary.refresh_button.setEnabled(bool(context and not context.legacy and not busy))
self.task_list.list.setEnabled(not self._workers or self._batch_stop is not None)
self.task_list.filter.setEnabled(not self._workers or self._batch_stop is not None)
self.task_list.search.setEnabled(not self._workers or self._batch_stop is not None)
self.task_list.recycle_button.setEnabled(not busy)
self.task_list.sort.setEnabled(not self._workers or self._batch_stop is not None)
self.task_list.new_button.setEnabled(not busy)
exists = bool(context)
@@ -269,6 +317,26 @@ class TrialTaskCenterWindow(QMainWindow):
if not busy:
self.run_panel.execution_status.setText('结果待核验' if context and context.interrupted else '空闲')
def _group_has_unsaved_plans(self):
if not self._context:
return False
task = self._context.task
ids = {task.task_id}
if task.group_id:
ids.update(task_id for task_id, group in self._known_task_groups.items() if group == task.group_id)
# Preview scope may also contain members no longer in the normal task list.
for batch in self.plan_panel._bom_batches.values():
if ids.intersection(task_id for task_id, _ in batch.scope):
return True
return self.plan_panel.has_unsaved_plan(ids)
def _rules_change_allowed(self):
if self._group_has_unsaved_plans():
self._set_operator_message('本批存在未保存计划,请先保存或放弃草稿后修改规则。', 'warning')
self._load_task_data()
return False
return True
def _new_task(self):
dialog = DirectoryTaskDialog(self.service, self)
if dialog.exec() == QDialog.DialogCode.Accepted:
@@ -277,7 +345,7 @@ class TrialTaskCenterWindow(QMainWindow):
self._project_tasks_created, self.task_list.new_button)
def _project_tasks_created(self, tasks):
self.task_list.filter.setCurrentText('进行中')
self.task_list.recycle_button.setChecked(False)
self._refresh_task_list()
if tasks:
self._task_id = tasks[0].task_id
@@ -318,7 +386,7 @@ class TrialTaskCenterWindow(QMainWindow):
operation = (lambda: self.service.purge_task(task.task_id, confirmed=True)) if permanent else (lambda: self.service.delete_task(task.task_id))
def done(_):
if permanent:
self.plan_panel._drafts.pop(task.task_id, None)
self.plan_panel.forget_task(task.task_id)
self._task_id = None
self._metadata_changed(None)
self._run_async(operation, done, self.task_list.delete_button)
@@ -345,6 +413,8 @@ class TrialTaskCenterWindow(QMainWindow):
self._mapping_dialog(rule)
def _mapping_dialog(self, rule):
if not self._rules_change_allowed():
return
dialog = _MappingDialog(self, *(() if rule is None else (rule.old_part_number, rule.new_part_number,
rule.enabled, rule.custom_value_enabled, rule.custom_value, rule.sync_nc)))
if dialog.exec() != QDialog.DialogCode.Accepted:
@@ -357,16 +427,22 @@ class TrialTaskCenterWindow(QMainWindow):
self._run_async(operation, lambda _: self._load_task_data(), expected_task_id=task_id)
def _delete_mapping(self):
if not self._rules_change_allowed():
return
rule_id = self.mapping_table.current_rule_id()
if rule_id:
self._run_async(lambda: self.service.delete_rule(rule_id), lambda _: self._load_task_data())
def _move_mapping(self, offset):
if not self._rules_change_allowed():
return
rule_id = self.mapping_table.current_rule_id()
if rule_id:
self._run_async(lambda: self.service.move_rule(rule_id, offset), lambda _: self._load_task_data())
def _rule_enabled_changed(self, rule_id, enabled):
if not self._rules_change_allowed():
return
rule = next((r for r in self._context.rules if r.rule_id == rule_id), None) if self._context else None
if rule:
self._run_async(lambda: self.service.update_rule(rule_id, old_part_number=rule.old_part_number,
@@ -552,12 +628,21 @@ class TrialTaskCenterWindow(QMainWindow):
except Exception as error:
self._show_error(error)
def failed(error):
if self._close_saving or not (isinstance(error, TaskCenterError) and error.code == 'operation_cancelled'):
self._close_pending = False
self._finish_run()
if isinstance(error, TaskCenterError) and error.code == 'operation_cancelled':
self._set_operator_message('已取消采集 / 导入,自有会话已安全释放。')
return
if valid():
self._load_task_data()
self._show_error(error, owner_task_id=owner)
def finished():
self._workers.discard(worker)
self.plan_panel.finish_operation()
self._close_saving = False
if self._close_pending and not self._closed:
QTimer.singleShot(0, self.close)
if not self._closed:
self._update_gates()
worker.signals.succeeded.connect(succeeded)
@@ -15,6 +15,10 @@ from .target_table import TargetTable
from .workers import ServiceWorker
class _OperationProgress(QObject):
changed = Signal(str)
class _ScanProgress(QObject):
changed = Signal(object, int, int)
@@ -166,7 +170,12 @@ class ProjectPlanPanel(QWidget):
self.task_id = None
self._drafts = {}
self._bom_batches = {}
self._orphaned_bom_batches = {}
self._editable = False
self._operation_stop = None
self.stop_button = QPushButton("取消采集 / 导入", objectName="cancelInventoryOperation")
self.stop_button.hide()
self.stop_button.clicked.connect(self.cancel_operation)
self.table = TargetTable(self)
self.collect_button = QPushButton('采集所有匹配位号', objectName='collectTargetInventory')
self.save_button = QPushButton('保存位号计划', objectName='saveTargetPlan')
@@ -192,6 +201,7 @@ class ProjectPlanPanel(QWidget):
for button in (self.collect_button, self.save_button, self.import_button, self.export_button,
self.import_bom_button, self.export_bom_button):
actions.addWidget(button)
actions.addWidget(self.stop_button)
actions.addStretch()
selection = QHBoxLayout()
selection.addWidget(self.select_all)
@@ -259,6 +269,81 @@ class ProjectPlanPanel(QWidget):
return any(task_id in self._drafts or
(task_id == self.task_id and self.table.dirty) for task_id in task_ids)
def has_unsaved_plans(self):
return bool(self._drafts or self._bom_batches or self._orphaned_bom_batches or self.table.dirty)
def prepare_save_all(self):
# Snapshot widgets only on the GUI thread; the returned operation uses plain data.
drafts = dict(self._drafts)
if self.task_id and self.table.dirty:
drafts[self.task_id] = self.table.rows()
batches = tuple(self._bom_batches.values()) + tuple(self._orphaned_bom_batches.values())
return lambda: self._save_all_snapshot(drafts, batches)
def save_all(self):
return self.prepare_save_all()()
def _save_all_snapshot(self, drafts, batches):
# Keep every draft until all writes succeed, including on a partial failure.
pending_batches = tuple((batch, {p.task_id: drafts.get(p.task_id, p.rows)
for p in batch.projects}) for batch in batches)
covered = {task_id for _, rows in pending_batches for task_id in rows}
standalone = {task_id: rows for task_id, rows in drafts.items() if task_id not in covered}
return self.window.service.save_plan_drafts(pending_batches, standalone)
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._orphaned_bom_batches.pop(task_id, None)
for owner, batch in tuple(self._orphaned_bom_batches.items()):
self._orphaned_bom_batches[owner] = replace(
batch, scope=tuple(item for item in batch.scope if item[0] != task_id))
batches = {}
for batch in self._bom_batches.values():
scope = tuple(item for item in batch.scope if item[0] != task_id)
projects = tuple(p for p in batch.projects if p.task_id != task_id)
if projects:
anchor = batch.anchor_task_id if batch.anchor_task_id != task_id else projects[0].task_id
batches[tuple(x for x, _ in scope)] = replace(batch, anchor_task_id=anchor,
scope=scope, projects=projects)
self._bom_batches = batches
if self.task_id == task_id:
self.task_id = None
self.table.populate(())
def discard_all(self):
self._drafts.clear()
self._bom_batches.clear()
self._orphaned_bom_batches.clear()
self.table.dirty = False
def cancel_operation(self):
if self._operation_stop is not None:
self._operation_stop.set()
self.stop_button.setEnabled(False)
self.summary.setText('正在取消;等待自有 CAD 会话安全释放…')
def finish_operation(self):
self._operation_stop = None
self.stop_button.hide()
def _dispatch_cancellable(self, operation, callback, button):
if self.window._workers:
return
stop = Event()
self._operation_stop = stop
progress = _OperationProgress(self)
self._operation_progress = progress
progress.changed.connect(self._operation_message)
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 _operation_message(self, message):
if self._operation_stop is not None and not self._operation_stop.is_set():
self.summary.setText(message)
def _summary(self):
rows = self.table.rows()
batch = self._active_bom_batch()
@@ -303,7 +388,8 @@ class ProjectPlanPanel(QWidget):
QMessageBox.StandardButton.No) != QMessageBox.StandardButton.Yes:
return
task_id = self.task_id
self._dispatch(lambda: self.window.service.collect_target_inventory(task_id),
self._dispatch_cancellable(lambda stop, progress: self.window.service.collect_target_inventory(
task_id, stop_event=stop, on_progress=progress),
self._saved, self.collect_button)
def _saved(self, rows):
@@ -356,20 +442,40 @@ class ProjectPlanPanel(QWidget):
path, _ = QFileDialog.getOpenFileName(self, '导入 BOM 模板', '', 'BOM Excel (*.xlsx)')
if path:
task_id = self.task_id
self._dispatch(lambda: self.window.service.preview_bom_batch(task_id, Path(path)),
self._dispatch_cancellable(lambda stop, progress: self.window.service.preview_bom_batch(
task_id, Path(path), stop_event=stop, on_progress=progress),
self._preview_bom, self.import_bom_button)
def _active_bom_batch(self):
return next((batch for batch in self._bom_batches.values()
if self.task_id in {task_id for task_id, _ in batch.scope}), None)
return next((batch for batch in (*self._bom_batches.values(), *self._orphaned_bom_batches.values())
if any(project.task_id == self.task_id for project in batch.projects)), None)
def _preview_bom(self, batch):
if self.task_id and self.table.dirty:
self._drafts[self.task_id] = self.table.rows()
key = tuple(task_id for task_id, _ in batch.scope)
incoming = {project.task_id for project in batch.projects}
existing = self._bom_batches.get(key)
projects = {project.task_id: project for project in existing.projects} if existing else {}
# A membership change invalidates every overlapping scope. Carry forward only
# still-present projects with the same binding, and preserve their local drafts.
identities = dict(batch.scope)
projects = {}
for old_key, existing in tuple(self._bom_batches.items()):
if set(old_key).intersection(key):
old_identities = dict(existing.scope)
projects.update({p.task_id: p for p in existing.projects
if p.task_id in identities and
old_identities.get(p.task_id) == identities[p.task_id]})
for project in existing.projects:
if project.task_id not in projects:
# Draft rows alone cannot reconstruct a never-persisted inventory.
# Keep its original scope so restore can validate the old binding.
self._orphaned_bom_batches[project.task_id] = replace(
existing, anchor_task_id=project.task_id, projects=(project,))
del self._bom_batches[old_key]
for task_id, detached in tuple(self._orphaned_bom_batches.items()):
if task_id in identities and dict(detached.scope).get(task_id) == identities[task_id]:
projects.setdefault(task_id, detached.projects[0])
del self._orphaned_bom_batches[task_id]
projects.update({project.task_id: project for project in batch.projects})
batch = replace(batch, projects=tuple(projects[task_id] for task_id in key if task_id in projects))
self._bom_batches[key] = batch
@@ -385,6 +491,7 @@ class ProjectPlanPanel(QWidget):
def _saved_bom_batch(self, saved):
for task_id in saved:
self._drafts.pop(task_id, None)
self._orphaned_bom_batches.pop(task_id, None)
self._bom_batches = {key: batch for key, batch in self._bom_batches.items()
if not all(project.task_id in saved for project in batch.projects)}
if self.task_id in saved:
@@ -26,6 +26,8 @@ class TaskList(QWidget):
('创建时间:新到旧', 'created_desc'), ('创建时间:旧到新', 'created_asc'),
('最近更新', 'updated_desc')):
self.sort.addItem(label, key)
self.recycle_button = QPushButton('回收站', objectName='taskRecycleBin')
self.recycle_button.setCheckable(True)
self.count = QLabel(objectName='taskCount')
self.filter = QComboBox(objectName="taskFilter")
self.filter.addItems(("进行中", "已完成", "已删除"))
@@ -53,6 +55,7 @@ class TaskList(QWidget):
layout.addWidget(QLabel('任务', objectName='taskSectionTitle'))
layout.addWidget(self.search)
layout.addWidget(self.sort)
layout.addWidget(self.recycle_button)
layout.addWidget(self.count)
layout.addWidget(self.list, 1)
layout.addLayout(actions)
+136
View File
@@ -0,0 +1,136 @@
import pytest
from dx_productivity.trial_task_center.errors import TaskCenterError
from dx_productivity.trial_task_center.logging_setup import configure_logging
from dx_productivity.trial_task_center.models import TaskStatus
from dx_productivity.trial_task_center.service import TaskCenterService
from dx_productivity.trial_task_center.store import TaskStore
from dx_productivity.trial_task_center.target_plan import ComponentTarget, TargetPlanRow
@pytest.fixture
def batch(tmp_path):
root = tmp_path / 'projects'
for name in ('a', 'b'):
folder = root / name
folder.mkdir(parents=True)
(folder / 'board.prj').write_text('KEY FrontEndSnapshot "DxD"\nKEY iCDBDir "database"\n')
store = TaskStore(tmp_path / 'tasks.db')
app = TaskCenterService(store, configure_logging(tmp_path / 'data'))
tasks = app.create_project_tasks(root)
yield app, store, tasks
store.close()
def values(rules):
return [(r.old_part_number, r.new_part_number, r.enabled, r.sync_nc) for r in rules]
def test_rule_crud_and_order_are_shared_across_projects(batch):
app, store, tasks = batch
a, b = (t.task_id for t in tasks)
first = app.add_rule(a, 'OLD', 'NEW')
assert values(app.rules(a)) == values(app.rules(b)) == [('OLD', 'NEW', True, True)]
second = app.add_rule(b, 'OTHER', 'OTHER-NEW', sync_nc=False)
app.move_rule(second.rule_id, -1)
assert values(app.rules(a)) == values(app.rules(b))
assert app.rules(a)[0].old_part_number == 'OTHER'
app.update_rule(first.rule_id, old_part_number='OLD', new_part_number='NEW2', enabled=False)
assert values(app.rules(a)) == values(app.rules(b))
app.delete_rule(first.rule_id)
assert values(app.rules(a)) == values(app.rules(b)) == [('OTHER', 'OTHER-NEW', True, False)]
def test_rule_change_updates_execution_defaults_but_keeps_manual_fields_and_selection(batch):
app, store, tasks = batch
rule = app.add_rule(tasks[0].task_id, 'OLD', 'NEW1')
for task in tasks:
path = store.list_projects(task.task_id)[0].path
targets = tuple(ComponentTarget(path, 'MAIN', '1', f'u{i}', f'R{i}', 'OLD', 'V0') for i in (1, 2, 3))
store.record_target_inventory(task.task_id, targets)
store.replace_target_plan(task.task_id, (
TargetPlanRow(targets[0], True, 'NEW1'),
TargetPlanRow(targets[1], True, 'MANUAL', True, 'custom', False),
TargetPlanRow(targets[2], False, 'NEW1'),
))
app.update_rule(rule.rule_id, old_part_number='OLD', new_part_number='NEW2', enabled=True,
custom_value_enabled=True, custom_value='rule value', sync_nc=False)
for task in tasks:
rows = app.target_plan(task.task_id)
assert [(r.enabled, r.new_part_number) for r in rows] == [(True, 'NEW2'), (True, 'MANUAL'), (False, 'NEW2')]
assert rows[0].custom_value == 'rule value' and not rows[0].sync_nc
assert rows[1].custom_value == 'custom' and not rows[1].sync_nc
effective = app._execution_rules(task.task_id)
assert {r.new_part_number for r in effective} == {'NEW2', 'MANUAL'}
assert app.task_context(task.task_id).targets == rows
def test_frozen_sibling_rejects_entire_rule_mutation(batch):
app, store, tasks = batch
rule = app.add_rule(tasks[0].task_id, 'OLD', 'NEW1')
store.set_task_status(tasks[1].task_id, TaskStatus.READY)
store.set_task_status(tasks[1].task_id, TaskStatus.RUNNING)
before = {t.task_id: app.rules(t.task_id) for t in tasks}
with pytest.raises(TaskCenterError):
app.update_rule(rule.rule_id, old_part_number='OLD', new_part_number='NEW2', enabled=True)
assert before == {t.task_id: app.rules(t.task_id) for t in tasks}
def test_failure_on_sibling_rolls_back_rules_and_target_defaults(batch, monkeypatch):
app, store, tasks = batch
rule = app.add_rule(tasks[0].task_id, 'OLD', 'NEW1')
path = store.list_projects(tasks[0].task_id)[0].path
target = ComponentTarget(path, 'MAIN', '1', 'u', 'R1', 'OLD', '')
store.record_target_inventory(tasks[0].task_id, (target,))
store.replace_target_plan(tasks[0].task_id, (TargetPlanRow(target, True, 'NEW1'),))
original = store.update_rule
def fail(rule_id, **kwargs):
if store.get_rule(rule_id).task_id == tasks[1].task_id:
raise TaskCenterError('injected', 'sibling write failed')
return original(rule_id, **kwargs)
monkeypatch.setattr(store, 'update_rule', fail)
with pytest.raises(TaskCenterError, match='sibling write failed'):
app.update_rule(rule.rule_id, old_part_number='OLD', new_part_number='NEW2', enabled=True)
assert all(app.rules(t.task_id)[0].new_part_number == 'NEW1' for t in tasks)
assert app.target_plan(tasks[0].task_id)[0].new_part_number == 'NEW1'
def test_legacy_group_disagreement_is_reported_instead_of_silent_partial_edit(batch):
app, store, tasks = batch
first = store.add_rule(tasks[0].task_id, 'OLD', 'A')
store.add_rule(tasks[1].task_id, 'OLD', 'B')
with pytest.raises(TaskCenterError, match='不一致'):
app.add_rule(tasks[0].task_id, 'OTHER', 'NEW')
# Editing the conflicting mapping explicitly resolves that old-number rule.
app.update_rule(first.rule_id, old_part_number='OLD', new_part_number='C', enabled=True)
assert all(app.rules(t.task_id)[0].new_part_number == 'C' for t in tasks)
@pytest.mark.parametrize('last_target, code', [('NEW', 'mapping_chain'), ('OLD', 'mapping_cycle')])
def test_legacy_rule_union_is_validated_before_execution_and_collection(batch, last_target, code):
app, store, tasks = batch
store.add_rule(tasks[0].task_id, 'OLD', 'MID')
store.add_rule(tasks[1].task_id, 'MID', last_target)
# Display remains available so a historical conflict can be corrected.
assert len(app.rules(tasks[0].task_id)) == 2
for task in tasks:
with pytest.raises(TaskCenterError) as error:
app._execution_rules(task.task_id)
assert error.value.code == code
with pytest.raises(TaskCenterError) as error:
app.collect_target_inventory(task.task_id)
assert error.value.code == code
@pytest.mark.parametrize('action', ['disable', 'delete'])
def test_historical_chain_can_be_resolved_through_normal_rule_edit(batch, action):
app, store, tasks = batch
store.add_rule(tasks[0].task_id, 'OLD', 'MID')
selected = store.add_rule(tasks[1].task_id, 'MID', 'NEW')
if action == 'disable':
updated = app.update_rule(selected.rule_id, old_part_number='MID', new_part_number='NEW', enabled=False)
assert updated.rule_id == selected.rule_id
else:
app.delete_rule(selected.rule_id)
assert values(app.rules(tasks[0].task_id)) == values(app.rules(tasks[1].task_id))
assert all([r.old_part_number for r in app._execution_rules(t.task_id) if r.enabled] == ['OLD'] for t in tasks)
+3 -1
View File
@@ -112,7 +112,9 @@ def test_preview_forwards_controls_and_reports_projects(batch, tmp_path):
service.for_project_task(task.task_id)._quick_run_preparer.collect_inventory = collect
preview_batch(service, tasks[0].task_id, path, stop_event=event, on_progress=progress.append)
assert all(any(task.name in message for message in progress) for task in tasks)
assert progress.count('reading') == 2
assert sum(message.endswith('reading') for message in progress) == 2
assert any('1/2' in message for message in progress)
assert any('2/2' in message for message in progress)
@pytest.mark.parametrize('change', ['remove', 'old_value'])
def test_bom_extension_rejects_changed_baseline_without_writes(batch, tmp_path, change):
+1
View File
@@ -71,6 +71,7 @@ def test_original_window_edits_target_plan_and_nc_without_export(qtbot, tmp_path
table.item(0, 6).setText('OTHER')
window.plan_panel.bind_task(None)
assert window.plan_panel.has_unsaved_plan((task.task_id,))
window._close_plan_confirmer = lambda: "discard"
window.close()
store.close()
+75
View File
@@ -0,0 +1,75 @@
from dataclasses import replace
from threading import Event
import pytest
from dx_productivity.trial_task_center.bom_plan import write_bom_template
from dx_productivity.trial_task_center.errors import TaskCenterError
from dx_productivity.trial_task_center.logging_setup import configure_logging
from dx_productivity.trial_task_center.service import TaskCenterService
from dx_productivity.trial_task_center.store import TaskStore
from dx_productivity.trial_task_center.target_plan import ComponentTarget, TargetPlanRow
@pytest.fixture
def group(tmp_path):
store = TaskStore(tmp_path / 'tasks.db')
service = TaskCenterService(store, configure_logging(tmp_path / 'data'))
root = tmp_path / 'projects'
root.mkdir()
for name in ('a', 'b'):
(root / (name + '.prj')).write_text('KEY FrontEndSnapshot "DxD"\nKEY iCDBDir "database"\n')
tasks = service.create_project_tasks(root)
targets = {t.task_id: ComponentTarget(store.list_projects(t.task_id)[0].path, 'MAIN', '1', 'u1', 'R1', 'OLD', 'V') for t in tasks}
yield service, store, tasks, targets
store.close()
def test_save_all_rolls_back_confirmed_bom_when_later_standalone_plan_fails(group, tmp_path):
service, store, tasks, targets = group
a, b = (t.task_id for t in tasks)
service.for_project_task(a)._quick_run_preparer.collect_inventory = lambda *args: (targets[a],)
path = write_bom_template(tmp_path / 'a.xlsx', ({'project_path': str(targets[a].project_path),
'old_part_number': 'OLD', 'new_part_number': 'NEW', 'refdes': 'R1'},))
preview = service.preview_bom_batch(a, path)
with pytest.raises(TaskCenterError):
service.save_plan_drafts(((preview, {a: preview.projects[0].rows}),), {b: (TargetPlanRow(targets[b], True, 'NEW'),)})
assert not store.list_target_plan(a)
assert not store.get_task(a).target_plan_mode
# Retrying the very same preview must still work after the rollback.
result = service.save_plan_drafts(((preview, {a: preview.projects[0].rows}),), {})
assert result[a][0].enabled
def test_service_extends_inventory_with_known_parts_and_preserves_saved_edits(group):
service, store, tasks, targets = group
task_id = tasks[0].task_id
first = targets[task_id]
second = replace(first, uid='u2', refdes='R2', old_part_number='OTHER')
store.record_target_inventory(task_id, (first,))
prior = TargetPlanRow(first, True, 'MANUAL', True, 'manual value', False)
store.replace_target_plan(task_id, (prior,))
service.add_rule(task_id, 'OTHER', 'OTHER-NEW', sync_nc=False)
seen = []
def collect(project, parts, **controls):
seen.append(parts)
return first, second
service.for_project_task(task_id)._quick_run_preparer.collect_inventory = collect
result = service.collect_target_inventory(task_id, ('OTHER',))
assert set(seen[0]) == {'OLD', 'OTHER'}
assert result[0] == prior
assert not result[1].enabled and result[1].new_part_number == 'OTHER-NEW' and not result[1].sync_nc
def test_cancelled_service_inventory_does_not_save_any_targets(group):
service, store, tasks, targets = group
task_id = tasks[0].task_id
stop = Event()
def collect(project, parts, **controls):
stop.set()
return (targets[task_id],)
service.for_project_task(task_id)._quick_run_preparer.collect_inventory = collect
with pytest.raises(TaskCenterError) as error:
service.collect_target_inventory(task_id, ('OLD',), stop_event=stop)
assert error.value.code == 'operation_cancelled'
assert not store.list_target_plan(task_id) and not store.get_task(task_id).target_plan_mode
+286
View File
@@ -0,0 +1,286 @@
import os
os.environ.setdefault('QT_QPA_PLATFORM', 'offscreen')
from dataclasses import replace
from pathlib import Path
from types import SimpleNamespace
import pytest
from dx_productivity.trial_task_center.bom_batch import BomBatchPreview, BomProjectPreview
from dx_productivity.trial_task_center.ui.project_plan import ProjectPlanPanel
from dx_productivity.trial_task_center.ui.task_list import TaskList
def panel(qtbot):
window = SimpleNamespace(_update_gates=lambda: None, service=SimpleNamespace(target_plan=lambda _: ()))
result = ProjectPlanPanel(window)
qtbot.addWidget(result)
return result
def batch(ids, imported):
return BomBatchPreview(ids[0], tuple((x, f'/{x}') for x in ids), tuple(
BomProjectPreview(x, Path(f'/{x}'), (), (), ()) for x in imported))
def test_reimport_replaces_overlapping_stale_scope_preserving_unaffected_projects(qtbot):
p = panel(qtbot)
p._preview_bom(batch(('a', 'b', 'deleted'), ('a', 'b', 'deleted')))
p._drafts['b'] = ('manual draft sentinel',)
p._preview_bom(batch(('a', 'b'), ('a',)))
assert tuple(p._bom_batches) == (('a', 'b'),)
assert [x.task_id for x in next(iter(p._bom_batches.values())).projects] == ['a', 'b']
assert p._drafts['b'] == ('manual draft sentinel',)
assert 'deleted' in p._drafts
def test_all_unsaved_detection_includes_hidden_batches(qtbot):
p = panel(qtbot)
p._bom_batches[('a',)] = batch(('a',), ('a',))
assert p.has_unsaved_plans()
def test_recycle_bin_has_independent_toggle(qtbot):
view = TaskList(lambda _: None)
qtbot.addWidget(view)
assert view.recycle_button.isCheckable()
assert view.filter.isHidden()
def test_creating_tasks_from_recycle_bin_returns_to_active_list(window, qtbot):
window.task_list.recycle_button.setChecked(True)
task = window.service.create_task('new board')
window._project_tasks_created((task,))
qtbot.waitUntil(lambda: not window._task_query.busy and not window._context_query.busy)
assert not window.task_list.recycle_button.isChecked()
assert window.task_list.list.count() == 1
def test_save_all_keeps_every_draft_if_a_save_fails(qtbot):
p = panel(qtbot)
p._drafts = {'a': (), 'b': ()}
calls = []
def save(task_id, rows):
calls.append(task_id)
if task_id == 'b':
raise RuntimeError('save failed')
p.window.service.save_plan_drafts = lambda batches, standalone: [save(k, v) for k, v in standalone.items()]
with pytest.raises(RuntimeError):
p.save_all()
assert calls == ['a', 'b']
assert set(p._drafts) == {'a', 'b'}
@pytest.fixture
def window(qtbot, tmp_path):
from dx_productivity.trial_task_center.service import TaskCenterService
from dx_productivity.trial_task_center.store import TaskStore
from dx_productivity.trial_task_center.logging_setup import configure_logging
from dx_productivity.trial_task_center.ui.main_window import TrialTaskCenterWindow
store = TaskStore(tmp_path / 'tasks.db')
service = TaskCenterService(store, configure_logging(tmp_path / 'data'))
view = TrialTaskCenterWindow(service, close_plan_confirmer=lambda: 'discard')
qtbot.addWidget(view)
qtbot.waitUntil(lambda: not view._task_query.busy)
yield view
qtbot.waitUntil(lambda: not view._workers)
view._close_plan_confirmer = lambda: 'discard'
view.close()
qtbot.waitUntil(lambda: not view._context_query.busy)
store.close()
def test_close_cancel_and_failed_save_preserve_hidden_drafts(window, qtbot, monkeypatch):
from PySide6.QtGui import QCloseEvent
window.plan_panel._drafts['hidden'] = ()
window._close_plan_confirmer = lambda: 'cancel'
event = QCloseEvent()
window.closeEvent(event)
assert not event.isAccepted()
assert not window._closed
window._close_plan_confirmer = lambda: 'save'
def fail(*args):
raise RuntimeError('simulated write failure')
monkeypatch.setattr(window.service, 'save_plan_drafts', fail, raising=False)
event = QCloseEvent()
window.closeEvent(event)
assert not event.isAccepted()
qtbot.waitUntil(lambda: not window._workers)
assert not window._closed
assert 'hidden' in window.plan_panel._drafts
window._close_plan_confirmer = lambda: 'discard'
def test_close_save_all_waits_then_closes(window, qtbot, monkeypatch):
from PySide6.QtGui import QCloseEvent
saved = []
window.plan_panel._drafts = {'first': (), 'hidden': ()}
window._close_plan_confirmer = lambda: 'save'
monkeypatch.setattr(window.service, 'save_plan_drafts', lambda batches, standalone: saved.extend(standalone), raising=False)
event = QCloseEvent()
window.closeEvent(event)
assert not event.isAccepted()
qtbot.waitUntil(lambda: window._closed)
assert saved == ['first', 'hidden']
assert not window.plan_panel.has_unsaved_plans()
@pytest.mark.parametrize('cancel_error', [False, True])
def test_cancellable_operation_progress_and_close_wait_for_cleanup(window, qtbot, cancel_error):
from threading import Event
from PySide6.QtGui import QCloseEvent
started, release, cleaned = Event(), Event(), Event()
received = []
def operation(stop, progress):
progress('工程 1 / 2:正在读取')
started.set()
assert stop.wait(5)
assert release.wait(5)
cleaned.set()
if cancel_error:
from dx_productivity.trial_task_center.errors import TaskCenterError
raise TaskCenterError("operation_cancelled", "cancelled")
return ()
window.plan_panel._dispatch_cancellable(operation, received.append, window.plan_panel.collect_button)
qtbot.waitUntil(lambda: started.is_set())
qtbot.waitUntil(lambda: '工程 1 / 2' in window.plan_panel.summary.text())
event = QCloseEvent()
window.closeEvent(event)
assert not event.isAccepted()
assert window.plan_panel._operation_stop.is_set()
assert window._workers and not window._closed
release.set()
qtbot.waitUntil(lambda: window._closed)
assert cleaned.is_set()
assert received == []
def test_recycle_toggle_queries_deleted_tasks(window, qtbot, monkeypatch):
from dx_productivity.trial_task_center.models import TaskStatus
statuses = []
def tasks(status=None, **kwargs):
statuses.append(status)
return ()
monkeypatch.setattr(window.service, 'tasks', tasks)
window.task_list.recycle_button.setChecked(True)
qtbot.waitUntil(lambda: not window._task_query.busy)
assert statuses[-1] is TaskStatus.DELETED
window.task_list.recycle_button.setChecked(False)
qtbot.waitUntil(lambda: not window._task_query.busy)
assert statuses[-1] is None
def test_permanent_purge_trims_pending_batch_without_losing_other_drafts(qtbot):
p = panel(qtbot)
p._preview_bom(batch(('a', 'b'), ('a', 'b')))
p.forget_task('a')
assert set(p._drafts) == {'b'}
remaining = p._bom_batches[('b',)]
assert remaining.scope == (('b', '/b'),)
assert remaining.anchor_task_id == 'b'
assert [project.task_id for project in remaining.projects] == ['b']
def test_recycle_search_sort_restore_and_permanent_delete(window, qtbot, monkeypatch):
from PySide6.QtWidgets import QMessageBox
from dx_productivity.trial_task_center.models import TaskStatus
task = window.service.create_task('Board 20', note='find-me')
window.service.delete_task(task.task_id)
window.task_list.search.setText('find-me')
window.task_list.sort.setCurrentIndex(window.task_list.sort.findData('name_desc'))
window.task_list.recycle_button.setChecked(True)
qtbot.waitUntil(lambda: not window._task_query.busy)
assert window.task_list.list.count() == 1
window.open_task(task.task_id)
qtbot.waitUntil(lambda: not window._loading and not window._context_query.busy)
assert window.task_list.restore_button.isEnabled()
window._restore_task()
qtbot.waitUntil(lambda: not window._workers and not window._task_query.busy and not window._context_query.busy)
assert window.service.get_task(task.task_id).status is TaskStatus.DRAFT
assert window.task_list.list.count() == 0
window.service.delete_task(task.task_id)
window._refresh_task_list()
window._load_task_data()
qtbot.waitUntil(lambda: not window._task_query.busy and not window._context_query.busy)
assert window.task_list.delete_button.text() == '彻底删除'
monkeypatch.setattr(QMessageBox, 'question', lambda *args, **kwargs: QMessageBox.StandardButton.Yes)
window._delete_task()
qtbot.waitUntil(lambda: not window._workers and not window._task_query.busy and not window._context_query.busy)
assert window.task_list.list.count() == 0
def test_group_rule_changes_are_blocked_by_hidden_member_draft(window, qtbot, tmp_path):
root = tmp_path / 'projects'
root.mkdir()
for name in ('a', 'b'):
(root / (name + '.prj')).write_text('KEY FrontEndSnapshot "DxD"\nKEY iCDBDir "database"\n')
tasks = window.service.create_project_tasks(root)
window.service.add_rule(tasks[0].task_id, 'OLD', 'NEW')
window._refresh_task_list()
window.open_task(tasks[0].task_id)
qtbot.waitUntil(lambda: not window._task_query.busy and not window._context_query.busy)
assert window.add_mapping_button.isEnabled()
window.plan_panel._drafts[tasks[1].task_id] = ()
window._update_gates()
assert not window.add_mapping_button.isEnabled()
assert not window._rules_change_allowed()
assert '本批存在未保存计划' in window._message
window._close_plan_confirmer = lambda: 'discard'
@pytest.mark.parametrize('reimport_after_restore', [False, True])
def test_detached_bom_inventory_survives_deleted_member_and_restore(window, qtbot, tmp_path, reimport_after_restore):
from dx_productivity.trial_task_center.bom_plan import write_bom_template
from dx_productivity.trial_task_center.target_plan import ComponentTarget
from dx_productivity.trial_task_center.errors import TaskCenterError
root = tmp_path / 'projects'
root.mkdir()
for name in ('a', 'b'):
(root / (name + '.prj')).write_text('KEY FrontEndSnapshot "DxD"\nKEY iCDBDir "database"\n')
service = window.service
tasks = service.create_project_tasks(root)
a, b = (task.task_id for task in tasks)
records = []
for task in tasks:
path = service.projects(task.task_id)[0].path
inventory = (ComponentTarget(path, 'MAIN', '1', 'uid', 'R1', 'OLD', '33R'),)
service.for_project_task(task.task_id)._quick_run_preparer.collect_inventory = lambda *args, rows=inventory, **kwargs: rows
records.append(dict(project_path=str(path), old_part_number='OLD', new_part_number='NEW', refdes='R1'))
both = write_bom_template(tmp_path / 'both.xlsx', records)
only_a = write_bom_template(tmp_path / 'a.xlsx', records[:1])
p = window.plan_panel
p._preview_bom(service.preview_bom_batch(a, both))
service.delete_task(b)
p._preview_bom(service.preview_bom_batch(a, only_a))
assert b in p._orphaned_bom_batches
with pytest.raises(TaskCenterError):
p.save_all()
assert not service.target_plan(a) and not service.target_plan(b)
service.restore_task(b)
if reimport_after_restore:
p._preview_bom(service.preview_bom_batch(a, only_a))
assert b not in p._orphaned_bom_batches
window.open_task(b)
qtbot.waitUntil(lambda: not window._loading and not window._context_query.busy)
assert p._active_bom_batch() is not None
p.save()
qtbot.waitUntil(lambda: not window._workers)
assert service.target_plan(b)[0].new_part_number == 'NEW'
assert b not in p._drafts and b not in p._orphaned_bom_batches
def test_scope_member_without_imported_project_does_not_select_unrelated_batch(qtbot):
p = panel(qtbot)
p._preview_bom(batch(('a', 'b'), ('a',)))
p.bind_task('b')
assert p._active_bom_batch() is None
@pytest.mark.parametrize('action', ['purge', 'discard'])
def test_detached_metadata_clears_on_purge_or_discard(qtbot, action):
p = panel(qtbot)
p._preview_bom(batch(('a', 'b'), ('a', 'b')))
p._preview_bom(batch(('a',), ('a',)))
assert 'b' in p._orphaned_bom_batches
if action == 'purge':
p.forget_task('b')
else:
p.discard_all()
assert 'b' not in p._orphaned_bom_batches
assert 'b' not in p._drafts
+1 -2
View File
@@ -25,8 +25,7 @@ def browser(qtbot, tmp_path):
store = TaskStore(tmp_path / 'tasks.db')
service = TaskCenterService(store, configure_logging(tmp_path / 'data'))
tasks = service.create_project_tasks(root)
for task in tasks:
service.add_rule(task.task_id, 'OLD', 'NEW')
service.add_rule(tasks[0].task_id, 'OLD', 'NEW')
window = TrialTaskCenterWindow(service)
yield window, service, tasks
qtbot.waitUntil(lambda: not window._workers, timeout=5000)
+2 -2
View File
@@ -107,9 +107,9 @@ def run_scenario(output: Path, *, projects=3, sheets=2, rules=2, behavior='succe
try:
tasks = measured('create_tasks', lambda: service.create_project_tasks(root))
assert len(tasks) == projects
for part in range(rules):
service.add_rule(tasks[0].task_id, f'OLD-{part}', f'NEW-{part}')
for task in tasks:
for part in range(rules):
service.add_rule(task.task_id, f'OLD-{part}', f'NEW-{part}')
rows = measured('collect_inventory', lambda: service.collect_target_inventory(task.task_id))
assert len(rows) == sheets * rules * 3
bom = output / f'{task.task_id}.xlsx'
+2 -2
View File
@@ -143,7 +143,7 @@ def main():
for task in tasks:
preparer = service.for_project_task(task.task_id)._quick_run_preparer
original_collect = preparer.collect_inventory
def collect(project, parts, task=task, original=original_collect):
def collect(project, parts, task=task, original=original_collect, **controls):
if args.native_inventory:
raise RuntimeError('Captured-inventory UI replay must not start another native reader')
if (output / 'stop.request').exists():
@@ -151,7 +151,7 @@ def main():
started = time.perf_counter()
print('collect_start', project.parent.name, len(parts), flush=True)
try:
rows = original(project, parts)
rows = original(project, parts, **controls)
inventory_by_task[task.task_id] = rows
report['collections'].append({'task_id': task.task_id, 'project': str(project),
'parts': parts, 'components': len(rows), 'seconds': time.perf_counter() - started})