@chenchaolong/plugin-trade-compliance-workbench 1.0.23 → 1.0.24

package/dist/lib/workbench.service.js

@@ -44,7 +44,11 @@ const SKIPPED_REASON_MESSAGES = {
 const RUNNING_IMPORT_TASK_STATUSES = ['EXTRACTING', 'AI_PARSING', 'VALIDATING', 'PERSISTING'];
 const RECOVERABLE_IMPORT_TASK_STATUSES = ['QUEUED', 'EXTRACTING', 'AI_PARSING', 'VALIDATING', 'PERSISTING'];
 const RECOVERABLE_REANALYSIS_STATUSES = ['PENDING', 'RUNNING'];
-const TERMINAL_IMPORT_TASK_STATUSES = ['AWAITING_REVIEW', 'SUCCEEDED', 'FAILED', 'TIMED_OUT'];
+const TERMINAL_IMPORT_TASK_STATUSES = ['AWAITING_REVIEW', 'SUCCEEDED', 'FAILED', 'TIMED_OUT', 'CANCELED'];
+const DELETABLE_IMPORT_TASK_STATUSES = [
+    'QUEUED', 'EXTRACTING', 'AI_PARSING', 'VALIDATING',
+    'AWAITING_REVIEW', 'PERSISTING', 'FAILED', 'TIMED_OUT'
+];
 const CATALOG_RISK_RECOMMENDATIONS = {
     DUAL_USE: '建议核验军民两用物项许可要求，并在出口前完成合规审批',
     OVERSEAS_SANCTION: '建议核验海外制裁限制及交易对手风险，并在交易前完成合规审批'
@@ -141,6 +145,89 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
         const page = await this.pagedQuery(ImportTask, scope, query, ['sourceFileName', 'documentType', 'status', 'errorMessage'], { documentType: query.parameters?.documentType, status: query.parameters?.status });
         return { ...page, items: page.items.map(publicImportTaskDto) };
     }
+    async deleteImportTask(scope, taskId) {
+        const transactionResult = await this.dataSource.transaction(async (manager) => {
+            const taskRepo = manager.getRepository(ImportTask);
+            const task = await required(taskRepo.findOne({
+                where: { ...activeScope(scope), id: requiredId(taskId, '解析任务标识') },
+                lock: { mode: 'pessimistic_write' }
+            }), '解析任务不存在');
+            if (task.deletedAt || task.status === 'CANCELED') {
+                return {
+                    taskId: task.id, status: 'CANCELED', deleted: true,
+                    idempotent: true, sourceFileCleanupRequired: false,
+                    cancellationTarget: null
+                };
+            }
+            if (!DELETABLE_IMPORT_TASK_STATUSES.includes(task.status)) {
+                throw new DomainError(DomainErrorCodes.INVALID_INPUT, '已完成任务不允许删除');
+            }
+            const cancellationTarget = {
+                importTaskId: task.id,
+                claimAttemptToken: task.claimAttemptToken
+            };
+            const now = new Date();
+            task.status = 'CANCELED';
+            task.canceledAt = now;
+            task.canceledById = scope.userId ?? null;
+            task.deletedAt = now;
+            task.deletedById = scope.userId ?? null;
+            task.deleteOperation = 'USER_DELETE';
+            task.claimAttemptToken = null;
+            task.resultProcessingClaimId = null;
+            task.resultProcessingClaimExpiresAt = null;
+            task.completedAt = now;
+            await this.deleteImportTaskTransientRows(manager, scope, task);
+            await taskRepo.save(task);
+            const sourceFileCleanupRequired = !await this.importSourceFileStillReferenced(manager, scope, task);
+            return {
+                taskId: task.id, status: 'CANCELED', deleted: true,
+                idempotent: false, sourceFileCleanupRequired, cancellationTarget,
+                sourceFileId: task.sourceFileId
+            };
+        });
+        let sourceFileRemoved = false;
+        const sourceFileId = 'sourceFileId' in transactionResult ? transactionResult.sourceFileId : undefined;
+        if (transactionResult.sourceFileCleanupRequired && typeof sourceFileId === 'string' && this.storage) {
+            try {
+                await this.storage.remove(sourceFileId);
+                sourceFileRemoved = true;
+            }
+            catch {
+                sourceFileRemoved = false;
+            }
+        }
+        return { ...transactionResult, sourceFileRemoved };
+    }
+    async deleteImportTaskTransientRows(manager, scope, task) {
+        await manager.getRepository(CatalogReviewBlock).delete({ ...activeScope(scope), importTaskId: task.id });
+        await this.deleteEmptyImportCatalogBatch(manager, scope, task.id, ControlledCatalogBatch, ControlledGoodsRecord, ControlledCatalogImportIssue);
+        await this.deleteEmptyImportCatalogBatch(manager, scope, task.id, SanctionCatalogBatch, SanctionedCompanyRecord, SanctionCatalogImportIssue);
+    }
+    async deleteEmptyImportCatalogBatch(manager, scope, importTaskId, batchEntity, recordEntity, issueEntity) {
+        const batchRepo = manager.getRepository(batchEntity);
+        const batch = await batchRepo.findOne({ where: { ...activeScope(scope), importTaskId } });
+        if (!batch)
+            return;
+        const committedRows = await manager.getRepository(recordEntity).count({
+            where: { ...activeScope(scope), batchId: batch.id }
+        });
+        if (committedRows > 0)
+            return;
+        await manager.getRepository(issueEntity).delete({ ...activeScope(scope), batchId: batch.id });
+        await batchRepo.delete({ ...activeScope(scope), id: batch.id });
+    }
+    async importSourceFileStillReferenced(manager, scope, task) {
+        const where = { ...activeScope(scope), sourceFileId: task.sourceFileId };
+        const [otherTasks, controlledBatches, sanctionBatches, contracts, orders] = await Promise.all([
+            manager.getRepository(ImportTask).count({ where: { ...where, id: Not(task.id) } }),
+            manager.getRepository(ControlledCatalogBatch).count({ where }),
+            manager.getRepository(SanctionCatalogBatch).count({ where }),
+            manager.getRepository(CustomerContract).count({ where }),
+            manager.getRepository(PurchaseOrder).count({ where })
+        ]);
+        return otherTasks + controlledBatches + sanctionBatches + contracts + orders > 0;
+    }
     async listActiveCustomerContractReanalyses(scope) {
         const [contracts, tasks] = await Promise.all([
             this.dataSource.getRepository(CustomerContract).find({ where: { ...activeScope(scope), currentReanalysisRunId: Not(IsNull()), deletedAt: IsNull() } }),
@@ -1045,6 +1132,8 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
             const task = await required(repo.findOne({
                 where: { ...activeScope(scope), id: taskId }, lock: { mode: 'pessimistic_write' }
             }), '解析任务不存在');
+            if (isCanceledImportTask(task))
+                return task;
             if (task.observerConversationId && task.observerConversationId !== normalizedConversationId) {
                 throw new DomainError(DomainErrorCodes.INVALID_INPUT, '观察会话标识不一致');
             }
@@ -1489,6 +1578,12 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
             return repo.save(task);
         });
     }
+    async isImportTaskCanceled(scope, id) {
+        const task = await this.dataSource.getRepository(ImportTask).findOne({
+            where: { ...activeScope(scope), id }
+        });
+        return !task || isCanceledImportTask(task);
+    }
     async markImportCommandDispatched(scope, id) {
         return this.dataSource.transaction(async (manager) => {
             const repo = manager.getRepository(ImportTask);
@@ -1530,6 +1625,12 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
             });
             if (!task)
                 return { accepted: false, reason: 'scope_mismatch', sequence: 0 };
+            if (isCanceledImportTask(task)) {
+                return {
+                    accepted: false, reason: 'task_canceled',
+                    sequence: task.handoffCallbackSequence ?? 0
+                };
+            }
             if (!handoffCallbackIdentityMatches(input, `trade-compliance-import-task-${task.id}`, task.targetAssistantId))
                 return { accepted: false, reason: 'identity_mismatch', sequence: task.handoffCallbackSequence ?? 0 };
             const currentSequence = task.handoffCallbackSequence ?? 0;
@@ -3351,6 +3452,9 @@ function assertImportTaskResultWritable(task) {
         throw new DomainError(DomainErrorCodes.INVALID_INPUT, '解析任务状态不允许保存结果');
     }
 }
+function isCanceledImportTask(task) {
+    return task.status === 'CANCELED' || Boolean(task.deletedAt);
+}
 function throwImportTaskTerminalState(task) {
     const message = task.status === 'FAILED' || task.status === 'TIMED_OUT'
         ? task.errorMessage || '解析任务未成功完成'