import importlib import shutil from pathlib import Path from .exception_service import ExceptionService from .library_postprocess import ( OrganizeItemError, _build_organize_plan, _build_prefixed_name, _build_quality_breakdown, _build_unique_destination, _serialize_compared_candidate ) from .metadata_normalization import ( MetadataNormalizationService, can_ingest_metadata, merge_metadata_layers ) from .matcher import Matcher from .preprocessor import PreprocessItemError, Preprocessor from .task_constants import ( STAGE_STATUS_COMPLETED, STAGE_STATUS_FAILED, STAGE_STATUS_RUNNING, TASK_STATUS_COMPLETED, TASK_STATUS_FAILED, TASK_STATUS_RUNNING, current_timestamp, create_empty_repair_stats, create_pending_repair_stage_states ) class RepairExecutionError(Exception): def __init__(self, reason: str, message: str): super().__init__(message) self.reason = reason self.message = message class MetadataPatchService: def apply(self, item: dict, metadata_patch: dict) -> tuple[dict, bool]: patch = {key: value for key, value in (metadata_patch or {}).items() if value is not None} if not patch: return item, False normalized_metadata = self.metadata_normalizer.normalize_item(item, patch) merged_tags = dict(item.get('original_tags_json') or {}) merged_tags.update({key: value for key, value in normalized_metadata.items() if key in self.writable_keys}) file_path = Path(item['current_file_path']) if file_path.exists(): self._write_tags(file_path, merged_tags) updated_item = self.task_store.update_task_item( item['id'], original_tags_json=merged_tags, matched_metadata_json=normalized_metadata ) return updated_item, True def __init__(self, task_store, metadata_normalizer: MetadataNormalizationService): self.task_store = task_store self.metadata_normalizer = metadata_normalizer self.writable_keys = {'title', 'artist', 'album', 'album_artist', 'track_number', 'disc_number', 'year', 'lyrics'} def _write_tags(self, file_path: Path, tags: dict): mutagen = importlib.import_module('mutagen') tags_file = mutagen.File(str(file_path), easy=True) if tags_file is None: raise RepairExecutionError('metadata_write_failed', f'无法写入标签: {file_path}') key_mapping = { 'title': 'title', 'artist': 'artist', 'album': 'album', 'album_artist': 'albumartist', 'track_number': 'tracknumber', 'disc_number': 'discnumber', 'year': 'date', 'lyrics': 'lyrics' } for source_key, target_key in key_mapping.items(): if source_key not in tags: continue value = tags[source_key] if value in (None, ''): continue tags_file[target_key] = [str(value)] tags_file.save() class OrganizeService: def __init__(self, task_store, metadata_normalizer: MetadataNormalizationService): self.task_store = task_store self.metadata_normalizer = metadata_normalizer def plan(self, item: dict, output_root: str, override_relative_path: str | None = None) -> dict: root = Path(output_root).expanduser().resolve(strict=False) if override_relative_path: planned_relative_path = Path(override_relative_path).as_posix().lstrip('/') return {'output_root': root, 'planned_relative_path': planned_relative_path} normalized_item = { **item, 'matched_metadata_json': self.metadata_normalizer.normalize_item(item) } return _build_organize_plan(root, normalized_item) def resolve_destination(self, desired_path: Path, source_path: Path) -> tuple[Path, int]: candidate = desired_path collision_index = 1 while candidate.exists(): if candidate.resolve(strict=False) == source_path.resolve(strict=False): return candidate, collision_index collision_index += 1 candidate = candidate.with_name( f'{desired_path.stem} ({collision_index}){desired_path.suffix}' ) return candidate, collision_index def move_to_review_trash( self, *, trash_root: str, task_id: str, item_id: int | None, source_path: str, reason: str ) -> str: source = Path(source_path) if not source.exists(): raise RepairExecutionError('source_missing', f'源文件不存在: {source}') destination = _build_unique_destination( Path(trash_root) / reason / task_id, _build_prefixed_name(item_id, source.name) ) destination.parent.mkdir(parents=True, exist_ok=True) shutil.move(str(source), str(destination)) return str(destination.resolve(strict=False)) def organize_item( self, item: dict, *, output_root: str, override_relative_path: str | None = None ) -> tuple[dict, dict]: normalized_metadata = self.metadata_normalizer.normalize_item(item) if normalized_metadata != (item.get('matched_metadata_json') or {}): item = self.task_store.update_task_item(item['id'], matched_metadata_json=normalized_metadata) plan = self.plan(item, output_root, override_relative_path) source_path = Path(item['current_file_path']) if not source_path.exists(): raise RepairExecutionError('source_missing', f'源文件不存在: {source_path}') desired_path = Path(plan['output_root']) / plan['planned_relative_path'] final_path, collision_count = self.resolve_destination(desired_path, source_path) final_path.parent.mkdir(parents=True, exist_ok=True) shutil.move(str(source_path), str(final_path)) final_relative_path = final_path.relative_to(plan['output_root']).as_posix() updated_item = self.task_store.update_task_item( item['id'], current_file_path=str(final_path.resolve(strict=False)), filename=final_path.name, organize_status='organized', organize_reason=None, organize_message='已按标准路径入库', library_relative_path=final_relative_path, library_file_path=str(final_path.resolve(strict=False)), organize_decision_json={ 'source_path': item['current_file_path'], 'planned_relative_path': plan['planned_relative_path'], 'final_relative_path': final_relative_path, 'collision_strategy': 'suffix' if collision_count > 1 else 'none', 'trashed_on_failure': None, 'final_action': 'organized' } ) return updated_item, { 'planned_relative_path': plan['planned_relative_path'], 'final_relative_path': final_relative_path, 'collision_count': collision_count } class MatchRetryService: def __init__(self, task_store, matcher: Matcher, metadata_normalizer: MetadataNormalizationService): self.task_store = task_store self.matcher = matcher self.metadata_normalizer = metadata_normalizer def retry_match(self, item: dict, config_snapshot: dict, providers: list[str] | None = None) -> dict: match_config = dict(config_snapshot) if providers: match_config['repair_provider_scope'] = providers result = self.matcher.match_item(item, [item], match_config) matched_metadata = self.metadata_normalizer.normalize_item( { **item, 'matched_metadata_json': result['matched_metadata_json'] } ) return self.task_store.update_task_item( item['id'], match_status=result['status'], match_reason=result['reason'], match_message=result['message'], match_source=result['source'], match_confidence=result['confidence'], match_is_authoritative=1 if result['is_authoritative'] else 0, matched_metadata_json=matched_metadata, match_candidates_json=result['match_candidates_json'], match_enrichment_json=result['match_enrichment_json'] ) def select_candidate(self, item: dict, candidate_index: int) -> dict: candidates = item.get('match_candidates_json') or [] if candidate_index < 0 or candidate_index >= len(candidates): raise RepairExecutionError('candidate_index_invalid', '候选索引无效') candidate = candidates[candidate_index] matched_metadata = { 'title': candidate.get('title'), 'artist': candidate.get('artist'), 'album': candidate.get('album'), 'album_artist': candidate.get('album_artist'), 'track_number': candidate.get('track_number'), 'disc_number': candidate.get('disc_number'), 'year': candidate.get('year'), 'lyrics': candidate.get('lyrics'), 'recording_id': candidate.get('recording_id'), 'release_id': candidate.get('release_id'), 'release_group_id': candidate.get('release_group_id'), 'source_ids': candidate.get('source_ids') or {} } matched_metadata = self.metadata_normalizer.normalize_item( { **item, 'matched_metadata_json': matched_metadata } ) return self.task_store.update_task_item( item['id'], match_status='matched_fallback', match_reason='manual_candidate_selected', match_message='已手动确认匹配候选', match_source=candidate.get('provider'), match_confidence=candidate.get('score'), match_is_authoritative=1 if candidate.get('is_authoritative') else 0, matched_metadata_json=matched_metadata ) class PreprocessRetryService: def __init__(self, task_store, preprocessor: Preprocessor): self.task_store = task_store self.preprocessor = preprocessor def retry_preprocess(self, item: dict) -> dict: try: audio_props = self.preprocessor.probe_audio(item['current_file_path']) tags = self.preprocessor.read_tags(item['current_file_path']) fingerprint = self.preprocessor.calculate_fingerprint(item['current_file_path']) return self.task_store.update_task_item( item['id'], preprocess_status='completed' if tags else 'warning', preprocess_reason=None if tags else 'metadata_failed', preprocess_message='预处理已重新执行' if tags else '预处理完成，但元数据仍缺失', audio_props_json=audio_props, original_tags_json=tags, acoustic_fingerprint=fingerprint.get('fingerprint'), fingerprint_duration_seconds=fingerprint.get('duration_seconds') ) except PreprocessItemError as error: return self.task_store.update_task_item( item['id'], preprocess_status='failed', preprocess_reason=error.reason, preprocess_message=error.message ) class DedupeDecisionService: def __init__(self, task_store, organize_service: OrganizeService): self.task_store = task_store self.organize_service = organize_service def keep_existing(self, item: dict, *, task_id: str, trash_root: str) -> dict: if item.get('trash_file_path'): return self.task_store.update_task_item( item['id'], dedupe_status='duplicate_trashed', dedupe_message='已保留库内文件' ) trashed_path = self.organize_service.move_to_review_trash( trash_root=trash_root, task_id=task_id, item_id=item['id'], source_path=item['current_file_path'], reason='duplicates' ) return self.task_store.update_task_item( item['id'], is_active=0, current_file_path=trashed_path, trash_file_path=trashed_path, dedupe_status='duplicate_trashed', dedupe_reason='manual_keep_existing', dedupe_message='已保留库内文件，当前文件移入 review trash' ) def replace_existing( self, item: dict, *, task_id: str, output_root: str, trash_root: str ) -> tuple[dict, dict]: existing_path = item.get('duplicate_of_path') if not existing_path: raise RepairExecutionError('duplicate_target_missing', '缺少库内重复文件路径') existing = Path(existing_path) if not existing.exists(): raise RepairExecutionError('duplicate_target_missing', f'库内文件不存在: {existing}') replaced_path = self.organize_service.move_to_review_trash( trash_root=trash_root, task_id=task_id, item_id=item['id'], source_path=str(existing), reason='duplicates' ) current_path = Path(item['current_file_path']) if not current_path.exists(): raise RepairExecutionError('source_missing', f'源文件不存在: {current_path}') existing.parent.mkdir(parents=True, exist_ok=True) shutil.move(str(current_path), str(existing)) final_item = self.task_store.update_task_item( item['id'], current_file_path=str(existing.resolve(strict=False)), filename=existing.name, dedupe_status='duplicate_replaced', dedupe_reason='replaced_library_duplicate', dedupe_message='已替换库内旧文件', library_relative_path=existing.relative_to( Path(output_root).expanduser().resolve(strict=False) ).as_posix() if str(existing).startswith(str(Path(output_root).expanduser().resolve(strict=False))) else item.get('library_relative_path'), library_file_path=str(existing.resolve(strict=False)), dedupe_decision_json={ 'comparison_scope': 'library', 'identity_basis': 'manual_replace', 'quality_breakdown': { 'kept': _build_quality_breakdown(item), 'replaced': {'total': None} }, 'kept_side': 'batch', 'trashed_path': replaced_path, 'replaced_existing_path': str(existing.resolve(strict=False)), 'compared_candidates': [ _serialize_compared_candidate('kept', item), {'side': 'replaced', 'path': str(existing.resolve(strict=False))} ] } ) return final_item, {'replaced_path': replaced_path, 'final_path': str(existing.resolve(strict=False))} def keep_both_with_rename( self, item: dict, *, output_root: str ) -> tuple[dict, dict]: return self.organize_service.organize_item(item, output_root=output_root) class RepairService: def __init__( self, task_store, exception_service: ExceptionService, matcher: Matcher, preprocessor: Preprocessor, task_stream, runner=None ): self.task_store = task_store self.exception_service = exception_service self.metadata_normalizer = MetadataNormalizationService(task_store) self.metadata_service = MetadataPatchService(task_store, self.metadata_normalizer) self.organize_service = OrganizeService(task_store, self.metadata_normalizer) self.match_service = MatchRetryService(task_store, matcher, self.metadata_normalizer) self.preprocess_service = PreprocessRetryService(task_store, preprocessor) self.dedupe_service = DedupeDecisionService(task_store, self.organize_service) self.task_stream = task_stream self.runner = runner def preview(self, payload: dict, config_snapshot: dict) -> dict: items = self._load_exception_items(payload['exception_ids']) action = payload['action'] params = payload.get('params') or {} self._validate_batch(items, action) preview_items = [] planned_operations = [] warnings: list[str] = [] risk_level = 'low' for item in items: item_operations, item_warnings, item_risk = self._preview_item(item, action, params, config_snapshot) preview_items.append( { 'exception_id': item['exception_id'], 'filename': item['filename'], 'exception_type': item['exception_type'], 'planned_operations': item_operations, 'warnings': item_warnings } ) planned_operations.extend(item_operations) warnings.extend(item_warnings) risk_level = self._merge_risk(risk_level, item_risk) return { 'action': action, 'items': preview_items, 'requires_confirmation': True, 'planned_operations': planned_operations, 'conflict_summary': { 'item_count': len(preview_items), 'mixed_types': len({item['exception_type'] for item in preview_items}) > 1 }, 'risk_level': risk_level, 'warnings': warnings } def execute(self, payload: dict, config_snapshot: dict) -> dict: items = self._load_exception_items(payload['exception_ids'], require_open=True) preview = self.preview(payload, config_snapshot) task = self.task_store.create_task_if_idle( config_snapshot, trigger_source='manual_ui', task_type='repair', source_task_id=items[0]['task_id'] if items else None, repair_plan_json={ 'action': payload['action'], 'params': payload.get('params') or {}, 'items': [item['exception_id'] for item in items], 'preview': preview } ) for item in items: before_snapshot = self.exception_service.get_item(item['exception_id']) previous_resolution = item.get('exception_resolution_json') or {} self.task_store.update_task_item( item['exception_id'], exception_resolution_status='planned', last_repair_task_id=task['task_id'], exception_resolution_json={ **previous_resolution, 'action': payload['action'], 'requested_at': current_timestamp(), 'resolved_at': None, 'repair_task_id': task['task_id'], 'operator': 'manual_ui', 'before_snapshot': before_snapshot, 'after_snapshot': None, 'notes': None, 'planned_operations': [ operation for operation in preview['planned_operations'] if operation.get('source_path') == before_snapshot.get('current_file_path') or operation.get('target_path') == before_snapshot.get('current_file_path') ], 'execution_result': None } ) return task def _validate_batch(self, items: list[dict], action: str): if not items: raise ValueError('至少选择一个异常项') types = {item['exception_type'] for item in items} if len(types) > 1: raise ValueError('批量动作不支持混合异常类型') for item in items: if action not in (item.get('available_actions') or []): raise ValueError(f'异常项 {item["exception_id"]} 不支持动作 {action}') def _load_exception_items(self, exception_ids: list[int], require_open: bool = False) -> list[dict]: ids = list(dict.fromkeys(exception_ids or [])) items = [self.exception_service.get_item(exception_id) for exception_id in ids] if require_open: for item in items: if item.get('exception_resolution_status') != 'open': raise ValueError(f'异常项 {item["exception_id"]} 当前不可执行') return items def _preview_item(self, item: dict, action: str, params: dict, config_snapshot: dict): current_path = item.get('current_file_path') if action == 'ignore_exception': return ( [self._op('status_update', current_path, None, '标记为已忽略，不执行物理删除')], ['真实执行仅做安全忽略或转入 review trash，不会物理删除源文件。'], 'low' ) if action == 'delete_file': return ( [self._op('trash', current_path, None, '永久删除当前文件')], ['该动作会真实删除文件，执行后无法恢复。'], 'high' ) if action == 'edit_metadata': return ([self._op('metadata_write', current_path, current_path, '写入元数据标签')], [], 'low') if action == 'retry_match': providers = params.get('providers') or [] description = '重新执行单文件匹配' if providers: description = f'重新执行单文件匹配 ({"/".join(providers)})' return ([self._op('status_update', current_path, None, description)], [], 'low') if action == 'select_match_candidate': return ([self._op('status_update', current_path, None, '确认现有匹配候选')], [], 'low') if action == 'retry_preprocess': return ([self._op('status_update', current_path, None, '重跑预处理与指纹提取')], [], 'low') if action == 'move_to_review_trash': return ([self._op('trash', current_path, None, '移动到 review trash')], [], 'medium') if action == 'keep_existing': return ([self._op('trash', current_path, item.get('trash_file_path'), '保留库内文件并移走当前文件')], [], 'medium') if action == 'replace_existing': return ( [ self._op('replace', item.get('duplicate_of_path'), None, '将库内旧文件移入 review trash'), self._op('move', current_path, item.get('duplicate_of_path'), '当前文件覆盖进入库内目标') ], [], 'high' ) if action in {'retry_organize', 'save_and_organize', 'keep_both_with_rename'}: override = params.get('target_relative_path') if action == 'retry_organize' else None if action == 'save_and_organize' and params.get('metadata_patch'): item = { **item, 'matched_metadata_json': self.metadata_normalizer.normalize_item(item, params['metadata_patch']) } if action == 'save_and_organize' and not can_ingest_metadata(self.metadata_normalizer.normalize_item(item)): raise ValueError('加入音乐库前必须补齐 title、artist、album_artist') plan = self.organize_service.plan(item, config_snapshot['output'], override) return ( [ self._op('move', current_path, str(Path(config_snapshot['output']) / plan['planned_relative_path']), '移动到目标库路径'), self._op('status_update', current_path, None, f'更新入库路径 {plan["planned_relative_path"]}') ], [], 'medium' ) raise ValueError(f'Unsupported action: {action}') def _merge_risk(self, current: str, next_risk: str) -> str: order = {'low': 0, 'medium': 1, 'high': 2} return next_risk if order[next_risk] > order[current] else current def _op(self, op_type: str, source_path: str | None, target_path: str | None, description: str) -> dict: return { 'type': op_type, 'source_path': source_path, 'target_path': target_path, 'description': description } class RepairRunner: def __init__(self, task_store, task_stream, repair_service: RepairService): self.task_store = task_store self.task_stream = task_stream self.repair_service = repair_service def start_task(self, repair_task_id: str, config_snapshot: dict): task = self.task_store.get_task(repair_task_id) plan = task.get('repair_plan_json') or {} stats = create_empty_repair_stats() stage_states = create_pending_repair_stage_states() try: stage_states['prepare'] = STAGE_STATUS_RUNNING self.task_store.update_task( repair_task_id, status=TASK_STATUS_RUNNING, current_stage='prepare', stage_states=stage_states, stats=stats ) self._log(repair_task_id, 'prepare', 'info', 'stage.started', '开始准备 repair 执行') stats['prepare']['previewed_items'] = len(plan.get('items') or []) stage_states['prepare'] = STAGE_STATUS_COMPLETED stage_states['execute'] = STAGE_STATUS_RUNNING self.task_store.update_task( repair_task_id, status=TASK_STATUS_RUNNING, current_stage='execute', stage_states=stage_states, stats=stats ) self._broadcast(repair_task_id, 'stage.completed', 'prepare', {'stats': stats}) for exception_id in plan.get('items') or []: try: self._apply_action_to_item(repair_task_id, exception_id, plan['action'], plan.get('params') or {}, config_snapshot, stats) stats['execute']['succeeded_items'] += 1 except Exception as error: stats['execute']['failed_items'] += 1 item = self.task_store.get_exception_source_item(exception_id) if item: resolution = dict(item.get('exception_resolution_json') or {}) resolution['resolved_at'] = current_timestamp() resolution['execution_result'] = {'status': 'failed', 'message': str(error)} self.task_store.update_task_item( exception_id, exception_resolution_status='open', exception_resolution_json=resolution ) self._log(repair_task_id, 'execute', 'error', 'repair.item_failed', f'异常项执行失败: {exception_id}', {'exception_id': exception_id, 'error': str(error)}) stage_states['execute'] = STAGE_STATUS_COMPLETED stage_states['complete'] = STAGE_STATUS_COMPLETED completed_at = current_timestamp() self.task_store.update_task( repair_task_id, status=TASK_STATUS_COMPLETED, current_stage='complete', stage_states=stage_states, stats=stats, completed_at=completed_at ) self._broadcast(repair_task_id, 'task.completed', 'complete', {'stats': stats}) self._log(repair_task_id, 'complete', 'success', 'task.completed', 'repair 任务已完成', {'stats': stats}) except Exception as error: stage_states['prepare'] = STAGE_STATUS_FAILED if stage_states['prepare'] == STAGE_STATUS_RUNNING else stage_states['prepare'] stage_states['execute'] = STAGE_STATUS_FAILED if stage_states['execute'] == STAGE_STATUS_RUNNING else stage_states['execute'] stage_states['complete'] = STAGE_STATUS_FAILED self.task_store.update_task( repair_task_id, status=TASK_STATUS_FAILED, current_stage='execute', stage_states=stage_states, stats=stats, error_message=str(error), completed_at=current_timestamp() ) self._broadcast(repair_task_id, 'task.failed', 'execute', {'error_message': str(error), 'stats': stats}) self._log(repair_task_id, 'execute', 'error', 'task.failed', f'repair 任务失败: {error}', {'error': str(error)}) def _apply_action_to_item(self, repair_task_id: str, exception_id: int, action: str, params: dict, config_snapshot: dict, stats: dict): item = self.task_store.get_exception_source_item(exception_id) if item is None: raise RepairExecutionError('item_missing', f'异常项不存在: {exception_id}') before_snapshot = self.repair_service.exception_service.get_item(exception_id) final_item = item execution_result = {'action': action, 'status': 'completed'} if action == 'ignore_exception': stats['execute']['ignored_items'] += 1 resolution_status = 'ignored' workflow_state = 'ignored' elif action == 'edit_metadata': final_item, changed = self.repair_service.metadata_service.apply(item, params.get('metadata_patch') or {}) if changed: stats['execute']['updated_metadata_items'] += 1 resolution_status = 'open' workflow_state = _metadata_workflow_state(final_item, params.get('metadata_patch') or {}) elif action == 'retry_match': final_item = self.repair_service.match_service.retry_match( item, config_snapshot, providers=params.get('providers') or None ) resolution_status = 'open' workflow_state = _metadata_workflow_state(final_item) elif action == 'select_match_candidate': final_item = self.repair_service.match_service.select_candidate(item, int(params.get('candidate_index', -1))) resolution_status = 'open' workflow_state = _candidate_workflow_state(final_item) elif action == 'retry_preprocess': final_item = self.repair_service.preprocess_service.retry_preprocess(item) resolution_status = 'resolved' if final_item.get('preprocess_status') != 'failed' else 'open' workflow_state = 'ingested' if resolution_status == 'resolved' else 'open' elif action == 'move_to_review_trash': trashed_path = self.repair_service.organize_service.move_to_review_trash( trash_root=config_snapshot['trash'], task_id=repair_task_id, item_id=item['id'], source_path=item['current_file_path'], reason='manual_review' ) final_item = self.task_store.update_task_item( item['id'], is_active=0, current_file_path=trashed_path, trash_file_path=trashed_path, organize_status='trashed', organize_reason='manual_review', organize_message='已移入 review trash' ) stats['execute']['moved_items'] += 1 resolution_status = 'resolved' workflow_state = 'ingested' elif action == 'keep_existing': final_item = self.repair_service.dedupe_service.keep_existing( item, task_id=repair_task_id, trash_root=config_snapshot['trash'] ) stats['execute']['moved_items'] += 1 resolution_status = 'resolved' workflow_state = 'ingested' elif action == 'replace_existing': final_item, execution_result = self.repair_service.dedupe_service.replace_existing( item, task_id=repair_task_id, output_root=config_snapshot['output'], trash_root=config_snapshot['trash'] ) stats['execute']['moved_items'] += 1 resolution_status = 'resolved' workflow_state = 'ingested' elif action == 'keep_both_with_rename': final_item, execution_result = self.repair_service.dedupe_service.keep_both_with_rename( item, output_root=config_snapshot['output'] ) stats['execute']['moved_items'] += 1 resolution_status = 'resolved' workflow_state = 'ingested' elif action == 'retry_organize': final_item, execution_result = self.repair_service.organize_service.organize_item( item, output_root=config_snapshot['output'], override_relative_path=params.get('target_relative_path') ) stats['execute']['moved_items'] += 1 resolution_status = 'resolved' workflow_state = 'ingested' elif action == 'save_and_organize': patched_item, changed = self.repair_service.metadata_service.apply(item, params.get('metadata_patch') or {}) if changed: stats['execute']['updated_metadata_items'] += 1 if not can_ingest_metadata(self.repair_service.metadata_normalizer.normalize_item(patched_item)): raise RepairExecutionError('metadata_incomplete', '加入音乐库前必须补齐 title、artist、album_artist') final_item, execution_result = self.repair_service.organize_service.organize_item( patched_item, output_root=config_snapshot['output'] ) stats['execute']['moved_items'] += 1 resolution_status = 'resolved' workflow_state = 'ingested' elif action == 'delete_file': file_path = Path(item['current_file_path']) if not file_path.exists(): raise RepairExecutionError('source_missing', f'源文件不存在: {file_path}') file_path.unlink() final_item = self.task_store.update_task_item( item['id'], is_active=0, organize_status='deleted', organize_reason='manual_delete', organize_message='文件已被永久删除' ) resolution_status = 'resolved' workflow_state = 'deleted' else: raise ValueError(f'Unsupported action: {action}') after_snapshot = self.repair_service.exception_service.get_item(exception_id) if resolution_status == 'open' else { **before_snapshot, 'current_file_path': final_item.get('current_file_path'), 'trash_file_path': final_item.get('trash_file_path'), 'library_relative_path': final_item.get('library_relative_path'), 'library_file_path': final_item.get('library_file_path'), 'matched_metadata_json': final_item.get('matched_metadata_json'), 'original_tags_json': final_item.get('original_tags_json') } resolution = dict(final_item.get('exception_resolution_json') or {}) resolution.update( { 'resolved_at': current_timestamp(), 'workflow_state': workflow_state, 'metadata_draft': _build_metadata_draft(final_item, params.get('metadata_patch') or {}, workflow_state), 'after_snapshot': after_snapshot, 'execution_result': execution_result } ) if action == 'keep_both_with_rename': resolution['secondary_version_retained'] = True self.task_store.update_task_item( final_item['id'], exception_resolution_status=resolution_status, exception_resolution_json=resolution, last_repair_task_id=repair_task_id ) self._log(repair_task_id, 'execute', 'success', 'repair.item_completed', f'异常项执行完成: {exception_id}', {'exception_id': exception_id, 'action': action, 'resolution_status': resolution_status}) self._broadcast(repair_task_id, 'repair.progress', 'execute', {'stats': stats, 'exception_id': exception_id}) def _log(self, task_id: str, stage: str, level: str, event_type: str, message: str, payload: dict | None = None): persisted_log = self.task_store.append_log(task_id, stage, level, event_type, message, payload) self._broadcast(task_id, 'log.appended', stage, {'log': persisted_log}) def _broadcast(self, task_id: str, event_type: str, stage: str, data: dict): self.task_stream.broadcast_event(task_id, event_type, stage, data) def _merge_metadata(item: dict, metadata_patch: dict | None = None) -> dict: return merge_metadata_layers( item.get('original_tags_json'), item.get('matched_metadata_json'), metadata_patch ) def _can_ingest(metadata: dict) -> bool: return can_ingest_metadata(metadata) def _metadata_workflow_state(item: dict, metadata_patch: dict | None = None) -> str: metadata = item.get('matched_metadata_json') or {} if metadata_patch: metadata = {**metadata, **{key: value for key, value in metadata_patch.items() if value is not None}} return 'ready_to_ingest' if _can_ingest(metadata) else 'open' def _candidate_workflow_state(item: dict) -> str: return 'ready_to_ingest' if _can_ingest(item.get('matched_metadata_json') or {}) else 'candidate_selected' def _build_metadata_draft(item: dict, metadata_patch: dict | None, workflow_state: str) -> dict | None: if workflow_state not in {'candidate_selected', 'ready_to_ingest'} and not metadata_patch: return None metadata = dict(item.get('matched_metadata_json') or {}) metadata.update({key: value for key, value in (metadata_patch or {}).items() if value is not None}) return metadata