ai-question-pro 0.0.21 → 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>
 
         <!-- 题目类型列表 -->
@@ -160,6 +160,12 @@
           </div>
         </div>
         <div class="question_body" ref="generateDiv">
+          <div v-if="isGenerating" class="generating-loading">
+            <div class="loading-content">
+              <div class="loading-spinner"></div>
+              <div class="loading-text">AI生成中...</div>
+            </div>
+          </div>
           <questionItem v-if="aiResponse.questions && aiResponse.questions.length > 0" @agree="agree" @join="join"
                         @selectionChange="handleQuestionSelection"
                         :isJoined="joinedQuestions.includes(idx)"
@@ -293,7 +299,7 @@ export default {
         {name: '简答题', id: 'shortanswer'},
       ],
       difficultyList: [
-        {name: '超级简单', id: 0},
+        {name: '非常简单', id: 0},
         {name: '简单', id: 1},
         {name: '一般', id: 2},
         {name: '困难', id: 3},
@@ -306,6 +312,10 @@ export default {
       currentBot: 'tongyi',
       selectedQuestions: [], // 存储选中的题目
       joinedQuestions: [], // 存储已加入题库的题目索引
+      retryCountMap: {}, // 存储每个题目的重试次数
+      isGenerating: false, // 内部loading状态
+      typeGeneratedCounts: {}, // 跟踪每个题型已生成的数量
+      pendingGenerations: [], // 待生成的题目队列
     }
   },
   watch: {
@@ -440,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('请选择关联知识点')
@@ -483,6 +502,7 @@ export default {
       if (this.generateCount == totalCount) {
         this.$message.success('题目(' + totalCount + '道)全部生成完毕！');
         this.rebuildFlag = false;
+        this.isGenerating = false;
       } else {
         this.$message.success('生成' + this.generateCount + '道题目成功');
       }
@@ -492,138 +512,153 @@ export default {
       });
     },
 
-    reSend() {
-      this.loading && this.loading.close()
-      this.loading = this.$loading({
-        target: '.el-dialog',
-        text: 'AI生成中...'
+    // 重新生成失败的题目 - 需要指定具体的题型和难度
+    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 isDuplicate = this.checkDuplicateQuestion(newQuestion, questionType);
+            
+            if (isDuplicate) {
+              // 重复题目，重新生成
+              const repetitionQuestions = this.getGeneratedQuestionsByType(questionType);
+              this.regenerateWithRepetition(obj, repetitionQuestions, questionType);
+              return;
+            }
+            
+            // 验证返回的题目类型是否正确
+            if (newQuestion.type && newQuestion.type !== questionType) {
+              console.log(`期望题型: ${questionType}, 实际题型: ${newQuestion.type}, 重新生成`);
+              this.generateSingleQuestion(questionType, difficulty);
+              return;
+            }
+            
             if (this.aiResponse.questions && this.aiResponse.questions.length > 0) {
-              this.aiResponse.questions.push(res.data.questions[0]);
+              this.aiResponse.questions.push(newQuestion);
             } else {
               this.aiResponse = res.data;
             }
-            this.$set(res.data.questions[0], 'evaluate', 0)
+            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.loading && this.loading.close()
+          this.isGenerating = false;
           this.$message.warning('题目获取失败')
           this.rebuildFlag = false;
         }
       }).catch(error => {
         console.log("error:" + error);
-        this.loading && this.loading.close()
+        this.isGenerating = false;
         this.$message.warning('题目获取失败')
         this.rebuildFlag = false;
       })
     },
 
