dbd-meeting-wx-small/miniprogram/pages/meeting/meetingRoom/meetingStaff/meetingStaff.js

const app = getApp()

import Notify from '@vant/weapp/notify/notify';

import {
  getStaff,
  selectReservationByIdRq,
  addStaff
} from "../../../../api/meeting/meetingRoom.js"


Page({

  /**
   * 页面的初始数据
   */
  data: {
    IMG_NAME: app.IMG_NAME,
    rId: '',
    checkUser: [],
    // staffMusicList: [{
    //   id: 1,
    //   name: '张三',
    //   isSelect: false
    // }],
    staffMusicList: [],
    // staffServeList: [{
    //   id: 4,
    //   name: '赵六',
    //   isSelect: false
    // }],
    staffServeList: [],
    serviceCheckAll: false,
    musicCheckAll: false
  },
  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    let _this = this
    let rId = options.rId

    // console.log(ser)
    _this.setData({
      rId: rId
    })
    // 获取数据
    _this.getData()
  },

  // 获取数据
  getData() {
    let _this = this
    let id = _this.data.rId
    
    // 显示加载中提示
    wx.showLoading({
      title: '加载中...',
      mask: true
    });
    
    // 获取预约信息
    selectReservationByIdRq({
      id: id
    }).then(res => {
      console.log('预约信息：', res)
      // 初始化数组
      let musicStaffArr = [] // 音控组人员ID
      let serviceStaffArr = [] // 会务服务组人员ID
      let staff = res.waiters || []
      
      // 清晰记录每个waiter的类型和ID，便于调试
      console.log('服务器返回的会务人员:', staff.map(item => ({id: item.userId, type: item.type})));
      
      // 分别存储音控组和会务服务组的人员ID
      for (let i = 0; i < staff.length; i++) {
        // 类型1为音控组
        if (staff[i].type === '1' || staff[i].type === 1) {
          musicStaffArr.push(staff[i].userId)
        }
        // 类型3为会务服务组
        else if (staff[i].type === '3' || staff[i].type === 3) {
          serviceStaffArr.push(staff[i].userId)
        }
      }
      
      getStaff().then(resStaff => {
        wx.hideLoading();
        console.log('会务人员列表：', resStaff)
        let musicList = []
        let serveList = []
        
        // 检查服务器返回的已选择人员
        let hasMusicStaff = musicStaffArr.length > 0
        let hasServiceStaff = serviceStaffArr.length > 0
        
        // 处理音控组数据
        if (resStaff.voiceWaiter && resStaff.voiceWaiter.length > 0) {
          for (let i = 0; i < resStaff.voiceWaiter.length; i++) {
            let eachObj = resStaff.voiceWaiter[i]
            // 判断该人员是否已被选择
            let isSel = musicStaffArr.includes(eachObj.id)
            musicList.push({
              id: eachObj.id,
              name: eachObj.username,
              isSelect: isSel
            })
          }
        }
        
        // 处理会务服务组数据
        if (resStaff.serveWaiter && resStaff.serveWaiter.length > 0) {
          for (let i = 0; i < resStaff.serveWaiter.length; i++) {
            let eachObj = resStaff.serveWaiter[i]
            // 判断该人员是否已被选择
            let isSel = serviceStaffArr.includes(eachObj.id)
            serveList.push({
              id: eachObj.id,
              name: eachObj.username,
              isSelect: isSel
            })
          }
        }
        
        // 重新检查选择状态，以确保准确性
        hasMusicStaff = musicList.some(item => item.isSelect);
        hasServiceStaff = serveList.some(item => item.isSelect);
        
        // 计算全选状态
        const musicCheckAll = musicList.length > 0 && musicList.every(item => item.isSelect);
        const serviceCheckAll = serveList.length > 0 && serveList.every(item => item.isSelect);
        
        console.log('音控组选择状态:', hasMusicStaff, '音控组IDs:', musicStaffArr);
        console.log('会务服务组选择状态:', hasServiceStaff, '会务服务组IDs:', serviceStaffArr);
        
        // 保存初始状态到本地存储
        wx.setStorageSync('staffStatus_' + _this.data.rId, {
          hasMusicStaff,
          hasServiceStaff,
          musicIds: musicStaffArr,
          serviceIds: serviceStaffArr,
          timestamp: new Date().getTime()
        });
        
        _this.setData({
          staffServeList: serveList,
          staffMusicList: musicList,
          musicCheckAll: musicCheckAll,
          serviceCheckAll: serviceCheckAll
        })
      }).catch(err => {
        wx.hideLoading();
        console.error('获取会务人员列表失败:', err);
        Notify({
          type: 'danger',
          message: '获取会务人员列表失败'
        });
      });
    }).catch(err => {
      wx.hideLoading();
      console.error('获取预约信息失败:', err);
      Notify({
        type: 'danger',
        message: '获取预约信息失败'
      });
    });
  },

  // 音控组全选
  checkMusicAll() {
    let _this = this
    let checkStatus = !_this.data.musicCheckAll // 直接取反更可靠
    
    // 更新所有音控组成员的选择状态
    let staffMusicList = _this.data.staffMusicList.map(item => {
      item.isSelect = checkStatus
      return item
    })
    
    _this.setData({
      staffMusicList,
      musicCheckAll: checkStatus
    })
    
    // 更新本地存储状态
    let hasServiceStaff = _this.data.staffServeList.some(item => item.isSelect);
    wx.setStorageSync('staffStatus_' + _this.data.rId, {
      hasMusicStaff: checkStatus,
      hasServiceStaff
    });
    
    console.log('音控组全选状态更新为:', checkStatus);
  },
  
  // 会务服务组全选
  checkServiceAll() {
    let _this = this
    let checkStatus = !_this.data.serviceCheckAll // 直接取反更可靠
    
    // 更新所有会务服务组成员的选择状态
    let staffServeList = _this.data.staffServeList.map(item => {
      item.isSelect = checkStatus
      return item
    })
    
    _this.setData({
      staffServeList,
      serviceCheckAll: checkStatus
    })
    
    // 更新本地存储状态
    let hasMusicStaff = _this.data.staffMusicList.some(item => item.isSelect);
    wx.setStorageSync('staffStatus_' + _this.data.rId, {
      hasMusicStaff,
      hasServiceStaff: checkStatus
    });
    
    console.log('会务服务组全选状态更新为:', checkStatus);
  },
  
  // 单个选择框点击
  checkBoxClick(e) {
    let _this = this
    console.log('checkBoxClick', e)
    // get param
    let id = e.target.dataset.id
    let type = e.target.dataset.type
    
    if (type === 'music') {
      // 音控组成员选择
      let staffMusicList = _this.data.staffMusicList.map(item => {
        if (item.id == id) {
          item.isSelect = !item.isSelect
        }
        return item
      })
      
      // 检查是否需要更新全选状态
      const allSelected = staffMusicList.length > 0 && staffMusicList.every(item => item.isSelect);
      const noneSelected = staffMusicList.every(item => !item.isSelect);
      
      _this.setData({
        staffMusicList,
        musicCheckAll: allSelected
      })
      
      // 检查音控组选择状态
      let hasMusicStaff = staffMusicList.some(item => item.isSelect);
      
      // 获取会务服务组选择状态
      let hasServiceStaff = _this.data.staffServeList.some(item => item.isSelect);
      
      // 更新本地存储
      wx.setStorageSync('staffStatus_' + _this.data.rId, {
        hasMusicStaff,
        hasServiceStaff
      });
      
      console.log('音控组选择状态:', hasMusicStaff, '全选状态:', allSelected);
      
    } else if (type === 'serve' || type === 'service') {
      // 会务服务组成员选择 (支持两种数据类型值)
      let staffServeList = _this.data.staffServeList.map(item => {
        if (item.id == id) {
          item.isSelect = !item.isSelect
        }
        return item
      })
      
      // 检查是否需要更新全选状态
      const allSelected = staffServeList.length > 0 && staffServeList.every(item => item.isSelect);
      const noneSelected = staffServeList.every(item => !item.isSelect);
      
      _this.setData({
        staffServeList,
        serviceCheckAll: allSelected
      })
      
      // 检查会务服务组选择状态
      let hasServiceStaff = staffServeList.some(item => item.isSelect);
      
      // 获取音控组选择状态
      let hasMusicStaff = _this.data.staffMusicList.some(item => item.isSelect);
      
      // 更新本地存储
      wx.setStorageSync('staffStatus_' + _this.data.rId, {
        hasMusicStaff,
        hasServiceStaff
      });
      
      console.log('会务服务组选择状态:', hasServiceStaff, '全选状态:', allSelected);
    }
  },

  // 确定
  submit() {
    let _this = this;
    
    console.log('提交全选状态:', {
      musicCheckAll: _this.data.musicCheckAll,
      serviceCheckAll: _this.data.serviceCheckAll
    });
    
    // 收集音控组选择的ID
    let staffMusicList = _this.data.staffMusicList;
    let musicIds = [];
    let hasMusicStaff = false;
    
    // 获取所有选中的音控组成员ID
    staffMusicList.forEach(item => {
      if (item.isSelect) {
        hasMusicStaff = true;
        musicIds.push(item.id);
      }
    });
    
    // 收集会务服务组选择的ID
    let staffServeList = _this.data.staffServeList;
    let serveIds = [];
    let hasServiceStaff = false;
    
    // 获取所有选中的会务服务组成员ID
    staffServeList.forEach(item => {
      if (item.isSelect) {
        hasServiceStaff = true;
        serveIds.push(item.id);
      }
    });
    
    // 将数组转换为以逗号分隔的字符串
    let musicId = musicIds.join(',');
    let serveId = serveIds.join(',');
    
    console.log('提交选择状态:', {
      hasMusicStaff, 
      hasServiceStaff,
      音控组IDs: musicIds, 
      会务服务组IDs: serveIds
    });
    
    // 保存选择状态到本地存储，添加更多信息和时间戳
    wx.setStorageSync('staffStatus_' + _this.data.rId, {
      hasMusicStaff,
      hasServiceStaff,
      musicIds: musicIds,
      serviceIds: serveIds,
      timestamp: new Date().getTime()
    });
    
    // 显示加载中
    wx.showLoading({
      title: '保存中...',
      mask: true
    });
    
    // 调用接口保存到服务器
    addStaff({
      id: _this.data.rId,
      voiceWaiter: musicId,  // 音控组 type=1
      serveWaiter: serveId   // 会务服务组 type=3
    }).then(res => {
      wx.hideLoading();
      
      if (res.code == 0) {
        Notify({
          type: 'success',
          message: '分配成功！'
        });
        
        // 再次确认状态已正确保存
        console.log('会务人员设置成功，最终状态:', {
          音控组: hasMusicStaff,
          会务服务组: hasServiceStaff,
          音控组人员: musicIds,
          会务服务组人员: serveIds
        });
        
        // 获取页面栈
        let pages = getCurrentPages();
        // 获取上一页实例
        let prevPage = pages[pages.length - 2];
        
        // 判断上一页是否是approve页面
        if (prevPage && prevPage.route && prevPage.route.includes('approve')) {
          // 设置上一页的dataChange为true，触发刷新
          prevPage.setData({
            dataChange: true
          });
          
          // 尝试直接更新上一页的记录数据
          try {
            // 查找对应的预约记录并更新其状态
            const reservationList = prevPage.data.reservationDataList || [];
            const currentRecord = reservationList.find(item => item.id === _this.data.rId);
            
            if (currentRecord) {
              // 构造一个模拟的waiters数组
              const waiters = [];
              
              // 添加音控组人员
              musicIds.forEach(id => {
                waiters.push({
                  userId: id,
                  type: '1'
                });
              });
              
              // 添加会务服务组人员
              serveIds.forEach(id => {
                waiters.push({
                  userId: id,
                  type: '3'
                });
              });
              
              // 更新记录的waiters属性
              currentRecord.waiters = waiters;
              
              // 重新处理会务负责人状态
              if (typeof prevPage.processStaffStatus === 'function') {
                prevPage.processStaffStatus(currentRecord);
                
                // 通知页面更新
                prevPage.setData({
                  reservationDataList: reservationList
                });
                
                console.log('直接更新上一页预约记录状态成功');
              }
            }
          } catch (err) {
            console.error('更新上一页数据失败:', err);
          }
        }
        
        // 返回上一页
        setTimeout(() => {
          wx.navigateBack();
        }, 500);
      } else {
        // 提交失败
        Notify({
          type: 'danger',
          message: res.msg || '分配失败，请重试'
        });
      }
    }).catch(err => {
      wx.hideLoading();
      console.error('分配会务人员失败:', err);
      Notify({
        type: 'danger',
        message: '网络错误，请重试'
      });
    });
  },

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

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {

  },

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

  },

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

  },

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

  },

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

  },

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

  }
})