常用取水口列表搜索接口兼容性

zuoxiao

2025-07-25 dc49b96b835326a64056da9da0b43eabd2d96e32

 pages/home/home.js

@@ -4,37 +4,13 @@
  get,
  post
} = require('../../api/request.js');
const config = require('../../api/config.js');
const {
  PROJECT_URLS
} = require('../../api/config.js');

// 项目配置，包含各项目的专有设置
const PROJECT_CONFIG = {
  JYG: {
    tag: 'ym',
    displayName: '嘉峪关项目',
    needLogin: true // 需要登录
  },
  MQ: {
    tag: 'mq',
    displayName: '民勤项目',
    operatorId: '2025033115305200006', // 统一ID用于operator和clientId
    needLogin: false // 不需要登录
  },
  TEST: {
    tag: 'ym',
    displayName: '测试项目',
    operatorId: '2025032411245000006', // 统一ID用于operator和clientId
    vcId: '2024122617295800009',
    needLogin: false // 不需要登录
  },
  SCHOOL: {
    tag: 'XX',
    displayName: '学校项目',
    operatorId: '2025040215305200006', // 统一ID用于operator和clientId
    needLogin: true // 不需要登录
  }
};
  PROJECT_CONFIG
} = require('../../utils/projectConfig.js');
const {
  ENV
} = require('../../api/env.js');

Page({

@@ -63,33 +39,64 @@
    lastIntakeName: "",
    showProjectDialog: false,
    selectedProject: '',
    tempSelectedProject: '', // 添加临时选择变量，用于保存用户在对话框中选择但尚未确认的项目
    avatarTapCount: 0,
    isFromLogin: false,
    showTipDialog: '',
    projectConfig: PROJECT_CONFIG // 添加项目配置到data中
    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'
      })
    // 检查当前项目是否需要登录
    const currentProject = app.globalData.selectedProject;
    if (currentProject && PROJECT_CONFIG[currentProject] && PROJECT_CONFIG[currentProject].needLogin) {
      // 需要登录的项目，检查是否已登录
      if (!app.globalData.isLoggedIn) {
        // 未登录，显示提示并阻止操作
        wx.showToast({
          title: '请先登录',
          icon: 'error',
          duration: 2000
        });
        
        // 获取项目配置
        const projectConfig = PROJECT_CONFIG[currentProject];
        if (projectConfig) {
          // 询问用户是否前往登录
          wx.showModal({
            title: '提示',
            content: '您需要登录后才能使用开阀功能，是否立即登录？',
            confirmText: '前往登录',
            cancelText: '取消',
            success: (res) => {
              if (res.confirm) {
                // 用户点击确认，直接调用wxLogin方法
                this.wxLogin();
              }
            }
          });
        }
        return;
      }
    }
    
    // 已登录或不需要登录的项目，执行开阀操作
    wx.navigateTo({
      url: '/pages/waterIntake/waterIntake',
    })
  },
  calculateScrollViewHeight: function () {
    wx.createSelectorQuery().selectAll('.list-item').boundingClientRect((rects) => {
      let totalHeight = rects.reduce((sum, rect) => sum + rect.height, 0);
      this.setData({
        scrollViewHeight: totalHeight,
      });
    }).exec();
  },

  // 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) {
@@ -117,6 +124,10 @@
   */
  onLoad(options) {
    console.log('home页面onLoad开始，参数:', options);

    // 初始化项目列表数据
    this.initProjectList();

    //当开阀成功后调用刷新
    if (options.param === "1" || options.param === "2") {
      this.setData({
@@ -148,6 +159,44 @@
    }, 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;
        }
      } catch (e) {
        console.error('从本地存储获取项目失败:', e);
      }
    }

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

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

  // 新增的初始化页面辅助函数，分离出onLoad中的逻辑以便延迟执行
  initializePage(options, fromLogin) {
    // 检查是否已选择项目
@@ -166,17 +215,30 @@
          });

          // 设置 baseUrl
          const baseUrl = PROJECT_URLS[project];
          getApp().globalData.baseUrl = baseUrl;
          getApp().globalData.selectedProject = project;
          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
            });
            
            // 根据项目是否需要登录，设置不同的userName
            if (projectConfig.needLogin === false) {
              // 不需要登录的项目，显示项目名称
              this.setData({
                userName: projectConfig.displayName
              });
            } else {
              // 需要登录的项目，显示"请点击登录"
              this.setData({
                userName: "请点击登录"
              });
            }
          }

          // 根据项目设置对应的operator和clientId
