GongFuServer/webServer/src/controller/ApiController.ts

import Msg from "../utils/msg"; // 确保路径是正确的
import QuickAsy from "../utils/quickAsy";
import { parseString } from "xml2js";
import {
  RefreshToken,
  PackageName,
  ProductId,
  IosUrl,
  SandboxIosUrl,
  Account,
  ClientSecret,
  ClientId,
  AppSecret360,
} from "../config/thirdParams";
import {
  compareVersions,
  generateOrderNumber,
  formatDate,
  getServerList,
} from "../utils/common";

const CryptoJS = require("crypto-js");
const Order = require("../model/OrderModel");
const Server = require("../model/ServerModel");
const System = require("../model/SystemModel");
const User = require("../model/UserModel");
const Version = require("../model/VersionModel");
const CDK = require("../model/CDK");
const notice = require("../json/notice.json");
const th_notice = require("../json/th_notice.json");
const xky_notice = require("../json/xky_notice.json");
const logger = require("../utils/log");
const axios = require("axios");

const googleCallPay = async (ctx) => {
  let ret = {
    code: 0,
    msg: "发货失败",
  };

  let data = ctx.request.body;
  let orderId = data.orderId;
  let googleToken = data.purchaseToken;
  let out_trade_no = "";
  logger.info("pay callback params:", { url: ctx.href, params: data });

  const res = await Order.updateOrderToken(orderId, googleToken, "google");

  const redisClient = ctx.redis.client;
  let access_token = await redisClient.get("access_token");

  if (!access_token) {
    console.log("请求api获取token");
    const apiData = {
      grant_type: "refresh_token",
      client_id: ClientId,
      client_secret: ClientSecret,
      refresh_token: RefreshToken,
    };

    const response = await axios.post(
      "https://accounts.google.com/o/oauth2/token",
      apiData,
      {
        headers: {
          "Content-Type": "application/x-www-form-urlencoded",
        },
      }
    );

    logger.info("token params:", { data: response.data, params: apiData });

    if (!response.data.access_token) {
      return ret;
    }

    access_token = response.data.access_token;
    await redisClient.set("access_token", response.data.access_token);
    await redisClient.expire("access_token", 1800);
  }

  if (!access_token) {
    return ret;
  }

  const orderInfo = (await Order.getOrder(orderId))[0];

  if (!orderInfo) {
    logger.info(`订单${orderId}不存在`);
    ret.msg = `订单${orderId}不存在`;
    return ret;
  }

  if (orderInfo.status == 2) {
    logger.info(`订单${orderId}已经重复发货`);
    ret.code = 1;
    ret.msg = `订单${orderId}已经重复发货`;
    return ret;
  }

  let url = await getServerList(orderInfo.server_id, "default");
  if (!url) {
    logger.info(`区服id错误: serverId ${orderInfo.server_id}`);
    ret.msg = `区服id错误: serverId ${orderInfo.server_id}`;
    return ret;
  }

  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 循环进行重试
  while (currentRetry < maxRetries) {
    try {
      // // 尝试执行的操作
      const googleRes = await axios.get(apiUrl, {
        headers: {
          "Content-Type": "application/x-www-form-urlencoded",
        },
      });

      console.log(googleRes.data);

      // 如果操作成功，退出循环
      if (googleRes.data.purchaseState == 0) {
        out_trade_no = googleRes.data.orderId;
        isCheck = true;
        break;
      }
    } catch (error) {
      // 捕获请求中的错误
      if (error.response) {
        // 请求已发出，服务器用状态码响应
        console.error(error.response.data);
        console.error(error.response.status);
        console.error(error.response.headers);
      } else if (error.request) {
        // 请求已发出但没有收到响应
        // 这通常是网络错误
        console.error(error.request);
      } else {
        // 在设置请求时出现错误
        console.error("Error", error.message);
      }
    }

    currentRetry++;
  }

  if (!isCheck) {
    return ret;
  }

  let sendMsg = new Msg();
  sendMsg.connect(url, Account);
  let orgMemId = orderInfo.uid;
  let orgOderId = orderId;
  let orgProductId = orderInfo.product_id;
  let orgProductPrice = orderInfo.amount;

  // 在适当的时机，调用 CG_ASK_LOGIN 方法
  let params = `{"account":"${orgMemId}","order":"${orgOderId}","id":${orgProductId},"cnt":100,"money":${orgProductPrice}}`;
  return new Promise((resolve) => {
    setTimeout(async () => {
      const send_res = sendMsg.CG_ASK_LOGIN(
        Account,
        0,
        "",
        "cn",
        "CN",
        ctx.request.ip,
        params,
        orderInfo.server_id
      );
      if (!send_res) {
        resolve(ret);
        return;
      }

      try {
        let acknowledgeUrl = `https://androidpublisher.googleapis.com/androidpublisher/v3/applications/${PackageName}/purchases/products/${productId}/tokens/${googleToken}:acknowledge?access_token=${access_token}`;
        const acknowledgeRes = await axios.post(
          acknowledgeUrl,
          {
            developerPayload: "",
          },
          {
            headers: {
              "Content-Type": "application/json",
            },
          }
        );
      } catch (error) {
        // 捕获请求中的错误
        if (error.response) {
          // 请求已发出，服务器用状态码响应
          console.error(error.response.data);
          console.error(error.response.status);
          console.error(error.response.headers);
        } else if (error.request) {
          // 请求已发出但没有收到响应
          // 这通常是网络错误
          console.error(error.request);
        } else {
          // 在设置请求时出现错误
          console.error("Error", error.message);
        }
        ret.msg = "请求第三方失败";
        resolve(ret);
      }

      try {
        let consumeUrl = `https://androidpublisher.googleapis.com/androidpublisher/v3/applications/${PackageName}/purchases/products/${productId}/tokens/${googleToken}:consume?access_token=${access_token}`;
        const consumeRes = await axios.post(
          consumeUrl,
          {
            developerPayload: "",
          },
          {
            headers: {
              "Content-Type": "application/json",
            },
          }
        );
      } catch (error) {
        // 捕获请求中的错误
        if (error.response) {
          // 请求已发出，服务器用状态码响应
          console.error(error.response.data);
          console.error(error.response.status);
          console.error(error.response.headers);
        } else if (error.request) {
          // 请求已发出但没有收到响应
          // 这通常是网络错误
          console.error(error.request);
        } else {
          // 在设置请求时出现错误
          console.error("Error", error.message);
        }
        ret.msg = "请求第三方失败";
        resolve(ret);
      }

      logger.info("谷歌 pass :", { orderId: orderId });

      const update_time = formatDate(new Date());
      const res = await Order.updateOrderStats(
        orderId,
        2,
        out_trade_no,
        update_time,
        orderInfo.uid
      );

      if (res.affectedRows <= 0) {
        logger.info(`订单${orderId} 发货失败`);
        ret.msg = "发货失败";
        resolve(ret);
        return;
      }

      ret.code = 1;
      ret.msg = "发货成功";
      resolve(ret);
    }, 1000);
  });
};