-    //发送请求
-    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.loading && this.loading.close()
-      this.loading = this.$loading({
-        target: '.el-dialog',
-        text: 'AI生成中...'
-      });
-
-      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) {
-              this.loading && this.loading.close()
-              if (res.data && res.data.questions && res.data.questions.length > 0) {
-                if (this.aiResponse.questions && this.aiResponse.questions.length > 0) {
-                  this.aiResponse.questions.push(res.data.questions[0]);
-                } else {
-                  this.aiResponse = res.data;
-                }
-                this.$set(res.data.questions[0], 'evaluate', 0)
-                // 设置题目类型，便于后续统计
-                this.$set(res.data.questions[0], 'type', type)
-                this.showGenerateResult();
-              } else {
-                this.$message.warning('题目获取失败,重新生成中...')
-                return this.reSend()
-              }
-            } else {
-              this.loading && this.loading.close()
-              this.$message.warning('题目获取失败')
-              this.rebuildFlag = false;
-            }
-          }).catch(error => {
-            console.log("error:" + error);
-            this.loading && this.loading.close()
-            this.$message.warning('题目获取失败')
-            this.rebuildFlag = false;
-          })
-        }
-      });
-    },
-
     //获取知识点名称
     getKnowledgeName(e, array) {
       array.forEach(item => {
@@ -749,6 +784,149 @@ export default {
       // 清空选中状态
       this.selectedQuestions = [];
     },
+
+    // 检查题目是否重复
+    checkDuplicateQuestion(newQuestion, questionType) {
+      if (!this.aiResponse.questions || this.aiResponse.questions.length === 0) {
+        return false;
+      }
+      return this.aiResponse.questions.some(existingQuestion => {
+        return existingQuestion.title === newQuestion.title && 
+               existingQuestion.type === questionType;
+      });
+    },
+
+    // 获取指定题型的已生成题目信息
+    getGeneratedQuestionsByType(questionType) {
+      if (!this.aiResponse.questions || this.aiResponse.questions.length === 0) {
+        return [];
+      }
+      return this.aiResponse.questions
+        .filter(question => question.type === questionType)
+        .map(question => ({
+          title: question.title,
+          type: question.type
+        }));
+    },
+
+    // 重复题目信息重新生成
+    regenerateWithRepetition(originalObj, repetitionQuestions, questionType, retryCount = 0) {
+      console.log('检测到重复题目，重新生成，已生成题目:', repetitionQuestions, '重试次数:', retryCount);
+      
+      // 如果重试次数超过3次，跳过此题目
+      if (retryCount >= 3) {
+        console.log('重试次数超过3次，跳过此题目');
+        this.isGenerating = false;
+        this.$message.warning('AI生成重复题目超过3次，已跳过该题目');
+        return;
+      }
+      
+      const newObj = {
+        ...originalObj,
+        repetitionQuestions: repetitionQuestions // 传递所有已生成的题目信息
+      };
+      
+      getAiQuestion(newObj).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 isStillDuplicate = this.checkDuplicateQuestion(newQuestion, questionType);
+            
+            if (isStillDuplicate) {
+              console.log('重新生成后仍有重复，继续重试，当前重试次数:', retryCount + 1);
+              // 递归调用，增加重试次数，重新获取最新的当前题型已生成题目列表
+              const updatedRepetitionQuestions = this.getGeneratedQuestionsByType(questionType);
+              this.regenerateWithRepetition(originalObj, updatedRepetitionQuestions, questionType, retryCount + 1);
+              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', questionType)
+            
+            // 更新该题型的生成计数
+            if (!this.typeGeneratedCounts[questionType]) {
+              this.typeGeneratedCounts[questionType] = 0;
+            }
+            this.typeGeneratedCounts[questionType]++;
+            
+            this.showGenerateResult();
+          } else {
+            this.$message.warning('重新生成题目失败')
+          }
+        } else {
+          this.$message.warning('重新生成题目失败')
+        }
+      }).catch(error => {
+        console.log("重新生成题目错误:" + error);
+        this.$message.warning('重新生成题目失败')
+      });
+    },
+
+    // 重新生成的重复检测重新生成
+    regenerateWithRepetitionForReSend(originalObj, repetitionQuestions, questionType, retryCount = 0) {
+      console.log('reSend检测到重复题目，重新生成，已生成题目:', repetitionQuestions, '重试次数:', retryCount);
+      // 如果重试次数超过3次，跳过此题目
+      if (retryCount >= 3) {
+        console.log('reSend重试次数超过3次，跳过此题目');
+        this.isGenerating = false;
+        this.$message.warning('AI生成重复题目超过3次，已跳过该题目');
+        return;
+      }
+      const newObj = {
+        ...originalObj,
+        repetitionQuestions: repetitionQuestions
+      };
+
+      getAiQuestion(newObj).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 isStillDuplicate = this.checkDuplicateQuestion(newQuestion, questionType);
+            
+            if (isStillDuplicate) {
+              console.log('reSend重新生成后仍有重复，继续重试，当前重试次数:', retryCount + 1);
+              // 递归调用，增加重试次数，重新获取最新的当前题型已生成题目列表
+              const updatedRepetitionQuestions = this.getGeneratedQuestionsByType(questionType);
+              this.regenerateWithRepetitionForReSend(originalObj, updatedRepetitionQuestions, questionType, retryCount + 1);
+              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', questionType)
+            this.showGenerateResult();
+          } else {
+            this.$message.warning('重新生成题目失败,重新生成中...')
+            return this.reSend()
+          }
+        } else {
+          this.loading && this.loading.close()
+          this.$message.warning('重新生成题目失败')
+          this.rebuildFlag = false;
+        }
+      }).catch(error => {
+        console.log("reSend重新生成题目错误:" + error);
+        this.loading && this.loading.close()
+        this.$message.warning('重新生成题目失败')
+        this.rebuildFlag = false;
+      });
+    },
   }
 }
 </script>
