修改配置

webServer/src/channels/factory/ChannelFactory.ts

@@ -10,6 +10,7 @@ import { QiAiH5ChannelHandler } from "../handlers/QiAiH5ChannelHandler";
 import { MuZiIosChannelHandler } from "../handlers/MuZiIosChannelHandler";
 import { MiniappChannelHandler } from "../handlers/MiniappChannelHandler";
 import { SYIOSChannelHandler } from "../handlers/SYIOSChannelHandler";
+import { MianyouChannelHandler } from "../handlers/MianyouChannelHandler";
 
 
 const logger = require("../../utils/log");
@@ -43,6 +44,7 @@ class ChannelFactory {
     this.registerHandler(10, new SanLiAndroidChannelHandler()); // muzi ios
     this.registerHandler(11, new MiniappChannelHandler()); // miniapp
     this.registerHandler(12, new SYIOSChannelHandler()); // sy ios
+    this.registerHandler(13, new MianyouChannelHandler()); // 面游渠道
   }
 
   /**

webServer/src/channels/handlers/MianyouChannelHandler.ts

@@ -0,0 +1,469 @@
+import {Context} from 'koa';
+import * as crypto from 'crypto';
+import {ChannelHandler, LoginResult, PaymentResult} from '../interfaces/ChannelHandler';
+import {ChannelConfig} from '../../config/channelConfig';
+import {PaymentHelper} from '../../utils/PaymentHelper';
+import axios from 'axios';
+
+const logger = require('../../utils/log');
+
+// 开服同步接口定义
+export interface ServerSyncParams {
+    GAME_ID: number;
+    SID: number;
+    _SID: number | string;
+    NAME: string;
+    START_TIME: string;
+    timestamp: number;
+    sign: string;
+}
+
+export interface ServerSyncResult {
+    status: number;
+    msg: string;
+}
+
+export class MianyouChannelHandler implements ChannelHandler {
+    /**
+     * 处理登录验证
+     * @param ctx Koa上下文
+     * @param config 渠道配置
+     * @returns 登录结果
+     */
+    async handleLogin(ctx: Context, config: ChannelConfig): Promise<LoginResult> {
+        try {
+            const data = ctx.request.body as any;
+            const {uid, timestamp, token} = data;
+            let username = uid;
+            // 验证必要参数
+            if (!username || !timestamp || !token) {
+                logger.warn('Mianyou登录验证失败: 缺少必要参数', {username, timestamp, token});
+                return {
+                    code: 400,
+                    msg: '缺少必要参数: username, timestamp, token'
+                };
+            }
+
+            // 获取登录验证密钥
+            const loginKey = config.loginConfig?.signKey;
+            if (!loginKey) {
+                logger.error('Mianyou登录验证失败: 未配置登录密钥');
+                return {
+                    code: 500,
+                    msg: '服务器配置错误: 未配置登录密钥'
+                };
+            }
+
+            // 验证token
+            const expectedToken = this.generateToken(username, timestamp, loginKey);
+            if (token.toLowerCase() !== expectedToken.toLowerCase()) {
+                console.log("timestamp:", timestamp,username,loginKey);
+                logger.warn('Mianyou登录验证失败: token验证失败', {
+                    loginKey,
+                    username,
+                    timestamp,
+                    receivedToken: token,
+                    expectedToken
+                });
+                return {
+                    code: 401,
+                    msg: '登录验证失败: token无效'
+                };
+            }
+
+            // 验证时间戳（可选：检查时间戳是否在有效期内，比如5分钟内）
+            const currentTime = Math.floor(Date.now() / 1000);
+            const timeDiff = Math.abs(currentTime - timestamp);
+            const maxTimeDiff = 300; // 5分钟
+
+            if (timeDiff > maxTimeDiff) {
+                logger.warn('Mianyou登录验证失败: 时间戳过期', {
+                    username,
+                    timestamp,
+                    currentTime,
+                    timeDiff
+                });
+                return {
+                    code: 401,
+                    msg: '登录验证失败: 时间戳过期'
+                };
+            }
+
+            logger.info('Mianyou登录验证成功', {username, timestamp});
+
+            return {
+                code: 0,
+                msg: '登录验证成功',
+                data: {
+                    username,
+                    timestamp,
+                    channelId: config.channelId,
+                    platform: config.platform
+                }
+            };
+
+        } catch (error) {
+            logger.error('Mianyou登录验证异常', error);
+            return {
+                code: 500,
+                msg: '服务器内部错误'
+            };
+        }
+    }
+
+    /**
+     * 处理支付验证
+     * @param ctx Koa上下文
+     * @param config 渠道配置
+     * @returns 支付结果
+     */
+    async handlePayment(ctx: Context, config: ChannelConfig): Promise<PaymentResult> {
+        try {
+            // 获取GET请求参数
+            const params = ctx.query as any;
+            const {
+                username,
+                order_id,
+                server,
+                amount,
+                extra,
+                sandbox,
+                timestamp,
+                sign
+            } = params;
+            let cpOrderId = extra
+            // 验证必要参数
+            if (!username || !order_id || !server || !amount || !extra|| !sandbox || !timestamp || !sign) {
+                logger.warn('Mianyou支付验证失败: 缺少必要参数', {
+                    username, order_id, server, amount, extra, sandbox, timestamp, sign
+                });
+                return {
+                    code: 400,
+                    msg: '缺少必要参数'
+                };
+            }
+
+            // 获取支付回调密钥
+            const paymentKey = config.paymentConfig?.signKey;
+            if (!paymentKey) {
+                logger.error('Mianyou支付验证失败: 未配置支付回调密钥');
+                return {
+                    code: 500,
+                    msg: '服务器配置错误: 未配置支付回调密钥'
+                };
+            }
+
+            // 验证签名
+            const expectedSign = this.generatePaymentSign(
+                username,
+                order_id,
+                server,
+                amount,
+                extra,
+                sandbox,
+                timestamp,
+                paymentKey
+            );
+
+            if (sign.toLowerCase() !== expectedSign.toLowerCase()) {
+                logger.warn('Mianyou支付验证失败: 签名验证失败', {
+                    username,
+                    order_id,
+                    receivedSign: sign,
+                    expectedSign
+                });
+                return {
+                    code: 401,
+                    msg: '支付验证失败: 签名无效'
+                };
+            }
+
+            // 验证时间戳（5分钟内有效）
+            const currentTime = Math.floor(Date.now() / 1000);
+            const timeDiff = Math.abs(currentTime - parseInt(timestamp));
+            const maxTimeDiff = 300; // 5分钟
+
+            // if (timeDiff > maxTimeDiff) {
+            //     logger.warn('Mianyou支付验证失败: 时间戳过期', {
+            //         username,
+            //         order_id,
+            //         timestamp,
+            //         currentTime,
+            //         timeDiff
+            //     });
+            //     return {
+            //         code: 401,
+            //         msg: '支付验证失败: 时间戳过期'
+            //     };
+            // }
+
+            // 验证金额格式
+            const paymentAmount = parseFloat(amount);
+            if (isNaN(paymentAmount) || paymentAmount <= 0) {
+                logger.warn('Mianyou支付验证失败: 金额格式错误', {
+                    username,
+                    cpOrderId,
+                    amount
+                });
+                return {
+                    code: 400,
+                    msg: '支付验证失败: 金额格式错误'
+                };
+            }
+
+            // 验证沙盒参数
+            const sandboxValue = parseInt(sandbox);
+            if (sandboxValue !== 0 && sandboxValue !== 1) {
+                logger.warn('Mianyou支付验证失败: 沙盒参数错误', {
+                    username,
+                    order_id,
+                    sandbox
+                });
+                return {
+                    code: 400,
+                    msg: '支付验证失败: 沙盒参数错误'
+                };
+            }
+
+            logger.info('Mianyou支付验证成功，开始处理发货', {
+                username,
+                cpOrderId,
+                order_id,
+                server,
+                amount: paymentAmount,
+                extra,
+                sandbox: sandboxValue === 1
+            });
+
+            // 验证订单
+            const validation = await PaymentHelper.validateOrder(cpOrderId);
+            if (!validation.valid) {
+                return {
+                    code: validation.message?.includes("重复发货") ? 1 : 0,
+                    msg: validation.message || "订单验证失败"
+                };
+            }
+            const orderInfo = validation.orderInfo;
+
+            // 直接调用系统封装的发货函数
+            const result = await PaymentHelper.deliverOrder(
+                orderInfo,
+                "127.0.0.1", // 使用默认IP地址
+                validation.url,
+                order_id // 使用订单号作为外部交易号
+            );
+
+            // 处理支付成功逻辑
+            logger.info(`Mianyou支付成功 - 用户: ${username}, 金额: ${paymentAmount}, 订单: ${cpOrderId}, 发货结果:`, result);
+            return result;
+
+        } catch (error) {
+            logger.error('Mianyou支付验证异常', error);
+            return {
+                code: 500,
+                msg: '服务器内部错误'
+            };
+        }
+    }
+
+    /**
+     * 生成token
+     * 根据文档：token = md5(username + timestamp + KEY)
+     * @param username 用户名
+     * @param timestamp 时间戳
+     * @param key 密钥
+     * @returns MD5哈希值（小写）
+     */
+    private generateToken(username: string, timestamp: number, key: string): string {
+        const data = username + timestamp + key;
+        console.log('generateToken data:', data);
+        return crypto.createHash('md5').update(data).digest('hex').toLowerCase();
+    }
+
+    /**
+     * 生成支付签名
+     * 根据文档：sign = md5(username + order_id + server + amount + extra + sandbox + timestamp + KEY)
+     * @param username 用户名
+     * @param order_id 订单号
+     * @param server 区服ID
+     * @param amount 支付金额
+     * @param extra 透传参数
+     * @param sandbox 沙盒标识
+     * @param timestamp 时间戳
+     * @param key 密钥
+     * @returns MD5哈希值（小写）
+     */
+    private generatePaymentSign(
+        username: string,
+        order_id: string,
+        server: string,
+        amount: string,
+        extra: string,
+        sandbox: string,
+        timestamp: string,
+        key: string
+    ): string {
+        const data = username + order_id + server + amount + extra + sandbox + timestamp + key;
+        return crypto.createHash('md5').update(data).digest('hex').toLowerCase();
+    }
+
+    /**
+     * 开服同步
+     * @param params 开服同步参数
+     * @param config 渠道配置
+     * @returns 同步结果
+     */
+    async syncServerOpen(params: Omit<ServerSyncParams, 'sign'>, config: ChannelConfig): Promise<ServerSyncResult> {
+        try {
+            // 获取游戏ID和密钥
+            const gameId = config.paymentConfig?.gameId;
+            const signKey = config.paymentConfig?.signKey;
+
+            if (!gameId || !signKey) {
+                logger.error('Mianyou开服同步失败: 缺少游戏ID或签名密钥');
+                return {
+                    status: -2,
+                    msg: '配置错误: 缺少游戏ID或签名密钥'
+                };
+            }
+
+            // 构建参数对象
+            const syncParams: Omit<ServerSyncParams, 'sign'> = {
+                GAME_ID: parseInt(gameId.toString()),
+                SID: params.SID,
+                _SID: params._SID,
+                NAME: params.NAME,
+                START_TIME: params.START_TIME,
+                timestamp: params.timestamp || Math.floor(Date.now() / 1000)
+            };
+
+            // 生成签名
+            const sign = this.generateServerSyncSign(syncParams, signKey);
+
+            // 构建完整参数
+            const fullParams: ServerSyncParams = {
+                ...syncParams,
+                sign
+            };
+
+            // 发送开服同步请求
+            const result = await this.sendServerSyncRequest(fullParams, config);
+
+            logger.info('Mianyou开服同步结果', {
+                params: syncParams,
+                result
+            });
+
+            return result;
+
+        } catch (error) {
+            logger.error('Mianyou开服同步异常', error);
+            return {
+                status: -9,
+                msg: '开服同步失败: 服务器内部错误'
+            };
+        }
+    }
+
+    /**
+     * 生成开服同步签名
+     * 根据文档：将所有参数按a-z升序排序后，将值直接拼接起来后再与密钥拼接，然后md5
+     * @param params 参数对象（不包含sign）
+     * @param key 签名密钥
+     * @returns MD5哈希值（小写）
+     */
+    private generateServerSyncSign(params: Omit<ServerSyncParams, 'sign'>, key: string): string {
+        // 按a-z升序排序参数
+        const sortedKeys = Object.keys(params).sort();
+
+        // 拼接所有参数值
+        const toSign = sortedKeys.map(key => params[key as keyof typeof params]).join('');
+
+        // 与密钥拼接后MD5
+        const data = toSign + key;
+        return crypto.createHash('md5').update(data).digest('hex').toLowerCase();
+    }
+
+    /**
+     * 发送开服同步请求
+     * @param params 完整参数（包含sign）
+     * @param config 渠道配置
+     * @returns 同步结果
+     */
+    private async sendServerSyncRequest(params: ServerSyncParams, config: ChannelConfig): Promise<ServerSyncResult> {
+        try {
+            // 构建请求URL
+            const sdkDomain = config.paymentConfig?.apiUrl;
+            const url = `${sdkDomain}/game/center/sync_server`;
+
+            // 构建form-data格式的请求体
+            const formData = new URLSearchParams();
+            Object.entries(params).forEach(([key, value]) => {
+                formData.append(key, value.toString());
+            });
+
+            logger.info('发送开服同步请求', {url, params});
+
+            // 发送POST请求
+            const response = await axios.post(url, formData, {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded'
+                },
+                timeout: 10000
+            });
+
+            // 解析响应
+            const result = typeof response.data === 'string' ? JSON.parse(response.data) : response.data;
+
+            logger.info('开服同步响应', {result});
+
+            return {
+                status: result.status || 0,
+                msg: result.msg || '未知响应'
+            };
+
+        } catch (error) {
+            logger.error('发送开服同步请求失败', error);
+            return {
+                status: -9,
+                msg: '网络请求失败'
+            };
+        }
+    }
+
+    /**
+     * 便捷的开服同步方法
+     * @param serverId 区服序号
+     * @param gameServerId 游戏区服ID
+     * @param serverName 区服名称
+     * @param startTime 开服时间
+     * @param config 渠道配置
+     * @returns 同步结果
+     */
+    async openServer(
+        serverId: number,
+        gameServerId: number | string,
+        serverName: string,
+        startTime: string,
+        config: ChannelConfig
+    ): Promise<ServerSyncResult> {
+        // 获取游戏ID
+        const gameId = config.paymentConfig?.gameId;
+        if (!gameId) {
+            return {
+                status: -2,
+                msg: '配置错误: 缺少游戏ID'
+            };
+        }
+
+        return await this.syncServerOpen({
+            GAME_ID: parseInt(gameId.toString()),
+            SID: serverId,
+            _SID: gameServerId,
+            NAME: serverName,
+            START_TIME: startTime,
+            timestamp: Math.floor(Date.now() / 1000)
+        }, config);
+    }
+
+}