@@ -198,11 +260,11 @@
              isLoggedIn: true,
              sessionId: projectConfig.operatorId
            };
            

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

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

@@ -286,9 +348,34 @@
      });
    }

    // 尝试获取eventChannel，用于监听登录页面发回的消息
    try {
      const eventChannel = currentPage.getOpenerEventChannel();
      if (eventChannel && eventChannel.on) {
        eventChannel.on('fromLogin', (data) => {
          console.log('onShow: 接收到登录页面返回的消息', data);
          if (data && data.fromLogin) {
            fromLogin = true;
            this.setData({
              isFromLogin: true
            });
            
            // 登录成功后刷新数据
            console.log('登录成功后刷新数据');
            this.initData();
          }
        });
      }
    } catch (e) {
      console.error('获取eventChannel失败:', e);
    }

    // 初始化处理
    if (fromLogin || this.data.isFromLogin) {
      console.log('onShow: 从登录页返回，不进行登录检查');
      
      // 如果是从登录页返回，重新加载数据
      this.initData();
    } else {
      console.log('onShow: 正常显示页面');
      // 延迟检查登录状态，确保能正确识别临时标记
@@ -364,12 +451,43 @@
    })
  },
  openValveList() {
    // wx.navigateTo({
    //   url: '/pages/valveList/valveList',
    // })
    wx.showToast({
      title: '暂未开放',
      icon: 'none'
    const app = getApp();
    // 检查当前项目是否需要登录
    const currentProject = app.globalData.selectedProject;
    if (currentProject && PROJECT_CONFIG[currentProject] && PROJECT_CONFIG[currentProject].needLogin) {
      // 需要登录的项目，检查是否已登录
      if (!app.globalData.isLoggedIn) {
        // 未登录，显示提示并阻止操作
        wx.showToast({
          title: '请先登录',
          icon: 'error',
          duration: 2000
        });
        
        // 获取项目配置
        const projectConfig = PROJECT_CONFIG[currentProject];
        if (projectConfig) {
          // 询问用户是否前往登录
          wx.showModal({
            title: '提示',
            content: '您需要登录后才能查看开关阀记录，是否立即登录？',
            confirmText: '前往登录',
            cancelText: '取消',
            success: (res) => {
              if (res.confirm) {
                // 用户点击确认，直接调用wxLogin方法
                this.wxLogin();
              }
            }
          });
        }
        return;
      }
    }
    
    // 已登录或不需要登录的项目，执行查看记录操作
    wx.navigateTo({
      url: '/pages/valveList/valveList',
    })
  },
  feedBack() {
@@ -383,24 +501,37 @@
    // 检查当前项目是否需要登录
    const currentProject = getApp().globalData.selectedProject;
    const projectConfig = PROJECT_CONFIG[currentProject];
    
    // 如果当前项目配置为不需要登录，则提示用户不可解绑

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

    // 如果已登录，显示解绑确认对话框
    if (getApp().globalData.isLoggedIn) {
      wx.showModal({
        title: '解绑确认',
        content: '确定要解绑当前账号吗？',
        content: '确定要解绑当前账号吗？解绑后将无法使用相关功能，需重新绑定。',
        confirmText: '确认解绑',
        confirmColor: '#e34d59',
        cancelText: '取消',
        success: (res) => {
          if (res.confirm) {
            this.unBindPost()
            this.unBindPost();
          }
        }
      });
@@ -408,21 +539,48 @@
      wx.showToast({
        title: '还未绑定',
        icon: 'error'
      })
      });
    }
  },
  //轮灌
  irrigation() {
    if (getApp().globalData.isLoggedIn) {
      wx.navigateTo({
        url: '/pages/irrigation/irrigation',
      })
    } else {
      wx.showToast({
        title: '请先登录',
        icon: 'error'
      })
    const app = getApp();
    // 检查当前项目是否需要登录
    const currentProject = app.globalData.selectedProject;
    if (currentProject && PROJECT_CONFIG[currentProject] && PROJECT_CONFIG[currentProject].needLogin) {
      // 需要登录的项目，检查是否已登录
      if (!app.globalData.isLoggedIn) {
        // 未登录，显示提示并阻止操作
        wx.showToast({
          title: '请先登录',
          icon: 'error',
          duration: 2000
        });
        
        // 获取项目配置
        const projectConfig = PROJECT_CONFIG[currentProject];
        if (projectConfig) {
          // 询问用户是否前往登录
          wx.showModal({
            title: '提示',
            content: '您需要登录后才能使用轮灌功能，是否立即登录？',
            confirmText: '前往登录',
            cancelText: '取消',
            success: (res) => {
              if (res.confirm) {
                // 用户点击确认，直接调用wxLogin方法
                this.wxLogin();
              }
            }
          });
        }
        return;
      }
    }
    
    // 已登录或不需要登录的项目，执行轮灌操作
    wx.navigateTo({
      url: '/pages/irrigation/irrigation',
    })
  },
  handleChange(e) {
    const item = e.currentTarget.dataset.item;
@@ -485,14 +643,22 @@
      })
    }).catch(error => {
      wx.hideLoading();
      this.setData({
        showErrorDialog: true,
        errorData: error.msg,
        errorDialogTitle: "关阀错误"
      })
      // 处理错误响应
      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: "关阀错误"
        })
      }
    });
  },
  /**
@@ -554,11 +720,8 @@
        isRefreshing: false, // 将triggered属性设置为false，表示下拉刷新已完成
        isWXRefreshing: false, // 将triggered属性设置为false，表示下拉刷新已完成
      });
      this.updateDisplayText();

      // 成功获取数据后刷新UI高度
      setTimeout(() => {
        this.calculateScrollViewHeight();
      }, 200);
    }).catch(err => {
      console.error('获取列表数据失败:', err);
      // 错误回调
@@ -601,12 +764,6 @@
  },
  //根据session获取农户信息
  getUserDataBySession() {
    // 先检查是否从登录页返回
    if (this.getFromLogin()) {
      console.log('getUserDataBySession: 检测到从登录页返回的标记，不执行API请求');
      return;
    }

    const app = getApp();

    // 检查是否有sessionId
@@ -651,13 +808,6 @@
            duration: 3000
          });
        }
      } else {
        // 其他错误，显示错误信息
        wx.showToast({
          title: err.msg || '获取用户信息失败',
          icon: 'none',
          duration: 3000
        });
      }
    });
  },
@@ -679,6 +829,41 @@
   * 扫码开阀
   */
  scenCode() {
    const app = getApp();
    // 检查当前项目是否需要登录
    const currentProject = app.globalData.selectedProject;
    if (currentProject && PROJECT_CONFIG[currentProject] && PROJECT_CONFIG[currentProject].needLogin) {
      // 需要登录的项目，检查是否已登录
      if (!app.globalData.isLoggedIn) {
        // 未登录，显示提示并阻止扫码
        wx.showToast({
          title: '请先登录',
          icon: 'error',
          duration: 2000
        });
        
        // 获取项目配置
        const projectConfig = PROJECT_CONFIG[currentProject];
        if (projectConfig) {
          // 询问用户是否前往登录
          wx.showModal({
            title: '提示',
            content: '您需要登录后才能使用扫码开阀功能，是否立即登录？',
            confirmText: '前往登录',
            cancelText: '取消',
            success: (res) => {
              if (res.confirm) {
                // 用户点击确认，直接调用wxLogin方法
                this.wxLogin();
              }
            }
          });
        }
        return;
      }
    }
    
    // 已登录或不需要登录的项目，执行扫码操作
    const that = this;
    wx.scanCode({
      success(res) {
@@ -777,35 +962,67 @@

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

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

      // 如果没有全局变量，尝试从本地存储中恢复
      Promise.all([
        storage.getItemSafe('userData'),
        storage.getItemSafe('sessionId'),
        storage.getItemSafe('clientId')
      ]).then(([userData, sessionId, clientId]) => {
        if (userData) {
          try {
            // 解析userData并设置全局变量
            let jsonObj = JSON.parse(userData);
            app.globalData.sessionId = jsonObj.sessionId;
            app.globalData.clientId = jsonObj.clientId || clientId;
            app.globalData.tag = jsonObj.tag;
            app.globalData.isLoggedIn = true;
            
            // 直接从userData设置用户信息
            if (jsonObj.clientName && jsonObj.phone) {
              this.setData({
                userName: jsonObj.clientName,
                userPhone: this.maskPhoneNumber(jsonObj.phone)
              });
            } else {
              // 如果userData中没有用户信息，调用接口获取
              this.getUserDataBySession();
            }
            
            console.log("userData已加载:", userData);
          } catch (e) {
            console.error('userData解析失败:', e);
            if (sessionId && clientId) {
              app.globalData.sessionId = sessionId;
              app.globalData.clientId = clientId;
              app.globalData.isLoggedIn = true;
              this.getUserDataBySession();
            }
          }
        } else if (sessionId && clientId) {
          // 如果没有userData但有session和client ID
          app.globalData.sessionId = sessionId;
          app.globalData.clientId = clientId;
          app.globalData.isLoggedIn = true;
          this.getUserDataBySession();
        }
        
        // 无论如何都尝试获取开阀列表
        this.getOpenList();
      }).catch(err => {
        console.error('恢复登录状态失败:', err);
        this.getOpenList();
      });
      
      return;
    }

@@ -814,12 +1031,20 @@
    const projectConfig = PROJECT_CONFIG[currentProject];
    const needLogin = projectConfig && projectConfig.needLogin;

    // 根据项目是否需要登录，设置不同的userName
    if (projectConfig && projectConfig.needLogin === false) {
      // 不需要登录的项目，显示项目名称
      this.setData({
        userName: projectConfig.displayName
      });
    }

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

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

        this.getOpenList();
        return;
      }
@@ -850,7 +1075,7 @@
                console.error('userData解析失败:', e);
              }
            }
            

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

            this.getOpenList();
          })
          .catch((err) => {
@@ -876,7 +1101,7 @@
              } else {
                console.log('initData:catch: 当前项目不需要登录，跳过获取用户数据');
              }
              

              this.getOpenList();
            }
          });
