fix: share batch defaults and protect BOM drafts across task lifecycle
This commit is contained in:
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, ...]:
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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)
|
||||
@@ -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):
|
||||
|
||||
@@ -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()
|
||||
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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)
|
||||
|
||||
@@ -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'
|
||||
|
||||
@@ -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})
|
||||
|
||||
Reference in new issue
Block a user