ai-question-pro 0.0.22 → 0.0.23

package/components/demo/src/main.vue

@@ -9,41 +9,41 @@
           <img src="../static/logo.png" alt="" style="width: 32px; height: 18px;"/>
           <span>出题</span>
         </div>
-        <div class="ai-bot-switch-wrap" style="position: absolute; left: 120px">
-          <div class="ai-bot-switch" @click="dropdownVisible = !dropdownVisible">
-            <img src="../static/aiBot-icon.png" alt="" style="width: 24px; height: 24px">
-            <span class="ai-bot-label">
-                    {{ currentBot === 'course' ? '课程智能体' : '通义千问' }}
-                  </span>
-            <img src="../static/check-icon.png" alt="" style="width: 12px; height: 12px">
-          </div>
-          <div
-              v-if="dropdownVisible"
-              class="ai-bot-dropdown"
-              @mousedown.prevent
-              style="position: absolute; z-index: 1000; min-width: 20%;"
-          >
-            <div
-                class="ai-bot-dropdown-item"
-                :class="{ active: currentBot === 'tongyi' }"
-                @click="selectBot('tongyi')"
-            >通义千问
-            </div>
+<!--        <div class="ai-bot-switch-wrap" style="position: absolute; left: 120px">-->
+<!--          <div class="ai-bot-switch" @click="dropdownVisible = !dropdownVisible">-->
+<!--            <img src="../static/aiBot-icon.png" alt="" style="width: 24px; height: 24px">-->
+<!--            <span class="ai-bot-label">-->
+<!--                    {{ currentBot === 'course' ? '课程智能体' : '通义千问' }}-->
+<!--                  </span>-->
+<!--            <img src="../static/check-icon.png" alt="" style="width: 12px; height: 12px">-->
+<!--          </div>-->
+<!--          <div-->
+<!--              v-if="dropdownVisible"-->
+<!--              class="ai-bot-dropdown"-->
+<!--              @mousedown.prevent-->
+<!--              style="position: absolute; z-index: 1000; min-width: 20%;"-->
+<!--          >-->
 <!--            <div-->
-<!--                v-if="courseId"-->
 <!--                class="ai-bot-dropdown-item"-->
-<!--                :class="{ active: currentBot === 'course' }"-->
-<!--                @click="selectBot('course')"-->
-<!--            >课程智能体-->
+<!--                :class="{ active: currentBot === 'tongyi' }"-->
+<!--                @click="selectBot('tongyi')"-->
+<!--            >通义千问-->
 <!--            </div>-->
-          </div>
-        </div>
+<!--&lt;!&ndash;            <div&ndash;&gt;-->
+<!--&lt;!&ndash;                v-if="courseId"&ndash;&gt;-->
+<!--&lt;!&ndash;                class="ai-bot-dropdown-item"&ndash;&gt;-->
+<!--&lt;!&ndash;                :class="{ active: currentBot === 'course' }"&ndash;&gt;-->
+<!--&lt;!&ndash;                @click="selectBot('course')"&ndash;&gt;-->
+<!--&lt;!&ndash;            >课程智能体&ndash;&gt;-->
+<!--&lt;!&ndash;            </div>&ndash;&gt;-->
+<!--          </div>-->
+<!--        </div>-->
       </template>
       <div class="add_question_body">
         <div class="question-type-header">
           <span class="required-mark">*</span>
           <span class="section-title">题目类型：</span>
