feat: wire admin workflows to real APIs

api/src/channels/channels.service.ts

@@ -112,6 +112,12 @@ export interface ChangeChannelStatusDto {
   reason?: string;
 }
 
+export interface CopyChannelDto {
+  name?: string;
+  code?: string;
+  operatorId?: string;
+}
+
 @Injectable()
 export class ChannelsService {
   constructor(private readonly prisma: PrismaService) {}
@@ -164,6 +170,91 @@ export class ChannelsService {
     return updated;
   }
 
+  async copyChannel(channelId: string, data: CopyChannelDto = {}) {
+    const source = await this.prisma.smsChannel.findUnique({
+      where: { id: channelId },
+      include: { reportFields: true },
+    });
+    if (!source) {
+      throw new NotFoundException('Channel not found');
+    }
+
+    const suffix = Date.now().toString(36).toUpperCase();
+    const nextName = data.name ?? `${source.name}副本`;
+    const nextCode = data.code ?? `${source.code}-COPY-${suffix}`;
+
+    const copied = await this.prisma.$transaction(async (tx) => {
+      const nextChannel = await tx.smsChannel.create({
+        data: {
+          code: nextCode,
+          name: nextName,
+          carrier: source.carrier,
+          protocol: source.protocol,
+          gatewayHost: source.gatewayHost,
+          gatewayPort: source.gatewayPort,
+          enterpriseCode: source.enterpriseCode,
+          account: source.account,
+          passwordCipher: source.passwordCipher,
+          srcId: source.srcId,
+          cmppVersion: source.cmppVersion,
+          rateLimitPerSecond: source.rateLimitPerSecond,
+          unitPrice: source.unitPrice,
+          status: source.status,
+          config: source.config as Prisma.InputJsonValue | undefined,
+          reportFields: {
+            create: source.reportFields.map((field) => ({
+              code: field.code,
+              name: field.name,
+              fieldType: field.fieldType,
+              required: field.required,
+              description: field.description,
+              sortOrder: field.sortOrder,
+              status: field.status,
+            })),
+          },
+        },
+        include: { reportFields: true },
+      });
+
+      const reportMaterials = await tx.signatureReportMaterial.findMany({ where: { channelId } });
+      if (reportMaterials.length > 0) {
+        await tx.signatureReportMaterial.createMany({
+          data: reportMaterials.map((material) => ({
+            signatureId: material.signatureId,
+            channelId: nextChannel.id,
+            fieldCode: material.fieldCode,
+            fieldValue: material.fieldValue,
+            fileObjectId: material.fileObjectId,
+          })),
+          skipDuplicates: true,
+        });
+      }
+
+      await tx.operationLog.create({
+        data: {
+          userId: data.operatorId,
+          action: 'sms_channel.copy',
+          resource: 'sms_channel',
+          resourceId: nextChannel.id,
+          detail: {
+            sourceChannelId: source.id,
+            sourceCode: source.code,
+            copiedReportFields: source.reportFields.length,
+            copiedReportMaterials: reportMaterials.length,
+          } as Prisma.InputJsonValue,
+        },
+      });
+
+      return nextChannel;
+    });
+
+    return copied;
+  }
+
+  async deleteChannel(channelId: string, data: ChangeChannelStatusDto = { status: 'deleted' }) {
+    return this.changeChannelStatus(channelId, { ...data, status: 'deleted' });
+  }
+
   testChannel(channelId: string) {
     return {
       channelId,
@@ -188,6 +279,42 @@ export class ChannelsService {
     });
   }
 
+  async listChannelLinkLogs(channelId: string) {
+    const channel = await this.prisma.smsChannel.findUnique({ where: { id: channelId }, select: { id: true } });
+    if (!channel) {
+      throw new NotFoundException('Channel not found');
+    }
+    const [connectionStates, logs] = await Promise.all([
+      this.prisma.cmppConnectionState.findMany({
+        where: { channelId },
+        orderBy: { updatedAt: 'desc' },
+        take: 50,
+      }),
+      this.prisma.operationLog.findMany({
+        where: {
+          OR: [
+            { resource: 'sms_channel', resourceId: channelId },
+            { resource: 'cmpp_connection', resourceId: { startsWith: `${channelId}:` } },
+          ],
+        },
+        orderBy: { createdAt: 'desc' },
+        take: 100,
+      }),
+    ]);
+    return {
+      channelId,
+      connectionStates,
+      logs: logs.map((log) => ({
+        id: log.id,
+        time: log.createdAt,
+        event: normalizeLinkEvent(log.action),
+        action: log.action,
+        resourceId: log.resourceId,
+        detail: log.detail,
+      })),
+    };
+  }
+
   listTenantConnections(tenantId: string) {
     return this.prisma.cmppConnectionState.findMany({
       where: { tenantId },
@@ -197,7 +324,7 @@ export class ChannelsService {
     });
   }
 
-  upsertConnectionState(data: UpsertConnectionStateDto) {
+  async upsertConnectionState(data: UpsertConnectionStateDto) {
     const payload = {
       tenantId: data.tenantId,
       status: data.status,
@@ -209,7 +336,7 @@ export class ChannelsService {
       reconnectCount: data.reconnectCount ?? 0,
       lastError: data.lastError,
     };
-    return this.prisma.cmppConnectionState.upsert({
+    const state = await this.prisma.cmppConnectionState.upsert({
       where: { channelId_connectionId: { channelId: data.channelId, connectionId: data.connectionId } },
       update: payload,
       create: {
@@ -218,6 +345,21 @@ export class ChannelsService {
         ...payload,
       },
     });
+    await this.prisma.operationLog.create({
+      data: {
+        tenantId: data.tenantId,
+        action: `cmpp_connection.${normalizeConnectionAction(data.status)}`,
+        resource: 'cmpp_connection',
+        resourceId: `${data.channelId}:${data.connectionId}`,
+        detail: {
+          status: data.status,
+          desiredConnections: state.desiredConnections,
+          currentConnections: state.currentConnections,
+          lastError: state.lastError,
+        } as Prisma.InputJsonValue,
+      },
+    });
+    return state;
   }
 
   listGroups() {
@@ -445,3 +587,42 @@ export class ChannelsService {
     });
   }
 }
+
+function normalizeConnectionAction(status: string) {
+  const normalized = status.toLowerCase();
+  if (['online', 'connected', 'open'].includes(normalized)) {
+    return 'connected';
+  }
+  if (['heartbeat', 'active_test'].includes(normalized)) {
+    return 'heartbeat';
+  }
+  if (['reconnecting', 'reconnect'].includes(normalized)) {
+    return 'reconnecting';
+  }
+  if (['offline', 'closed', 'disconnected'].includes(normalized)) {
+    return 'disconnected';
+  }
+  return 'updated';
+}
+
+function normalizeLinkEvent(action: string) {
+  if (action.includes('connected')) {
+    return '新建';
+  }
+  if (action.includes('heartbeat')) {
+    return '心跳';
+  }
+  if (action.includes('reconnecting')) {
+    return '重连';
+  }
+  if (action.includes('disconnected')) {
+    return '断开';
+  }
+  if (action.includes('copy')) {
+    return '复制';
+  }
+  if (action.includes('deleted')) {
+    return '删除';
+  }
+  return '更新';
+}