:update login

app.js

@@ -6,6 +6,50 @@ const plugin = requirePlugin('fm-plugin')
 const { Parse } = plugin
 App({
   onLaunch() {
+    // 全局拦截插件的"登录信息已过期"提示
+    const originalShowModal = wx.showModal;
+    wx.showModal = function(options) {
+      // 如果是"登录信息已过期"的提示，改为友好的重新登录提示
+      if (options.content && (options.content.includes('登录信息过期') || 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: () => {
+                  console.log('✅ 重新加载首页成功');
+                },
+                fail: (err) => {
+                  console.error('❌ 重新加载失败:', err);
+                }
+              });
+            }
+            
+            // 调用原始的 success 回调
+            if (options.success) {
+              options.success(result);
+            }
+          }
+        });
+      }
+      
+      // 其他提示正常显示
+      return originalShowModal.call(this, options);
+    };
+    
     // 展示本地存储能力
     const logs = wx.getStorageSync('logs') || []
     logs.unshift(Date.now())

components/app-auth/index.js

@@ -567,9 +567,12 @@ Page({
       });
     } else {
       console.error('❌ 未获取到头像URL');
+      
+      // 在开发环境下，如果获取失败，提示用户可以跳过
       wx.showToast({
-        title: '获取头像失败，请重试',
-        icon: 'none'
+        title: '开发工具不支持，请真机测试或跳过',
+        icon: 'none',
+        duration: 2000
       });
     }
   },

index.js

