教学互动测试版完成

闫增涛

2024-12-16 dcdf94bfb544daeb6ada5c3b1ce6cb62f4c35863

 packageBookService/pages/bookServices/examination/examination.js

@@ -1,7 +1,11 @@
import { getPublicImage } from '../../../../assets/js/middleGround/tool'
const app = getApp()
import {
  getPublicImage
} from "../../../../assets/js/middleGround/tool";
import {
  loginInfo
} from '../../../../assets/js/login';
const app = getApp();
Page({

  /**
   * 页面的初始数据
   */
@@ -9,26 +13,51 @@
    barHeight: "",
    navBarHeight: "",
    loading: false,
    answerTitle: "",  // 导航栏标题
    countdownInterval: null,   // 计时器
    answerTitle: "", // 导航栏标题
    countdownInterval: null, // 计时器
    isCountdownRunning: true, // 是否倒计时
    countdownTime: 0,  // 倒计时时间
    countdownTime: 0, // 倒计时时间
    storeInfo: '',
    jslx: '',
    bookId: "",
    productLinkPath: "",
    rootCmsItemId: "",
    idPathList: [],  // 题目列表
    answerType: "",  // 答题模式
    submitStatus: false,  // 提交状态
    idPathList: [], // 题目列表
    answerType: "", // 答题模式
    submitStatus: false, // 提交状态
    currentIndex: 0, // 当前显示的题号
    collectList: [],   //  收藏题目列表 
    errorList: [],  // 错题列表
    subjectiveTotal: 0,  // 客观题总数
    collectList: [], //  收藏题目列表
    errorList: [], // 错题列表
    subjectiveTotal: 0, // 客观题总数
    subjectiveNum: 0, // 客观题得分
    subjectiveGrade: 0, // 客观题总分
    correctNum: 0,  // 正确题目数量
    total: 0,   // 题目总数
    cardList: [],  // 提交项,
    questionDataList: [],  // 显示题目列表
    correctNum: 0, // 正确题目数量
    total: 0, // 题目总数
    cardList: [], // 提交项,
    questionDataList: [], // 显示题目列表
    noData: false,
    mockid: 0,
    uuid: 0,
    mockData: {
      // 组卷信息
      state: "0",
      score: 0, // 总分
      sumTime: 0,
      time: 0, // 答题剩余时间
      datas: [], // 所有模考记录数据(题目列表，用户答题，考试报告)
      answer: [],
    },
    saveTime: 20,
    isNight: false,
    sliderValue: 0, // 字体滑块
    startTime: "", //进入页面当前时间
    pauseTime: 0, //暂停时间
    showDialog: false, // 未提交退出拦截弹窗
    showId: '',
    isShowDialog: false, // 测试报告弹窗是否显示
    joinGroup: false, // 是否加入班级
    visible: false, // 加入班级弹窗是否打开
    classList: [] // 班级列表
  },

  /**
@@ -37,239 +66,569 @@
  onLoad(options) {
    const systInfo = wx.getSystemInfoSync();
    const menu = wx.getMenuButtonBoundingClientRect(); // 胶囊信息
    const navBarHeight = (menu.top - systInfo.statusBarHeight) * 2 + menu.height; // 导航栏高度
    const navBarHeight =
      (menu.top - systInfo.statusBarHeight) * 2 + menu.height; // 导航栏高度
    this.setData({
      barHeight: systInfo.statusBarHeight,
      navBarHeight: navBarHeight,
      answerTitle: options.answerTitle,
      bookId: options.bookId,
      productLinkPath: options.productLinkPath ? options.productLinkPath : '',
      productLinkPath: options.productLinkPath ? options.productLinkPath : "",
      rootCmsItemId: options.rootCmsItemId,
      idPathList: options.idPathList ? JSON.parse(options.idPathList) : [],
      answerType: options.answerType
      answerType: options.answerType,
      storeInfo: options.storeInfo,
      jslx: options.jslx,
    });
    this.init()
    console.log('传参', options);
    wx.setNavigationBarTitle({
      title: options.answerTitle,
    })
    if (this.data.answerType == "mock") {
      this.setData({
        uuid: options.uuid,
        mockid: options.mockid,
      });
    }

    const token = wx.getStorageSync(app.config.tokenKey)

    if (!token) {
      loginInfo(app, (data) => {
        if (data) {
          this.init();
        } else {
          this.init();
        }
      })
    } else {
      this.init()
    }

  },

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

  },
  onReady() {},

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

    if (this.data.answerType != "mock") {
      if (wx.timer) {
        clearInterval(wx.timer);
      }
    }
    if (this.data.answerType == "mock") {
      if (wx.timer) {
        clearInterval(wx.timer);
      }
      wx.timer = setInterval(() => {
        this.setData({
          saveTime: this.data.saveTime - 1,
        });
        if (this.data.saveTime == 0) {
          this.saveMockData();
        }
      }, 1000);
    }
    this.setData({
      startTime: Date.now(),
    });
  },

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

    if (wx.timer) {
      clearInterval(wx.timer);
    }
    this.setData({
      pauseTime: Date.now(),
    });
    if (wx.getStorageSync(app.config.tokenKey)) {
      let duration = this.data.pauseTime - this.data.startTime;
      this.count(duration);
    }
  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {
    if (this.data.countdownInterval !== null) {
      clearInterval(this.data.countdownInterval)
  onUnload(e) {
    if (wx.timer) {
      clearInterval(wx.timer);
    }
    if (this.data.countdownInterval !== null) {
      clearInterval(this.data.countdownInterval);
    }
    this.setData({
      pauseTime: Date.now(),
    });
    if (wx.getStorageSync(app.config.tokenKey)) {
      let duration = this.data.pauseTime - this.data.startTime;
      this.count(duration);
    }
  },

  count(timeStr) {
    const data = {
      appRefCode: app.config.appRefCode,
      type: "LearningTime", //统计类型--阅读时长
      data: timeStr + "", //统计内容--时长毫秒
      event: "LearningTime",
      sysType: "App",
    };
    //阅读商品的id
    if (this.data.bookId) {
      data.productId = this.data.bookId;
    }
    //阅读资源的id
    // if (product.cmsItemId) {
    //   data.cmsItemId = product.cmsItemId
    // }
    app.MG.job.newJobWithApiNewEvent(data).then((res) => {});
  },

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

  },
  onPullDownRefresh() {},

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

  },
  onReachBottom() {},

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

  // 监听watch
  watch(context, variableName, callback) {
    let value = context.data[variableName]; // 获取被监听属性的当前值
    // 使用 Object.defineProperty 方法在数据对象上定义属性的 getter 和 setter
    Object.defineProperty(context.data, variableName, {
      configurable: true, // 可配置
      enumerable: true, // 可枚举
      get: function () {
        return value; // 返回属性的当前值
      },
      set: function (newVal) {
        const oldVal = value; // 记录属性的旧值
        value = newVal; // 更新属性的值
        callback.call(context, newVal, oldVal); // 调用回调函数，传递新值和旧值
      },
    });
  },
  // 修改nav颜色
  changeNavBarColor(e) {
    if (type == 'night') {
      wx.setNavigationBarColor({
        backgroundColor: '#000000',
        frontColor: '#ffffff',
      })
    } else {
      wx.setNavigationBarColor({
        backgroundColor: '#ffffff',
        frontColor: '#000000',
      })
    }
  },
  // 正则找出听力src
  extractSourceSrc(htmlString) {
    // 正则表达式匹配<source>标签中的src属性值  
    var srcRegex = /<source\s+src="([^"]+)"/i;
    var srcTwo = /<audio\s+src="([^"]+)"/i;

    // 执行正则匹配  
    var match = srcRegex.exec(htmlString);
    const local = srcTwo.exec(htmlString)
    // 如果匹配成功，返回第一个捕获组的内容（src属性的值）  
    if (match && match[1]) {
      return match[1].replace('../file', app.config.requestCtx + '/file');
    } else if (local && local[1]) {
      return local[1].replace('../file', app.config.requestCtx + '/file')
    } else {
      // 如果没有匹配到，返回null  
      return null;
    }
  },

  // 拿到听力题除audio标签外其他内容
  removeVideoAndAudioTags(htmlString) {
    // 使用正则表达式匹配并移除所有的 <video> 和 <audio> 标签
    var cleanedHtml = htmlString.replace(/<video[^>]*>[\s\S]*?<\/video>|<audio[^>]*>[\s\S]*?<\/audio>/gi, '');

    return cleanedHtml;
  },

  // 改变loading状态
  changeLoadingState() {
    this.setData({
      loading: true
    })
  },
  // 返回拦截
  beforeleave() {
    if ((this.data.answerType == 'option' || this.data.answerType == 'mock') && !this.data.submitStatus) {
      wx.showModal({
        title: "提示",
        content: "未提交，是否退出答题",
        confirmColor: "#ff6c00",
        cancelColor: "#949494",
        complete: (res) => {
          if (res.cancel) {
            this.setData({
              showDialog: true
            })
          }
          if (res.confirm) {
            this.setData({
              submitStatus: true,
              showDialog: false
            });
            wx.navigateBack();
          }
        },
      });
    }
  },
  onChangeSlider(e) {
    this.setData({
      sliderValue: e.detail.value,
    });
  },
  // 返回
  goBack() {
    wx.navigateBack();
  },

  //设置背景色
  changeBGColor(e) {
    const flag = e.detail.value
    this.setData({
      isNight: flag,
    });
    if (flag) {
      wx.setNavigationBarColor({
        backgroundColor: '#000000',
        frontColor: '#ffffff',
      })
    } else {
      wx.setNavigationBarColor({
        backgroundColor: '#ffffff',
        frontColor: '#000000',
      })
    }
  },
  // 获取保存的倒计时时间
  getSavedTime() {
    const savedTime = wx.getStorageSync('countdownTime')
    return savedTime ? parseInt(savedTime) : null
    const savedTime = wx.getStorageSync("countdownTime");
    return savedTime ? parseInt(savedTime) : null;
  },
  // 保存倒计时时间到本地存储
  saveTime() {
    wx.setStorageSync('countdownTime', this.data.countdownTime.toString())
    wx.setStorageSync("countdownTime", this.data.countdownTime.toString());
  },
  clearTime() {
    this.setData({
      countdownTime: 2 * 60 * 60 * 1000
    })
      countdownTime: 2 * 60 * 60 * 1000,
    });
  },
  // 暂停或继续倒计时
  toggleCountdown() {
    if (this.data.countdownInterval) {
      clearInterval(this.data.countdownInterval)
      clearInterval(this.data.countdownInterval);
      this.setData({
        countdownInterval: null,
        isCountdownRunning: false
      })
        isCountdownRunning: false,
      });
    } else {
      this.startCountdown()
      this.startCountdown();
      this.setData({
        isCountdownRunning: true
      })
        isCountdownRunning: true,
      });
    }
  },
  // 开始倒计时
  startCountdown() {
    // 如果计时器已经存在，先清除之前的计时器
    if (this.data.countdownInterval) {
      clearInterval(this.data.countdownInterval)
      clearInterval(this.data.countdownInterval);
      this.setData({
        countdownInterval: null
      })
        countdownInterval: null,
      });
    }
    this.setData({
      countdownInterval: setInterval(() => {
        this.setData({
          countdownTime: this.data.countdownTime - 1000
        })
          countdownTime: this.data.countdownTime - 1000,
        });
        if (this.data.countdownTime <= 0) {
          clearInterval(this.data.countdownInterval)
          clearInterval(this.data.countdownInterval);
          this.setData({
            countdownTime: 0,
            isCountdownRunning: false
          })
            isCountdownRunning: false,
          });
        }
        this.saveTime()
      }, 1000)
    })
        this.saveTime();
      }, 1000),
    });
  },
  // 切换题目
  changeSwiper(e) {
    let index = e.detail.index - 1 >= 0 ? e.detail.index - 1 : 0;
    const item = this.data.questionDataList[index];
    const lastItem = this.data.questionDataList[index + 1];
    this.setData({
      currentIndex: e.detail.index
    })
    let index = e.detail.index - 1 >= 0 ? e.detail.index - 1 : 0
    let flag = this.isHaveAnswer(this.data.questionDataList[index].userAnswer)
    if (flag) this.handleQuestion(e.detail.index)

      currentIndex: e.detail.index,
      showId: lastItem.id
    });
    if (
      (this.data.answerType == "collectQuestion" ||
        this.data.answerType == "errorQuestion") &&
      !item.isComplete
    ) {
      let flag = this.isHaveAnswer(item.userAnswer);
      if (flag) this.handleQuestion(index);
    }
  },
  // 我的错题，收藏查看解析按钮
  viewParsing() {
    if (
      this.data.answerType == "collectQuestion" ||
      this.data.answerType == "errorQuestion"
    ) {
      const item = this.data.questionDataList[this.data.currentIndex];
      if (!item.isComplete) {
        this.handleQuestion(this.data.currentIndex);
      }
    }
  },
  // 点击答题卡跳转题目
  goQuestion(e) {
    console.log(e);
    const id = e.detail.id
    const id = e.detail.id;
    this.data.questionDataList.forEach((item, index) => {
      if (item.id == id) {
        this.setData({
          currentIndex: index
        })
          currentIndex: index,
        });
      }
    })
    });
  },
  // 单选 多选 触发
  onChangeRadio(e) {
    const radioData = e.detail.value.currentTarget.dataset.value
    const id = e.detail.value.currentTarget.dataset.id
    const radioChecked = e.detail.value.detail.value
    const questionList = this.data.questionDataList
    questionList.forEach(item => {
      if (item.id == id) {
        item.userAnswer = radioChecked
    const radioData = e.detail.value.currentTarget.dataset.value;
    const id = e.detail.value.currentTarget.dataset.id;
    const radioChecked = e.detail.value.detail.value;
    const questionList = this.data.questionDataList;
    // 我的错题和我的收藏模式下，单选题选择了直接批改
    for (let index = 0; index < questionList.length; index++) {
      const item = questionList[index];
      if (item.id == id && !item.isComplete) {
        item.userAnswer = radioChecked;
        item.isUserAnswer = this.isHaveAnswer(radioChecked);
        if (
          (item.questionType == "singleChoice" ||
            item.questionType == "judge") &&
          (this.data.answerType == "collectQuestion" ||
            this.data.answerType == "errorQuestion") &&
          !item.isComplete
        ) {
          this.handleQuestion(this.data.currentIndex);
        }
      }
    })
    }
    // questionList.forEach(item => {
    //   if (item.id == id && !item.isComplete) {
    //     item.userAnswer = radioChecked
    //     item.isUserAnswer = this.isHaveAnswer(radioChecked)
    //     if ((item.questionType == 'singleChoice' || item.questionType == 'judge') && (this.data.answerType == 'collectQuestion' || this.data.answerType == 'errorQuestion') && !item.isComplete) {
    //       this.handleQuestion(this.data.currentIndex)
    //     }
    //   }
    // })
    const cardListUpdata = this.data.cardList;
    for (let index = 0; index < cardListUpdata.length; index++) {
      const item = cardListUpdata[index];
      for (let cindex = 0; cindex < item.infoList.length; cindex++) {
        const citem = item.infoList[cindex];
        if (citem.id == id && !citem.isComplete) {
          citem.userAnswer = radioChecked;
          citem.isUserAnswer = this.isHaveAnswer(radioChecked);
        }
      }
    }
    // cardListUpdata.forEach(item => {
    //   item.infoList.forEach(citem => {
    //     if (citem.id == id && !citem.isComplete) {
    //       citem.userAnswer = radioChecked
    //       citem.isUserAnswer = this.isHaveAnswer(radioChecked)
    //     }
    //   })
    // })
    this.setData({
      questionDataList: questionList
    })
    console.log(this.data.questionDataList);
      questionDataList: questionList,
      cardList: cardListUpdata,
    });
    if (this.data.answerType == "mock") {
      this.setData({
        saveTime: 20,
      });
    }
  },
  // 输入框触发
  onChangeInput(e) {
    const inputData = e.detail.value.detail.value
    const id = e.detail.value.currentTarget.dataset.id
    const index = e.detail.value.currentTarget.dataset.index
    const questionList = this.data.questionDataList
    questionList.forEach(item => {
    const inputData = e.detail.value.detail.value;
    const id = e.detail.value.currentTarget.dataset.id;
    const index = Number(e.detail.value.currentTarget.dataset.index);
    const questionList = this.data.questionDataList;
    questionList.forEach((item) => {
      if (item.id == id) {
        item.userAnswer[index] = inputData
        item.userAnswer[index] = inputData;
        return (item.isUserAnswer = this.isHaveAnswer(inputData));
      }
    })
    });
    const cardListUpdata = this.data.cardList;
    cardListUpdata.forEach((item) => {
      item.infoList.forEach((citem) => {
        if (citem.id == id) {
          citem.userAnswer[index] = inputData;
          return (citem.isUserAnswer = this.isHaveAnswer(inputData));
        }
      });
    });
    this.setData({
      questionDataList: questionList
    })
    console.log(this.data.questionDataList);
      questionDataList: questionList,
      cardList: cardListUpdata,
    });
    if (this.data.answerType == "mock") {
      this.setData({
        saveTime: 20,
      });
    }
  },
  // 数组转为字符串方法
  arrayToString(data) {
    // 检查是否为数组
    if (Array.isArray(data)) {
      // 使用 join 方法将数组转换为字符串，默认使用逗号分隔
      return data.join(',').replace(/<[^>]*>/g, '')
      return data.join(",").replace(/<[^>]*>/g, "");
    } else {
      // 如果不是数组，直接返回原始值
      return data.replace(/<[^>]*>/g, '')
      return data.replace(/<[^>]*>/g, "");
    }
  },
  // 判断是否有用户答案
  isHaveAnswer(data) {
    if (typeof data == 'string') {
    if (typeof data == "string") {
      data = data
        .replace(/<[^>]*>/g, '')
        .replace(/&nbsp;/g, '')
        .trim()
        .replace(/<[^>]*>/g, "")
        .replace(/&nbsp;/g, "")
        .trim();
      if (data.length) {
        return true
        return true;
      } else {
        return false
        return false;
      }
    } else if (typeof data == "object") {
      const answer = data.find((item) => item.length > 0);
      if (answer) {
        return true;
      } else {
        return false;
      }
    } else {
      const answer = data.find((item) => item.length > 0)
      if (answer) {
        return true
      } else {
        return false
      }
      return false;
    }
  },
  // 提交逻辑
  submitPaper() {
    this.setData({
      submitStatus: true
    })
    if (this.data.answerType == 'option') {
      this.toggleCountdown()
      const child = this.selectComponent('#question-options')
      if (this.data.answerType == 'option' || this.data.answerType == 'errorQuestion') {
        // 先遍历所有题目，将未批改的题目批改
        const qustionList = this.data.questionDataList
        for (let index = 0; index < qustionList.length; index++) {
          const item = qustionList[index];
          if (!item.isComplete) this.handleQuestion(index + 1)
        }
      }
      if (this.data.answerType == 'option') {
        this.recordAnswerData()
        child.openTestReportDialog()
      }
    } else if (this.data.answerType == 'collectQuestion' || this.data.answerType == 'errorQuestion') {
      this.goBack()
    }
      submitStatus: true,
      loading: true,
    });
    const child = this.selectComponent('#question-options');

    if (
      this.data.answerType == "option" ||
      this.data.answerType == "errorQuestion" ||
      this.data.answerType == "mock" ||
      this.data.answerType == 'interaction'
    ) {
      // 先遍历所有题目，将未批改的题目批改
      const qustionList = this.data.questionDataList;
      for (let index = 0; index < qustionList.length; index++) {
        const item = qustionList[index];
        if (!item.isComplete) this.handleQuestion(index);
      }
    }
    if (this.data.answerType == "option") {
      this.toggleCountdown();
      this.recordAnswerData();
      // this.selectComponent 拿不到 组件了， 改为监听组件传值 打开弹窗
      // child.openTestReportDialog();
      this.setData({
        isShowDialog: true
      })
    } else if (
      this.data.answerType == "collectQuestion" ||
      this.data.answerType == "errorQuestion"
    ) {
      this.goBack();
    } else if (this.data.answerType == "mock") {
      this.toggleCountdown();
      // 设置模考状态为已完成
      const mockData = this.data.mockData;
      mockData.datas.forEach((item) => {
        if (item.id == this.data.uuid) {
          item.state = "3";
          item.report = {
            userScore: this.data.subjectiveNum,
          };
        }
      });
      this.setData({
        mockData: mockData,
        submitStatus: true,
      });
      this.setMockInfo(mockData.datas);
      // 记录用户答题数据
      let saveData = [];
      for (let index = 0; index < this.data.questionDataList.length; index++) {
        const item = this.data.questionDataList[index];
        saveData.push({
          id: item.id,
          answer: item.userAnswer,
          isRight: item.isRight,
        });
      }
      app.MG.identity.setUserKey({
        setKeyRequests: [{
          domain: "mockAnswerData",
          key: this.data.uuid,
          value: JSON.stringify({
            time: this.data.countdownTime,
            answerData: saveData,
          }),
        }, ],
      });
      // child.openTestReportDialog();
      this.setData({
        isShowDialog: true
      })
    } else if (this.data.answerType == 'interaction') {
      this.toggleCountdown();
      this.handleClassQuestion()
    }
    this.setData({
      loading: false,
      showDialog: false,
    });
  },
  // 初始化函数
  async init() {
@@ -277,29 +636,96 @@
      loading: true,
      subjectiveTotal: 0,
      subjectiveNum: 0,
      subjectiveGrade: 0
    })
    if (this.data.answerType == 'option') {
      subjectiveGrade: 0,
    });
    if (this.data.answerType == "option") {
      if (this.data)
        this.startCountdown()
      this.setData({
        countdownTime: 2 * 60 * 60 * 1000
      })
        this.setData({
          countdownTime: 2 * 60 * 60 * 1000,
        });
      // 测试答题
      await this.getCollectIdList() // 获取收藏id列表
      await this.getErrorList()   // 获取错题id列表
    } else if (this.data.answerType == 'collectQuestion') {
      await this.getCollectIdList(); // 获取收藏id列表
      await this.getErrorList(); // 获取错题id列表
    } else if (this.data.answerType == "interaction") {
      this.setData({
        countdownTime: 2 * 60 * 60 * 1000,
      });
      this.getCurrentClassList()
      this.getinteractionInfo()
      // 教学互动
    } else if (this.data.answerType == "collectQuestion") {
      this.setData({
        submitStatus: true,
      });
      // 我的收藏
      await this.getcollectId() // 获取收藏题目
    } else if (this.data.answerType == 'errorQuestion') {
      await this.getcollectId(); // 获取收藏题目
    } else if (this.data.answerType == "errorQuestion") {
      this.setData({
        submitStatus: true,
      });
      // 我的错题
      // loadings.value = true
      await this.getErrorIdList()
      await this.getCollectIdList() // 获取收藏id列表
      await this.getErrorIdList();
      await this.getCollectIdList(); // 获取收藏id列表
    } else if (this.data.answerType == "mock") {
      this.getErrorList();
      this.getCollectIdList();
      this.getMockInfo(async (res) => {
        let mocklist;
        try {
          mocklist = JSON.parse(res[0].value);
        } catch (error) {
          mocklist = [];
        }
        if (mocklist.length && this.data.uuid) {
          const oldMockData = mocklist.find(
            (mockItem) => mockItem.id == this.data.uuid
          );
          this.setData({
            "mockData.state": oldMockData.state,
            "mockData.score": oldMockData.score,
            "mockData.datas": mocklist,
          });
          if (oldMockData.state == "0") {
            // 组卷购买了，但未进入页面
            await this.getEduQuizConfig();
          } else if (
            oldMockData.state == "1" ||
            oldMockData.state == "2" ||
            oldMockData.state == "3"
          ) {
            // 组卷后进入过页面，但是未答过题
            let oldQuestionList = [];
            oldQuestionList = await this.getMockQuestionList();
            const userAnswerList = await this.getMockAnswer();
            this.setData({
              "mockData.sumTime": oldMockData.time,
              cardList: oldQuestionList,
            });
            await this.getMockDataList(oldQuestionList, userAnswerList);
          }
          if (
            oldMockData.state == "0" ||
            oldMockData.state == "1" ||
            oldMockData.state == "2"
          ) {
            this.startCountdown();
            this.setData({
              showDialog: true
            })
          }
          if (oldMockData.state == "3") {
            this.setData({
              submitStatus: true,
              subjectiveNum: oldMockData.report.userScore,
            });
          }
        }
      });
    }
  },
  async restart() {
    const countDownRef = this.selectComponent('#countDownRef')
    const countDownRef = this.selectComponent("#countDownRef");
    this.setData({
      loading: true,
      total: 0,
@@ -307,40 +733,39 @@
      subjectiveTotal: 0,
      subjectiveNum: 0,
      currentIndex: 0,
      submitStatus: false
    })
    if (this.data.answerType == 'option') {
      submitStatus: false,
      showDialog: true
    });
    if (this.data.answerType == "option") {
      this.setData({
        countdownTime: 2 * 60 * 60 * 1000
      })
        countdownTime: 2 * 60 * 60 * 1000,
      });
      this.delAnswerInfo(() => {
        this.getQuestionList()
        this.clearTime()
      })
        this.getQuestionList();
        this.clearTime();
      });
      if (!this.data.submitStatus) {
        this.startCountdown()
        this.startCountdown();
      }
    } else if (this.data.answerType == 'mock') {
    } else if (this.data.answerType == "mock") {
      // 组卷模式
      // 清空答题记录
      await app.MG.identity.setUserKey({
        setKeyRequests: [
          {
            domain: 'mockAnswerData',
            key: route.query.uuid,
            value: JSON.stringify({
              time: countDownRef.value.countdownTime,
              answerData: []
            })
          }
        ]
      })
      this.init()
        setKeyRequests: [{
          domain: "mockAnswerData",
          key: this.data.uuid,
          value: JSON.stringify({
            time: this.data.countdownTime,
            answerData: [],
          }),
        }, ],
      });
      this.init();
    } else {
      this.init()
      this.clearTime()
      this.init();
      this.clearTime();
      if (submitStatus.value) {
        this.startCountdown()
        this.startCountdown();
      }
    }
  },
@@ -348,88 +773,93 @@
  getCollectIdList() {
    app.MG.identity
      .getUserKey({
        domain: 'collectData',
        keys: [this.data.rootCmsItemId]
        domain: "collectData",
        keys: [this.data.rootCmsItemId],
      })
      .then((res) => {
        try {
          this.setData({
            collectList: JSON.parse(res[0].value)
          })
        } catch (error) {
        }
        if (this.data.answerType == 'option') {
            collectList: JSON.parse(res[0].value),
          });
        } catch (error) {}
        if (this.data.answerType == "option") {
          // 先获取用户答题记录
          this.getAnswerInfo(async (res) => {
            if (res.length) {
              // 有记录，不能答题，状态设为已提交
              this.setData({
                submitStatus: true
              })
              let value = JSON.parse(res[0].value)
                submitStatus: true,
              });
              let value = JSON.parse(res[0].value);
              // 有答题记录，得分赋值
              if (value) {
                this.setData({
                  submitStatus: true
                })
                  submitStatus: true,
                });
                value.dataList.forEach((item) => {
                  if (item.name == '客观题得分' && item.path == this.data.productLinkPath)
                  if (
                    item.name == "客观题得分" &&
                    item.path == this.data.productLinkPath
                  )
                    this.setData({
                      subjectiveNum: item.score
                    })
                })
                      subjectiveNum: item.score,
                    });
                });
              }
              this.setData({
                currentIndex: value.currentIndex
              })
                currentIndex: value.currentIndex,
              });
              // 携带答题记录 获取题目
              await this.getQuestionList(value.dataList)
              await this.getQuestionList(value.dataList);
            } else {
              await this.getQuestionList() // 获取题库题目
              await this.getQuestionList(); // 获取题库题目
              this.setData({
                showDialog: true
              })
            }
          })
          });
        }
      })
      });
  },
  // 获取错题id列表
  getErrorList() {
    app.MG.identity
      .getUserKey({
        domain: 'errorData',
        keys: [this.data.rootCmsItemId]
        domain: "errorData",
        keys: [this.data.rootCmsItemId],
      })
      .then((res) => {
        try {
          this.setData({
            errorList: JSON.parse(res[0].value)
          })
        } catch (error) {

        }
      })
            errorList: JSON.parse(res[0].value),
          });
        } catch (error) {}
      });
  },
  // 获取题库题目
  getQuestionList(oldData) {
  async getQuestionList(oldData) {
    // 清空正确题数记录
    this.setData({
      noData: false,
      cardList: [],
      correctNum: 0,
    })
    let flag = 0
    this.data.idPathList.forEach((pathitem) => {
      const pathList = this.data.cardList
    });
    let flag = 0;
    for (let index = 0; index < this.data.idPathList.length; index++) {
      const pathitem = this.data.idPathList[index];
      const pathList = this.data.cardList;
      pathList.push({
        path: pathitem.productLinkPath,
        catalogName: pathitem.name,
        infoList: []
      })
        infoList: [],
      });
      this.setData({
        cardList: pathList
      })
        cardList: pathList,
      });
      // 获取题目
      let query = {
        path: '*',
        queryType: '*',
        path: "*",
        queryType: "*",
        productId: this.data.bookId,
        cmsPath: pathitem.productLinkPath,
        itemFields: {
@@ -442,243 +872,340 @@
          Embedded_QuestionBank_StemStyle: [],
          Embedded_QuestionBank_OptionStyle: [],
          Embedded_QuestionBank_KnowledgePoint: [],
          Embedded_QuestionBank_Difficulty: []
          Embedded_QuestionBank_Difficulty: [],
        },
        pading: {
          start: 0,
          size: 999
        }
          size: 999,
        },
      };
      if (this.data.storeInfo) {
        query.storeInfo = this.data.storeInfo
      }
      app.MG.store.getProductDetail(query).then((res) => {
      await app.MG.store.getProductDetail(query).then((res) => {
        this.setData({
          total: res.datas.cmsDatas[0].datas.length
        })
          total: res.datas.cmsDatas[0].datas.length,
        });
        // total.value += res.datas.cmsDatas[0].datas.length
        let oldList
        let oldList;
        if (oldData) {
          // 提交过，存在答题记录
          oldList = oldData.find((item) => item.path == pathitem.productLinkPath).infoList
          this.setData({
            submitStatus: true
          })
          oldList = oldData.find(
            (item) => item.path == pathitem.productLinkPath
          ).infoList;
        }
        res.datas.cmsDatas[0].datas.forEach((item, index) => {
          let oldObj = ''
          if (oldList) oldObj = oldList.find((oldItem) => oldItem.id == item.id)
          if (this.data.storeInfo || this.data.jslx) {
            if (item.Embedded_QuestionBank_QuestionType == 'singleChoice') {
              pathitem.name = "单选题"
            } else if (item.Embedded_QuestionBank_QuestionType == 'shortAnswer') {
              pathitem.name = "简答题"
            } else if (item.Embedded_QuestionBank_QuestionType == "completion") {
              pathitem.name = "填空题";
            } else if (item.Embedded_QuestionBank_QuestionType == "multipleChoice") {
              pathitem.name = "多选题";
            } else if (item.Embedded_QuestionBank_QuestionType == "judge") {
              pathitem.name = "判断题";
            }
          }
          let oldObj = "";
          if (oldList)
            oldObj = oldList.find((oldItem) => oldItem.id == item.id);
          let questionObj = {
            // num: index, // 题号
            id: item.id,
            type: pathitem.name,
            stem:
              item.Embedded_QuestionBank_QuestionType == 'completion'
                ? JSON.parse(item.Embedded_QuestionBank_Stem)
                  .stemTxt.replaceAll('<vacancy>', ',input,')
                  .split(',')
                : JSON.parse(item.Embedded_QuestionBank_Stem), // 题干
            stem: item.Embedded_QuestionBank_QuestionType == "completion" ?
              JSON.parse(item.Embedded_QuestionBank_Stem)
              .stemTxt.replaceAll("<vacancy>", ",input,")
              .split(",") : JSON.parse(item.Embedded_QuestionBank_Stem), // 题干
            answer: item.Embedded_QuestionBank_Answer, // 答案
            option: item.Embedded_QuestionBank_Option
              ? JSON.parse(item.Embedded_QuestionBank_Option)
              : '', // 选择题选项
            option: item.Embedded_QuestionBank_Option ?
              JSON.parse(item.Embedded_QuestionBank_Option) : "", // 选择题选项
            analysisCon: item.Embedded_QuestionBank_AnalysisCon, // 解析
            questionType: item.Embedded_QuestionBank_QuestionType, // 题型
            optionStyle: item.Embedded_QuestionBank_OptionStyle, // 选项显示类型
            stemStyle: item.Embedded_QuestionBank_StemStyle, // 题干显示类型
            difficulty: item.Embedded_QuestionBank_Difficulty
              ? 4 - item.Embedded_QuestionBank_Difficulty
              : 0, // 难度等级
            userAnswer: oldObj
              ? oldObj.userAnswer
              : item.Embedded_QuestionBank_QuestionType == 'completion' ||
                item.Embedded_QuestionBank_QuestionType == 'multipleChoice'
                ? []
                : '',
            difficulty: item.Embedded_QuestionBank_Difficulty ?
              4 - item.Embedded_QuestionBank_Difficulty : 0, // 难度等级
            userAnswer: oldObj ?
              oldObj.userAnswer : item.Embedded_QuestionBank_QuestionType == "completion" ||
              item.Embedded_QuestionBank_QuestionType == "multipleChoice" ? [] : "",
            isUserAnswer: oldObj ? this.isHaveAnswer(oldObj.userAnswer) : false,
            isRight: oldObj ? oldObj.isRight : null,
            isComplete: oldObj ? oldObj.isComplete : false,
            isCollect: this.data.collectList.indexOf(item.id) > -1 ? true : false,
            isUnfold: '' // 控制解析的折叠面板是否展开
          }
            isUnfold: "", // 控制解析的折叠面板是否展开
          };
          // 多选和填空答案肯为数组，要转换JSON格式
          if (
            questionObj.questionType == 'completion' ||
            questionObj.questionType == 'multipleChoice'
            questionObj.questionType == "completion" ||
            questionObj.questionType == "multipleChoice"
          ) {
            try {
              // questionObj.answer = JSON.parse(questionObj.answer).toString();
              questionObj.answer = JSON.parse(questionObj.answer)
            } catch (error) {
              questionObj.answer = item.Embedded_QuestionBank_Answer
              questionObj.answer = item.Embedded_QuestionBank_Answer;
            }
          }
          // questionObj.userAnswer = this.arrayToString(questionObj.userAnswer)
          // questionObj.isHaveAnswer = this.isHaveAnswer(questionObj.userAnswer)
          // 填空题改造
          if (questionObj.questionType == 'completion') {
            let index = 0
          if (questionObj.questionType == "completion") {
            let index = 0;
            for (let i = 0; i < questionObj.stem.length; i++) {
              const item = questionObj.stem[i]
              if (item == 'input') {
              const item = questionObj.stem[i];
              if (item == "input") {
                questionObj.stem[i] = {
                  num: index,
                  data: 'input'
                }
                if (!oldObj) questionObj.userAnswer[index] = ''
                index++
                  data: "input",
                };
                if (!oldObj) questionObj.userAnswer[index] = "";
                index++;
              }
            }
          }
          // 获取图片
          if (questionObj.stemStyle == 'Image' || questionObj.stemStyle == 'TxtAndImage') {
            questionObj.stem.stemImage = getPublicImage(questionObj.stem.stemImage, 150)
          // 题干富文本处理
          if (questionObj.stemStyle == "RichText") {
            // questionObj.option.txt = ''
            questionObj.stem.stemTxt = questionObj.stem.stemTxt
              .replace(
                /\<img/gi,
                '<img style="max-width: 300rpx !important;object-fit: contain;" class="stem-rich-img" '
              )
              .replace(/\<p/gi, '<p class="stem-rich-p"').replace('../file', app.config.requestCtx + '/file');
          }
          if (questionObj.optionStyle == 'Image' || questionObj.optionStyle == 'TxtAndImage') {
            questionObj.option.forEach(optionItem => {
              if (optionItem.img) optionItem.img = getPublicImage(optionItem.img, 150)
            })
          // 选项富文本处理
          if (
            questionObj.optionStyle == "RichText" &&
            (questionObj.questionType == "singleChoice" ||
              questionObj.questionType == "judge" ||
              questionObj.questionType == "multipleChoice")
          ) {
            questionObj.option.forEach((item) => {
              if (item.txt)
                item.txt = item.txt
                .replace(/\<img/gi, '<img class="option-rich-img"')
                .replace(/\<p/gi, '<p class="stem-rich-p"').replace('../file', app.config.requestCtx + '/file');
            });
          }
          // 解析富文本处理
          if (
            questionObj.analysisCon &&
            typeof questionObj.analysisCon == "string"
          ) {
            questionObj.analysisCon = questionObj.analysisCon.replace(
              /\<img/gi,
              '<img style="max-width: 300rpx !important;object-fit: contain;" class="stem-rich-img" '
            );
          }
          // 听力题修改
          if (questionObj.questionType == 'singleChoice') {
            const src = this.extractSourceSrc(questionObj.stem.stemTxt)
            if (src) {
              questionObj.src = src
              questionObj.stem.stemTxt = this.removeVideoAndAudioTags(questionObj.stem.stemTxt)
            }
          }
          // 获取图片
          if (
            questionObj.stemStyle == "Image" ||
            questionObj.stemStyle == "TxtAndImage"
          ) {
            questionObj.stem.stemImage = getPublicImage(
              questionObj.stem.stemImage,
              150
            );
          }
          if (
            questionObj.optionStyle == "Image" ||
            questionObj.optionStyle == "TxtAndImage"
          ) {
            questionObj.option.forEach((optionItem) => {
              if (optionItem.img)
                optionItem.img = getPublicImage(optionItem.img, 150);
            });
          }
          // 客观题总分赋值
          if (questionObj.questionType !== "shortAnswer") {
            this.setData({
              subjectiveGrade: this.data.subjectiveGrade + 2,
            });
          }
          // if (questionObj.optionStyle == 'RichText') {
          //   questionObj.option.forEach(optionItem => {
          //     optionItem.txt.replace(/<img>/g, "<img class='imgClass'>")
          //   })
          // }
          // 旧数据里 题目已经作答，修改已答题目数量
          // if (oldObj && oldObj.userAnswer.length > 0) countDownRef.value.changeAlready()
          // 旧数据里 题目正确 记录正确数量
          if (questionObj.isRight) {
            this.setData({
              correctNum: this.data.correctNum + 1
            })
              correctNum: this.data.correctNum + 1,
            });
          }
          if (pathitem.name == '判断题' || pathitem.name == '填空题' || pathitem.name == '多选题' || pathitem.name == '单选题' || pathitem.name == '听力题') {
          if (
            pathitem.name == "判断题" ||
            pathitem.name == "填空题" ||
            pathitem.name == "多选题" ||
            pathitem.name == "单选题" ||
            pathitem.name == "听力题"
          ) {
            if (oldObj) {
              this.setData({
                subjectiveTotal: this.data.subjectiveTotal + 1
              })
                subjectiveTotal: this.data.subjectiveTotal + 1,
              });
            }

          }
          // cardList赋值
          let cardIndex = this.data.cardList.findIndex((item) => item.path == pathitem.productLinkPath)
          let infoList = this.data.cardList[cardIndex].infoList
          infoList.push(questionObj)
          let cardIndex = this.data.cardList.findIndex(
            (item) => item.path == pathitem.productLinkPath
          );
          let infoList = this.data.cardList[cardIndex].infoList;
          infoList.push(questionObj);
          this.setData({
            [`cardList[${cardIndex}].infoList`]: infoList
          })
          //   this.data.cardList[this.data.cardList.findIndex((item) => item.path == pathitem.productLinkPath)]
          //     .infoList
          // infoList.push(questionObj)
            [`cardList[${cardIndex}].infoList`]: infoList,
          });
          flag++;
          let questionList = []
          const cardUpdatedList = this.data.cardList
          let questionList = [];
          let grade = 0;
          const cardUpdatedList = this.data.cardList;
          // if (flag == this.data.idPathList.length) {
          cardUpdatedList.forEach(aitem => {
          cardUpdatedList.forEach((aitem) => {
            aitem.infoList.forEach((bitem, bindex) => {
              questionList.push(bitem)
              bitem.number = bindex + 1
              bitem.grade = 2
            })
          })
              questionList.push(bitem);
              bitem.number = bindex + 1;
              bitem.score = 2;
            });
          });
          this.setData({
            questionDataList: questionList,
            cardList: cardUpdatedList
          })
        })
            cardList: cardUpdatedList,
          });
          console.log(
            '题目', this.data.questionDataList
          );
        });
      });
    }
    // 有题目再开始倒计时
    if (this.data.questionDataList.length) {
      this.startCountdown();
      this.setData({
        loading: false,
        showId: this.data.questionDataList[0].id
      })
    })
    this.setData({
      loading: false,
    })
    } else {
      this.setData({
        noData: true,
        loading: false,
      })
    }
  },
  // 批改题目 （练习，我的错题，我的收藏）
  handleQuestion(num) {
    const questionList = this.data.questionDataList
    const index = num - 1 >= 0 ? num - 1 : 0
  // 批改题目 （练习，我的错题，我的收藏,，组卷）
  handleQuestion(index) {
    const questionList = this.data.questionDataList;
    if (questionList[index].isComplete) {
      // 题目已完成，跳过
      return true
      return true;
    }
    questionList[index].isComplete = true
    const item = questionList[index]
    questionList[index].isComplete = true;
    const item = questionList[index];
    // 批改题目
    if (item.questionType == 'multipleChoice') {
    if (item.questionType == "multipleChoice") {
      // 多选题
      // subjectiveGrade.value += item.score
      if (item.answer.length == item.userAnswer.length) {
        const sortedArr1 = item.answer.slice().sort()
        const sortedArr2 = item.userAnswer.slice().sort()
        const sortedArr1 = item.answer.slice().sort();
        const sortedArr2 = item.userAnswer.slice().sort();
        questionList[index].isRight = sortedArr1.every(
          (value, valueIndex) => value === sortedArr2[valueIndex]
        )
        );
      } else {
        questionList[index].isRight = false
        questionList[index].isRight = false;
      }
    } else if (item.questionType == 'singleChoice' || item.questionType == 'judge') {
    } else if (
      item.questionType == "singleChoice" ||
      item.questionType == "judge"
    ) {
      // 单选 判断
      // subjectiveGrade.value += item.score
      questionList[index].isRight = item.answer == item.userAnswer
    } else if (item.questionType == 'shortAnswer') {
      questionList[index].isRight = item.answer == item.userAnswer;
    } else if (item.questionType == "shortAnswer") {
      // 简答 翻译
      questionList[index].isRight = null
    } else if (item.questionType == 'completion') {
      // 填空
      // subjectiveGrade.value += item.score
      if (typeof item.answer == 'string') {
        questionList[index].isRight = item.answer == item.userAnswer[0]
      questionList[index].isRight = null;
    } else if (item.questionType == "completion") {
      if (typeof item.answer == "string") {
        item.isRight = item.answer == item.userAnswer[0];
      } else {
        if (item.answer.length != item.userAnswer.length) {
          questionList[index].isRight = false
          item.isRight = false;
        } else {
          item.isRight = item.answer.every(
            (value, index) => value === item.userAnswer[index]
          );
        }
      }
      if (typeof item.answer == "string") {
        questionList[index].isRight = item.answer == item.userAnswer[0];
      } else {
        if (item.answer.length != item.userAnswer.length) {
          questionList[index].isRight = false;
        } else {
          questionList[index].isRight = item.answer.every(
            (value, valueIndex) => value === item.userAnswer[valueIndex]
          )
          );
        }
      }
    }
    if (item.questionType != 'shortAnswer') {
    if (item.questionType != "shortAnswer") {
      this.setData({
        subjectiveTotal: this.data.subjectiveTotal + 1,
        subjectiveGrade: this.data.subjectiveGrade + item.grade
      })
      });
    }
    if (questionList[index].isRight && item.questionType != 'shortAnswer') {
    if (questionList[index].isRight && item.questionType != "shortAnswer") {
      // 客观题回答正确
      this.setData({
        subjectiveNum: this.data.subjectiveNum + item.grade,
        correctNum: this.data.correctNum + 1
      })
        subjectiveNum: this.data.subjectiveNum + item.score,
        correctNum: this.data.correctNum + 1,
      });
    }
    if (!questionList[index].isRight && item.questionType != 'shortAnswer') {
    if (!questionList[index].isRight && item.questionType != "shortAnswer") {
      // 客观题回答错误 记录错题
      if (this.data.errorList.findIndex((errorItem) => errorItem == item.id) == -1) {
        this.data.errorList.push(item.id)
      if (
        this.data.errorList.findIndex((errorItem) => errorItem == item.id) == -1
      ) {
        this.data.errorList.push(item.id);
      }
    } else {
      if (this.data.answerType == 'errorQuestion' || this.data.answerType == 'option') {
      if (
        this.data.answerType == "errorQuestion" ||
        this.data.answerType == "option"
      ) {
        // 从错题集中移除
        let errorIndex = this.data.errorList.findIndex((erroritem) => erroritem == item.id)
        let errorIndex = this.data.errorList.findIndex(
          (erroritem) => erroritem == item.id
        );
        if (errorIndex > -1) {
          this.data.errorList.splice(errorIndex, 1)
          this.data.errorList.splice(errorIndex, 1);
        }
      }
    }
    if (this.data.answerType != 'collectQuestion') {
    if (this.data.answerType != "collectQuestion") {
      // 记录错题
      app.MG.identity
        .setUserKey({
          setKeyRequests: [
            {
              domain: 'errorData',
              key: this.data.rootCmsItemId,
              value: JSON.stringify(this.data.errorList)
            }
          ]
          setKeyRequests: [{
            domain: "errorData",
            key: this.data.rootCmsItemId,
            value: JSON.stringify(this.data.errorList),
          }, ],
        })
        .then((res) => {
          console.log(res)
        })
          console.log(res);
        });
    }

    this.setData({
      questionDataList: questionList
    })
    const cardUpdatedList = this.data.cardList
      questionDataList: questionList,
    });
    const cardUpdatedList = this.data.cardList;
    cardUpdatedList.forEach((item) => {
      item.infoList.forEach((citem) => {
        if (citem.id == questionList[index].id) {
@@ -687,337 +1214,447 @@
      });
    });
    this.setData({
      cardList: cardUpdatedList
    })
    // console.log(this.data.questionDataList, this.data.cardList);
      cardList: cardUpdatedList,
    });
  },
  // 题目收藏按钮,收藏和取消同一接口，取消数组减去该项id
  setCollect() {
    const citem = this.data.questionDataList[this.data.currentIndex]
    const questionList = this.data.questionDataList
    const citem = this.data.questionDataList[this.data.currentIndex];
    const questionList = this.data.questionDataList;
    for (let index = 0; index < questionList.length; index++) {
      const item = questionList[index];
      if (item.id == citem.id) {
        item.isCollect = !item.isCollect
        item.isCollect = !item.isCollect;
      }
    }
    this.setData({
      questionDataList: questionList
    })
      questionDataList: questionList,
    });
    if (this.data.collectList.length == 0) {
      this.setData({
        collectList: [citem.id]
      })
        collectList: [citem.id],
      });
    } else {
      const collectItme = this.data.collectList.filter((item) => item == citem.id)
      const collectItme = this.data.collectList.filter(
        (item) => item == citem.id
      );
      if (collectItme.length) {
        const arr = this.data.collectList.filter((item) => item != citem.id)
        const arr = this.data.collectList.filter((item) => item != citem.id);
        this.setData({
          collectList: arr
        })
          collectList: arr,
        });
      } else {
        const collectArr = this.data.collectList
        collectArr.push(citem.id)
        const collectArr = this.data.collectList;
        collectArr.push(citem.id);
        this.setData({
          collectList: collectArr
        })
          collectList: collectArr,
        });
      }
    }
    app.MG.identity
      .setUserKey({
        setKeyRequests: [
          {
            domain: 'collectData',
            key: this.data.rootCmsItemId,
            value: JSON.stringify(this.data.collectList)
          }
        ]
        setKeyRequests: [{
          domain: "collectData",
          key: this.data.rootCmsItemId,
          value: JSON.stringify(this.data.collectList),
        }, ],
      })
      .then((res) => { })
      .then((res) => {});
  },
  // 处理答题数据
  recordAnswerData() {
    this.data.cardList.push(
      {
        name: '客观题得分',
        score: this.data.subjectiveNum,
        path: this.data.productLinkPath,
        // infoList: [],
        // catalogName: ''
      }
    )
    this.data.cardList.push({
      name: "客观题得分",
      score: this.data.subjectiveNum,
      path: this.data.productLinkPath,
      // infoList: [],
      // catalogName: ''
    });
    let setInfoData = {
      currentIndex: this.data.currentIndex,
      dataList: JSON.parse(JSON.stringify(this.data.cardList))
    }
      dataList: JSON.parse(JSON.stringify(this.data.cardList)),
    };
    for (let i = 0; i < setInfoData.dataList.length; i++) {
      const item = setInfoData.dataList[i]
      if (!item.name && !item.name == '客观题得分') {
      const item = setInfoData.dataList[i];
      if (!item.name && !item.name == "客观题得分") {
        for (let j = 0; j < item.infoList.length; j++) {
          let obj = {
            id: item.infoList[j].id,
            userAnswer: item.infoList[j].userAnswer,
            isComplete: item.infoList[j].isComplete,
            isRight: item.infoList[j].isRight,
            isCollect: item.infoList[j].isCollect
          }
          item.infoList[j] = obj
            isCollect: item.infoList[j].isCollect,
          };
          item.infoList[j] = obj;
        }
      }
    }

    this.setAnswerInfo(setInfoData)
    this.setAnswerInfo(setInfoData);
  },
  // 提交答题数据
  setAnswerInfo(data) {
    app.MG.identity
      .setUserKey({
        setKeyRequests: [
          {
            domain: 'answerData',
            key: this.data.productLinkPath,
            value: JSON.stringify(data)
          }
        ]
        setKeyRequests: [{
          domain: "answerData",
          key: this.data.productLinkPath,
          value: JSON.stringify(data),
        }, ],
      })
      .then((res) => { })
      .then((res) => {});
  },
  // 获取答题数据
  // 获取旧答题数据
  getAnswerInfo(callback) {
    app.MG.identity
      .getUserKey({
        domain: 'answerData',
        keys: [this.data.productLinkPath]
        domain: "answerData",
        keys: [this.data.productLinkPath],
      })
      .then((res) => {
        if (callback) callback(res)
      })
        if (callback) callback(res);
      });
  },
  // 删除答题数据
  // 删除旧答题数据
  delAnswerInfo(callback) {
    app.MG.identity
      .delUserKey({
        domain: 'answerData',
        keys: [this.data.productLinkPath]
        domain: "answerData",
        keys: [this.data.productLinkPath],
      })
      .then((res) => {
        if (callback) callback()
      })
        if (callback) callback();
      });
  },
  // 我的收藏模式下获取收藏题目id
  async getcollectId() {
    app.MG.identity
      .getUserKey({
        domain: 'collectData',
        keys: [this.data.rootCmsItemId]
        domain: "collectData",
        keys: [this.data.rootCmsItemId],
      })
      .then(async (res) => {
        try {
          this.setData({
            collectList: JSON.parse(res[0].value)
          })
          // total.value = collectList.value.length
        } catch (error) {
        }
            collectList: JSON.parse(res[0].value),
          });
        } catch (error) {}
        if (this.data.collectList && this.data.collectList.length) {
          await this.getCollectDataList()
          await this.getCollectDataList();
        } else {
          this.setData({
            loading: false
          })
            loading: false,
            noData: true
          });
          wx.showModal({
            title: '提示',
            content: '收藏夹暂无数据',//editable如果为true，这就是输入框的内容
            editable: false,//是否显示输入框
            title: "提示",
            content: "收藏夹暂无数据", //editable如果为true，这就是输入框的内容
            confirmColor: "#ff6c00",
            cancelColor: "#949494",
            editable: false, //是否显示输入框
            showCancel: false,
            success: (res) => {
              if (res.confirm) {
                this.setData({
                  submitStatus: true
                })
                this.goBack()
                  submitStatus: true,
                });
                this.goBack();
              }

            }
          })
            },
          });
        }
        // console.log('收藏', collectList.value)
      })
      });
  },
  // 获取收藏夹
  async getCollectDataList() {
    let questionArr = []
    let questionArr = [];
    this.setData({
      cardList: [
      cardList: [{
          catalogName: "单选题",
          infoList: [],
        },
        {
          catalogName: '收藏夹',
          infoList: []
        }
      ]
    })
    let query = {
      path: '*',
      cmsPath: this.data.rootCmsItemId,
      cmsType: '*',
      productId: this.data.bookId,
      queryType: '*',
      itemIds: this.data.collectList.map((item) => item + ''),
      itemFields: {
        Embedded_QuestionBank_Stem: [],
        Embedded_QuestionBank_AnalysisCon: [],
        Embedded_QuestionBank_Answer: [],
        Embedded_QuestionBank_Option: [],
        Embedded_QuestionBank_QuestionType: [],
        Embedded_QuestionBank_StemStyle: [],
        Embedded_QuestionBank_OptionStyle: [],
        Embedded_QuestionBank_KnowledgePoint: [],
        Embedded_QuestionBank_Difficulty: []
          catalogName: "判断题",
          infoList: [],
        },
        {
          catalogName: "多选题",
          infoList: [],
        },
        {
          catalogName: "填空题",
          infoList: [],
        },
        {
          catalogName: "简答题",
          infoList: [],
        },
      ],
    });
    let singleChoiceArr = []; // 单选
    let judgeArr = []; // 判断
    let shortArr = []; // 简答
    let multipleChoiceArr = []; // 多选
    let completionArr = []; // 填空
    for (let qindex = 0; qindex < this.data.collectList.length; qindex++) {
      const qitem = this.data.collectList[qindex];
      let query = {
        path: "*",
        cmsPath: this.data.rootCmsItemId,
        cmsType: "*",
        productId: this.data.bookId,
        queryType: "*",
        itemIds: qitem + "",
        itemFields: {
          Embedded_QuestionBank_Stem: [],
          Embedded_QuestionBank_AnalysisCon: [],
          Embedded_QuestionBank_Answer: [],
          Embedded_QuestionBank_Option: [],
          Embedded_QuestionBank_QuestionType: [],
          Embedded_QuestionBank_StemStyle: [],
          Embedded_QuestionBank_OptionStyle: [],
          Embedded_QuestionBank_KnowledgePoint: [],
          Embedded_QuestionBank_Difficulty: [],
        },
      };
      if (this.data.storeInfo) {
        query.storeInfo = this.data.storeInfo
      }
    }
    app.MG.store.getProductDetail(query).then((res) => {
      let questionArr = []
      res.datas.cmsDatas[0].datas.forEach((item, index) => {
        const questionObj = {
          number: index + 1, // 题号
          id: item.id,
          stem:
            item.Embedded_QuestionBank_QuestionType == 'completion'
              ? JSON.parse(item.Embedded_QuestionBank_Stem)
                .stemTxt.replaceAll('<vacancy>', ',input,')
                .split(',')
              : JSON.parse(item.Embedded_QuestionBank_Stem), // 题干
          answer: item.Embedded_QuestionBank_Answer, // 答案
          option: item.Embedded_QuestionBank_Option
            ? JSON.parse(item.Embedded_QuestionBank_Option)
            : '', // 选择题选项
          analysisCon: item.Embedded_QuestionBank_AnalysisCon, // 解析
          questionType: item.Embedded_QuestionBank_QuestionType, // 题型
          optionStyle: item.Embedded_QuestionBank_OptionStyle, // 选项显示类型
          stemStyle: item.Embedded_QuestionBank_StemStyle, // 题干显示类型
          difficulty: item.Embedded_QuestionBank_Difficulty
            ? 4 - item.Embedded_QuestionBank_Difficulty
            : 0, // 难度等级
          userAnswer:
            item.Embedded_QuestionBank_QuestionType == 'completion' ||
              item.Embedded_QuestionBank_QuestionType == 'multipleChoice'
              ? []
              : '',
          isSubmit: false, // 查看解析
          isRight: null, // 是否正确
          isComplete: false,
          isCollect: true
        }
        // 多选和填空答案肯为数组，要转换JSON格式
        if (
          questionObj.questionType == 'completion' ||
          questionObj.questionType == 'multipleChoice'
        ) {
          try {
            questionObj.answer = JSON.parse(questionObj.answer)
          } catch (error) {
            //
          }
        }
        // 填空题改造
        if (questionObj.questionType == 'completion') {
          let index = 0
          for (let i = 0; i < questionObj.stem.length; i++) {
            const item = questionObj.stem[i]
            if (item == 'input') {
              questionObj.stem[i] = {
                num: index,
                data: 'input'
              }
              questionObj.userAnswer[index] = ''
              index++
      await app.MG.store.getProductDetail(query).then((res) => {
        let questionArr = [];
        res.datas.cmsDatas[0].datas.forEach((item, index) => {
          const questionObj = {
            number: index + 1, // 题号
            id: item.id,
            stem: item.Embedded_QuestionBank_QuestionType == "completion" ?
              JSON.parse(item.Embedded_QuestionBank_Stem)
              .stemTxt.replaceAll("<vacancy>", ",input,")
              .split(",") : JSON.parse(item.Embedded_QuestionBank_Stem), // 题干
            answer: item.Embedded_QuestionBank_Answer, // 答案
            option: item.Embedded_QuestionBank_Option ?
              JSON.parse(item.Embedded_QuestionBank_Option) : "", // 选择题选项
            analysisCon: item.Embedded_QuestionBank_AnalysisCon, // 解析
            questionType: item.Embedded_QuestionBank_QuestionType, // 题型
            optionStyle: item.Embedded_QuestionBank_OptionStyle, // 选项显示类型
            stemStyle: item.Embedded_QuestionBank_StemStyle, // 题干显示类型
            difficulty: item.Embedded_QuestionBank_Difficulty ?
              4 - item.Embedded_QuestionBank_Difficulty : 0, // 难度等级
            userAnswer: item.Embedded_QuestionBank_QuestionType == "completion" ||
              item.Embedded_QuestionBank_QuestionType == "multipleChoice" ? [] : "",
            isSubmit: false, // 查看解析
            isRight: null, // 是否正确
            isComplete: false,
            isCollect: true,
          };
          // 多选和填空答案肯为数组，要转换JSON格式
          if (
            questionObj.questionType == "completion" ||
            questionObj.questionType == "multipleChoice"
          ) {
            console.log(questionObj.answer, "111")
            try {
              questionObj.answer = JSON.parse(questionObj.answer).toString();
            } catch (error) {
              questionObj.answer = item.Embedded_QuestionBank_Answer;
            }
          }
        }
        // 获取图片
        if (questionObj.stemStyle == 'Image' || questionObj.stemStyle == 'TxtAndImage') {
          questionObj.stem.stemImage = getPublicImage(questionObj.stem.stemImage, 150)
        }
        if (questionObj.optionStyle == 'Image' || questionObj.optionStyle == 'TxtAndImage') {
          questionObj.option.forEach(optionItem => {
            if (optionItem.img) optionItem.img = getPublicImage(optionItem.img, 150)
          })
        }
        // if (item.Embedded_QuestionBank_QuestionType == 'judge') {
        //   topicList.value.judge.data.push(questionObj)
        // } else if (item.Embedded_QuestionBank_QuestionType == 'singleChoice') {
        //   topicList.value.radio.data.push(questionObj)
        // } else if (item.Embedded_QuestionBank_QuestionType == 'multipleChoice') {
        //   topicList.value.check.data.push(questionObj)
        // } else if (item.Embedded_QuestionBank_QuestionType == 'completion') {
        //   topicList.value.gap.data.push(questionObj)
        // } else if (item.Embedded_QuestionBank_QuestionType == 'shortAnswer') {
        //   topicList.value.short.data.push(questionObj)
        // }
        questionArr.push(questionObj)
        // cardList.value[0].infoList.push(questionObj)
      })
      // loadings.value = false
      this.setData({
        questionDataList: questionArr,
        ['cardList[0].infoList']: questionArr,
        loading: false,
      })
    })
          // 填空题改造
          if (questionObj.questionType == "completion") {
            let index = 0;
            for (let i = 0; i < questionObj.stem.length; i++) {
              const item = questionObj.stem[i];
              if (item == "input") {
                questionObj.stem[i] = {
                  num: index,
                  data: "input",
                };
                questionObj.userAnswer[index] = "";
                index++;
              }
            }
          }
          // 获取图片
          if (
            questionObj.stemStyle == "Image" ||
            questionObj.stemStyle == "TxtAndImage"
          ) {
            questionObj.stem.stemImage = getPublicImage(
              questionObj.stem.stemImage,
              150
            );
          }
          if (
            questionObj.optionStyle == "Image" ||
            questionObj.optionStyle == "TxtAndImage"
          ) {
            questionObj.option.forEach((optionItem) => {
              if (optionItem.img)
                optionItem.img = getPublicImage(optionItem.img, 150);
            });
          }
          // 题干富文本处理
          if (questionObj.stemStyle == "RichText") {
            // questionObj.option.txt = ''
            questionObj.stem.stemTxt = questionObj.stem.stemTxt
              .replace(
                /\<img/gi,
                '<img style="max-width: 300rpx !important;object-fit: contain;" class="stem-rich-img" '
              )
              .replace(/\<p/gi, '<p class="stem-rich-p"').replace('../file', app.config.requestCtx + '/file');
          }
          // 选项富文本处理
          if (
            questionObj.optionStyle == "RichText" &&
            (questionObj.questionType == "singleChoice" ||
              questionObj.questionType == "judge" ||
              questionObj.questionType == "multipleChoice")
          ) {
            questionObj.option.forEach((item) => {
              if (item.txt)
                item.txt = item.txt
                .replace(/\<img/gi, '<img class="option-rich-img"')
                .replace(/\<p/gi, '<p class="stem-rich-p"').replace('../file', app.config.requestCtx + '/file');
            });
          }
          // 解析富文本处理
          if (
            questionObj.analysisCon &&
            typeof questionObj.analysisCon == "string"
          ) {
            questionObj.analysisCon = questionObj.analysisCon.replace(
              /\<img/gi,
              '<img style="max-width: 300rpx !important;object-fit: contain;" class="stem-rich-img" '
            );
          }
          // 听力题修改
          if (questionObj.questionType == 'singleChoice') {
            const src = this.extractSourceSrc(questionObj.stem.stemTxt)
            if (src) {
              questionObj.src = src
              questionObj.stem.stemTxt = this.removeVideoAndAudioTags(questionObj.stem.stemTxt)
            }
          }
          if (item.Embedded_QuestionBank_QuestionType == "judge") {
            questionObj.type = "判断题";
            judgeArr.push(questionObj);
          } else if (
            item.Embedded_QuestionBank_QuestionType == "singleChoice"
          ) {
            questionObj.type = "单选题";
            singleChoiceArr.push(questionObj);
          } else if (
            item.Embedded_QuestionBank_QuestionType == "multipleChoice"
          ) {
            questionObj.type = "多选题";
            multipleChoiceArr.push(questionObj);
          } else if (item.Embedded_QuestionBank_QuestionType == "completion") {
            questionObj.type = "填空题";
            completionArr.push(questionObj);
          } else if (item.Embedded_QuestionBank_QuestionType == "shortAnswer") {
            questionObj.type = "简答题";
            shortArr.push(questionObj);
          }
        });
      });
    }
    this.setData({
      ["cardList[0].infoList"]: singleChoiceArr,
      ["cardList[1].infoList"]: judgeArr,
      ["cardList[2].infoList"]: multipleChoiceArr,
      ["cardList[3].infoList"]: completionArr,
      ["cardList[4].infoList"]: shortArr,
    });
    const cardList = this.data.cardList;
    for (let index = 0; index < cardList.length; index++) {
      const item = cardList[index];
      for (let cindex = 0; cindex < item.infoList.length; cindex++) {
        const citem = item.infoList[cindex];
        citem.number = cindex + 1;
        questionArr.push(citem);
      }
    }
    this.setData({
      questionDataList: questionArr,
      showId: questionArr[0].id,
      cardList: cardList,
      loading: false,
    });
  },
  // 我的错题模式下获取错题id列表
  async getErrorIdList() {
    await app.MG.identity
      .getUserKey({
        domain: 'errorData',
        keys: [this.data.rootCmsItemId]
        domain: "errorData",
        keys: [this.data.rootCmsItemId],
      })
      .then((res) => {
        try {
          this.setData({
            errorList: JSON.parse(res[0].value)
          })
        } catch (error) {
        }
            errorList: JSON.parse(res[0].value),
          });
        } catch (error) {}
        if (this.data.errorList && this.data.errorList.length) {
          this.getErrorDataList()
          this.getErrorDataList();
        } else {
          this.setData({
            loading: true
          })
            loading: false,
            noData: true
          });
          wx.showModal({
            title: '提示',
            content: '错题集暂无数据',//editable如果为true，这就是输入框的内容
            editable: false,//是否显示输入框
            title: "提示",
            content: "错题集暂无数据", //editable如果为true，这就是输入框的内容
            confirmColor: "#ff6c00",
            cancelColor: "#949494",
            editable: false, //是否显示输入框
            showCancel: false,
            success: (res) => {
              if (res.confirm) {
                this.setData({
                  submitStatus: true
                })
                this.goBack()
                  submitStatus: true,
                });
                this.goBack();
              }
            }
          })
            },
          });
        }
      })
      });
  },
  // 获取错题集
  async getErrorDataList() {
    this.setData({
      cardList: [
      cardList: [{
          catalogName: "单选题",
          infoList: [],
        },
        {
          catalogName: '错题集',
          infoList: []
        }
      ]
    })
          catalogName: "判断题",
          infoList: [],
        },
        {
          catalogName: "多选题",
          infoList: [],
        },
        {
          catalogName: "填空题",
          infoList: [],
        },
        {
          catalogName: "简答题",
          infoList: [],
        },
      ],
    });
    let singleChoiceArr = []; // 单选
    let judgeArr = []; // 判断
    let shortArr = []; // 简答
    let multipleChoiceArr = []; // 多选
    let completionArr = []; // 填空
    let query = {
      path: '*',
      path: "*",
      cmsPath: this.data.rootCmsItemId,
      cmsType: '*',
      cmsType: "*",
      productId: this.data.bookId,
      queryType: '*',
      itemIds: this.data.errorList.map((item) => item + ''),
      queryType: "*",
      itemIds: this.data.errorList.map((item) => item + ""),
      itemFields: {
        Embedded_QuestionBank_Stem: [],
        Embedded_QuestionBank_AnalysisCon: [],
@@ -1027,97 +1664,856 @@
        Embedded_QuestionBank_StemStyle: [],
        Embedded_QuestionBank_OptionStyle: [],
        Embedded_QuestionBank_KnowledgePoint: [],
        Embedded_QuestionBank_Difficulty: []
      }
        Embedded_QuestionBank_Difficulty: [],
      },
    };
    if (this.data.storeInfo) {
      query.storeInfo = this.data.storeInfo
    }
    await app.MG.store.getProductDetail(query).then((res) => {
      let questionArr = []
      let questionArr = [];
      res.datas.cmsDatas[0].datas.forEach((item, index) => {
        const questionObj = {
          number: index + 1, // 题号
          id: item.id,
          stem:
            item.Embedded_QuestionBank_QuestionType == 'completion'
              ? JSON.parse(item.Embedded_QuestionBank_Stem)
                .stemTxt.replaceAll('<vacancy>', ',input,')
                .split(',')
              : JSON.parse(item.Embedded_QuestionBank_Stem), // 题干
          stem: item.Embedded_QuestionBank_QuestionType == "completion" ?
            JSON.parse(item.Embedded_QuestionBank_Stem)
            .stemTxt.replaceAll("<vacancy>", ",input,")
            .split(",") : JSON.parse(item.Embedded_QuestionBank_Stem), // 题干
          answer: item.Embedded_QuestionBank_Answer, // 答案
          option: item.Embedded_QuestionBank_Option
            ? JSON.parse(item.Embedded_QuestionBank_Option)
            : '', // 选择题选项
          option: item.Embedded_QuestionBank_Option ?
            JSON.parse(item.Embedded_QuestionBank_Option) : "", // 选择题选项
          analysisCon: item.Embedded_QuestionBank_AnalysisCon, // 解析
          questionType: item.Embedded_QuestionBank_QuestionType, // 题型
          optionStyle: item.Embedded_QuestionBank_OptionStyle, // 选项显示类型
          stemStyle: item.Embedded_QuestionBank_StemStyle, // 题干显示类型
          difficulty: item.Embedded_QuestionBank_Difficulty
            ? 4 - item.Embedded_QuestionBank_Difficulty
            : 0, // 难度等级
          userAnswer:
            item.Embedded_QuestionBank_QuestionType == 'completion' ||
              item.Embedded_QuestionBank_QuestionType == 'multipleChoice'
              ? []
              : '',
          difficulty: item.Embedded_QuestionBank_Difficulty ?
            4 - item.Embedded_QuestionBank_Difficulty : 0, // 难度等级
          userAnswer: item.Embedded_QuestionBank_QuestionType == "completion" ||
            item.Embedded_QuestionBank_QuestionType == "multipleChoice" ? [] : "",
          isSubmit: false, // 查看解析
          isRight: null, // 是否正确
          isComplete: false,
          isCollect: this.data.collectList.some((collectItem) => collectItem == item.id)
        }
          isCollect: this.data.collectList.some(
            (collectItem) => collectItem == item.id
          ),
        };
        // 多选和填空答案肯为数组，要转换JSON格式
        if (
          questionObj.questionType == 'completion' ||
          questionObj.questionType == 'multipleChoice'
          questionObj.questionType == "completion" ||
          questionObj.questionType == "multipleChoice"
        ) {
          try {
            questionObj.answer = JSON.parse(questionObj.answer)
            questionObj.answer = JSON.parse(questionObj.answer).toString();
          } catch (error) {
            //
            questionObj.answer = item.Embedded_QuestionBank_Answer;
          }
        }
        // 填空题改造
        if (questionObj.questionType == 'completion') {
          let index = 0
        if (questionObj.questionType == "completion") {
          let index = 0;
          for (let i = 0; i < questionObj.stem.length; i++) {
            const item = questionObj.stem[i]
            if (item == 'input') {
            const item = questionObj.stem[i];
            if (item == "input") {
              questionObj.stem[i] = {
                num: index,
                data: 'input'
              }
              questionObj.userAnswer[index] = ''
              index++
                data: "input",
              };
              questionObj.userAnswer[index] = "";
              index++;
            }
          }
        }
        // 获取图片
        if (questionObj.stemStyle == 'Image' || questionObj.stemStyle == 'TxtAndImage') {
          questionObj.stem.stemImage = getPublicImage(questionObj.stem.stemImage, 150)
        if (
          questionObj.stemStyle == "Image" ||
          questionObj.stemStyle == "TxtAndImage"
        ) {
          questionObj.stem.stemImage = getPublicImage(
            questionObj.stem.stemImage,
            150
          );
        }
        if (questionObj.optionStyle == 'Image' || questionObj.optionStyle == 'TxtAndImage') {
          questionObj.option.forEach(optionItem => {
            if (optionItem.img) optionItem.img = getPublicImage(optionItem.img, 150)
          })
        if (
          questionObj.optionStyle == "Image" ||
          questionObj.optionStyle == "TxtAndImage"
        ) {
          questionObj.option.forEach((optionItem) => {
            if (optionItem.img)
              optionItem.img = getPublicImage(optionItem.img, 150);
          });
        }
        // if (item.Embedded_QuestionBank_QuestionType == 'judge') {
        //   topicList.value.judge.data.push(questionObj)
        // } else if (item.Embedded_QuestionBank_QuestionType == 'singleChoice') {
        //   topicList.value.radio.data.push(questionObj)
        // } else if (item.Embedded_QuestionBank_QuestionType == 'multipleChoice') {
        //   topicList.value.check.data.push(questionObj)
        // } else if (item.Embedded_QuestionBank_QuestionType == 'completion') {
        //   topicList.value.gap.data.push(questionObj)
        // } else if (item.Embedded_QuestionBank_QuestionType == 'shortAnswer') {
        //   topicList.value.short.data.push(questionObj)
        // }
        questionArr.push(questionObj)
      })
        // 题干富文本处理
        if (questionObj.stemStyle == "RichText") {
          // questionObj.option.txt = ''
          questionObj.stem.stemTxt = questionObj.stem.stemTxt
            .replace(
              /\<img/gi,
              '<img style="max-width: 300rpx !important;object-fit: contain;" class="stem-rich-img" '
            )
            .replace(/\<p/gi, '<p class="stem-rich-p"').replace('../file', app.config.requestCtx + '/file');
        }
        // 选项富文本处理
        if (
          questionObj.optionStyle == "RichText" &&
          (questionObj.questionType == "singleChoice" ||
            questionObj.questionType == "judge" ||
            questionObj.questionType == "multipleChoice")
        ) {
          questionObj.option.forEach((item) => {
            if (item.txt)
              item.txt = item.txt
              .replace(/\<img/gi, '<img class="option-rich-img"')
              .replace(/\<p/gi, '<p class="stem-rich-p"').replace('../file', app.config.requestCtx + '/file');
          });
        }
        // 解析富文本处理
        if (
          questionObj.analysisCon &&
          typeof questionObj.analysisCon == "string"
        ) {
          questionObj.analysisCon = questionObj.analysisCon.replace(
            /\<img/gi,
            '<img style="max-width: 300rpx !important;object-fit: contain;" class="stem-rich-img" '
          );
        }
        // 听力题修改
        if (questionObj.questionType == 'singleChoice') {
          const src = this.extractSourceSrc(questionObj.stem.stemTxt)
          if (src) {
            questionObj.src = src
            questionObj.stem.stemTxt = this.removeVideoAndAudioTags(questionObj.stem.stemTxt)
            console.log('题干', questionObj.stem.stemTxt);
          }
        }
        if (item.Embedded_QuestionBank_QuestionType == "judge") {
          questionObj.type = "判断题";
          judgeArr.push(questionObj);
        } else if (item.Embedded_QuestionBank_QuestionType == "singleChoice") {
          questionObj.type = "单选题";
          singleChoiceArr.push(questionObj);
        } else if (
          item.Embedded_QuestionBank_QuestionType == "multipleChoice"
        ) {
          questionObj.type = "多选题";
          multipleChoiceArr.push(questionObj);
        } else if (item.Embedded_QuestionBank_QuestionType == "completion") {
          questionObj.type = "填空题";
          completionArr.push(questionObj);
        } else if (item.Embedded_QuestionBank_QuestionType == "shortAnswer") {
          questionObj.type = "简答题";
          shortArr.push(questionObj);
        }
        // questionArr.push(questionObj)
      });
      this.setData({
        // questionDataList: questionArr,
        ["cardList[0].infoList"]: singleChoiceArr,
        ["cardList[1].infoList"]: judgeArr,
        ["cardList[2].infoList"]: multipleChoiceArr,
        ["cardList[3].infoList"]: completionArr,
        ["cardList[4].infoList"]: shortArr,
        // loading: false
      });
      const cardList = this.data.cardList;
      for (let index = 0; index < cardList.length; index++) {
        const item = cardList[index];
        for (let cindex = 0; cindex < item.infoList.length; cindex++) {
          const citem = item.infoList[cindex];
          citem.number = cindex + 1;
          questionArr.push(citem);
        }
      }
      this.setData({
        questionDataList: questionArr,
        ['cardList[0].infoList']: questionArr,
        loading: false
        showId: questionArr[0].id,
        cardList: cardList,
        loading: false,
      });
      console.log(this.data.questionDataList, "questionDataList");
    });
  },
  // 获取组卷结果
  async getEduQuizConfig() {
    await app.MG.edu
      .getEduQuizConfigResult({
        idOrRefCode: this.data.mockid,
      })
      .then(async (configRes) => {
        // 获取 分数 时间
        this.setData({
          "mockData.score": configRes.score,
        });
        try {
          this.setData({
            "mockData.time": JSON.parse(configRes.config).time * 1000,
            countdownTime: JSON.parse(configRes.config).time * 1000,
          });
        } catch (error) {
          this.setData({
            "mockData.time": 3600 * 1000,
            countdownTime: 3600 * 1000,
          });
        }
        this.setData({
          "mockData.sumTime": this.data.mockData.time,
        });
        let itemIds = [];
        let numberIndex = 1;
        // 获取抽题结果
        const cardList = configRes.eduQuizConfigStageResultList.map((item) => {
          let questionIds = [];
          // 获取必含题目
          let list = item.cmsItemList.map((idItem) => {
            itemIds.push(idItem.id + "");
            questionIds.push({
              id: idItem.id + "",
              score: idItem.score,
            });
            numberIndex++;
            return {
              number: numberIndex,
              id: idItem.id,
              score: idItem.score,
            };
          });
          // 获取抽题题目
          let extractList = [];
          for (let i = 0; i < item.generatorResultList.length; i++) {
            const extractItem = item.generatorResultList[i];
            let extractItemList = extractItem.cmsItemList.map(
              (extractCmsItem) => {
                itemIds.push(extractCmsItem.id + "");
                questionIds.push({
                  id: extractCmsItem.id + "",
                  score: extractCmsItem.score,
                });
                numberIndex++;
                return {
                  number: numberIndex,
                  id: extractCmsItem.id,
                  score: extractCmsItem.score,
                };
              }
            );
            extractList = extractList.concat(extractItemList);
          }
          return {
            path: item.id,
            catalogName: item.name,
            infoList: list.concat(extractList),
          };
        });
        this.setData({
          cardList: cardList,
        });
        // 更新该条组卷的数据状态，包括记录改试卷总分，更改组卷状态state为1，表示已经抽题完成，并要将抽屉数据记录下来
        if (this.data.mockData.datas && this.data.mockData.datas.length) {
          const mockData = this.data.mockData;
          mockData.datas.forEach((item, index) => {
            if (item.id == this.data.uuid) {
              item.state = "1";
              item.time = mockData.time;
              item.score = configRes.score;
              mockData.state = "1";
            }
          });
          this.setData({
            mockData: mockData,
          });
        }
        this.setMockInfo(this.data.mockData.datas); // 记录试卷总分 时长，修改state为 1
        // 更新本地mockData
        this.saveMockQuestionList(this.data.cardList); // 记录题目列表
        await this.getMockDataList(this.data.cardList); // 请求题目数据
      });
  },
  // 获取组卷题目列表
  async getMockDataList(questionList, oldList) {
    const questionDataList = this.data.questionDataList;
    for (let pathindex = 0; pathindex < questionList.length; pathindex++) {
      const pathitem = questionList[pathindex];
      let itemIds = [];
      pathitem.infoList.forEach((item) => {
        itemIds.push(item.id + "");
      });
      let query = {
        path: "*",
        cmsPath: this.data.rootCmsItemId,
        cmsType: "*",
        productId: this.data.bookId,
        queryType: "*",
        itemIds,
        itemFields: {
          Embedded_QuestionBank_Stem: [],
          Embedded_QuestionBank_AnalysisCon: [],
          Embedded_QuestionBank_Answer: [],
          Embedded_QuestionBank_Option: [],
          Embedded_QuestionBank_QuestionType: [],
          Embedded_QuestionBank_StemStyle: [],
          Embedded_QuestionBank_OptionStyle: [],
          Embedded_QuestionBank_KnowledgePoint: [],
          Embedded_QuestionBank_Difficulty: [],
        },
      };
      if (this.data.storeInfo) {
        query.storeInfo = this.data.storeInfo
      }
      await app.MG.store.getProductDetail(query).then((res) => {
        res.datas.cmsDatas[0].datas.forEach((item, index) => {
          // 循环questionList,给每题赋值分数
          let oldObj;
          if (oldList)
            oldObj = oldList.find((oldItem) => oldItem.id == item.id);
          let questionObj = {
            // number: pathitem.infoList.find(infoItem => infoItem.itemId == item.id).number,
            id: item.id,
            score: pathitem.infoList.find((infoItem) => infoItem.id == item.id)
              .score,
            stem: item.Embedded_QuestionBank_QuestionType == "completion" ?
              JSON.parse(item.Embedded_QuestionBank_Stem)
              .stemTxt.replaceAll("<vacancy>", ",input,")
              .split(",") : JSON.parse(item.Embedded_QuestionBank_Stem), // 题干
            answer: item.Embedded_QuestionBank_Answer, // 答案
            option: item.Embedded_QuestionBank_Option ?
              JSON.parse(item.Embedded_QuestionBank_Option) : "", // 选择题选项
            analysisCon: item.Embedded_QuestionBank_AnalysisCon, // 解析
            questionType: item.Embedded_QuestionBank_QuestionType, // 题型
            optionStyle: item.Embedded_QuestionBank_OptionStyle, // 选项显示类型
            stemStyle: item.Embedded_QuestionBank_StemStyle, // 题干显示类型
            difficulty: item.Embedded_QuestionBank_Difficulty ?
              4 - item.Embedded_QuestionBank_Difficulty : 0, // 难度等级
            userAnswer: oldObj ?
              oldObj.answer : item.Embedded_QuestionBank_QuestionType == "completion" ||
              item.Embedded_QuestionBank_QuestionType == "multipleChoice" ? [] : "",
            isUserAnswer: oldObj ? this.isHaveAnswer(oldObj.answer) : false,
            isRight: oldObj ? oldObj.isRight : null,
            // isComplete: oldObj ? oldObj.isComplete : false,
            isComplete: this.data.mockData.state == "3" ? true : false,
            isCollect: this.data.collectList.indexOf(item.id) > -1 ? true : false,
            isUnfold: "", // 控制解析的折叠面板是否展开
          };
          // 多选和填空答案肯为数组，要转换JSON格式
          if (
            questionObj.questionType == "completion" ||
            questionObj.questionType == "multipleChoice"
          ) {
            try {
              questionObj.answer = JSON.parse(questionObj.answer).toString();
            } catch (error) {
              questionObj.answer = item.Embedded_QuestionBank_Answer;
            }
          }
          // 填空题改造
          if (questionObj.questionType == "completion") {
            let index = 0;
            for (let i = 0; i < questionObj.stem.length; i++) {
              const item = questionObj.stem[i];
              if (item == "input") {
                questionObj.stem[i] = {
                  num: index,
                  data: "input",
                };
                if (!oldObj) questionObj.userAnswer[index] = "";
                index++;
              }
            }
          }
          // 题干富文本处理
          if (questionObj.stemStyle == "RichText") {
            // questionObj.option.txt = ''
            questionObj.stem.stemTxt = questionObj.stem.stemTxt.replace(
              /\<img/gi,
              '<img style="max-width: 300rpx !important;object-fit: contain;" class="stem-rich-img"'
            ).replace(/\<p/gi, '<p class="stem-rich-p"').replace('../file', app.config.requestCtx + '/file');
          }
          // 选项富文本处理
          if (
            questionObj.optionStyle == "RichText" &&
            (questionObj.questionType == "singleChoice" ||
              questionObj.questionType == "judge" ||
              questionObj.questionType == "multipleChoice")
          ) {
            questionObj.option.forEach((item) => {
              if (item.txt)
                item.txt = item.txt.replace(
                  /\<img/gi,
                  '<img class="option-rich-img"'
                ).replace(/\<p/gi, '<p class="stem-rich-p"').replace('../file', app.config.requestCtx + '/file');
            });
          }
          // 听力题修改
          if (questionObj.questionType == 'singleChoice') {
            const src = this.extractSourceSrc(questionObj.stem.stemTxt)
            if (src) {
              questionObj.src = src
              questionObj.stem.stemTxt = this.removeVideoAndAudioTags(questionObj.stem.stemTxt)
            }
          }
          // 获取图片
          if (
            questionObj.stemStyle == "Image" ||
            questionObj.stemStyle == "TxtAndImage"
          ) {
            questionObj.stem.stemImage = getPublicImage(
              questionObj.stem.stemImage,
              150
            );
          }
          if (
            questionObj.optionStyle == "Image" ||
            questionObj.optionStyle == "TxtAndImage"
          ) {
            questionObj.option.forEach((optionItem) => {
              if (optionItem.img)
                optionItem.img = getPublicImage(optionItem.img, 150);
            });
          }
          // 客观题总分赋值
          if (questionObj.questionType !== "shortAnswer") {
            this.setData({
              subjectiveGrade: this.data.subjectiveGrade + questionObj.score,
            });
          }
          if (oldObj && oldObj.isRight) {
            this.setData({
              correctNum: this.data.correctNum + 1,
            });
          }
          if (item.questionType != "shortAnswer" && item.isComplete) {
            this.setData({
              subjectiveTotal: this.data.subjectiveTotal + 1,
            });
          }
          // if (oldObj && isHaveAnswer(oldObj.answer)) countDownRef.value.changeAlready()
          // cardList赋值
          let cardIndex = this.data.cardList.findIndex(
            (item) => item.catalogName == pathitem.catalogName
          );
          let infoIndex = this.data.cardList[cardIndex].infoList.findIndex(
            (infoItem) => infoItem.id == item.id
          );
          this.setData({
            [`cardList[${cardIndex}].infoList[${infoIndex}]`]: questionObj,
          });
          let questionList = [];
          const cardUpdatedList = this.data.cardList;
          cardUpdatedList.forEach((aitem) => {
            aitem.infoList.forEach((bitem, bindex) => {
              questionList.push(bitem);
              bitem.number = bindex + 1;
            });
          });
          this.setData({
            questionDataList: questionList,
            cardList: cardUpdatedList,
          });
        });
      });
    }
    this.setData({
      loading: false,
      showId: this.data.questionDataList[0].id
    });
  },
  // 获取组卷数据
  getMockInfo(callback) {
    app.MG.identity
      .getUserKey({
        domain: "mockData",
        keys: [this.data.bookId],
      })
      .then((res) => {
        if (callback) callback(res);
      });
  },
  // 记录购买组卷时间
  setMockInfo(data) {
    app.MG.identity.setUserKey({
      setKeyRequests: [{
        domain: "mockData",
        key: this.data.bookId + "",
        value: JSON.stringify(data),
      }, ],
    });
  },
  // 记录组卷题目列表
  saveMockQuestionList(data) {
    app.MG.identity
      .setUserKey({
        setKeyRequests: [{
          domain: "mockQuestionData",
          key: this.data.uuid,
          value: JSON.stringify(data),
        }, ],
      })
      .then((res) => {
        console.log("模考题目列表已记录");
      });
  },
  // 获取记录组卷题目列表
  async getMockQuestionList() {
    let list = [];
    await app.MG.identity
      .getUserKey({
        domain: "mockQuestionData",
        keys: [this.data.uuid],
      })
      .then((res) => {
        list = JSON.parse(res[0].value);
      });
    return list;
  },
  // 获取模考用户答题数据
  async getMockAnswer() {
    let data;
    await app.MG.identity
      .getUserKey({
        domain: "mockAnswerData",
        keys: [this.data.uuid],
      })
      .then((res) => {
        if (res[0]) {
          // 这里的 countdownTime 赋值：如果是时间到了提交，记录的剩余时间就是0，所以：如果是0的话赋值1秒，防止监听到时间为0再次提交
          this.setData({
            currentIndex: JSON.parse(res[0].value).currentIndex,
            "mockData.time": JSON.parse(res[0].value).time,
            countdownTime: JSON.parse(res[0].value).time > 0 ?
              JSON.parse(res[0].value).time : 1000,
            "mockData.answer": JSON.parse(res[0].value).answerData,
          });
          console.log(JSON.parse(res[0].value));
          data = JSON.parse(res[0].value).answerData;
        }
      });
    return data;
  },

  // 记录模考答题数据
  saveMockData() {
    const data = this.data.mockData.datas.find(
      (itme) => itme.id == this.data.uuid
    );
    if (data.state == "3") return true;
    const saveData = this.data.mockData.answer;
    for (let i = 0; i < this.data.questionDataList.length; i++) {
      const item = this.data.questionDataList[i];
      if (this.isHaveAnswer(item.userAnswer)) {
        const index = saveData.findIndex((saveitem) => saveitem.id == item.id);
        if (index + "" != "-1") {
          saveData[index].answer = item.userAnswer;
        } else {
          saveData.push({
            id: item.id,
            answer: item.userAnswer,
          });
        }
      }
    }
    //
    if (this.data.mockData.state == "1") {
      const datas = this.data.mockData.datas;
      datas.forEach((item) => {
        if (item.id == this.data.uuid) {
          item.state = "2";
        }
      });
      this.setMockInfo(datas);
    }
    //
    app.MG.identity
      .setUserKey({
        setKeyRequests: [{
          domain: "mockAnswerData",
          key: this.data.uuid,
          value: JSON.stringify({
            currentIndex: this.data.currentIndex,
            time: this.data.countdownTime,
            answerData: saveData,
          }),
        }, ],
      })
      .then((res) => {
        this.setData({
          saveTime: 20,
        });
        console.log("模考答题数据已记录");
      });
  },

  // 富文本处理
  formatRichText(html) {
    let newContent = html.replace(/<img[^>]*>/gi, function (match, capture) {
      match = match
        .replace(/style="[^"]+"/gi, "")
        .replace(/style='[^']+'/gi, "");
      match = match
        .replace(/width="[^"]+"/gi, "")
        .replace(/width='[^']+'/gi, "");
      match = match
        .replace(/height="[^"]+"/gi, "")
        .replace(/height='[^']+'/gi, "");
      return match;
    });
    newContent = newContent.replace(
      /style="[^"]+"/gi,
      function (match, capture) {
        match = match
          .replace(/<p>/gi, '<p class="p_class">')
          .replace(/width:[^;]+;/gi, "max-width:100%;")
          .replace(/width:[^;]+;/gi, "max-width:100%;");
        return match;
      }
    );
    newContent = newContent.replace(/<br[^>]*\/>/gi, "");
    newContent = newContent.replace(/<a>/gi, '<a class="p_class "');
    newContent = newContent.replace(/<li>/gi, '<li class="p_class "');
    newContent = newContent.replace(/\<p/gi, '<p class="p_class "');
    newContent = newContent.replace(/\<span/gi, '<span class="p_class "');
    newContent = newContent.replace(
      /\<img/gi,
      '<img style="max-width:100%;height:auto;display:block;margin-top:0;margin-bottom:0;"'
    );
    return newContent;
  },
  // 教学互动模式相关
  // 获取班级列表
  getCurrentClassList() {
    const query = {
      start: 0,
      size: 999,
      filterList: [],
    }
    app.MG.identity.joinedGroupByList(query).then((res) => {
      console.log('班级信息', res);
      res.datas.forEach(async item => {
        item.topicId = null
        const data = await this.getTopicInfo(item.id)
        if (data) {
          item.topicId = data.id
        }
      })

      if (res.datas.length) {
        this.setData({
          classList: res.datas
        })
        // 判断班级 是否所属于该书
        const flag = res.datas.some(item => item.linkProductDto.product.id == this.data.bookId)
        if (!flag) {
          this.setData({
            visible: true,
          })
        } else {
          this.setData({
            visible: false,
            joinGroup: true
          })
        }
      } else {
        this.setData({
          visible: true,
        })
      }

      // if (res.datas.length) {
      //   this.setData({
      //     classList: res.datas,
      //     visible: true
      //   })
      // } else {
      //   // 未加入班级，唤起加入班级弹窗
      //   this.setData({
      //     joinGroup: false,
      //     visible: true
      //   })
      // }
    })
  },
  // 加入班级
  joinClass(e) {
    const data = {
      refCode: e.detail.value
    }
    app.MG.identity.joinGroupByRefCode(data).then((res) => {
      if (res == '组不存在') {
        wx.showToast({
          icon: 'error',
          title: '无效的班级',
        })
      } else if (res == '组成员数量已最大,不能加入') {
        wx.showToast({
          icon: 'error',
          title: '班级成员数量已最大，不能加入',
        })
      } else if (res == '已经申请过加入此组') {
        wx.showToast({
          icon: 'error',
          title: '已经申请过加入此班级',
        })
      } else {
        wx.showToast({
          icon: "success",
          title: '已成功，等待审核中...',
        })
        this.setData({
          visible: false
        })
        this.getCurrentClassList()
      }
    })
  },
  // 获取班级topic
  async getTopicInfo(classId) {
    let query = {
      classId,
      refCodes: ["TeachInteraction"]
    }
    const res = await app.MG.edu.getClassTopic(query)
    return res[0] ?? null
  },
  // 获取旧教学互动答题数据
  getinteractionInfo() {
    app.MG.identity
      .getUserKey({
        domain: "interactionData",
        keys: [this.data.productLinkPath],
      })
      .then((res) => {
        if (res.length) {
          let value = JSON.parse(res[0].value);
          const scoreData = value.dataList.find(item => item.name == "客观题得分" && item.path == this.data.productLinkPath)
          this.setData({
            submitStatus: value.submitStatus,
            currentIndex: value.currentIndex,
            subjectiveNum: scoreData ? scoreData.score : 0
          });
          // 携带答题记录 获取题目
          this.getQuestionList(value.dataList);
        } else {
          this.getQuestionList(); // 获取题库题目
          this.setData({
            showDialog: true
          })
        }
      });
  },
  // 提交教学互动答题数据
  setinteractionInfo(submitStatus) {
    const list = []
    this.data.cardList.forEach(item => {
      list.push({
        catalogName: item.catalogName,
        path: item.path,
        infoList: item.infoList.map((citem) => ({
          id: citem.id,
          userAnswer: citem.userAnswer
        }))
      })
    })
    // loadings.value = false
    // console.log('错题集', topicList.value)
  }
})
    list.push({
      name: "客观题得分",
      score: this.data.subjectiveNum,
      path: this.data.productLinkPath,
    })
    console.log('提交数据', list);
    app.MG.identity
      .setUserKey({
        setKeyRequests: [{
          domain: "interactionData",
          key: this.data.productLinkPath,
          value: JSON.stringify({
            submitStatus,
            currentIndex: this.data.currentIndex,
            dataList: list
          }),
        }, ],
      })
      .then((res) => {});
  },
  // 处理教学互动答题 
  handleClassQuestion() {
    console.log(1, this.data.questionDataList);
    const flag = this.data.questionDataList.some(item => !item.userAnswer)
    if (flag) {
      // 没做完，保存即可
      const isAnswer = this.data.questionDataList.some(item => item.userAnswer)
      if (isAnswer) this.setinteractionInfo(false)
    } else {
      // 做完了且加入了班级，提交到message
      if (this.data.classList.length && this.data.joinGroup) {
        this.data.classList.forEach(item => {
          if (item.linkProductDto.product.id == this.data.bookId)
            this.newTopicMessage(item.topicId)
        })
        this.setinteractionInfo(true)
      } else {
        // 做完了，没加入班级
        this.setinteractionInfo(false)
      }
      this.setData({
        isShowDialog: true
      })
    }
    this.setData({
      submitStatus: true
    })
  },

  // 新建topicMessage
  newTopicMessage(topicId) {
    let content = []
    for (let cindex = 0; cindex < this.data.questionDataList.length; cindex++) {
      const citem = this.data.questionDataList[cindex];
      content.push({
        cmsItemId: citem.id,
        answer: citem.userAnswer,
        state: citem.questionType == 'shortAnswer' ? 'none' : citem.isRight,
        type: citem.questionType
      })
    }
    const data = {
      description: '',
      icon: '',
      state: 'Normal',
      topicIdOrRefCode: String(topicId),
      name: this.data.answerTitle,
      content: JSON.stringify({
        bookId: this.data.bookId,
        userName: JSON.parse(wx.getStorageSync(app.config.userInfoKey)).name,
        path: this.data.productLinkPath,
        content
      }),
      type: 'Normal',
      cmsTypeRefCode: '',
      newDataListRequest: []
    }
    app.MG.ugc.newTopicMessage(data).then((res) => {
      if (res) {
        this.setData({
          isShowDialog: true
        })
      }
    })
  },
  // 新建子topicMessage
  // newTopicSubMessage(parentId,topicId) {
  //   const data = {
  //     description: '',
  //     icon: '',
  //     parentId,
  //     state: 'Normal',
  //     topicIdOrRefCode: String(topicId),
  //     name: this.data.answerTitle,
  //     content: '',
  //     type: 'Normal',
  //     cmsTypeRefCode: '',
  //     newDataListRequest: []
  //   }
  //   MG.ugc.newTopicMessage(data).then((res) => {
  //     if (res) {

  //     }
  //   })
  // },
});