const appleCallPay = async (ctx) => {
  let ret = {
    code: 0,
    msg: "发货失败",
  };

  let data = ctx.request.body;
  logger.info("pay callback params:", { url: ctx.href, params: data });

  if (!data.purchaseToken || !data.orderId) {
    return ret;
  }

  let receipt_data = data.purchaseToken.replace(/ /g, "+");
  let orderId = data.orderId;
  let maxRetries = 5;
  let currentRetry = 0;
  let isCheck = false;
  let out_trade_no = orderId;

  const res = await Order.updateOrderToken(orderId, receipt_data, "apple");

  // 使用 while 循环进行重试
  while (currentRetry < maxRetries) {
    try {
      const apiData = {
        "receipt-data": receipt_data,
      };

      const response = await axios.post(IosUrl, apiData, {
        headers: {
          "Content-Type": "application/json",
        },
      });

      logger.info(`苹果返回的状态:${response.data.status}`);
      // 如果操作成功，退出循环
      if (response.data.status == 0) {
        isCheck = true;
        break;
      }
    } catch (error) {
      // 如果操作失败，记录错误并继续尝试
      console.log(error);
    }

    currentRetry++;
  }

  if (!isCheck) {
    logger.info(`票据验证失败！`);
    ret.msg = `票据验证失败！`;
    return ret;
  }

  const orderInfo = (await Order.getOrder(orderId))[0];

  if (!orderInfo) {
    logger.info(`订单${orderId}不存在`);
    ret.msg = `订单${orderId}不存在`;
    return ret;
  }

  if (orderInfo.status == 2) {
    logger.info(`订单${orderId}已经重复发货`);
    ret.code = 1;
    ret.msg = `订单${orderId}已经重复发货`;
    return ret;
  }

  let url = await getServerList(orderInfo.server_id, "default");
  if (!url) {
    logger.info(`区服id错误: serverId ${orderInfo.server_id}`);
    ret.msg = `区服id错误: serverId ${orderInfo.server_id}`;
    return ret;
  }

  let sendMsg = new Msg();
  sendMsg.connect(url, Account);
  let orgMemId = orderInfo.uid;
  let orgOderId = orderId;
  let orgProductId = orderInfo.product_id;
  let orgProductPrice = orderInfo.amount;

  // 在适当的时机，调用 CG_ASK_LOGIN 方法
  let params = `{"account":"${orgMemId}","order":"${orgOderId}","id":${orgProductId},"cnt":100,"money":${orgProductPrice}}`;
  return new Promise((resolve) => {
    setTimeout(async () => {
      logger.info(`订单${orderId}通知游戏发货开始`);

      const send_res = sendMsg.CG_ASK_LOGIN(
        Account,
        0,
        "",
        "cn",
        "CN",
        ctx.request.ip,
        params,
        orderInfo.server_id
      );
      if (!send_res) {
        resolve(ret);
        return;
      }

      logger.info(`订单${orderId}通知游戏发货结束`);

      const update_time = formatDate(new Date());
      const res = await Order.updateOrderStats(
        orderId,
        2,
        out_trade_no,
        update_time,
        orderInfo.uid
      );

      if (res.affectedRows <= 0) {
        logger.info(`订单${orderId} 发货失败`);
        ret.msg = "发货失败";
        resolve(ret);
        return;
      }

      ret.code = 1;
      ret.msg = "发货成功";
      resolve(ret);
    }, 1000);
  });
};

