更新灌溉计划页面，添加项目选择器和总灌溉时间计算功能；优化界面样式，增加SVG图标；修复项目列表和轮灌组显示逻辑；调整配置文件，添加libVersio...

zuoxiao

2025-03-25 fe3ce21a469f7e2584dbcb85cb75022d149f436c

 pages/home/home.js

@@ -1,42 +1,56 @@
// pages/home/home.js
const storage = require('../../utils/storage.js');
const {
  get,
  post
} = require('../../api/request.js');
const {
  PROJECT_URLS
} = require('../../api/config.js');
Page({

  /**
   * 页面的初始数据
   */
  data: {
    sessionId: "",
    showConfirm: false,
    myItem: {},
    waterIntakeName: "",
    image: "/images/ic_head_bg.jpg",
    userCode: "张三",
    userName: "1005535",
    userBalance: "100.5元",
    userPhone: "",
    userName: "请点击登录",
    scrollViewHeight: 0,
    listData: [{
        name: '取水口 1',
        code: '1055201'
      },
      {
        name: '取水口 2',
        code: '1055201'
      },
      {
        name: '取水口 3',
        code: '1055201'
      },
      {
        name: '取水口 3',
        code: '1055201'
      },
      {
        name: '取水口 3',
        code: '1055201'
      }
    ]
    listData: [],
    isRefreshing: false,
    isWXRefreshing: false,
    errorData: '', //错误内容
    showErrorDialog: false,
    confirmBtn: {
      content: '确认'
    },
    errorDialogTitle: "关阀错误",
    showForceConfirm: false, //是否强制开阀
    lastIntakeName: "",
    showProjectDialog: false,
    selectedProject: '',
    avatarTapCount: 0,
    isFromLogin: false,
    showTipDialog:''
  },

  rechageTap:function (e) {
   wx.navigateTo({
     url: '/pages/recharge/recharge',
   })
  openValve: function (e) {
    const app = getApp();
    if (app.globalData.isLoggedIn) {
      wx.navigateTo({
        url: '/pages/waterIntake/waterIntake',
      })
    } else {
      wx.showToast({
        title: '请先登录',
        icon: 'error'
      })
    }
  },
  calculateScrollViewHeight: function () {
    wx.createSelectorQuery().selectAll('.list-item').boundingClientRect((rects) => {
@@ -46,51 +60,320 @@
      });
    }).exec();
  },
  startPullDownRefresh() {
    if (!this.data.isWXRefreshing) {
      var self = this;
      console.log(this.data.isRefreshing);
      this.setData({
        isRefreshing: true
      });
      this.getOpenList();

    }

  },
  //获取用户数据
  getUserData() {
    get('/items')
      .then((data) => {
        this.setData({
          items: data
        });
      })
      .catch((error) => {
        console.error('Failed to fetch data:', error);
      });
  },



  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
   // 使用 wx.nextTick 等待页面渲染完成
   wx.nextTick(() => {
    this.calculateScrollViewHeight();
  });
    console.log('home页面onLoad开始，参数:', options);
     //当开阀成功后调用刷新
    if (options.param === "1" || options.param === "2") {
        this.setData({
          options: options
        })
      }
    // 检查是否从登录页面返回
    let fromLogin = false;

    // 检查URL参数
    if (options && options.fromLogin === 'true') {
      console.log('检测到URL参数fromLogin=true');
      fromLogin = true;
    }

    // 检查是否有临时标记
    try {
      const tempFromLogin = wx.getStorageSync('_temp_from_login');
      console.log('读取到的临时标记值:', tempFromLogin);

      if (tempFromLogin === 'true') {
        console.log('检测到临时fromLogin标记');
        fromLogin = true;

        // 延迟清除临时标记，确保其他地方有足够时间读取
        setTimeout(() => {
          try {
            wx.removeStorageSync('_temp_from_login');
            console.log('自动清除临时fromLogin标记');
          } catch (e) {
            console.error('清除临时标记失败:', e);
          }
        }, 10000); // 延长到10秒
      }
    } catch (e) {
      console.error('读取临时标记失败:', e);
    }

    console.log('home页面加载，fromLogin:', fromLogin, '参数:', options);

    // 设置fromLogin标志
    if (fromLogin) {
      console.log('设置isFromLogin=true');
      this.setData({
        isFromLogin: true
      });
    }

    // 延迟执行剩余的初始化过程，以确保临时标记和URL参数能被正确处理
    setTimeout(() => {
      this.initializePage(options, fromLogin);
    }, 100);
  },

  // 新增的初始化页面辅助函数，分离出onLoad中的逻辑以便延迟执行
  initializePage(options, fromLogin) {
    // 检查是否已选择项目
    const {
      PROJECT_URLS
    } = require('../../api/config.js');

    // 确保全局变量存在
    getApp().globalData = getApp().globalData || {};

    storage.getItemSafe('selectedProject')
      .then((project) => {
        if (project) {
          this.setData({
            selectedProject: project
          });

          // 设置 baseUrl
          const baseUrl = PROJECT_URLS[project];
          getApp().globalData.baseUrl = baseUrl;
          getApp().globalData.selectedProject = project;

          // 根据项目设置对应的tag
          if (project === 'JYG') {
            getApp().globalData.tag = 'ym'; // 嘉峪关项目对应tag为ym
            this.setData({
              userName: "嘉峪关项目"
            });
          } else if (project === 'MQ') {
            getApp().globalData.tag = 'mq'; // 民勤项目对应tag为mq
            this.setData({
              userName: "民勤项目"
            });
            // 加载民勤项目持久化参数
            return storage.getItemSafe('MQ_params')
              .then(params => {
                if (params) {
                  getApp().globalData.operator = params.operator;
                  getApp().globalData.clientId = params.clientId;
                  getApp().globalData.isLoggedIn = params.isLoggedIn;
                  getApp().globalData.sessionId = params.sessionId;
                }
                return Promise.resolve();
              });
          } else if (project === 'TEST') {
            getApp().globalData.tag = 'ym'; // 测试项目对应tag为test
            this.setData({
              userName: "测试项目"
            });
            // 加载测试项目持久化参数
            return storage.getItemSafe('TEST_params')
              .then(params => {
                if (params) {
                  getApp().globalData.operator = params.operator;
                  getApp().globalData.clientId = params.clientId;
                  getApp().globalData.isLoggedIn = params.isLoggedIn;
                  getApp().globalData.sessionId = params.sessionId;
                  getApp().globalData.vcId = params.vcId;
                }
                return Promise.resolve();
              });
          }

          // 继续初始化页面
          this.continueInitPage(options);
        } else {
          // 首次进入，显示项目选择弹窗
          this.setData({
            showProjectDialog: true
          });
          return Promise.reject({
            type: 'project_not_selected',
            message: '未选择项目'
          }); // 终止后续处理
        }
      })
      .then(() => {
        // 继续初始化页面
        this.continueInitPage(options);
      })
      .catch(err => {
        // 将错误对象规范化
        const error = typeof err === 'object' ? err : {
          type: 'unknown',
          message: String(err)
        };
        console.log('获取存储数据中断:', error.message);

        // 如果是从登录页返回或已登录，不再跳转
        if (fromLogin || getApp().globalData.isLoggedIn) {
          console.log('从登录页返回或已登录，继续初始化页面');
          this.continueInitPage(options);
          return;
        }

        // 处理未选择项目的情况
        if (error.type === 'project_not_selected') {
          console.log('未选择项目，显示项目选择弹窗');
          this.setData({
            showProjectDialog: true
          });
          return;
        }

        // 其他未知错误，尝试继续初始化页面
        console.warn('未知错误，尝试继续初始化页面:', error);
        this.continueInitPage(options);
      });
  },

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

    if (this.data.options.param === "1") {
        this.setData({
          showTipDialog: true,
          tipData: "开阀命令下发成功，因开阀需要时间，约20-60秒后可刷新快速关阀列表查看执行结果。"
        })
        setTimeout(() => {
          this.getOpenList();
        }, 20000)
  
      } else if (this.data.options.param === "2") {
        this.setData({
          showTipDialog: true,
          tipData: "预约开阀命令下发成功，当到达预约时间并且成功开阀后快速关阀列表会显示未关阀记录"
        })
        this.getOpenList();
      }
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    console.log('home页面onShow开始');

    // 获取当前页面的参数
    const pages = getCurrentPages();
    const currentPage = pages[pages.length - 1];

    let fromLogin = false;

    // 检查是否有fromLogin参数
    if (currentPage && currentPage.options && currentPage.options.fromLogin === 'true') {
      console.log('onShow: 检测到fromLogin参数，设置isFromLogin标记');
      fromLogin = true;
      this.setData({
        isFromLogin: true
      });
    }

    // 检查是否有临时标记
    try {
      const tempFromLogin = wx.getStorageSync('_temp_from_login');
      console.log('onShow: 读取到的临时标记值:', tempFromLogin);

      if (tempFromLogin === 'true') {
        console.log('onShow: 检测到临时fromLogin标记');
        fromLogin = true;
        this.setData({
          isFromLogin: true
        });
      }
    } catch (e) {
      console.error('onShow: 读取临时标记失败:', e);
    }

    // 初始化处理
    if (fromLogin || this.data.isFromLogin) {
      console.log('onShow: 从登录页返回，不进行登录检查');
    } else {
      console.log('onShow: 正常显示页面');
      // 延迟检查登录状态，确保能正确识别临时标记
      setTimeout(() => {
        this.checkLoginStatusIfNeeded();
      }, 300);
    }
  },

  // 检查登录状态（仅在需要时）
  checkLoginStatusIfNeeded() {
    // 再次确认是否从登录页返回
    if (this.getFromLogin()) {
      console.log('检测到从登录页返回的标记，不进行登录检查');
      return;
    }

    // 再次检查全局登录状态
    if (getApp().globalData.isLoggedIn) {
      console.log('检测到全局登录状态，不进行登录检查');
      return;
    }

    console.log('执行登录状态检查');
    this.checkLoginStatus();
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {

    // 页面隐藏时考虑清理临时标记
    this.cleanupTempMarkers();
  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {

    // 页面卸载时清理临时标记
    this.cleanupTempMarkers();
  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {

    // 下拉刷新触发的逻辑，可以是请求数据等操作
    // 例如，请求数据后更新页面内容
    console.log(this.data.isRefreshing);
    this.setData({
      isWXRefreshing: true
    });
    console.log(this.data.isRefreshing);
    // 数据请求完成后，停止下拉刷新的动画
    this.getOpenList();
  },

  /**
@@ -105,5 +388,1136 @@
   */
  onShareAppMessage() {

  }
  },
  recharge() {
    // wx.navigateTo({
    //   url: '/pages/rechargeCard/rechargeCard',
    // })
    wx.showToast({
      title: '暂未开放',
      icon: 'none'
    })
  },
  openValveList() {
    // wx.navigateTo({
    //   url: '/pages/valveList/valveList',
    // })
    wx.showToast({
      title: '暂未开放',
      icon: 'none'
    })
  },
  feedBack() {
    wx.showToast({
      title: '暂未开放',
      icon: 'none'
    })
  },
  //解绑用户
  unbind() {
    wx.showModal({
      title: '解绑确认',
      content: '确定要解绑当前账号吗？',
      success: (res) => {
        if (res.confirm) {
          this.unBindPost()
        }
      }
    });
  },
  //轮灌
  irrigation() {
    wx.navigateTo({
      url: '/pages/irrigation/irrigation',
    })
  },
  handleChange(e) {
    const item = e.currentTarget.dataset.item;
    console.log(item);
    this.setData({
      showConfirm: true,
      waterIntakeName: item.intakeNum,
      myItem: item
    });
  },
  closeDialog() {
    console.log("closeDialog");
    this.setData({
      showConfirm: false,
      showErrorDialog: false,
      showForceConfirm: false
    });
  },
  cancelDialog() {
    this.setData({
      showForceConfirm: false,
      showConfirm: false
    });
  },
  /**
   * 关闭阀门
   * @param {*} orderNo 订单号
   * @param {*} rtuAddr 阀控器地址
   * @param {*} vcNum 虚拟卡编号
   */
  postCloseValaue(orderNo, rtuAddr, vcNum) {
    wx.showLoading({
      title: '正在关阀请稍候...', // 加载提示文字
      mask: true // 是否显示透明蒙层，防止触摸穿透，默认为 false
    });
    const app = getApp();
    const data = {
      rtuAddr: rtuAddr,
      vcNum: vcNum, //虚拟卡ID
      orderNo: orderNo,
      operator: app.globalData.clientId //操作员
    };
    console.log("postCloseValaue" + data);
    post({
      url: "wx/valve/close_wx",
      data: data,
      isShowLoding: false,
      timeout: 185000
    }).then(response => {

      // 处理成功响应
      console.log('请求成功:', response);
      // 加载完成后隐藏加载动画
      wx.hideLoading();
      this.getOpenList();
      wx.showToast({
        title: '关阀成功',
        icon: 'success',
        duration: 3000
      })
    }).catch(error => {
      wx.hideLoading();
      this.setData({
        showErrorDialog: true,
        errorData: error.msg,
        errorDialogTitle: "关阀错误"
      })
      // 处理错误响应
      console.error('请求失败:', error);

    });
  },
  /**
   * 获取为关阀记录
   */
  getOpenList() {
    const app = getApp();

    // 检查是否从登录页返回
    const fromLogin = this.getFromLogin();

    // 检查clientId是否存在
    if (!app.globalData.clientId) {
      console.log('getOpenList: clientId不存在，不执行API请求');

      // 如果是从登录页返回，就显示空列表而不是错误提示
      this.setData({
        listData: [],
        isRefreshing: false,
        isWXRefreshing: false
      });

      // 如果不是从登录页返回且不处于刷新状态，考虑检查登录状态
      if (!fromLogin && !this.data.isRefreshing && !this.data.isWXRefreshing) {
        console.log('getOpenList: 非刷新状态下检测到无clientId，尝试自动登录');
        // 延迟调用微信登录，尝试自动恢复会话
        setTimeout(() => {
          if (!getApp().globalData.clientId && !this.getFromLogin()) {
            this.wxLogin();
          }
        }, 1000);
      }
      return;
    }

    console.log('getOpenList: 开始获取列表数据, clientId:', app.globalData.clientId);

    const params = {
      url: 'wx/valve/get',
      data: {
        operator: app.globalData.clientId
      }
    };

    get(params).then(data => {
      console.log('获取列表数据成功:', data);
      this.setData({
        listData: data.content,
        isRefreshing: false, // 将triggered属性设置为false，表示下拉刷新已完成
        isWXRefreshing: false, // 将triggered属性设置为false，表示下拉刷新已完成
      });

      // 成功获取数据后刷新UI高度
      setTimeout(() => {
        this.calculateScrollViewHeight();
      }, 200);
    }).catch(err => {
      console.error('获取列表数据失败:', err);
      // 错误回调
      this.setData({
        isRefreshing: false, // 将triggered属性设置为false，表示下拉刷新已完成
        isWXRefreshing: false, // 将triggered属性设置为false，表示下拉刷新已完成
      });

      // 检查错误类型
      if (err && err.code === '0003') {
        console.log('会话无效或过期，但不进行跳转');

        // 如果不是从登录页返回，显示错误提示
        if (!fromLogin) {
          wx.showToast({
            title: '登录已过期，请刷新重试',
            icon: 'none',
            duration: 3000
          });
        }
      } else {
        // 一般错误，显示错误信息
        wx.showToast({
          title: err.msg || '获取列表数据失败',
          icon: 'none',
          duration: 3000
        });
      }
    });
  },
  /**
   * 确认关闭回调
   * @param {} item 
   */
  confirmDialog() {
    this.setData({
      showConfirm: false
    });
    this.postCloseValaue(this.data.myItem.orderNo, this.data.myItem.rtuAddr, this.data.myItem.vcNum);
  },
  //根据session获取农户信息
  getUserDataBySession() {
    // 先检查是否从登录页返回
    if (this.getFromLogin()) {
      console.log('getUserDataBySession: 检测到从登录页返回的标记，不执行API请求');
      return;
    }

    const app = getApp();

    // 检查是否有sessionId
    if (!app.globalData.sessionId) {
      console.log('getUserDataBySession: sessionId不存在，不执行API请求');
      return;
    }

    console.log('getUserDataBySession: 开始获取用户数据, sessionId:', app.globalData.sessionId);

    const params = {
      url: 'wx/client/simple_info',
      data: {
        sessionId: app.globalData.sessionId
      }
    };

    get(params).then(data => {
      console.log('获取用户数据成功:', data);
      this.setData({
        userName: data.content.clientName,
        userPhone: this.maskPhoneNumber(data.content.phone)
      });
    }).catch(err => {
      console.error('获取用户数据失败:', err);
      // 错误回调，但不进行页面跳转

      // 检查错误类型
      if (err && err.code === '0003') {
        console.log('会话无效或过期，但不进行跳转');
        // 不再直接跳转到登录页

        // 清除会话信息
        app.globalData.sessionId = '';
        app.globalData.isLoggedIn = false;

        // 如果不是从登录页返回，显示错误提示
        if (!this.getFromLogin()) {
          wx.showToast({
            title: '登录已过期，请重新登录',
            icon: 'none',
            duration: 3000
          });
        }
      } else {
        // 其他错误，显示错误信息
        wx.showToast({
          title: err.msg || '获取用户信息失败',
          icon: 'none',
          duration: 3000
        });
      }
    });
  },
  maskPhoneNumber(phoneNumber) {
    if (phoneNumber.length !== 11) {
      throw new Error("Phone number must be 11 digits");
    }
    // 使用正则表达式替换中间四位数字为星号
    const maskedPhoneNumber = phoneNumber.replace(/^(\d{3})\d{4}(\d{4})$/, "$1****$2");
    return maskedPhoneNumber;
  },

  closeDialog() {
    this.setData({
      showErrorDialog: false
    })
  },
  /**
   * 扫码开阀
   */
  scenCode() {
    const that = this;
    wx.scanCode({
      success(res) {
        console.log(res.result); // 当且仅当扫码为非微信二维码时，会返回result  
        if (res.result.startsWith("content://")) {
          let jsonStr = res.result.replace("content://", "")
          try {

            that.saveData(jsonStr)
          } catch (error) {
            console.error('Error parsing JSON:', error);
          }

        } else {
          that.postOppenValva(res.result)
        }

      },
      fail(err) {
        console.error(err);
      }
    })
  },
  confirmForceDialog() {
    console.log("confirmForceDialog");
    this.setData({
      showForceConfirm: false
    })
    this.postOppenValva(this.data.lastIntakeName, true)
  },
  /**
   * 
   * @param {*} intakeName 
   */
  postOppenValva(intakeName, isforce) {
    const that = this;
    wx.showLoading({
      title: '正在开阀请稍候...', // 加载提示文字
      mask: true // 是否显示透明蒙层，防止触摸穿透，默认为 false
    });
    const app = getApp();
    that.setData({
      lastIntakeName: intakeName
    })
    const data = {
      intakeName: intakeName, //取水口ID
      // vcId: vcId, //虚拟卡ID
      operator: app.globalData.clientId, //操作员
      forceOpen: !!isforce // 使用逻辑非操作符 !! 来确保 isForce 是布尔值  
    };
    post({
      url: "wx/valve/open_wx",
      data: data,
      timeout: 180000
    }).then(response => {

      // 处理成功响应
      console.log('请求成功:', response);
      // 加载完成后隐藏加载动画
      wx.hideLoading();
      //完成后回到首页
      wx.reLaunch({
        url: '/pages/home/home?param=true' // 首页的路径，根据实际情况填写
      });
    }).catch(error => {
      // 加载完成后隐藏加载动画
      wx.hideLoading();
      // 处理错误响应
      console.error('请求失败:', error);
      if (error.code === "10005") {
        that.setData({
          showForceConfirm: true
        })
      } else {
        that.setData({
          showErrorDialog: true,
          errorData: error.msg,
          errorDialogTitle: "开阀错误"
        })
      }
    });
  },
  /**
   * 扫描后保存用户id和tag
   */
  saveData(userData) {
    storage.setItem("userData", userData).then(() => {
      this.initData();
    }).catch((error) => {});

  },
  //进入界面获取界面数据
  initData() {
    const app = getApp();
    console.log("initData开始，tag:", app.globalData.tag);

    // 首先检查是否从登录页返回
    if (this.getFromLogin()) {
      console.log('initData: 检测到从登录页返回的标记，仅获取基本数据');

      // 即使从登录页返回，也尝试获取开阀列表以显示基本UI
      // 但先检查是否有客户端ID可用
      if (!app.globalData.clientId) {
        console.log('initData: 从登录页返回且无clientId，尝试从存储恢复');
        // 尝试从存储恢复clientId
        storage.getItemSafe('clientId')
          .then(clientId => {
            if (clientId) {
              console.log('initData: 从存储恢复clientId成功:', clientId);
              app.globalData.clientId = clientId;
              this.getOpenList();
            } else {
              console.log('initData: 无法恢复clientId，显示空列表');
              this.setData({
                listData: []
              });
            }
          })
          .catch(err => {
            console.error('initData: 恢复clientId失败:', err);
            this.setData({
              listData: []
            });
          });
      } else {
        this.getOpenList();
      }
      return;
    }

    // 尝试获取用户数据和已开阀记录
    try {
      // 优先检查全局变量中是否有sessionId
      if (app.globalData.sessionId) {
        console.log('initData: 使用全局sessionId获取数据');
        this.getUserDataBySession();
        this.getOpenList();
        return;
      }

      // 检查是否有存储的userData
      const hasUserData = storage.isHasKeySync("userData");
      console.log('initData: 是否存在userData:', hasUserData);

      if (hasUserData) {
        storage.getItemSafe('userData')
          .then((data) => {
            console.log('initData: 成功读取userData');
            if (data) {
              try {
                let jsonObj = JSON.parse(data);
                app.globalData.sessionId = jsonObj.sessionId;
                app.globalData.tag = jsonObj.tag;
                console.log("userData已加载:", data);
              } catch (e) {
                console.error('userData解析失败:', e);
              }
            }
            // 无论如何都尝试获取用户信息和开阀列表
            this.getUserDataBySession();
            this.getOpenList();
          })
          .catch((err) => {
            console.error('加载userData失败:', err);

            // 再次检查是否从登录页返回
            if (this.getFromLogin()) {
              console.log('initData:catch: 检测到从登录页返回的标记，只获取开阀列表');
              this.getOpenList();
            } else {
              this.getUserDataBySession();
              this.getOpenList();
            }
          });
      } else {
        console.log('未找到userData，直接获取数据');

        // 再次检查是否从登录页返回
        if (this.getFromLogin()) {
          console.log('initData:else: 检测到从登录页返回的标记，只获取开阀列表');
          this.getOpenList();
        } else {
          this.getUserDataBySession();
          this.getOpenList();
        }
      }
    } catch (e) {
      console.error('initData执行出错:', e);

      // 再次检查是否从登录页返回
      if (this.getFromLogin()) {
        console.log('initData:error: 检测到从登录页返回的标记，只获取开阀列表');
        this.getOpenList();
      } else {
        // 出错时仍尝试获取数据
        this.getUserDataBySession();
        this.getOpenList();
      }
    }
  },
  // 处理头像点击
  handleAvatarTap() {
    this.setData({
      avatarTapCount: this.data.avatarTapCount + 1
    });

    if (this.data.avatarTapCount >= 5) {
      this.setData({
        showProjectDialog: true,
        avatarTapCount: 0
      });
    }
  },

  // 处理弹窗可见性变化
  onVisibleChange(e) {
    // 如果尝试关闭弹窗且没有选择项目，则阻止关闭
    if (!e.detail.visible && !this.data.selectedProject) {
      return;
    }
    this.setData({
      showProjectDialog: e.detail.visible
    });
  },

  // 处理项目选择变化
  onProjectChange(event) {
    console.log('选择的项目：', event.detail.value);
    this.setData({
      selectedProject: event.detail.value
    });
  },

  // 处理项目选择确认
  handleProjectConfirm() {
    if (!this.data.selectedProject) {
      wx.showToast({
        title: '请选择项目',
        icon: 'none'
      });
      return;
    }

    // 获取当前已选项目和新选择的项目
    const currentProject = getApp().globalData.selectedProject;
    const newProject = this.data.selectedProject;
    const projectName = newProject === 'JYG' ? '嘉峪关项目' : 
                       newProject === 'MQ' ? '民勤项目' : 
                       newProject === 'TEST' ? '测试项目' : '未知项目';

    // 检查是否切换了项目（如果当前项目不同于新选择的项目）
    const isProjectChanged = currentProject && currentProject !== newProject;

    // 如果切换了项目，先清除登录状态
    if (isProjectChanged) {
      console.log(`正在从项目 ${currentProject} 切换到 ${newProject}，将清除登录状态`);

      // 清除全局登录状态
      getApp().globalData.sessionId = '';
      getApp().globalData.clientId = '';
      getApp().globalData.isLoggedIn = false;
      getApp().globalData.userInfo = null;

      // 清除存储中的登录状态
      try {
        wx.removeStorageSync('sessionId');
        wx.removeStorageSync('clientId');
        wx.removeStorageSync('userData');
        wx.removeStorageSync('isLoggedIn');
        console.log('已清除登录相关的存储数据');
      } catch (e) {
        console.error('清除存储数据失败:', e);
      }

      // 重置UI显示状态
      this.setData({
        userName: "请登录",
        userPhone: "",
        listData: []
      });
    }

    // 保存项目选择到本地存储
    storage.setItem('selectedProject', newProject).then(() => {
      // 更新 BASEURL
      const {
        PROJECT_URLS
      } = require('../../api/config.js');
      const baseUrl = PROJECT_URLS[newProject];

      // 更新全局变量
      getApp().globalData = getApp().globalData || {};
      getApp().globalData.baseUrl = baseUrl;
      getApp().globalData.selectedProject = newProject;

      // 根据项目设置对应的tag和clientId
      if (newProject === 'JYG') {
        getApp().globalData.tag = 'ym'; // 嘉峪关项目对应tag为ym
        this.setData({
          userName: "嘉峪关项目"
        });
      } else if (newProject === 'MQ') {
        getApp().globalData.tag = 'mq'; // 民勤项目对应tag为mq
        getApp().globalData.operator = '2025030517095000006';
        getApp().globalData.clientId = '2025030517095000006';
        getApp().globalData.isLoggedIn = true;
        getApp().globalData.sessionId = '2025030517095000006';
        this.setData({
          userName: "民勤项目"
        });
        // 持久化存储民勤项目参数
        storage.setItem('MQ_params', {
          operator: '2025030517095000006',
          clientId: '2025030517095000006',
          isLoggedIn: true,
          sessionId: '2025030517095000006'
        });
      } else if (newProject === 'TEST') {
        getApp().globalData.tag = 'ym'; // 测试项目对应tag为test
        getApp().globalData.operator = '2025032411245000006';
        getApp().globalData.clientId = '2025032411245000006';
        getApp().globalData.isLoggedIn = true;
        getApp().globalData.sessionId = '2025032411245000006';
        getApp().globalData.vcId = '2024122617295800009';
        this.setData({
          userName: "测试项目"
        });
        // 持久化存储测试项目参数
        storage.setItem('TEST_params', {
          operator: '2025032411245000006',
          clientId: '2025032411245000006',
          isLoggedIn: true,
          sessionId: '2025032411245000006',
          vcId: '2024122617295800009'
        });
      }

      console.log('已切换到项目:', projectName, '域名:', baseUrl, 'tag:', getApp().globalData.tag);

      this.setData({
        showProjectDialog: false
      });

      // 显示切换成功提示
      wx.showToast({
        title: `已选择${projectName}`,
        icon: 'success',
        duration: 2000
      });

      // 直接初始化数据
      setTimeout(() => {
        console.log('项目已切换，正在初始化数据');
        this.initData();
      }, 1000);
    }).catch(err => {
      console.error('保存项目选择失败：', err);
      wx.showToast({
        title: '保存失败，请重试',
        icon: 'none',
        duration: 2000
      });
    });
  },

  // 检查登录状态
  checkLoginStatus() {
    const app = getApp();

    // 首先，强制再次检查是否从登录页返回
    try {
      const tempFromLogin = wx.getStorageSync('_temp_from_login');
      if (tempFromLogin === 'true') {
        console.log('checkLoginStatus: 检测到临时存储_temp_from_login=true，不执行跳转');
        this.setData({
          isFromLogin: true
        });
        return;
      }
    } catch (e) {
      console.error('checkLoginStatus: 读取临时标记失败:', e);
    }

    // 检查是否已登录
    if (app.globalData.isLoggedIn && app.globalData.sessionId) {
      console.log('已从全局变量检测到登录状态');
      return;
    }

    // 检查本页面是否正在处理返回逻辑
    const fromLogin = this.getFromLogin();
    if (fromLogin) {
      console.log('从登录页返回，不再重定向');
      return;
    }

    // 获取当前页面路由和参数
    const pages = getCurrentPages();
    const currentPage = pages[pages.length - 1];
    const currentRoute = currentPage ? currentPage.route : '';
    const currentOptions = currentPage ? currentPage.options || {} : {};

    console.log('当前页面路由:', currentRoute, '参数:', currentOptions);

    // 检查URL参数中是否有fromLogin
    if (currentOptions.fromLogin === 'true') {
      console.log('URL参数中检测到fromLogin=true，不执行跳转');
      this.setData({
        isFromLogin: true
      });
      return;
    }

    // 如果当前已在登录页，不再跳转
    if (currentRoute === 'pages/login/login') {
      console.log('当前已在登录页，不再跳转');
      return;
    }

    // Promise链处理存储检查
    Promise.all([
        storage.getItemSafe('sessionId'),
        storage.getItemSafe('clientId'),
        storage.getItemSafe('isLoggedIn')
      ])
      .then(([sessionId, clientId, isLoggedIn]) => {
        // 最后一次检查临时标记
        try {
          const tempFromLogin = wx.getStorageSync('_temp_from_login');
          if (tempFromLogin === 'true') {
            console.log('Promise内部: 检测到临时存储_temp_from_login=true，不执行跳转');
            this.setData({
              isFromLogin: true
            });
            return;
          }
        } catch (e) {}

        if (sessionId) {
          // 从存储中恢复登录状态
          app.globalData.sessionId = sessionId;
          app.globalData.isLoggedIn = true;

          if (clientId) {
            app.globalData.clientId = clientId;
          }

          console.log('已从存储恢复登录状态');
          // 已登录，刷新页面
          wx.reLaunch({
            url: '/pages/home/home'
          });
        } else {
          // 标记当前页面正在处理返回逻辑
          this.setData({
            isFromLogin: true
          });

          // 未登录，可能需要跳转到登录页面
          console.log('未检测到登录状态，可能需要跳转到登录页');

          // 最后再检查一次是否已从登录页返回
          const finalCheck = this.getFromLogin();
          if (finalCheck) {
            console.log('最终检查: 已从登录页返回，不再跳转');
            return;
          }

          console.log('确认需要跳转到登录页');

          // 跳转前再次检查登录页面临时标记
          try {
            wx.setStorageSync('_attempted_login_redirect', 'true');
          } catch (e) {}

          wx.redirectTo({
            url: `/pages/login/login?project=${this.data.selectedProject}`,
            success: () => console.log('成功跳转到登录页'),
            fail: (err) => console.error('跳转到登录页失败:', err)
          });
        }
      })
      .catch(err => {
        console.error('检查登录状态时出错:', err);

        // 标记当前页面正在处理返回逻辑
        this.setData({
          isFromLogin: true
        });

        // 再次检查是否已从登录页返回
        if (this.getFromLogin()) {
          console.log('错误处理: 已从登录页返回，不再跳转');
          return;
        }

        // 出错时也跳转到登录页
        wx.redirectTo({
          url: `/pages/login/login?project=${this.data.selectedProject}`,
          success: () => console.log('错误后成功跳转到登录页'),
          fail: (err) => console.error('错误后跳转到登录页失败:', err)
        });
      });
  },

  // 辅助函数：检查是否从登录页返回
  getFromLogin() {
    // 先检查全局变量（作为备用方案）
    if (getApp().globalData && getApp().globalData._tempFromLogin === true) {
      console.log('getFromLogin: 检测到全局变量_tempFromLogin=true');
      // 设置标志，确保下次检查时能识别
      this.setData({
        isFromLogin: true
      });

      // 清除全局标记，防止重复识别
      setTimeout(() => {
        getApp().globalData._tempFromLogin = false;
        console.log('已清除全局变量_tempFromLogin标记');
      }, 100);

      return true;
    }

    // 检查是否有设置fromLogin标志
    if (this.data.isFromLogin) {
      console.log('getFromLogin: 检测到this.data.isFromLogin=true');
      return true;
    }

    // 检查当前页面的options
    const pages = getCurrentPages();
    const currentPage = pages[pages.length - 1];
    if (currentPage && currentPage.options && currentPage.options.fromLogin === 'true') {
      console.log('getFromLogin: 检测到URL参数fromLogin=true');
      // 设置标志，确保下次检查时能识别
      this.setData({
        isFromLogin: true
      });
      return true;
    }

    // 检查临时标记
    try {
      const tempFromLogin = wx.getStorageSync('_temp_from_login');
      console.log('getFromLogin: 读取到的临时标记值:', tempFromLogin);

      if (tempFromLogin === 'true') {
        console.log('getFromLogin: 检测到临时存储_temp_from_login=true');
        // 设置标志，确保下次检查时能识别
        this.setData({
          isFromLogin: true
        });
        return true;
      }
    } catch (e) {
      console.error('getFromLogin: 读取临时标记失败:', e);
    }

    console.log('getFromLogin: 未检测到从登录页返回的标记');
    return false;
  },

  // 继续初始化页面
  continueInitPage(options) {
    console.log('继续初始化页面，options:', options);

    // 检查是否从登录页返回
    let fromLogin = false;

    // 从URL参数中检查
    if (options && options.fromLogin === 'true') {
      console.log('continueInitPage: 从URL参数检测到fromLogin=true');
      fromLogin = true;
      this.setData({
        isFromLogin: true
      });
    }

    // 从临时标记中检查
    try {
      const tempFromLogin = wx.getStorageSync('_temp_from_login');
      if (tempFromLogin === 'true') {
        console.log('continueInitPage: 检测到临时标记_temp_from_login=true');
        fromLogin = true;
        this.setData({
          isFromLogin: true
        });
      }
    } catch (e) {
      console.error('continueInitPage: 读取临时标记失败:', e);
    }

    // 从页面数据中检查
    if (this.data.isFromLogin) {
      console.log('continueInitPage: 从页面数据中检测到isFromLogin=true');
      fromLogin = true;
    }

    // 判断本地是否保存sessionId
    // 使用 wx.nextTick 等待页面渲染完成
    wx.nextTick(() => {
      this.calculateScrollViewHeight();
    });

    // 当开阀成功后调用刷新
    if (options && options.param) {
      console.log("开阀成功参数:", options.param);
      wx.showToast({
        title: '开阀成功',
        icon: 'success',
        duration: 3000
      });
      this.getOpenList();
    }

    // 初始化数据
    this.initData();

    // 如果不是从登录页返回，则设置延迟检查登录状态
    if (!fromLogin) {
      console.log('不是从登录页返回，延迟检查登录状态');
      setTimeout(() => {
        // 再次检查是否已从登录页返回（可能在初始化过程中状态已变）
        if (this.getFromLogin()) {
          console.log('延迟检查：检测到从登录页返回的标记，不再检查登录状态');
          return;
        }

        // 仅在未登录且不是从登录页返回时检查登录状态
        if (!getApp().globalData.isLoggedIn) {
          console.log('延迟检查：未登录且不是从登录页返回，执行登录状态检查');
          this.checkLoginStatus();
        }
      }, 500);
    } else {
      console.log('从登录页返回，不检查登录状态');
    }
  },

  // 微信登录
  wxLogin() {
    if (!getApp().globalData.isLoggedIn) {
      wx.showLoading({
        title: '正在登录请稍候...',
        mask: true
      });

      wx.login({
        success: (res) => {
          if (res.code) {
            // 将code发送到服务器获取openid
            post({
              url: "wx/client/code_login",
              data: {
                code: res.code
              }
            }).then(response => {
              wx.hideLoading();
              if (response.code === "0001") {
                if (response.content.client.clientId === "") {
                  // 未绑定账号，跳转到登录页面
                  wx.redirectTo({
                    url: `/pages/login/login?project=${this.data.selectedProject}`
                  });
                } else {
                  this.setData({
                    userName: response.content.client.clientName,
                    userPhone: response.content.client.userPhone
                  })
                  // 已有账号，保存数据并初始化
                  const sessionId = response.content.client.sessionId;
                  const clientId = response.content.client.clientId;

                  // 设置全局变量
                  getApp().globalData.sessionId = sessionId;
                  getApp().globalData.clientId = clientId;
                  getApp().globalData.isLoggedIn = true;

                  // 设置正确的项目tag
                  const tag = this.data.selectedProject === 'JYG' ? 'ym' : 'mq';
                  getApp().globalData.tag = tag;

                  // 保存到存储
                  storage.setItem("sessionId", sessionId);
                  storage.setItem("clientId", clientId);
                  storage.setItem("isLoggedIn", "true");

                  // 保存userData信息，包含sessionId和tag
                  const userData = JSON.stringify({
                    sessionId: sessionId,
                    tag: tag,
                    project: this.data.selectedProject,
                    userName: response.content.client.clientName,
                    userPhone: response.content.client.userPhone
                  });
                  storage.setItem("userData", userData)
                    .then(() => {
                      console.log('用户数据保存成功，包含项目信息:', this.data.selectedProject, 'tag:', tag);
                      this.initData();
                    })
                    .catch(err => {
                      console.warn('保存userData失败，但继续初始化:', err);
                      this.initData();
                    });

                }
              } else {
                wx.showToast({
                  title: '登录失败',
                  icon: 'error',
                  duration: 2000
                });
                wx.redirectTo({
                  url: `/pages/login/login?project=${this.data.selectedProject}`
                });
              }
            }).catch(error => {
              wx.hideLoading();
              console.error('登录请求失败:', error);
              wx.showToast({
                title: '登录失败，请重试',
                icon: 'none'
              });
              wx.redirectTo({
                url: `/pages/login/login?project=${this.data.selectedProject}`
              });
            });
          } else {
            wx.hideLoading();
            console.log('登录失败！' + res.errMsg);
            wx.showToast({
              title: '微信登录失败',
              icon: 'none'
            });
          }
        },
        fail: (err) => {
          wx.hideLoading();
          console.error('微信登录API调用失败:', err);
          wx.showToast({
            title: '登录失败，请重试',
            icon: 'none'
          });
        }
      });
    }
  },

  // 辅助函数：清理临时标记
  cleanupTempMarkers() {
    // 只有在isFromLogin为true时才进行清理
    if (this.data.isFromLogin) {
      console.log('清理临时标记');

      // 清理存储标记
      try {
        wx.removeStorageSync('_temp_from_login');
      } catch (e) {
        console.error('清理存储标记失败:', e);
      }

      // 清理全局变量标记
      if (getApp().globalData) {
        getApp().globalData._tempFromLogin = false;
      }

      // 重设isFromLogin为false，但添加延迟，避免影响当前页面的返回逻辑
      setTimeout(() => {
        this.setData({
          isFromLogin: false
        });
        console.log('重置isFromLogin=false');
      }, 5000);
    }
  }, //确认解绑
  unBindPost() {
    this.setData({
      showUnBind: false
    })
    wx.showLoading({
      title: '正在解绑请稍候...', // 加载提示文字
      mask: true // 是否显示透明蒙层，防止触摸穿透，默认为 false
    });
    const data = {
      sessionId: getApp().globalData.sessionId //取水口ID
    };
    post({
      url: 'wx/client/unbind',
      data: data,
      useParams: true
    }).then(response => {
      // 处理成功响应
      console.log('请求成功:', response);
      // 加载完成后隐藏加载动画
      wx.hideLoading();
      const app = getApp();

      // 清除全局登录状态
      app.globalData.sessionId = '';
      app.globalData.clientId = '';
      app.globalData.isLoggedIn = false;
      app.globalData.userInfo = null;

      // 清除存储中的登录状态
      const storage = require('../../utils/storage.js');
      storage.removeItem('sessionId')
        .then(() => storage.removeItem('clientId'))
        .then(() => storage.removeItem('userData'))
        .then(() => storage.removeItem('isLoggedIn'))
        .then(() => {
          wx.showToast({
            title: '解绑成功',
            icon: 'success',
            duration: 2000
          });

          // 重置UI显示状态
          this.setData({
            userName: "请点击登录",
            userPhone: "",
            listData: []
          });
        })
        .catch(err => {
          console.error('解绑过程中出错:', err);
          wx.showToast({
            title: '解绑失败，请重试',
            icon: 'none',
            duration: 2000
          });
        });
    }).catch(error => {
      // 加载完成后隐藏加载动画
      wx.hideLoading();
      // 处理错误响应
      console.error('请求失败:', error);
      wx.showToast({
        title: '解绑失败',
        icon: 'error',
        duration: 3000
      })
    });
  },
})