shoot-miniprograms/src/apis.js

let BASE_URL = "https://api.shelingxingqiu.com/api/shoot"; // 默认正式版

try {
  const accountInfo = uni.getAccountInfoSync();
  const envVersion = accountInfo.miniProgram.envVersion;

  switch (envVersion) {
    case "develop": // 开发版
      // BASE_URL = "http://192.168.1.30:8000/api/shoot";
      BASE_URL = "https://apitest.shelingxingqiu.com/api/shoot";
      break;
    case "trial": // 体验版
      BASE_URL = "https://apitest.shelingxingqiu.com/api/shoot";
      break;
    case "release": // 正式版
      BASE_URL = "https://api.shelingxingqiu.com/api/shoot";
      break;
    default:
      // 保持默认值
      break;
  }
} catch (e) {
  console.error("获取环境信息失败，使用默认正式环境", e);
}

function request(method, url, data = {}) {
  const token = uni.getStorageSync(
    `${uni.getAccountInfoSync().miniProgram.envVersion}_token`
  );
  const header = {};
  if (token) header.Authorization = `Bearer ${token || ""}`;
  return new Promise((resolve, reject) => {
    uni.request({
      url: `${BASE_URL}${url}`,
      method,
      header,
      data,
      timeout: 10000,
      success: (res) => {
        if (res.data) {
          const { code, data, message } = res.data;
          if (code === 0) resolve(data);
          else if (message) {
            if (message.indexOf("登录身份已失效") !== -1) {
              uni.removeStorageSync(
                `${uni.getAccountInfoSync().miniProgram.envVersion}_token`
              );
              uni.$emit("update-user");
            }
            if (message === "ROOM_FULL") {
              resolve({ full: true });
              return;
            }
            if (message === "ERROR_ROOM_GAME_START") {
              resolve({ started: true });
              return;
            }
            if (url.indexOf("/user/room") !== -1 && method === "GET") {
              resolve({});
              return;
            }
            if (message === "ERROR_BATTLE_GAMING") {
              resolve({});
              return;
            }
            if (message === "BIND_DEVICE") {
              resolve({ binded: true });
              return;
            }
            if (message === "ERROR_ORDER_UNPAY") {
              uni.showToast({
                title: "当前有未支付订单",
                icon: "none",
              });
              resolve({});
              return;
            }
            if (message === "ROOM_EMPTY") {
              return uni.showToast({
                title: "房间已过期",
                icon: "none",
              });
            }
            uni.showToast({
              title: message,
              icon: "none",
            });
          }
          reject("");
        }
      },
      fail: (err) => {
        handleRequestError(err, url);
        reject(err);
      },
    });
  });
}

// 统一的错误处理函数
function handleRequestError(err, url) {
  console.log("请求失败:", { err, url });

  // 根据错误类型显示不同提示
  if (err.errMsg) {
    if (err.errMsg.includes("timeout")) {
      showCustomToast("请求超时，请稍后重试", "timeout");
    } else if (err.errMsg.includes("fail")) {
      // 检查网络状态
      uni.getNetworkType({
        success: (res) => {
          if (res.networkType === "none") {
            showCustomToast("网络连接已断开，请检查网络设置", "network");
          } else {
            showCustomToast("服务器连接失败，请稍后重试", "server");
          }
        },
        fail: () => {
          showCustomToast("网络异常，请检查网络连接", "unknown");
        },
      });
    } else {
      showCustomToast("请求失败，请稍后重试", "general");
    }
  } else {
    showCustomToast("网络异常，请稍后重试", "unknown");
  }
}

// 自定义提示函数
function showCustomToast(message, type) {
  const config = {
    title: message,
    icon: "none",
    duration: 3000,
  };

  // 根据错误类型可以添加不同的处理逻辑
  switch (type) {
    case "timeout":
      config.duration = 4000; // 超时提示显示更久
      break;
    case "network":
      config.duration = 5000; // 网络问题提示显示更久
      break;
    default:
      break;
  }

  uni.showToast(config);
}