//qucik发货
//扩展参数格式为${serverId};${productId}
const CallPayQuick = async (ctx) => {
  let ret = {
    code: 0,
    msg: "发货失败",
  };
  //sdk参数
  let md5Key = "q97tvr1yqpum8y2h7d0mhvosffrplwlm";
  let callbackKey = "77410735093537425113205417841669";

  let data = ctx.request.body;
  logger.info("qucik 回调参数", { data: data });
  let md5Sign = data.md5Sign;
  let ntData = data.nt_data;
  let verifySignData = QuickAsy.getSign(data, md5Key);
  if (verifySignData != md5Sign) {
    logger.error("quick 调用md5Sign错误", {
      $verifySignData: verifySignData,
      md5Sign: md5Sign,
    });
    return ret;
  }
  let xmlData = QuickAsy.decode(ntData, callbackKey);
  const result = await new Promise((resolve, reject) => {
    parseString(xmlData, (err, result) => {
      if (err) {
        return reject(err);
      }
      resolve(result);
    });
  });
  const message = (result as any).quicksdk_message.message[0];
  const channel = message.channel[0];
  const orgMemId = message.channel_uid[0];
  const channelOrder = message.channel_order[0];
  const orderId = message.game_order[0]; //cp单号
  const orderNo = message.order_no[0]; //sdk订单号
  const payTime = message.pay_time[0];
  const orgProductPrice = message.amount[0]; //充值成功的金额
  const status = message.status[0]; //0成功
  const extrasParams = message.extras_params[0];
  if (status == 1) {
    return;
  }

  const orderInfo = (await Order.getOrder(orderId))[0];

  if (!orderInfo) {
    logger.info(`订单${orderId}不存在`);
    ret.msg = `订单${orderId}不存在`;
    return ret;
  }

  let serverId = orderInfo.server_id; //区服id
  let orgProductId = orderInfo.product_id; //商品id

  if (orderInfo.status == 2) {
    logger.info(`订单${orderId}已经重复发货`);
    ret.code = 1;
    ret.msg = `订单${orderId}已经重复发货`;
    return ret;
  }
  let url = await getServerList(serverId, "default");
  if (!url) {
    logger.info(`区服id错误: serverId ${serverId}`);
    ret.msg = `区服id错误: serverId ${serverId}`;
    return ret;
  }
  // 使用 Msg 类的 connect 方法连接到 WebSocket 服务器
  let sendMsg = new Msg();
  sendMsg.connect(url, Account);
  logger.info(`订单${orderId} ${url}`);
  // 在适当的时机，调用 CG_ASK_LOGIN 方法
  let params = `{"account":"${orgMemId}","order":"${orderId}","id":${orgProductId},"cnt":100,"money":${orgProductPrice}}`;
  return new Promise((resolve) => {
    setTimeout(async () => {
      console.log("这个消息将在3秒后打印出来");
      const send_res = sendMsg.CG_ASK_LOGIN(
        Account,
        0,
        "",
        "cn",
        "CN",
        ctx.request.ip,
        params,
        serverId
      );
      if (!send_res) {
        resolve(ret);
        return;
      }

      const update_time = formatDate(new Date());
      const res = await Order.updateOrderStats(
        orderId,
        2,
        orderNo,
        update_time,
        orderInfo.uid
      );

      if (res.affectedRows <= 0) {
        logger.info(`订单${orderId} 发货失败`);
        ret.msg = "发货失败";
        resolve(ret);
        return;
      }

      ret.code = 1;
      ret.msg = "发货成功";
      resolve(ret);
    }, 1000);
  });
};

