pbf-wxapp/index.js

// var Parse = getApp().Parse;
// var app = getApp()
// const { wxLogin } = require('./utils/login')
const CONFIG = require("config.js");
let config = {
  appid: CONFIG.default.appid,
  company: CONFIG.default.company,
  rootPage: CONFIG.default.rootPage,
}
const plugin = requirePlugin('fm-plugin')
const { Parse, checkAuth } = plugin

Page({
  /**
   * 页面的初始数据
   */
  data: {
    splashUrl: wx.getStorageSync("enabledOptions")[0],
    loading:true
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad: async function (options) {
    // 拦截插件的"登录信息已过期"提示
    const originalShowModal = wx.showModal;
    wx.showModal = function(options) {
      // 如果是"登录信息已过期"的提示，改为友好的重新登录提示
      if (options.content && options.content.includes('登录信息过期')) {
        console.log('⚠️ 拦截到"登录信息已过期"提示，改为友好提示');
        
        return originalShowModal.call(this, {
          title: '提示',
          content: '登录状态异常，是否重新登录？',
          showCancel: true,
          cancelText: '取消',
          confirmText: '重新登录',
          success: (result) => {
            if (result.confirm) {
              // 清除登录状态
              wx.removeStorageSync("sessionToken");
              wx.removeStorageSync("userLogin");
              
              // 重新加载首页
              const rootPage = getApp().globalData.rootPage || getApp().globalData.defaultTabBar?.list?.[0]?.pagePath || '/pages/index/index';
              wx.reLaunch({
                url: rootPage
              });
            }
            
            // 调用原始的 success 回调
            if (options.success) {
              options.success(result);
            }
          }
        });
      }
      
      // 其他提示正常显示
      return originalShowModal.call(this, options);
    };
    
    wx.login({
      success: function (res) {
        if (res.code) {
          console.log(res);
          // wx.request({
          //   url: "https://server.fmode.cn/api/wxapp/auth_wxapp",
          //   data: {
          //     c: getApp().globalData.company,
          //     code: res.code,
          //   },
          //   async success(res) {
          //     wx.setStorageSync("userInfo", res.data);
          //     resolve(res)
          //   },
          // });
        }
      },
      fail: function (err) {
        wx.showToast({
          title: '服务器繁忙，请稍后重试',
        })
      }
    });

    wx.setStorageSync("invite", null);
    
    // 处理扫码链接（options.q 包含完整的URL或activityId）
    if (options.q) {
      let str = decodeURIComponent(options.q); // 扫描二维码获得的跳转链接

      // 兼容一些环境中把 & 编码成 & 的情况，防止参数解析错误（如 scanCount=0&storeId=...）
      if (str.indexOf('&') !== -1) {
        console.log('🔧 检测到 URL 中包含 &，自动还原为 &');
        str = str.replace(/&/g, '&');
      }
      
      // 检查是否是员工邀请链接（app.fmode.cn/dev/pobingfeng/manager/staff?invite=xxx）
      if (str.includes('app.fmode.cn/dev/pobingfeng/manager/staff')) {
        let obj = this.getParaName(str);
        if (obj && obj.invite) {
          wx.setStorageSync("invite", obj.invite);
          console.log('✅ 检测到员工邀请链接，invite:', obj.invite);
        }
        // 员工邀请链接不需要跳转到店铺，直接返回
        this.setData({ options: options });
        plugin.init(config, wx.getStorageSync('invite'));
        return;
      }
      
      // 检查是否是活动海报二维码（activityId作为qrCode参数值）
      // 如果str不包含http/https，且看起来像是一个ID，则可能是activityId
      if (!str.includes('http://') && !str.includes('https://') && !str.includes('?')) {
        // 可能是活动ID，尝试作为activityId处理
        if (str && str.length > 0 && !isNaN(str)) {
          options.activityId = str;
          console.log('✅ 检测到活动海报二维码，activityId:', str);
          // 活动二维码需要特殊处理，先保存activityId
          wx.setStorageSync("activityId", str);
        }
      }
      
      // 处理店铺相关的二维码链接（pwa.fmode.cn/gomini/pmd/）
      // 从完整URL中提取参数
      if (str.includes('pwa.fmode.cn/gomini/pmd') || str.includes('?')) {
        let obj = this.getParaName(str);
        if (obj && obj.invite) {
          wx.setStorageSync("invite", obj.invite);
        }
        // 将所有参数合并到 options 中
        obj && Object.keys(obj).forEach(key=> options[key] = obj[key]);
      }
    }
    // 兼容从编译参数或页面直达传入的 storeId
    if (options && options.scene && !options.storeId) {
      try {
        const sceneStr = decodeURIComponent(options.scene)
        if (sceneStr) {
          const pairs = sceneStr.split('&')
          for (const p of pairs) {
            const [k, v] = p.split('=')
            if (k === 'storeId' && v) {
              options.storeId = v
              break
            }
          }
        }
      } catch (e) {
        console.warn('解析 scene 失败:', e)
      }
    }
    this.setData({
      options: options
    })
    let {
      time,
      dramaId,
      roomId,
      orderId,
      shopId,
      invite,
      activityId,
      company,
      inviteHost,
      storeId
    } = options
    time && wx.setStorageSync("time", time);
    dramaId && wx.setStorageSync("dramaId", dramaId);
    roomId && wx.setStorageSync("roomId", roomId);
    orderId && wx.setStorageSync("orderId", orderId);
    shopId && wx.setStorageSync("shopId", shopId);
    invite && wx.setStorageSync("invite", invite);
    activityId && wx.setStorageSync("activityId", activityId);
    inviteHost && wx.setStorageSync("inviteHost", true);
    if (storeId) {
      // 扫码进入时，强制设置店铺 ID，标记为扫码来源
      wx.setStorageSync('storeId', storeId)
      getApp().globalData.storeId = storeId
      wx.setStorageSync('storeId_from_scan', true)
      console.log('✅ 入口页扫码进入，已设置店铺 ID（优先级最高）:', storeId)
    }
    if (company) getApp().globalData.toCompany = true;
    
    // 检查是否是扫码进入（需要统计扫码次数）
    this.checkAndHandleScan(options);
    
    plugin.init(config, wx.getStorageSync('invite'))
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady: async function () { },


  /**
   * 生命周期函数--监听页面显示
   */
  onShow: async function () {
    await this.review()
  },

  async review(force){
    try {
      let options = this.data.options
      let url = getApp().globalData.rootPage || getApp().globalData.defaultTabBar.list[0].pagePath
      if (options) {
        let objArr = Object.keys(options)
        if (objArr && objArr.length > 0) {
          let parms = '?'
          objArr.forEach((o, index) => {
            if (index > 0) {
              parms += '&' + o + '=' + options[o]
            } else {
              parms += o + '=' + options[o]
            }
          })
          url += parms
        }
      }

      let currentUser = Parse.User.current()
      console.log('===========================================');
      console.log('======= index.js review 方法 =======');
      console.log('当前用户:', currentUser ? currentUser.id : '无');
      console.log('用户手机号:', currentUser?.get('mobile') || '无');
      console.log('用户名:', currentUser?.get('username') || '无');
      console.log('Session Token:', currentUser?.getSessionToken()?.substring(0, 20) || '无');
      console.log('userLogin 存储:', wx.getStorageSync('userLogin') || '无');
      console.log('force 参数:', force);
      console.log('===========================================');
      
      // 查询 Company 的 isPublishing 字段
      let isPublishing = false;
      try {
        const companyQuery = new Parse.Query('Company');
        companyQuery.equalTo('objectId', getApp().globalData.company);
        companyQuery.select('isPublishing');
        
        try {
          const companyObj = await companyQuery.first();
          
          if (companyObj) {
            isPublishing = companyObj.get('isPublishing') === true;
            console.log('📋 Company isPublishing:', isPublishing);
          } else {
            console.log('⚠️ 未找到 Company 记录，默认 isPublishing = false');
            isPublishing = false;
          }
        } catch (queryError) {
          console.error('❌ 查询 Company 失败（可能 token 无效）:', queryError.message);
          // 查询失败时，默认为 false（强制登录）
          isPublishing = false;
        }
        
        // 保存到全局，供其他页面使用
        getApp().globalData.isPublishing = isPublishing;
        wx.setStorageSync('isPublishing', isPublishing);
      } catch (error) {
        console.error('❌ 查询 Company isPublishing 失败:', error);
        // 查询失败时，默认为 false（强制登录）
        isPublishing = false;
      }
      
      // 根据 isPublishing 决定是否强制登录
      if (!currentUser || force) {
        console.log('🔄 开始调用 checkAuth...');
        
        // isPublishing == true 时不强制授权，否则强制授权
        const forceAuth = !isPublishing;
        console.log('🔐 是否强制登录:', forceAuth);
        
        let r = await checkAuth(forceAuth);
        
        console.log('===========================================');
        console.log('======= checkAuth 返回结果 =======');
        console.log('返回值:', r);
        
        // 重新获取用户信息
        currentUser = Parse.User.current();
        console.log('checkAuth 后的用户:', currentUser ? currentUser.id : '无');
        console.log('checkAuth 后的手机号:', currentUser?.get('mobile') || '无');
        console.log('checkAuth 后的 Session Token:', currentUser?.getSessionToken()?.substring(0, 20) || '无');
        console.log('===========================================');
        
        // 如果强制登录但用户未登录，不允许继续访问
        if (forceAuth && !r) {
          console.log('❌ 强制登录模式，用户未登录，停止访问');
          return;
        }
        
        // 即使登录失败，也允许继续访问（仅在非强制登录模式下）
        if(!r) {
          console.log('⚠️ 用户未登录或拒绝授权，允许游客访问');
          // 不要 return，继续执行后面的跳转逻辑
        } else {
          // 登录成功，设置 userLogin
          if (currentUser && currentUser.get('mobile')) {
            wx.setStorageSync("userLogin", currentUser.id);
            console.log('✅ 授权登录成功，已设置 userLogin:', currentUser.id);
            console.log('✅ 用户手机号:', currentUser.get('mobile'));
          } else {
            console.warn('⚠️ checkAuth 返回成功，但用户没有手机号！');
            console.warn('   用户对象:', currentUser);
          }
          
          // 检查是否有待记录的扫码信息
          await this.checkAndRecordPendingScan();
        }
      } else {
        console.log('✅ 用户已登录，跳过 checkAuth');
        
        // 用户已登录，确保 userLogin 已设置
        if (currentUser.get('mobile')) {
          wx.setStorageSync("userLogin", currentUser.id);
          console.log('✅ 已确认 userLogin:', currentUser.id);
        }
        this.updateUser(currentUser.id);
        // 用户已登录，检查是否有待记录的扫码信息
        await this.checkAndRecordPendingScan();
      }
      getApp().Parse = Parse
      getApp().checkAuth = checkAuth
      if (!await this.getCompanyServerExpire(url)) {
        return
      }
      
      // 检查是否需要跳转到活动页面
      if (wx.getStorageSync('need_activity_redirect') === true) {
        await this.redirectToActivityPage();
        return;
      }
      
      // 检查是否需要跳转到扫码统计页面
      if (this.shouldRedirectToScanPage()) {
        await this.redirectToScanPage();
        return;
      }
      
      console.log('✅ 准备跳转到:', url);
      
      wx.redirectTo({
        url: url,
        success: () => {
          console.log('✅ redirectTo 跳转成功');
        },
        fail: (err) => {
          console.error('❌ redirectTo 失败:', err);
          console.log('⚠️ 尝试使用 reLaunch');
          
          // 降级：尝试使用 reLaunch
          wx.reLaunch({
            url: url,
            success: () => {
              console.log('✅ reLaunch 跳转成功');
            },
            fail: (err2) => {
              console.error('❌ reLaunch 也失败:', err2);
              // 显示错误提示
              this.setData({ loading: false });
              wx.showModal({
                title: '温馨提示',
                content: '页面加载失败，请检查网络后重试。',
                showCancel: true,
                cancelText: '退出',
                confirmText: '重试',
                success: (result) => {
                  if (result.confirm) {
                    this.review(true);
                  } else {
                    wx.exitMiniProgram();
                  }
                }
              });
            }
          });
        }
      });
    }
    catch (err) {
      console.log('❌ review 方法出错:', err);
      
      /* 登录身份信息到期，重新登陆 */
      if((err?.message?.indexOf('Session token is expired') != -1 || err?.message?.indexOf('Invalid session token') != -1) && !force){
        console.log('⚠️ Session Token 过期，准备重新登录');
        
        // 保存需要保留的数据
        const invite = wx.getStorageSync('invite');
        const agreementAccepted = wx.getStorageSync('user_agreement_accepted');
        const storeId = wx.getStorageSync('storeId');
        const isPublishing = wx.getStorageSync('isPublishing');
        
        // 先登出 Parse 用户
        try {
          await Parse.User.logOut();
          console.log('✅ Parse 用户已登出');
        } catch (logoutErr) {
          console.warn('⚠️ Parse 登出失败:', logoutErr);
        }
        
        // 清除所有存储
        wx.clearStorageSync();
        
        // 恢复需要保留的数据
        if (invite) wx.setStorageSync('invite', invite);
        if (agreementAccepted) wx.setStorageSync('user_agreement_accepted', agreementAccepted);
        if (storeId) wx.setStorageSync('storeId', storeId);
        if (isPublishing !== undefined) wx.setStorageSync('isPublishing', isPublishing);
        
        console.log('✅ 已清除过期登录信息，保留必要数据');
        console.log('   保留的 invite:', invite || '无');
        console.log('   保留的协议状态:', agreementAccepted || '无');
        console.log('   保留的店铺ID:', storeId || '无');
        
        /* 强制重新登录 */
        this.review(true);
        return;
      }
      
      // 如果出错，尝试继续跳转到主页（游客模式）
      console.log('⚠️ 登录出错，尝试游客模式访问');
      
      let url = getApp().globalData.rootPage || getApp().globalData.defaultTabBar.list[0].pagePath;
      if (this.data.options) {
        let objArr = Object.keys(this.data.options)
        if (objArr && objArr.length > 0) {
          let parms = '?'
          objArr.forEach((o, index) => {
            if (index > 0) {
              parms += '&' + o + '=' + this.data.options[o]
            } else {
              parms += o + '=' + this.data.options[o]
            }
          })
          url += parms
        }
      }
      
      wx.redirectTo({
        url: url,
        fail: () => {
          // 如果跳转失败，显示错误提示
          this.setData({
            loading:false
          })
          wx.showModal({
            title: '温馨提示',
            content: '页面加载失败，请检查网络后重试。',
            showCancel: true,
            cancelText: '退出',
            confirmText: '重试',
            success: (result) => {
              if (result.confirm) {
                // 用户选择重试
                this.review(true)
              } else {
                // 用户选择退出
                wx.exitMiniProgram()
              }
            },
          });
        }
      });
    }
  },
  
  /**
   * 检查并记录待处理的扫码统计
   */
  async checkAndRecordPendingScan() {
    try {
      const pendingScan = wx.getStorageSync('pending_scan_record');
      
      if (!pendingScan) {
        return;
      }
      
      console.log('===========================================');
      console.log('======= 发现待记录的扫码信息 =======');
      console.log('扫码信息:', pendingScan);
      console.log('===========================================');
      
      // 检查是否超时（24小时）
      const now = Date.now();
      const scanTime = pendingScan.timestamp || 0;
      const hoursPassed = (now - scanTime) / (1000 * 60 * 60);
      
      if (hoursPassed > 24) {
        console.log('⚠️ 扫码信息已超过24小时，不再记录');
        wx.removeStorageSync('pending_scan_record');
        return;
      }
      
      // 记录扫码统计
      await this.recordScanStatistics({
        storeId: pendingScan.storeId,
        sourceType: pendingScan.sourceType,
        sourceId: pendingScan.sourceId,
        ownerId: pendingScan.ownerId,
        employeeId: pendingScan.employeeId,
        partnerId: pendingScan.partnerId,
        userId: pendingScan.userId,
        productId: pendingScan.productId,
        scanCount: pendingScan.scanCount
      });
      
      // 清除待记录的扫码信息
      wx.removeStorageSync('pending_scan_record');
      console.log('✅ 扫码统计已记录并清除');
      
    } catch (error) {
      console.error('❌ 记录待处理扫码信息失败:', error);
    }
  },

  async updateUser(id) {
    try {
      let User = new Parse.Query('_User')
      let user = await User.get(id)
      let invite = wx.getStorageSync('invite')
      //查询邀请人user
      let query = new Parse.Query("_User")
      query.equalTo('objectId', invite)
      let result = await query.first()
      if (result && result.id && result.get("invite")?.id == user.id) {
        console.error('邀请人不能是自己的下级')
        return
      }
      if (invite && !user.get('invite') && user.id != invite && !user.get('agentLevel')) {
        console.log('上下级绑定成功');
        user.set('invite', {
          __type: "Pointer",
          className: "_User",
          objectId: invite
        })
        user.set('agent', {
          __type: "Pointer",
          className: "_User",
          objectId: invite
        })
        await Parse.Cloud.run('user_save', {
          userJson: user.toJSON()
        })
      }
    } catch (error) {
      console.error('❌ updateUser 失败:', error.message);
      // 不阻断流程，继续执行
    }
  },
  async getCompanyServerExpire(url) {
    try {
      let query = new Parse.Query('Company')
      query.equalTo('objectId', getApp().globalData.company)
      query.select('expireDate', 'expireMap')
      let com = await query.first()
      if (com?.id && com?.get('expireDate')) {
        let now = + new Date()
        let expireTime = + new Date(com?.get('expireDate'))
        if (com?.get('expireMap') && com.get('expireMap')[getApp().globalData.appid]) {
          expireTime = + new Date(com.get('expireMap')[getApp().globalData.appid])
        }
        if (now >= expireTime) {
          console.log('服务器到期');
          wx.reLaunch({
            url: `common-page/pages/loading/index?url=${url}`,
          });
          return
        }
      }
      return true
    } catch (error) {
      console.error('❌ getCompanyServerExpire 失败:', error.message);
      // 查询失败时，允许继续访问
      return true
    }
  },

  onUnload: function () {
    wx.setStorageSync("active", 0);
  },
  getParaName(url) {
    if (!url || url.indexOf('?') == -1) {
      return
    }

    // 兼容 URL 中 & 的情况，先统一还原为 &
    if (url.indexOf('&') !== -1) {
      url = url.replace(/&/g, '&');
    }

    // 提取查询参数部分（去除可能的 hash 部分）
    let queryString = url.split('?')[1];
    // 如果包含 #，只取 # 之前的部分
    if (queryString.indexOf('#') !== -1) {
      queryString = queryString.split('#')[0];
    }
    return this.setObject(queryString) //封装成对象
  },
  setObject(paraArr) {
    let obj = {}
    let arr1 = paraArr.split('&')
    arr1.forEach(item => {
      let str = item.split('=')
      let key = str[0]
      let val = str[1]
      obj[key] = val
    })
    return obj
  },

  /**
   * 检查并处理扫码参数
   * 支持所有类型的二维码：
   * 1. 推广员二维码: ?scanCount=0&storeId=xxx&userId=xxx
   * 2. 产品二维码: ?scanCount=0&storeId=xxx&productId=xxx
   * 3. 案例二维码: ?scanCount=0&storeId=xxx&caseId=xxx
   * 4. 活动海报二维码: activityId作为qrCode参数值
   * 5. 异业合作伙伴二维码（移动端 / PC端统一）: ?scanCount=xxx&storeId=xxx&partnerId=xxx
   * 6. 员工邀请二维码（移动端）: ?scanCount=0&storeId=xxx&employeeId=xxx
   * 7. 我的二维码（老板）: ?scanCount=0&storeId=xxx&ownerId=xxx
   * 8. 我的二维码（员工）: ?scanCount=0&storeId=xxx&employeeId=xxx
   */
  checkAndHandleScan(options) {
    const { 
      scanCount, 
      ownerId, 
      employeeId, 
      partnerId,
      storeId,
      productId,
      caseId,
      userId,  // 推广员二维码使用userId
      activityId
    } = options;
    
    // 处理活动海报二维码（activityId作为qrCode参数值）
    if (activityId && !storeId) {
      console.log('===========================================');
      console.log('======= 检测到活动海报二维码 =======');
      console.log('活动ID (activityId):', activityId);
      console.log('===========================================');
      
      // 活动二维码需要跳转到活动页面，不需要跳转到店铺
      wx.setStorageSync('scan_activityId', activityId);
      wx.setStorageSync('need_activity_redirect', true);
      return;
    }
    
    // 如果存在 storeId，说明是扫码进入具体门店（包括异业分享）
    if (storeId) {
      console.log('===========================================');
      console.log('======= 检测到扫码参数 =======');
      console.log('店铺ID (storeId):', storeId);
      console.log('扫码次数 (scanCount):', scanCount || '0');
      
      // 确定来源类型
      let sourceType = 'unknown';
      let sourceId = null;
      
      if (employeeId) {
        sourceType = 'employee';
        sourceId = employeeId;
        console.log('来源类型: 员工展业');
        console.log('员工ID (employeeId):', employeeId);
      } else if (userId) {
        // 推广员二维码使用userId
        sourceType = 'promoter';
        sourceId = userId;
        console.log('来源类型: 推广员展业');
        console.log('推广员ID (userId):', userId);
      } else if (ownerId) {
        sourceType = 'owner';
        sourceId = ownerId;
        console.log('来源类型: 老板展业');
        console.log('老板ID (ownerId):', ownerId);
      } else if (partnerId) {
        sourceType = 'partner';
        sourceId = partnerId;
        console.log('来源类型: 异业合作伙伴');
        console.log('合作伙伴ID (partnerId):', partnerId);
      } else {
        sourceType = 'store';
        console.log('来源类型: 店铺分享');
      }
      
      if (productId) {
        console.log('产品ID (productId):', productId);
      }
      
      if (caseId) {
        console.log('案例ID (caseId):', caseId);
      }
      
      console.log('===========================================');
      
      // 保存到临时存储，用于后续跳转和统计
      wx.setStorageSync('scan_storeId', storeId);
      wx.setStorageSync('scan_scanCount', scanCount || '0');
      wx.setStorageSync('scan_sourceType', sourceType);
      wx.setStorageSync('scan_sourceId', sourceId || '');
      wx.setStorageSync('scan_ownerId', ownerId || '');
      wx.setStorageSync('scan_employeeId', employeeId || '');
      wx.setStorageSync('scan_partnerId', partnerId || '');
      wx.setStorageSync('scan_userId', userId || '');
      if (productId) {
        wx.setStorageSync('scan_productId', productId);
      }
      if (caseId) {
        wx.setStorageSync('scan_caseId', caseId);
      }
      wx.setStorageSync('need_scan_redirect', true);
    } else if (partnerId) {
      // 理论上异业二维码现在也必须带 storeId，这里仅作为兜底保护
      console.warn('⚠️ 检测到异业合作伙伴二维码缺少 storeId，无法确定门店，请检查二维码生成逻辑');
    }
  },

  /**
   * 判断是否需要跳转到扫码统计页面
   */
  shouldRedirectToScanPage() {
    return wx.getStorageSync('need_scan_redirect') === true;
  },

  /**
   * 跳转到扫码对应的店铺页面
   * 根据 storeId 跳转到对应店铺，同时记录所有来源信息用于统计
   */
  async redirectToScanPage() {
    try {
      // 获取所有扫码相关参数
      const storeId = wx.getStorageSync('scan_storeId');
      const scanCount = wx.getStorageSync('scan_scanCount');
      const sourceType = wx.getStorageSync('scan_sourceType');
      const sourceId = wx.getStorageSync('scan_sourceId');
      const ownerId = wx.getStorageSync('scan_ownerId');
      const employeeId = wx.getStorageSync('scan_employeeId');
      const partnerId = wx.getStorageSync('scan_partnerId');
      const userId = wx.getStorageSync('scan_userId');
      const productId = wx.getStorageSync('scan_productId');
      const caseId = wx.getStorageSync('scan_caseId');
      
      // 清除临时存储
      wx.removeStorageSync('scan_storeId');
      wx.removeStorageSync('scan_scanCount');
      wx.removeStorageSync('scan_sourceType');
      wx.removeStorageSync('scan_sourceId');
      wx.removeStorageSync('scan_ownerId');
      wx.removeStorageSync('scan_employeeId');
      wx.removeStorageSync('scan_partnerId');
      wx.removeStorageSync('scan_userId');
      wx.removeStorageSync('scan_productId');
      wx.removeStorageSync('scan_caseId');
      wx.removeStorageSync('need_scan_redirect');
      
      if (!storeId) {
        console.error('❌ 缺少 storeId 参数，无法跳转');
        return;
      }
      
      console.log('===========================================');
      console.log('======= 扫码进入店铺 =======');
      console.log('店铺 ID (storeId):', storeId);
      console.log('来源类型 (sourceType):', sourceType);
      console.log('来源 ID (sourceId):', sourceId || '无');
      console.log('扫码次数 (scanCount):', scanCount);
      if (ownerId) console.log('老板 ID (ownerId):', ownerId);
      if (employeeId) console.log('员工 ID (employeeId):', employeeId);
      if (partnerId) console.log('合作伙伴 ID (partnerId):', partnerId);
      if (userId) console.log('推广员 ID (userId):', userId);
      if (productId) console.log('产品 ID (productId):', productId);
      if (caseId) console.log('案例 ID (caseId):', caseId);
      console.log('===========================================');
      
      // 设置店铺 ID 到全局和本地存储
      wx.setStorageSync('storeId', storeId);
      getApp().globalData.storeId = storeId;
      
      // 保存来源信息到本地存储（用于后续统计或绑定关系）
      if (sourceId) {
        wx.setStorageSync('scan_from_sourceType', sourceType);
        wx.setStorageSync('scan_from_sourceId', sourceId);
        console.log('✅ 已记录来源信息:', sourceType, sourceId);
      }
      
      // 检查用户是否已登录
      const currentUser = Parse.User.current();
      
      if (currentUser) {
        // 用户已登录，立即记录扫码统计
        console.log('✅ 用户已登录，记录扫码统计');
        await this.recordScanStatistics({
          storeId,
          sourceType,
          sourceId,
          ownerId,
          employeeId,
          partnerId,
          userId,
          productId,
          scanCount
        });
      } else {
        // 用户未登录，保存扫码信息，等登录后再记录
        console.log('⚠️ 用户未登录，保存扫码信息待登录后记录');
        wx.setStorageSync('pending_scan_record', {
          storeId,
          sourceType,
          sourceId,
          ownerId,
          employeeId,
          partnerId,
          userId,
          productId,
          scanCount,
          timestamp: Date.now()
        });
      }
      
      // 如果有产品ID，直接跳转到产品详情的 H5 页面
      if (productId) {
        console.log('🎯 检测到产品ID，跳转到产品详情页');
        await this.redirectToProductDetail(storeId, productId, partnerId);
        return;
      }
      
      // 如果有案例ID，直接跳转到案例详情的 H5 页面
      if (caseId) {
        console.log('🎯 检测到案例ID，跳转到案例详情页');
        await this.redirectToCaseDetail(storeId, caseId, partnerId);
        return;
      }
      
      // 获取默认首页路径并跳转
      let url = getApp().globalData.rootPage || getApp().globalData.defaultTabBar.list[0].pagePath;
      url += `?storeId=${storeId}`;
      
      // 如果有产品ID，添加到URL参数中
      if (productId) {
        url += `&productId=${productId}`;
      }
      
      // 如果有异业合作伙伴ID，添加到URL参数中传回web-view
      if (partnerId) {
        url += `&partnerId=${partnerId}`;
      }
      
      console.log('✅ 跳转到店铺页面:', url);
      
      wx.redirectTo({
        url: url,
        fail: (err) => {
          console.error('❌ 跳转失败:', err);
          // 如果 redirectTo 失败，尝试 reLaunch
          wx.reLaunch({
            url: url,
            fail: (err2) => {
              console.error('❌ reLaunch 也失败:', err2);
            }
          });
        }
      });
    } catch (error) {
      console.error('❌ 跳转到店铺页面失败:', error);
    }
  },
  
  /**
   * 跳转到活动页面
   */
  async redirectToActivityPage() {
    try {
      const activityId = wx.getStorageSync('scan_activityId');
      
      // 清除临时存储
      wx.removeStorageSync('scan_activityId');
      wx.removeStorageSync('need_activity_redirect');
      
      if (!activityId) {
        console.error('❌ 缺少 activityId 参数，无法跳转');
        return;
      }
      
      console.log('===========================================');
      console.log('======= 扫码进入活动页面 =======');
      console.log('活动 ID (activityId):', activityId);
      console.log('===========================================');
      
      // 保存活动ID
      wx.setStorageSync('activityId', activityId);
      
      // 获取默认首页路径并跳转（活动页面可能需要根据实际路由调整）
      let url = getApp().globalData.rootPage || getApp().globalData.defaultTabBar.list[0].pagePath;
      url += `?activityId=${activityId}`;
      
      console.log('✅ 跳转到活动页面:', url);
      
      wx.redirectTo({
        url: url,
        fail: (err) => {
          console.error('❌ 跳转失败:', err);
          wx.reLaunch({
            url: url,
            fail: (err2) => {
              console.error('❌ reLaunch 也失败:', err2);
            }
          });
        }
      });
    } catch (error) {
      console.error('❌ 跳转到活动页面失败:', error);
    }
  },
  
  /**
   * 跳转到产品详情的 H5 页面
   * @param {string} storeId - 店铺 ID
   * @param {string} productId - 产品 ID
   * @param {string} partnerId - 可选的合作伙伴 ID
   */
  async redirectToProductDetail(storeId, productId, partnerId = null) {
    try {
      console.log('===========================================');
      console.log('======= 跳转到产品详情页 =======');
      console.log('店铺 ID:', storeId);
      console.log('产品 ID:', productId);
      if (partnerId) console.log('合作伙伴 ID:', partnerId);
      console.log('===========================================');
      
      const currentUser = Parse.User.current();
      const token = currentUser ? currentUser.getSessionToken() : null;
      
      // 构建产品详情的 H5 URL（不要在这里编码，后面统一编码）
      let h5Url = `https://app.fmode.cn/dev/pobingfeng/owner/nav/products?storeId=${storeId}`;
      
      // 如果有 token，添加到 URL
      if (token) {
        h5Url += `&token=${token}`;
      } else {
        // 如果没有 token，使用游客模式
        h5Url += `&guestMode=true`;
      }
      
      // 添加产品ID（不要在这里编码，避免双重编码）
      h5Url += `&productId=${productId}`;
      
      // 如果有合作伙伴ID，也添加到URL中
      if (partnerId) {
        h5Url += `&partnerId=${partnerId}`;
      }
      
      console.log('🌐 H5 URL:', h5Url);
      
      // 编码 URL（统一在这里编码一次）
      const encodedUrl = encodeURIComponent(h5Url);
      
      // 构建 web-view 页面路径
      let webViewPath = `/common-page/pages/web-view/index?path=${encodedUrl}&storeId=${storeId}`;
      
      console.log('📄 web-view 页面路径:', webViewPath.substring(0, 100) + '...');
      console.log('===========================================');
      
      wx.redirectTo({
        url: webViewPath,
        success: () => {
          console.log('✅ 跳转到产品详情页成功');
        },
        fail: (err) => {
          console.error('❌ 跳转失败:', err);
          // 如果 redirectTo 失败，尝试 reLaunch
          wx.reLaunch({
            url: webViewPath,
            fail: (err2) => {
              console.error('❌ reLaunch 也失败:', err2);
            }
          });
        }
      });
    } catch (error) {
      console.error('❌ 跳转到产品详情页失败:', error);
    }
  },
  
  /**
   * 跳转到案例详情的 H5 页面
   * @param {string} storeId - 店铺 ID
   * @param {string} caseId - 案例 ID
   * @param {string} partnerId - 可选的合作伙伴 ID
   */
  async redirectToCaseDetail(storeId, caseId, partnerId = null) {
    try {
      console.log('===========================================');
      console.log('======= 跳转到案例详情页 =======');
      console.log('店铺 ID:', storeId);
      console.log('案例 ID:', caseId);
      if (partnerId) console.log('合作伙伴 ID:', partnerId);
      console.log('===========================================');
      
      const currentUser = Parse.User.current();
      const token = currentUser ? currentUser.getSessionToken() : null;
      
      // 构建案例详情的 H5 URL（不要在这里编码，后面统一编码）
      let h5Url = `https://app.fmode.cn/dev/pobingfeng/owner/nav/cases?storeId=${storeId}`;
      
      // 如果有 token，添加到 URL
      if (token) {
        h5Url += `&token=${token}`;
      } else {
        // 如果没有 token，使用游客模式
        h5Url += `&guestMode=true`;
      }
      
      // 添加案例ID（不要在这里编码，避免双重编码）
      h5Url += `&caseId=${caseId}`;
      
      // 如果有合作伙伴ID，也添加到URL中
      if (partnerId) {
        h5Url += `&partnerId=${partnerId}`;
      }
      
      console.log('🌐 H5 URL:', h5Url);
      
      // 编码 URL（统一在这里编码一次）
      const encodedUrl = encodeURIComponent(h5Url);
      
      // 构建 web-view 页面路径
      let webViewPath = `/common-page/pages/web-view/index?path=${encodedUrl}&storeId=${storeId}`;
      
      console.log('📄 web-view 页面路径:', webViewPath.substring(0, 100) + '...');
      console.log('===========================================');
      
      wx.redirectTo({
        url: webViewPath,
        success: () => {
          console.log('✅ 跳转到案例详情页成功');
        },
        fail: (err) => {
          console.error('❌ 跳转失败:', err);
          // 如果 redirectTo 失败，尝试 reLaunch
          wx.reLaunch({
            url: webViewPath,
            fail: (err2) => {
              console.error('❌ reLaunch 也失败:', err2);
            }
          });
        }
      });
    } catch (error) {
      console.error('❌ 跳转到案例详情页失败:', error);
    }
  },
  
  /**
   * 记录扫码统计信息
   * @param {Object} params - 扫码参数对象
   * @param {string} params.storeId - 店铺 ID
   * @param {string} params.sourceType - 来源类型 (employee/owner/partner/promoter/store)
   * @param {string} params.sourceId - 来源 ID
   * @param {string} params.ownerId - 老板 ID
   * @param {string} params.employeeId - 员工 ID
   * @param {string} params.partnerId - 合作伙伴 ID
   * @param {string} params.userId - 推广员 ID
   * @param {string} params.productId - 产品 ID
   * @param {string} params.scanCount - 扫码次数
   */
  async recordScanStatistics(params) {
    try {
      const {
        storeId,
        sourceType,
        sourceId,
        ownerId,
        employeeId,
        partnerId,
        userId,
        productId,
        scanCount
      } = params;
      
      // 检查用户是否已登录
      const currentUser = Parse.User.current();
      if (!currentUser) {
        console.log('⚠️ 用户未登录，不记录扫码统计');
        return;
      }
      
      // 如果没有来源信息，不记录统计
      if (!sourceId && !ownerId && !employeeId && !partnerId && !userId) {
        console.log('ℹ️ 无来源信息，跳过统计记录');
        return;
      }
      
      console.log('✅ 用户已登录，记录扫码统计');
      
      // 创建扫码记录
      const ScanRecord = Parse.Object.extend('ScanRecord');
      const record = new ScanRecord();
      
      record.set('company', {
        __type: 'Pointer',
        className: 'Company',
        objectId: getApp().globalData.company
      });
      record.set('storeId', storeId);
      record.set('sourceType', sourceType || 'unknown');
      record.set('scanCount', parseInt(scanCount) || 0);
      record.set('scanTime', new Date());
      
      // 根据来源类型设置对应的ID
      if (ownerId) {
        record.set('ownerId', ownerId);
      }
      if (employeeId) {
        record.set('employeeId', employeeId);
      }
      if (partnerId) {
        record.set('partnerId', partnerId);
      }
      if (userId) {
        record.set('userId', userId);
      }
      if (productId) {
        record.set('productId', productId);
      }
      
      // 记录扫码用户
      record.set('user', {
        __type: 'Pointer',
        className: '_User',
        objectId: currentUser.id
      });
      
      await record.save();
      console.log('✅ 扫码记录已保存');

      // 如果存在异业合作伙伴ID，处理异业绑定和扫码次数
      if (partnerId) {
        try {
          console.log('===========================================');
          console.log('======= 处理异业扫码逻辑 =======');
          console.log('用户ID:', currentUser.id);
          console.log('异业ID:', partnerId);
          console.log('门店ID:', storeId);
          
          // 检查用户是否已经绑定了异业合作伙伴
          const userBoundPartner = currentUser.get('Partner');
          const userBoundPartnerId = userBoundPartner ? userBoundPartner.id : null;
          
          console.log('用户已绑定的异业ID:', userBoundPartnerId || '无');
          
          // 规则1：如果用户已绑定其他异业，不处理当前异业的扫码
          if (userBoundPartnerId && userBoundPartnerId !== partnerId) {
            console.log('⚠️ 用户已绑定其他异业，不处理当前异业的扫码');
            console.log('   已绑定异业:', userBoundPartnerId);
            console.log('   当前扫码异业:', partnerId);
            console.log('===========================================');
            return;
          }
          
          // 规则2：检查该用户在该门店是否已经扫过该异业的码
          const ScanRecord = Parse.Object.extend('ScanRecord');
          const scanQuery = new Parse.Query(ScanRecord);
          scanQuery.equalTo('user', {
            __type: 'Pointer',
            className: '_User',
            objectId: currentUser.id
          });
          scanQuery.equalTo('partnerId', partnerId);
          scanQuery.equalTo('storeId', storeId);
          
          const existingScan = await scanQuery.first();
          
          if (existingScan) {
            console.log('⚠️ 该用户在该门店已扫过该异业的码，不重复计数');
            console.log('   首次扫码时间:', existingScan.get('scanTime'));
            console.log('===========================================');
            return;
          }
          
          console.log('✅ 该用户在该门店首次扫该异业码');
          
          // 规则3：如果用户还没有绑定异业，绑定当前异业
          if (!userBoundPartnerId) {
            console.log('🔗 用户首次扫异业码，绑定异业合作伙伴:', partnerId);
            
            currentUser.set('Partner', {
              __type: 'Pointer',
              className: 'Partner',
              objectId: partnerId
            });
            await currentUser.save();
            console.log('✅ 异业绑定成功');
          }
          
          // 规则4：为该异业在该门店增加扫码次数
          const Partner = Parse.Object.extend('Partner');
          const partnerQuery = new Parse.Query(Partner);
          const partnerObj = await partnerQuery.get(partnerId);

          if (partnerObj) {
            // 获取或初始化门店扫码次数映射
            let storeScans = partnerObj.get('storeScans') || {};
            
            // 为该门店的扫码次数 +1
            storeScans[storeId] = (storeScans[storeId] || 0) + 1;
            
            partnerObj.set('storeScans', storeScans);
            
            // 同时更新总扫码次数
            partnerObj.increment('scanCount', 1);
            
            await partnerObj.save();
            
            console.log('✅ 异业扫码次数已更新');
            console.log('   门店ID:', storeId);
            console.log('   该门店扫码次数:', storeScans[storeId]);
            console.log('   总扫码次数:', partnerObj.get('scanCount'));
          }
          
          console.log('===========================================');
        } catch (e) {
          console.error('❌ 处理异业合作伙伴绑定失败:', e);
          console.log('===========================================');
        }
      }
    } catch (error) {
      console.warn('⚠️ 保存扫码记录失败:', error);
      // 不影响主流程
    }
  }
});