heros/build-templates/wechatgame/cloud_functions/cocos_cloud/modules/auth.js

// 登录认证模块
const { 
  getNewUserInitData, 
  mergeUserDataWithDefaults, 
  checkDataVersionCompatibility 
} = require('../user_init_data');

const user_db_name = "cocos_users";

/**
 * 用户登录处理
 * @param {Object} db 数据库实例
 * @param {Object} wxContext 微信上下文
 * @returns {Object} 登录结果
 */
async function login(db, wxContext) {
  try {
    let user = await getOrCreaterUser(db, wxContext.OPENID);
    if (!user) {
      return {
        code: -4,
        msg: "获取或创建用户失败"
      };
    }
    
    return {
      code: 200,
      data: {
        user_id: user._id,
        openid: user._openid,
        regist_time: user.regist_time,
        data: user.data,
        fight_heros: user.fight_heros,
        heros: user.heros,
        items: user.items,
        tals: user.tals,
        equips: user.equips,
        data_version: user.data_version,
        last_save_time: user.last_save_time || null
      },
      msg: "登录成功"
    };
  } catch (error) {
    console.error("登录错误:", error);
    return {
      code: -5,
      msg: `登录错误: ${error.message}`
    };
  }
}

/**
 * 获取或创建用户
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @returns {Object} 用户数据
 */
async function getOrCreaterUser(db, openid) {
  try {
    let res = await db.collection(user_db_name).where({ _openid: openid }).get();
    let userData = null;
    
    if (res == null || res.data == null || res.data.length <= 0) {
      // 创建新用户时使用初始化数据配置
      let initData = getNewUserInitData();
      userData = {
        _openid: openid,
        regist_time: Date.now(),
        data: initData.data,
        fight_heros: initData.fight_heros,
        heros: initData.heros,
        items: initData.items,
        tals: initData.tals,
        equips: initData.equips,
        data_version: initData.data_version,
        init_time: initData.init_time
      };
      
      let addResult = await db.collection(user_db_name).add({
        data: userData
      });
      userData._id = addResult._id;
      
  // console.log(`新用户已创建: ${openid}, 版本: ${initData.data_version}`);
    } else {
      userData = res.data[0];
      
      // 检查数据版本兼容性
      const versionCheck = checkDataVersionCompatibility(userData.data_version);
  // console.log(`用户 ${openid} 数据版本检查:`, versionCheck);
      
      if (versionCheck.needsUpgrade) {
        // 使用新的数据管理系统合并和升级数据
        const upgradedData = mergeUserDataWithDefaults({
          data: userData.data,
          fight_heros: userData.fight_heros,
          heros: userData.heros,
          items: userData.items,
          tals: userData.tals,
          equips: userData.equips,
          data_version: userData.data_version
        });
        
        // 更新用户数据
        userData.data = upgradedData.data;
        userData.fight_heros = upgradedData.fight_heros;
        userData.heros = upgradedData.heros;
        userData.items = upgradedData.items;
        userData.tals = upgradedData.tals;
        userData.equips = upgradedData.equips;
        userData.data_version = upgradedData.data_version;
        
    // console.log(`用户 ${openid} 数据已升级到版本: ${upgradedData.data_version}`);
      }
    }
    
    return userData;
  } catch (err) {
    console.error(`获取或创建用户错误`, err);
    return null;
  }
}

/**
 * 获取用户基本信息
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @returns {Object} 用户基本信息
 */
async function getUserInfo(db, openid) {
  try {
    let user = await getOrCreaterUser(db, openid);
    if (!user) {
      return {
        code: -4,
        msg: "未找到用户"
      };
    }
    
    return {
      code: 200,
      data: {
        user_id: user._id,
        openid: user._openid,
        regist_time: user.regist_time,
        init_time: user.init_time,
        data_version: user.data_version,
        last_save_time: user.last_save_time
      },
      msg: "用户信息获取成功"
    };
  } catch (error) {
    console.error("获取用户信息错误:", error);
    return {
      code: -5,
      msg: `获取用户信息错误: ${error.message}`
    };
  }
}

/**
 * 检查用户数据版本
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @returns {Object} 版本检查结果
 */
async function checkVersion(db, openid) {
  try {
    let user = await getOrCreaterUser(db, openid);
    if (!user) {
      return {
        code: -4,
        msg: "未找到用户"
      };
    }
    
    const versionCheck = checkDataVersionCompatibility(user.data_version);
    
    return {
      code: 200,
      data: {
        user_version: user.data_version || "unknown",
        current_version: require('../user_init_data').DATA_VERSION,
        compatibility: versionCheck,
        init_time: user.init_time,
        regist_time: user.regist_time,
        last_save_time: user.last_save_time
      },
      msg: "版本信息获取成功"
    };
  } catch (error) {
    console.error("检查版本错误:", error);
    return {
      code: -5,
      msg: `检查版本错误: ${error.message}`
    };
  }
}

/**
 * 强制升级用户数据
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @returns {Object} 升级结果
 */
async function upgradeUserData(db, openid) {
  try {
    const _ = db.command;
    let user = await getOrCreaterUser(db, openid);
    if (!user) {
      return {
        code: -4,
        msg: "User not found"
      };
    }
    
    // 强制升级用户数据
    const upgradedData = mergeUserDataWithDefaults({
      data: user.data,
      fight_heros: user.fight_heros,
      heros: user.heros,
      items: user.items,
      tals: user.tals,
      equips: user.equips,
      data_version: user.data_version
    });
    
    let upgradeDataRes = await db.collection(user_db_name).doc(user._id).update({
      data: {
        data: _.set(upgradedData.data),
        fight_heros: _.set(upgradedData.fight_heros),
        heros: _.set(upgradedData.heros),
        items: _.set(upgradedData.items),
        tals: _.set(upgradedData.tals),
        equips: _.set(upgradedData.equips),
        data_version: _.set(upgradedData.data_version),
        last_save_time: _.set(Date.now()),
        upgrade_time: _.set(Date.now())
      }
    });

    if (upgradeDataRes?.stats?.updated >= 1) {
      return {
        code: 200,
        data: {
          old_version: user.data_version || "unknown",
          new_version: upgradedData.data_version,
          upgrade_time: Date.now(),
          data: upgradedData.data,
          fight_heros: upgradedData.fight_heros,
          heros: upgradedData.heros,
          items: upgradedData.items,
          tals: upgradedData.tals,
          equips: upgradedData.equips
        },
        msg: "数据升级成功完成"
      };
    } else {
      return {
        code: -1,
        msg: `升级失败, ${JSON.stringify(upgradeDataRes)}`
      };
    }
  } catch (error) {
    console.error("升级用户数据错误:", error);
    return {
      code: -5,
      msg: `升级错误: ${error.message}`
    };
  }
}

module.exports = {
  login,
  getOrCreaterUser,
  getUserInfo,
  checkVersion,
  upgradeUserData
};