const CallPay360 = async (ctx) => {
  let ret = {
    code: 0,
    msg: "发货失败",
  };
  let data = ctx.request.body;
  let sign = data.sign;
  let serverId = data.serverId;
  let orderId = data.cpOrder;
  let out_trade_no = data.orderId;
  logger.info("pay callback params:", { url: ctx.href, params: data });

  const orderInfo = (await Order.getOrder(orderId))[0];

  if (!orderInfo) {
    logger.info(`订单${orderId}不存在`);
    ret.msg = `订单${orderId}不存在`;
    return ret;
  }

  if (orderInfo.status == 2) {
    logger.info(`订单${orderId}已经重复发货`);
    ret.code = 1;
    ret.msg = `订单${orderId}已经重复发货`;
    return ret;
  }

  //签名参数
  let signData = Object.keys(data)
    .sort()
    .filter((key) => key !== "sign");
  let signStr = signData.map((key) => `${data[key]}`).join("");
  signStr += AppSecret360;

  let newSign = CryptoJS.MD5(signStr).toString();
  console.log("signStr:", signStr);
  console.log("newSign:", newSign);
  if (sign != newSign) {
    logger.info(`签名错误: 签名串 ${signStr} newSign ${newSign} sign ${sign}`);
    ret.msg = `签名错误`;
    return ret;
  }

  let url = await getServerList(serverId, "default");
  if (!url) {
    logger.info(`区服id错误: serverId ${serverId}`);
    ret.msg = `区服id错误: serverId ${serverId}`;
    return ret;
  }
  //发货
  // 使用 Msg 类的 connect 方法连接到 WebSocket 服务器
  let sendMsg = new Msg();
  sendMsg.connect(url, Account);
  logger.info(`订单${orderId} ${url}`);

  let orgMemId = data.uid;
  let orgOderId = data.cpOrder;
  let orgProductId = orderInfo.product_id;
  let orgExt = data.cText;
  let orgProductPrice = data.skuPrice;
  // 在适当的时机，调用 CG_ASK_LOGIN 方法
  let params = `{"account":"${orgMemId}","order":"${orgOderId}","id":${orgProductId},"cnt":100,"money":${orgProductPrice}}`;
  return new Promise((resolve) => {
    setTimeout(async () => {
      console.log("这个消息将在3秒后打印出来");
      const send_res = sendMsg.CG_ASK_LOGIN(
        Account,
        0,
        "",
        "cn",
        "CN",
        ctx.request.ip,
        params,
        serverId
      );
      if (!send_res) {
        resolve(ret);
        return;
      }

      const update_time = formatDate(new Date());
      const res = await Order.updateOrderStats(
        orderId,
        2,
        out_trade_no,
        update_time,
        orderInfo.uid
      );

      if (res.affectedRows <= 0) {
        logger.info(`订单${orderId} 发货失败`);
        ret.msg = "发货失败";
        resolve(ret);
        return;
      }

      ret.code = 1;
      ret.msg = "发货成功";
      resolve(ret);
    }, 1000);
  });
};