@@ -23,6 +23,44 @@ Page({
    * 生命周期函数--监听页面加载
    */
   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) {
@@ -200,11 +238,21 @@ Page({
         const companyQuery = new Parse.Query('Company');
         companyQuery.equalTo('objectId', getApp().globalData.company);
         companyQuery.select('isPublishing');
-        const companyObj = await companyQuery.first();
         
-        if (companyObj) {
-          isPublishing = companyObj.get('isPublishing') === true;
-          console.log('📋 Company isPublishing:', 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;
         }
         
         // 保存到全局，供其他页面使用
@@ -468,54 +516,65 @@ Page({
   },
 
   async updateUser(id) {
-    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()
-      })
+    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) {
-    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
+    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
     }
-    return true
   },
 
   onUnload: function () {

nova-pbf/components/home/index.js

@@ -113,53 +113,6 @@ Component({
       }
     },
 
-    /**
-     * 检查 Company 的 isPublishing 状态
-     * 只有 isPublishing == true 时才显示 AI 相关内容
-     */
-    async checkPublishingStatus() {
-      try {
-        // 先尝试从全局或缓存读取
-        let isPublishing = getApp().globalData.isPublishing;
-        
-        if (isPublishing === undefined) {
-          isPublishing = wx.getStorageSync('isPublishing');
-        }
-        
-        // 如果缓存中没有，查询数据库
-        if (isPublishing === undefined || isPublishing === '') {
-          const companyQuery = new Parse.Query('Company');
-          companyQuery.equalTo('objectId', getApp().globalData.company);
-          companyQuery.select('isPublishing');
-          const companyObj = await companyQuery.first();
-          
-          if (companyObj) {
-            isPublishing = companyObj.get('isPublishing') === true;
-          } else {
-            isPublishing = false;
-          }
-          
-          // 保存到全局和缓存
-          getApp().globalData.isPublishing = isPublishing;
-          wx.setStorageSync('isPublishing', isPublishing);
-        }
-        
-        console.log('📋 isPublishing 状态:', isPublishing);
-        console.log('🤖 是否显示 AI:', isPublishing);
-        
-        // 更新组件数据
-        this.setData({
-          showAI: isPublishing === true
-        });
-      } catch (error) {
-        console.error('❌ 检查 isPublishing 状态失败:', error);
-        // 出错时默认不显示 AI
-        this.setData({
-          showAI: false
-        });
-      }
-    },
-
     /**
      * 在控制台显示当前登录用户信息
      */
@@ -203,6 +156,58 @@ Component({
       }
     },
 
+    /**
+     * 检查登录状态（强制登录模式）
+     * 当 isPublishing != true 时，必须登录才能访问
+     * @returns {Promise<boolean>} 是否已登录或允许访问
+     */
+    async checkLoginRequired() {
+      // 获取 isPublishing 状态
+      const isPublishing = wx.getStorageSync('isPublishing');
+      
+      console.log('🔐 检查登录要求...');
+      console.log('   isPublishing:', isPublishing);
+      
+      // 如果 isPublishing == true，不需要强制登录，允许游客访问
+      if (isPublishing === true) {
+        console.log('✅ isPublishing == true，允许游客访问');
+        return true;
+      }
+      
+      console.log('⚠️ isPublishing != true，需要强制登录');
+      
+      // 检查用户是否已登录
+      const currentUser = Parse.User.current();
+      const userLogin = wx.getStorageSync('userLogin');
+      const isLoggedIn = currentUser && currentUser.get('mobile') && userLogin;
+      
+      console.log('   当前用户:', currentUser ? currentUser.id : '无');
+      console.log('   手机号:', currentUser?.get('mobile') || '无');
+      console.log('   userLogin:', userLogin || '无');
+      console.log('   登录状态:', isLoggedIn ? '已登录' : '未登录');
+      
+      if (!isLoggedIn) {
+        console.log('❌ 用户未登录，显示登录提示');
+        
+        wx.showModal({
+          title: '需要登录',
+          content: '请先登录后再使用此功能',
+          showCancel: false,
+          confirmText: '立即登录',
+          success: () => {
+            // 跳转到登录页面
+            console.log('🔄 跳转到登录页面');
+            login.loginNow();
+          }
+        });
+        
+        return false;
+      }
+      
+      console.log('✅ 用户已登录，允许访问');
+      return true;
+    },
+
     /**
      * 检查 Company 的 isPublishing 状态
      * 用于控制是否显示 AI 相关内容
@@ -215,22 +220,38 @@ Component({
         let isPublishing = wx.getStorageSync('isPublishing');
         
         if (isPublishing === '' || isPublishing === null || isPublishing === undefined) {
-          // 缓存中没有，查询 Company 表
-          const companyQuery = new Parse.Query('Company');
-          companyQuery.equalTo('objectId', getApp().globalData.company);
-          companyQuery.select('isPublishing');
-          const companyObj = await companyQuery.first();
+          console.log('📦 缓存中没有 isPublishing，尝试查询数据库...');
           
-          if (companyObj) {
-            isPublishing = companyObj.get('isPublishing') === true;
-            console.log('📋 从数据库查询 isPublishing:', isPublishing);
+          try {
+            // 缓存中没有，查询 Company 表（使用 master key，不需要登录）
+            const companyQuery = new Parse.Query('Company');
+            companyQuery.equalTo('objectId', getApp().globalData.company);
+            companyQuery.select('isPublishing');
             
-            // 保存到缓存
-            wx.setStorageSync('isPublishing', isPublishing);
-            getApp().globalData.isPublishing = isPublishing;
-          } else {
-            console.warn('⚠️ 未找到 Company 记录');
+            // 使用 find 而不是 first，避免 session token 问题
+            const results = await companyQuery.find();
+            
+            if (results && results.length > 0) {
+              const companyObj = results[0];
+              isPublishing = companyObj.get('isPublishing') === true;
+              console.log('📋 从数据库查询 isPublishing:', isPublishing);
+              
+              // 保存到缓存
+              wx.setStorageSync('isPublishing', isPublishing);
+              getApp().globalData.isPublishing = isPublishing;
+            } else {
+              console.warn('⚠️ 未找到 Company 记录，默认为 false');
+              isPublishing = false;
+              // 也保存到缓存，避免重复查询
+              wx.setStorageSync('isPublishing', false);
+              getApp().globalData.isPublishing = false;
+            }
+          } catch (queryError) {
+            console.error('❌ 查询 Company 失败:', queryError);
+            // 查询失败时，默认为 false（需要登录）
             isPublishing = false;
+            wx.setStorageSync('isPublishing', false);
+            getApp().globalData.isPublishing = false;
           }
         } else {
           console.log('📦 从缓存读取 isPublishing:', isPublishing);
@@ -247,21 +268,31 @@ Component({
         console.log('===========================================');
       } catch (error) {
         console.error('❌ 检查 isPublishing 状态失败:', error);
-        // 出错时默认不显示 AI
+        // 出错时默认不显示 AI（需要登录）
         this.setData({
           showAI: false
         });
+        wx.setStorageSync('isPublishing', false);
       }
     },
 
     /**
      * 点击"立即开始探索"按钮
      */
-    onStart() {
+    async onStart() {
       console.log('===========================================');
       console.log('🚀 调用了 onStart 方法（立即开始探索）');
       console.log('===========================================');
       
+      // 检查 isPublishing 状态，如果不是 true，需要强制登录
+      const isPublishing = this.data.showAI; // showAI 就是 isPublishing 的状态
+      
+      // 检查是否需要强制登录
+      const canAccess = await this.checkLoginRequired();
+      if (!canAccess) {
+        return;
+      }
+      
       // 标记已访问
       wx.setStorageSync('hasVisitedWelcome', true);
       
@@ -272,7 +303,13 @@ Component({
     /**
      * 点击"跳过引导"按钮
      */
-    onSkip() {
+    async onSkip() {
+      // 检查是否需要强制登录
+      const canAccess = await this.checkLoginRequired();
+      if (!canAccess) {
+        return;
+      }
+      
       // 标记已访问
       wx.setStorageSync('hasVisitedWelcome', true);
       
@@ -692,7 +729,16 @@ Component({
       console.log('🏠 调用了 navigateToCases 方法（案例展示）');
       console.log('===========================================');
       
-      // 案例展示允许游客访问，直接跳转
+      // 检查 isPublishing 状态，如果不是 true，需要强制登录
+      const isPublishing = this.data.showAI;
+      
+      // 检查是否需要强制登录
+      const canAccess = await this.checkLoginRequired();
+      if (!canAccess) {
+        return;
+      }
+      
+      // 案例展示允许游客访问（当 isPublishing == true 时）
       const currentUser = Parse.User.current();
       
       if (!currentUser) {
@@ -703,7 +749,7 @@ Component({
         await this.navigateToH5Page('owner/nav/cases');
       }
     },
-
+    
     /**
      * 跳转到产品中心页面
      * @param {string} productId - 可选的产品ID，用于直接跳转到特定产品详情
@@ -713,7 +759,13 @@ Component({
       console.log('📦 调用了 navigateToProducts 方法（产品中心）');
       console.log('===========================================');
       
-      // 产品中心允许游客访问，直接跳转
+      // 检查是否需要强制登录
+      const canAccess = await this.checkLoginRequired();
+      if (!canAccess) {
+        return;
+      }
+      
+      // 产品中心允许游客访问（当 isPublishing == true 时）
       const currentUser = Parse.User.current();
       const params = productId ? { productId } : {};
       
@@ -734,6 +786,15 @@ Component({
       console.log('======= 点击咨询/方案定制 =======');
       console.log('===========================================');
       
+      // 检查 isPublishing 状态，如果不是 true，需要强制登录
+      const isPublishing = this.data.showAI;
+      
+      // 检查是否需要强制登录
+      const canAccess = await this.checkLoginRequired();
+      if (!canAccess) {
+        return;
+      }
+      
       // 方案定制需要登录
       let currentUser = Parse.User.current();
       const isGuestMode = wx.getStorageSync('isGuestMode');
@@ -1012,6 +1073,49 @@ Component({
       });
     },
     
+    /**
+     * 检查登录状态
+     * @returns {boolean} 是否已登录
+     */
+    async checkLoginStatus() {
+      let currentUser = Parse.User.current();
+      let userLogin = wx.getStorageSync('userLogin');
+      
+      // 如果有 Parse 用户但没有 userLogin，等待同步
+      if (currentUser && currentUser.get('mobile') && !userLogin) {
+        console.log('⏳ 等待登录状态同步...');
+        await new Promise(resolve => setTimeout(resolve, 500));
+        
+        currentUser = Parse.User.current();
+        userLogin = wx.getStorageSync('userLogin');
+        
+        if (currentUser && currentUser.get('mobile') && !userLogin) {
+          wx.setStorageSync("userLogin", currentUser.id);
+          userLogin = currentUser.id;
+        }
+      }
+      
+      return currentUser && currentUser.get('mobile') && userLogin;
+    },
+    
+    /**
+     * 显示需要登录的提示
+     */
+    showLoginRequired() {
+      wx.showModal({
+        title: '需要登录',
+        content: '此功能需要登录后使用，请先完成登录',
+        confirmText: '立即登录',
+        cancelText: '取消',
+        success: (res) => {
+          if (res.confirm) {
+            console.log('用户选择：立即登录');
+            login.loginNow();
+          }
+        }
+      });
+    },
+    
     /**
      * 游客模式跳转 H5 页面
      * @param {string} pagePath - H5 页面路径

utils/clearLogin.js

@@ -18,16 +18,22 @@ async function clearAllLoginState() {
     const currentUser = Parse.User.current();
     if (currentUser) {
       console.log('当前用户 ID:', currentUser.id);
-      console.log('当前手机号:', currentUser.get('mobile'));
+      console.log('当前手机号:', currentUser.get('mobile') || '无');
     }
     
-    // 2. 登出 Parse 用户
+    // 2. 登出 Parse 用户（即使 token 无效也要尝试）
     if (currentUser) {
-      await Parse.User.logOut();
-      console.log('✅ 已登出 Parse 用户');
+      try {
+        await Parse.User.logOut();
+        console.log('✅ 已登出 Parse 用户');
+      } catch (logoutError) {
+        // 如果登出失败（比如 token 无效），直接清除本地缓存
+        console.log('⚠️ Parse 登出失败（可能 token 已失效），直接清除本地状态');
+        console.log('   错误信息:', logoutError.message);
+      }
     }
     
-    // 3. 清除所有本地存储
+    // 3. 清除所有本地存储（无论 Parse 登出是否成功）
     wx.removeStorageSync('userLogin');
     wx.removeStorageSync('sessionToken');
     wx.removeStorageSync('isGuestMode');
@@ -46,6 +52,18 @@ async function clearAllLoginState() {
     return true;
   } catch (error) {
     console.error('❌ 清除登录状态失败:', error);
+    
+    // 即使出错，也尝试清除本地存储
+    try {
+      wx.removeStorageSync('userLogin');
+      wx.removeStorageSync('sessionToken');
+      wx.removeStorageSync('isGuestMode');
+      wx.removeStorageSync('userInfo');
+      console.log('✅ 已强制清除本地存储');
+    } catch (e) {
+      console.error('❌ 清除本地存储也失败:', e);
+    }
+    
     return false;
   }
 }