feat: inherit channel report requirements

2026-07-12 16:14:54 +08:00
parent 053bcca990
commit 87ae4a2063
14 changed files with 612 additions and 65 deletions
@@ -181,6 +181,75 @@ export class SmsConfigService {
    return application;
  }

+  async getApplicationReportFields(applicationId: string, reportType?: 'signature' | 'drainage') {
+    await this.getApplication(applicationId);
+    const routes = await this.prisma.channelRouteRule.findMany({
+      where: { applicationId, status: 'active' },
+      include: {
+        group: {
+          include: {
+            items: {
+              include: {
+                channel: {
+                  include: {
+                    reportFields: { include: { drainageField: true }, orderBy: { sortOrder: 'asc' } },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+      orderBy: { priority: 'asc' },
+    });
+    type MergedReportField = {
+      id: string;
+      code: string;
+      name: string;
+      fieldType: string;
+      required: boolean;
+      description?: string | null;
+      reportTypes: string[];
+      channels: Array<{ id: string; code: string; name: string; groupId: string; groupName: string; required: boolean; reportType: string }>;
+    };
+    const merged = new Map<string, MergedReportField>();
+    for (const route of routes) {
+      if (!route.group) continue;
+      for (const item of route.group.items) {
+        for (const configured of item.channel.reportFields) {
+          if (configured.status !== 'active' || !configured.drainageField || configured.drainageField.status !== 'active') continue;
+          if (reportType && configured.reportType !== 'both' && configured.reportType !== reportType) continue;
+          const key = configured.drainageField.id;
+          const current: MergedReportField = merged.get(key) ?? {
+            id: configured.drainageField.id,
+            code: configured.drainageField.code,
+            name: configured.drainageField.name,
+            fieldType: configured.drainageField.fieldType,
+            required: false,
+            description: configured.drainageField.description,
+            reportTypes: [],
+            channels: [],
+          };
+          current.required = current.required || configured.required;
+          if (!current.reportTypes.includes(configured.reportType)) current.reportTypes.push(configured.reportType);
+          if (!current.channels.some((channel) => channel.id === item.channel.id)) {
+            current.channels.push({
+              id: item.channel.id,
+              code: item.channel.code,
+              name: item.channel.name,
+              groupId: route.group.id,
+              groupName: route.group.name,
+              required: configured.required,
+              reportType: configured.reportType,
+            });
+          }
+          merged.set(key, current);
+        }
+      }
+    }
+    return Array.from(merged.values());
+  }
+
  async createApplication(data: CreateSmsApplicationDto) {
    const secret = normalizeApplicationPassword(data.passwordCipher);
    const queuePriority = normalizeApplicationQueuePriority(data.queuePriority);
@@ -519,16 +588,20 @@ export class SmsConfigService {
    });
  }

-  createSignature(data: CreateSmsSignatureDto) {
-    return this.prisma.smsSignature.create({
+  async createSignature(data: CreateSmsSignatureDto) {
+    await this.validateSignatureReportValues(data.applicationId, data.drainageInfo);
+    const drainageInfo = await this.withReportRequirementSnapshot(data.applicationId, data.drainageInfo);
+    const signature = await this.prisma.smsSignature.create({
      data: {
        tenantId: data.tenantId,
        applicationId: data.applicationId,
        name: data.name,
        purpose: data.purpose,
-        drainageInfo: data.drainageInfo as Prisma.InputJsonValue | undefined,
+        drainageInfo: drainageInfo as Prisma.InputJsonValue | undefined,
      },
    });
+    await this.syncSignatureReportValues(signature.id, data.applicationId, drainageInfo);
+    return signature;
  }

  async updateSignature(signatureId: string, data: UpdateSmsSignatureDto) {
@@ -536,17 +609,114 @@ export class SmsConfigService {
    if (!signature) {
      throw new NotFoundException('Signature not found');
    }
-    return this.prisma.smsSignature.update({
+    await this.validateSignatureReportValues(data.applicationId ?? signature.applicationId ?? undefined, data.drainageInfo);
+    const applicationId = data.applicationId ?? signature.applicationId ?? undefined;
+    const drainageInfo = data.drainageInfo
+      ? await this.withReportRequirementSnapshot(applicationId, data.drainageInfo)
+      : undefined;
+    const updated = await this.prisma.smsSignature.update({
      where: { id: signatureId },
      data: {
        applicationId: data.applicationId,
        name: data.name,
        purpose: data.purpose,
        auditStatus: data.auditStatus,
-        drainageInfo: data.drainageInfo as Prisma.InputJsonValue | undefined,
+        drainageInfo: drainageInfo as Prisma.InputJsonValue | undefined,
      },
      include: { materials: true, tenant: true, application: true },
    });
+    await this.syncSignatureReportValues(signatureId, updated.applicationId ?? undefined, drainageInfo);
+    return updated;
+  }
+
+  private async withReportRequirementSnapshot(applicationId?: string, drainageInfo?: Record<string, unknown>) {
+    if (!drainageInfo || !applicationId) return drainageInfo;
+    const fields = await this.getApplicationReportFields(applicationId);
+    return {
+      ...drainageInfo,
+      reportRequirementSnapshot: {
+        capturedAt: new Date().toISOString(),
+        applicationId,
+        fields: fields.map((field) => ({
+          id: field.id,
+          code: field.code,
+          name: field.name,
+          fieldType: field.fieldType,
+          required: field.required,
+          reportTypes: field.reportTypes,
+          channels: field.channels,
+        })),
+      },
+    };
+  }
+
+  private async syncSignatureReportValues(signatureId: string, applicationId?: string, drainageInfo?: Record<string, unknown>) {
+    if (!applicationId || !drainageInfo) return;
+    const fields = await this.getApplicationReportFields(applicationId);
+    const signatureValues = isRecord(drainageInfo.signatureReportValues) ? drainageInfo.signatureReportValues : {};
+    const links = Array.isArray(drainageInfo.links) ? drainageInfo.links.filter(isRecord) : [];
+    const drainageItemIds = links.map((link) => String(link.id ?? '')).filter(Boolean);
+    await this.prisma.drainageReportMaterial.deleteMany({
+      where: {
+        signatureId,
+        ...(drainageItemIds.length > 0 ? { drainageItemId: { notIn: drainageItemIds } } : {}),
+      },
+    });
+    for (const field of fields.filter((item) => item.reportTypes.some((type) => type === 'signature' || type === 'both'))) {
+      const value = reportValueParts(signatureValues[field.code]);
+      for (const channel of field.channels) {
+        await this.prisma.signatureReportMaterial.upsert({
+          where: { signatureId_channelId_fieldCode: { signatureId, channelId: channel.id, fieldCode: field.code } },
+          update: value,
+          create: { signatureId, channelId: channel.id, fieldCode: field.code, ...value },
+        });
+      }
+    }
+    for (const link of links) {
+      const drainageItemId = String(link.id ?? '');
+      const values = isRecord(link.reportValues) ? link.reportValues : {};
+      if (!drainageItemId) continue;
+      for (const field of fields.filter((item) => item.reportTypes.some((type) => type === 'drainage' || type === 'both'))) {
+        const value = reportValueParts(values[field.code]);
+        for (const channel of field.channels) {
+          await this.prisma.drainageReportMaterial.upsert({
+            where: {
+              signatureId_drainageItemId_channelId_fieldCode: {
+                signatureId,
+                drainageItemId,
+                channelId: channel.id,
+                fieldCode: field.code,
+              },
+            },
+            update: value,
+            create: { signatureId, drainageItemId, channelId: channel.id, fieldCode: field.code, ...value },
+          });
+        }
+      }
+    }
+  }
+
+  private async validateSignatureReportValues(applicationId?: string, drainageInfo?: Record<string, unknown>) {
+    if (!applicationId || !drainageInfo) return;
+    const fields = await this.getApplicationReportFields(applicationId);
+    const signatureValues = isRecord(drainageInfo.signatureReportValues) ? drainageInfo.signatureReportValues : {};
+    const missingSignature = fields
+      .filter((field) => field.required && field.reportTypes.some((type) => type === 'signature' || type === 'both'))
+      .filter((field) => !hasReportValue(signatureValues[field.code]));
+    if (missingSignature.length > 0) {
+      throw new BadRequestException(`缺少必填签名报备资料：${missingSignature.map((field) => field.name).join('、')}`);
+    }
+    const drainageFields = fields.filter(
+      (field) => field.required && field.reportTypes.some((type) => type === 'drainage' || type === 'both'),
+    );
+    const links = Array.isArray(drainageInfo.links) ? drainageInfo.links.filter(isRecord) : [];
+    for (const link of links) {
+      const values = isRecord(link.reportValues) ? link.reportValues : {};
+      const missing = drainageFields.filter((field) => !hasReportValue(values[field.code]));
+      if (missing.length > 0) {
+        throw new BadRequestException(`引流信息缺少必填报备资料：${missing.map((field) => field.name).join('、')}`);
+      }
+    }
  }

  createSignatureMaterial(data: CreateSignatureMaterialDto) {
@@ -934,3 +1104,21 @@ function parseGatewayDate(value?: string) {
  const parsed = new Date(value);
  return Number.isNaN(parsed.getTime()) ? undefined : parsed;
 }
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function reportValueParts(value: unknown) {
+  if (isRecord(value) && typeof value.fileObjectId === 'string') {
+    return { fieldValue: typeof value.fileName === 'string' ? value.fileName : undefined, fileObjectId: value.fileObjectId };
+  }
+  return { fieldValue: value === undefined || value === null ? undefined : String(value), fileObjectId: undefined };
+}
+
+function hasReportValue(value: unknown) {
+  if (isRecord(value)) {
+    return Boolean(value.fileObjectId || value.fieldValue || value.value);
+  }
+  return value !== undefined && value !== null && String(value).trim().length > 0;
+}