@@ -759,7 +937,7 @@ export default {
 
   ::v-deep {
     .el-drawer.rtl {
-      border-radius: 15px 0 0 15px;
+      border-radius: 20px;
       width: 720px !important;
     }
 
@@ -775,6 +953,7 @@ export default {
       background: linear-gradient(to bottom, rgba(255, 255, 255, 0), white),
       linear-gradient(to right, #BCB9F4, #D5C6F8, #E6C6F9);
       margin-bottom: 0;
+      border-radius: 20px;
     }
 
     .el-drawer__body {
@@ -824,7 +1003,7 @@ export default {
 
     .el-input__inner {
       border-radius: 12px;
-      height: 48px;
+      height: 48px !important;
       border: 1px solid #E0E0E0;
     }
 
@@ -946,10 +1125,11 @@ export default {
             margin-left: 20px;
 
             ::v-deep .el-input__inner {
-              height: 42px;
+              height: 42px !important;
               border-radius: 56px;
               text-align: center;
               font-size: 12px;
+              padding: 0 !important;
             }
           }
 
@@ -1135,6 +1315,41 @@ export default {
       flex-direction: column;
     }
 
+    // 内部loading样式
+    .generating-loading {
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      height: 200px;
+      
+      .loading-content {
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        gap: 16px;
+        
+        .loading-spinner {
+          width: 40px;
+          height: 40px;
+          border: 4px solid #f3f3f3;
+          border-top: 4px solid #7C4DFF;
+          border-radius: 50%;
+          animation: spin 1s linear infinite;
+        }
+        
+        .loading-text {
+          font-size: 14px;
+          color: #7C4DFF;
+          font-weight: 500;
+        }
+      }
+    }
+
+    @keyframes spin {
+      0% { transform: rotate(0deg); }
+      100% { transform: rotate(360deg); }
+    }
+
     .drawer_content_wrapper {
       display: flex;
       flex-direction: column;

package/components/demo/src/questionItem.vue

@@ -13,14 +13,14 @@
                 <span class="difficult">{{ difficultyList.find(item => item.id == detail.difficulty).name }}</span>
                 <span>{{ detail.title }}</span>
             </span>
-            <span class="question_contain_title_reght">
-                <img src="../static/zan_plain.png" v-if="detail.evaluate == 0 || detail.evaluate == 2"
-                    @click="agree(1)">
-                <img src="../static/zan_bg.png" v-if="detail.evaluate == 1">
-                <img src="../static/unzan_plain.png" v-if="detail.evaluate == 0 || detail.evaluate == 1"
-                    @click="agree(2)">
-                <img src="../static/unzan_bg.png" v-if="detail.evaluate == 2">
-            </span>
+<!--            <span class="question_contain_title_reght">-->
+<!--                <img src="../static/zan_plain.png" v-if="detail.evaluate == 0 || detail.evaluate == 2"-->
+<!--                    @click="agree(1)">-->
+<!--                <img src="../static/zan_bg.png" v-if="detail.evaluate == 1">-->
+<!--                <img src="../static/unzan_plain.png" v-if="detail.evaluate == 0 || detail.evaluate == 1"-->
+<!--                    @click="agree(2)">-->
+<!--                <img src="../static/unzan_bg.png" v-if="detail.evaluate == 2">-->
+<!--            </span>-->
         </div>
         <div class="question_contain_question" v-if="detail.type == 'single' || detail.type == 'multiple' ">
             <div v-for="item, idx in detail.options" :key="idx">