校验任务请求是否补题

src/main/java/com/project/interaction/controller/InteractionController.java

@@ -11,6 +11,8 @@ import com.project.task.application.TaskApplicationService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.*;
 
+import java.util.List;
+
 @RestController
 @RequestMapping("/api/interaction")
 public class InteractionController {
@@ -43,9 +45,9 @@ public class InteractionController {
     /**
      * 判断任务是否删除
      */
-    @GetMapping("/isDeletedTask")
+    @PostMapping("/isDeletedTask")
-    public Result<Boolean> isDeletedTask(Long taskId){
+    public Result<Boolean> isDeletedTask(Long taskId,@RequestParam("taskKpIds") List<Long> taskKpIds){
-        return taskApplicationService.selectById(taskId);
+        return taskApplicationService.isDeletedTask(taskId,taskKpIds);
     }
 
     /**

src/main/java/com/project/question/domain/service/QuestionInventoryDomainService.java

@@ -1,9 +1,15 @@
 package com.project.question.domain.service;
 
 import com.project.base.domain.result.Result;
+import com.project.question.domain.entity.TaskKnowledgeClusterEntity;
+import com.project.task.domain.entity.TaskEntity;
 
 public interface QuestionInventoryDomainService {
     void checkAndReplenish(Long taskId) throws Exception;
 
     Result<String> checkAndReplenishBoolean(Long taskId);
+
+    Boolean checkKp(TaskEntity task, Long kpId);
+
+    Boolean checkCluster(TaskEntity task, TaskKnowledgeClusterEntity cluster);
 }

src/main/java/com/project/question/domain/service/impl/QuestionInventoryDomainServiceImpl.java

@@ -1,6 +1,5 @@
 package com.project.question.domain.service.impl;
 
-import cn.hutool.core.util.StrUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.project.base.domain.result.Result;
 import com.project.question.domain.entity.TaskKnowledgeClusterEntity;
@@ -18,7 +17,6 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
-import java.util.Collections;
 import java.util.Date;
 import java.util.List;
 
@@ -46,14 +44,8 @@ public class QuestionInventoryDomainServiceImpl implements QuestionInventoryDoma
         if (task == null || task.getEndTime().before(new Date())) {
             return;
         }
-        int u = (task.getParticipantNum() == null ? 0 : task.getParticipantNum())
+        int watermark = getWatermark(task);
-                - (task.getPassNum() == null ? 0 : task.getPassNum());
+        int targetLine = (int) Math.ceil(1.2 * getUnpassedCount(task));
-        if (u <= 0) {
-            return;
-        }
-        int watermark = (int) Math.ceil(1.0 * u);
-        int targetLine = (int) Math.ceil(1.2 * u);
-        // 针对每个知识点遍历每种题型
         List<TaskKnowledgePointEntity> kpList = taskKpMapper.selectList(
                 new LambdaQueryWrapper<TaskKnowledgePointEntity>().eq(TaskKnowledgePointEntity::getTaskId , taskId));
         for (TaskKnowledgePointEntity kp : kpList) {
@@ -85,59 +77,33 @@ public class QuestionInventoryDomainServiceImpl implements QuestionInventoryDoma
 
     @Override
     public Result<String> checkAndReplenishBoolean(Long taskId) {
-        //标记是否生成完成
-        Boolean flage = true;
-
         TaskEntity task = taskMapper.selectById(taskId);
         if (task == null || task.getEndTime().before(new Date())) {
             return Result.success("题目生成完成");
         }
-        int u = (task.getParticipantNum() == null ? 0 : task.getParticipantNum())
+        int unpassed = getUnpassedCount(task);
-                - (task.getPassNum() == null ? 0 : task.getPassNum());
+        if (unpassed <= 0) {
-        if (u <= 0) {
             return Result.success("题目生成完成");
         }
-        int watermark = (int) Math.ceil(1.0 * u);
-        int targetLine = (int) Math.ceil(1.2 * u);
-        // 针对每个知识点遍历每种题型
         List<TaskKnowledgePointEntity> kpList = taskKpMapper.selectList(
                 new LambdaQueryWrapper<TaskKnowledgePointEntity>().eq(TaskKnowledgePointEntity::getTaskId , taskId));
         for (TaskKnowledgePointEntity kp : kpList) {
-            for (QuestionTypeEnum questionType : QuestionTypeEnum.values()) {
+            if(!checkKp(task,kp.getId())){
-                if (QuestionTypeEnum.MULTIPLE_CHOICE.equals(questionType)) {
+                return Result.success("题目未生成完成");
-                    continue;
-                }
-                int currentStock = questionKpMapper.countAvailableByKp(kp.getId(), questionType.getValue());
-                if (currentStock < watermark){
-                    flage = false;
-                    break;
-                }
             }
         }
         // 针对每一个簇
         List<TaskKnowledgeClusterEntity> clusterList = clusterMapper.selectList(
                 new LambdaQueryWrapper<TaskKnowledgeClusterEntity>().eq(TaskKnowledgeClusterEntity::getTaskId, taskId));
-
         for (TaskKnowledgeClusterEntity cluster : clusterList) {
             if (cluster.getClusterSize() < 2) {
                 continue;
             }
-            int w = cluster.getClusterSize();
+            if (!checkCluster(task, cluster)) {
-            // 簇水位线: 1.0 * U * W
+                return Result.success("题目未生成完成");
-            int clusterWatermark = watermark * w;
-
-            int currentStock = questionKpMapper.countAvailableByCluster(cluster.getId());
-            if (currentStock < clusterWatermark){
-                flage = false;
-                break;
             }
         }
-
-        if (flage){
         return Result.success("题目生成完成");
-        }else{
-            return Result.success("题目未生成完成");
-        }
     }
 
     /**
@@ -168,4 +134,56 @@ public class QuestionInventoryDomainServiceImpl implements QuestionInventoryDoma
         }
     }
 
+    /**
+     * 校验知识点是否库存充足
+     */
+    private boolean checkKpInventory(Long kpId, QuestionTypeEnum type, int watermark) {
+        int currentStock = questionKpMapper.countAvailableByKp(kpId, type.getValue());
+        return currentStock >= watermark;
+    }
+
+    /**
+     * 校验知识点簇是否库存充足
+     */
+    private boolean checkClusterInventory(Long clusterId, int clusterWatermark) {
+        int currentStock = questionKpMapper.countAvailableByCluster(clusterId);
+        return currentStock >= clusterWatermark;
+    }
+
+    /**
+     * 计算未通过人数
+     */
+    private int getUnpassedCount(TaskEntity task) {
+        return (task.getParticipantNum() == null ? 0 : task.getParticipantNum())
+                - (task.getPassNum() == null ? 0 : task.getPassNum());
+    }
+
+    /**
+     * 计算水位线 (watermark = ceil(1.0 * u))
+     */
+    private int getWatermark(TaskEntity task) {
+        return (int) Math.ceil(1.0 * getUnpassedCount(task));
+    }
+
+    @Override
+    public Boolean checkKp(TaskEntity task, Long kpId){
+        int watermark = getWatermark(task);
+        for (QuestionTypeEnum questionType : QuestionTypeEnum.values()) {
+            if (QuestionTypeEnum.MULTIPLE_CHOICE.equals(questionType)) {
+                continue;
+            }
+            if (!checkKpInventory(kpId, questionType, watermark)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public Boolean checkCluster(TaskEntity task, TaskKnowledgeClusterEntity cluster) {
+        int watermark = getWatermark(task);
+        int clusterWatermark = watermark * cluster.getClusterSize();
+        return checkClusterInventory(cluster.getId(), clusterWatermark);
+    }
+
 }

src/main/java/com/project/question/mapper/TaskKnowledgeClusterMapper.java

@@ -3,8 +3,14 @@ package com.project.question.mapper;
 import com.project.question.domain.entity.TaskKnowledgeClusterEntity;
 import org.apache.ibatis.annotations.Mapper;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
 
 
 @Mapper
 public interface TaskKnowledgeClusterMapper extends BaseMapper<TaskKnowledgeClusterEntity>{
+    @Select(" select c.* from evaluator_task_knowledge_cluster c " +
+            " inner join evaluator_task_knowledge_point p on p.cluster_id = c.id " +
+            " where p.id = #{id} and c.deleted = 0 ")
+    TaskKnowledgeClusterEntity getByIdWithCluster(@Param("id") Long id);
 }

src/main/java/com/project/task/application/TaskApplicationService.java

@@ -22,5 +22,5 @@ public interface TaskApplicationService {
 
     Result<TaskDTO> getCandidateDetail(Long id) throws Exception;
 
-    Result<Boolean> selectById(Long taskId);
+    Result<Boolean> isDeletedTask(Long taskId, List<Long> taskKpIds);
 }

src/main/java/com/project/task/application/impl/TaskApplicationServiceImpl.java

@@ -1,12 +1,17 @@
 package com.project.task.application.impl;
 
+import com.project.base.domain.exception.MissingParameterException;
 import com.project.base.domain.result.PageResult;
 import com.project.base.domain.result.Result;
+import com.project.question.domain.entity.TaskKnowledgeClusterEntity;
+import com.project.question.domain.service.QuestionInventoryDomainService;
+import com.project.question.mapper.TaskKnowledgeClusterMapper;
 import com.project.task.application.TaskApplicationService;
 import com.project.task.domain.dto.TaskDTO;
 import com.project.task.domain.entity.TaskEntity;
 import com.project.task.domain.param.TaskParam;
 import com.project.task.domain.service.*;
+import org.apache.commons.collections4.CollectionUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
@@ -30,6 +35,12 @@ public class TaskApplicationServiceImpl implements TaskApplicationService {
     @Autowired
     private CandidateSearchTaskDomainService candidateSearchTaskDomainService;
 
+    @Autowired
+    private QuestionInventoryDomainService questionInventoryDomainService;
+
+    @Autowired
+    private TaskKnowledgeClusterMapper taskKnowledgeClusterMapper;
+
     @Override
     public Result<TaskDTO> saveOrUpdate(TaskDTO dto) throws Exception {
         return saveOrUpdateTaskDomainService.saveOrUpdate(dto);
@@ -62,13 +73,33 @@ public class TaskApplicationServiceImpl implements TaskApplicationService {
     }
 
     @Override
-    public Result<Boolean> selectById(Long taskId) {
+    public Result<Boolean> isDeletedTask(Long taskId, List<Long> taskKpIds) {
+        if (taskKpIds == null || CollectionUtils.isEmpty(taskKpIds)) {
+            throw new MissingParameterException("参数不完整");
+        }
+        //判断任务是否删除
         TaskEntity taskEntity = taskBaseService.getById(taskId);
         if (taskEntity == null) {
             return Result.success(false);
         }
+
+        //校验知识点是否库存不足
+        if (taskKpIds.size() == 1) {
+            if(!questionInventoryDomainService.checkKp(taskEntity, taskKpIds.get(0))){
+                return Result.success(true);
+            }
+        }else{
+            //校验知识点簇是否库存不足
+            TaskKnowledgeClusterEntity cluster = taskKnowledgeClusterMapper.getByIdWithCluster(taskKpIds.get(0));
+            if (cluster == null){
+                throw new MissingParameterException("知识点不存在");
+            }
+            if(!questionInventoryDomainService.checkCluster(taskEntity,cluster)){
                 return Result.success(true);
             }
+        }
+        return Result.success(false);
+    }
 
     @Override
     public List<TaskDTO> selectBatchIds(List<Long> taskIdList) {