// 获取全局配置
export const getAppConfig = () => {
  return request("GET", "/index/appConfig");
};

export const getHomeData = (seasonId) => {
  return request("GET", `/user/myHome?seasonId=${seasonId}`);
};

export const getProvinceData = () => {
  return request("GET", "/index/provinces/list");
};

export const loginAPI = async (phone, nickName, avatarData, code) => {
  const result = await request("POST", "/index/code", {
    appName: "shoot",
    appId: "wxa8f5989dcd45cc23",
    nickName,
    avatarData,
    code,
    phone,
  });
  uni.setStorageSync(
    `${uni.getAccountInfoSync().miniProgram.envVersion}_token`,
    result.token
  );
  return result;
};

export const bindDeviceAPI = (device) => {
  return request("POST", "/user/device/bindDevice", {
    device,
  });
};

export const unbindDeviceAPI = (deviceId) => {
  return request("POST", "/user/device/unbindDevice", {
    deviceId,
  });
};

export const getMyDevicesAPI = () => {
  // "/user/device/getBinding?deviceId=9ZF9oVXs"
  return request("GET", "/user/device/getBindings");
};

export const createPractiseAPI = (arrows, time) => {
  return request("POST", "/user/practice/create", {
    shootNumber: arrows,
    shootTime: time,
  });
};

export const startPractiseAPI = () => {
  return request("POST", "/user/practice/begin");
};

export const endPractiseAPI = () => {
  return request("POST", "/user/practice/stop");
};

export const getPractiseAPI = async (id) => {
  return request("GET", `/user/practice/get?id=${id}`);
};

export const createRoomAPI = (gameType, teamSize) => {
  return request("POST", "/user/createroom", {
    gameType,
    teamSize,
  });
};

export const getRoomAPI = (number) => {
  return request("GET", `/user/room?number=${number}`);
};

export const joinRoomAPI = (number) => {
  return request("POST", `/user/room/join`, { number });
};

export const destroyRoomAPI = (roomNumber) => {
  return request("POST", "/user/room/destroyRoom", {
    roomNumber,
  });
};

export const exitRoomAPI = (number, userId) => {
  return request("POST", "/user/room/exitRoom", {
    number,
    userId,
  });
};

export const startRoomAPI = (number) => {
  return request("POST", "/user/room/start", { number });
};

export const getPractiseResultListAPI = async (page = 1, page_size = 15) => {
  const reuslt = await request(
    "GET",
    `/user/practice/list?page=${page}&page_size=${page_size}`
  );
  return reuslt.list;
};

export const matchGameAPI = (match, gameType, teamSize) => {
  return request("POST", "/user/game/match", {
    match,
    gameType,
    teamSize,
    readyTime: 1.5,
  });
};

export const readyGameAPI = (battleId) => {
  return request("POST", "/user/game/prepare", {
    battleId,
  });
};

export const simulShootAPI = (device_id, x, y) => {
  const data = {
    device_id,
  };
  if (x !== undefined && y !== undefined) {
    data.x = x;
    data.y = y;
  }
  return request("POST", "/index/arrow", data);
};

export const getBattleListAPI = async (page, battleType) => {
  const result = await request("POST", "/user/battle/details/list", {
    page,
    pageSize: 10,
    battleType,
  });
  return result.list;
};

export const getRankListAPI = () => {
  return request("GET", "/index/ranklist");
};

export const createOrderAPI = (vipId) => {
  return request("POST", "/user/order/create", {
    vipId,
    quanity: 1,
    tradeType: "mini",
    payType: "wxpay",
  });
};

export const payOrderAPI = (id) => {
  return request("POST", "/user/order/pay", {
    id,
    tradeType: "mini",
    payType: "wxpay",
  });
};