webServer/src/config/channelConfig.ts

@@ -27,7 +27,12 @@ import {
     MINI_APP_GAME_ID,
     MINI_APP_API_KEY,
     MINI_APP_STAT_API_KEY,
-    SY_IOS_PRIVATE_KEY, SY_IOS_GAME_ID
+    SY_IOS_PRIVATE_KEY, 
+    SY_IOS_GAME_ID,
+    MIANYOU_LOGIN_KEY,
+    MIANYOU_PAYMENT_KEY,
+    MIANYOU_GAME_ID,
+    MIANYOU_SDK_DOMAIN
 } from "./thirdParams";
 
 // 渠道配置接口定义
@@ -211,7 +216,7 @@ export const channelConfigs: Record<number, ChannelConfig> = {
     },
     12: {
         // ios
-        channelId: 11,
+        channelId: 12,
         name: "ios",
         platform: "sy_ios",
         paymentConfig: {
@@ -222,4 +227,18 @@ export const channelConfigs: Record<number, ChannelConfig> = {
             signKey: SY_IOS_PRIVATE_KEY,
         },
     },
+    13: {
+        // 勉游渠道
+        channelId: 13,
+        name: "勉游",
+        platform: "mianyou",
+        paymentConfig: {
+            signKey: MIANYOU_PAYMENT_KEY,
+            gameId: MIANYOU_GAME_ID,
+            apiUrl: MIANYOU_SDK_DOMAIN,
+        },
+        loginConfig: {
+            signKey: MIANYOU_LOGIN_KEY,
+        },
+    },
 };

webServer/src/config/thirdParams.ts

@@ -103,4 +103,13 @@ export const MINI_APP_STAT_API_KEY = "your_stat_api_key_here";
 export const SY_IOS_PRIVATE_KEY = "rDfOG8nq4y9dH0oXfUwghcBQqllmJwrR";
 export const SY_IOS_GAME_ID = "1550";
 export const SY_IOS_API_KEY = "your_api_key_here";
-export const SY_IOS_STAT_API_KEY = "your_stat_api_key_here";
+export const SY_IOS_STAT_API_KEY = "your_stat_api_key_here";
+
+//勉游渠道
+export const MIANYOU_LOGIN_KEY = "5881827684e373b286b94f0091be0b6e";
+export const MIANYOU_PAYMENT_KEY = "5881827684e373b286b94f0091be0b6e";
+export const MIANYOU_GAME_ID = "109";
+export const MIANYOU_SDK_DOMAIN = "https://i.fist-game.com";
+
+
+

webServer/src/controller/ApiController.ts

@@ -1,23 +1,23 @@
 import Msg from "../utils/msg";
 import {
-  RefreshToken,
-  PackageName,
-  ProductId,
-  IosUrl,
-  Account,
-  ClientSecret,
-  ClientId,
-  ORDER_SIGN_KEY,
+    RefreshToken,
+    PackageName,
+    ProductId,
+    IosUrl,
+    Account,
+    ClientSecret,
+    ClientId,
+    ORDER_SIGN_KEY,
 } from "../config/thirdParams";
 import {
-  generateOrderNumber,
-  formatDate,
-  getServerList,
-  getClientIp,
+    generateOrderNumber,
+    formatDate,
+    getServerList,
+    getClientIp,
 } from "../utils/common";
-import { PaymentHelper } from "../utils/PaymentHelper";
-import { SignatureVerifier } from "../utils/SignatureVerifier";
-import { ChannelConfigManager } from "../utils/ChannelConfigManager";
+import {PaymentHelper} from "../utils/PaymentHelper";
+import {SignatureVerifier} from "../utils/SignatureVerifier";
+import {ChannelConfigManager} from "../utils/ChannelConfigManager";
 import {getRoleInfoByUidAndServerId} from "../mongo/mongodb";
 
 // 导入依赖
@@ -28,1405 +28,1472 @@ const System = require("../model/SystemModel");
 const User = require("../model/UserModel");
 const logger = require("../utils/log");
 const axios = require("axios");
-const { channelFactory } = require("../channels/factory/ChannelFactory");
+const {channelFactory} = require("../channels/factory/ChannelFactory");
+const {MianyouChannelHandler} = require("../channels/handlers/MianyouChannelHandler");
 
 /**
  * Google支付回调处理
  */
 const googleCallPay = async (ctx, config) => {
-  let data = ctx.request.body;
-  let orderId = data.orderId;
-  let googleToken = data.purchaseToken;
-  let out_trade_no = "";
-
-  logger.info("Google支付回调参数:", { url: ctx.href, params: data });
-
-  // 更新订单Token
-  await Order.updateOrderToken(orderId, googleToken, "google");
-
-  // 获取Google访问令牌
-  const redisClient = ctx.redis.client;
-  let access_token = await redisClient.get("access_token");
-
-  if (!access_token) {
-    logger.info("请求Google API获取token");
-    const apiData = {
-      grant_type: "refresh_token",
-      client_id: ClientId,
-      client_secret: ClientSecret,
-      refresh_token: RefreshToken,
-    };
+    let data = ctx.request.body;
+    let orderId = data.orderId;
+    let googleToken = data.purchaseToken;
+    let out_trade_no = "";
+
+    logger.info("Google支付回调参数:", {url: ctx.href, params: data});
+
+    // 更新订单Token
+    await Order.updateOrderToken(orderId, googleToken, "google");
+
+    // 获取Google访问令牌
+    const redisClient = ctx.redis.client;
+    let access_token = await redisClient.get("access_token");
+
+    if (!access_token) {
+        logger.info("请求Google API获取token");
+        const apiData = {
+            grant_type: "refresh_token",
+            client_id: ClientId,
+            client_secret: ClientSecret,
+            refresh_token: RefreshToken,
+        };
 
-    try {
-    const response = await axios.post(
-      "https://accounts.google.com/o/oauth2/token",
-      apiData,
-      {
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded",
-        },
-      }
-    );
+        try {
+            const response = await axios.post(
+                "https://accounts.google.com/o/oauth2/token",
+                apiData,
+                {
+                    headers: {
+                        "Content-Type": "application/x-www-form-urlencoded",
+                    },
+                }
+            );
+
+            logger.info("Google token响应:", {data: response.data});
+
+            if (!response.data.access_token) {
+                return PaymentHelper.DEFAULT_RESULT;
+            }
 
-      logger.info("Google token响应:", { data: response.data });
+            access_token = response.data.access_token;
+            await redisClient.set("access_token", response.data.access_token);
+            await redisClient.expire("access_token", 1800);
+        } catch (error) {
+            logger.error("获取Google token失败:", error);
+            return PaymentHelper.DEFAULT_RESULT;
+        }
+    }
 
-    if (!response.data.access_token) {
+    if (!access_token) {
         return PaymentHelper.DEFAULT_RESULT;
     }
 
-    access_token = response.data.access_token;
-    await redisClient.set("access_token", response.data.access_token);
-    await redisClient.expire("access_token", 1800);
-    } catch (error) {
-      logger.error("获取Google token失败:", error);
-      return PaymentHelper.DEFAULT_RESULT;
-    }
-  }
-
-  if (!access_token) {
-    return PaymentHelper.DEFAULT_RESULT;
-  }
-
-  // 验证订单
-  const validation = await PaymentHelper.validateOrder(orderId);
-  if (!validation.valid) {
-    return {
-      code: validation.message?.includes("重复发货") ? 1 : 0,
-      msg: validation.message,
-    };
-  }
-
-  const orderInfo = validation.orderInfo;
-
-  // 验证Google订单
-  const productId = ProductId + orderInfo.product_id;
-  let apiUrl = `https://androidpublisher.googleapis.com/androidpublisher/v3/applications/${PackageName}/purchases/products/${productId}/tokens/${googleToken}?access_token=${access_token}`;
-  let maxRetries = 3;
-  let currentRetry = 0;
-  let isCheck = false;
-
-  // 使用循环进行重试
-  while (currentRetry < maxRetries) {
-    try {
-      const googleRes = await axios.get(apiUrl, {
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded",
-        },
-      });
-
-      logger.info("Google验证响应:", googleRes.data);
-
-      if (googleRes.data.purchaseState == 0) {
-        out_trade_no = googleRes.data.orderId;
-        isCheck = true;
-        break;
-      }
-    } catch (error) {
-      logger.error("Google验证请求失败:", error);
+    // 验证订单
+    const validation = await PaymentHelper.validateOrder(orderId);
+    if (!validation.valid) {
+        return {
+            code: validation.message?.includes("重复发货") ? 1 : 0,
+            msg: validation.message,
+        };
     }
 
-    currentRetry++;
-  }
+    const orderInfo = validation.orderInfo;
+
+    // 验证Google订单
+    const productId = ProductId + orderInfo.product_id;
+    let apiUrl = `https://androidpublisher.googleapis.com/androidpublisher/v3/applications/${PackageName}/purchases/products/${productId}/tokens/${googleToken}?access_token=${access_token}`;
+    let maxRetries = 3;
+    let currentRetry = 0;
+    let isCheck = false;
+
+    // 使用循环进行重试
+    while (currentRetry < maxRetries) {
+        try {
+            const googleRes = await axios.get(apiUrl, {
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                },
+            });
+
+            logger.info("Google验证响应:", googleRes.data);
+
+            if (googleRes.data.purchaseState == 0) {
+                out_trade_no = googleRes.data.orderId;
+                isCheck = true;
+                break;
+            }
+        } catch (error) {
+            logger.error("Google验证请求失败:", error);
+        }
+
+        currentRetry++;
+    }
 
-  if (!isCheck) {
-    return PaymentHelper.DEFAULT_RESULT;
-  }
+    if (!isCheck) {
+        return PaymentHelper.DEFAULT_RESULT;
+    }
 
-  // 发货处理
-  const result = await PaymentHelper.deliverOrder(
-    orderInfo,
+    // 发货处理
+    const result = await PaymentHelper.deliverOrder(
+        orderInfo,
         ctx.request.ip,
-    validation.url,
-    out_trade_no
-      );
+        validation.url,
+        out_trade_no
+    );
 
-  // 确认和消费Google订单
-      try {
-    // 确认订单
+    // 确认和消费Google订单
+    try {
+        // 确认订单
         let acknowledgeUrl = `https://androidpublisher.googleapis.com/androidpublisher/v3/applications/${PackageName}/purchases/products/${productId}/tokens/${googleToken}:acknowledge?access_token=${access_token}`;
-    await axios.post(
-          acknowledgeUrl,
-      { developerPayload: "" },
-      { headers: { "Content-Type": "application/json" } }
-    );
+        await axios.post(
+            acknowledgeUrl,
+            {developerPayload: ""},
+            {headers: {"Content-Type": "application/json"}}
+        );
 
-    // 消费订单
+        // 消费订单
         let consumeUrl = `https://androidpublisher.googleapis.com/androidpublisher/v3/applications/${PackageName}/purchases/products/${productId}/tokens/${googleToken}:consume?access_token=${access_token}`;
-    await axios.post(
-          consumeUrl,
-      { developerPayload: "" },
-      { headers: { "Content-Type": "application/json" } }
-    );
+        await axios.post(
+            consumeUrl,
+            {developerPayload: ""},
+            {headers: {"Content-Type": "application/json"}}
+        );
 
-    logger.info("Google订单处理完成:", { orderId: orderId });
-      } catch (error) {
-    logger.error("Google订单确认/消费失败:", error);
-    // 即使确认/消费失败，我们仍然返回发货结果，因为发货可能已经成功
-  }
+        logger.info("Google订单处理完成:", {orderId: orderId});
+    } catch (error) {
+        logger.error("Google订单确认/消费失败:", error);
+        // 即使确认/消费失败，我们仍然返回发货结果，因为发货可能已经成功
+    }
 
