operation_wx/pages/equipment/index.js

const api = require('../../api/index.js');
Page({
  data: {
    // 筛选状态
    activeFilter: 'all', // all/car/station/user
    activeStatus: 'unread', // unread/read/handled
    // 告警数量统计
    alertCount: {
      all: 0,
      car: 0,
      station: 0,
      user: 0
    },
    // 是否有未处理告警（控制底部批量操作栏显示）
    hasUnHandled: false,
    // 原始告警数据（实际项目从接口获取）
    alertData: [],
    // 筛选后的告警列表
    filteredAlerts: [],

    // ===== 新增分页相关数据 =====
    pageNum: 1,          // 当前页码
    pageSize: 10,        // 每页条数
    totalPages: 0,            // 总数据量
    hasMore: true,       // 是否还有更多数据
    isLoading: false     // 是否正在加载（防止重复请求）
  },

  onLoad(options) {
    this.handleWsMessage()
  },
  onHide(){
    // 页面卸载时，取消订阅，这是至关重要的一步！
    wx.$off('wsMessage', this.handleWsMessage);
  },
    /**
   * 处理接收到的 WebSocket 消息
   * @param {Object} message 从 app.js 广播过来的消息对象
   */
  handleWsMessage(message) {
    console.log('Other Page 收到 WebSocket 消息:', message);
 
    // 根据消息类型进行不同的处理
    switch (message.api) {
      case '/alarm/selectalarm':
        // 在这里可以更新地图、刷新UI等
        this.initAlertData(true);
        break;
     
    }
  },
onShow(){
    // 初始化告警数据（第一页）

  this.initAlertData(true);

},
  /**
   * 下拉刷新：重新加载第一页告警数据
   */
  onPullDownRefresh() {
    // 重置分页状态，重新加载第一页
    this.initAlertData(true);
    wx.stopPullDownRefresh();
  },

  /**
   * 上拉加载更多：加载下一页数据
   */
  onReachBottom() {
    // 没有更多数据或正在加载时，不执行
    if (!this.data.hasMore || this.data.isLoading) return;
    
    // 加载下一页
    this.initAlertData(false);
  },

  /**
   * 初始化/加载告警数据（支持分页）
   * @param {Boolean} isRefresh 是否刷新（true=重新加载第一页，false=加载下一页）
   */
  initAlertData(isRefresh = true) {
    // 防止重复加载
    if (this.data.isLoading) return;
    
    // 设置加载状态
    this.setData({ isLoading: true });

    // 分页参数处理
    const pageNum = isRefresh ? 1 : this.data.pageNum + 1;
    const pageSize = this.data.pageSize;

    // 接口请求参数
    let activeStatus = ''
    if (this.data.activeStatus=='unread') {
      activeStatus = ''
    }else if(this.data.activeStatus=='read'){
      activeStatus = 0
    }else if(this.data.activeStatus=='handled'){
      activeStatus = 1
    }
    let data = {
      faultstatus: activeStatus,
      pageNum,
      pageSize
    };

    api.request(`/alarm/selectalarm`, 'post', data, { isPublic: false })
      .then((res) => {
        console.log('告警数据请求结果：', res);
        if (res.code === 200) {
          const { data: responseData } = res;
          const { data: list, totalPages } = responseData;

          // 数据处理：刷新=覆盖，加载更多=追加
          const newAlertData = isRefresh 
            ? list 
            : [...this.data.alertData, ...list];

          // 计算是否还有更多数据
          const hasMore = newAlertData.length < totalPages;
console.log(newAlertData);
console.log(pageNum);
console.log(totalPages);
console.log(hasMore);
          // 更新数据
          this.setData({
            alertData: newAlertData,
            pageNum:res.data.currentPage,          // 更新当前页码
            totalPages:res.data.totalCount,            // 更新总条数
            hasMore           // 更新是否有更多数据
          });
      this.filterAlerts();

        }
      })
      .catch((err) => {
        console.error('告警数据请求失败：', err);
        wx.showToast({
          title: '数据加载失败',
          icon: 'none',
          duration: 1500
        });
      })
      .finally(() => {
        // 无论成功失败，都结束加载状态
        this.setData({ isLoading: false });
      });
  },

  /**
   * 统计各类型告警数量（角标显示）
   */
  calcAlertCount() {
    const { alertData } = this.data;
    // 过滤已处理的告警（角标只显示未处理的）  
    const unHandledAlerts = alertData.filter(item => item.faultstatus != 0);
    
    // 统计数量
    const count = {
      all: unHandledAlerts.length,
      car: unHandledAlerts.filter(item => item.type === 'car').length,
      station: unHandledAlerts.filter(item => item.type === 'station').length,
      user: unHandledAlerts.filter(item => item.type === 'user').length
    };

    // 判断是否有未处理告警
    const hasUnHandled = unHandledAlerts.length > 0;

    this.setData({
      alertCount: count,
      hasUnHandled
    });
  },

  /**
   * 筛选告警列表（根据类型+状态）
   */
  filterAlerts() {
    const { alertData} = this.data;
    
    // 第一步：按类型筛选
    let filtered = alertData;
   
    // 更新筛选后的列表
    this.setData({ filteredAlerts: filtered });
  },

  /**
   * 切换告警类型筛选
   */
  switchFilter(e) {
    const type = e.currentTarget.dataset.type;
    this.setData({ activeFilter: type }, () => {
      this.filterAlerts();
    });
  },

  /**
   * 切换告警状态筛选
   */
  switchStatus(e) {
    const status = e.currentTarget.dataset.status;
      this.setData({
        activeStatus: status
      })
    this.initAlertData()

  },
  /**
   * 跳转告警详情页
   */
  toAlertDetail(e) {
    const alert = e.currentTarget.dataset.alert;
    console.log(alert);
    if (!alert.faultId) return;

    // 先标记为已读（未读状态下）
    if (alert.status === 'unread') {
      const { alertData } = this.data;
      const newAlerts = alertData.map(item => {
        if (item.id === alert.id) {
          return { ...item, status: 'read' };
        }
        return item;
      });
      this.setData({ alertData: newAlerts }, () => {
        this.calcAlertCount();
        this.filterAlerts();
      });
    }

    // 跳转详情页（替换为你的详情页路径）
    wx.navigateTo({
      url: `/pages/alert-detail/alert-detail?id=${alert.id}`
    });
  },

 

  /**
   * 重置分页状态（可选：筛选条件变更时调用）
   */
  resetPage() {
    this.setData({
      pageNum: 1,
      totalPages: 0,
      hasMore: true,
      alertData: []
    });
  }
});
//