const testGoogleCallPay = async (ctx) => {
  let ret = {
    code: 0,
    msg: "消费失败",
  };

  let data = ctx.request.body;

  logger.info("pay callback params:", { url: ctx.href, params: data });

  const redisClient = ctx.redis.client;
  let access_token = await redisClient.get("access_token");

  if (!access_token) {
    console.log("请求api获取token");
    const apiData = {
      grant_type: "refresh_token",
      client_id: ClientId,
      client_secret: ClientSecret,
      refresh_token: RefreshToken,
    };

    const response = await axios.post(
      "https://accounts.google.com/o/oauth2/token",
      apiData,
      {
        headers: {
          "Content-Type": "application/x-www-form-urlencoded",
        },
      }
    );

    logger.info("token params:", { data: response.data, params: apiData });

    if (!response.data.access_token) {
      return ret;
    }

    access_token = response.data.access_token;
    await redisClient.set("access_token", response.data.access_token);
    await redisClient.expire("access_token", 1800);
  }

  if (!access_token) {
    return ret;
  }

  let googleToken = data.purchaseToken;
  let product_id = data.orderId;

  const productId = ProductId + product_id;
  let apiUrl = `https://androidpublisher.googleapis.com/androidpublisher/v3/applications/${PackageName}/purchases/products/${productId}/tokens/${googleToken}?access_token=${access_token}`;
  let maxRetries = 5;
  let currentRetry = 0;
  let isCheck = false;

  // 使用 while 循环进行重试
  while (currentRetry < maxRetries) {
    try {
      // // 尝试执行的操作
      const googleRes = await axios.get(apiUrl, {
        headers: {
          "Content-Type": "application/x-www-form-urlencoded",
        },
      });

      console.log(googleRes.data);

      // 如果操作成功，退出循环
      if (googleRes.data.purchaseState == 0) {
        isCheck = true;
        break;
      }
    } catch (error) {
      // 如果操作失败，记录错误并继续尝试
      console.log(error);
    }

    currentRetry++;
  }

  if (!isCheck) {
    return ret;
  }

  return new Promise(async (resolve) => {
    let acknowledgeUrl = `https://androidpublisher.googleapis.com/androidpublisher/v3/applications/${PackageName}/purchases/products/${productId}/tokens/${googleToken}:acknowledge?access_token=${access_token}`;
    console.log(acknowledgeUrl);
    const acknowledgeRes = 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}`;
    const consumeRes = await axios.post(
      consumeUrl,
      {
        developerPayload: "",
      },
      {
        headers: {
          "Content-Type": "application/json",
        },
      }
    );

    ret.code = 1;
    ret.msg = "发货成功";
    resolve(ret);
  });
};

const checkVersion = async (ctx) => {
  let ret = {
    code: 0,
    msg: "无需更新",
    url: "",
  };
  let data = ctx.request.body;
  let version = data.version;
  let tag = data.tag || "default";
  logger.info("checkVersion params:", { url: ctx.href, params: data });

  const versionInfo = (await Version.getGameVersion(tag))[0];

  if (!versionInfo) {
    return ret;
  }

  if (compareVersions(versionInfo.version, version) === 1) {
    if (versionInfo.download_url) {
      ret.code = 1;
      ret.msg = "需要更新";
      ret.url = versionInfo.download_url;
    }
  }
  return ret;
};

function splitString(input: string, separator: string): string[] {
  return input.split(separator);
}

function extractIPAddresses(text: string): string[] {
  // 正则表达式匹配IP地址
  const ipRegex = /(?:(?:\d{1,3}\.){3}\d{1,3})/g;
  // 使用正则表达式执行匹配并返回结果
  return text.match(ipRegex) || [];
}

//验证账号
const checkUserToken = async (ctx) => {
  let ret = {
    code: 0,
    msg: "请求失败",
  };

  let ip = ctx.request.ip;
  if (ip.startsWith("::ffff:")) {
    ip = ip.substring("::ffff:".length);
  }

  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))[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) {
      ret.msg = "添加账户失败";
      return ret;
    }
  }

  res = await User.logAccountLogin(
    uid,
    ip,
    device_type,
    device_no,
    device_model,
    device_version,
    system_version,
    create_time
  );

  if (res.affectedRows <= 0) {
    ret.msg = "添加日志失败";
    return ret;
  }

  ret.code = 1;
  ret.msg = "请求成功";
  return ret;
};

class ApiController {
  async createOrder(ctx) {
    let { uid, level, amount, role_id, role_name, product_id, server_id } =
      ctx.request.body;

    logger.info("create params:", { params: ctx.request.body });

    if (
      !product_id ||
      !server_id ||
      !role_name ||
      !role_id ||
      !amount ||
      !uid
    ) {
      ctx.body = { code: -1, message: "参数错误,创建订单失败!!", data: "" };
      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,
      create_time
    );

    if (res.affectedRows > 0) {
      ctx.body = { code: 0, message: "创建订单成功", data: orderId };
    } else {
      ctx.body = { code: -1, message: "创建订单失败", data: "" };
    }

    logger.info("创建订单返回结果:", { params: ctx.body });
  }

  async checkUserToken(ctx) {
    let data = ctx.request.body;
    let platform = "360"; // 默认360

    if (ctx.query.platform) {
      platform = ctx.query.platform;
    }

    if (data.platform) {
      platform = data.platform;
    }

    switch (platform) {
      case "360":
        var result = await checkUserToken(ctx);
        ctx.body = result;
        break;
      case "th":
        var result = await checkUserToken(ctx);
        ctx.body = result;
        break;
    case "quick":
        var result = await checkUserToken(ctx);
        ctx.body = result;
        break;
      default:
        ctx.body = {
          code: 0,
          msg: "渠道错误",
        };
    }
  }

  //quick登陆
  async quickUserLogin(ctx) {
    //sdk参数
    let productCode = "40202114039243214268433998697181";

    let data = ctx.request.body;
    let uid = data.uid;
    let token = data.token;
    let reqUrl =
      "http://checkuser.quickapi.net/v2/checkUserInfo?token=" +
      token +
      "&uid=" +
      uid +
      "product_code=" +
      productCode;
    logger.info("quick登陆验证请求", { params: data, url: reqUrl });
    const res = await axios.get(reqUrl);
    logger.info("quick req", { res: res.data });
    if (res.data == "1") {
      ctx.body = {
        code: 200,
        msg: "success",
      };
    } else {
      ctx.body = {
        code: 0,
        msg: "fail",
      };
    }
  }

  async callPay(ctx) {
    console.log(234234234);
    let data = ctx.request.body;
    let platform = "360"; // 默认360

    if (ctx.query.platform) {
      platform = ctx.query.platform;
    }

    if (data.platform) {
      platform = data.platform;
    }

    switch (platform) {
      case "google":
        var result = await googleCallPay(ctx);
        console.log("发货结果", result);
        ctx.body = result;
        break;
      case "apple":
        var result = await appleCallPay(ctx);
        console.log("发货结果", result);
        ctx.body = result;
        break;
      case "360":
        var result = await CallPay360(ctx);
        console.log("发货结果", result);
        ctx.body = result;
        break;
      // case 'testGoogle':
      // var result = await testGoogleCallPay(ctx)
      // console.log('发货结果', result)
      // ctx.body = result
      // break;
      case "quick":
        var result = await CallPayQuick(ctx);
        console.log("发货结果", result);
        if ((result as any).code == 1) {
          ctx.body = "SUCCESS";
        } else {
          ctx.body = "Fail";
        }
        break;
      default:
        ctx.body = {
          code: 0,
          msg: "渠道错误",
        };
    }
  }

  async checkVersion(ctx) {
    var result = await checkVersion(ctx);
    console.log("校验版本", result);
    ctx.body = result;
  }

  async getServerList(ctx) {
    let tag = ctx.query.tag || "default";
    const servers = await Server.getServerList(tag);
    let data = [];
    let ip = ctx.request.ip;
    if (ip.startsWith("::ffff:")) {
      ip = ip.substring("::ffff:".length);
    }

    logger.info("区服接口", { ip: ctx.request.ip });
    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;
            }
          }
        }

        data.push({
          id: element.id,
          name: element.name,
          ip: element.ip,
          port: element.port,
          tips: element.tips,
          status: status,
        });
      });
    }

    ctx.body = data;
  }
  async getAllServerList(ctx) {
    let tag = ctx.query.tag || "default";
    let ip = ctx.request.ip;
    if (ip.startsWith("::ffff:")) {
      ip = ip.substring("::ffff:".length);
    }
    logger.info("getAllServerList 区服接口", { ip: ctx.request.ip });
    const servers = await Server.getAllServerList(tag, ip);
    ctx.body = servers;
  }

  async enterServer(ctx) {
    let ret = {
      code: 0,
      msg: "请求失败",
    };

    let { uid, server_id } = ctx.request.body;

    let url = await getServerList(server_id, "default");
    if (!url) {
      ctx.body = {
        code: -1,
        message: `区服id错误: serverId ${server_id}`,
        data: "",
      };
      return;
    }

    logger.info("create params:", { params: ctx.request.body });

    if (!server_id || !uid) {
      ctx.body = { code: -1, message: "参数错误!!", data: "" };
      return;
    }

    const create_time = formatDate(new Date());
    const serverInfo = (await Server.checkEnterServerByUid(uid, server_id))[0];
    let res = null;

    if (serverInfo) {
      res = await Server.updateEnterServer(serverInfo.id, create_time);
    } else {
      res = await Server.enterServer(uid, server_id, create_time);
    }

    if (res.affectedRows > 0) {
      ctx.body = { code: 0, message: "请求成功", data: "" };
    } else {
      ctx.body = { code: -1, message: "请求失败", data: "" };
    }
  }

  async getLastServerList(ctx) {
    let { uid } = ctx.request.body;

    let tag = "default";
    let data = [];
    let isNewAccount = 1;
    let enterServerList = await Server.getEnterServerListByUid(uid);
    let ip = ctx.request.ip;
    if (ip.startsWith("::ffff:")) {
      ip = ip.substring("::ffff:".length);
    }
    logger.info("getLastServerList 区服接口", { ip: ctx.request.ip });

    if (enterServerList.length > 0) {
      isNewAccount = 0;
      // const servers = (await Server.getServerList(tag, 1))
      const servers = await Server.getAllServerList(tag, ip);
      enterServerList.forEach(function (element) {
        data.push({
          channel: "Thailand", //渠道固定
          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.ip ? `ws://${element.ip}:${element.port}` : "",
          status: element.status || 0,
        });
      });
    } else {
      // const servers = (await Server.getServerList(tag, 1))
      const servers = await Server.getAllServerList(tag, ip);
      if (servers.length > 0) {
        const serverInfo = servers[servers.length - 1];
        data.push({
          channel: "Thailand", //渠道固定
          minSid: 1, //最小服务器
          maxSid: servers.length, //最大服务器 这里会控制 服务器列表显示的数量
          isNewAccount: isNewAccount, //1为新号 会弹出用户协议
          //以下是最近登陆的服务器 (不可为空 如果没有参数可以填最后一个区)
          sid: serverInfo.id || 1,
          id: serverInfo.id || 1,
          name: serverInfo.name || "1区",
          tips: serverInfo.tips || "",
          server: serverInfo.ip
            ? `ws://${serverInfo.ip}:${serverInfo.port}`
            : "",
          status: serverInfo.status || 0,
        });
      } else {
        data.push({
          channel: "Thailand", //渠道固定
          minSid: 1, //最小服务器
          maxSid: 10, //最大服务器 这里会控制 服务器列表显示的数量
          isNewAccount: isNewAccount, //1为新号 会弹出用户协议
          //以下是最近登陆的服务器 (不可为空 如果没有参数可以填最后一个区)
          sid: 1,
          id: 1,
          name: "1区",
          tips: "",
          server: "",
          status: 0,
        });
      }
    }

    ctx.body = data;
  }

  async getNotice(ctx) {
    let data = ctx.request.body;
    let platform = "th";
    if (ctx.query.platform) {
      platform = ctx.query.platform;
    }

    let content = "";
    let content_wh = "";
    const system = await System.getSystemConfig();

    if (system) {
      system.forEach((element) => {
        if (element.key == "content") {
          content = element.value;
        }

        if (element.key == "content_wh") {
          content_wh = element.value;
        }
      });
    }

    let notice_data = [
      {
        status: 1,
        content: content,
        content_wh: content_wh,
      },
    ];

    if (notice_data[0].content == "") {
      switch (platform) {
        case "th":
          notice_data = th_notice;
          break;
        case "360":
          notice_data = notice;
          break;
        case "xky":
          notice_data = xky_notice;
          break;
        default:
          notice_data = notice;
      }
    }
    ctx.body = notice_data;
  }

  async genCDK(ctx) {
    /*
        data = {
            cnt : number -- 生成数量
            useCnt : number -- 当前批次最大使用数量
            serverList : string -- 区服列表Json字符串
            itemList : string -- CDK对应物品列表Json字符串
        }
        */
    let data = ctx.request.body;
    await CDK.genCDK(
      ctx,
      data.cnt,
      data.useCnt,
      data.serverList,
      data.itemList
    );
    ctx.body = {
      code: 0,
      msg: "success",
    };
    return;
  }

  async getCDK(ctx) {
    let data = ctx.request.body;
    let ret = await CDK.getCDK(ctx, data.batch);
    if (ret.length <= 0) {
      ctx.body = {
        code: 1,
        msg: "batch invalid",
      };
      return;
    }
    ctx.body = {
      code: 0,
      msg: ret,
    };
  }
  async useCDK(ctx) {
    let data = ctx.request.body;
    let url = await getServerList(data.serverId, "default");
    let err = "";
    if (!url) {
      ctx.body = {
        code: 1,
        msg: `区服id错误: serverId ${data.serverId}`,
      };
      err = "server id invalid";
    }
    let param: string = "";
    // 验证CDK
    if (err.length == 0) {
      let batchInfo = await CDK.getCDKItemList(ctx, data.code);
      if (batchInfo.length <= 0) {
        err = "cdk not found";
      } else {
        err = await CDK.checkCDK(ctx, data.code, data.serverId);
        param = JSON.stringify({
          type: "UseCDK",
          err: err,
          batchInfo: batchInfo,
        });
      }
    }
    // 固定码
    if (err == "cdk not found" || err == "server id invalid") {
      param = JSON.stringify({
        code: data.code,
        type: "UseFixCDK",
      });
    }
    // 测试是否可以调用过去
    // 通知给服务器，发放道具
    // "ws://43.143.193.23:18192"
    // Msg.connect(url, Account);
    try {
      let sendMsg = new Msg();
      sendMsg.connect(url, Account);
      logger.info(`code ${data.code} id ${data.serverId} ${url}`);
      new Promise((resolve) => {
        setTimeout(async () => {
          sendMsg.CG_TEST_PROTO(data.account, param);
          CDK.useCDK(ctx, data.code);
        }, 1000);
      });
    } catch (error) {
      console.log(error);
    }
    ctx.body = {
      code: 0,
      msg: "success",
    };
  }

  async validCDK(ctx) {
    let data = ctx.request.body;
    if (data.code.length == 10) {
      let ret = await CDK.useCDK(ctx, data.code);
      if (ret != "success") {
        ctx.body = {
          code: 1,
          msg: ret,
        };
        return;
      }
    }
    ctx.body = {
      code: 0,
      msg: "success",
    };
  }

  // 维护服务器，踢掉所有玩家
  async maintenance(ctx) {
    let data = ctx.request.body;
    let url = await getServerList(data.serverId, "default");
    if (!url) {
      ctx.body = {
        code: 1,
        msg: `区服id错误: serverId ${data.serverId}`,
      };
      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);
    });
    ctx.body = {
      code: 0,
      msg: "success",
    };
  }

  async maintenanceAll(ctx) {
    let data = ctx.request.body;

    const servers = await Server.getServerList("default");
    const serversId = []
    servers.forEach(function (element) {
      let url = "ws://" + element.ip + ":" + element.port;
      if (!url) {
        ctx.body = {
          code: 1,
          msg: `区服id错误: serverId ${element.id}`,
        };
        return;
      }
      serversId.push(element.id)

      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);
      });
    });

    const res = await Server.updateServerStatus(
        serversId,
        3
      );

    ctx.body = {
      code: 0,
      msg: "success",
    };
  }

  async sendMail(ctx) {
    let data = ctx.request.body;
    let url = await getServerList(data.serverId, "default");
    if (!url) {
      ctx.body = {
        code: 1,
        msg: `区服id错误: serverId ${data.serverId}`,
      };
      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 = {
      code: 0,
      msg: "success",
    };
  }

  async sendAllMail(ctx) {
    let data = ctx.request.body;


    if (!data.server_list || data.server_list.length === 0) {
      ctx.body = { code: -1, message: "区服不能为空", data: "" };
      return;
    }

    logger.info("sendAllMail 接口请求 data:", { data: data });

    const server_list = data.server_list;
    const servers = await Server.getServerList("default");
    const filteredServer = servers.filter(item => server_list.includes(item.id));

    filteredServer.forEach(function (element) {
        let url = "ws://" + element.ip + ":" + element.port;
        if (!url) {
          ctx.body = {
            code: 1,
            msg: `区服id错误: serverId ${element.server_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 = {
      code: 0,
      msg: "success",
    };
  }

  async useCDKV2(ctx) {
    let body = ctx.request.body;
    let data = {
      code: body.code,
      userId: body.account,
    };

    if (body.uuid) {
      data.userId = body.uuid;
    }

    logger.info("api cdk 接口请求 data:", { data: data });

    let serverUrl = await getServerList(body.serverId, "default");
    let err = "";
    if (!serverUrl) {
      ctx.body = {
        code: 1,
        msg: `区服id错误: serverId ${body.serverId}`,
      };
      return;
    }
    let port = 8004;
    // let host = extractIPAddresses(serverUrl)[0]
    let host = "127.0.0.1";
    let url = "http://" + host + ":" + port + "/api/giftCode/exchange";

    try {
      const response = await axios.post(url, data, {
        headers: {
          "Content-Type": "application/json",
        },
      });
      let param: string = "";
      logger.info("api cdk 接口返回 response:", { data: response.data });
      if (response.data.code != 200) {
        // 可能是固定码 ，游戏再去检测一下
        param = JSON.stringify({
          code: data.code,
          type: "UseFixCDK",
        });
      } else {
        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,
        });
      }

      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);
        }, 1000);
      });
    } catch (error) {
      console.log(error);
    }
    ctx.body = {
      code: 0,
      msg: "success",
    };
  }
}

module.exports = new ApiController();