fix: enforce carrier-specific channel group routing

api/src/channels/channels.service.ts

@@ -24,6 +24,7 @@ export interface CreateChannelDto {
 export interface CreateChannelGroupDto {
   code: string;
   name: string;
+  carrier: string;
   description?: string;
   status?: string;
   retryEnabled?: boolean;
@@ -391,10 +392,12 @@ export class ChannelsService {
     if (!Number.isInteger(retryTimeLimitHours) || retryTimeLimitHours <= 0 || retryTimeLimitHours > 72) {
       throw new BadRequestException('retryTimeLimitHours must be an integer between 1 and 72');
     }
+    const carrier = normalizeBusinessCarrier(data.carrier);
     return this.prisma.smsChannelGroup.create({
       data: {
         code: data.code,
         name: data.name,
+        carrier,
         description: data.description,
         status: data.status ?? 'active',
         retryEnabled: data.retryEnabled ?? true,
@@ -404,17 +407,51 @@ export class ChannelsService {
   }
 
   async addGroupItem(data: CreateChannelGroupItemDto) {
+    const group = await this.prisma.smsChannelGroup.findUnique({ where: { id: data.groupId } });
+    if (!group) {
+      throw new NotFoundException('Channel group not found');
+    }
+    const groupCarrier = normalizeBusinessCarrier(group.carrier);
+    const itemCarrier = data.carrier ? normalizeBusinessCarrier(data.carrier) : groupCarrier;
+    if (itemCarrier !== groupCarrier) {
+      throw new BadRequestException('Channel group items must use the same carrier as the channel group');
+    }
+    const channel = await this.prisma.smsChannel.findUnique({ where: { id: data.channelId } });
+    if (!channel) {
+      throw new NotFoundException('Channel not found');
+    }
+    if (!isChannelCarrierCompatible(channel.carrier, groupCarrier)) {
+      throw new BadRequestException('Channel carrier is not compatible with the channel group carrier');
+    }
+    if (data.province && !isRegionCompatible(channel.sendRegion, data.province)) {
+      throw new BadRequestException('Province route must use a channel with the same sendRegion');
+    }
     const existing = await this.prisma.smsChannelGroupItem.findFirst({
       where: { groupId: data.groupId, channelId: data.channelId },
     });
     if (existing) {
       throw new BadRequestException('通道组内不能重复配置同一通道');
     }
+    if (data.province) {
+      const existingProvince = await this.prisma.smsChannelGroupItem.findFirst({
+        where: { groupId: data.groupId, province: data.province },
+      });
+      if (existingProvince) {
+        throw new BadRequestException('同一通道组内同一省份只能配置一个通道');
+      }
+    } else {
+      const existingPriority = await this.prisma.smsChannelGroupItem.findFirst({
+        where: { groupId: data.groupId, province: null, priority: data.priority ?? 100 },
+      });
+      if (existingPriority) {
+        throw new BadRequestException('同一通道组内全国通道优先级不能重复');
+      }
+    }
     return this.prisma.smsChannelGroupItem.create({
       data: {
         groupId: data.groupId,
         channelId: data.channelId,
-        carrier: data.carrier,
+        carrier: itemCarrier,
         province: data.province,
         priority: data.priority ?? 100,
         weight: data.weight ?? 1,
@@ -432,26 +469,34 @@ export class ChannelsService {
     });
   }
 
-  createRouteRule(data: CreateRouteRuleDto) {
+  async createRouteRule(data: CreateRouteRuleDto) {
     if (!data.applicationId) {
       throw new BadRequestException('applicationId is required for channel group routing');
     }
     if (!data.carrier) {
       throw new BadRequestException('carrier is required for application channel group routing');
     }
+    const carrier = normalizeBusinessCarrier(data.carrier);
     if (data.channelId) {
       throw new BadRequestException('Route rules can only bind channel groups, not single channels');
     }
     if (data.province) {
       throw new BadRequestException('Province routing must be configured inside the channel group');
     }
+    const group = await this.prisma.smsChannelGroup.findUnique({ where: { id: data.groupId } });
+    if (!group) {
+      throw new NotFoundException('Channel group not found');
+    }
+    if (normalizeBusinessCarrier(group.carrier) !== carrier) {
+      throw new BadRequestException('Route rule carrier must match the channel group carrier');
+    }
     return this.prisma.channelRouteRule.create({
       data: {
         tenantId: data.tenantId,
         applicationId: data.applicationId,
         groupId: data.groupId,
         channelId: undefined,
-        carrier: data.carrier,
+        carrier,
         province: undefined,
         priority: data.priority ?? 100,
         status: data.status ?? 'active',
@@ -645,6 +690,36 @@ function normalizeConnectionAction(status: string) {
   return 'updated';
 }
 
+function normalizeBusinessCarrier(carrier?: string | null) {
+  const normalized = normalizeChannelCarrier(carrier);
+  if (!['mobile', 'unicom', 'telecom'].includes(normalized)) {
+    throw new BadRequestException('carrier must be mobile, unicom, or telecom');
+  }
+  return normalized;
+}
+
+function normalizeChannelCarrier(carrier?: string | null) {
+  const value = String(carrier ?? '').trim().toLowerCase();
+  if (['mobile', 'cmcc', '移动', '中国移动'].includes(value)) return 'mobile';
+  if (['unicom', 'cucc', '联通', '中国联通'].includes(value)) return 'unicom';
+  if (['telecom', 'ctcc', '电信', '中国电信'].includes(value)) return 'telecom';
+  if (['all', 'tri', '三网', '全网'].includes(value)) return 'all';
+  return value;
+}
+
+function isChannelCarrierCompatible(channelCarrier: string | null | undefined, groupCarrier: string) {
+  const normalized = normalizeChannelCarrier(channelCarrier);
+  return normalized === 'all' || normalized === groupCarrier;
+}
+
+function normalizeRegion(region?: string | null) {
+  return String(region ?? '').replace(/省|市|自治区|壮族|回族|维吾尔/g, '').trim();
+}
+
+function isRegionCompatible(channelRegion: string | null | undefined, itemProvince: string) {
+  return normalizeRegion(channelRegion) === normalizeRegion(itemProvince);
+}
+
 function normalizeLinkEvent(action: string) {
   if (action.includes('connected')) {
     return '新建';