feat: complete signature and drainage reporting workflows

api/src/channels/channels.service.spec.ts

@@ -216,6 +216,33 @@ describe('ChannelsService', () => {
     expect(tx.smsSignature.update).toHaveBeenCalledWith({ where: { id: 'sig-1' }, data: { reportStatus: 'approved' } });
   });
 
+  it('changes a drainage report task without overwriting the signature report summary', async () => {
+    const prisma = createPrismaMock();
+    const tx = {
+      smsSignature: {
+        findUnique: jest.fn().mockResolvedValue({ id: 'sig-1', tenantId: 'tenant-1', applicationId: 'app-1' }),
+        update: jest.fn(),
+      },
+      smsChannel: { findUnique: jest.fn().mockResolvedValue({ id: 'channel-1', carrier: 'mobile', status: 'active' }) },
+      channelSignatureReportTask: {
+        findFirst: jest.fn().mockResolvedValue({ id: 'drainage-task-1', signatureId: 'sig-1', channelId: 'channel-1', reportType: 'drainage', drainageItemId: 'drain-1', status: 'reporting' }),
+        update: jest.fn().mockResolvedValue({ id: 'drainage-task-1', status: 'approved' }),
+        create: jest.fn(),
+      },
+      channelSignatureReportRecord: { create: jest.fn().mockResolvedValue({ id: 'record-1' }) },
+    };
+    prisma.$transaction.mockImplementation((callback) => callback(tx));
+    const service = new ChannelsService(prisma as never);
+
+    await expect(service.changeReportTaskStatuses({
+      items: [{ signatureId: 'sig-1', channelId: 'channel-1', reportType: 'drainage', drainageItemId: 'drain-1', status: 'approved' }],
+      reason: '引流信息已报备',
+    })).resolves.toEqual([{ signatureId: 'sig-1', reportType: 'drainage', drainageItemId: 'drain-1', channelId: 'channel-1', status: 'approved' }]);
+    expect(tx.channelSignatureReportTask.findFirst).toHaveBeenCalledWith({ where: { signatureId: 'sig-1', channelId: 'channel-1', reportType: 'drainage', drainageItemId: 'drain-1' } });
+    expect(tx.channelSignatureReportRecord.create).toHaveBeenCalledWith({ data: expect.objectContaining({ action: 'manual_status_change', statusBefore: 'reporting', statusAfter: 'approved' }) });
+    expect(tx.smsSignature.update).not.toHaveBeenCalled();
+  });
+
   beforeEach(() => {
     mockQueueAdd.mockClear();
     mockQueueClose.mockClear();

api/src/channels/channels.service.ts

@@ -98,11 +98,13 @@ export interface CreateReportTaskDto {
   tenantId: string;
   signatureId: string;
   channelId: string;
+  reportType?: 'signature' | 'drainage';
+  drainageItemId?: string;
   createdById?: string;
 }
 
 export interface ChangeReportTaskStatusesDto {
-  items: Array<{ signatureId: string; channelId: string; status: string }>;
+  items: Array<{ signatureId: string; channelId: string; status: string; reportType?: 'signature' | 'drainage'; drainageItemId?: string }>;
   reason?: string;
   operatorId?: string;
 }
@@ -973,11 +975,15 @@ export class ChannelsService implements OnModuleInit, OnModuleDestroy {
   }
 
   async createReportTask(data: CreateReportTaskDto) {
+    const reportType = data.reportType ?? 'signature';
+    if (reportType === 'drainage' && !data.drainageItemId) throw new BadRequestException('drainageItemId is required');
     const task = await this.prisma.channelSignatureReportTask.create({
       data: {
         tenantId: data.tenantId,
         signatureId: data.signatureId,
         channelId: data.channelId,
+        reportType,
+        drainageItemId: reportType === 'drainage' ? data.drainageItemId : undefined,
         createdById: data.createdById,
         status: 'pending',
       },
@@ -993,20 +999,24 @@ export class ChannelsService implements OnModuleInit, OnModuleDestroy {
       if (!allowed.has(item.status)) throw new BadRequestException('unsupported report task status');
     }
     return this.prisma.$transaction(async (tx) => {
-      const signatureIds = [...new Set(data.items.map((item) => item.signatureId))];
+      const signatureIds = [...new Set(data.items.filter((item) => (item.reportType ?? 'signature') === 'signature').map((item) => item.signatureId))];
+      const drainageResults: Array<{ signatureId: string; reportType: 'drainage'; drainageItemId: string; channelId: string; status: string }> = [];
       for (const item of data.items) {
+        const reportType = item.reportType ?? 'signature';
+        if (reportType === 'drainage' && !item.drainageItemId) throw new BadRequestException('drainageItemId is required');
         const signature = await tx.smsSignature.findUnique({ where: { id: item.signatureId } });
         const channel = await tx.smsChannel.findUnique({ where: { id: item.channelId } });
         if (!signature || !channel) throw new NotFoundException('Signature or channel not found');
-        const existing = await tx.channelSignatureReportTask.findFirst({ where: { signatureId: item.signatureId, channelId: item.channelId } });
+        const existing = await tx.channelSignatureReportTask.findFirst({ where: { signatureId: item.signatureId, channelId: item.channelId, reportType, drainageItemId: reportType === 'drainage' ? item.drainageItemId : null } });
         const task = existing
           ? await tx.channelSignatureReportTask.update({ where: { id: existing.id }, data: { status: item.status, reason: data.reason } })
-          : await tx.channelSignatureReportTask.create({ data: { tenantId: signature.tenantId, signatureId: item.signatureId, channelId: item.channelId, status: item.status, reason: data.reason, createdById: data.operatorId } });
+          : await tx.channelSignatureReportTask.create({ data: { tenantId: signature.tenantId, signatureId: item.signatureId, channelId: item.channelId, reportType, drainageItemId: reportType === 'drainage' ? item.drainageItemId : undefined, status: item.status, reason: data.reason, createdById: data.operatorId } });
         await tx.channelSignatureReportRecord.create({ data: { taskId: task.id, channelId: item.channelId, action: 'manual_status_change', statusBefore: existing?.status, statusAfter: item.status, reason: data.reason, operatorId: data.operatorId } });
+        if (reportType === 'drainage') drainageResults.push({ signatureId: item.signatureId, reportType, drainageItemId: item.drainageItemId!, channelId: item.channelId, status: item.status });
       }
       const summaries = [];
       for (const signatureId of signatureIds) summaries.push(await this.recomputeSignatureReportSummary(tx, signatureId));
-      return summaries;
+      return [...summaries, ...drainageResults];
     });
   }
 
@@ -1018,7 +1028,7 @@ export class ChannelsService implements OnModuleInit, OnModuleDestroy {
       include: { group: { include: { items: { include: { channel: true } } } } },
     }) : [];
     const configuredChannels = routes.flatMap((route) => route.group.items.map((item) => item.channel)).filter((channel) => channel.status !== 'deleted');
-    const tasks = await tx.channelSignatureReportTask.findMany({ where: { signatureId }, include: { channel: true } });
+    const tasks = await tx.channelSignatureReportTask.findMany({ where: { signatureId, reportType: 'signature' }, include: { channel: true } });
     const channels = configuredChannels.length ? configuredChannels : tasks.map((task) => task.channel);
     const uniqueChannels = [...new Map(channels.map((channel) => [channel.id, channel])).values()];
     const taskByChannel = new Map(tasks.map((task) => [task.channelId, task]));
@@ -1067,7 +1077,9 @@ export class ChannelsService implements OnModuleInit, OnModuleDestroy {
       },
     });
     await this.updateReportTaskStatus(taskId, task.channelId, task.status, statusAfter, 'receipt_import', data.reason);
-    await this.recomputeSignatureReportSummary(this.prisma as unknown as Prisma.TransactionClient, task.signatureId);
+    if ((task.reportType ?? 'signature') === 'signature') {
+      await this.recomputeSignatureReportSummary(this.prisma as unknown as Prisma.TransactionClient, task.signatureId);
+    }
     return imported;
   }