@@ -895,7 +1120,7 @@
          } else {
            console.log('initData:else: 当前项目不需要登录，跳过获取用户数据');
          }
          

          this.getOpenList();
        }
      }
@@ -914,7 +1139,7 @@
        } else {
          console.log('initData:error: 当前项目不需要登录，跳过获取用户数据');
        }
        

        this.getOpenList();
      }
    }
@@ -928,7 +1153,8 @@
    if (this.data.avatarTapCount >= 5) {
      this.setData({
        showProjectDialog: true,
        avatarTapCount: 0
        avatarTapCount: 0,
        tempSelectedProject: this.data.selectedProject // 初始化临时选择为当前选择
      });
    }
  },
@@ -940,21 +1166,28 @@
      return;
    }
    this.setData({
      showProjectDialog: e.detail.visible
      showProjectDialog: e.detail.visible,
      // 当显示对话框时，初始化临时选择为当前选择
      tempSelectedProject: e.detail.visible ? this.data.selectedProject : ''
    });
  },

  // 处理项目选择变化
  onProjectChange(event) {
    console.log('选择的项目：', event.detail.value);
    // 不立即设置到state，而是存储到临时变量中
    this.setData({
      selectedProject: event.detail.value
      tempSelectedProject: event.detail.value
    });
  },

  // 处理项目选择确认
  handleProjectConfirm() {
    if (!this.data.selectedProject) {
    // 从临时变量获取选择的项目
    const selectedProject = this.data.tempSelectedProject || this.data.selectedProject;
    console.log('开始处理项目选择确认', selectedProject, this.data.projectList);

    if (!selectedProject) {
      wx.showToast({
        title: '请选择项目',
        icon: 'none'
@@ -964,9 +1197,13 @@

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

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

    if (!projectConfig) {
      wx.showToast({
        title: '项目配置错误',
@@ -978,6 +1215,38 @@
    // 检查是否切换了项目（如果当前项目不同于新选择的项目）
    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.setData({
            selectedProject: newProject
          });
          // 用户确认选择，继续处理
          this.processProjectSelection(currentProject, newProject, projectConfig, isProjectChanged);
        } else {
          // 用户取消，不进行任何操作
          console.log('用户取消了项目选择');
          // 恢复之前的选择状态
          this.setData({
            tempSelectedProject: this.data.selectedProject
          });
        }
      }
    });
  },

  // 处理项目选择的后续操作
  processProjectSelection(currentProject, newProject, projectConfig, isProjectChanged) {
    // 如果切换了项目，先清除登录状态
    if (isProjectChanged) {
      console.log(`正在从项目 ${currentProject} 切换到 ${newProject}，将清除登录状态`);
@@ -987,44 +1256,69 @@
      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显示状态
      this.setData({
        userName: "请登录",
        userPhone: "",
        listData: []
      });
      if (projectConfig.needLogin === false) {
        // 不需要登录的项目，显示项目名称作为userName
        this.setData({
          userName: projectConfig.displayName,
          userPhone: "",
          listData: []
        });
      } else {
        // 需要登录的项目，显示"请点击登录"
        this.setData({
          userName: "请点击登录",
          userPhone: "",
          listData: []
        });
      }
    }

    // 保存项目选择到本地存储
    storage.setItem('selectedProject', newProject).then(() => {
      // 更新 BASEURL
      const baseUrl = PROJECT_URLS[newProject];
      // 调用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.baseUrl = baseUrl;
      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;
@@ -1032,12 +1326,12 @@
        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,
@@ -1045,15 +1339,15 @@
          isLoggedIn: true,
          sessionId: operatorId
        };
        

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

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

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

      this.setData({
        showProjectDialog: false
@@ -1067,6 +1361,16 @@
      });
      setTimeout(() => {
        console.log('项目已切换，正在初始化数据');
        // 确保显示正确的用户名
        if (!projectConfig.needLogin) {
          this.setData({
            userName: projectConfig.displayName
          });
        } else {
          this.setData({
            userName: "请点击登录"
          });
        }
        this.initData();
      }, 1000);

@@ -1122,7 +1426,7 @@
    }

    // 如果当前已在登录页，不再跳转
    if (currentRoute === 'pages/login/login') {
    if (currentRoute === 'pages/login/login' || currentRoute === 'pages/accountLogin/accountLogin') {
      console.log('当前已在登录页，不再跳转');
      return;
    }
@@ -1177,11 +1481,26 @@
            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)
          // });
          // 根据项目配置的loginType决定跳转到哪个登录页面
          // 此处不做跳转，注释掉原有代码
          // const projectInfo = PROJECT_CONFIG[currentProject];
          // const loginType = projectInfo?.loginType || 'code'; // 默认使用验证码登录
          
          // if (loginType === 'account') {
          //   // 账号密码登录
          //   wx.navigateTo({
          //     url: `/pages/accountLogin/accountLogin?project=${currentProject}`,
          //     success: () => console.log('成功跳转到账号密码登录页'),
          //     fail: (err) => console.error('跳转到账号密码登录页失败:', err)
          //   });
          // } else {
          //   // 验证码登录
          //   wx.navigateTo({
          //     url: `/pages/login/login?project=${currentProject}`,
          //     success: () => console.log('成功跳转到验证码登录页'),
          //     fail: (err) => console.error('跳转到验证码登录页失败:', err)
          //   });
          // }
        }
      })
      .catch(err => {
@@ -1204,12 +1523,26 @@
          return;
        }

        // 出错时也跳转到登录页
        // wx.navigateTo({
        //   url: `/pages/login/login?project=${this.data.selectedProject}`,
        //   success: () => console.log('错误后成功跳转到登录页'),
        //   fail: (err) => console.error('错误后跳转到登录页失败:', err)
        // });
        // 出错时也跳转到登录页，根据loginType决定跳转目标
        // 此处不做跳转，注释掉原有代码
        // const projectInfo = PROJECT_CONFIG[currentProject];
        // const loginType = projectInfo?.loginType || 'code'; // 默认使用验证码登录
        
        // if (loginType === 'account') {
        //   // 账号密码登录
        //   wx.navigateTo({
        //     url: `/pages/accountLogin/accountLogin?project=${currentProject}`,
        //     success: () => console.log('错误后成功跳转到账号密码登录页'),
        //     fail: (err) => console.error('错误后跳转到账号密码登录页失败:', err)
        //   });
        // } else {
        //   // 验证码登录
        //   wx.navigateTo({
        //     url: `/pages/login/login?project=${currentProject}`,
        //     success: () => console.log('错误后成功跳转到验证码登录页'),
        //     fail: (err) => console.error('错误后跳转到验证码登录页失败:', err)
        //   });
        // }
      });
  },

