优化首页和灌溉页面的样式，添加当前项目显示；重构项目配置，确保项目登录需求一致性；更新登录页面逻辑，简化项目选择和信息展示，提升用户体验。

zuoxiao

16 小时以前 6ae0924bdb44e8b1f569b6f1cdb6ff403e1d2ce3

优化首页和灌溉页面的样式，添加当前项目显示；重构项目配置，确保项目登录需求一致性；更新登录页面逻辑，简化项目选择和信息展示，提升用户体验。

 pages/home/home.js

@@ -1,1620 +1,1675 @@
// pages/home/home.js
const storage = require('../../utils/storage.js');
const {
    get,
    post
  get,
  post
} = require('../../api/request.js');
const config = require('../../api/config.js');
const {
    PROJECT_CONFIG
  PROJECT_CONFIG
} = require('../../utils/projectConfig.js');
const {
    ENV
  ENV
} = require('../../api/env.js');

Page({

    /**
     * 页面的初始数据
     */
    data: {
        sessionId: "",
        showConfirm: false,
        myItem: {},
        waterIntakeName: "",
        image: "/images/ic_head_bg.jpg",
        userPhone: "",
        userName: "请点击登录",
        scrollViewHeight: 0,
        listData: [],
        isRefreshing: false,
        isWXRefreshing: false,
        errorData: '', //错误内容
        showErrorDialog: false,
        confirmBtn: {
            content: '确认'
        },
        errorDialogTitle: "关阀错误",
        showForceConfirm: false, //是否强制开阀
        lastIntakeName: "",
        showProjectDialog: false,
        selectedProject: '',
        avatarTapCount: 0,
        isFromLogin: false,
        showTipDialog: '',
        projectConfig: PROJECT_CONFIG, // 添加项目配置到data中
        showInfoDialog: false,
        projectList: []
  /**
   * 页面的初始数据
   */
  data: {
    sessionId: "",
    showConfirm: false,
    myItem: {},
    waterIntakeName: "",
    image: "/images/ic_head_bg.jpg",
    userPhone: "",
    userName: "请点击登录",
    scrollViewHeight: 0,
    listData: [],
    isRefreshing: false,
    isWXRefreshing: false,
    errorData: '', //错误内容
    showErrorDialog: false,
    confirmBtn: {
      content: '确认'
    },
    errorDialogTitle: "关阀错误",
    showForceConfirm: false, //是否强制开阀
    lastIntakeName: "",
    showProjectDialog: false,
    selectedProject: '',
    avatarTapCount: 0,
    isFromLogin: false,
    showTipDialog: '',
    projectConfig: PROJECT_CONFIG, // 添加项目配置到data中
    showInfoDialog: false,
    projectList: []
  },

    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) => {
    //         let totalHeight = rects.reduce((sum, rect) => sum + rect.height, 0);
    //         this.setData({
    //             scrollViewHeight: totalHeight,
    //         });
    //     }).exec();
    // },
    startPullDownRefresh() {
        if (getApp().globalData.isLoggedIn) {
            if (!this.data.isWXRefreshing) {
                var self = this;
                console.log(this.data.isRefreshing);
                this.setData({
                    isRefreshing: true
                });
                this.getOpenList();
            }
        } else {
            wx.showToast({
                title: '请先登录',
                icon: 'error'
            })
        }
  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) => {
  //         let totalHeight = rects.reduce((sum, rect) => sum + rect.height, 0);
  //         this.setData({
  //             scrollViewHeight: totalHeight,
  //         });
  //     }).exec();
  // },
  startPullDownRefresh() {
    if (getApp().globalData.isLoggedIn) {
      if (!this.data.isWXRefreshing) {
        var self = this;
        console.log(this.data.isRefreshing);
        this.setData({
          isRefreshing: true
        });
        this.getOpenList();
      }
    } else {
      wx.showToast({
        title: '请先登录',
        icon: 'error'
      })
    }


    },
  },



    /**
     * 生命周期函数--监听页面加载
     */
    onLoad(options) {
        console.log('home页面onLoad开始，参数:', options);
        
        // 初始化项目列表数据
        this.initProjectList();
        
        //当开阀成功后调用刷新
        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;
        }

        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(options) {
    console.log('home页面onLoad开始，参数:', options);

    // 初始化项目列表数据
    initProjectList() {
        // 将PROJECT_CONFIG对象转换为数组，方便在视图中遍历
        const projectList = Object.entries(PROJECT_CONFIG).map(([key, config]) => ({
            key: key, // 使用key作为项目标识(JYG、MQ等)
            tag: config.tag, // 保留tag字段（原配置中已有的标识，如ym、mq等）
            displayName: config.displayName, // 显示名称
            ...config // 其他配置属性
        }));
        
        // 获取当前已选择的项目，默认为JYG
        let currentSelectedProject = 'JYG';
        
        // 尝试从全局变量获取
        const app = getApp();
        if (app && app.globalData && app.globalData.selectedProject) {
            currentSelectedProject = app.globalData.selectedProject;
        } else {
            // 尝试从本地存储获取
            try {
                const savedProject = wx.getStorageSync('selectedProject');
                if (savedProject) {
                    currentSelectedProject = savedProject;
                }
            } catch (e) {
                console.error('从本地存储获取项目失败:', e);
            }
    this.initProjectList();

    //当开阀成功后调用刷新
    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;
    }

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

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

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

  // 初始化项目列表数据
  initProjectList() {
    // 将PROJECT_CONFIG对象转换为数组，方便在视图中遍历
    const projectList = Object.entries(PROJECT_CONFIG).map(([key, config]) => ({
      key: key, // 使用key作为项目标识(JYG、MQ等)
      tag: config.tag, // 保留tag字段（原配置中已有的标识，如ym、mq等）
      displayName: config.displayName, // 显示名称
      ...config // 其他配置属性
    }));

    // 获取当前已选择的项目，默认为JYG
    let currentSelectedProject = 'JYG';

    // 尝试从全局变量获取
    const app = getApp();
    if (app && app.globalData && app.globalData.selectedProject) {
      currentSelectedProject = app.globalData.selectedProject;
    } else {
      // 尝试从本地存储获取
      try {
        const savedProject = wx.getStorageSync('selectedProject');
        if (savedProject) {
          currentSelectedProject = savedProject;
        }
        
        // 设置到页面数据中
        this.setData({ 
            projectList,
            selectedProject: currentSelectedProject
        });
        
        console.log('项目列表已初始化:', projectList, '当前选中项目:', currentSelectedProject);
    },

    // 新增的初始化页面辅助函数，分离出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 serverUrl = PROJECT_CONFIG[project]?.serverUrl;
                    if (serverUrl) {
                        getApp().globalData.baseUrl = serverUrl;
                        getApp().globalData.selectedProject = project;
                        console.log('设置baseUrl:', serverUrl);
                    }

                    // 根据项目设置对应的tag
                    const projectConfig = PROJECT_CONFIG[project];
                    if (projectConfig) {
                        getApp().globalData.tag = projectConfig.tag;
                        this.setData({
                            userName: projectConfig.displayName
                        });
                    }

                    // 根据项目设置对应的operator和clientId
                    if (projectConfig && projectConfig.operatorId) {
                        getApp().globalData.operator = projectConfig.operatorId;
                        getApp().globalData.clientId = projectConfig.operatorId;
                        getApp().globalData.isLoggedIn = true;
                        getApp().globalData.sessionId = projectConfig.operatorId;

                        // 如果有vcId，也设置
                        if (projectConfig.vcId) {
                            getApp().globalData.vcId = projectConfig.vcId;
                        }

                        // 持久化存储项目参数
                        const params = {
                            operator: projectConfig.operatorId,
                            clientId: projectConfig.operatorId,
                            isLoggedIn: true,
                            sessionId: projectConfig.operatorId
                        };

                        if (projectConfig.vcId) {
                            params.vcId = projectConfig.vcId;
                        }

                        storage.setItem(`${project}_params`, params);
                    }

                    // 继续初始化页面
                    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) {
                    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() {
        // 检查是否有options和param
        if (this.data.options && this.data.options.param) {
            if (this.data.options.param === "1" || this.data.options.param === "2") {
                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
            });
        }

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

    // 检查登录状态（仅在需要时）
    checkLoginStatusIfNeeded() {
        // 再次确认是否从登录页返回
        if (this.getFromLogin()) {
            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();
    },

    /**
     * 页面上拉触底事件的处理函数
     */
    onReachBottom() {

    },

    /**
     * 用户点击右上角分享
     */
    onShareAppMessage() {

    },
    recharge() {
        // wx.navigateTo({
        //   url: '/pages/rechargeCard/rechargeCard',
        // })
        wx.showToast({
            title: '暂未开放',
            icon: 'none'
        })
    },
    openValveList() {
      const app = getApp();
      if (app.globalData.isLoggedIn) {
          wx.navigateTo({
            url: '/pages/valveList/valveList',
          })
      } else {
          wx.showToast({
              title: '请先登录',
              icon: 'error'
          })
      } catch (e) {
        console.error('从本地存储获取项目失败:', e);
      }
    },
    feedBack() {
    }

    // 设置到页面数据中
    this.setData({
      projectList,
      selectedProject: currentSelectedProject
    });

    console.log('项目列表已初始化:', projectList, '当前选中项目:', currentSelectedProject);
  },

  // 新增的初始化页面辅助函数，分离出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 serverUrl = PROJECT_CONFIG[project]?.serverUrl;
          if (serverUrl) {
            getApp().globalData.baseUrl = serverUrl;
            getApp().globalData.selectedProject = project;
            console.log('设置baseUrl:', serverUrl);
          }

          // 根据项目设置对应的tag
          const projectConfig = PROJECT_CONFIG[project];
          if (projectConfig) {
            getApp().globalData.tag = projectConfig.tag;
            
            // 根据项目是否需要登录，设置不同的userName
            if (projectConfig.needLogin === false) {
              // 不需要登录的项目，显示项目名称
              this.setData({
                userName: projectConfig.displayName
              });
            } else {
              // 需要登录的项目，显示"请点击登录"
              this.setData({
                userName: "请点击登录"
              });
            }
          }

          // 根据项目设置对应的operator和clientId
          if (projectConfig && projectConfig.operatorId) {
            getApp().globalData.operator = projectConfig.operatorId;
            getApp().globalData.clientId = projectConfig.operatorId;
            getApp().globalData.isLoggedIn = true;
            getApp().globalData.sessionId = projectConfig.operatorId;

            // 如果有vcId，也设置
            if (projectConfig.vcId) {
              getApp().globalData.vcId = projectConfig.vcId;
            }

            // 持久化存储项目参数
            const params = {
              operator: projectConfig.operatorId,
              clientId: projectConfig.operatorId,
              isLoggedIn: true,
              sessionId: projectConfig.operatorId
            };

            if (projectConfig.vcId) {
              params.vcId = projectConfig.vcId;
            }

            storage.setItem(`${project}_params`, params);
          }

          // 继续初始化页面
          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) {
          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() {
    // 检查是否有options和param
    if (this.data.options && this.data.options.param) {
      if (this.data.options.param === "1" || this.data.options.param === "2") {
        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
      });
    }

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

  // 检查登录状态（仅在需要时）
  checkLoginStatusIfNeeded() {
    // 再次确认是否从登录页返回
    if (this.getFromLogin()) {
      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();
  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {

  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {

  },
  recharge() {
    // wx.navigateTo({
    //   url: '/pages/rechargeCard/rechargeCard',
    // })
    wx.showToast({
      title: '暂未开放',
      icon: 'none'
    })
  },
  openValveList() {
    const app = getApp();
    if (app.globalData.isLoggedIn) {
      wx.navigateTo({
        url: '/pages/valveList/valveList',
      })
    } else {
      wx.showToast({
        title: '请先登录',
        icon: 'error'
      })
    }
  },
  feedBack() {
    wx.showToast({
      title: '暂未开放',
      icon: 'none'
    })
  },
  //解绑用户
  unbind() {
    // 检查当前项目是否需要登录
    const currentProject = getApp().globalData.selectedProject;
    const projectConfig = PROJECT_CONFIG[currentProject];

    // 如果当前项目配置为不需要登录，则提示用户并打开项目选择弹窗
    if (projectConfig && !projectConfig.needLogin) {
      wx.showModal({
        title: '切换项目',
        content: '是否确定解绑？',
        confirmText: '确认',
        cancelText: '取消',
        success: (res) => {
          if (res.confirm) {
            // 显示项目选择弹窗
            this.setData({
              showProjectDialog: true
            });
          }
        }
      });
      return;
    }

    // 如果已登录，显示解绑确认对话框
    if (getApp().globalData.isLoggedIn) {
      wx.showModal({
        title: '解绑确认',
        content: '确定要解绑当前账号吗？解绑后将无法使用相关功能，需重新绑定。',
        confirmText: '确认解绑',
        confirmColor: '#e34d59',
        cancelText: '取消',
        success: (res) => {
          if (res.confirm) {
            this.unBindPost();
          }
        }
      });
    } else {
      wx.showToast({
        title: '还未绑定',
        icon: 'error'
      });
    }
  },
  //轮灌
  irrigation() {
    if (getApp().globalData.isLoggedIn) {
      wx.navigateTo({
        url: '/pages/irrigation/irrigation',
      })
    } else {
      wx.showToast({
        title: '请先登录',
        icon: 'error'
      })
    }
  },
  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();
      // 处理错误响应
      console.error('请求失败:', error);
      if (error.code === "ECONNABORTED" || error.message?.includes('timeout')) {
        // 处理超时错误
        this.setData({
          showErrorDialog: true,
          errorData: "通信超时，请稍后再试",
          errorDialogTitle: "关阀错误"
        })
      } else {
        this.setData({
          showErrorDialog: true,
          errorData: error.msg,
          errorDialogTitle: "关阀错误"
        })
      }
    });
  },
  /**
   * 获取为关阀记录
   */
  getOpenList() {
    const app = getApp();
    if (!getApp().globalData.isLoggedIn) {
      wx.showToast({
        title: '请先登录',
        icon: 'error'
      })
      this.setData({
        isRefreshing: false, // 将triggered属性设置为false，表示下拉刷新已完成
        isWXRefreshing: false, // 将triggered属性设置为false，表示下拉刷新已完成
      });
      return;
    }
    // 检查是否从登录页返回
    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，表示下拉刷新已完成
      });
      this.updateDisplayText();

    }).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: '暂未开放',
            icon: 'none'
        })
    },
    //解绑用户
    unbind() {
        // 检查当前项目是否需要登录
        const currentProject = getApp().globalData.selectedProject;
        const projectConfig = PROJECT_CONFIG[currentProject];
          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;
    }

        // 如果当前项目配置为不需要登录，则提示用户并打开项目选择弹窗
        if (projectConfig && !projectConfig.needLogin) {
            wx.showModal({
                title: '切换项目',
                content: '是否确定解绑？',
                confirmText: '确认',
                cancelText: '取消',
                success: (res) => {
                    if (res.confirm) {
                        // 显示项目选择弹窗
                        this.setData({
                            showProjectDialog: true
                        });
                    }
                }
            });
            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
          });
        }
      }
    });
  },
  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;
  },

        // 如果已登录，显示解绑确认对话框
        if (getApp().globalData.isLoggedIn) {
            wx.showModal({
                title: '解绑确认',
                content: '确定要解绑当前账号吗？解绑后将无法使用相关功能，需重新绑定。',
                confirmText: '确认解绑',
                confirmColor: '#e34d59',
                cancelText: '取消',
                success: (res) => {
                    if (res.confirm) {
                        this.unBindPost();
                    }
                }
            });
  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 {
            wx.showToast({
                title: '还未绑定',
                icon: 'error'
            });
        }
    },
    //轮灌
    irrigation() {
        if (getApp().globalData.isLoggedIn) {
            wx.navigateTo({
                url: '/pages/irrigation/irrigation',
            })
        } else {
            wx.showToast({
                title: '请先登录',
                icon: 'error'
            })
        }
    },
    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();
            // 处理错误响应
            console.error('请求失败:', error);
            if (error.code === "ECONNABORTED" || error.message?.includes('timeout')) {
                // 处理超时错误
                this.setData({
                    showErrorDialog: true,
                    errorData: "通信超时，请稍后再试",
                    errorDialogTitle: "关阀错误"
                })
            } else {
                this.setData({
                    showErrorDialog: true,
                    errorData: error.msg,
                    errorDialogTitle: "关阀错误"
                })
            }
        });
    },
    /**
     * 获取为关阀记录
     */
    getOpenList() {
        const app = getApp();
        if (!getApp().globalData.isLoggedIn) {
            wx.showToast({
                title: '请先登录',
                icon: 'error'
            })
            this.setData({
                isRefreshing: false, // 将triggered属性设置为false，表示下拉刷新已完成
                isWXRefreshing: false, // 将triggered属性设置为false，表示下拉刷新已完成
            });
            return;
        }
        // 检查是否从登录页返回
        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;
          that.postOppenValva(res.result)
        }

        console.log('getOpenList: 开始获取列表数据, clientId:', app.globalData.clientId);
      },
      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 => {

        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，表示下拉刷新已完成
            });
            this.updateDisplayText();

        }).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();
      // 处理成功响应
      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({
            lastIntakeName: intakeName
          showForceConfirm: true
        })
        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 => {
      } else {
        that.setData({
          showErrorDialog: true,
          errorData: error.msg,
          errorDialogTitle: "开阀错误"
        })
      }
    });
  },
  /**
   * 扫描后保存用户id和tag
   */
  saveData(userData) {
    storage.setItem("userData", userData).then(() => {
      this.initData();
    }).catch((error) => {});

            // 处理成功响应
            console.log('请求成功:', response);
            // 加载完成后隐藏加载动画
            wx.hideLoading();
            //完成后回到首页
            wx.reLaunch({
                url: '/pages/home/home?param=true' // 首页的路径，根据实际情况填写
  },
  //进入界面获取界面数据
  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: []
            });
        }).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) => { });
          });
      } else {
        this.getOpenList();
      }
      return;
    }

    },
    //进入界面获取界面数据
    initData() {
        const app = getApp();
        console.log("initData开始，tag:", app.globalData.tag);
    // 检查当前项目是否需要登录
    const currentProject = app.globalData.selectedProject;
    const projectConfig = PROJECT_CONFIG[currentProject];
    const needLogin = projectConfig && projectConfig.needLogin;

        // 首先检查是否从登录页返回
        if (this.getFromLogin()) {
            console.log('initData: 检测到从登录页返回的标记，仅获取基本数据');
    // 根据项目是否需要登录，设置不同的userName
    if (projectConfig && projectConfig.needLogin === false) {
      // 不需要登录的项目，显示项目名称
      this.setData({
        userName: projectConfig.displayName
      });
    }

            // 即使从登录页返回，也尝试获取开阀列表以显示基本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获取数据');

        // 只有需要登录的项目才调用getUserDataBySession
        if (needLogin) {
          console.log('initData: 当前项目需要登录，获取用户数据');
          this.getUserDataBySession();
        } else {
          console.log('initData: 当前项目不需要登录，跳过获取用户数据');
        }

        // 检查当前项目是否需要登录
        const currentProject = app.globalData.selectedProject;
        const projectConfig = PROJECT_CONFIG[currentProject];
        const needLogin = projectConfig && projectConfig.needLogin;
        this.getOpenList();
        return;
      }

        // 尝试获取用户数据和已开阀记录
        try {
            // 优先检查全局变量中是否有sessionId
            if (app.globalData.sessionId) {
                console.log('initData: 使用全局sessionId获取数据');
      // 检查是否有存储的userData
      const hasUserData = storage.isHasKeySync("userData");
      console.log('initData: 是否存在userData:', hasUserData);

                // 只有需要登录的项目才调用getUserDataBySession
                if (needLogin) {
                    console.log('initData: 当前项目需要登录，获取用户数据');
                    this.getUserDataBySession();
                } else {
                    console.log('initData: 当前项目不需要登录，跳过获取用户数据');
                }

                this.getOpenList();
                return;
      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);
              }
            }

            // 检查是否有存储的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);
                            }
                        }

                        // 只有需要登录的项目才调用getUserDataBySession
                        if (needLogin) {
                            console.log('initData: 当前项目需要登录，获取用户数据');
                            this.getUserDataBySession();
                        } else {
                            console.log('initData: 当前项目不需要登录，跳过获取用户数据');
                        }

                        this.getOpenList();
                    })
                    .catch((err) => {
                        console.error('加载userData失败:', err);

                        // 再次检查是否从登录页返回
                        if (this.getFromLogin()) {
                            console.log('initData:catch: 检测到从登录页返回的标记，只获取开阀列表');
                            this.getOpenList();
                        } else {
                            // 只有需要登录的项目才调用getUserDataBySession
                            if (needLogin) {
                                console.log('initData:catch: 当前项目需要登录，获取用户数据');
                                this.getUserDataBySession();
                            } else {
                                console.log('initData:catch: 当前项目不需要登录，跳过获取用户数据');
                            }

                            this.getOpenList();
                        }
                    });
            // 只有需要登录的项目才调用getUserDataBySession
            if (needLogin) {
              console.log('initData: 当前项目需要登录，获取用户数据');
              this.getUserDataBySession();
            } else {
                console.log('未找到userData，直接获取数据');

                // 再次检查是否从登录页返回
                if (this.getFromLogin()) {
                    console.log('initData:else: 检测到从登录页返回的标记，只获取开阀列表');
                    this.getOpenList();
                } else {
                    // 只有需要登录的项目才调用getUserDataBySession
                    if (needLogin) {
                        console.log('initData:else: 当前项目需要登录，获取用户数据');
                        this.getUserDataBySession();
                    } else {
                        console.log('initData:else: 当前项目不需要登录，跳过获取用户数据');
                    }

                    this.getOpenList();
                }
              console.log('initData: 当前项目不需要登录，跳过获取用户数据');
            }
        } catch (e) {
            console.error('initData执行出错:', e);

            this.getOpenList();
          })
          .catch((err) => {
            console.error('加载userData失败:', err);

            // 再次检查是否从登录页返回
            if (this.getFromLogin()) {
                console.log('initData:error: 检测到从登录页返回的标记，只获取开阀列表');
                this.getOpenList();
              console.log('initData:catch: 检测到从登录页返回的标记，只获取开阀列表');
              this.getOpenList();
            } else {
                // 只有需要登录的项目才调用getUserDataBySession
                if (needLogin) {
                    console.log('initData:error: 当前项目需要登录，获取用户数据');
                    this.getUserDataBySession();
                } else {
                    console.log('initData:error: 当前项目不需要登录，跳过获取用户数据');
                }
              // 只有需要登录的项目才调用getUserDataBySession
              if (needLogin) {
                console.log('initData:catch: 当前项目需要登录，获取用户数据');
                this.getUserDataBySession();
              } else {
                console.log('initData:catch: 当前项目不需要登录，跳过获取用户数据');
              }

                this.getOpenList();
              this.getOpenList();
            }
        }
    },
    // 处理头像点击
    handleAvatarTap() {
        this.setData({
            avatarTapCount: this.data.avatarTapCount + 1
        });
          });
      } else {
        console.log('未找到userData，直接获取数据');

        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() {
        console.log('开始处理项目选择确认', this.data.selectedProject, this.data.projectList);
        
        if (!this.data.selectedProject) {
            wx.showToast({
                title: '请选择项目',
                icon: 'none'
            });
            return;
        }

        // 获取当前已选项目和新选择的项目
        const currentProject = getApp().globalData.selectedProject;
        const newProject = this.data.selectedProject;
        console.log('当前项目:', currentProject, '新选择项目:', newProject);
        console.log('PROJECT_CONFIG 内容:', PROJECT_CONFIG);
        
        const projectConfig = PROJECT_CONFIG[newProject];
        console.log('选择的项目配置:', projectConfig);

        if (!projectConfig) {
            wx.showToast({
                title: '项目配置错误',
                icon: 'none'
            });
            return;
        }

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

        // 添加二次确认
        const confirmText = isProjectChanged 
            ? `确定要将项目从"${PROJECT_CONFIG[currentProject]?.displayName || '当前项目'}"切换到"${projectConfig.displayName}"吗？`
            : `确定选择"${projectConfig.displayName}"项目吗？`;
            
        wx.showModal({
            title: isProjectChanged ? '确认切换项目' : '确认选择项目',
            content: confirmText,
            confirmText: isProjectChanged ? '确认切换' : '确认',
            cancelText: '取消',
            success: (res) => {
                if (res.confirm) {
                    // 用户确认选择，继续处理
                    this.processProjectSelection(currentProject, newProject, projectConfig, isProjectChanged);
                } else {
                    // 用户取消，不进行任何操作
                    console.log('用户取消了项目选择');
                }
            }
        });
    },

    // 处理项目选择的后续操作
    processProjectSelection(currentProject, newProject, projectConfig, isProjectChanged) {
        // 如果切换了项目，先清除登录状态
        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(() => {
            // 调用setBaseUrl来更新基础URL
            try {
                console.log('尝试设置基础URL，项目:', newProject);
                const result = config.setBaseUrl(newProject);
                console.log('设置基础URL结果:', result);
            } catch (error) {
                console.error('设置基础URL出错:', error);
                // 继续执行，不中断流程
            }
            
            // 更新全局变量
            getApp().globalData = getApp().globalData || {};
            getApp().globalData.selectedProject = newProject;
            getApp().globalData.baseUrl = projectConfig.serverUrl;
            getApp().globalData.serverId = projectConfig.serverId;

            // 通过配置对象统一设置项目参数
            getApp().globalData.tag = projectConfig.tag;

            // 设置用户界面显示的项目名称
            this.setData({
                userName: projectConfig.displayName
            });

            // 对于不需要登录的项目，直接设置operator和clientId
            if (!projectConfig.needLogin && projectConfig.operatorId) {
                const operatorId = projectConfig.operatorId;
                getApp().globalData.operator = operatorId;
                getApp().globalData.clientId = operatorId;
                getApp().globalData.isLoggedIn = true;
                getApp().globalData.sessionId = operatorId;

                // 如果有vcId，也设置
                if (projectConfig.vcId) {
                    getApp().globalData.vcId = projectConfig.vcId;
                }

                // 持久化存储项目参数
                const params = {
                    operator: operatorId,
                    clientId: operatorId,
                    isLoggedIn: true,
                    sessionId: operatorId
                };

                if (projectConfig.vcId) {
                    params.vcId = projectConfig.vcId;
                }

                storage.setItem(`${newProject}_params`, params);
            }

            console.log('已切换到项目:', projectConfig.displayName, '服务器:', projectConfig.serverId, 'tag:', getApp().globalData.tag);

            this.setData({
                showProjectDialog: false
            });

            // 显示切换成功提示
            wx.showToast({
                title: `已选择${projectConfig.displayName}`,
                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();

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

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

        // 检查当前项目是否需要登录
        const currentProject = app.globalData.selectedProject;
        if (currentProject && PROJECT_CONFIG[currentProject] && !PROJECT_CONFIG[currentProject].needLogin) {
            console.log('当前项目不需要登录:', currentProject);
            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]) => {
                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;
                    }

                    // 检查项目是否需要登录
                    if (currentProject && PROJECT_CONFIG[currentProject] && !PROJECT_CONFIG[currentProject].needLogin) {
                        console.log('最终检查: 当前项目不需要登录:', currentProject);
                        return;
                    }

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

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

                    // wx.navigateTo({
                    //   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;
                }

                // 检查项目是否需要登录
                if (currentProject && PROJECT_CONFIG[currentProject] && !PROJECT_CONFIG[currentProject].needLogin) {
                    console.log('错误处理: 当前项目不需要登录:', currentProject);
                    return;
                }

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

    // 辅助函数：检查是否从登录页返回
    getFromLogin() {
        // 检查当前页面的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;
        }
        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
            });
        }

        // 从页面数据中检查
        if (this.data.isFromLogin) {
            console.log('continueInitPage: 从页面数据中检测到isFromLogin=true');
            fromLogin = true;
        }
        // 当开阀成功后调用刷新
        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 (!getApp().globalData.isLoggedIn) {
                    console.log('延迟检查：未登录且不是从登录页返回，执行登录状态检查');
                    this.checkLoginStatus();
                }
            }, 500);
        // 再次检查是否从登录页返回
        if (this.getFromLogin()) {
          console.log('initData:else: 检测到从登录页返回的标记，只获取开阀列表');
          this.getOpenList();
        } else {
            console.log('从登录页返回，不检查登录状态');
        }
    },
          // 只有需要登录的项目才调用getUserDataBySession
          if (needLogin) {
            console.log('initData:else: 当前项目需要登录，获取用户数据');
            this.getUserDataBySession();
          } else {
            console.log('initData:else: 当前项目不需要登录，跳过获取用户数据');
          }

    // 微信登录
    wxLogin() {
        // 检查当前项目是否需要登录
        const currentProject = getApp().globalData.selectedProject;
        if (currentProject && PROJECT_CONFIG[currentProject] && !PROJECT_CONFIG[currentProject].needLogin) {
            console.log('wxLogin: 当前项目不需要登录:', currentProject);
          this.getOpenList();
        }
      }
    } catch (e) {
      console.error('initData执行出错:', e);

      // 再次检查是否从登录页返回
      if (this.getFromLogin()) {
        console.log('initData:error: 检测到从登录页返回的标记，只获取开阀列表');
        this.getOpenList();
      } else {
        // 只有需要登录的项目才调用getUserDataBySession
        if (needLogin) {
          console.log('initData:error: 当前项目需要登录，获取用户数据');
          this.getUserDataBySession();
        } else {
          console.log('initData:error: 当前项目不需要登录，跳过获取用户数据');
        }

        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() {
    console.log('开始处理项目选择确认', this.data.selectedProject, this.data.projectList);

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

    // 获取当前已选项目和新选择的项目
    const currentProject = getApp().globalData.selectedProject;
    const newProject = this.data.selectedProject;
    console.log('当前项目:', currentProject, '新选择项目:', newProject);
    console.log('PROJECT_CONFIG 内容:', PROJECT_CONFIG);

    const projectConfig = PROJECT_CONFIG[newProject];
    console.log('选择的项目配置:', projectConfig);

    if (!projectConfig) {
      wx.showToast({
        title: '项目配置错误',
        icon: 'none'
      });
      return;
    }

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

    // 添加二次确认
    const confirmText = isProjectChanged ?
      `确定要将项目从"${PROJECT_CONFIG[currentProject]?.displayName || '当前项目'}"切换到"${projectConfig.displayName}"吗？` :
      `确定选择"${projectConfig.displayName}"项目吗？`;

    wx.showModal({
      title: isProjectChanged ? '确认切换项目' : '确认选择项目',
      content: confirmText,
      confirmText: isProjectChanged ? '确认切换' : '确认',
      cancelText: '取消',
      success: (res) => {
        if (res.confirm) {
          // 用户确认选择，继续处理
          this.processProjectSelection(currentProject, newProject, projectConfig, isProjectChanged);
        } else {
          // 用户取消，不进行任何操作
          console.log('用户取消了项目选择');
        }
      }
    });
  },

  // 处理项目选择的后续操作
  processProjectSelection(currentProject, newProject, projectConfig, isProjectChanged) {
    // 如果切换了项目，先清除登录状态
    if (isProjectChanged) {
      console.log(`正在从项目 ${currentProject} 切换到 ${newProject}，将清除登录状态`);

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

      // 清除存储中的登录状态
      try {
        // 清除基本登录数据
        wx.removeStorageSync('sessionId');
        wx.removeStorageSync('clientId');
        wx.removeStorageSync('userData');
        wx.removeStorageSync('isLoggedIn');

        // 清除之前项目的特定数据
        if (currentProject) {
          wx.removeStorageSync(`${currentProject}_params`);
        }

        // 清除其他可能的缓存数据
        wx.removeStorageSync('_attempted_login_redirect');

        console.log('已清除登录相关的存储数据');
      } catch (e) {
        console.error('清除存储数据失败:', e);
      }

      // 重置UI显示状态
      if (projectConfig.needLogin === false) {
        // 不需要登录的项目，显示项目名称作为userName
        this.setData({
          userName: projectConfig.displayName,
          userPhone: "",
          listData: []
        });
      } else {
        // 需要登录的项目，显示"请点击登录"
        this.setData({
          userName: "请点击登录",
          userPhone: "",
          listData: []
        });
      }
    }

    // 保存项目选择到本地存储
    storage.setItem('selectedProject', newProject).then(() => {
      // 调用setBaseUrl来更新基础URL
      try {
        console.log('尝试设置基础URL，项目:', newProject);
        const result = config.setBaseUrl(newProject);
        console.log('设置基础URL结果:', result);
      } catch (error) {
        console.error('设置基础URL出错:', error);
        // 继续执行，不中断流程
      }

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

      // 通过配置对象统一设置项目参数
      getApp().globalData.tag = projectConfig.tag;

      // 对于不需要登录的项目，直接设置operator和clientId
      if (!projectConfig.needLogin && projectConfig.operatorId) {
        const operatorId = projectConfig.operatorId;
        getApp().globalData.operator = operatorId;
        getApp().globalData.clientId = operatorId;
        getApp().globalData.isLoggedIn = true;
        getApp().globalData.sessionId = operatorId;

        // 如果有vcId，也设置
        if (projectConfig.vcId) {
          getApp().globalData.vcId = projectConfig.vcId;
        }

        // 持久化存储项目参数
        const params = {
          operator: operatorId,
          clientId: operatorId,
          isLoggedIn: true,
          sessionId: operatorId
        };

        if (projectConfig.vcId) {
          params.vcId = projectConfig.vcId;
        }

        storage.setItem(`${newProject}_params`, params);
      }

      console.log('已切换到项目:', projectConfig.displayName, '服务器:', projectConfig.serverId, 'tag:', getApp().globalData.tag);

      this.setData({
        showProjectDialog: false
      });

      // 显示切换成功提示
      wx.showToast({
        title: `已选择${projectConfig.displayName}`,
        icon: 'success',
        duration: 2000
      });
      setTimeout(() => {
        console.log('项目已切换，正在初始化数据');
        // 确保显示正确的用户名
        if (!projectConfig.needLogin) {
          this.setData({
            userName: projectConfig.displayName
          });
        } else {
          this.setData({
            userName: "请点击登录"
          });
        }
        this.initData();
      }, 1000);

    }).catch(err => {
      console.error('保存项目选择失败：', err);
      wx.showToast({
        title: '保存失败，请重试',
        icon: 'none',
        duration: 2000
      });
    });
  },

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

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

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

    // 检查当前项目是否需要登录
    const currentProject = app.globalData.selectedProject;
    if (currentProject && PROJECT_CONFIG[currentProject] && !PROJECT_CONFIG[currentProject].needLogin) {
      console.log('当前项目不需要登录:', currentProject);
      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]) => {
        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;
          }

          // 检查项目是否需要登录
          if (currentProject && PROJECT_CONFIG[currentProject] && !PROJECT_CONFIG[currentProject].needLogin) {
            console.log('最终检查: 当前项目不需要登录:', currentProject);
            return;
          }

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

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

          // wx.navigateTo({
          //   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;
        }

        // 检查项目是否需要登录
        if (currentProject && PROJECT_CONFIG[currentProject] && !PROJECT_CONFIG[currentProject].needLogin) {
          console.log('错误处理: 当前项目不需要登录:', currentProject);
          return;
        }

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

  // 辅助函数：检查是否从登录页返回
  getFromLogin() {
    // 检查当前页面的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;
    }
    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
      });
    }

    // 从页面数据中检查
    if (this.data.isFromLogin) {
      console.log('continueInitPage: 从页面数据中检测到isFromLogin=true');
      fromLogin = true;
    }
    // 当开阀成功后调用刷新
    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 (!getApp().globalData.isLoggedIn) {
            wx.showLoading({
                title: '正在登录请稍候...',
                mask: true
            });
          console.log('延迟检查：未登录且不是从登录页返回，执行登录状态检查');
          this.checkLoginStatus();
        }
      }, 500);
    } else {
      console.log('从登录页返回，不检查登录状态');
    }
  },

            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.navigateTo({
                                    //   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;
  // 微信登录
  wxLogin() {
    // 检查当前项目是否需要登录
    const currentProject = getApp().globalData.selectedProject;
    if (currentProject && PROJECT_CONFIG[currentProject]) {
      const projectConfig = PROJECT_CONFIG[currentProject];
      
      if (!projectConfig.needLogin) {
        console.log('wxLogin: 当前项目不需要登录:', currentProject);
        // 不需要登录的项目，显示项目名称
        this.setData({
          userName: projectConfig.displayName
        });
        return;
      }
    }

                                    // 设置全局变量
                                    getApp().globalData.sessionId = sessionId;
                                    getApp().globalData.clientId = clientId;
                                    getApp().globalData.isLoggedIn = true;
    if (!getApp().globalData.isLoggedIn) {
      wx.showLoading({
        title: '正在登录请稍候...',
        mask: true
      });

                                    // 设置正确的项目tag
                                    const projectConfig = PROJECT_CONFIG[this.data.selectedProject];
                                    if (projectConfig) {
                                        getApp().globalData.tag = projectConfig.tag;
                                    }
      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 === "") {
                  // 未绑定账号，跳转到登录页面并传递当前项目信息
                  const projectInfo = PROJECT_CONFIG[this.data.selectedProject];
                  wx.navigateTo({
                    url: `/pages/login/login?project=${this.data.selectedProject}&projectName=${projectInfo.displayName}`
                  });
                } 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;

                                    // 保存到存储
                                    storage.setItem("sessionId", sessionId);
                                    storage.setItem("clientId", clientId);
                                    storage.setItem("isLoggedIn", "true");
                  // 设置全局变量
                  getApp().globalData.sessionId = sessionId;
                  getApp().globalData.clientId = clientId;
                  getApp().globalData.isLoggedIn = true;

                                    // 保存userData信息，包含sessionId和tag
                                    const userData = JSON.stringify({
                                        sessionId: sessionId,
                                        tag: projectConfig ? projectConfig.tag : 'ym',
                                        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:', projectConfig ? projectConfig.tag : 'ym');
                                            this.initData();
                                        })
                                        .catch(err => {
                                            console.warn('保存userData失败，但继续初始化:', err);
                                            this.initData();
                                        });
                  // 设置正确的项目tag
                  const projectConfig = PROJECT_CONFIG[this.data.selectedProject];
                  if (projectConfig) {
                    getApp().globalData.tag = projectConfig.tag;
                  }

                                }
                            } else {
                                wx.showToast({
                                    title: '登录失败',
                                    icon: 'error',
                                    duration: 2000
                                });
                                // wx.navigateTo({
                                //   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'
                  // 保存到存储
                  storage.setItem("sessionId", sessionId);
                  storage.setItem("clientId", clientId);
                  storage.setItem("isLoggedIn", "true");

                  // 保存userData信息，包含sessionId和tag
                  const userData = JSON.stringify({
                    sessionId: sessionId,
                    tag: projectConfig ? projectConfig.tag : 'ym',
                    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:', projectConfig ? projectConfig.tag : 'ym');
                      this.initData();
                    })
                    .catch(err => {
                      console.warn('保存userData失败，但继续初始化:', err);
                      this.initData();
                    });

                }
              } else if (response.code === "1003") {
                // 未绑定账号，跳转到登录页面并传递当前项目信息
                const projectInfo = PROJECT_CONFIG[this.data.selectedProject];
                wx.navigateTo({
                  url: `/pages/login/login?project=${this.data.selectedProject}&projectName=${projectInfo.displayName}`
                });
              } else {
                wx.showToast({
                  title: '登录失败',
                  icon: 'error',
                  duration: 2000
                });
              }
            }).catch(error => {
              wx.hideLoading();
              console.error('登录请求失败:', error);
              if(error.code==="1003"){
                // 未绑定账号，跳转到登录页面并传递当前项目信息
                const projectInfo = PROJECT_CONFIG[this.data.selectedProject];
                wx.navigateTo({
                  url: `/pages/login/login?project=${this.data.selectedProject}&projectName=${projectInfo.displayName}`
                });
              }else{
                wx.showToast({
                  title: '登录失败，请重试',
                  icon: 'none'
                });
              }
            });
        }
    },

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


            // 重设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);
            // 加载完成后隐藏加载动画
          } else {
            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);
            console.log('登录失败！' + res.errMsg);
            wx.showToast({
                title: '解绑失败',
                icon: 'error',
                duration: 3000
            })
              title: '微信登录失败',
              icon: 'none'
            });
          }
        },
        fail: (err) => {
          wx.hideLoading();
          console.error('微信登录API调用失败:', err);
          wx.showToast({
            title: '登录失败，请重试',
            icon: 'none'
          });
        }
      });
    }
  },

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


      // 重设isFromLogin为false，但添加延迟，避免影响当前页面的返回逻辑
      setTimeout(() => {
        this.setData({
          isFromLogin: false
        });
    },
    onShareAppMessage: function (options) {
        // 设置分享内容
        return {
            title: '大禹灌溉助手', // 分享标题
            path: '/pages/home/home', // 分享路径，该路径需要是当前小程序存在的页面路径
            imageUrl: '/images/logo2.jpg', // 分享图标，可以是网络图片路径或本地图片路径
            success: function (res) {
                // 分享成功的回调函数
            },
            fail: function (res) {
                // 分享失败的回调函数
            }
        };
    },
    //点击提示按钮
    infoShow() {
        this.setData({
            showInfoDialog: true
        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: []
          });
        })
    },
    //提示窗确认按钮
    confirmBtnInfoDialog() {
        this.setData({
            showInfoDialog: false
        })
    },
        .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
      })
    });
  },
  onShareAppMessage: function (options) {
    // 设置分享内容
    return {
      title: '大禹灌溉助手', // 分享标题
      path: '/pages/home/home', // 分享路径，该路径需要是当前小程序存在的页面路径
      imageUrl: '/images/logo2.jpg', // 分享图标，可以是网络图片路径或本地图片路径
      success: function (res) {
        // 分享成功的回调函数
      },
      fail: function (res) {
        // 分享失败的回调函数
      }
    };
  },
  //点击提示按钮
  infoShow() {
    this.setData({
      showInfoDialog: true
    })
  },
  //提示窗确认按钮
  confirmBtnInfoDialog() {
    this.setData({
      showInfoDialog: false
    })
  },
  //强制删除
  onDelete(e) {
    const item = e.currentTarget.dataset.item;
    const that = this;
    

    if (this.data.useTestData) {
      // 测试数据模式下，模拟删除操作
      wx.showLoading({
        title: '正在强制删除请稍候...', 
        mask: true 
        title: '正在强制删除请稍候...',
        mask: true
      });
      

      // 模拟请求延迟
      setTimeout(() => {
        wx.hideLoading();
        

        // 从列表中移除被删除的项
        const updatedList = this.data.listData.filter(listItem => 
        const updatedList = this.data.listData.filter(listItem =>
          listItem.orderNo !== item.orderNo
        );
        

        this.setData({
          listData: updatedList
        });
        

        wx.showToast({
          title: '删除成功',
          icon: 'success',
@@ -1623,7 +1678,7 @@
      }, 1500);
      return;
    }
    

    wx.showLoading({
      title: '正在强制删除请稍候...', // 加载提示文字
      mask: true // 是否显示透明蒙层，防止触摸穿透，默认为 false
@@ -1666,7 +1721,7 @@
      } else {
        time = this.extractTime(item.dt)
      }
      if (item.waterInstant===null) {
      if (item.waterInstant === null) {
        item.waterInstant = "暂无"
      }

@@ -1682,62 +1737,62 @@
      listData: updatedList
    });
  },
    //处理时间去掉年月日
    extractTime(datetimeString) {
      const formattedDate = datetimeString.replace(" ", "T");
      const date = new Date(formattedDate);
      // 获取小时、分钟和秒
      const hours = date.getHours().toString().padStart(2, '0');
      const minutes = date.getMinutes().toString().padStart(2, '0');
      const seconds = date.getSeconds().toString().padStart(2, '0');
      return `${hours}:${minutes}:${seconds}`;
    },
  
    // 切换项目
    switchProject(e) {
        const project = e.currentTarget.dataset.project;
        
        if (config.setBaseUrl(project)) {
            this.setData({
                selectedProject: project
            });
            
            // 保存选择到本地存储
            try {
                wx.setStorageSync('selectedProject', project);
            } catch (e) {
                console.error('保存项目选择失败:', e);
  //处理时间去掉年月日
  extractTime(datetimeString) {
    const formattedDate = datetimeString.replace(" ", "T");
    const date = new Date(formattedDate);
    // 获取小时、分钟和秒
    const hours = date.getHours().toString().padStart(2, '0');
    const minutes = date.getMinutes().toString().padStart(2, '0');
    const seconds = date.getSeconds().toString().padStart(2, '0');
    return `${hours}:${minutes}:${seconds}`;
  },

  // 切换项目
  switchProject(e) {
    const project = e.currentTarget.dataset.project;

    if (config.setBaseUrl(project)) {
      this.setData({
        selectedProject: project
      });

      // 保存选择到本地存储
      try {
        wx.setStorageSync('selectedProject', project);
      } catch (e) {
        console.error('保存项目选择失败:', e);
      }

      // 更新全局变量
      const app = getApp();
      if (app && app.globalData) {
        app.globalData.selectedProject = project;

        // 根据项目配置设置相关参数
        const projectConfig = PROJECT_CONFIG[project];
        if (projectConfig) {
          app.globalData.tag = projectConfig.tag;
          if (!projectConfig.needLogin) {
            app.globalData.operator = projectConfig.operatorId;
            app.globalData.clientId = projectConfig.operatorId;
            app.globalData.isLoggedIn = true;
            app.globalData.sessionId = projectConfig.operatorId;
            // 如果有vcId，也设置
            if (projectConfig.vcId) {
              app.globalData.vcId = projectConfig.vcId;
            }
            
            // 更新全局变量
            const app = getApp();
            if (app && app.globalData) {
                app.globalData.selectedProject = project;
                
                // 根据项目配置设置相关参数
                const projectConfig = PROJECT_CONFIG[project];
                if (projectConfig) {
                    app.globalData.tag = projectConfig.tag;
                    if (!projectConfig.needLogin) {
                        app.globalData.operator = projectConfig.operatorId;
                        app.globalData.clientId = projectConfig.operatorId;
                        app.globalData.isLoggedIn = true;
                        app.globalData.sessionId = projectConfig.operatorId;
                        // 如果有vcId，也设置
                        if (projectConfig.vcId) {
                            app.globalData.vcId = projectConfig.vcId;
                        }
                    }
                }
            }
            
            // 重新加载页面数据
            this.initData();
        } else {
            wx.showToast({
                title: '切换项目失败',
                icon: 'none'
            });
          }
        }
    },
      }

      // 重新加载页面数据
      this.initData();
    } else {
      wx.showToast({
        title: '切换项目失败',
        icon: 'none'
      });
    }
  },
})

 pages/home/home.wxml

@@ -3,7 +3,13 @@

  <view class="head-wrapper">
    <view class="head-top">
      <t-avatar class="avatar-example" image="{{image}}" size="120rpx" bind:tap="handleAvatarTap" />
      <view class="avatar-project-container">
       
        <t-avatar class="avatar-example" image="{{image}}" size="120rpx" bind:tap="handleAvatarTap" />
         <view class="current-project">
          <text>{{ projectConfig[selectedProject].displayName }}</text>
        </view>
      </view>
      <view class="head-text-wrapper">
        <text bind:tap="wxLogin">{{userName}}</text>
        <text class="head-bottom">{{userPhone}}</text>

 pages/home/home.wxss

@@ -38,6 +38,7 @@
    align-items: left;
    justify-content: center;
    margin-left: 15rpx;
    margin-bottom: 70rpx;
}

.head-button-wrapper {
@@ -752,4 +753,44 @@
    font-size: 32rpx;
    color: #888;
  }
  
.current-project {
  display: flex;
  flex-direction: column;
  justify-content: center;
  margin-left: 20rpx;
  margin-right: 10rpx;
  margin-top: 10rpx;
}

.current-project text {
  font-size: 28rpx;
  color: #ffffff;
  font-weight: bold;
  background-color: rgba(255, 255, 255, 0.2);
  border-radius: 15rpx;
  padding: 6rpx 14rpx;
}

.avatar-project-container {
  display: flex;
  flex-direction: column;
  align-items: center;
  justify-content: center;
}

.current-project {
  display: flex;
  justify-content: center;
  margin-bottom: 10rpx;
}

.current-project text {
  font-size: 28rpx;
  color: #ffffff;
  font-weight: bold;
  background-color: rgba(255, 255, 255, 0.2);
  border-radius: 15rpx;
  padding: 6rpx 14rpx;
}
  

 pages/irrigation/irrigation.js

@@ -347,7 +347,8 @@
              planId: id,
              operatorId: app.globalData.clientId
            },
            isShowLoding: true
            isShowLoding: true,
            timeout: 180000
          }).then(res => {
            if (res.success) {
              wx.showToast({
@@ -449,7 +450,8 @@
          planId: planID,
          operatorId: app.globalData.clientId
        },
        isShowLoding: true
        isShowLoding: true,
        timeout: 180000
      }).then(res => {
        if (res.success) {
          wx.showToast({

 pages/login/login.js

@@ -185,12 +185,11 @@
      manualNavigate: false // 标记是否是通过编程方式导航的
    });
    
    // 获取选择的项目 - 优先使用URL参数
    // 从URL参数获取项目信息
    if (options && options.project) {
      const project = options.project;
      const projectName = project === 'JYG' ? '嘉峪关项目' : 
                         project === 'MQ' ? '民勤项目' : 
                         project === 'TEST' ? '测试项目' : '未知项目';
      // 直接使用传入的项目名称，不再手动转换
      const projectName = options.projectName || '默认项目';
      
      console.log(`从URL参数获取项目信息: ${project} (${projectName})`);
      
@@ -218,30 +217,8 @@
          console.error('设置baseUrl失败:', e);
        }
      }
      
      // 保存项目选择到本地存储，确保项目信息一致
      storage.setItem('selectedProject', project)
        .then(() => console.log('成功保存项目选择到存储'))
        .catch(err => console.error('保存项目选择到存储失败:', err));
    } else {
      // 从本地存储获取已选择的项目
      storage.getItemSafe('selectedProject').then(project => {
        if (project) {
          const projectName = project === 'JYG' ? '嘉峪关项目' : 
                            project === 'MQ' ? '民勤项目' : 
                            project === 'TEST' ? '测试项目' : '未知项目';
          console.log(`从存储获取项目信息: ${project} (${projectName})`);
          
          this.setData({
            selectedProject: project,
            projectName: projectName
          });
        } else {
          console.log('未找到已选择的项目，使用默认项目');
        }
      }).catch(err => {
        console.error('获取已选择项目失败:', err);
      });
      console.log('未从URL获取到项目信息，使用默认值');
    }
  },

@@ -327,41 +304,9 @@
    }
  },
  
  // 备用的返回首页方法
  backupReturnToHome() {
    console.log('使用备用方法返回首页');
  
    
    // 尝试使用switchTab（如果首页在tabBar中）
    const useReLaunch = () => {
      console.log('使用reLaunch返回首页');
      wx.reLaunch({
        url: '/pages/home/home?fromLogin=true',
        success: () => console.log('reLaunch成功返回首页'),
        fail: (err) => {
          console.error('reLaunch返回首页失败:', err);
          // 最后的备用方案：使用redirectTo
          setTimeout(() => {
            console.log('延迟使用redirectTo尝试返回首页');
            wx.redirectTo({
              url: '/pages/home/home?fromLogin=true',
              success: () => console.log('redirectTo成功返回首页'),
              fail: (err) => console.error('所有返回方法都失败:', err)
            });
          }, 100);
        }
      });
    };
    
    // 先尝试使用switchTab（某些版本可能将首页设置为tabBar）
    wx.switchTab({
      url: '/pages/home/home',
      success: () => console.log('switchTab成功返回首页'),
      fail: (err) => {
        console.log('switchTab失败（可能首页不在tabBar中）:', err);
        useReLaunch();
      }
    });
  },


  /**
   * 页面相关事件处理函数--监听用户下拉动作
@@ -469,11 +414,6 @@
        getApp().globalData.clientId = String(data.content.clientId);
        storage.setItem("clientId", String(data.content.clientId));
        
        // 设置当前项目的tag
        const tag = this.data.selectedProject === 'JYG' ? 'ym' : 
                   this.data.selectedProject === 'MQ' ? 'mq' : 
                   this.data.selectedProject === 'TEST' ? 'test' : 'unknown';
        getApp().globalData.tag = tag;
        
        // 保存用户信息
        const userInfo = {
@@ -481,8 +421,7 @@
          clientId: String(data.content.clientId),
          phone: this.data.phone,
          token: data.content.token || '',
          project: this.data.selectedProject,
          tag: tag
          project: this.data.selectedProject
        };
        
        // 保存到全局变量
@@ -554,7 +493,7 @@
          wx.redirectTo({
            url: '/pages/home/home'
          });
        }, 1500);
        });
      }
    });
  },

 pages/login/login.wxml

@@ -25,7 +25,7 @@
    </view>
  </view>
  
  <view class="project-info {{selectedProject === 'MQ' ? 'mq' : 'jyg'}}">
  <view class="project-info">
    <text>当前项目: {{projectName}}</text>
  </view>


 pages/waterIntake/waterIntake.js

@@ -238,14 +238,14 @@
          isRefreshing_all: false
        });
        if (data.success && data.code === "0001") {
          if (!data.content) {
          if (!data.content || data.content.itemTotal === 0 || !data.content.obj || data.content.obj.length === 0) {
            wx.showToast({
              title: '没有搜索到取水口',
              icon: 'error',
            })
          } else {
            this.setData({
              allWaterPoints: [data.content]
              allWaterPoints: data.content.obj
            });
          }


 utils/projectConfig.js

@@ -31,9 +31,8 @@
  TEST: {
    tag: 'ym',
    displayName: '测试项目',
    operatorId: '2024122617295800009', // 统一ID用于operator和clientId
    vcId: '2024122617295800009',
    needLogin: false, // 不需要登录
    operatorId: '', // 统一ID用于operator和clientId
    needLogin: true, // 需要登录
    serverId: '166',
    get serverUrl() {
      return SERVER_INFO.URL_166;
@@ -42,8 +41,8 @@
  JC: {
    tag: 'jc',
    displayName: '金昌项目',
    operatorId: '2025041710412400006', // 统一ID用于operator和clientId
    needLogin: false, // 不需要登录
    operatorId: '', // 统一ID用于operator和clientId 2025041710412400006
    needLogin: true, // 需要登录
    serverId: '121',
    get serverUrl() {
      return SERVER_INFO.URL_121;
@@ -51,49 +50,9 @@
  },
  GSCLT: {
    tag: 'test',
    displayName: '甘肃农科院-崔龙天',
    operatorId: '2025041912201400006', // 统一ID用于operator和clientId
    needLogin: false, // 不需要登录
    serverId: '233',
    get serverUrl() {
      return SERVER_INFO.URL_233;
    }
  },
  GSWJ: {
    tag: 'test',
    displayName: '甘肃农科院-王娟',
    operatorId: '2025042115424500006', // 统一ID用于operator和clientId
    needLogin: false, // 不需要登录
    serverId: '233',
    get serverUrl() {
      return SERVER_INFO.URL_233;
    }
  },
  GSCLT2: {
    tag: 'test',
    displayName: '甘肃农科院-晁玉亮',
    operatorId: '2025042115452400006', // 统一ID用于operator和clientId
    needLogin: false, // 不需要登录
    serverId: '233',
    get serverUrl() {
      return SERVER_INFO.URL_233;
    }
  },
  GSCLT3: {
    tag: 'test',
    displayName: '甘肃农科院-黄虎生',
    operatorId: '2025042115454100006', // 统一ID用于operator和clientId
    needLogin: false, // 不需要登录
    serverId: '233',
    get serverUrl() {
      return SERVER_INFO.URL_233;
    }
  },
  GSCLT4: {
    tag: 'test',
    displayName: '甘肃农科院-朱兆宝',
    operatorId: '2025042115455900006', // 统一ID用于operator和clientId
    needLogin: false, // 不需要登录
    displayName: '甘肃农科院',
    operatorId: '', // 统一ID用于operator和clientId
    needLogin: true, // 不需要登录
    serverId: '233',
    get serverUrl() {
      return SERVER_INFO.URL_233;