-          <span class="tip-text">(为避免您等待时间过长，一次性最多生成10道题)</span>
+          <span class="tip-text">(为避免您等待时间过长，所选择题型数量总和最好不超过10道</span>
         </div>
 
         <!-- 题目类型列表 -->
@@ -299,7 +299,7 @@ export default {
         {name: '简答题', id: 'shortanswer'},
       ],
       difficultyList: [
-        {name: '超级简单', id: 0},
+        {name: '非常简单', id: 0},
         {name: '简单', id: 1},
         {name: '一般', id: 2},
         {name: '困难', id: 3},
@@ -314,6 +314,8 @@ export default {
       joinedQuestions: [], // 存储已加入题库的题目索引
       retryCountMap: {}, // 存储每个题目的重试次数
       isGenerating: false, // 内部loading状态
+      typeGeneratedCounts: {}, // 跟踪每个题型已生成的数量
+      pendingGenerations: [], // 待生成的题目队列
     }
   },
   watch: {
@@ -448,6 +450,15 @@ export default {
         return this.$message.warning('请至少选择一种题目类型')
       }
 
+      // 验证选中的题目类型是否都输入了数量
+      for (let type of selectedTypes) {
+        const count = this.form.typeCounts[type]
+        if (!count || count <= 0) {
+          const typeName = this.quesTypeList.find(item => item.id === type)?.name || type
+          return this.$message.warning(`请为${typeName}输入生成数量`)
+        }
+      }
+
       // 验证是否选择了知识点
       if (!this.form.knowledgeIds) {
         return this.$message.warning('请选择关联知识点')
@@ -501,39 +512,119 @@ export default {
       });
     },
 
-    reSend() {
+    // 重新生成失败的题目 - 需要指定具体的题型和难度
+    reSend(failedQuestionType = null, failedDifficulty = null) {
       this.isGenerating = true;
+      
+      // 如果没有指定失败的题型，则需要分析哪个题型还缺少题目
+      let targetType = failedQuestionType;
+      let targetDifficulty = failedDifficulty;
+      
+      if (!targetType) {
+        // 分析哪个题型的数量不足
+        const selectedTypes = Object.keys(this.form.selectedTypes).filter(key => this.form.selectedTypes[key]);
+        for (let type of selectedTypes) {
+          const expectedCount = this.form.typeCounts[type];
+          const actualCount = this.typeGeneratedCounts[type] || 0;
+          if (actualCount < expectedCount) {
+            targetType = type;
+            targetDifficulty = this.form.typeDifficulties[type];
+            break;
+          }
+        }
+      }
+      
+      // 如果找不到需要补充的题型，说明数量已经足够
+      if (!targetType) {
+        this.isGenerating = false;
+        return;
+      }
+
+      // 使用 generateSingleQuestion 方法来生成指定题型
+      this.generateSingleQuestion(targetType, targetDifficulty);
+    },
+
+    //发送请求
+    sendPost() {
+      checkVersion(this.businessSource).then(res => {
+        console.log(res);
+        if (res.errCode === '403') {
+          this.$message.warning(res.errMessage)
+        } else {
+          this.postQuestion();
+        }
+      });
+    },
+
+    postQuestion() {
+      this.rebuildFlag = true;
+      this.generateCount = 0;
+      this.aiResponse = {}
+      this.isGenerating = true;
+
+      // 初始化题型生成计数器
+      this.typeGeneratedCounts = {};
+      this.pendingGenerations = [];
+
       const selectedTypes = Object.keys(this.form.selectedTypes).filter(key => this.form.selectedTypes[key])
-      const questionTypes = selectedTypes
-      const difficultys = selectedTypes.map(type => this.form.typeDifficulties[type])
 
+      // 初始化每个题型的计数器和待生成队列
+      selectedTypes.forEach(type => {
+        this.typeGeneratedCounts[type] = 0;
+        const count = this.form.typeCounts[type] || 1;
+        
+        // 将每个需要生成的题目加入队列
+        for (let i = 0; i < count; i++) {
+          this.pendingGenerations.push({
+            type: type,
+            difficulty: this.form.typeDifficulties[type],
+            index: i
+          });
+        }
+      });
+
+      // 开始生成题目
+      this.pendingGenerations.forEach(item => {
+        this.generateSingleQuestion(item.type, item.difficulty);
+      });
+    },
+
+    // 生成单个题目的方法
+    generateSingleQuestion(questionType, difficulty) {
       let obj = {
         modelType: 'aliyun',
         questionAddCmd: {
-          questionTypes: questionTypes,
+          questionTypes: [questionType], // 指定单个题型
           count: 1,
           knowledge: this.form.knowledge.join(' '),
           knowledgeId: this.form.knowledgeId[this.form.knowledgeId.length - 1],
-          difficultys: difficultys,
+          difficultys: [difficulty],
           prompt: this.form.prompt
         },
         sessionId: this.aiResponse.sessionId ? this.aiResponse.sessionId : '',
         businessSource: this.businessSource,
         courseId: this.courseId,
       }
-
+      
       getAiQuestion(obj).then(res => {
         if (res.success) {
-          this.loading && this.loading.close()
           if (res.data && res.data.questions && res.data.questions.length > 0) {
             const newQuestion = res.data.questions[0];
-            const questionType = newQuestion.type;
+            
             // 检查是否有重复的题目标题和题型
             const isDuplicate = this.checkDuplicateQuestion(newQuestion, questionType);
             
             if (isDuplicate) {
+              // 重复题目，重新生成
               const repetitionQuestions = this.getGeneratedQuestionsByType(questionType);
-              this.regenerateWithRepetitionForReSend(obj, repetitionQuestions, questionType);
+              this.regenerateWithRepetition(obj, repetitionQuestions, questionType);
+              return;
+            }
+            
+            // 验证返回的题目类型是否正确
+            if (newQuestion.type && newQuestion.type !== questionType) {
+              console.log(`期望题型: ${questionType}, 实际题型: ${newQuestion.type}, 重新生成`);
+              this.generateSingleQuestion(questionType, difficulty);
               return;
             }
             
@@ -545,10 +636,15 @@ export default {
             this.$set(newQuestion, 'evaluate', 0)
             // 设置题目类型，便于后续统计
             this.$set(newQuestion, 'type', questionType)
+            
+            // 更新该题型的生成计数
+            this.typeGeneratedCounts[questionType]++;
+            
             this.showGenerateResult();
           } else {
             this.$message.warning('题目获取失败,重新生成中...')
-            return this.reSend()
+            // 重新生成指定题型
+            this.generateSingleQuestion(questionType, difficulty);
           }
         } else {
           this.isGenerating = false;
@@ -563,91 +659,6 @@ export default {
       })
     },
 
-    //发送请求
-    sendPost() {
-      checkVersion(this.businessSource).then(res => {
-        console.log(res);
-        if (res.errCode === '403') {
-          this.$message.warning(res.errMessage)
-        } else {
-          this.postQuestion();
-        }
-      });
-    },
-
-    postQuestion() {
-      this.rebuildFlag = true;
-      this.generateCount = 0;
-      this.aiResponse = {}
-      this.isGenerating = true;
-
-      const selectedTypes = Object.keys(this.form.selectedTypes).filter(key => this.form.selectedTypes[key])
-
-      // 按题型分别生成题目
-      selectedTypes.forEach(type => {
-        const count = this.form.typeCounts[type] || 1;
-        const difficulty = this.form.typeDifficulties[type];
-
-        // 为每种题型生成指定数量的题目
-        for (let i = 0; i < count; i++) {
-          let obj = {
-            modelType: 'aliyun',
-            questionAddCmd: {
-              questionTypes: [type], // 单个题型
-              count: 1,
-              knowledge: this.form.knowledge.join(' '),
-              knowledgeId: this.form.knowledgeId[this.form.knowledgeId.length - 1],
-              difficultys: [difficulty], // 对应的难度
-              prompt: this.form.prompt
-            },
-            sessionId: this.aiResponse.sessionId ? this.aiResponse.sessionId : '',
-            businessSource: this.businessSource,
-            courseId: this.courseId,
-          }
-          
-          getAiQuestion(obj).then(res => {
-            if (res.success) {
-              if (res.data && res.data.questions && res.data.questions.length > 0) {
-                const newQuestion = res.data.questions[0];
-                
-                // 检查是否有重复的题目标题和题型
-                const isDuplicate = this.checkDuplicateQuestion(newQuestion, type);
-                
-                if (isDuplicate) {
-                  // 只传递当前题型
-                  const repetitionQuestions = this.getGeneratedQuestionsByType(type);
-                  this.regenerateWithRepetition(obj, repetitionQuestions, type);
-                  return;
-                }
-                
-                if (this.aiResponse.questions && this.aiResponse.questions.length > 0) {
-                  this.aiResponse.questions.push(newQuestion);
-                } else {
-                  this.aiResponse = res.data;
-                }
-                this.$set(newQuestion, 'evaluate', 0)
-                // 设置题目类型，便于后续统计
-                this.$set(newQuestion, 'type', type)
-                this.showGenerateResult();
-              } else {
-                this.$message.warning('题目获取失败,重新生成中...')
-                return this.reSend()
-              }
-            } else {
-              this.isGenerating = false;
-              this.$message.warning('题目获取失败')
-              this.rebuildFlag = false;
-            }
-          }).catch(error => {
-            console.log("error:" + error);
-            this.isGenerating = false;
-            this.$message.warning('题目获取失败')
-            this.rebuildFlag = false;
-          })
-        }
-      });
-    },
-
     //获取知识点名称
     getKnowledgeName(e, array) {
       array.forEach(item => {
@@ -839,6 +850,13 @@ export default {
             this.$set(newQuestion, 'evaluate', 0)
             // 设置题目类型，便于后续统计
             this.$set(newQuestion, 'type', questionType)
+            
+            // 更新该题型的生成计数
+            if (!this.typeGeneratedCounts[questionType]) {
+              this.typeGeneratedCounts[questionType] = 0;
+            }
+            this.typeGeneratedCounts[questionType]++;
+            
             this.showGenerateResult();
           } else {
             this.$message.warning('重新生成题目失败')