@@ -1251,13 +1584,6 @@
      console.log('continueInitPage: 从页面数据中检测到isFromLogin=true');
      fromLogin = true;
    }

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

    // 当开阀成功后调用刷新
    if (options && options.param) {
      console.log("开阀成功参数:", options.param);
@@ -1291,11 +1617,19 @@
  wxLogin() {
    // 检查当前项目是否需要登录
    const currentProject = getApp().globalData.selectedProject;
    if (currentProject && PROJECT_CONFIG[currentProject] && !PROJECT_CONFIG[currentProject].needLogin) {
      console.log('wxLogin: 当前项目不需要登录:', currentProject);
      return;
    if (currentProject && PROJECT_CONFIG[currentProject]) {
      const projectConfig = PROJECT_CONFIG[currentProject];
      
      if (!projectConfig.needLogin) {
        console.log('wxLogin: 当前项目不需要登录:', currentProject);
        // 不需要登录的项目，显示项目名称
        this.setData({
          userName: projectConfig.displayName
        });
        return;
      }
    }
    

    if (!getApp().globalData.isLoggedIn) {
      wx.showLoading({
        title: '正在登录请稍候...',
@@ -1315,10 +1649,21 @@
              wx.hideLoading();
              if (response.code === "0001") {
                if (response.content.client.clientId === "") {
                  // 未绑定账号，跳转到登录页面
                  // wx.navigateTo({
                  //   url: `/pages/login/login?project=${this.data.selectedProject}`
                  // });
                  // 未绑定账号，根据项目配置的loginType跳转到相应的登录页面
                  const projectInfo = PROJECT_CONFIG[this.data.selectedProject];
                  const loginType = projectInfo?.loginType || 'code'; // 默认使用验证码登录
                  
                  if (loginType === 'account') {
                    // 账号密码登录
                    wx.navigateTo({
                      url: `/pages/accountLogin/accountLogin?project=${this.data.selectedProject}&projectName=${projectInfo.displayName}`
                    });
                  } else {
                    // 验证码登录
                    wx.navigateTo({
                      url: `/pages/login/login?project=${this.data.selectedProject}&projectName=${projectInfo.displayName}`
                    });
                  }
                } else {
                  this.setData({
                    userName: response.content.client.clientName,
@@ -1363,26 +1708,54 @@
                    });

                }
              } else if (response.code === "1003") {
                // 未绑定账号，根据项目配置的loginType跳转到相应的登录页面
                const projectInfo = PROJECT_CONFIG[this.data.selectedProject];
                const loginType = projectInfo?.loginType || 'code'; // 默认使用验证码登录
                
                if (loginType === 'account') {
                  // 账号密码登录
                  wx.navigateTo({
                    url: `/pages/accountLogin/accountLogin?project=${this.data.selectedProject}&projectName=${projectInfo.displayName}`
                  });
                } else {
                  // 验证码登录
                  wx.navigateTo({
                    url: `/pages/login/login?project=${this.data.selectedProject}&projectName=${projectInfo.displayName}`
                  });
                }
              } 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}`
              // });
              if(error.code==="1003"){
                // 未绑定账号，根据项目配置的loginType跳转到相应的登录页面
                const projectInfo = PROJECT_CONFIG[this.data.selectedProject];
                const loginType = projectInfo?.loginType || 'code'; // 默认使用验证码登录
                
                if (loginType === 'account') {
                  // 账号密码登录
                  wx.navigateTo({
                    url: `/pages/accountLogin/accountLogin?project=${this.data.selectedProject}&projectName=${projectInfo.displayName}`
                  });
                } else {
                  // 验证码登录
                  wx.navigateTo({
                    url: `/pages/login/login?project=${this.data.selectedProject}&projectName=${projectInfo.displayName}`
                  });
                }
              }else{
                wx.showToast({
                  title: '登录失败，请重试',
                  icon: 'none'
                });
              }
            });
          } else {
            wx.hideLoading();
@@ -1501,5 +1874,183 @@
        // 分享失败的回调函数
      }
    };
  }
  },
  //点击提示按钮
  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
      });

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

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

        this.setData({
          listData: updatedList
        });

        wx.showToast({
          title: '删除成功',
          icon: 'success',
          duration: 2000
        });
      }, 1500);
      return;
    }

    wx.showLoading({
      title: '正在强制删除请稍候...', // 加载提示文字
      mask: true // 是否显示透明蒙层，防止触摸穿透，默认为 false
    });
    const data = {
      vcNum: item.vcNum, //取水口ID
      rtuAddr: item.rtuAddr, //阀控器地址
    };
    post({
      url: "wx/valve/deleteUnclosed",
      data: data,
      timeout: 180000
    }).then(response => {
      // 处理成功响应
      console.log('请求成功:', response);
      // 加载完成后隐藏加载动画
      wx.hideLoading();
      //重新获取列表刷新数据
      this.getOpenList();
    }).catch(error => {
      // 加载完成后隐藏加载动画
      wx.hideLoading();
      // 处理错误响应
      console.error('请求失败:', error);
    });
  },
  //修改按钮文字
  updateDisplayText() {
    const updatedList = this.data.listData.map(item => {
      let displayText = '';
      if (item.planned) {
        displayText = '取消';
      } else {
        displayText = "关阀"
      }
      let deleteText = "删除"
      let time;
      if (!item.dt) {
        time = "暂无"
      } else {
        time = this.extractTime(item.dt)
      }
      if (item.waterInstant === null) {
        item.waterInstant = "暂无"
      }

      return {
        ...item,
        displayText,
        deleteText,
        time
      }; // 保留所有其他字段，并添加 displayText 字段
    });
    // 更新列表数据
    this.setData({
      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() {
    // 显示二次确认弹窗
    wx.showModal({
      title: '切换项目',
      content: '确定要切换项目吗？切换后需要重新登录。',
      confirmText: '确认切换',
      confirmColor: '#1890FF',
      cancelText: '取消',
      success: (res) => {
        if (res.confirm) {
          // 用户点击确认，显示项目选择弹窗
          this.setData({
            showProjectDialog: true
          });
        }
      }
    });
  },

  // 添加用户点击头像或用户名登录的处理逻辑
  handleUserTap() {
    const app = getApp();
    // 如果已登录，不需要跳转到登录页面
    if (app.globalData.isLoggedIn) {
      return;
    }

    // 检查当前项目是否需要登录
    const currentProject = app.globalData.selectedProject;
    if (currentProject && PROJECT_CONFIG[currentProject]) {
      const projectConfig = PROJECT_CONFIG[currentProject];
      
      if (!projectConfig.needLogin) {
        console.log('handleUserTap: 当前项目不需要登录:', currentProject);
        // 不需要登录的项目，显示项目名称
        this.setData({
          userName: projectConfig.displayName
        });
        return;
      }
      
      // 根据项目配置的loginType决定跳转到哪个登录页面
      const loginType = projectConfig.loginType || 'code'; // 默认使用验证码登录
      
      if (loginType === 'account') {
        // 账号密码登录
        wx.navigateTo({
          url: `/pages/accountLogin/accountLogin?project=${currentProject}&projectName=${projectConfig.displayName}`
        });
      } else {
        // 验证码登录
        wx.navigateTo({
          url: `/pages/login/login?project=${currentProject}&projectName=${projectConfig.displayName}`
        });
      }
    } else {
      // 如果没有当前项目配置，默认跳转到验证码登录
      wx.navigateTo({
        url: '/pages/login/login'
      });
    }
  },
})