-  return result;
+    return result;
 };
 
 /**
  * Apple支付回调处理
  */
 const appleCallPay = async (ctx, config) => {
-  let data = ctx.request.body;
-  logger.info("Apple支付回调参数:", { url: ctx.href, params: data });
+    let data = ctx.request.body;
+    logger.info("Apple支付回调参数:", {url: ctx.href, params: data});
 
-  if (!data.purchaseToken || !data.orderId) {
-    return PaymentHelper.DEFAULT_RESULT;
-  }
+    if (!data.purchaseToken || !data.orderId) {
+        return PaymentHelper.DEFAULT_RESULT;
+    }
 
-  let receipt_data = data.purchaseToken.replace(/ /g, "+");
-  let orderId = data.orderId;
-  let out_trade_no = orderId;
+    let receipt_data = data.purchaseToken.replace(/ /g, "+");
+    let orderId = data.orderId;
+    let out_trade_no = orderId;
 
-  // 更新订单Token
-  await Order.updateOrderToken(orderId, receipt_data, "apple");
+    // 更新订单Token
+    await Order.updateOrderToken(orderId, receipt_data, "apple");
 
-  // 验证Apple收据
-  let maxRetries = 5;
-  let currentRetry = 0;
-  let isCheck = false;
+    // 验证Apple收据
+    let maxRetries = 5;
+    let currentRetry = 0;
+    let isCheck = false;
 
-  while (currentRetry < maxRetries) {
-    try {
-      const apiData = {
-        "receipt-data": receipt_data,
-      };
-
-      const response = await axios.post(IosUrl, apiData, {
-        headers: {
-          "Content-Type": "application/json",
-        },
-      });
-
-      logger.info(`Apple验证响应状态:${response.data.status}`);
-
-      if (response.data.status == 0) {
-        isCheck = true;
-        break;
-      }
-    } catch (error) {
-      logger.error("Apple验证请求失败:", error);
+    while (currentRetry < maxRetries) {
+        try {
+            const apiData = {
+                "receipt-data": receipt_data,
+            };
+
+            const response = await axios.post(IosUrl, apiData, {
+                headers: {
+                    "Content-Type": "application/json",
+                },
+            });
+
+            logger.info(`Apple验证响应状态:${response.data.status}`);
+
+            if (response.data.status == 0) {
+                isCheck = true;
+                break;
+            }
+        } catch (error) {
+            logger.error("Apple验证请求失败:", error);
+        }
+
+        currentRetry++;
     }
 
-    currentRetry++;
-  }
-
-  if (!isCheck) {
-    logger.info(`Apple票据验证失败！`);
-    return { code: 0, msg: "票据验证失败！" };
-  }
-
-  // 验证订单
-  const validation = await PaymentHelper.validateOrder(orderId);
-  if (!validation.valid) {
-    return {
-      code: validation.message?.includes("重复发货") ? 1 : 0,
-      msg: validation.message,
-    };
-  }
-
-  const orderInfo = validation.orderInfo;
-
-  // 发货处理
-      logger.info(`订单${orderId}通知游戏发货开始`);
-  const result = await PaymentHelper.deliverOrder(
-    orderInfo,
+    if (!isCheck) {
+        logger.info(`Apple票据验证失败！`);
+        return {code: 0, msg: "票据验证失败！"};
+    }
+
+    // 验证订单
+    const validation = await PaymentHelper.validateOrder(orderId);
+    if (!validation.valid) {
+        return {
+            code: validation.message?.includes("重复发货") ? 1 : 0,
+            msg: validation.message,
+        };
+    }
+
+    const orderInfo = validation.orderInfo;
+
+    // 发货处理
+    logger.info(`订单${orderId}通知游戏发货开始`);
+    const result = await PaymentHelper.deliverOrder(
+        orderInfo,
         ctx.request.ip,
-    validation.url,
-    out_trade_no
-  );
-  logger.info(`订单${orderId}通知游戏发货结束，结果:`, result);
+        validation.url,
+        out_trade_no
+    );
+    logger.info(`订单${orderId}通知游戏发货结束，结果:`, result);
 
-  return result;
+    return result;
 };
 
 function splitString(input: string, separator: string): string[] {
-  return input.split(separator);
+    return input.split(separator);
 }
+
 //验证账号
 const checkUserToken = async (ctx) => {
-  let ip = getClientIp(ctx);
-
-  let {
-    uid,
-    channel_id,
-    device_no,
-    reg_device,
-    device_type,
-    device_model,
-    device_version,
-    system_version,
-  } = ctx.request.body;
-
-  const create_time = formatDate(new Date());
-  const accountInfo = (await User.checkAccountIsExist(uid, channel_id))[0];
-
-  let accountRes = null;
-  let res = null;
-  if (!accountInfo) {
-    accountRes = await User.createAccount(
-      uid,
-      channel_id,
-      ip,
-      device_no,
-      reg_device,
-      create_time
+    let ip = getClientIp(ctx);
+
+    let {
+        uid,
+        channel_id,
+        device_no,
+        reg_device,
+        device_type,
+        device_model,
+        device_version,
+        system_version,
+    } = ctx.request.body;
+
+    const create_time = formatDate(new Date());
+    const accountInfo = (await User.checkAccountIsExist(uid, channel_id))[0];
+
+    let accountRes = null;
+    let res = null;
+    if (!accountInfo) {
+        accountRes = await User.createAccount(
+            uid,
+            channel_id,
+            ip,
+            device_no,
+            reg_device,
+            create_time
+        );
+
+        if (accountRes.affectedRows <= 0) {
+            return ApiController.fail("添加账户失败");
+        }
+    }
+
+    res = await User.logAccountLogin(
+        uid,
+        ip,
+        device_type,
+        device_no,
+        device_model,
+        device_version,
+        system_version,
+        create_time,
+        channel_id
     );
 
-    if (accountRes.affectedRows <= 0) {
-      return ApiController.fail("添加账户失败");
+    if (res.affectedRows <= 0) {
+        return ApiController.fail("添加日志失败");
     }
-  }
-
-  res = await User.logAccountLogin(
-    uid,
-    ip,
-    device_type,
-    device_no,
-    device_model,
-    device_version,
-    system_version,
-    create_time,
-    channel_id
-  );
-
-  if (res.affectedRows <= 0) {
-    return ApiController.fail("添加日志失败");
-  }
-
-  return ApiController.success("请求成功", 1, false, { ip: ip });
+
+    return ApiController.success("请求成功", 1, false, {ip: ip});
 };
 
 class ApiController {
-  /**
-   * 生成成功响应
-   * @param msg 成功消息
-   * @param code 成功码，默认为1（部分API使用0表示成功）
-   * @param useMessage 是否使用message字段而不是msg字段，默认为false
-   * @param data 响应数据
-   * @returns 标准化的成功响应对象
-   */
-  static success(
-    msg: string = "请求成功",
-    code: number = 1,
-    useMessage: boolean = false,
-    data: any = null
-  ) {
-    return {
-      code: code,
-      [useMessage ? "message" : "msg"]: msg,
-      data: data,
-    };
-  }
-
-  /**
-   * 生成失败响应
-   * @param msg 错误消息
-   * @param code 错误码，默认为0
-   * @param data 额外的错误数据
-   * @param useMessage 是否使用message字段而不是msg字段，默认为false
-   * @returns 标准化的失败响应对象
-   */
-  static fail(
-    msg: string = "请求失败",
-    code: number = 0,
-    data: any = null,
-    useMessage: boolean = false
-  ) {
-    return {
-      code: code,
-      [useMessage ? "message" : "msg"]: msg,
-      data: data,
-    };
-  }
-
-  async createOrder(ctx) {
-    let {
-      uid,
-      level,
-      amount,
-      role_id,
-      role_name,
-      product_id,
-      server_id,
-      channel_id,
-    } = ctx.request.body;
-
-    logger.info("create params:", { params: ctx.request.body });
-
-    if (
-      !product_id ||
-      !server_id ||
-      !role_name ||
-      !role_id ||
-      !amount ||
-      !uid ||
-      !channel_id
+    /**
+     * 生成成功响应
+     * @param msg 成功消息
+     * @param code 成功码，默认为1（部分API使用0表示成功）
+     * @param useMessage 是否使用message字段而不是msg字段，默认为false
+     * @param data 响应数据
+     * @returns 标准化的成功响应对象
+     */
+    static success(
+        msg: string = "请求成功",
+        code: number = 1,
+        useMessage: boolean = false,
+        data: any = null
     ) {
-      ctx.body = ApiController.fail("参数错误,创建订单失败!!", -1);
-      return;
+        return {
+            code: code,
+            [useMessage ? "message" : "msg"]: msg,
+            data: data,
+        };
     }
 
-    const data = ctx.request.body;
-    if (!SignatureVerifier.verifyMD5Sign(data, ORDER_SIGN_KEY)) {
-      logger.error("创建订单签名验证失败");
-      ctx.body = ApiController.fail("签名错误,创建订单失败!!", -1);
-      return;
+    /**
+     * 生成失败响应
+     * @param msg 错误消息
+     * @param code 错误码，默认为0
+     * @param data 额外的错误数据
+     * @param useMessage 是否使用message字段而不是msg字段，默认为false
+     * @returns 标准化的失败响应对象
+     */
+    static fail(
+        msg: string = "请求失败",
+        code: number = 0,
+        data: any = null,
+        useMessage: boolean = false
+    ) {
+        return {
+            code: code,
+            [useMessage ? "message" : "msg"]: msg,
+            data: data,
+        };
     }
 
-    if (amount < 1) {
-      ctx.body = ApiController.fail("金额错误,创建订单失败!!", -1);
-      return;
-    }
+    async createOrder(ctx) {
+        let {
+            uid,
+            level,
+            amount,
+            role_id,
+            role_name,
+            product_id,
+            server_id,
+            channel_id,
+        } = ctx.request.body;
+
+        logger.info("create params:", {params: ctx.request.body});
+
+        if (
+            !product_id ||
+            !server_id ||
+            !role_name ||
+            !role_id ||
+            !amount ||
+            !uid ||
+            !channel_id
+        ) {
+            ctx.body = ApiController.fail("参数错误,创建订单失败!!", -1);
+            return;
+        }
 
-    const orderId = generateOrderNumber(); // 生成一个长度为8的订单号
-    const create_time = formatDate(new Date());
-    const res = await Order.createOrder(
-      orderId,
-      uid,
-      level,
-      amount,
-      role_id,
-      role_name,
-      product_id,
-      server_id,
-      channel_id,
-      create_time
-    );
+        const data = ctx.request.body;
+        if (!SignatureVerifier.verifyMD5Sign(data, ORDER_SIGN_KEY)) {
+            logger.error("创建订单签名验证失败");
+            ctx.body = ApiController.fail("签名错误,创建订单失败!!", -1);
+            return;
+        }
+
+        if (amount <= 0) {
+            ctx.body = ApiController.fail("金额错误,创建订单失败!!", -1);
+            return;
+        }
+
+        const orderId = generateOrderNumber(); // 生成一个长度为8的订单号
+        const create_time = formatDate(new Date());
+        const res = await Order.createOrder(
+            orderId,
+            uid,
+            level,
+            amount,
+            role_id,
+            role_name,
+            product_id,
+            server_id,
+            channel_id,
+            create_time
+        );
+
+        if (res.affectedRows > 0) {
+            ctx.body = ApiController.success("创建订单成功", 0, false, orderId);
+        } else {
+            ctx.body = ApiController.fail("创建订单失败", -1, null);
+        }
 
-    if (res.affectedRows > 0) {
-      ctx.body = ApiController.success("创建订单成功", 0, false, orderId);
-    } else {
-      ctx.body = ApiController.fail("创建订单失败", -1, null);
+        logger.info("创建订单返回结果:", {params: ctx.body});
     }
 
-    logger.info("创建订单返回结果:", { params: ctx.body });
-  }
-
-  async checkUserToken(ctx) {
-    let { channel_id } = ctx.request.body;
-    const channelConfig = ChannelConfigManager.getConfig(channel_id);
-    if (!channelConfig) {
-      logger.info("未找到渠道配置:", { channel_id });
-      ctx.body = {
-        code: 0,
-        msg: "未知渠道id",
-      };
-      return;
+    async checkUserToken(ctx) {
+        let {channel_id} = ctx.request.body;
+        const channelConfig = ChannelConfigManager.getConfig(channel_id);
+        if (!channelConfig) {
+            logger.info("未找到渠道配置:", {channel_id});
+            ctx.body = {
+                code: 0,
+                msg: "未知渠道id",
+            };
+            return;
+        }
+
+        var result = await checkUserToken(ctx);
+        ctx.body = result;
     }
 
-    var result = await checkUserToken(ctx);
-    ctx.body = result;
-  }
+    async thirdLogin(ctx) {
+        const data = ctx.request.body;
+        let channelId = parseInt(data.channel_id) || 1;
+        const platform = data.platform; // 平台参数：ios、Android、miniapp、h5
 
-  async thirdLogin(ctx) {
-    const data = ctx.request.body;
-    let channelId = parseInt(data.channel_id) || 1;
-    const platform = data.platform; // 平台参数：ios、Android、miniapp、h5
+        logger.info("thirdLogin请求参数:", {data, channelId, platform});
 
-    logger.info("thirdLogin请求参数:", { data, channelId, platform });
+        // 渠道11和渠道12数据打通，统一使用渠道11
+        if (channelId === 12) {
+            channelId = 11;
+            logger.info("渠道12映射到渠道11，平台参数:", platform);
+        }
 
-    // 渠道11和渠道12数据打通，统一使用渠道11
-    if (channelId === 12) {
-      channelId = 11;
-      logger.info("渠道12映射到渠道11，平台参数:", platform);
-    }
+        // 获取渠道配置
+        let channelConfig = ChannelConfigManager.getConfig(channelId);
 
-    // 获取渠道配置
-    let channelConfig = ChannelConfigManager.getConfig(channelId);
+        if (data.is_new == 1) {
+            if (channelId == 6) {
+                channelConfig = ChannelConfigManager.getConfig(999);
+            }
 
-    if (data.is_new == 1 ) {
-        if(channelId == 6){
-            channelConfig = ChannelConfigManager.getConfig(999);
+            if (channelId == 1) {
+                channelConfig = ChannelConfigManager.getConfig(9);
+            }
         }
 
-        if(channelId == 1){
-            channelConfig = ChannelConfigManager.getConfig(9);
+        if (!channelConfig) {
+            logger.info("未找到渠道配置:", {channelId});
+            ctx.body = ApiController.fail("未知渠道id");
+            return;
         }
-    }
 
-    if (!channelConfig) {
-      logger.info("未找到渠道配置:", { channelId });
-      ctx.body = ApiController.fail("未知渠道id");
-      return;
-    }
+        // 从工厂获取对应的渠道处理器
+        const handler = channelFactory.getHandler(channelId);
 
-    // 从工厂获取对应的渠道处理器
-    const handler = channelFactory.getHandler(channelId);
+        if (!handler) {
+            logger.info("未找到渠道处理器:", {channelId});
+            ctx.body = ApiController.fail("未知渠道id");
+            return;
+        }
 
-    if (!handler) {
-      logger.info("未找到渠道处理器:", { channelId });
-      ctx.body = ApiController.fail("未知渠道id");
-      return;
-    }
+        logger.info("使用渠道处理器处理登录:", {
+            channelId: channelId,
+            channelName: channelConfig.name,
+            platform: platform
+        });
 
-    logger.info("使用渠道处理器处理登录:", {
-      channelId: channelId,
-      channelName: channelConfig.name,
-      platform: platform
-    });
+        // 调用渠道处理器的登录方法
+        const result = await handler.handleLogin(ctx, channelConfig);
 
-    // 调用渠道处理器的登录方法
-    const result = await handler.handleLogin(ctx, channelConfig);
+        // 在返回结果中添加平台信息
+        if (result && result.data) {
+            result.data.platform = platform || 'unknown';
+        }
 
-    // 在返回结果中添加平台信息
-    if (result && result.data) {
-      result.data.platform = platform || 'unknown';
+        // 根据不同渠道的返回格式要求处理结果
+        ctx.body = result;
     }
 
-    // 根据不同渠道的返回格式要求处理结果
-    ctx.body = result;
-  }
+    async callPay(ctx) {
+        const data = ctx.request.body;
+        let channelId = 1; // 默认渠道ID
+        //打印回调参数
+        logger.info("callPay支付回调参数:", {url: ctx.href, params: data, query: ctx.query});
 
-  async callPay(ctx) {
-    const data = ctx.request.body;
-    let channelId = 1; // 默认渠道ID
-    //打印回调参数
-    logger.info("callPay支付回调参数:", { url: ctx.href, params: data, query: ctx.query });
+        // 从请求中获取渠道ID
+        if (ctx.query.channel_id) {
+            channelId = parseInt(ctx.query.channel_id);
+        }
 
-    // 从请求中获取渠道ID
-    if (ctx.query.channel_id) {
-      channelId = parseInt(ctx.query.channel_id);
-    }
+        if (data.channel_id) {
+            channelId = parseInt(data.channel_id);
+        }
 
-    if (data.channel_id) {
-      channelId = parseInt(data.channel_id);
-    }
+        logger.info("当前支付渠道id:", {channelId});
 
-    logger.info("当前支付渠道id:", { channelId });
+        // 获取渠道配置
+        let channelConfig = ChannelConfigManager.getConfig(channelId);
+        if (!channelConfig) {
+            logger.info("未找到渠道配置:", {channelId});
+            ctx.body = ApiController.fail("未知渠道id");
+            return;
+        }
 
-    // 获取渠道配置
-    let channelConfig = ChannelConfigManager.getConfig(channelId);
-    if (!channelConfig) {
-      logger.info("未找到渠道配置:", { channelId });
-      ctx.body = ApiController.fail("未知渠道id");
-      return;
-    }
+        if (ctx.query.is_new && ctx.query.is_new == 1) {
+            if (channelId == 6) {
+                channelConfig = ChannelConfigManager.getConfig(999);
+            }
 
-    if (ctx.query.is_new && ctx.query.is_new == 1 ) {
-        if(channelId == 6){
-            channelConfig = ChannelConfigManager.getConfig(999);
+            if (channelId == 1) {
+                channelConfig = ChannelConfigManager.getConfig(9);
+            }
         }
 
-        if(channelId == 1){
-            channelConfig = ChannelConfigManager.getConfig(9);
+        const handler = channelFactory.getHandler(channelId);
+
+        if (!handler) {
+            logger.info("未找到渠道处理器:", {channelId});
+            ctx.body = ApiController.fail("未知渠道id");
+            return;
         }
-    }
 
-    const handler = channelFactory.getHandler(channelId);
+        logger.info("使用渠道处理器处理支付:", {
+            channelId: channelId,
+            channelName: channelConfig.name,
+        });
 
-    if (!handler) {
-      logger.info("未找到渠道处理器:", { channelId });
-      ctx.body = ApiController.fail("未知渠道id");
-      return;
+        // 调用渠道处理器的支付方法
+        const result = await handler.handlePayment(ctx, channelConfig);
+        // 根据不同渠道的返回格式要求处理结果
+        switch (channelConfig.channelId) {
+            case 6:
+                ctx.body = result.code === 1 ? 1 : result.code;
+                break;
+            case 2:
+            case 3:
+            case 5:
+            case 8:
+                ctx.body = result.code === 1 ? "SUCCESS" : "Fail";
+                break;
+            case 7:
+                ctx.body = result.code === 1 ? "success" : "fail";
+                break;
+            case 11:
+                ctx.body = result.code === 1 ? "SUCCESS" : "Fail";
+                break;
+            case 12:
+                ctx.body = result.code === 1 ? "SUCCESS" : "Fail";
+                break;
+            case 13:
+                //{"status":0,"msg":"status 非 0 时，传入失败信息"}
+                ctx.body = {status: result.code === 1 ? 0 : -1, msg: result.msg};
+                break;
+            default:
+                ctx.body = result;
+        }
     }
 
-    logger.info("使用渠道处理器处理支付:", {
-      channelId: channelId,
-      channelName: channelConfig.name,
-    });
-
-    // 调用渠道处理器的支付方法
-    const result = await handler.handlePayment(ctx, channelConfig);
-    // 根据不同渠道的返回格式要求处理结果
-    switch (channelConfig.channelId) {
-      case 6:
-        ctx.body = result.code === 1 ? 1 : result.code;
-        break;
-      case 2:
-      case 3:
-      case 5:
-      case 8:
-        ctx.body = result.code === 1 ? "SUCCESS" : "Fail";
-        break;
-      case 7:
-        ctx.body = result.code === 1 ? "success" : "fail";
-        break;
-      case 11:
-        ctx.body = result.code === 1 ? "SUCCESS" : "Fail";
-        break;
-      case 12:
-        ctx.body = result.code === 1 ? "SUCCESS" : "Fail";
-        break;
-      default:
-        ctx.body = result;
+    async getServerList(ctx) {
+        let tag = ctx.query.channel_id || 1;
+        let data = ctx.request.body;
+        let ip = getClientIp(ctx);
+
+        // 尝试从渠道ID获取配置
+        const channelConfig = ChannelConfigManager.getConfig(1);
+        const signStr = data.timestamp + channelConfig.loginConfig?.signKey;
+        let newSign = CryptoJS.MD5(signStr).toString();
+
+        if (data.sign != newSign) {
+            console.log("signStr:", signStr);
+            logger.info(
+                `签名错误: 签名串 ${signStr} newSign ${newSign} sign ${data.sign}`
+            );
+            ctx.body = ApiController.fail("签名错误");
+            return;
+        }
+
+        let sort = data.sort == 0 ? "asc" : "desc";
+        logger.info("区服接口", {ip: ip});
+        const servers = await Server.getServerList(tag, 0, sort);
+
+        let serverList = [];
+        if (servers.length > 0) {
+            servers.forEach(function (element) {
+                let status = element.status;
+                if ((status == 0 || status == 3) && element.white_list) {
+                    const list = element.white_list.split(",");
+
+                    if (list.length > 0) {
+                        if (list.includes(ip)) {
+                            status = 1;
+                        }
+                    }
+                }
+
+                serverList.push({
+                    serverId: element.id,
+                    serverName: element.name,
+                });
+            });
+        }
+
+        ctx.body = ApiController.success("成功", 1, false, serverList);
     }
-  }
 
-  async getServerList(ctx) {
-    let tag = ctx.query.channel_id || 1;
-    let data = ctx.request.body;
-    let ip = getClientIp(ctx);
+    async getAllServerList(ctx) {
+        let tag = ctx.query.channel_id || 1;
+        let uid = ctx.query.uid || ctx.request.body?.uid; // uid是可选参数，支持GET和POST请求
+        let ip = getClientIp(ctx);
+        logger.info("getAllServerList 区服接口", {tag: tag, uid: uid, ip: ip});
+
+        const servers = await Server.getAllServerList(tag, ip);
 
-    // 尝试从渠道ID获取配置
-    const channelConfig = ChannelConfigManager.getConfig(1);
-    const signStr = data.timestamp + channelConfig.loginConfig?.signKey;
-    let newSign = CryptoJS.MD5(signStr).toString();
-
-    if (data.sign != newSign) {
-      console.log("signStr:", signStr);
-      logger.info(
-        `签名错误: 签名串 ${signStr} newSign ${newSign} sign ${data.sign}`
-      );
-      ctx.body = ApiController.fail("签名错误");
-      return;
+        // 如果提供了玩家ID，则查询每个服务器的角色信息；否则只返回基本服务器信息
+        if (uid) {
+            const {getRoleInfoByUidAndServerId} = require("../mongo/mongodb");
+
+            // 为每个服务器添加角色信息
+            const serversWithRoleInfo = await Promise.all(
+                servers.map(async (server) => {
+                    try {
+                        const newUniqueTag = `${server.tag}|${server.sid}|${uid}`;
+                        const roleInfo = await getRoleInfoByUidAndServerId(newUniqueTag, server.db_name);
+                        return {
+                            ...server,
+                            roleName: roleInfo?.roleName || null,
+                            roleLevel: roleInfo?.roleLevel || null,
+                            head: roleInfo?.head || null,
+                            hasRole: !!roleInfo
+                        };
+                    } catch (error) {
+                        logger.error(`查询服务器${server.id}角色信息失败:`, error);
+                        return {
+                            ...server,
+                            roleName: null,
+                            roleLevel: null,
+                            head: null,
+                            hasRole: false
+                        };
+                    }
+                })
+            );
+
+            ctx.body = serversWithRoleInfo;
+        } else {
+            ctx.body = servers;
+        }
     }
 
-    let sort = data.sort == 0 ? "asc" : "desc";
-    logger.info("区服接口", { ip: ip });
-    const servers = await Server.getServerList(tag, 0, sort);
+    async enterServer(ctx) {
+        let {uid, server_id, channel_id} = ctx.request.body;
 
-    let serverList = [];
-    if (servers.length > 0) {
-      servers.forEach(function (element) {
-        let status = element.status;
-        if ((status == 0 || status == 3) && element.white_list) {
-          const list = element.white_list.split(",");
+        let url = await getServerList(server_id, channel_id || 1);
+        if (!url) {
+            ctx.body = ApiController.fail(`区服id错误: serverId ${server_id}`, -1);
+            return;
+        }
 
-          if (list.length > 0) {
-            if (list.includes(ip)) {
-              status = 1;
-            }
-          }
+        logger.info("create params:", {params: ctx.request.body});
+
+        if (!server_id || !uid) {
+            ctx.body = ApiController.fail("参数错误!!", -1);
+            return;
         }
 
-        serverList.push({
-          serverId: element.id,
-          serverName: element.name,
-        });
-      });
-    }
+        const create_time = formatDate(new Date());
+        const serverInfo = (
+            await Server.checkEnterServerByUid(uid, server_id, channel_id)
+        )[0];
+        let res = null;
 
-    ctx.body = ApiController.success("成功", 1, false, serverList);
-  }
-  async getAllServerList(ctx) {
-    let tag = ctx.query.channel_id || 1;
-    let uid = ctx.query.uid || ctx.request.body?.uid; // uid是可选参数，支持GET和POST请求
-    let ip = getClientIp(ctx);
-    logger.info("getAllServerList 区服接口", { tag: tag, uid: uid, ip: ip });
-    
-    const servers = await Server.getAllServerList(tag, ip);
-    
-    // 如果提供了玩家ID，则查询每个服务器的角色信息；否则只返回基本服务器信息
-    if (uid) {
-      const { getRoleInfoByUidAndServerId } = require("../mongo/mongodb");
-      
-      // 为每个服务器添加角色信息
-      const serversWithRoleInfo = await Promise.all(
-        servers.map(async (server) => {
-          try {
-            const newUniqueTag = `${server.tag}|${server.sid}|${uid}`;
-            const roleInfo = await getRoleInfoByUidAndServerId(newUniqueTag, server.db_name);
-            return {
-              ...server,
-              roleName: roleInfo?.roleName || null,
-              roleLevel: roleInfo?.roleLevel || null,
-              head: roleInfo?.head || null,
-              hasRole: !!roleInfo
-            };
-          } catch (error) {
-            logger.error(`查询服务器${server.id}角色信息失败:`, error);
-            return {
-              ...server,
-              roleName: null,
-              roleLevel: null,
-              head: null,
-              hasRole: false
-            };
-          }
-        })
-      );
-      
-      ctx.body = serversWithRoleInfo;
-    } else {
-      ctx.body = servers;
+        if (serverInfo) {
+            res = await Server.updateEnterServer(serverInfo.id, create_time);
+        } else {
+            res = await Server.enterServer(uid, server_id, create_time, channel_id);
+        }
+
+        if (res.affectedRows > 0) {
+            ctx.body = ApiController.success("请求成功", 0, true, "");
+        } else {
+            ctx.body = ApiController.fail("请求失败", -1, null, true);
+        }
     }
-  }
 
-  async enterServer(ctx) {
-    let { uid, server_id, channel_id } = ctx.request.body;
+    async getLastServerList(ctx) {
+        let {uid, channel_id} = ctx.request.body;
+        // uid是可选参数，如果不提供则只返回基本服务器信息
+
+        let tag = channel_id || 1;
+        let data = [];
+        let isNewAccount = 1;
+        let enterServerList = [];
+        let ip = getClientIp(ctx);
+        logger.info("getLastServerList 区服接口", {uid: uid, ip: ip});
+
+        // 获取渠道配置
+        const channelConfig = ChannelConfigManager.getConfig(tag);
+        if (!channelConfig) {
+            logger.info("未找到渠道配置:", {tag});
+            ctx.body = ApiController.fail("未知渠道id");
+            return;
+        }
 
-    let url = await getServerList(server_id, channel_id || 1);
-    if (!url) {
-      ctx.body = ApiController.fail(`区服id错误: serverId ${server_id}`, -1);
-      return;
-    }
+        // 如果提供了uid，查询用户进入过的服务器列表
+        if (uid) {
+            enterServerList = await Server.getEnterServerListByUid(uid, channel_id);
+        }
 
-    logger.info("create params:", { params: ctx.request.body });
+        if (enterServerList.length > 0) {
+            isNewAccount = 0;
+            const servers = await Server.getAllServerList(tag, ip);
+            const {getRoleInfoByUidAndServerId} = require("../mongo/mongodb");
+
+            // 为每个进入过的服务器添加角色信息
+            for (const element of enterServerList) {
+                let roleInfo = null;
+                // 只有在提供了uid时才查询角色信息
+                if (uid) {
+                    try {
+                        const newUniqueTag = `${tag}|${element.server_id}|${uid}`;
+                        roleInfo = await getRoleInfoByUidAndServerId(newUniqueTag, element.db_name);
+                    } catch (error) {
+                        logger.error(`查询服务器${element.server_id}角色信息失败:`, error);
+                    }
+                }
+
+                data.push({
+                    channel: channelConfig.name, //渠道固定
+                    minSid: 1, //最小服务器
+                    maxSid: servers.length, //最大服务器 这里会控制 服务器列表显示的数量
+                    isNewAccount: isNewAccount, //1为新号 会弹出用户协议
+                    //以下是最近登陆的服务器 (不可为空 如果没有参数可以填最后一个区)
+                    sid: element.server_id || 1,
+                    id: element.server_id || 1,
+                    name: element.name || "1区",
+                    tips: element.tips || "",
+                    server: element.wss
+                        ? element.wss
+                        : `ws://${element.ip}:${element.port}`,
+                    status: element.status || 0,
+                    // 角色信息（只有在提供了uid时才包含）
+                    roleName: roleInfo?.roleName || null,
+                    roleLevel: roleInfo?.roleLevel || null,
+                    head: roleInfo?.head || null,
+                    hasRole: !!roleInfo
+                });
 
-    if (!server_id || !uid) {
-      ctx.body = ApiController.fail("参数错误!!", -1);
-      return;
+            }
+            logger.info("getLastServerList 区服接口 enterServerList", {
+                enterServerList: enterServerList,
+            });
+        } else {
+            const servers = await Server.getAllServerList(tag, ip);
+            let roleInfo = null;
+
+            if (servers.length > 0) {
+                const serverInfo = servers[servers.length - 1];
+                logger.info("getLastServerList 区服接口 serverInfo", {
+                    serverInfo: serverInfo,
+                });
+
+                // 只有在提供了uid时才查询最后一个服务器的角色信息
+                if (uid) {
+                    const {getRoleInfoByUidAndServerId} = require("../mongo/mongodb");
+                    try {
+                        const newUniqueTag = `${serverInfo.tag}|${serverInfo.sid}|${uid}`;
+                        roleInfo = await getRoleInfoByUidAndServerId(newUniqueTag, serverInfo.db_name);
+                    } catch (error) {
+                        logger.error(`查询服务器${serverInfo.id}角色信息失败:`, error);
+                    }
+                }
+
+                data.push({
+                    channel: channelConfig.name, //渠道固定
+                    minSid: 1, //最小服务器
+                    maxSid: servers.length, //最大服务器 这里会控制 服务器列表显示的数量
+                    isNewAccount: isNewAccount, //1为新号 会弹出用户协议
+                    //以下是最近登陆的服务器 (不可为空 如果没有参数可以填最后一个区)
+                    sid: serverInfo.sid || 1,
+                    id: serverInfo.id || 1,
+                    name: serverInfo.name || "1区",
+                    tips: serverInfo.tips || "",
+                    server: serverInfo.server
+                        ? serverInfo.server
+                        : `ws://${serverInfo.ip}:${serverInfo.port}/`,
+                    status: serverInfo.status || 0,
+                    // 角色信息
+                    roleName: roleInfo?.roleName || null,
+                    roleLevel: roleInfo?.roleLevel || null,
+                    head: roleInfo?.head || null,
+                    hasRole: !!roleInfo
+                });
+            } else {
+                data.push({
+                    channel: "未知", //渠道固定
+                    minSid: 1, //最小服务器
+                    maxSid: 10, //最大服务器 这里会控制 服务器列表显示的数量
+                    isNewAccount: isNewAccount, //1为新号 会弹出用户协议
+                    //以下是最近登陆的服务器 (不可为空 如果没有参数可以填最后一个区)
+                    sid: 1,
+                    id: 1,
+                    name: "1区",
+                    tips: "",
+                    server: "",
+                    status: 0,
+                    // 角色信息（新用户，无角色）
+                    roleName: null,
+                    roleLevel: null,
+                    head: null,
+                    hasRole: false
+                });
+            }
+        }
+        ctx.body = data;
+        // ctx.body = ApiController.success("获取最近服务器列表成功", 1, false, data);
     }
 
-    const create_time = formatDate(new Date());
-    const serverInfo = (
-      await Server.checkEnterServerByUid(uid, server_id, channel_id)
-    )[0];
-    let res = null;
+    async getNotice(ctx) {
+        let tag = ctx.query.channel_id || 1;
 
-    if (serverInfo) {
-      res = await Server.updateEnterServer(serverInfo.id, create_time);
-    } else {
-      res = await Server.enterServer(uid, server_id, create_time, channel_id);
-    }
+        let content = "";
+        let content_wh = "";
+        const system = await System.getSystemConfig(tag);
 
-    if (res.affectedRows > 0) {
-      ctx.body = ApiController.success("请求成功", 0, true, "");
-    } else {
-      ctx.body = ApiController.fail("请求失败", -1, null, true);
-    }
-  }
+        if (system) {
+            system.forEach((element) => {
+                if (element.key == "content") {
+                    content = element.value;
+                }
 
-  async getLastServerList(ctx) {
-    let { uid, channel_id } = ctx.request.body;
-    // uid是可选参数，如果不提供则只返回基本服务器信息
+                if (element.key == "content_wh") {
+                    content_wh = element.value;
+                }
+            });
+        }
 
-    let tag = channel_id || 1;
-    let data = [];
-    let isNewAccount = 1;
-    let enterServerList = [];
-    let ip = getClientIp(ctx);
-    logger.info("getLastServerList 区服接口", { uid: uid, ip: ip });
-
-    // 获取渠道配置
-    const channelConfig = ChannelConfigManager.getConfig(tag);
-    if (!channelConfig) {
-      logger.info("未找到渠道配置:", { tag });
-      ctx.body = ApiController.fail("未知渠道id");
-      return;
+        let notice_data = [
+            {
+                status: 1,
+                content: content,
+                content_wh: content_wh,
+            },
+        ];
+        ctx.body = notice_data;
+        // ctx.body = ApiController.success("获取公告成功", 1, false, notice_data);
     }
 
-    // 如果提供了uid，查询用户进入过的服务器列表
-    if (uid) {
-      enterServerList = await Server.getEnterServerListByUid(uid, channel_id);
-    }
+    // 维护服务器，踢掉所有玩家
+    async maintenance(ctx) {
+        let data = {
+            channel_id: parseInt(ctx.query.channel_id),
+            serverId: parseInt(ctx.query.serverId) || "",
+        };
 
-    if (enterServerList.length > 0) {
-      isNewAccount = 0;
-      const servers = await Server.getAllServerList(tag, ip);
-      const { getRoleInfoByUidAndServerId } = require("../mongo/mongodb");
-      
-      // 为每个进入过的服务器添加角色信息
-      for (const element of enterServerList) {
-          let roleInfo = null;
-          // 只有在提供了uid时才查询角色信息
-          if (uid) {
-            try {
-              const newUniqueTag = `${tag}|${element.server_id}|${uid}`;
-               roleInfo = await getRoleInfoByUidAndServerId(newUniqueTag, element.db_name);
-            } catch (error) {
-              logger.error(`查询服务器${element.server_id}角色信息失败:`, error);
-            }
-          }
-          
-          data.push({
-            channel: channelConfig.name, //渠道固定
-            minSid: 1, //最小服务器
-            maxSid: servers.length, //最大服务器 这里会控制 服务器列表显示的数量
-            isNewAccount: isNewAccount, //1为新号 会弹出用户协议
-            //以下是最近登陆的服务器 (不可为空 如果没有参数可以填最后一个区)
-            sid: element.server_id || 1,
-            id: element.server_id || 1,
-            name: element.name || "1区",
-            tips: element.tips || "",
-            server: element.wss
-                ? element.wss
-                : `ws://${element.ip}:${element.port}`,
-            status: element.status || 0,
-            // 角色信息（只有在提供了uid时才包含）
-            roleName: roleInfo?.roleName || null,
-            roleLevel: roleInfo?.roleLevel || null,
-            head: roleInfo?.head || null,
-            hasRole: !!roleInfo
-          });
-
-      }
-      logger.info("getLastServerList 区服接口 enterServerList", {
-        enterServerList: enterServerList,
-      });
-    } else {
-      const servers = await Server.getAllServerList(tag, ip);
-      let roleInfo = null;
-
-      if (servers.length > 0) {
-        const serverInfo = servers[servers.length - 1];
-        logger.info("getLastServerList 区服接口 serverInfo", {
-          serverInfo: serverInfo,
-        });
-        
-        // 只有在提供了uid时才查询最后一个服务器的角色信息
-        if (uid) {
-          const { getRoleInfoByUidAndServerId } = require("../mongo/mongodb");
-          try {
-            const newUniqueTag = `${serverInfo.tag}|${serverInfo.sid}|${uid}`;
-             roleInfo = await getRoleInfoByUidAndServerId(newUniqueTag, serverInfo.db_name);
-          } catch (error) {
-            logger.error(`查询服务器${serverInfo.id}角色信息失败:`, error);
-          }
+        logger.info("maintenance :", {channelId: data.channel_id});
+
+        let url = await getServerList(data.serverId, data.channel_id || 1);
+        if (!url) {
+            ctx.body = ApiController.fail(`区服id错误: serverId ${data.serverId}`, 1);
+            return;
         }
-        
-        data.push({
-          channel: channelConfig.name, //渠道固定
-          minSid: 1, //最小服务器
-          maxSid: servers.length, //最大服务器 这里会控制 服务器列表显示的数量
-          isNewAccount: isNewAccount, //1为新号 会弹出用户协议
-          //以下是最近登陆的服务器 (不可为空 如果没有参数可以填最后一个区)
-          sid: serverInfo.sid || 1,
-          id: serverInfo.id || 1,
-          name: serverInfo.name || "1区",
-          tips: serverInfo.tips || "",
-          server: serverInfo.server
-            ? serverInfo.server
-            : `ws://${serverInfo.ip}:${serverInfo.port}/`,
-          status: serverInfo.status || 0,
-          // 角色信息
-          roleName: roleInfo?.roleName || null,
-          roleLevel: roleInfo?.roleLevel || null,
-          head: roleInfo?.head || null,
-          hasRole: !!roleInfo
+        let param = JSON.stringify({
+            type: "kickAllUser",
         });
-      } else {
-        data.push({
-          channel: "未知", //渠道固定
-          minSid: 1, //最小服务器
-          maxSid: 10, //最大服务器 这里会控制 服务器列表显示的数量
-          isNewAccount: isNewAccount, //1为新号 会弹出用户协议
-          //以下是最近登陆的服务器 (不可为空 如果没有参数可以填最后一个区)
-          sid: 1,
-          id: 1,
-          name: "1区",
-          tips: "",
-          server: "",
-          status: 0,
-          // 角色信息（新用户，无角色）
-          roleName: null,
-          roleLevel: null,
-          head: null,
-          hasRole: false
+        let sendMsg = new Msg();
+        sendMsg.connect(url, Account);
+        new Promise((resolve) => {
+            setTimeout(async () => {
+                sendMsg.CG_TEST_PROTO("test", param);
+            }, 1000);
         });
-      }
+        ctx.body = ApiController.success("success", 0, false, null);
     }
-    ctx.body = data;
-    // ctx.body = ApiController.success("获取最近服务器列表成功", 1, false, data);
-  }
 
-  async getNotice(ctx) {
-    let tag = ctx.query.channel_id || 1;
+    async maintenanceAll(ctx) {
+        let channelId = parseInt(ctx.query.channel_id);
+        let isMaintenance = ctx.query.isMaintenance;
+        let key = ctx.query.key;
+        logger.info("maintenanceAll :", {
+            channelId: channelId,
+            isMaintenance: isMaintenance,
+        });
+
+        if (key != "dsdadsadajkkjkxab") {
+            ctx.body = ApiController.fail("无权使用", -1);
+            return;
+        }
 
-    let content = "";
-    let content_wh = "";
-    const system = await System.getSystemConfig(tag);
+        const servers = await Server.getAllServerList(channelId, "");
+        logger.info("maintenanceAll servers:", {servers: servers});
 
-    if (system) {
-      system.forEach((element) => {
-        if (element.key == "content") {
-          content = element.value;
+        if (servers.length === 0) {
+            ctx.body = ApiController.fail("不存在可操作区服", -1);
+            return;
         }
+        const serversId = servers.map((obj) => obj.id);
 
-        if (element.key == "content_wh") {
-          content_wh = element.value;
+        if (isMaintenance == "true") {
+            const res = await Server.updateServerStatus(serversId, 3);
         }
-      });
-    }
 
-    let notice_data = [
-      {
-        status: 1,
-        content: content,
-        content_wh: content_wh,
-      },
-    ];
-    ctx.body = notice_data;
-    // ctx.body = ApiController.success("获取公告成功", 1, false, notice_data);
-  }
-
-  // 维护服务器，踢掉所有玩家
-  async maintenance(ctx) {
-    let data = {
-      channel_id: parseInt(ctx.query.channel_id),
-      serverId: parseInt(ctx.query.serverId) || "",
-    };
-
-    logger.info("maintenance :", { channelId: data.channel_id });
-
-    let url = await getServerList(data.serverId, data.channel_id || 1);
-    if (!url) {
-      ctx.body = ApiController.fail(`区服id错误: serverId ${data.serverId}`, 1);
-      return;
-    }
-    let param = JSON.stringify({
-      type: "kickAllUser",
-    });
-    let sendMsg = new Msg();
-    sendMsg.connect(url, Account);
-    new Promise((resolve) => {
-      setTimeout(async () => {
-        sendMsg.CG_TEST_PROTO("test", param);
-      }, 1000);
-    });
-    ctx.body = ApiController.success("success", 0, false, null);
-  }
-
-  async maintenanceAll(ctx) {
-    let channelId = parseInt(ctx.query.channel_id);
-    let isMaintenance = ctx.query.isMaintenance;
-    let key = ctx.query.key;
-    logger.info("maintenanceAll :", {
-      channelId: channelId,
-      isMaintenance: isMaintenance,
-    });
-
-    if (key != "dsdadsadajkkjkxab") {
-      ctx.body = ApiController.fail("无权使用", -1);
-      return;
-    }
+        servers.forEach(function (element) {
+            let url = "ws://" + element.ip + ":" + element.port;
+            if (!url) {
+                ctx.body = ApiController.fail(`区服id错误: serverId ${element.id}`, 1);
+                return;
+            }
 
-    const servers = await Server.getAllServerList(channelId, "");
-    logger.info("maintenanceAll servers:", { servers: servers });
+            let param = JSON.stringify({
+                type: "kickAllUser",
+            });
+            // Msg.connect(url, Account);
+            let sendMsg = new Msg();
+            sendMsg.connect(url, Account);
+            new Promise((resolve) => {
+                setTimeout(async () => {
+                    sendMsg.CG_TEST_PROTO("test", param);
+                }, 1000);
+            });
+        });
 
-    if (servers.length === 0) {
-      ctx.body = ApiController.fail("不存在可操作区服", -1);
-      return;
-    }
-    const serversId = servers.map((obj) => obj.id);
+        logger.info("maintenanceAll 更新的区服id:", {serversId: serversId});
 
-    if (isMaintenance == "true") {
-      const res = await Server.updateServerStatus(serversId, 3);
+        ctx.body = ApiController.success("success", 0, false, null);
     }
 
-    servers.forEach(function (element) {
-      let url = "ws://" + element.ip + ":" + element.port;
-      if (!url) {
-        ctx.body = ApiController.fail(`区服id错误: serverId ${element.id}`, 1);
-        return;
-      }
-
-      let param = JSON.stringify({
-        type: "kickAllUser",
-      });
-      // Msg.connect(url, Account);
-      let sendMsg = new Msg();
-      sendMsg.connect(url, Account);
-      new Promise((resolve) => {
-        setTimeout(async () => {
-          sendMsg.CG_TEST_PROTO("test", param);
-        }, 1000);
-      });
-    });
-
-    logger.info("maintenanceAll 更新的区服id:", { serversId: serversId });
-
-    ctx.body = ApiController.success("success", 0, false, null);
-  }
-
-  async sendMail(ctx) {
-    let data = ctx.request.body;
-    let url = await getServerList(data.serverId, data.channel_id || 1);
-    if (!url) {
-      ctx.body = ApiController.fail(`区服id错误: serverId ${data.serverId}`, 1);
-      return;
+    async sendMail(ctx) {
+        let data = ctx.request.body;
+        let url = await getServerList(data.serverId, data.channel_id || 1);
+        if (!url) {
+            ctx.body = ApiController.fail(`区服id错误: serverId ${data.serverId}`, 1);
+            return;
+        }
+        let param = JSON.stringify({
+            type: "sendMail",
+            mail: JSON.stringify({
+                uuid: data.uuid,
+                title: data.title,
+                content: data.content,
+                items: JSON.parse(data.items),
+                expire: data.expire,
+            }),
+        });
+        // Msg.connect(url, Account);
+        let sendMsg = new Msg();
+        sendMsg.connect(url, Account);
+        new Promise((resolve) => {
+            setTimeout(async () => {
+                sendMsg.CG_TEST_PROTO("test", param);
+            }, 1000);
+        });
+        ctx.body = ApiController.success("success", 0, false, null);
     }
-    let param = JSON.stringify({
-      type: "sendMail",
-      mail: JSON.stringify({
-        uuid: data.uuid,
-        title: data.title,
-        content: data.content,
-        items: JSON.parse(data.items),
-        expire: data.expire,
-      }),
-    });
-    // Msg.connect(url, Account);
-    let sendMsg = new Msg();
-    sendMsg.connect(url, Account);
-    new Promise((resolve) => {
-      setTimeout(async () => {
-        sendMsg.CG_TEST_PROTO("test", param);
-      }, 1000);
-    });
-    ctx.body = ApiController.success("success", 0, false, null);
-  }
-
-  async sendAllMail(ctx) {
-    let data = ctx.request.body;
 
-    if (!data.server_list || data.server_list.length === 0) {
-      ctx.body = ApiController.fail("区服不能为空", -1);
-      return;
-    }
+    async sendAllMail(ctx) {
+        let data = ctx.request.body;
 
-    logger.info("sendAllMail 接口请求 data:", { data: data });
+        if (!data.server_list || data.server_list.length === 0) {
+            ctx.body = ApiController.fail("区服不能为空", -1);
+            return;
+        }
 
-    const server_list = data.server_list;
-    const servers = await Server.getServerList(data.channel_id || 1);
-    const filteredServer = servers.filter((item) =>
-      server_list.includes(item.id)
-    );
+        logger.info("sendAllMail 接口请求 data:", {data: data});
 
-    filteredServer.forEach(function (element) {
-      let url = "ws://" + element.ip + ":" + element.port;
-      if (!url) {
-        ctx.body = ApiController.fail(
-          `区服id错误: serverId ${element.server_id}`,
-          1
+        const server_list = data.server_list;
+        const servers = await Server.getServerList(data.channel_id || 1);
+        const filteredServer = servers.filter((item) =>
+            server_list.includes(item.id)
         );
-        return;
-      }
-
-      let param = JSON.stringify({
-        type: "sendAllMail",
-        mail: JSON.stringify({
-          title: data.title,
-          content: data.content,
-          items: JSON.parse(data.items),
-          expire: data.expire,
-        }),
-      });
-      let sendMsg = new Msg();
-      sendMsg.connect(url, Account);
-      new Promise((resolve) => {
-        setTimeout(async () => {
-          sendMsg.CG_TEST_PROTO("test", param);
-        }, 1000);
-      });
-    });
-
-    ctx.body = ApiController.success("success", 0);
-  }
-
-  async useCDKV2(ctx) {
-    let body = ctx.request.body;
-
-    logger.info("useCDKV2接口请求参数:", { data: body });
-
-    let data = {
-      code: body.code,
-      userId: body.account,
-      channelId: body.channel_id || 0,
-    };
-
-    if (body.uuid) {
-      data.userId = body.uuid;
-    }
-
-    let serverUrl = await getServerList(body.serverId, body.channel_id);
-    let err = "";
-    if (!serverUrl) {
-      ctx.body = ApiController.fail(`区服id错误: serverId ${body.serverId}`, 1);
-      return;
-    }
-    let port = 8004;
-    let host = "127.0.0.1";
-    let url = "http://" + host + ":" + port + "/api/giftCode/exchange";
 
-    logger.info("接口请求后台 data:", { data: data, url: url });
+        filteredServer.forEach(function (element) {
+            let url = "ws://" + element.ip + ":" + element.port;
+            if (!url) {
+                ctx.body = ApiController.fail(
+                    `区服id错误: serverId ${element.server_id}`,
+                    1
+                );
+                return;
+            }
 
-    try {
-      const specialCodes = [
-        "gfyx555",
-        "gfyx666",
-        "gfyx777",
-        "gfyx1000",
-        "gfyx2000",
-        "gfyx3000",
-        "gfyxrqlb",
-        "GFYX555",
-        "GFYX666",
-        "GFYX777",
-        "GFYX1000",
-        "GFYX2000",
-        "GFYX3000",
-        "GFYXrqlb",
-        "GFYX000",
-        "GFYX222",
-        "GFYX333",
-        "GFYX888",
-        "GFYX1818",
-        "GQ888",
-        "ZQ888",
-        "gfyx8888",
-        "gfyx6666",
-        "gfyx7777"
-      ];
-      let param: string = "";
-
-      const h5Codes = ["gfyx000", "gfyx222", "gfyx333", "gfyx888", "gfyx1818"];
-      if (h5Codes.includes(data.code) && body.channel_id != 5) {
-        ctx.body = ApiController.fail("该激活码无法在h5渠道使用", 1);
-      }
-
-      if (specialCodes.includes(data.code) || h5Codes.includes(data.code)) {
-        param = JSON.stringify({
-          code: data.code,
-          type: "UseFixCDK",
-          channel_id: body.channel_id,
-        });
-      } else {
-        const response = await axios.post(url, data, {
-          headers: {
-            "Content-Type": "application/json",
-          },
-          timeout: 10000,
-        });
-        logger.info("接口请求后台 接口返回 response:", { data: response.data });
-        if (response.data.code != 200) {
-          ctx.body = ApiController.fail(response.data.msg, 1);
-          return;
-        }
-        const result = splitString(response.data.data, ";");
-        // 重构itemList
-        let itemList = Array();
-        for (let i = 0; i < result.length; i++) {
-          let elem = splitString(result[i], ":");
-          let output0 = parseInt(elem[0], 10);
-          let output1 = parseInt(elem[1], 10);
-          itemList.push([output0, output1]);
-        }
-        param = JSON.stringify({
-          type: "UseCDKV2",
-          itemList: itemList,
-          channel_id: body.channel_id,
+            let param = JSON.stringify({
+                type: "sendAllMail",
+                mail: JSON.stringify({
+                    title: data.title,
+                    content: data.content,
+                    items: JSON.parse(data.items),
+                    expire: data.expire,
+                }),
+            });
+            let sendMsg = new Msg();
+            sendMsg.connect(url, Account);
+            new Promise((resolve) => {
+                setTimeout(async () => {
+                    sendMsg.CG_TEST_PROTO("test", param);
+                }, 1000);
+            });
         });
-      }
-
-      let sendMsg = new Msg();
-      sendMsg.connect(serverUrl, Account);
-      logger.info("api cdk 发送服务器 param:", { param: param });
-      new Promise((resolve) => {
-        setTimeout(async () => {
-          sendMsg.CG_TEST_PROTO(body.account, param, body.serverId);
-        }, 1000);
-      });
-    } catch (error) {
-      console.log(error);
+
+        ctx.body = ApiController.success("success", 0);
     }
-    ctx.body = ApiController.success("success", 0);
-  }
 
-  async banUser(ctx) {
-    let data = ctx.request.body;
-    logger.info("banUser 接口请求 data:", { data: data });
+    async useCDKV2(ctx) {
+        let body = ctx.request.body;
 
-    if (!data.server_tag) {
-      ctx.body = ApiController.fail("区服id不能为空", -1, "");
-      return;
-    }
+        logger.info("useCDKV2接口请求参数:", {data: body});
 
-    let banInfo = {};
-
-    switch (parseInt(data.ban_type)) {
-      case 1:
-        banInfo = {
-          roleBanInfo: {
-            channelTag: data.channel_id,
-            serverTag: data.server_tag,
-            roleTag: data.role_tag,
-            banTime: data.ban_time,
-          },
-          type: "setBan",
-        };
-        break;
-      case 2:
-        banInfo = {
-          accountBanInfo: {
-            channelTag: data.channel_id,
-            accountTag: data.account_tag,
-            banTime: data.ban_time,
-          },
-          type: "setBan",
-        };
-        break;
-      case 3:
-        banInfo = {
-          appBanInfo: {
-            appId: data.device_id,
-            banTime: data.ban_time,
-          },
-          type: "setBan",
+        let data = {
+            code: body.code,
+            userId: body.account,
+            channelId: body.channel_id || 0,
         };
-        break;
-      default:
-    }
 
-    logger.info("banUser 发送服务器 banInfo:", banInfo);
+        if (body.uuid) {
+            data.userId = body.uuid;
+        }
+
+        let serverUrl = await getServerList(body.serverId, body.channel_id);
+        let err = "";
+        if (!serverUrl) {
+            ctx.body = ApiController.fail(`区服id错误: serverId ${body.serverId}`, 1);
+            return;
+        }
+        let port = 8004;
+        let host = "127.0.0.1";
+        let url = "http://" + host + ":" + port + "/api/giftCode/exchange";
+
+        logger.info("接口请求后台 data:", {data: data, url: url});
+
+        try {
+            const specialCodes = [
+                "gfyx555",
+                "gfyx666",
+                "gfyx777",
+                "gfyx1000",
+                "gfyx2000",
+                "gfyx3000",
+                "gfyxrqlb",
+                "GFYX555",
+                "GFYX666",
+                "GFYX777",
+                "GFYX1000",
+                "GFYX2000",
+                "GFYX3000",
+                "GFYXrqlb",
+                "GFYX000",
+                "GFYX222",
+                "GFYX333",
+                "GFYX888",
+                "GFYX1818",
+                "GQ888",
+                "ZQ888",
+                "gfyx8888",
+                "gfyx6666",
+                "gfyx7777",
+                "gfyxxjbc",
+                "LIDONGLB",
+                "XIAOXULB",
+                "GANENLB",
+                "WANSHLB",
+                "HERO666",
+                "HERO777",
+                "HERO888"
+            ];
+            let param: string = "";
+
+            const h5Codes = ["gfyx000", "gfyx222", "gfyx333", "gfyx888", "gfyx1818"];
+            if (h5Codes.includes(data.code) && body.channel_id != 5) {
+                ctx.body = ApiController.fail("该激活码无法在h5渠道使用", 1);
+            }
+
+            if (specialCodes.includes(data.code) || h5Codes.includes(data.code)) {
+                param = JSON.stringify({
+                    code: data.code,
+                    type: "UseFixCDK",
+                    channel_id: body.channel_id,
+                });
+            } else {
+                const response = await axios.post(url, data, {
+                    headers: {
+                        "Content-Type": "application/json",
+                    },
+                    timeout: 10000,
+                });
+                logger.info("接口请求后台 接口返回 response:", {data: response.data});
+                if (response.data.code != 200) {
+                    ctx.body = ApiController.fail(response.data.msg, 1);
+                    return;
+                }
+                const result = splitString(response.data.data, ";");
+                // 重构itemList
+                let itemList = Array();
+                for (let i = 0; i < result.length; i++) {
+                    let elem = splitString(result[i], ":");
+                    let output0 = parseInt(elem[0], 10);
+                    let output1 = parseInt(elem[1], 10);
+                    itemList.push([output0, output1]);
+                }
+                param = JSON.stringify({
+                    type: "UseCDKV2",
+                    itemList: itemList,
+                    channel_id: body.channel_id,
+                });
+            }
 
-    let url = await getServerList(data.server_tag, data.channel_id);
-    if (!url) {
-      ctx.body = ApiController.fail(
-        `区服id错误: serverId ${data.server_tag}`,
-        1
-      );
-      return;
+            let sendMsg = new Msg();
+            sendMsg.connect(serverUrl, Account);
+            logger.info("api cdk 发送服务器 param:", {param: param});
+            new Promise((resolve) => {
+                setTimeout(async () => {
+                    sendMsg.CG_TEST_PROTO(body.account, param, body.serverId);
+                }, 1000);
+            });
+        } catch (error) {
+            console.log(error);
+        }
+        ctx.body = ApiController.success("success", 0);
     }
 
-    let param = JSON.stringify(banInfo);
+    async banUser(ctx) {
+        let data = ctx.request.body;
+        logger.info("banUser 接口请求 data:", {data: data});
 
-    logger.info("banUser 发送服务器 json字符串: " + param);
+        if (!data.server_tag) {
+            ctx.body = ApiController.fail("区服id不能为空", -1, "");
+            return;
+        }
 
-    let sendMsg = new Msg();
-    sendMsg.connect(url, Account);
-    new Promise((resolve) => {
-      setTimeout(async () => {
-        sendMsg.CG_TEST_PROTO("test", param, data.server_tag);
-        // sendMsg.CG_SET_BAN(param);
-      }, 1000);
-    });
-    ctx.body = ApiController.success("success", 0);
-  }
+        let banInfo = {};
+
+        switch (parseInt(data.ban_type)) {
+            case 1:
+                banInfo = {
+                    roleBanInfo: {
+                        channelTag: data.channel_id,
+                        serverTag: data.server_tag,
+                        roleTag: data.role_tag,
+                        banTime: data.ban_time,
+                    },
+                    type: "setBan",
+                };
+                break;
+            case 2:
+                banInfo = {
+                    accountBanInfo: {
+                        channelTag: data.channel_id,
+                        accountTag: data.account_tag,
+                        banTime: data.ban_time,
+                    },
+                    type: "setBan",
+                };
+                break;
+            case 3:
+                banInfo = {
+                    appBanInfo: {
+                        appId: data.device_id,
+                        banTime: data.ban_time,
+                    },
+                    type: "setBan",
+                };
+                break;
+            default:
+        }
 
-  async uicFilter4399(ctx) {
-    let body = ctx.request.body;
+        logger.info("banUser 发送服务器 banInfo:", banInfo);
 
-    let channelConfig = ChannelConfigManager.getConfig(6);
-    if (body.is_new == 1){
-        channelConfig = ChannelConfigManager.getConfig(999);
-    }
-    logger.info("uicFilter4399 body:", { data: body });
+        let url = await getServerList(data.server_tag, data.channel_id);
+        if (!url) {
+            ctx.body = ApiController.fail(
+                `区服id错误: serverId ${data.server_tag}`,
+                1
+            );
+            return;
+        }
 
-    let toCheck = body.toCheck;
-    let signStr = channelConfig.loginConfig?.signKey + toCheck;
-    logger.info("uicFilter4399 signStr:", { signStr: signStr });
+        let param = JSON.stringify(banInfo);
 
-    let apiParams = {
-      toCheck: toCheck,
-      app: channelConfig.loginConfig.appId,
-      byPinyin: true,
-      isBatch: false,
-      sig: CryptoJS.MD5(signStr).toString(),
-    };
+        logger.info("banUser 发送服务器 json字符串: " + param);
 
-    logger.info("uicFilter4399 apiParams:", { data: apiParams });
+        let sendMsg = new Msg();
+        sendMsg.connect(url, Account);
+        new Promise((resolve) => {
+            setTimeout(async () => {
+                sendMsg.CG_TEST_PROTO("test", param, data.server_tag);
+                // sendMsg.CG_SET_BAN(param);
+            }, 1000);
+        });
+        ctx.body = ApiController.success("success", 0);
+    }
 
-    const queryStr = Object.entries(apiParams)
-      .map(
-        ([key, value]) =>
-          `${encodeURIComponent(key)}=${encodeURIComponent(value)}`
-      )
-      .join("&");
+    async uicFilter4399(ctx) {
+        let body = ctx.request.body;
 
-    let url = "https://wo.webgame138.com/test/matchService.do" + "?" + queryStr;
-    // let url = "https://wo.webgame138.com/test/matchService.do";
-    logger.info("uicFilter4399 url:", { url: url });
+        let channelConfig = ChannelConfigManager.getConfig(6);
+        if (body.is_new == 1) {
+            channelConfig = ChannelConfigManager.getConfig(999);
+        }
+        logger.info("uicFilter4399 body:", {data: body});
+
+        let toCheck = body.toCheck;
+        let signStr = channelConfig.loginConfig?.signKey + toCheck;
+        logger.info("uicFilter4399 signStr:", {signStr: signStr});
+
+        let apiParams = {
+            toCheck: toCheck,
+            app: channelConfig.loginConfig.appId,
+            byPinyin: true,
+            isBatch: false,
+            sig: CryptoJS.MD5(signStr).toString(),
+        };
 
-    try {
-      //   let response = await axios.get(url, {
-      //     timeout: 10000, // 设置10秒超时
-      //   });
-
-      const response = await axios.post(url, apiParams, {
-        headers: {
-          "Content-Type": "application/json",
-        },
-      });
-      logger.info("uicFilter4399 接口返回 response:", { data: response.data });
-
-      ctx.body = ApiController.success("success", 0, false, response.data);
-    } catch (error) {
-      console.log(error);
-      ctx.body = ApiController.fail(error.message || "请求失败", 1);
+        logger.info("uicFilter4399 apiParams:", {data: apiParams});
+
+        const queryStr = Object.entries(apiParams)
+            .map(
+                ([key, value]) =>
+                    `${encodeURIComponent(key)}=${encodeURIComponent(value)}`
+            )
+            .join("&");
+
+        let url = "https://wo.webgame138.com/test/matchService.do" + "?" + queryStr;
+        // let url = "https://wo.webgame138.com/test/matchService.do";
+        logger.info("uicFilter4399 url:", {url: url});
+
+        try {
+            //   let response = await axios.get(url, {
+            //     timeout: 10000, // 设置10秒超时
+            //   });
+
+            const response = await axios.post(url, apiParams, {
+                headers: {
+                    "Content-Type": "application/json",
+                },
+            });
+            logger.info("uicFilter4399 接口返回 response:", {data: response.data});
+
+            ctx.body = ApiController.success("success", 0, false, response.data);
+        } catch (error) {
+            console.log(error);
+            ctx.body = ApiController.fail(error.message || "请求失败", 1);
+        }
     }
-  }
 
-  async roleList4399(ctx) {
-    let body = ctx.request.body;
-    logger.info("RoleList4399 请求参数:", { body: body });
+    async roleList4399(ctx) {
+        let body = ctx.request.body;
+        logger.info("RoleList4399 请求参数:", {body: body});
 
-    let data = {
-      userId: body.userId,
-      server: body.server,
-      is_new: ctx.query.is_new || 0
-    };
+        let data = {
+            userId: body.userId,
+            server: body.server,
+            is_new: ctx.query.is_new || 0
+        };
 
-    let port = 8004;
-    let host = "127.0.0.1";
-    let url = "http://" + host + ":" + port + "/api/roleList/checkBy4399";
+        let port = 8004;
+        let host = "127.0.0.1";
+        let url = "http://" + host + ":" + port + "/api/roleList/checkBy4399";
 
-    logger.info("RoleList4399 url:", { url: url });
+        logger.info("RoleList4399 url:", {url: url});
 
-    try {
-      const response = await axios.post(url, data, {
-        headers: {
-          "Content-Type": "application/json",
-        },
-      });
+        try {
+            const response = await axios.post(url, data, {
+                headers: {
+                    "Content-Type": "application/json",
+                },
+            });
 
-      logger.info("RoleList4399 返回 response:", { data: response.data });
+            logger.info("RoleList4399 返回 response:", {data: response.data});
 
-      ctx.body = response.data;
-    } catch (error) {
-      console.log(error);
+            ctx.body = response.data;
+        } catch (error) {
+            console.log(error);
+        }
     }
-  }
 
-  async cdkBy4399(ctx) {
-    let body = ctx.request.body;
+    async cdkBy4399(ctx) {
+        let body = ctx.request.body;
 
-    logger.info("cdkBy4399:", { data: body });
-    let server = body.server || 1;
-    let channel = 5;
+        logger.info("cdkBy4399:", {data: body});
+        let server = body.server || 1;
+        let channel = 5;
 
-    let data = {
-      code: body.giftId,
-      userId: body.userId,
-      channelId: channel,
-    };
+        let data = {
+            code: body.giftId,
+            userId: body.userId,
+            channelId: channel,
+        };
 
-    if (body.uuid) {
-      data.userId = body.uuid;
-    }
+        if (body.uuid) {
+            data.userId = body.uuid;
+        }
 
-    let serverUrl = await getServerList(server, channel);
-    let err = "";
-    if (!serverUrl) {
-      ctx.body = ApiController.fail(`区服id错误: serverId ${body.serverId}`, 1);
-      return;
+        let serverUrl = await getServerList(server, channel);
+        let err = "";
+        if (!serverUrl) {
+            ctx.body = ApiController.fail(`区服id错误: serverId ${body.serverId}`, 1);
+            return;
+        }
+        let port = 8004;
+        let host = "127.0.0.1";
+        let url = "http://" + host + ":" + port + "/api/giftCode/exchange";
+
+        logger.info("cdkBy4399接口请求后台 data:", {data: data, url: url});
+
+        try {
+            const response = await axios.post(url, data, {
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                timeout: 10000,
+            });
+            logger.info("cdkBy4399接口请求后台 接口返回 response:", {
+                data: response.data,
+            });
+            if (response.data.code != 200) {
+                ctx.body = ApiController.fail(response.data.msg, 10004);
+                return;
+            }
+            const result = splitString(response.data.data, ";");
+            // 重构itemList
+            let itemList = Array();
+            for (let i = 0; i < result.length; i++) {
+                let elem = splitString(result[i], ":");
+                let output0 = parseInt(elem[0], 10);
+                let output1 = parseInt(elem[1], 10);
+                itemList.push([output0, output1]);
+            }
+            let param = JSON.stringify({
+                type: "UseCDKV2",
+                itemList: itemList,
+                channel_id: channel,
+            });
+
+            let sendMsg = new Msg();
+            sendMsg.connect(serverUrl, Account);
+            logger.info("cdkBy4399 cdk 发送服务器 param:", {param: param});
+            new Promise((resolve) => {
+                setTimeout(async () => {
+                    sendMsg.CG_TEST_PROTO("test", param, server);
+                }, 1000);
+            });
+        } catch (error) {
+            console.log(error);
+        }
+        ctx.body = ApiController.success("success", 10000);
     }
-    let port = 8004;
-    let host = "127.0.0.1";
-    let url = "http://" + host + ":" + port + "/api/giftCode/exchange";
 
-    logger.info("cdkBy4399接口请求后台 data:", { data: data, url: url });
+    async roleListYfy(ctx) {
+        let gameCode = ctx.query.gameCode;
+        let timestamp = ctx.query.timestamp;
+        let uid = ctx.query.uid;
+        let sign = ctx.query.sign;
+        let AppSecret = "H1EqhbpA80jt0Jw6Q3T2";
+
+        logger.info("roleListYfy 请求参数:", {
+            uid: uid,
+            gameCode: gameCode,
+            timestamp: timestamp,
+        });
 
-    try {
-      const response = await axios.post(url, data, {
-        headers: {
-          "Content-Type": "application/json",
-        },
-        timeout: 10000,
-      });
-      logger.info("cdkBy4399接口请求后台 接口返回 response:", {
-        data: response.data,
-      });
-      if (response.data.code != 200) {
-        ctx.body = ApiController.fail(response.data.msg, 10004);
-        return;
-      }
-      const result = splitString(response.data.data, ";");
-      // 重构itemList
-      let itemList = Array();
-      for (let i = 0; i < result.length; i++) {
-        let elem = splitString(result[i], ":");
-        let output0 = parseInt(elem[0], 10);
-        let output1 = parseInt(elem[1], 10);
-        itemList.push([output0, output1]);
-      }
-      let param = JSON.stringify({
-        type: "UseCDKV2",
-        itemList: itemList,
-        channel_id: channel,
-      });
-
-      let sendMsg = new Msg();
-      sendMsg.connect(serverUrl, Account);
-      logger.info("cdkBy4399 cdk 发送服务器 param:", { param: param });
-      new Promise((resolve) => {
-        setTimeout(async () => {
-          sendMsg.CG_TEST_PROTO("test", param, server);
-        }, 1000);
-      });
-    } catch (error) {
-      console.log(error);
-    }
-    ctx.body = ApiController.success("success", 10000);
-  }
-
-  async roleListYfy(ctx) {
-    let gameCode = ctx.query.gameCode;
-    let timestamp = ctx.query.timestamp;
-    let uid = ctx.query.uid;
-    let sign = ctx.query.sign;
-    let AppSecret = "H1EqhbpA80jt0Jw6Q3T2";
-
-    logger.info("roleListYfy 请求参数:", {
-      uid: uid,
-      gameCode: gameCode,
-      timestamp: timestamp,
-    });
-
-    const signStr = `gameCode-${gameCode}&timestamp=${timestamp}&uid=${uid}${AppSecret}`;
-    const newSign = CryptoJS.MD5(signStr).toString();
-    if (newSign != sign) {
-      logger.info("roleListYfy 签名错误:", {
-        signStr: signStr,
-        sign: sign,
-        newSign: newSign,
-      });
-      ctx.body = ApiController.fail("签名错误!!", -1);
-    }
+        const signStr = `gameCode-${gameCode}&timestamp=${timestamp}&uid=${uid}${AppSecret}`;
+        const newSign = CryptoJS.MD5(signStr).toString();
+        if (newSign != sign) {
+            logger.info("roleListYfy 签名错误:", {
+                signStr: signStr,
+                sign: sign,
+                newSign: newSign,
+            });
+            ctx.body = ApiController.fail("签名错误!!", -1);
+        }
 
-    let port = 8004;
-    let host = "127.0.0.1";
-    let url = "http://" + host + ":" + port + "/api/roleList/checkByYfy";
+        let port = 8004;
+        let host = "127.0.0.1";
+        let url = "http://" + host + ":" + port + "/api/roleList/checkByYfy";
+
+        logger.info("roleListYfy url:", {url: url});
+
+        try {
+            const response = await axios.post(
+                url,
+                {
+                    userId: uid,
+                },
+                {
+                    headers: {
+                        "Content-Type": "application/json",
+                    },
+                }
+            );
+
+            logger.info("roleListYfy 返回 response:", {data: response.data});
+
+            ctx.body = response.data;
+        } catch (error) {
+            console.log(error);
+        }
+    }
 
-    logger.info("roleListYfy url:", { url: url });
+    async getQuickSign(ctx) {
+        let data = ctx.request.body;
+        logger.info("getQuickSign 请求参数:", {body: data});
 
-    try {
-      const response = await axios.post(
-        url,
-        {
-          userId: uid,
-        },
-        {
-          headers: {
-            "Content-Type": "application/json",
-          },
+        if (!SignatureVerifier.verifyMD5Sign(data, ORDER_SIGN_KEY)) {
+            logger.error("签名验证失败");
+            ctx.body = ApiController.fail("签名错误!!", -1);
+            return;
         }
-      );
 
-      logger.info("roleListYfy 返回 response:", { data: response.data });
-
-      ctx.body = response.data;
-    } catch (error) {
-      console.log(error);
+        let key = "H1EqhbpA80jt0Jw6Q3T2";
+        let signStr =
+            "uid=" +
+            data.uid +
+            "&username=" +
+            data.username +
+            "&serverId=" +
+            data.serverId +
+            "&serverName=" +
+            data.serverName +
+            "&userRoleId=" +
+            data.userRoleId +
+            "&userRoleName=" +
+            data.userRoleName +
+            "&userRoleLevel=" +
+            data.userRoleLevel +
+            "&vipLevel=" +
+            data.vipLevel +
+            "&gameRolePower=" +
+            data.gameRolePower +
+            "&key=" +
+            key;
+        logger.info("getQuickSign signStr:", {signStr: signStr});
+
+        data.sign = CryptoJS.MD5(signStr).toString();
+
+        ctx.body = ApiController.success("success", 0, false, data);
     }
-  }
 
-  async getQuickSign(ctx) {
-    let data = ctx.request.body;
-    logger.info("getQuickSign 请求参数:", { body: data });
+    /**
+     * mianyou开服同步处理
+     * @param ctx Koa上下文
+     */
+    async mianyouSyncServer(ctx) {
+        try {
+            const data = ctx.request.body;
+            logger.info("mianyou开服同步请求参数:", {data});
+
+            // 验证必要参数
+            const {serverId, gameServerId, serverName, startTime, channelId} = data;
+            
+            if (!serverId || !gameServerId || !serverName || !startTime) {
+                logger.warn("mianyou开服同步失败: 缺少必要参数", {data});
+                ctx.body = ApiController.fail("缺少必要参数: serverId, gameServerId, serverName, startTime");
+                return;
+            }
+
+            // 获取渠道配置
+            const channelConfig = ChannelConfigManager.getConfig(channelId || 1);
+            if (!channelConfig) {
+                logger.error("mianyou开服同步失败: 未找到渠道配置", {channelId});
+                ctx.body = ApiController.fail("未找到渠道配置");
+                return;
+            }
 
-    if (!SignatureVerifier.verifyMD5Sign(data, ORDER_SIGN_KEY)) {
-      logger.error("签名验证失败");
-      ctx.body = ApiController.fail("签名错误!!", -1);
-      return;
+            // 创建MianyouChannelHandler实例
+            const mianyouHandler = new MianyouChannelHandler();
+
+            // 调用开服同步方法
+            const result = await mianyouHandler.openServer(
+                parseInt(serverId),
+                gameServerId,
+                serverName,
+                startTime,
+                channelConfig
+            );
+
+            logger.info("mianyou开服同步结果:", {result});
+
+            // 根据返回结果设置响应
+            if (result.status === 0) {
+                ctx.body = ApiController.success("开服同步成功", 0, false, result);
+            } else {
+                ctx.body = ApiController.fail(result.msg || "开服同步失败", result.status);
+            }
+
+        } catch (error) {
+            logger.error("mianyou开服同步异常:", error);
+            ctx.body = ApiController.fail("服务器内部错误", -1);
+        }
     }
 
-    let key = "H1EqhbpA80jt0Jw6Q3T2";
-    let signStr =
-      "uid=" +
-      data.uid +
-      "&username=" +
-      data.username +
-      "&serverId=" +
-      data.serverId +
-      "&serverName=" +
-      data.serverName +
-      "&userRoleId=" +
-      data.userRoleId +
-      "&userRoleName=" +
-      data.userRoleName +
-      "&userRoleLevel=" +
-      data.userRoleLevel +
-      "&vipLevel=" +
-      data.vipLevel +
-      "&gameRolePower=" +
-      data.gameRolePower +
-      "&key=" +
-      key;
-    logger.info("getQuickSign signStr:", { signStr: signStr });
-
-    data.sign = CryptoJS.MD5(signStr).toString();
-
-    ctx.body = ApiController.success("success", 0, false, data);
-  }
-
- 
-  
+
 }
 
 module.exports = new ApiController();

webServer/src/router/index.ts

@@ -89,5 +89,8 @@ router.get("/qqGift", TencentController.qqGift);
 
 router.post("/qqReport", TencentController.qqReport);
 
+// mianyou开服同步
+router.post("/mianyou/syncServer", ApiController.mianyouSyncServer);
+
 
 module.exports = router;