export const getOrderListAPI = async (page) => {
  const reuslt = await request("GET", `/user/order/list?page=${page}`);
  return reuslt.items || [];
};

export const cancelOrderListAPI = async (id) => {
  return request("POST", "/user/order/cancelOrder", { id });
};

export const getUserGameState = () => {
  return request("GET", "/user/state");
};

export const getPointBookConfigAPI = async () => {
  return request("GET", "/user/score/sheet/option");
};

export const savePointBookAPI = async (
  bowType,
  distance,
  targetType,
  groups,
  arrows,
  data = []
) => {
  return request("POST", "/user/score/sheet/report", {
    bowType,
    distance,
    targetType,
    groups,
    arrows,
    group_data: data.map((item) =>
      item.map((i) => ({
        ...i,
        ring: i.ring === "M" ? -1 : i.ring === "X" ? 0 : Number(i.ring),
      }))
    ),
  });
};

export const getPointBookListAPI = async (
  page = 1,
  bowType,
  distance,
  targetType
) => {
  let url = `/user/score/sheet/list?pageNum=${page}&pageSize=10`;
  if (bowType) url += `&bowType=${bowType}`;
  if (distance) url += `&distance=${distance}`;
  if (targetType) url += `&targetType=${targetType}`;
  const result = await request("GET", url);
  return result.list || [];
};

export const getPointBookDetailAPI = async (id) => {
  return request("GET", `/user/score/sheet/detail?id=${id}`);
};

export const getPointBookDataAPI = async () => {
  return request("GET", "/user/score/sheet/statistics");
};

export const getPractiseDataAPI = async () => {
  return request("GET", "/user/practice/statistics");
};

export const getBattleDataAPI = async () => {
  return request("GET", "/user/fight/statistics");
};

export const chooseTeamAPI = async (number, group) => {
  return request("POST", "/user/room/group", { number, group });
};

export const getVIPDescAPI = async () => {
  return request("GET", "/index/memberVipDescribe");
};

export const getPointBookStatisticsAPI = async () => {
  return request("GET", `/v2/user/score/sheet/statistics`);
};

export const donateAPI = async (amount, name, phone, organizer, advice) => {
  return request("POST", `/user/donate`, {
    amount,
    name,
    phone,
    organizer,
    advice,
  });
};

export const laserAimAPI = async () => {
  return request("POST", "/user/device/laserAim");
};

export const laserCloseAPI = async () => {
  return request("POST", "/user/device/closeAim");
};

export const getDeviceBatteryAPI = async () => {
  return request("GET", "/user/device/battery");
};

export const addNoteAPI = async (id, remark) => {
  return request("POST", "/user/score/sheet/remark", { id, remark });
};

export const removePointRecord = async (id) => {
  return request("DELETE", `/user/score/sheet/delete?id=${id}`);
};

export const getPhoneNumberAPI = (data) => {
  return request("POST", "/index/getPhone", data);
};

export const getPointBookRankListAPI = (page = 1) => {
  return request(
    "GET",
    `/user/score/sheet/week/shoot/rank/list?pageNum=${page}&pageSize=100`
  );
};

export const clickLikeAPI = (userId, ifLike) => {
  return request("POST", "/user/score/sheet/week/shoot/rank/like", {
    userId,
    ifLike,
  });
};

export const getMyLikeList = (page = 1, pageSize = 10) => {
  return request(
    "GET",
    `/user/score/sheet/week/shoot/rank/like/list?pageNum=${page}&pageSize=${pageSize}`
  );
};

export const getReadyAPI = (roomId) => {
  return request("POST", `/user/room/ready`, {
    roomId,
  });
};

export const getBattleAPI = async (battleId) => {
  return request("POST", "/user/match/info", {
    id: battleId,
  });
};

export const kickPlayerAPI = (number, userId) => {
  return request("POST", "/user/room/kicking", {
    number,
    userId,
  });
};